Aura: Don't create GL context for CreateSharedSurfaceHandle()

content/browser/aura/gpu_process_transport_factory.cc

 // Copyright (c) 2013 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/aura/gpu_process_transport_factory.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/output_surface.h"
 #include "content/browser/aura/browser_compositor_output_surface.h"
 #include "content/browser/aura/browser_compositor_output_surface_proxy.h"
 #include "content/browser/aura/gpu_browser_compositor_output_surface.h"
 #include "content/browser/aura/reflector_impl.h"
 #include "content/browser/aura/software_browser_compositor_output_surface.h"
 #include "content/browser/gpu/browser_gpu_channel_host_factory.h"
 #include "content/browser/gpu/gpu_data_manager_impl.h"
 #include "content/browser/gpu/gpu_surface_tracker.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/common/gpu/client/context_provider_command_buffer.h"
 #include "content/common/gpu/client/gl_helper.h"
 #include "content/common/gpu/client/gpu_channel_host.h"
 #include "content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.h"
 #include "content/common/gpu/gpu_process_launch_causes.h"
+#include "content/public/browser/render_process_host.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "ui/compositor/compositor.h"
 #include "ui/compositor/compositor_switches.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gfx/size.h"
 
 #if defined(OS_WIN)
 #include "content/browser/aura/software_output_device_win.h"
 #include "ui/surface/accelerated_surface_win.h"
@@ skipping 100 matching lines @@
 
  private:
   std::string mailbox_name_;
   DISALLOW_COPY_AND_ASSIGN(ImageTransportClientTexture);
 };
 
 GpuProcessTransportFactory::GpuProcessTransportFactory()
     : callback_factory_(this) {
   output_surface_proxy_ = new BrowserCompositorOutputSurfaceProxy(
       &output_surface_map_);
+  if (GpuDataManagerImpl::GetInstance()->CanUseGpuBrowserCompositor()) {
+    CauseForGpuLaunch cause = CAUSE_FOR_GPU_LAUNCH_BROWSER_STARTUP;
+    BrowserGpuChannelHostFactory::instance()->EstablishGpuChannel(
+        cause,
+        base::Bind(&GpuProcessTransportFactory::OnGpuChannelReady,
+                   callback_factory_.GetWeakPtr()));
+  }
 }
 
 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>
@@ skipping 118 matching lines @@
     gl_helper_.reset();
 }
 
 bool GpuProcessTransportFactory::DoesCreateTestContexts() { return false; }
 
 ui::ContextFactory* GpuProcessTransportFactory::AsContextFactory() {
   return this;
 }
 
 gfx::GLSurfaceHandle GpuProcessTransportFactory::CreateSharedSurfaceHandle() {
-  scoped_refptr<cc::ContextProvider> provider =
-      SharedMainThreadContextProvider();
-  if (!provider.get())
+  if (!GpuDataManagerImpl::GetInstance()->CanUseGpuBrowserCompositor())

[piman, 2013/12/11 01:14:03]

In the rest of the patch, we're essentially assuming the GLSurfaceHandle doesn't
change anymore. However, CanUseGpuBrowserCompositor can start succeeding, and
then failing after a few GPU crashes, at which point we'll blacklist the GPU (on
desktop).
When that happens, this will return a different GLSurfaceHandle, that would
cause CreateViewCommandBuffer from the renderer to fail.

That being said, maybe the conditions that lead to this are such that:
1- we only transition from accelerated to non-accelerated
2- when we do, the renderer will also always stop trying to use GPU acceleration

If that's the case, then the patch can simplify code further, and we can pretty
much remove all the CreateViewCommandBuffer delaying logic - see other comments
in the CL

If that is not the case, then we need a chance for the UI to cause a
CreateViewCommandBuffer failure to the renderer, because we can't support the
renderer using GL and the UI to use software. That needs some kind of
throttling, and the current code wouldn't do that correctly I think. However,
we're down to a single bit of information that'd be valid for all renderers, so
maybe this can be handled in a simpler way.

[no sievers, 2013/12/11 01:49:24]

I think on windows with SwiftShader it's possible that
CanUseGpuBrowserCompositor() initially fails and later succeeds :/

     return gfx::GLSurfaceHandle();
-  typedef WebGraphicsContext3DCommandBufferImpl WGC3DCBI;
-  WGC3DCBI* context = static_cast<WGC3DCBI*>(provider->Context3d());
+
   gfx::GLSurfaceHandle handle = gfx::GLSurfaceHandle(
       gfx::kNullPluginWindow, gfx::TEXTURE_TRANSPORT);
-  handle.parent_gpu_process_id = context->GetGPUProcessID();
   handle.parent_client_id =
       BrowserGpuChannelHostFactory::instance()->GetGpuChannelId();
   return handle;
 }
 
 void GpuProcessTransportFactory::DestroySharedSurfaceHandle(
     gfx::GLSurfaceHandle surface) {}
 
 scoped_refptr<ui::Texture> GpuProcessTransportFactory::CreateTransportClient(
     float device_scale_factor) {
@@ skipping 179 matching lines @@
       shared_main_thread_contexts_;
   offscreen_compositor_contexts_ = NULL;
   shared_main_thread_contexts_  = NULL;
 
   scoped_ptr<GLHelper> lost_gl_helper = gl_helper_.Pass();
 
   FOR_EACH_OBSERVER(ImageTransportFactoryObserver,
                     observer_list_,
                     OnLostResources());
 
+  // This needs to happen after we notified the observers, because until then
+  // we want to block renderers' CreateViewCommandBuffer requests.
+  CauseForGpuLaunch cause =
+      CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE;
+  BrowserGpuChannelHostFactory::instance()->EstablishGpuChannel(
+      cause,
+      base::Bind(&GpuProcessTransportFactory::OnGpuChannelReady,
+                 callback_factory_.GetWeakPtr()));
+
   // Kill things that use the shared context before killing the shared context.
   lost_gl_helper.reset();
   lost_offscreen_compositor_contexts = NULL;
   lost_shared_main_thread_contexts  = NULL;
 }
 
+void GpuProcessTransportFactory::OnGpuChannelReady() {

[piman, 2013/12/11 01:14:03]

nit: this could be static, so you wouldn't need weakptrs above.

+  for (RenderProcessHost::iterator i(RenderProcessHost::AllHostsIterator());
+       !i.IsAtEnd();
+       i.Advance()) {
+    i.GetCurrentValue()->OnParentGpuChannelEstablished();
+  }
+}
+
 }  // namespace content