Make browser GPU channel creation async.

content/browser/compositor/gpu_process_transport_factory.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/compositor/gpu_process_transport_factory.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 79 matching lines @@
 
 GpuProcessTransportFactory::~GpuProcessTransportFactory() {
   DCHECK(per_compositor_data_.empty());
 
   // Make sure the lost context callback doesn't try to run during destruction.
   callback_factory_.InvalidateWeakPtrs();
 }
 
 scoped_ptr<WebGraphicsContext3DCommandBufferImpl>
 GpuProcessTransportFactory::CreateOffscreenCommandBufferContext() {
-  return CreateContextCommon(0);
+  CauseForGpuLaunch cause =
+      CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE;
+  scoped_refptr<GpuChannelHost> gpu_channel_host(
+      BrowserGpuChannelHostFactory::instance()->EstablishGpuChannelSync(cause));
+  return CreateContextCommon(gpu_channel_host, 0);
 }
 
 scoped_ptr<cc::SoftwareOutputDevice> CreateSoftwareOutputDevice(
     ui::Compositor* compositor) {
 #if defined(OS_WIN)
   return scoped_ptr<cc::SoftwareOutputDevice>(new SoftwareOutputDeviceWin(
       compositor));
 #elif defined(USE_OZONE)
   return scoped_ptr<cc::SoftwareOutputDevice>(new SoftwareOutputDeviceOzone(
       compositor));
@@ skipping 17 matching lines @@
   if (overlay_candidates &&
       base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableHardwareOverlays)) {
     return scoped_ptr<cc::OverlayCandidateValidator>(
         new OverlayCandidateValidatorOzone(widget, overlay_candidates));
   }
 #endif
   return scoped_ptr<cc::OverlayCandidateValidator>();
 }
 
