content/browser/compositor/gpu_process_transport_factory.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/browser/compositor/gpu_process_transport_factory.h"
   6
   7 #include <string>
   8
   9 #include "base/bind.h"
  10 #include "base/command_line.h"
  11 #include "base/location.h"
  12 #include "base/message_loop/message_loop.h"
  13 #include "base/metrics/histogram.h"
  14 #include "base/profiler/scoped_tracker.h"
  15 #include "base/threading/simple_thread.h"
  16 #include "base/threading/thread.h"
  17 #include "cc/output/compositor_frame.h"
  18 #include "cc/output/output_surface.h"
  19 #include "cc/resources/task_graph_runner.h"
  20 #include "cc/surfaces/onscreen_display_client.h"
  21 #include "cc/surfaces/surface_display_output_surface.h"
  22 #include "cc/surfaces/surface_manager.h"
  23 #include "content/browser/compositor/browser_compositor_output_surface.h"
  24 #include "content/browser/compositor/gpu_browser_compositor_output_surface.h"
  25 #include "content/browser/compositor/gpu_surfaceless_browser_compositor_output_surface.h"
  26 #include "content/browser/compositor/reflector_impl.h"
  27 #include "content/browser/compositor/software_browser_compositor_output_surface.h"
  28 #include "content/browser/gpu/browser_gpu_channel_host_factory.h"
  29 #include "content/browser/gpu/browser_gpu_memory_buffer_manager.h"
  30 #include "content/browser/gpu/compositor_util.h"
  31 #include "content/browser/gpu/gpu_data_manager_impl.h"
  32 #include "content/browser/gpu/gpu_surface_tracker.h"
  33 #include "content/browser/renderer_host/render_widget_host_impl.h"
  34 #include "content/common/gpu/client/context_provider_command_buffer.h"
  35 #include "content/common/gpu/client/gl_helper.h"
  36 #include "content/common/gpu/client/gpu_channel_host.h"
  37 #include "content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.h"
  38 #include "content/common/gpu/gpu_process_launch_causes.h"
  39 #include "content/common/host_shared_bitmap_manager.h"
  40 #include "content/public/common/content_switches.h"
  41 #include "gpu/GLES2/gl2extchromium.h"
  42 #include "gpu/command_buffer/client/gles2_interface.h"
  43 #include "gpu/command_buffer/common/mailbox.h"
  44 #include "third_party/khronos/GLES2/gl2.h"
  45 #include "ui/compositor/compositor.h"
  46 #include "ui/compositor/compositor_constants.h"
  47 #include "ui/compositor/compositor_switches.h"
  48 #include "ui/gfx/geometry/size.h"
  49 #include "ui/gfx/native_widget_types.h"
  50
  51 #if defined(OS_WIN)
  52 #include "content/browser/compositor/software_output_device_win.h"
  53 #elif defined(USE_OZONE)
  54 #include "content/browser/compositor/overlay_candidate_validator_ozone.h"
  55 #include "content/browser/compositor/software_output_device_ozone.h"
  56 #include "ui/ozone/public/ozone_switches.h"
  57 #include "ui/ozone/public/surface_factory_ozone.h"
  58 #elif defined(USE_X11)
  59 #include "content/browser/compositor/software_output_device_x11.h"
  60 #elif defined(OS_MACOSX)
  61 #include "content/browser/compositor/software_output_device_mac.h"
  62 #endif
  63
  64 using cc::ContextProvider;
  65 using gpu::gles2::GLES2Interface;
  66
  67 static const int kNumRetriesBeforeSoftwareFallback = 4;
  68
  69 namespace content {
  70 namespace {
  71
  72 class RasterThread : public base::SimpleThread {
  73  public:
  74   RasterThread(cc::TaskGraphRunner* task_graph_runner)
  75       : base::SimpleThread("CompositorTileWorker1"),
  76         task_graph_runner_(task_graph_runner) {}
  77
  78   // Overridden from base::SimpleThread:
  79   void Run() override { task_graph_runner_->Run(); }
  80
  81  private:
  82   cc::TaskGraphRunner* task_graph_runner_;
  83
  84   DISALLOW_COPY_AND_ASSIGN(RasterThread);
  85 };
  86
  87 }  // namespace
  88
  89 struct GpuProcessTransportFactory::PerCompositorData {
  90   int surface_id;
  91   BrowserCompositorOutputSurface* surface;
  92   ReflectorImpl* reflector;
  93   scoped_ptr<cc::OnscreenDisplayClient> display_client;
  94
  95   PerCompositorData() : surface_id(0), surface(nullptr), reflector(nullptr) {}
  96 };
  97
  98 GpuProcessTransportFactory::GpuProcessTransportFactory()
  99     : next_surface_id_namespace_(1u),
 100       task_graph_runner_(new cc::TaskGraphRunner),
 101       callback_factory_(this) {
 102   if (UseSurfacesEnabled())
 103     surface_manager_ = make_scoped_ptr(new cc::SurfaceManager);
 104
 105   if (ui::IsUIImplSidePaintingEnabled()) {
 106     raster_thread_.reset(new RasterThread(task_graph_runner_.get()));
 107     raster_thread_->Start();
 108   }
 109 }
 110
 111 GpuProcessTransportFactory::~GpuProcessTransportFactory() {
 112   DCHECK(per_compositor_data_.empty());
 113
 114   // Make sure the lost context callback doesn't try to run during destruction.
 115   callback_factory_.InvalidateWeakPtrs();
 116
 117   task_graph_runner_->Shutdown();
 118   if (raster_thread_)
 119     raster_thread_->Join();
 120 }
 121
 122 scoped_ptr<WebGraphicsContext3DCommandBufferImpl>
 123 GpuProcessTransportFactory::CreateOffscreenCommandBufferContext() {
 124   CauseForGpuLaunch cause =
 125       CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE;
 126   scoped_refptr<GpuChannelHost> gpu_channel_host(
 127       BrowserGpuChannelHostFactory::instance()->EstablishGpuChannelSync(cause));
 128   return CreateContextCommon(gpu_channel_host, 0);
 129 }
 130
 131 scoped_ptr<cc::SoftwareOutputDevice> CreateSoftwareOutputDevice(
 132     ui::Compositor* compositor) {
 133 #if defined(OS_WIN)
 134   return scoped_ptr<cc::SoftwareOutputDevice>(new SoftwareOutputDeviceWin(
 135       compositor));
 136 #elif defined(USE_OZONE)
 137   return scoped_ptr<cc::SoftwareOutputDevice>(new SoftwareOutputDeviceOzone(
 138       compositor));
 139 #elif defined(USE_X11)
 140   return scoped_ptr<cc::SoftwareOutputDevice>(new SoftwareOutputDeviceX11(
 141       compositor));
 142 #elif defined(OS_MACOSX)
 143   return scoped_ptr<cc::SoftwareOutputDevice>(
 144       new SoftwareOutputDeviceMac(compositor));
 145 #else
 146   NOTREACHED();
 147   return scoped_ptr<cc::SoftwareOutputDevice>();
 148 #endif
 149 }
 150
 151 scoped_ptr<cc::OverlayCandidateValidator> CreateOverlayCandidateValidator(
 152     gfx::AcceleratedWidget widget) {
 153 #if defined(USE_OZONE)
 154   ui::OverlayCandidatesOzone* overlay_candidates =
 155       ui::SurfaceFactoryOzone::GetInstance()->GetOverlayCandidates(widget);
 156   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
 157   if (overlay_candidates &&
 158       (command_line->HasSwitch(switches::kEnableHardwareOverlays) ||
 159        command_line->HasSwitch(switches::kOzoneTestSingleOverlaySupport))) {
 160     return scoped_ptr<cc::OverlayCandidateValidator>(
 161         new OverlayCandidateValidatorOzone(widget, overlay_candidates));
 162   }
 163 #endif
 164   return scoped_ptr<cc::OverlayCandidateValidator>();
 165 }
 166
 167 static bool ShouldCreateGpuOutputSurface(ui::Compositor* compositor) {
 168 #if defined(OS_CHROMEOS)
 169   // Software fallback does not happen on Chrome OS.
 170   return true;
 171 #endif
 172
 173 #if defined(OS_WIN)
 174   if (::GetProp(compositor->widget(), kForceSoftwareCompositor) &&
 175       ::RemoveProp(compositor->widget(), kForceSoftwareCompositor))
 176     return false;
 177 #endif
 178
 179   return GpuDataManagerImpl::GetInstance()->CanUseGpuBrowserCompositor();
 180 }
 181
 182 void GpuProcessTransportFactory::CreateOutputSurface(
 183     base::WeakPtr<ui::Compositor> compositor) {
 184   DCHECK(!!compositor);
 185   PerCompositorData* data = per_compositor_data_[compositor.get()];
 186   if (!data) {
 187     // TODO(robliao): Remove ScopedTracker below once https://crbug.com/466870
 188     // is fixed.
 189     tracked_objects::ScopedTracker tracking_profile1(
 190         FROM_HERE_WITH_EXPLICIT_FUNCTION(
 191             "466870 GpuProcessTransportFactory::CreateOutputSurface1"));
 192     data = CreatePerCompositorData(compositor.get());
 193   } else {
 194     // TODO(piman): Use GpuSurfaceTracker to map ids to surfaces instead of an
 195     // output_surface_map_ here.
 196     output_surface_map_.Remove(data->surface_id);
 197     data->surface = nullptr;
 198   }
 199
 200   // TODO(robliao): Remove ScopedTracker below once https://crbug.com/466870
 201   // is fixed.
 202   tracked_objects::ScopedTracker tracking_profile2(
 203       FROM_HERE_WITH_EXPLICIT_FUNCTION(
 204           "466870 GpuProcessTransportFactory::CreateOutputSurface2"));
 205
 206   bool create_gpu_output_surface =
 207       ShouldCreateGpuOutputSurface(compositor.get());
 208   if (create_gpu_output_surface) {
 209     // TODO(robliao): Remove ScopedTracker below once https://crbug.com/466870
 210     // is fixed.
 211     tracked_objects::ScopedTracker tracking_profile3(
 212         FROM_HERE_WITH_EXPLICIT_FUNCTION(
 213             "466870 GpuProcessTransportFactory::CreateOutputSurface3"));
 214
 215     CauseForGpuLaunch cause =
 216         CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE;
 217     BrowserGpuChannelHostFactory::instance()->EstablishGpuChannel(
 218         cause, base::Bind(&GpuProcessTransportFactory::EstablishedGpuChannel,
 219                           callback_factory_.GetWeakPtr(), compositor,
 220                           create_gpu_output_surface, 0));
 221   } else {
 222     // TODO(robliao): Remove ScopedTracker below once https://crbug.com/466870
 223     // is fixed.
 224     tracked_objects::ScopedTracker tracking_profile4(
 225         FROM_HERE_WITH_EXPLICIT_FUNCTION(
 226             "466870 GpuProcessTransportFactory::CreateOutputSurface4"));
 227
 228     EstablishedGpuChannel(compositor, create_gpu_output_surface, 0);
 229   }
 230 }
 231
 232 void GpuProcessTransportFactory::EstablishedGpuChannel(
 233     base::WeakPtr<ui::Compositor> compositor,
 234     bool create_gpu_output_surface,
 235     int num_attempts) {
 236   if (!compositor)
 237     return;
 238   PerCompositorData* data = per_compositor_data_[compositor.get()];
 239   DCHECK(data);
 240
 241   if (num_attempts > kNumRetriesBeforeSoftwareFallback) {
 242 #if defined(OS_CHROMEOS)
 243     LOG(FATAL) << "Unable to create a UI graphics context, and cannot use "
 244                << "software compositing on ChromeOS.";
 245 #endif
 246     create_gpu_output_surface = false;
 247   }
 248
 249   scoped_refptr<ContextProviderCommandBuffer> context_provider;
 250   if (create_gpu_output_surface) {
 251     scoped_refptr<GpuChannelHost> gpu_channel_host =
 252         BrowserGpuChannelHostFactory::instance()->GetGpuChannel();
 253     if (gpu_channel_host.get()) {
 254       context_provider = ContextProviderCommandBuffer::Create(
 255           GpuProcessTransportFactory::CreateContextCommon(gpu_channel_host,
 256                                                           data->surface_id),
 257           "Compositor");
 258       if (context_provider && !context_provider->BindToCurrentThread())
 259         context_provider = nullptr;
 260     }
 261
 262     UMA_HISTOGRAM_BOOLEAN("Aura.CreatedGpuBrowserCompositor",
 263                           !!context_provider.get());
 264
 265     if (!context_provider) {
 266       // Try again.
 267       CauseForGpuLaunch cause =
 268           CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE;
 269       BrowserGpuChannelHostFactory::instance()->EstablishGpuChannel(
 270           cause, base::Bind(&GpuProcessTransportFactory::EstablishedGpuChannel,
 271                             callback_factory_.GetWeakPtr(), compositor,
 272                             create_gpu_output_surface, num_attempts + 1));
 273       return;
 274     }
 275   }
 276
 277   scoped_ptr<BrowserCompositorOutputSurface> surface;
 278   if (!create_gpu_output_surface) {
 279     surface = make_scoped_ptr(new SoftwareBrowserCompositorOutputSurface(
 280         CreateSoftwareOutputDevice(compositor.get()),
 281         compositor->vsync_manager()));
 282   } else {
 283     DCHECK(context_provider);
 284 #if defined(USE_OZONE)
 285     if (ui::SurfaceFactoryOzone::GetInstance()
 286             ->CanShowPrimaryPlaneAsOverlay()) {
 287       surface =
 288           make_scoped_ptr(new GpuSurfacelessBrowserCompositorOutputSurface(
 289               context_provider, data->surface_id, compositor->vsync_manager(),
 290               CreateOverlayCandidateValidator(compositor->widget()), GL_RGB,
 291               BrowserGpuMemoryBufferManager::current()));
 292     } else
 293 #endif
 294     {
 295       surface = make_scoped_ptr(new GpuBrowserCompositorOutputSurface(
 296           context_provider, compositor->vsync_manager(),
 297           CreateOverlayCandidateValidator(compositor->widget())));
 298     }
 299   }
 300
 301   // TODO(piman): Use GpuSurfaceTracker to map ids to surfaces instead of an
 302   // output_surface_map_ here.
 303   output_surface_map_.AddWithID(surface.get(), data->surface_id);
 304   data->surface = surface.get();
 305   if (data->reflector)
 306     data->reflector->OnSourceSurfaceReady(data->surface);
 307
 308   if (!UseSurfacesEnabled()) {
 309     compositor->SetOutputSurface(surface.Pass());
 310     return;
 311   }
 312
 313   // This gets a bit confusing. Here we have a ContextProvider in the |surface|
 314   // configured to render directly to this widget. We need to make an
 315   // OnscreenDisplayClient associated with that context, then return a
 316   // SurfaceDisplayOutputSurface set up to draw to the display's surface.
 317   cc::SurfaceManager* manager = surface_manager_.get();
 318   scoped_ptr<cc::OnscreenDisplayClient> display_client(
 319       new cc::OnscreenDisplayClient(
 320           surface.Pass(), manager, HostSharedBitmapManager::current(),
 321           BrowserGpuMemoryBufferManager::current(),
 322           compositor->GetRendererSettings(), compositor->task_runner()));
 323
 324   scoped_ptr<cc::SurfaceDisplayOutputSurface> output_surface(
 325       new cc::SurfaceDisplayOutputSurface(
 326           manager, compositor->surface_id_allocator(), context_provider));
 327   display_client->set_surface_output_surface(output_surface.get());
 328   output_surface->set_display_client(display_client.get());
 329   display_client->display()->Resize(compositor->size());
 330   data->display_client = display_client.Pass();
 331   compositor->SetOutputSurface(output_surface.Pass());
 332 }
 333
 334 scoped_ptr<ui::Reflector> GpuProcessTransportFactory::CreateReflector(
 335     ui::Compositor* source_compositor,
 336     ui::Layer* target_layer) {
 337   PerCompositorData* source_data = per_compositor_data_[source_compositor];
 338   DCHECK(source_data);
 339
 340   scoped_ptr<ReflectorImpl> reflector(
 341       new ReflectorImpl(source_compositor, target_layer));
 342   source_data->reflector = reflector.get();
 343   if (BrowserCompositorOutputSurface* source_surface = source_data->surface)
 344     reflector->OnSourceSurfaceReady(source_surface);
 345   return reflector.Pass();
 346 }
 347
 348 void GpuProcessTransportFactory::RemoveReflector(ui::Reflector* reflector) {
 349   ReflectorImpl* reflector_impl = static_cast<ReflectorImpl*>(reflector);
 350   PerCompositorData* data =
 351       per_compositor_data_[reflector_impl->mirrored_compositor()];
 352   DCHECK(data);
 353   data->reflector->Shutdown();
 354   data->reflector = nullptr;
 355 }
 356
 357 void GpuProcessTransportFactory::RemoveCompositor(ui::Compositor* compositor) {
 358   PerCompositorDataMap::iterator it = per_compositor_data_.find(compositor);
 359   if (it == per_compositor_data_.end())
 360     return;
 361   PerCompositorData* data = it->second;
 362   DCHECK(data);
 363   // TODO(piman): Use GpuSurfaceTracker to map ids to surfaces instead of an
 364   // output_surface_map_ here.
 365   if (data->surface)
 366     output_surface_map_.Remove(data->surface_id);
 367   GpuSurfaceTracker::Get()->RemoveSurface(data->surface_id);
 368   delete data;
 369   per_compositor_data_.erase(it);
 370   if (per_compositor_data_.empty()) {
 371     // Destroying the GLHelper may cause some async actions to be cancelled,
 372     // causing things to request a new GLHelper. Due to crbug.com/176091 the
 373     // GLHelper created in this case would be lost/leaked if we just reset()
 374     // on the |gl_helper_| variable directly. So instead we call reset() on a
 375     // local scoped_ptr.
 376     scoped_ptr<GLHelper> helper = gl_helper_.Pass();
 377
 378     // If there are any observer left at this point, make sure they clean up
 379     // before we destroy the GLHelper.
 380     FOR_EACH_OBSERVER(
 381         ImageTransportFactoryObserver, observer_list_, OnLostResources());
 382
 383     helper.reset();
 384     DCHECK(!gl_helper_) << "Destroying the GLHelper should not cause a new "
 385                            "GLHelper to be created.";
 386   }
 387 }
 388
 389 bool GpuProcessTransportFactory::DoesCreateTestContexts() { return false; }
 390
 391 uint32 GpuProcessTransportFactory::GetImageTextureTarget() {
 392   return BrowserGpuChannelHostFactory::GetImageTextureTarget();
 393 }
 394
 395 cc::SharedBitmapManager* GpuProcessTransportFactory::GetSharedBitmapManager() {
 396   return HostSharedBitmapManager::current();
 397 }
 398
 399 gpu::GpuMemoryBufferManager*
 400 GpuProcessTransportFactory::GetGpuMemoryBufferManager() {
 401   return BrowserGpuMemoryBufferManager::current();
 402 }
 403
 404 cc::TaskGraphRunner* GpuProcessTransportFactory::GetTaskGraphRunner() {
 405   return task_graph_runner_.get();
 406 }
 407
 408 ui::ContextFactory* GpuProcessTransportFactory::GetContextFactory() {
 409   return this;
 410 }
 411
 412 gfx::GLSurfaceHandle GpuProcessTransportFactory::GetSharedSurfaceHandle() {
 413   gfx::GLSurfaceHandle handle = gfx::GLSurfaceHandle(
 414       gfx::kNullPluginWindow, gfx::NULL_TRANSPORT);
 415   handle.parent_client_id =
 416       BrowserGpuChannelHostFactory::instance()->GetGpuChannelId();
 417   return handle;
 418 }
 419
 420 scoped_ptr<cc::SurfaceIdAllocator>
 421 GpuProcessTransportFactory::CreateSurfaceIdAllocator() {
 422   return make_scoped_ptr(
 423       new cc::SurfaceIdAllocator(next_surface_id_namespace_++));
 424 }
 425
 426 void GpuProcessTransportFactory::ResizeDisplay(ui::Compositor* compositor,
 427                                                const gfx::Size& size) {
 428   PerCompositorDataMap::iterator it = per_compositor_data_.find(compositor);
 429   if (it == per_compositor_data_.end())
 430     return;
 431   PerCompositorData* data = it->second;
 432   DCHECK(data);
 433   if (data->display_client)
 434     data->display_client->display()->Resize(size);
 435 }
 436
 437 cc::SurfaceManager* GpuProcessTransportFactory::GetSurfaceManager() {
 438   return surface_manager_.get();
 439 }
 440
 441 GLHelper* GpuProcessTransportFactory::GetGLHelper() {
 442   if (!gl_helper_ && !per_compositor_data_.empty()) {
 443     scoped_refptr<cc::ContextProvider> provider =
 444         SharedMainThreadContextProvider();
 445     if (provider.get())
 446       gl_helper_.reset(new GLHelper(provider->ContextGL(),
 447                                     provider->ContextSupport()));
 448   }
 449   return gl_helper_.get();
 450 }
 451
 452 void GpuProcessTransportFactory::AddObserver(
 453     ImageTransportFactoryObserver* observer) {
 454   observer_list_.AddObserver(observer);
 455 }
 456
 457 void GpuProcessTransportFactory::RemoveObserver(
 458     ImageTransportFactoryObserver* observer) {
 459   observer_list_.RemoveObserver(observer);
 460 }
 461
 462 #if defined(OS_MACOSX)
 463 void GpuProcessTransportFactory::OnSurfaceDisplayed(int surface_id) {
 464   BrowserCompositorOutputSurface* surface = output_surface_map_.Lookup(
 465       surface_id);
 466   if (surface)
 467     surface->OnSurfaceDisplayed();
 468 }
 469
 470 void GpuProcessTransportFactory::OnCompositorRecycled(
 471     ui::Compositor* compositor) {
 472   PerCompositorDataMap::iterator it = per_compositor_data_.find(compositor);
 473   if (it == per_compositor_data_.end())
 474     return;
 475   PerCompositorData* data = it->second;
 476   DCHECK(data);
 477   BrowserCompositorOutputSurface* surface =
 478       output_surface_map_.Lookup(data->surface_id);
 479   if (surface)
 480     surface->OnSurfaceRecycled();
 481 }
 482
 483 bool GpuProcessTransportFactory::SurfaceShouldNotShowFramesAfterRecycle(
 484     int surface_id) const {
 485   BrowserCompositorOutputSurface* surface =
 486       output_surface_map_.Lookup(surface_id);
 487   if (surface)
 488     return surface->ShouldNotShowFramesAfterRecycle();
 489   return false;
 490 }
 491 #endif
 492
 493 scoped_refptr<cc::ContextProvider>
 494 GpuProcessTransportFactory::SharedMainThreadContextProvider() {
 495   if (shared_main_thread_contexts_.get())
 496     return shared_main_thread_contexts_;
 497
 498   // In threaded compositing mode, we have to create our own context for the
 499   // main thread since the compositor's context will be bound to the
 500   // compositor thread. When not in threaded mode, we still need a separate
 501   // context so that skia and gl_helper don't step on each other.
 502   shared_main_thread_contexts_ = ContextProviderCommandBuffer::Create(
 503       GpuProcessTransportFactory::CreateOffscreenCommandBufferContext(),
 504       "Offscreen-MainThread");
 505
 506   if (shared_main_thread_contexts_.get()) {
 507     shared_main_thread_contexts_->SetLostContextCallback(
 508         base::Bind(&GpuProcessTransportFactory::
 509                         OnLostMainThreadSharedContextInsideCallback,
 510                    callback_factory_.GetWeakPtr()));
 511     if (!shared_main_thread_contexts_->BindToCurrentThread())
 512       shared_main_thread_contexts_ = NULL;
 513   }
 514   return shared_main_thread_contexts_;
 515 }
 516
 517 GpuProcessTransportFactory::PerCompositorData*
 518 GpuProcessTransportFactory::CreatePerCompositorData(
 519     ui::Compositor* compositor) {
 520   DCHECK(!per_compositor_data_[compositor]);
 521
 522   gfx::AcceleratedWidget widget = compositor->widget();
 523   GpuSurfaceTracker* tracker = GpuSurfaceTracker::Get();
 524
 525   PerCompositorData* data = new PerCompositorData;
 526   data->surface_id = tracker->AddSurfaceForNativeWidget(widget);
 527   tracker->SetSurfaceHandle(
 528       data->surface_id,
 529       gfx::GLSurfaceHandle(widget, gfx::NATIVE_DIRECT));
 530
 531   per_compositor_data_[compositor] = data;
 532
 533   return data;
 534 }
 535
 536 scoped_ptr<WebGraphicsContext3DCommandBufferImpl>
 537 GpuProcessTransportFactory::CreateContextCommon(
 538     scoped_refptr<GpuChannelHost> gpu_channel_host,
 539     int surface_id) {
 540   if (!GpuDataManagerImpl::GetInstance()->CanUseGpuBrowserCompositor())
 541     return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
 542   blink::WebGraphicsContext3D::Attributes attrs;
 543   attrs.shareResources = true;
 544   attrs.depth = false;
 545   attrs.stencil = false;
 546   attrs.antialias = false;
 547   attrs.noAutomaticFlushes = true;
 548   bool lose_context_when_out_of_memory = true;
 549   if (!gpu_channel_host.get()) {
 550     LOG(ERROR) << "Failed to establish GPU channel.";
 551     return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
 552   }
 553   GURL url("chrome://gpu/GpuProcessTransportFactory::CreateContextCommon");
 554   scoped_ptr<WebGraphicsContext3DCommandBufferImpl> context(
 555       new WebGraphicsContext3DCommandBufferImpl(
 556           surface_id,
 557           url,
 558           gpu_channel_host.get(),
 559           attrs,
 560           lose_context_when_out_of_memory,
 561           WebGraphicsContext3DCommandBufferImpl::SharedMemoryLimits(),
 562           NULL));
 563   return context.Pass();
 564 }
 565
 566 void GpuProcessTransportFactory::OnLostMainThreadSharedContextInsideCallback() {
 567   base::MessageLoop::current()->PostTask(
 568       FROM_HERE,
 569       base::Bind(&GpuProcessTransportFactory::OnLostMainThreadSharedContext,
 570                  callback_factory_.GetWeakPtr()));
 571 }
 572
 573 void GpuProcessTransportFactory::OnLostMainThreadSharedContext() {
 574   LOG(ERROR) << "Lost UI shared context.";
 575
 576   // Keep old resources around while we call the observers, but ensure that
 577   // new resources are created if needed.
 578   // Kill shared contexts for both threads in tandem so they are always in
 579   // the same share group.
 580   scoped_refptr<cc::ContextProvider> lost_shared_main_thread_contexts =
 581       shared_main_thread_contexts_;
 582   shared_main_thread_contexts_  = NULL;
 583
 584   scoped_ptr<GLHelper> lost_gl_helper = gl_helper_.Pass();
 585
 586   FOR_EACH_OBSERVER(ImageTransportFactoryObserver,
 587                     observer_list_,
 588                     OnLostResources());
 589
 590   // Kill things that use the shared context before killing the shared context.
 591   lost_gl_helper.reset();
 592   lost_shared_main_thread_contexts  = NULL;
 593 }
 594
 595 }  // namespace content