blimp: Set up the CompositorDependencies for blimp in Chrome.

Add ChromeCompositorDependencies to implement the CompositorDependencies
for blimp in Chrome. The class passes through to the
ui::ContextProviderFactory to create the contexts.

TBR=jochen

BUG=611105
CQ_INCLUDE_TRYBOTS=master.tryserver.chromium.linux:linux_site_isolation

Review-Url: https://codereview.chromium.org/2297933002
Cr-Commit-Position: refs/heads/master@{#416333}

blimp/client/app/compositor/browser_compositor.cc

@@ -71,7 +71,7 @@ BrowserCompositor::BrowserCompositor(
     CompositorDependencies* compositor_dependencies)
     : compositor_dependencies_(compositor_dependencies),
       surface_id_allocator_(base::MakeUnique<cc::SurfaceIdAllocator>(
-          compositor_dependencies->AllocateSurfaceId())),
+          compositor_dependencies->AllocateSurfaceClientId())),
       widget_(gfx::kNullAcceleratedWidget),
       output_surface_request_pending_(false),
       root_layer_(cc::Layer::Create()) {

blimp/client/core/compositor/BUILD.gn

@@ -29,6 +29,7 @@ source_set("compositor") {
 
   deps = [
     "//blimp/client/public:public_headers",
+    "//blimp/client/support/compositor",
     "//blimp/net",
     "//cc/proto",
     "//cc/surfaces",

blimp/client/core/compositor/blimp_compositor.cc

@@ -72,7 +72,7 @@ BlimpCompositor::BlimpCompositor(
   DCHECK(thread_checker_.CalledOnValidThread());
 
   surface_id_allocator_ = base::MakeUnique<cc::SurfaceIdAllocator>(
-      GetEmbedderDeps()->AllocateSurfaceId());
+      GetEmbedderDeps()->AllocateSurfaceClientId());
   GetEmbedderDeps()->GetSurfaceManager()->RegisterSurfaceClientId(
       surface_id_allocator_->client_id());
 }
@@ -104,8 +104,8 @@ void BlimpCompositor::RequestNewOutputSurface() {
   DCHECK(!output_surface_request_pending_);
 
   output_surface_request_pending_ = true;
-  GetEmbedderDeps()->GetContextProvider(
-      base::Bind(&BlimpCompositor::OnContextProviderCreated,
+  GetEmbedderDeps()->GetContextProviders(
+      base::Bind(&BlimpCompositor::OnContextProvidersCreated,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
@@ -157,8 +157,9 @@ void BlimpCompositor::OnCompositorMessageReceived(
   }
 }
 
-void BlimpCompositor::OnContextProviderCreated(
-    const scoped_refptr<cc::ContextProvider>& provider) {
+void BlimpCompositor::OnContextProvidersCreated(
+    const scoped_refptr<cc::ContextProvider>& compositor_context_provider,
+    const scoped_refptr<cc::ContextProvider>& worker_context_provider) {
   DCHECK(!surface_factory_)
       << "Any connection to the old output surface should have been destroyed";
 
@@ -168,15 +169,19 @@ void BlimpCompositor::OnContextProviderCreated(
   if (!output_surface_request_pending_)
     return;
 
-  // TODO(khushalsagar): Make a worker context and bind it to the current
-  // thread:
-  // Worker context is bound to the main thread in RenderThreadImpl. One day
-  // that will change and then this will have to be removed.
-  // worker_context_provider->BindToCurrentThread();
+  // Try again if the context creation failed.
+  if (!compositor_context_provider) {
+    GetEmbedderDeps()->GetContextProviders(
+        base::Bind(&BlimpCompositor::OnContextProvidersCreated,
+                   weak_ptr_factory_.GetWeakPtr()));
+    return;
+  }
+
   std::unique_ptr<DelegatedOutputSurface> delegated_output_surface =
       base::MakeUnique<DelegatedOutputSurface>(
-          provider, nullptr, base::ThreadTaskRunnerHandle::Get(),
-          weak_ptr_factory_.GetWeakPtr());
+          std::move(compositor_context_provider),
+          std::move(worker_context_provider),
+          base::ThreadTaskRunnerHandle::Get(), weak_ptr_factory_.GetWeakPtr());
 
   host_->SetOutputSurface(std::move(delegated_output_surface));
 }
@@ -275,7 +280,14 @@ void BlimpCompositor::CreateLayerTreeHost(
   params.main_task_runner = base::ThreadTaskRunnerHandle::Get();
   params.image_serialization_processor =
       compositor_dependencies_->GetImageSerializationProcessor();
-  params.settings = GetEmbedderDeps()->GetLayerTreeSettings();
+
+  cc::LayerTreeSettings* settings =
+      compositor_dependencies_->GetLayerTreeSettings();
+  // TODO(khushalsagar): This is a hack. Remove when we move the split point
+  // out. For details on why this is needed, see crbug.com/586210.
+  settings->abort_commit_before_output_surface_creation = false;
+  params.settings = settings;
+
   params.animation_host = cc::AnimationHost::CreateMainInstance();
 
   scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner =

blimp/client/core/compositor/blimp_compositor.h

@@ -11,6 +11,7 @@
 #include "base/memory/ref_counted.h"
 #include "blimp/client/core/compositor/blimp_output_surface.h"
 #include "blimp/client/core/input/blimp_input_manager.h"
+#include "blimp/client/public/compositor/compositor_dependencies.h"
 #include "cc/surfaces/surface_factory_client.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_host_client.h"
@@ -46,7 +47,6 @@ class BlimpMessage;
 namespace client {
 
 class BlimpCompositorDependencies;
-class CompositorDependencies;
 
 // The BlimpCompositorClient provides the BlimpCompositor with the necessary
 // dependencies for cc::LayerTreeHost owned by this compositor and for
@@ -103,12 +103,6 @@ class BlimpCompositor : public cc::LayerTreeHostClient,
   virtual void OnCompositorMessageReceived(
       std::unique_ptr<cc::proto::CompositorMessage> message);
 
-  // Called when the a ContextProvider has been created by the
-  // CompositorDependencies class.  If |host_| is waiting on an OutputSurface
-  // this will build one for it.
-  void OnContextProviderCreated(
-      const scoped_refptr<cc::ContextProvider>& provider);
-
   scoped_refptr<cc::Layer> layer() const { return layer_; }
 
   int render_widget_id() const { return render_widget_id_; }
@@ -155,6 +149,13 @@ class BlimpCompositor : public cc::LayerTreeHostClient,
   void ReturnResources(const cc::ReturnedResourceArray& resources) override;
   void SetBeginFrameSource(cc::BeginFrameSource* begin_frame_source) override {}
 
+  // Called when the a ContextProvider has been created by the
+  // CompositorDependencies class.  If |host_| is waiting on an OutputSurface
+  // this will build one for it.
+  void OnContextProvidersCreated(
+      const scoped_refptr<cc::ContextProvider>& compositor_context_provider,
+      const scoped_refptr<cc::ContextProvider>& worker_context_provider);
+
   // Helper method to get the embedder dependencies.
   CompositorDependencies* GetEmbedderDeps();
 

blimp/client/core/compositor/blimp_compositor_dependencies.cc

@@ -11,7 +11,9 @@
 #include "base/threading/thread.h"
 #include "blimp/client/core/compositor/blob_image_serialization_processor.h"
 #include "blimp/client/public/compositor/compositor_dependencies.h"
+#include "blimp/client/support/compositor/blimp_layer_tree_settings.h"
 #include "cc/raster/single_thread_task_graph_runner.h"
+#include "cc/trees/layer_tree_settings.h"
 
 namespace blimp {
 namespace client {
@@ -79,5 +81,14 @@ BlimpCompositorDependencies::GetImageSerializationProcessor() {
   return BlobImageSerializationProcessor::current();
 }
 
+cc::LayerTreeSettings* BlimpCompositorDependencies::GetLayerTreeSettings() {
+  if (!settings_) {
+    settings_ = base::MakeUnique<cc::LayerTreeSettings>();
+    PopulateCommonLayerTreeSettings(settings_.get());
+  }
+
+  return settings_.get();
+}
+
 }  // namespace client
 }  // namespace blimp

blimp/client/core/compositor/blimp_compositor_dependencies.h

@@ -16,6 +16,7 @@ class Thread;
 
 namespace cc {
 class ImageSerializationProcessor;
+class LayerTreeSettings;
 class TaskGraphRunner;
 }
 
@@ -42,6 +43,9 @@ class BlimpCompositorDependencies {
 
   cc::ImageSerializationProcessor* GetImageSerializationProcessor();
 
+  // TODO(xingliu): Get from the embedder when crbug.com/577985.
+  cc::LayerTreeSettings* GetLayerTreeSettings();
+
  private:
   std::unique_ptr<CompositorDependencies> embedder_dependencies_;
 
@@ -49,6 +53,8 @@ class BlimpCompositorDependencies {
   std::unique_ptr<base::Thread> compositor_impl_thread_;
   std::unique_ptr<cc::TaskGraphRunner> task_graph_runner_;
 
+  std::unique_ptr<cc::LayerTreeSettings> settings_;
+
   DISALLOW_COPY_AND_ASSIGN(BlimpCompositorDependencies);
 };
 

blimp/client/public/blimp_client_context.h

@@ -25,7 +25,6 @@ class SupportsUserData;
 
 namespace blimp {
 namespace client {
-
 class CompositorDependencies;
 
 // BlimpClientContext is the core class for the Blimp client. It provides hooks

blimp/client/public/compositor/compositor_dependencies.h

@@ -10,7 +10,6 @@
 
 namespace cc {
 class ContextProvider;
-class LayerTreeSettings;
 class SurfaceManager;
 }  // namespace cc
 
@@ -25,20 +24,20 @@ namespace client {
 // is expected to outlive all BlimpContents instances.
 class CompositorDependencies {
  public:
-  using ContextProviderCallback =
-      base::Callback<void(const scoped_refptr<cc::ContextProvider>&)>;
+  using ContextProviderCallback = base::Callback<void(
+      const scoped_refptr<cc::ContextProvider>& compositor_context_provider,
+      const scoped_refptr<cc::ContextProvider>& worker_context_provider)>;
 
   virtual ~CompositorDependencies() = default;
 
   // Settings used to create all BlimpCompositor instances.
-  virtual cc::LayerTreeSettings* GetLayerTreeSettings() = 0;
   virtual gpu::GpuMemoryBufferManager* GetGpuMemoryBufferManager() = 0;
   virtual cc::SurfaceManager* GetSurfaceManager() = 0;
-  virtual uint32_t AllocateSurfaceId() = 0;
+  virtual uint32_t AllocateSurfaceClientId() = 0;
 
   // This call may return synchronously if the ContextProvider has already been
   // created.
-  virtual void GetContextProvider(const ContextProviderCallback& callback) = 0;
+  virtual void GetContextProviders(const ContextProviderCallback& callback) = 0;
 };
 
 }  // namespace client

blimp/client/support/compositor/blimp_context_provider.cc

@@ -107,9 +107,7 @@ void BlimpContextProvider::InvalidateGrContext(uint32_t state) {
 }
 
 base::Lock* BlimpContextProvider::GetLock() {
-  // This context provider is not used on multiple threads.
-  NOTREACHED();
-  return nullptr;
+  return &context_lock_;
 }
 
 void BlimpContextProvider::SetLostContextCallback(

blimp/client/support/compositor/blimp_context_provider.h

@@ -60,6 +60,8 @@ class BlimpContextProvider : public cc::ContextProvider {
 
   LostContextCallback lost_context_callback_;
 
+  base::Lock context_lock_;
+
   DISALLOW_COPY_AND_ASSIGN(BlimpContextProvider);
 };
 

blimp/client/support/compositor/blimp_layer_tree_settings.cc

@@ -10,12 +10,17 @@
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/sys_info.h"
+#include "blimp/client/support/compositor/blimp_gpu_memory_buffer_manager.h"
 #include "cc/base/switches.h"
 #include "cc/trees/layer_tree_settings.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/gfx/buffer_types.h"
 #include "ui/gl/gl_switches.h"
 
+#if defined(OS_ANDROID)
+#include "ui/gfx/android/device_display_info.h"
+#endif
+
 namespace blimp {
 namespace client {
 
@@ -168,6 +173,52 @@ void PopulateCommonLayerTreeSettings(cc::LayerTreeSettings* settings) {
   memory_policy.priority_cutoff_when_visible =
       gpu::MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE;
 #endif
+
+  int default_tile_size = 256;
+#if defined(OS_ANDROID)
+  gfx::DeviceDisplayInfo info;
+  bool real_size_supported = true;
+  int display_width = info.GetPhysicalDisplayWidth();
+  int display_height = info.GetPhysicalDisplayHeight();
+  if (display_width == 0 || display_height == 0) {
+    real_size_supported = false;
+    display_width = info.GetDisplayWidth();
+    display_height = info.GetDisplayHeight();
+  }
+
+  int portrait_width = std::min(display_width, display_height);
+  int landscape_width = std::max(display_width, display_height);
+
+  if (real_size_supported) {
+    // Maximum HD dimensions should be 768x1280
+    // Maximum FHD dimensions should be 1200x1920
+    if (portrait_width > 768 || landscape_width > 1280)
+      default_tile_size = 384;
+    if (portrait_width > 1200 || landscape_width > 1920)
+      default_tile_size = 512;
+
+    // Adjust for some resolutions that barely straddle an extra
+    // tile when in portrait mode. This helps worst case scroll/raster
+    // by not needing a full extra tile for each row.
+    if (default_tile_size == 256 && portrait_width == 768)
+      default_tile_size += 32;
+    if (default_tile_size == 384 && portrait_width == 1200)
+      default_tile_size += 32;
+  } else {
+    // We don't know the exact resolution due to screen controls etc.
+    // So this just estimates the values above using tile counts.
+    int numTiles = (display_width * display_height) / (256 * 256);
+    if (numTiles > 16)
+      default_tile_size = 384;
+    if (numTiles >= 40)
+      default_tile_size = 512;
+  }
+#endif
+  settings->default_tile_size.SetSize(default_tile_size, default_tile_size);
+
+  settings->renderer_settings.buffer_to_texture_target_map =
+      BlimpGpuMemoryBufferManager::GetDefaultBufferToTextureTargetMap();
+  settings->use_output_surface_begin_frame_source = true;
 }
 
 }  // namespace client

blimp/client/support/compositor/compositor_dependencies_impl.cc

@@ -11,10 +11,6 @@
 #include "cc/surfaces/surface_manager.h"
 #include "cc/trees/layer_tree_settings.h"
 
-#if defined(OS_ANDROID)
-#include "ui/gfx/android/device_display_info.h"
-#endif
-
 namespace blimp {
 namespace client {
 
@@ -26,62 +22,6 @@ CompositorDependenciesImpl::CompositorDependenciesImpl()
 
 CompositorDependenciesImpl::~CompositorDependenciesImpl() = default;
 
-cc::LayerTreeSettings* CompositorDependenciesImpl::GetLayerTreeSettings() {
-  if (!settings_) {
-    settings_ = base::MakeUnique<cc::LayerTreeSettings>();
-
-    PopulateCommonLayerTreeSettings(settings_.get());
-    settings_->abort_commit_before_output_surface_creation = false;
-    settings_->renderer_settings.buffer_to_texture_target_map =
-        BlimpGpuMemoryBufferManager::GetDefaultBufferToTextureTargetMap();
-    settings_->use_output_surface_begin_frame_source = true;
-
-    int default_tile_size = 256;
-#if defined(OS_ANDROID)
-    gfx::DeviceDisplayInfo info;
-    bool real_size_supported = true;
-    int display_width = info.GetPhysicalDisplayWidth();
-    int display_height = info.GetPhysicalDisplayHeight();
-    if (display_width == 0 || display_height == 0) {
-      real_size_supported = false;
-      display_width = info.GetDisplayWidth();
-      display_height = info.GetDisplayHeight();
-    }
-
-    int portrait_width = std::min(display_width, display_height);
-    int landscape_width = std::max(display_width, display_height);
-
-    if (real_size_supported) {
-      // Maximum HD dimensions should be 768x1280
-      // Maximum FHD dimensions should be 1200x1920
-      if (portrait_width > 768 || landscape_width > 1280)
-        default_tile_size = 384;
-      if (portrait_width > 1200 || landscape_width > 1920)
-        default_tile_size = 512;
-
-      // Adjust for some resolutions that barely straddle an extra
-      // tile when in portrait mode. This helps worst case scroll/raster
-      // by not needing a full extra tile for each row.
-      if (default_tile_size == 256 && portrait_width == 768)
-        default_tile_size += 32;
-      if (default_tile_size == 384 && portrait_width == 1200)
-        default_tile_size += 32;
-    } else {
-      // We don't know the exact resolution due to screen controls etc.
-      // So this just estimates the values above using tile counts.
-      int numTiles = (display_width * display_height) / (256 * 256);
-      if (numTiles > 16)
-        default_tile_size = 384;
-      if (numTiles >= 40)
-        default_tile_size = 512;
-    }
-#endif
-    settings_->default_tile_size.SetSize(default_tile_size, default_tile_size);
-  }
-
-  return settings_.get();
-}
-
 gpu::GpuMemoryBufferManager*
 CompositorDependenciesImpl::GetGpuMemoryBufferManager() {
   return gpu_memory_buffer_manager_.get();
@@ -91,15 +31,18 @@ cc::SurfaceManager* CompositorDependenciesImpl::GetSurfaceManager() {
   return surface_manager_.get();
 }
 
-uint32_t CompositorDependenciesImpl::AllocateSurfaceId() {
+uint32_t CompositorDependenciesImpl::AllocateSurfaceClientId() {
   return ++next_surface_id_;
 }
 
-void CompositorDependenciesImpl::GetContextProvider(
+void CompositorDependenciesImpl::GetContextProviders(
     const CompositorDependencies::ContextProviderCallback& callback) {
-  scoped_refptr<cc::ContextProvider> provider = BlimpContextProvider::Create(
-      gfx::kNullAcceleratedWidget, gpu_memory_buffer_manager_.get());
-  callback.Run(provider);
+  scoped_refptr<cc::ContextProvider> compositor_context =
+      BlimpContextProvider::Create(gfx::kNullAcceleratedWidget,
+                                   gpu_memory_buffer_manager_.get());
+
+  // TODO(khushalsagar): Make a worker context and bind to the current thread.
+  callback.Run(compositor_context, nullptr);
 }
 
 }  // namespace client

blimp/client/support/compositor/compositor_dependencies_impl.h

@@ -24,14 +24,12 @@ class CompositorDependenciesImpl : public CompositorDependencies {
   ~CompositorDependenciesImpl() override;
 
   // CompositorDependencies implementation.
-  cc::LayerTreeSettings* GetLayerTreeSettings() override;
   gpu::GpuMemoryBufferManager* GetGpuMemoryBufferManager() override;
   cc::SurfaceManager* GetSurfaceManager() override;
-  uint32_t AllocateSurfaceId() override;
-  void GetContextProvider(const ContextProviderCallback& callback) override;
+  uint32_t AllocateSurfaceClientId() override;
+  void GetContextProviders(const ContextProviderCallback& callback) override;
 
  private:
-  std::unique_ptr<cc::LayerTreeSettings> settings_;
   std::unique_ptr<BlimpGpuMemoryBufferManager> gpu_memory_buffer_manager_;
   std::unique_ptr<cc::SurfaceManager> surface_manager_;
   uint32_t next_surface_id_;

blimp/client/support/compositor/mock_compositor_dependencies.cc

@@ -9,11 +9,11 @@
 namespace blimp {
 namespace client {
 
-void MockCompositorDependencies::GetContextProvider(
+void MockCompositorDependencies::GetContextProviders(
     const ContextProviderCallback& callback) {
-  scoped_refptr<cc::ContextProvider> provider =
-      make_scoped_refptr(new cc::TestInProcessContextProvider(nullptr));
-  callback.Run(provider);
+  callback.Run(
+      make_scoped_refptr(new cc::TestInProcessContextProvider(nullptr)),
+      make_scoped_refptr(new cc::TestInProcessContextProvider(nullptr)));
 }
 
 }  // namespace client

blimp/client/support/compositor/mock_compositor_dependencies.h

@@ -16,7 +16,7 @@ class MockCompositorDependencies : public CompositorDependenciesImpl {
   ~MockCompositorDependencies() override = default;
 
   // CompositorDependenciesImpl implementation.
-  void GetContextProvider(const ContextProviderCallback& callback) override;
+  void GetContextProviders(const ContextProviderCallback& callback) override;
 };
 
 }  // namespace client

chrome/browser/BUILD.gn

@@ -2892,6 +2892,8 @@ split_static_library("browser") {
       "android/blimp/chrome_blimp_client_context_delegate.h",
       "android/blimp/chrome_blimp_client_context_delegate_android.cc",
       "android/blimp/chrome_blimp_client_context_delegate_android.h",
+      "android/blimp/chrome_compositor_dependencies.cc",
+      "android/blimp/chrome_compositor_dependencies.h",
       "android/bookmarks/bookmark_bridge.cc",
       "android/bookmarks/bookmark_bridge.h",
       "android/bookmarks/partner_bookmarks_reader.cc",

chrome/browser/android/DEPS

@@ -2,6 +2,7 @@ include_rules = [
   "+blimp/client/public",
   "-components/devtools_bridge",
   "+cc/layers/layer.h",
+  "+cc/output/context_provider.h",
   "+components/devtools_http_handler",
   "+components/ntp_snippets",
   "+components/spellcheck/browser",

chrome/browser/android/blimp/blimp_client_context_factory.cc

@@ -8,9 +8,11 @@
 #include "base/supports_user_data.h"
 #include "blimp/client/public/blimp_client_context.h"
 #include "blimp/client/public/compositor/compositor_dependencies.h"
+#include "chrome/browser/android/blimp/chrome_compositor_dependencies.h"
 #include "components/keyed_service/content/browser_context_dependency_manager.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
+#include "ui/android/context_provider_factory.h"
 
 // static
 BlimpClientContextFactory* BlimpClientContextFactory::GetInstance() {
@@ -40,7 +42,8 @@ KeyedService* BlimpClientContextFactory::BuildServiceInstanceFor(
           content::BrowserThread::IO),
       content::BrowserThread::GetTaskRunnerForThread(
           content::BrowserThread::FILE),
-      nullptr);
+      base::MakeUnique<ChromeCompositorDependencies>(
+          ui::ContextProviderFactory::GetInstance()));
 }
 
 content::BrowserContext* BlimpClientContextFactory::GetBrowserContextToUse(

chrome/browser/android/blimp/chrome_compositor_dependencies.cc

+// Copyright 2016 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 "chrome/browser/android/blimp/chrome_compositor_dependencies.h"
+
+#include "base/bind.h"
+#include "base/command_line.h"
+#include "cc/output/context_provider.h"
+#include "content/public/common/content_switches.h"
+#include "gpu/command_buffer/client/gles2_interface.h"
+#include "gpu/command_buffer/client/shared_memory_limits.h"
+#include "gpu/command_buffer/common/gles2_cmd_utils.h"
+#include "gpu/ipc/client/gpu_channel_host.h"
+
+namespace {
+
+bool IsValidWorkerContext(cc::ContextProvider* context_provider) {
+  cc::ContextProvider::ScopedContextLock lock(context_provider);
+  return context_provider->ContextGL()->GetGraphicsResetStatusKHR() ==
+         GL_NO_ERROR;
+}
+
+gpu::gles2::ContextCreationAttribHelper
+GetOffscreenContextCreationAttributes() {
+  gpu::gles2::ContextCreationAttribHelper attributes;
+  attributes.alpha_size = -1;
+  attributes.depth_size = 0;
+  attributes.stencil_size = 0;
+  attributes.samples = 0;
+  attributes.sample_buffers = 0;
+  attributes.bind_generates_resource = false;
+  attributes.lose_context_when_out_of_memory = true;
+  return attributes;
+}
+
+bool IsAsyncWorkerContextEnabled() {
+  const base::CommandLine& command_line =
+      *base::CommandLine::ForCurrentProcess();
+
+  if (command_line.HasSwitch(switches::kDisableGpuAsyncWorkerContext))
+    return false;
+  else if (command_line.HasSwitch(switches::kEnableGpuAsyncWorkerContext))
+    return true;
+
+  return false;
+}
+
+}  // namespace
+
+ChromeCompositorDependencies::ChromeCompositorDependencies(
+    ui::ContextProviderFactory* context_provider_factory)
+    : context_provider_factory_(context_provider_factory), weak_factory_(this) {
+  DCHECK(context_provider_factory_);
+}
+
+ChromeCompositorDependencies::~ChromeCompositorDependencies() = default;
+
+gpu::GpuMemoryBufferManager*
+ChromeCompositorDependencies::GetGpuMemoryBufferManager() {
+  return context_provider_factory_->GetGpuMemoryBufferManager();
+}
+
+cc::SurfaceManager* ChromeCompositorDependencies::GetSurfaceManager() {
+  return context_provider_factory_->GetSurfaceManager();
+}
+
+uint32_t ChromeCompositorDependencies::AllocateSurfaceClientId() {
+  return context_provider_factory_->AllocateSurfaceClientId();
+}
+
+void ChromeCompositorDependencies::GetContextProviders(
+    const ContextProviderCallback& callback) {
+  context_provider_factory_->RequestGpuChannelHost(
+      base::Bind(&ChromeCompositorDependencies::OnGpuChannelEstablished,
+                 weak_factory_.GetWeakPtr(), callback));
+}
+
+void ChromeCompositorDependencies::OnGpuChannelEstablished(
+    const ContextProviderCallback& callback,
+    scoped_refptr<gpu::GpuChannelHost> gpu_channel_host,
+    ui::ContextProviderFactory::GpuChannelHostResult result) {
+  using GpuRequestResult = ui::ContextProviderFactory::GpuChannelHostResult;
+
+  switch (result) {
+    case GpuRequestResult::FAILURE_GPU_PROCESS_INITIALIZATION_FAILED:
+      // Pass the null result to the caller and let them try again.
+      break;
+    case GpuRequestResult::FAILURE_FACTORY_SHUTDOWN:
+      // If the factory is shutting down, early out and drop the requests.
+      return;
+    case GpuRequestResult::SUCCESS:
+      // Create the worker context first if necessary.
+      if (!shared_main_thread_worker_context_ ||
+          !IsValidWorkerContext(shared_main_thread_worker_context_.get())) {
+        shared_main_thread_worker_context_ =
+            context_provider_factory_->CreateOffscreenContextProvider(
+                ui::ContextProviderFactory::ContextType::
+                    BLIMP_RENDER_WORKER_CONTEXT,
+                gpu::SharedMemoryLimits(),
+                GetOffscreenContextCreationAttributes(),
+                true /* support_locking */, false /* automatic_flushes */,
+                nullptr, gpu_channel_host);
+        if (!shared_main_thread_worker_context_->BindToCurrentThread()) {
+          shared_main_thread_worker_context_ = nullptr;
+        }
+      }
+      break;
+  }
+
+  scoped_refptr<cc::ContextProvider> compositor_context_provider;
+  if (gpu_channel_host && shared_main_thread_worker_context_) {
+    // The compositor context shares resources with the worker context unless
+    // the worker is async.
+    cc::ContextProvider* shared_context =
+        IsAsyncWorkerContextEnabled()
+            ? nullptr
+            : shared_main_thread_worker_context_.get();
+
+    compositor_context_provider =
+        context_provider_factory_->CreateOffscreenContextProvider(
+            ui::ContextProviderFactory::ContextType::
+                BLIMP_RENDER_COMPOSITOR_CONTEXT,
+            gpu::SharedMemoryLimits::ForMailboxContext(),
+            GetOffscreenContextCreationAttributes(),
+            false /* support_locking */, false /* automatic_flushes */,
+            shared_context, std::move(gpu_channel_host));
+  }
+
+  callback.Run(compositor_context_provider, shared_main_thread_worker_context_);
+}

chrome/browser/android/blimp/chrome_compositor_dependencies.h

+// Copyright 2016 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.
+
+#ifndef CHROME_BROWSER_ANDROID_BLIMP_CHROME_COMPOSITOR_DEPENDENCIES_H_
+#define CHROME_BROWSER_ANDROID_BLIMP_CHROME_COMPOSITOR_DEPENDENCIES_H_
+
+#include "base/macros.h"
+#include "base/memory/weak_ptr.h"
+#include "blimp/client/public/compositor/compositor_dependencies.h"
+#include "ui/android/context_provider_factory.h"
+
+// A wrapper for the Blimp compositor dependencies that passes through to the
+// ui::ContextProviderFactory. The ContextProviderFactory must outlive this
+// class.
+class ChromeCompositorDependencies
+    : public blimp::client::CompositorDependencies {
+ public:
+  ChromeCompositorDependencies(
+      ui::ContextProviderFactory* context_provider_factory);
+  ~ChromeCompositorDependencies() override;
+
+  // CompositorDependencies implementation.
+  gpu::GpuMemoryBufferManager* GetGpuMemoryBufferManager() override;
+  cc::SurfaceManager* GetSurfaceManager() override;
+  uint32_t AllocateSurfaceClientId() override;
+  void GetContextProviders(const ContextProviderCallback& callback) override;
+
+ private:
+  void OnGpuChannelEstablished(
+      const ContextProviderCallback& callback,
+      scoped_refptr<gpu::GpuChannelHost> gpu_channel_host,
+      ui::ContextProviderFactory::GpuChannelHostResult result);
+
+  void HandlePendingRequests(gpu::GpuChannelHost* gpu_channel_host);
+
+  ui::ContextProviderFactory* context_provider_factory_;
+
+  // Worker context shared across all Blimp Compositors.
+  scoped_refptr<cc::ContextProvider> shared_main_thread_worker_context_;
+
+  base::WeakPtrFactory<ChromeCompositorDependencies> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(ChromeCompositorDependencies);
+};
+
+#endif  // CHROME_BROWSER_ANDROID_BLIMP_CHROME_COMPOSITOR_DEPENDENCIES_H_

content/browser/browser_main_loop.cc

@@ -976,7 +976,6 @@ void BrowserMainLoop::ShutdownThreadsAndCleanUp() {
 
 #if defined(OS_ANDROID)
   g_browser_main_loop_shutting_down = true;
-  ui::ContextProviderFactory::SetInstance(nullptr);
 #endif
 
   if (RenderProcessHost::run_renderer_in_process())
@@ -1131,8 +1130,14 @@ void BrowserMainLoop::ShutdownThreadsAndCleanUp() {
   // it.
   {
     TRACE_EVENT0("shutdown", "BrowserMainLoop::Subsystem:GPUChannelFactory");
-    if (BrowserGpuChannelHostFactory::instance())
+    if (BrowserGpuChannelHostFactory::instance()) {
+#if defined(OS_ANDROID)
+      // Clean up the references to the factory before terminating it.
+      ui::ContextProviderFactory::SetInstance(nullptr);
+      ContextProviderFactoryImpl::Terminate();
+#endif
       BrowserGpuChannelHostFactory::Terminate();
+    }
   }
 
   // Must happen after the I/O thread is shutdown since this class lives on the
@@ -1213,6 +1218,8 @@ int BrowserMainLoop::BrowserThreadsStarted() {
   established_gpu_channel = false;
   always_uses_gpu = ShouldStartGpuProcessOnBrowserStartup();
   BrowserGpuChannelHostFactory::Initialize(established_gpu_channel);
+  ContextProviderFactoryImpl::Initialize(
+      BrowserGpuChannelHostFactory::instance());
   ui::ContextProviderFactory::SetInstance(
       ContextProviderFactoryImpl::GetInstance());
 #elif defined(USE_AURA) || defined(OS_MACOSX)

content/browser/frame_host/render_widget_host_view_child_frame_unittest.cc

@@ -32,6 +32,7 @@
 
 #if defined(OS_ANDROID)
 #include "content/browser/renderer_host/context_provider_factory_impl_android.h"
+#include "content/test/mock_gpu_channel_establish_factory.h"
 #endif
 
 namespace content {
@@ -85,6 +86,7 @@ class RenderWidgetHostViewChildFrameTest : public testing::Test {
     ImageTransportFactory::InitializeForUnitTests(
         base::WrapUnique(new NoTransportImageTransportFactory));
 #else
+    ContextProviderFactoryImpl::Initialize(&gpu_channel_factory_);
     ui::ContextProviderFactory::SetInstance(
         ContextProviderFactoryImpl::GetInstance());
 #endif
@@ -115,6 +117,7 @@ class RenderWidgetHostViewChildFrameTest : public testing::Test {
     ImageTransportFactory::Terminate();
 #else
     ui::ContextProviderFactory::SetInstance(nullptr);
+    ContextProviderFactoryImpl::Terminate();
 #endif
   }
 
@@ -131,6 +134,10 @@ class RenderWidgetHostViewChildFrameTest : public testing::Test {
   RenderWidgetHostViewChildFrame* view_;
   MockCrossProcessFrameConnector* test_frame_connector_;
 
+#if defined(OS_ANDROID)
+  MockGpuChannelEstablishFactory gpu_channel_factory_;
+#endif
+
  private:
   DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostViewChildFrameTest);
 };

content/browser/frame_host/render_widget_host_view_guest_unittest.cc

@@ -32,6 +32,7 @@
 
 #if defined(OS_ANDROID)
 #include "content/browser/renderer_host/context_provider_factory_impl_android.h"
+#include "content/test/mock_gpu_channel_establish_factory.h"
 #endif
 
 namespace content {
@@ -59,6 +60,7 @@ class RenderWidgetHostViewGuestTest : public testing::Test {
         std::unique_ptr<ImageTransportFactory>(
             new NoTransportImageTransportFactory));
 #else
+    ContextProviderFactoryImpl::Initialize(&gpu_channel_factory_);
     ui::ContextProviderFactory::SetInstance(
         ContextProviderFactoryImpl::GetInstance());
 #endif
@@ -87,6 +89,7 @@ class RenderWidgetHostViewGuestTest : public testing::Test {
     ImageTransportFactory::Terminate();
 #else
     ui::ContextProviderFactory::SetInstance(nullptr);
+    ContextProviderFactoryImpl::Terminate();
 #endif
   }
 
@@ -100,6 +103,10 @@ class RenderWidgetHostViewGuestTest : public testing::Test {
   RenderWidgetHostImpl* widget_host_;
   RenderWidgetHostViewGuest* view_;
 
+#if defined(OS_ANDROID)
+  MockGpuChannelEstablishFactory gpu_channel_factory_;
+#endif
+
  private:
   DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostViewGuestTest);
 };
@@ -166,6 +173,10 @@ class RenderWidgetHostViewGuestSurfaceTest
     ImageTransportFactory::InitializeForUnitTests(
         std::unique_ptr<ImageTransportFactory>(
             new NoTransportImageTransportFactory));
+#else
+    ContextProviderFactoryImpl::Initialize(&gpu_channel_factory_);
+    ui::ContextProviderFactory::SetInstance(
+        ContextProviderFactoryImpl::GetInstance());
 #endif
     browser_context_.reset(new TestBrowserContext);
     MockRenderProcessHost* process_host =
@@ -195,6 +206,9 @@ class RenderWidgetHostViewGuestSurfaceTest
     base::RunLoop().RunUntilIdle();
 #if !defined(OS_ANDROID)
     ImageTransportFactory::Terminate();
+#else
+    ui::ContextProviderFactory::SetInstance(nullptr);
+    ContextProviderFactoryImpl::Terminate();
 #endif
   }
 
@@ -211,6 +225,10 @@ class RenderWidgetHostViewGuestSurfaceTest
   std::unique_ptr<TestWebContents> web_contents_;
   TestBrowserPluginGuest* browser_plugin_guest_;
 
+#if defined(OS_ANDROID)
+  MockGpuChannelEstablishFactory gpu_channel_factory_;
+#endif
+
   // Tests should set these to NULL if they've already triggered their
   // destruction.
   RenderWidgetHostImpl* widget_host_;

content/browser/renderer_host/compositor_impl_android.cc

@@ -610,13 +610,8 @@ void CompositorImpl::HandlePendingOutputSurfaceRequest() {
 #endif
 
   DCHECK(surface_handle_ != gpu::kNullSurfaceHandle);
-
-  ContextProviderFactoryImpl::GetInstance()->CreateDisplayContextProvider(
-      surface_handle_, GetCompositorContextSharedMemoryLimits(),
-      GetCompositorContextAttributes(has_transparent_background_),
-      false /*support_locking*/, false /*automatic_flushes*/,
-      base::Bind(&CompositorImpl::CreateCompositorOutputSurface,
-                 weak_factory_.GetWeakPtr()));
+  ContextProviderFactoryImpl::GetInstance()->RequestGpuChannelHost(base::Bind(
+      &CompositorImpl::OnGpuChannelEstablished, weak_factory_.GetWeakPtr()));
 }
 
 #if defined(ENABLE_VULKAN)
@@ -648,27 +643,49 @@ void CompositorImpl::CreateVulkanOutputSurface() {
 }
 #endif
 
-void CompositorImpl::CreateCompositorOutputSurface(
-    const scoped_refptr<cc::ContextProvider>& context_provider) {
-  // This callback should run only if we have a pending output surface request,
-  // since that is when we should have queued a context request.
-  // In case the surface was invalidated after the context request was queued,
-  // the request should have been dropped by the ContextProviderFactory.
+void CompositorImpl::OnGpuChannelEstablished(
+    scoped_refptr<gpu::GpuChannelHost> gpu_channel_host,
+    ui::ContextProviderFactory::GpuChannelHostResult result) {
   DCHECK(output_surface_request_pending_);
-  DCHECK(host_->visible());
-  DCHECK(window_);
-  DCHECK_NE(surface_handle_, gpu::kNullSurfaceHandle);
-  DCHECK(context_provider);
-
-  scoped_refptr<ContextProviderCommandBuffer> context_provider_command_buffer =
-      static_cast<ContextProviderCommandBuffer*>(context_provider.get());
-  std::unique_ptr<cc::OutputSurface> display_output_surface(
-      new OutputSurfaceWithoutParent(
-          context_provider_command_buffer,
-          base::Bind(&CompositorImpl::PopulateGpuCapabilities,
-                     base::Unretained(this))));
-  InitializeDisplay(std::move(display_output_surface), nullptr,
-                    std::move(context_provider));
+
+  switch (result) {
+    // Don't retry if we are shutting down.
+    case ui::ContextProviderFactory::GpuChannelHostResult::
+        FAILURE_FACTORY_SHUTDOWN:
+      break;
+    case ui::ContextProviderFactory::GpuChannelHostResult::
+        FAILURE_GPU_PROCESS_INITIALIZATION_FAILED:
+      // TODO(khushalsagar): Retry or have a fallback path after
+      // crbug.com/643282 is resolved.
+      break;
+    case ui::ContextProviderFactory::GpuChannelHostResult::SUCCESS:
+      // We don't need the context anymore if we are invisible.
+      if (!host_->visible())
+        return;
+
+      DCHECK(window_);
+      DCHECK_NE(surface_handle_, gpu::kNullSurfaceHandle);
+      scoped_refptr<cc::ContextProvider> context_provider =
+          ContextProviderFactoryImpl::GetInstance()
+              ->CreateDisplayContextProvider(
+                  surface_handle_, GetCompositorContextSharedMemoryLimits(),
+                  GetCompositorContextAttributes(has_transparent_background_),
+                  false /*support_locking*/, false /*automatic_flushes*/,
+                  std::move(gpu_channel_host));
+
+      scoped_refptr<ContextProviderCommandBuffer>
+          context_provider_command_buffer =
+              static_cast<ContextProviderCommandBuffer*>(
+                  context_provider.get());
+      std::unique_ptr<cc::OutputSurface> display_output_surface(
+          new OutputSurfaceWithoutParent(
+              context_provider_command_buffer,
+              base::Bind(&CompositorImpl::PopulateGpuCapabilities,
+                         base::Unretained(this))));
+      InitializeDisplay(std::move(display_output_surface), nullptr,
+                        std::move(context_provider));
+      break;
+  }
 }
 
 void CompositorImpl::InitializeDisplay(

content/browser/renderer_host/compositor_impl_android.h

@@ -126,8 +126,9 @@ class CONTENT_EXPORT CompositorImpl
 #if defined(ENABLE_VULKAN)
   void CreateVulkanOutputSurface();
 #endif
-  void CreateCompositorOutputSurface(
-      const scoped_refptr<cc::ContextProvider>& context_provider);
+  void OnGpuChannelEstablished(
+      scoped_refptr<gpu::GpuChannelHost> gpu_channel_host,
+      ui::ContextProviderFactory::GpuChannelHostResult result);
   void InitializeDisplay(
       std::unique_ptr<cc::OutputSurface> display_output_surface,
       scoped_refptr<cc::VulkanContextProvider> vulkan_context_provider,

content/browser/renderer_host/context_provider_factory_impl_android.h

@@ -5,7 +5,7 @@
 #ifndef CONTENT_BROWSER_RENDERER_HOST_CONTEXT_PROVIDER_FACTORY_IMPL_ANDROID_H_
 #define CONTENT_BROWSER_RENDERER_HOST_CONTEXT_PROVIDER_FACTORY_IMPL_ANDROID_H_
 
-#include <list>
+#include <queue>
 
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
@@ -17,17 +17,13 @@
 #include "gpu/ipc/common/surface_handle.h"
 #include "ui/android/context_provider_factory.h"
 
-namespace base {
-template <typename T>
-struct DefaultSingletonTraits;
-}
-
 namespace cc {
 class VulkanInProcessContextProvider;
 }
 
 namespace gpu {
 class GpuChannelHost;
+class GpuChannelEstablishFactory;
 }
 
 namespace content {
@@ -36,41 +32,46 @@ class ContextProviderCommandBuffer;
 class CONTENT_EXPORT ContextProviderFactoryImpl
     : public ui::ContextProviderFactory {
  public:
+  // The factory must outlive the ContextProviderFactoryImpl instance, which
+  // will be destroyed when terminate is called.
+  static void Initialize(gpu::GpuChannelEstablishFactory* gpu_channel_factory);
+
+  static void Terminate();
+
   static ContextProviderFactoryImpl* GetInstance();
 
   ~ContextProviderFactoryImpl() override;
 
-  // The callback may be triggered synchronously, if the Gpu Channel is already
-  // initialized. In case the surface_handle is invalidated before the context
-  // can be created, the request is dropped and the callback will *not* run.
-  void CreateDisplayContextProvider(
+  scoped_refptr<cc::ContextProvider> CreateDisplayContextProvider(
       gpu::SurfaceHandle surface_handle,
       gpu::SharedMemoryLimits shared_memory_limits,
       gpu::gles2::ContextCreationAttribHelper attributes,
       bool support_locking,
       bool automatic_flushes,
-      ContextProviderCallback result_callback);
+      scoped_refptr<gpu::GpuChannelHost> gpu_channel_host);
 
   // ContextProviderFactory implementation.
   scoped_refptr<cc::VulkanContextProvider> GetSharedVulkanContextProvider()
       override;
-  void CreateOffscreenContextProvider(
+  void RequestGpuChannelHost(GpuChannelHostCallback callback) override;
+  scoped_refptr<cc::ContextProvider> CreateOffscreenContextProvider(
       ContextType context_type,
       gpu::SharedMemoryLimits shared_memory_limits,
       gpu::gles2::ContextCreationAttribHelper attributes,
       bool support_locking,
       bool automatic_flushes,
       cc::ContextProvider* shared_context_provider,
-      ContextProviderCallback result_callback) override;
+      scoped_refptr<gpu::GpuChannelHost> gpu_channel_host) override;
   cc::SurfaceManager* GetSurfaceManager() override;
   uint32_t AllocateSurfaceClientId() override;
   cc::SharedBitmapManager* GetSharedBitmapManager() override;
   gpu::GpuMemoryBufferManager* GetGpuMemoryBufferManager() override;
 
  private:
-  friend struct base::DefaultSingletonTraits<ContextProviderFactoryImpl>;
+  ContextProviderFactoryImpl(
+      gpu::GpuChannelEstablishFactory* gpu_channel_factory);
 
-  void CreateContextProviderInternal(
+  scoped_refptr<cc::ContextProvider> CreateContextProviderInternal(
       command_buffer_metrics::ContextType context_type,
       gpu::SurfaceHandle surface_handle,
       gpu::SharedMemoryLimits shared_memory_limits,
@@ -78,33 +79,20 @@ class CONTENT_EXPORT ContextProviderFactoryImpl
       bool support_locking,
       bool automatic_flushes,
       cc::ContextProvider* shared_context_provider,
-      ContextProviderCallback result_callback);
-
-  struct ContextProvidersRequest {
-    ContextProvidersRequest();
-    ContextProvidersRequest(const ContextProvidersRequest& other);
-    ~ContextProvidersRequest();
-
-    command_buffer_metrics::ContextType context_type;
-    gpu::SurfaceHandle surface_handle;
-    gpu::SharedMemoryLimits shared_memory_limits;
-    gpu::gles2::ContextCreationAttribHelper attributes;
-    bool support_locking;
-    bool automatic_flushes;
-    cc::ContextProvider* shared_context_provider;
-    ContextProviderCallback result_callback;
-  };
-
-  ContextProviderFactoryImpl();
+      scoped_refptr<gpu::GpuChannelHost> gpu_channel_host);
 
   // Will return nullptr if the Gpu channel has not been established.
-  gpu::GpuChannelHost* EnsureGpuChannelEstablished();
+  void EstablishGpuChannel();
   void OnGpuChannelEstablished(scoped_refptr<gpu::GpuChannelHost> gpu_channel);
   void OnGpuChannelTimeout();
 
-  void HandlePendingRequests();
+  void HandlePendingRequests(
+      scoped_refptr<gpu::GpuChannelHost> gpu_channel_host,
+      GpuChannelHostResult result);
 
-  std::list<ContextProvidersRequest> context_provider_requests_;
+  gpu::GpuChannelEstablishFactory* gpu_channel_factory_;
+
+  std::queue<GpuChannelHostCallback> gpu_channel_requests_;
 
   scoped_refptr<ContextProviderCommandBuffer> shared_worker_context_provider_;
 
@@ -112,6 +100,8 @@ class CONTENT_EXPORT ContextProviderFactoryImpl
 
   bool in_handle_pending_requests_;
 
+  bool in_shutdown_;
+
   base::OneShotTimer establish_gpu_channel_timeout_;
 
   std::unique_ptr<cc::SurfaceManager> surface_manager_;

content/browser/renderer_host/render_widget_host_unittest.cc

@@ -39,6 +39,7 @@
 #if defined(OS_ANDROID)
 #include "content/browser/renderer_host/context_provider_factory_impl_android.h"
 #include "content/browser/renderer_host/render_widget_host_view_android.h"
+#include "content/test/mock_gpu_channel_establish_factory.h"
 #endif
 
 #if defined(USE_AURA) || defined(OS_MACOSX)
@@ -472,6 +473,7 @@ class RenderWidgetHostTest : public testing::Test {
             new NoTransportImageTransportFactory));
 #endif
 #if defined(OS_ANDROID)
+    ContextProviderFactoryImpl::Initialize(&gpu_channel_factory_);
     ui::ContextProviderFactory::SetInstance(
         ContextProviderFactoryImpl::GetInstance());
 #endif
@@ -505,6 +507,7 @@ class RenderWidgetHostTest : public testing::Test {
 #endif
 #if defined(OS_ANDROID)
     ui::ContextProviderFactory::SetInstance(nullptr);
+    ContextProviderFactoryImpl::Terminate();
 #endif
 
     // Process all pending tasks to avoid leaks.
@@ -651,6 +654,10 @@ class RenderWidgetHostTest : public testing::Test {
   double last_simulated_event_time_seconds_;
   double simulated_event_time_delta_seconds_;
 
+#if defined(OS_ANDROID)
+  MockGpuChannelEstablishFactory gpu_channel_factory_;
+#endif
+
  private:
   SyntheticWebTouchEvent touch_event_;
 

content/content_tests.gypi

@@ -119,6 +119,8 @@
       'test/mock_background_sync_controller.h',
       'test/mock_google_streaming_server.cc',
       'test/mock_google_streaming_server.h',
+      'test/mock_gpu_channel_establish_factory.cc',
+      'test/mock_gpu_channel_establish_factory.h',
       'test/mock_keyboard.cc',
       'test/mock_keyboard.h',
       'test/mock_keyboard_driver_win.cc',

content/public/test/test_renderer_host.cc

@@ -30,6 +30,7 @@
 
 #if defined(OS_ANDROID)
 #include "content/browser/renderer_host/context_provider_factory_impl_android.h"
+#include "content/test/mock_gpu_channel_establish_factory.h"
 #endif
 
 #if defined(OS_WIN)
@@ -245,6 +246,8 @@ void RenderViewHostTestHarness::SetUp() {
   ImageTransportFactory::InitializeForUnitTests(
       base::WrapUnique(new NoTransportImageTransportFactory));
 #else
+  gpu_channel_factory_ = base::MakeUnique<MockGpuChannelEstablishFactory>();
+  ContextProviderFactoryImpl::Initialize(gpu_channel_factory_.get());
   ui::ContextProviderFactory::SetInstance(
       ContextProviderFactoryImpl::GetInstance());
 #endif
@@ -314,6 +317,8 @@ void RenderViewHostTestHarness::TearDown() {
     ImageTransportFactory::Terminate();
 #else
   ui::ContextProviderFactory::SetInstance(nullptr);
+  ContextProviderFactoryImpl::Terminate();
+  gpu_channel_factory_.reset();
 #endif
 }
 

content/public/test/test_renderer_host.h

@@ -36,6 +36,7 @@ namespace content {
 
 class BrowserContext;
 class ContentBrowserSanityChecker;
+class MockGpuChannelEstablishFactory;
 class MockRenderProcessHost;
 class MockRenderProcessHostFactory;
 class NavigationController;
@@ -275,6 +276,9 @@ class RenderViewHostTestHarness : public testing::Test {
 #endif
 #if defined(USE_AURA)
   std::unique_ptr<aura::test::AuraTestHelper> aura_test_helper_;
+#endif
+#if defined(OS_ANDROID)
+  std::unique_ptr<MockGpuChannelEstablishFactory> gpu_channel_factory_;
 #endif
   RenderViewHostTestEnabler rvh_test_enabler_;
 

content/test/mock_gpu_channel_establish_factory.cc

+// Copyright 2011 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/test/mock_gpu_channel_establish_factory.h"
+
+namespace content {
+
+MockGpuChannelEstablishFactory::MockGpuChannelEstablishFactory() = default;
+
+MockGpuChannelEstablishFactory::~MockGpuChannelEstablishFactory() = default;
+
+void MockGpuChannelEstablishFactory::EstablishGpuChannel(
+    const gpu::GpuChannelEstablishedCallback& callback) {
+  callback.Run(nullptr);
+}
+
+scoped_refptr<gpu::GpuChannelHost>
+MockGpuChannelEstablishFactory::EstablishGpuChannelSync() {
+  return nullptr;
+}
+
+gpu::GpuMemoryBufferManager*
+MockGpuChannelEstablishFactory::GetGpuMemoryBufferManager() {
+  return nullptr;
+}
+
+}  // namespace content

content/test/mock_gpu_channel_establish_factory.h

+// Copyright 2011 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.
+
+#ifndef CONTENT_TEST_MOCK_GPU_CHANNEL_ESTABLISH_FACTORY_H_
+#define CONTENT_TEST_MOCK_GPU_CHANNEL_ESTABLISH_FACTORY_H_
+
+#include "base/macros.h"
+#include "gpu/ipc/client/gpu_channel_host.h"
+
+namespace content {
+
+class MockGpuChannelEstablishFactory : public gpu::GpuChannelEstablishFactory {
+ public:
+  MockGpuChannelEstablishFactory();
+  ~MockGpuChannelEstablishFactory() override;
+
+  void EstablishGpuChannel(
+      const gpu::GpuChannelEstablishedCallback& callback) override;
+  scoped_refptr<gpu::GpuChannelHost> EstablishGpuChannelSync() override;
+  gpu::GpuMemoryBufferManager* GetGpuMemoryBufferManager() override;
+};
+
+}  // namespace content
+
+#endif  // CONTENT_TEST_MOCK_GPU_CHANNEL_ESTABLISH_FACTORY_H_

content/test/test_render_view_host.cc

@@ -33,6 +33,10 @@
 #include "ui/compositor/compositor.h"
 #include "ui/gfx/geometry/rect.h"
 
+#if defined(OS_ANDROID)
+#include "content/browser/renderer_host/context_provider_factory_impl_android.h"
+#endif
+
 namespace content {
 
 void InitNavigateParams(FrameHostMsg_DidCommitProvisionalLoad_Params* params,
@@ -63,10 +67,13 @@ TestRenderWidgetHostView::TestRenderWidgetHostView(RenderWidgetHost* rwh)
       is_occluded_(false),
       did_swap_compositor_frame_(false) {
 #if defined(OS_ANDROID)
-  surface_id_allocator_.reset(
-      new cc::SurfaceIdAllocator(AllocateSurfaceClientId()));
-  GetSurfaceManager()->RegisterSurfaceClientId(
-      surface_id_allocator_->client_id());
+  // Not all tests initialize or need a context provider factory.
+  if (ContextProviderFactoryImpl::GetInstance()) {
+    surface_id_allocator_.reset(
+        new cc::SurfaceIdAllocator(AllocateSurfaceClientId()));
+    GetSurfaceManager()->RegisterSurfaceClientId(
+        surface_id_allocator_->client_id());
+  }
 #else
   // Not all tests initialize or need an image transport factory.
   if (ImageTransportFactory::GetInstance()) {
@@ -81,9 +88,15 @@ TestRenderWidgetHostView::TestRenderWidgetHostView(RenderWidgetHost* rwh)
 }
 
 TestRenderWidgetHostView::~TestRenderWidgetHostView() {
-  if (GetSurfaceManager()) {
-    GetSurfaceManager()->InvalidateSurfaceClientId(
-        surface_id_allocator_->client_id());
+  cc::SurfaceManager* manager = nullptr;
+#if defined(OS_ANDROID)
+  if (ContextProviderFactoryImpl::GetInstance())
+    manager = GetSurfaceManager();
+#else
+  manager = GetSurfaceManager();
+#endif
+  if (manager) {
+    manager->InvalidateSurfaceClientId(surface_id_allocator_->client_id());
   }
 }
 

ui/android/context_provider_factory.h

@@ -23,6 +23,7 @@ struct ContextCreationAttribHelper;
 }  // namespace gles
 
 struct SharedMemoryLimits;
+class GpuChannelHost;
 class GpuMemoryBufferManager;
 }  // namespace gpu
 
@@ -31,8 +32,20 @@ namespace ui {
 // This class is not thread-safe and should only be accessed from the UI thread.
 class UI_ANDROID_EXPORT ContextProviderFactory {
  public:
-  using ContextProviderCallback =
-      base::Callback<void(const scoped_refptr<cc::ContextProvider>&)>;
+  enum class GpuChannelHostResult {
+    FAILURE_GPU_PROCESS_INITIALIZATION_FAILED,
+
+    // Used when the factory is shutting down. No more requests should be made
+    // to the factory after this response is dispatched.
+    FAILURE_FACTORY_SHUTDOWN,
+
+    // Set if the Context creation was successful.
+    SUCCESS,
+  };
+
+  using GpuChannelHostCallback =
+      base::Callback<void(scoped_refptr<gpu::GpuChannelHost>,
+                          GpuChannelHostResult)>;
 
   enum class ContextType {
     BLIMP_RENDER_COMPOSITOR_CONTEXT,
@@ -50,18 +63,20 @@ class UI_ANDROID_EXPORT ContextProviderFactory {
   virtual scoped_refptr<cc::VulkanContextProvider>
   GetSharedVulkanContextProvider() = 0;
 
+  // The callback may be triggered synchronously if possible. If the creation
+  // fails, a null host is passed with the specified reason.
+  virtual void RequestGpuChannelHost(GpuChannelHostCallback callback) = 0;
+
   // Creates an offscreen ContextProvider for the compositor. Any shared
   // contexts passed here *must* have been created using this factory.
-  // The callback may be triggered synchronously if possible, and will always
-  // have the context provider.
-  virtual void CreateOffscreenContextProvider(
+  virtual scoped_refptr<cc::ContextProvider> CreateOffscreenContextProvider(
       ContextType context_type,
       gpu::SharedMemoryLimits shared_memory_limits,
       gpu::gles2::ContextCreationAttribHelper attributes,
       bool support_locking,
       bool automatic_flushes,
       cc::ContextProvider* shared_context_provider,
-      ContextProviderCallback result_callback) = 0;
+      scoped_refptr<gpu::GpuChannelHost> gpu_channel_host) = 0;
 
   virtual cc::SurfaceManager* GetSurfaceManager() = 0;