-scoped_ptr<cc::OutputSurface> GpuProcessTransportFactory::CreateOutputSurface(
-    ui::Compositor* compositor, bool software_fallback) {
-  PerCompositorData* data = per_compositor_data_[compositor];
+void GpuProcessTransportFactory::CreateOutputSurface(
+    base::WeakPtr<ui::Compositor> compositor,
+    bool software_fallback) {
+  DCHECK(!!compositor);
+  PerCompositorData* data = per_compositor_data_[compositor.get()];
   if (!data)
-    data = CreatePerCompositorData(compositor);
+    data = CreatePerCompositorData(compositor.get());
 
   bool create_software_renderer = software_fallback;
 #if defined(OS_CHROMEOS)
   // Software fallback does not happen on Chrome OS.
   create_software_renderer = false;
 #elif defined(OS_WIN)
   if (::GetProp(compositor->widget(), kForceSoftwareCompositor)) {
     if (::RemoveProp(compositor->widget(), kForceSoftwareCompositor))
       create_software_renderer = true;
   }
 #endif
-
-  scoped_refptr<ContextProviderCommandBuffer> context_provider;
+  if (!GpuDataManagerImpl::GetInstance()->CanUseGpuBrowserCompositor())
+    create_software_renderer = true;
 
   if (!create_software_renderer) {
+    CauseForGpuLaunch cause =
+        CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE;
+    BrowserGpuChannelHostFactory::instance()->EstablishGpuChannel(
+        cause,
+        base::Bind(&GpuProcessTransportFactory::EstablishedGpuChannel,
+                   callback_factory_.GetWeakPtr(),
+                   compositor,
+                   create_software_renderer));
+  } else {
+    EstablishedGpuChannel(compositor, create_software_renderer);
+  }
+}
+
+void GpuProcessTransportFactory::EstablishedGpuChannel(
+    base::WeakPtr<ui::Compositor> compositor,
+    bool create_software_renderer) {
+  if (!compositor)
+    return;
+  PerCompositorData* data = per_compositor_data_[compositor.get()];
+  DCHECK(data);
+  scoped_refptr<GpuChannelHost> gpu_channel_host =
+      BrowserGpuChannelHostFactory::instance()->GetGpuChannel();
+  scoped_refptr<ContextProviderCommandBuffer> context_provider;
+  if (gpu_channel_host.get() && !create_software_renderer) {
     context_provider = ContextProviderCommandBuffer::Create(
-        GpuProcessTransportFactory::CreateContextCommon(data->surface_id),
+        GpuProcessTransportFactory::CreateContextCommon(gpu_channel_host,
+                                                        data->surface_id),
         "Compositor");
   }
 
   UMA_HISTOGRAM_BOOLEAN("Aura.CreatedGpuBrowserCompositor",
                         !!context_provider.get());
 
   if (context_provider.get()) {
     scoped_refptr<base::SingleThreadTaskRunner> compositor_thread_task_runner =
         GetCompositorMessageLoop();
     if (!compositor_thread_task_runner.get())
       compositor_thread_task_runner = base::MessageLoopProxy::current();
 
     // Here we know the GpuProcessHost has been set up, because we created a
     // context.
     output_surface_proxy_->ConnectToGpuProcessHost(
         compositor_thread_task_runner.get());
   }
 
   if (UseSurfacesEnabled()) {
     // This gets a bit confusing. Here we have a ContextProvider configured to
     // render directly to this widget. We need to make an OnscreenDisplayClient
     // associated with this context, then return a SurfaceDisplayOutputSurface
     // set up to draw to the display's surface.
     cc::SurfaceManager* manager = surface_manager_.get();
     scoped_ptr<cc::OutputSurface> display_surface;
     if (!context_provider.get()) {
       display_surface =
           make_scoped_ptr(new SoftwareBrowserCompositorOutputSurface(
               output_surface_proxy_,
-              CreateSoftwareOutputDevice(compositor),
-              per_compositor_data_[compositor]->surface_id,
+              CreateSoftwareOutputDevice(compositor.get()),
+              data->surface_id,
               &output_surface_map_,
               compositor->vsync_manager()));
     } else {
       display_surface = make_scoped_ptr(new GpuBrowserCompositorOutputSurface(
           context_provider,
-          per_compositor_data_[compositor]->surface_id,
+          data->surface_id,
           &output_surface_map_,
           compositor->vsync_manager(),
           CreateOverlayCandidateValidator(compositor->widget())));
     }
     scoped_ptr<OnscreenDisplayClient> display_client(new OnscreenDisplayClient(
         display_surface.Pass(), manager, compositor->task_runner()));
 
     scoped_ptr<SurfaceDisplayOutputSurface> output_surface(
         new SurfaceDisplayOutputSurface(
             manager, compositor->surface_id_allocator(), context_provider));
     display_client->set_surface_output_surface(output_surface.get());
     output_surface->set_display_client(display_client.get());
     data->display_client = display_client.Pass();
-    return output_surface.Pass();
+    compositor->SetOutputSurface(output_surface.Pass());
+    return;
   }
 
   if (!context_provider.get()) {
     if (compositor_thread_.get()) {
       LOG(FATAL) << "Failed to create UI context, but can't use software"
                  " compositing with browser threaded compositing. Aborting.";
     }
 
-    return make_scoped_ptr(new SoftwareBrowserCompositorOutputSurface(
-        output_surface_proxy_,
-        CreateSoftwareOutputDevice(compositor),
-        per_compositor_data_[compositor]->surface_id,
-        &output_surface_map_,
-        compositor->vsync_manager()));
+    scoped_ptr<SoftwareBrowserCompositorOutputSurface> surface(
+        new SoftwareBrowserCompositorOutputSurface(
+            output_surface_proxy_,
+            CreateSoftwareOutputDevice(compositor.get()),
+            data->surface_id,
+            &output_surface_map_,
+            compositor->vsync_manager()));
+    compositor->SetOutputSurface(surface.Pass());
+    return;
   }
 
   scoped_ptr<BrowserCompositorOutputSurface> surface;
 #if defined(USE_OZONE)
   if (ui::SurfaceFactoryOzone::GetInstance()->CanShowPrimaryPlaneAsOverlay()) {
     surface.reset(new GpuSurfacelessBrowserCompositorOutputSurface(
         context_provider,
-        per_compositor_data_[compositor]->surface_id,
+        data->surface_id,
         &output_surface_map_,
         compositor->vsync_manager(),
         CreateOverlayCandidateValidator(compositor->widget()),
         GL_RGB,
         compositor_thread_ != nullptr));
   }
 #endif
   if (!surface)
     surface.reset(new GpuBrowserCompositorOutputSurface(
         context_provider,
-        per_compositor_data_[compositor]->surface_id,
+        data->surface_id,
         &output_surface_map_,
         compositor->vsync_manager(),
         CreateOverlayCandidateValidator(compositor->widget())));
 
   if (data->reflector.get())
     data->reflector->ReattachToOutputSurfaceFromMainThread(surface.get());
 
-  return surface.Pass();
+  compositor->SetOutputSurface(surface.Pass());
 }
 
 scoped_refptr<ui::Reflector> GpuProcessTransportFactory::CreateReflector(
     ui::Compositor* source,
     ui::Layer* target) {
   PerCompositorData* data = per_compositor_data_[source];
   DCHECK(data);
 
   data->reflector = new ReflectorImpl(source,
                                       target,
@@ skipping 148 matching lines @@
   tracker->SetSurfaceHandle(
       data->surface_id,
       gfx::GLSurfaceHandle(widget, gfx::NATIVE_DIRECT));
 
   per_compositor_data_[compositor] = data;
 
   return data;
 }
 
 scoped_ptr<WebGraphicsContext3DCommandBufferImpl>
-GpuProcessTransportFactory::CreateContextCommon(int surface_id) {
+GpuProcessTransportFactory::CreateContextCommon(
+    scoped_refptr<GpuChannelHost> gpu_channel_host,
+    int surface_id) {
   if (!GpuDataManagerImpl::GetInstance()->CanUseGpuBrowserCompositor())
     return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
   blink::WebGraphicsContext3D::Attributes attrs;
   attrs.shareResources = true;
   attrs.depth = false;
   attrs.stencil = false;
   attrs.antialias = false;
   attrs.noAutomaticFlushes = true;
   bool lose_context_when_out_of_memory = true;
-  CauseForGpuLaunch cause =
-      CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE;
-  scoped_refptr<GpuChannelHost> gpu_channel_host(
-      BrowserGpuChannelHostFactory::instance()->EstablishGpuChannelSync(cause));
   if (!gpu_channel_host.get()) {
     LOG(ERROR) << "Failed to establish GPU channel.";
     return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
   }
   GURL url("chrome://gpu/GpuProcessTransportFactory::CreateContextCommon");
   scoped_ptr<WebGraphicsContext3DCommandBufferImpl> context(
       new WebGraphicsContext3DCommandBufferImpl(
           surface_id,
           url,
           gpu_channel_host.get(),
@@ skipping 27 matching lines @@
   FOR_EACH_OBSERVER(ImageTransportFactoryObserver,
                     observer_list_,
                     OnLostResources());
 
   // Kill things that use the shared context before killing the shared context.
   lost_gl_helper.reset();
   lost_shared_main_thread_contexts  = NULL;
 }
 
 }  // namespace content