blimp: Set up the CompositorDependencies for blimp in Chrome.

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_);
+}