blimp: Set up the CompositorDependencies for blimp in Chrome.

content/browser/renderer_host/compositor_impl_android.cc

 // Copyright (c) 2012 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/renderer_host/compositor_impl_android.h"
 
 #include <android/bitmap.h>
 #include <android/native_window_jni.h>
 #include <stdint.h>
 #include <unordered_set>
@@ skipping 592 matching lines @@
   if (!host_->visible())
     return;
 
 #if defined(ENABLE_VULKAN)
   CreateVulkanOutputSurface()
   if (display_)
     return;
 #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)
 void CompositorImpl::CreateVulkanOutputSurface() {
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableVulkan))
     return;
 
   std::unique_ptr<cc::OutputSurface> display_output_surface;
   scoped_refptr<cc::VulkanContextProvider> vulkan_context_provider =
@@ skipping 11 matching lines @@
   }
 
   if (!display_output_surface)
     return;
 
   InitializeDisplay(std::move(display_output_surface),
                     std::move(vulkan_context_provider), nullptr);
 }
 #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(
     std::unique_ptr<cc::OutputSurface> display_output_surface,
     scoped_refptr<cc::VulkanContextProvider> vulkan_context_provider,
     scoped_refptr<cc::ContextProvider> context_provider) {
   DCHECK(output_surface_request_pending_);
 
   pending_swapbuffers_ = 0;
 
@@ skipping 113 matching lines @@
 
   TRACE_EVENT0("compositor", "Compositor::SetNeedsAnimate");
   host_->SetNeedsAnimate();
 }
 
 bool CompositorImpl::HavePendingReadbacks() {
   return !readback_layer_tree_->children().empty();
 }
 
 }  // namespace content