Request context sharing via content::ContextProviderCommandBuffer

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 <utility>
 
 #include "base/bind.h"
@@ skipping 79 matching lines @@
 
 using cc::ContextProvider;
 using gpu::gles2::GLES2Interface;
 
 namespace {
 
 const int kNumRetriesBeforeSoftwareFallback = 4;
 
 std::unique_ptr<content::WebGraphicsContext3DCommandBufferImpl>
 CreateContextCommon(scoped_refptr<gpu::GpuChannelHost> gpu_channel_host,
-                    gpu::SurfaceHandle surface_handle,
-                    bool share_resources) {
+                    gpu::SurfaceHandle surface_handle) {
   DCHECK(
       content::GpuDataManagerImpl::GetInstance()->CanUseGpuBrowserCompositor());
   DCHECK(gpu_channel_host);
 
   // This is called from a few places to create different contexts:
   // - The shared main thread context (offscreen).
   // - The compositor context, which is used by the browser compositor
   //   (offscreen) for synchronization mostly, and by the display compositor
   //   (onscreen) for actual GL drawing.
   // - The compositor worker context (offscreen) used for GPU raster.
@@ skipping 10 matching lines @@
   attributes.samples = 0;
   attributes.sample_buffers = 0;
   attributes.bind_generates_resource = false;
   attributes.lose_context_when_out_of_memory = true;
 
   bool automatic_flushes = false;
 
   GURL url("chrome://gpu/GpuProcessTransportFactory::CreateContextCommon");
   return base::WrapUnique(new content::WebGraphicsContext3DCommandBufferImpl(
       surface_handle, url, gpu_channel_host.get(), attributes,
-      gfx::PreferIntegratedGpu, share_resources, automatic_flushes,
-      nullptr));
+      gfx::PreferIntegratedGpu, automatic_flushes));
 }
 
 #if defined(OS_MACOSX)
 bool IsCALayersDisabledFromCommandLine() {
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   return command_line->HasSwitch(switches::kDisableMacOverlays);
 }
 #endif
 
 }  // namespace
@@ skipping 208 matching lines @@
     if (GpuDataManagerImpl::GetInstance()->CanUseGpuBrowserCompositor()) {
       // We attempted to do EstablishGpuChannel already, so we just use
       // GetGpuChannel() instead of EstablishGpuChannelSync().
       gpu_channel_host =
           BrowserGpuChannelHostFactory::instance()->GetGpuChannel();
     }
 
     if (!gpu_channel_host) {
       shared_worker_context_provider_ = nullptr;
     } else {
-      // This context is used for both the browser compositor and the display
-      // compositor.
-      constexpr bool share_resources = true;
-      context_provider = new ContextProviderCommandBuffer(
-          CreateContextCommon(gpu_channel_host, data->surface_handle,
-                              share_resources),
-          gpu::SharedMemoryLimits(), DISPLAY_COMPOSITOR_ONSCREEN_CONTEXT);
-      if (!context_provider->BindToCurrentThread())
-        context_provider = nullptr;
-
       if (!shared_worker_context_provider_) {
         shared_worker_context_provider_ = new ContextProviderCommandBuffer(
-            CreateContextCommon(std::move(gpu_channel_host),
-                                gpu::kNullSurfaceHandle, share_resources),
-            gpu::SharedMemoryLimits(), BROWSER_WORKER_CONTEXT);
+            CreateContextCommon(gpu_channel_host, gpu::kNullSurfaceHandle),
+            gpu::SharedMemoryLimits(), nullptr, BROWSER_WORKER_CONTEXT);
         if (shared_worker_context_provider_->BindToCurrentThread())
           shared_worker_context_provider_->SetupLock();
         else
           shared_worker_context_provider_ = nullptr;
       }
+
+      // The |context_provider| is used for both the browser compositor and the
+      // display compositor. It shares resources with the worker context, so if
+      // we failed to make a worker context, just start over and try again.
+      if (shared_worker_context_provider_) {
+        context_provider = new ContextProviderCommandBuffer(
+            CreateContextCommon(std::move(gpu_channel_host),
+                                data->surface_handle),
+            gpu::SharedMemoryLimits(), shared_worker_context_provider_.get(),
+            DISPLAY_COMPOSITOR_ONSCREEN_CONTEXT);
+        if (!context_provider->BindToCurrentThread())
+          context_provider = nullptr;
+      }
     }
 
     bool created_gpu_browser_compositor =
         !!context_provider && !!shared_worker_context_provider_;
 
     UMA_HISTOGRAM_BOOLEAN("Aura.CreatedGpuBrowserCompositor",
                           created_gpu_browser_compositor);
 
     if (!created_gpu_browser_compositor) {
       // Try again.
@@ skipping 284 matching lines @@
     return nullptr;
   CauseForGpuLaunch cause =
       CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE;
   scoped_refptr<gpu::GpuChannelHost> gpu_channel_host(
       BrowserGpuChannelHostFactory::instance()->EstablishGpuChannelSync(cause));
   if (!gpu_channel_host)
     return nullptr;
 
   // We need a separate context from the compositor's so that skia and gl_helper
   // don't step on each other.
-  bool share_resources = false;
   shared_main_thread_contexts_ = new ContextProviderCommandBuffer(
-      CreateContextCommon(std::move(gpu_channel_host), gpu::kNullSurfaceHandle,
-                          share_resources),
-      gpu::SharedMemoryLimits(), BROWSER_OFFSCREEN_MAINTHREAD_CONTEXT);
+      CreateContextCommon(std::move(gpu_channel_host), gpu::kNullSurfaceHandle),
+      gpu::SharedMemoryLimits(), nullptr, BROWSER_OFFSCREEN_MAINTHREAD_CONTEXT);
   shared_main_thread_contexts_->SetLostContextCallback(base::Bind(
       &GpuProcessTransportFactory::OnLostMainThreadSharedContextInsideCallback,
       callback_factory_.GetWeakPtr()));
   if (!shared_main_thread_contexts_->BindToCurrentThread())
     shared_main_thread_contexts_ = nullptr;
   return shared_main_thread_contexts_;
 }
 
 GpuProcessTransportFactory::PerCompositorData*
 GpuProcessTransportFactory::CreatePerCompositorData(
@@ skipping 57 matching lines @@
       shared_vulkan_context_provider_ =
           cc::VulkanInProcessContextProvider::Create();
     }
 
     shared_vulkan_context_provider_initialized_ = true;
   }
   return shared_vulkan_context_provider_;
 }
 
 }  // namespace content