content: Add ContextProviderFactory to create a render ContextProvider.

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 32 matching lines @@
 #include "cc/surfaces/display.h"
 #include "cc/surfaces/display_scheduler.h"
 #include "cc/surfaces/surface_display_output_surface.h"
 #include "cc/surfaces/surface_id_allocator.h"
 #include "cc/surfaces/surface_manager.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_settings.h"
 #include "components/display_compositor/compositor_overlay_candidate_validator_android.h"
 #include "components/display_compositor/gl_helper.h"
 #include "content/browser/android/child_process_launcher_android.h"
-#include "content/browser/gpu/browser_gpu_channel_host_factory.h"
 #include "content/browser/gpu/browser_gpu_memory_buffer_manager.h"
 #include "content/browser/gpu/compositor_util.h"
 #include "content/browser/gpu/gpu_surface_tracker.h"
+#include "content/browser/renderer_host/context_provider_factory_impl_android.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_process_launch_causes.h"
 #include "content/common/host_shared_bitmap_manager.h"
 #include "content/public/browser/android/compositor.h"
 #include "content/public/browser/android/compositor_client.h"
 #include "content/public/common/content_switches.h"
 #include "gpu/command_buffer/client/context_support.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/ipc/client/command_buffer_proxy_impl.h"
@@ skipping 214 matching lines @@
     OutputSurface::OnSwapBuffersComplete();
   }
 
  private:
   std::unique_ptr<gpu::VulkanSurface> surface_;
 
   DISALLOW_COPY_AND_ASSIGN(VulkanOutputSurface);
 };
 #endif
 
-base::LazyInstance<scoped_refptr<cc::VulkanInProcessContextProvider>>
-    g_shared_vulkan_context_provider_android_ = LAZY_INSTANCE_INITIALIZER;
-
 static bool g_initialized = false;
 
 base::LazyInstance<cc::SurfaceManager> g_surface_manager =
     LAZY_INSTANCE_INITIALIZER;
 
 int g_surface_client_id = 0;
 
 class SingleThreadTaskGraphRunner : public cc::SingleThreadTaskGraphRunner {
  public:
   SingleThreadTaskGraphRunner() {
@@ skipping 30 matching lines @@
 // static
 cc::SurfaceManager* CompositorImpl::GetSurfaceManager() {
   return g_surface_manager.Pointer();
 }
 
 // static
 uint32_t CompositorImpl::AllocateSurfaceClientId() {
   return ++g_surface_client_id;
 }
 
-// static
-scoped_refptr<cc::VulkanInProcessContextProvider>
-CompositorImpl::SharedVulkanContextProviderAndroid() {
-  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kEnableVulkan)) {
-    scoped_refptr<cc::VulkanInProcessContextProvider>* context_provider =
-        g_shared_vulkan_context_provider_android_.Pointer();
-    if (!*context_provider)
-      *context_provider = cc::VulkanInProcessContextProvider::Create();
-    return *context_provider;
-  }
-  return nullptr;
-}
-
 CompositorImpl::CompositorImpl(CompositorClient* client,
                                gfx::NativeWindow root_window)
     : surface_id_allocator_(
           new cc::SurfaceIdAllocator(AllocateSurfaceClientId())),
       resource_manager_(root_window),
       has_transparent_background_(false),
       device_scale_factor_(1),
       window_(NULL),
       surface_handle_(gpu::kNullSurfaceHandle),
       client_(client),
@@ skipping 116 matching lines @@
 }
 
 void CompositorImpl::SetVisible(bool visible) {
   TRACE_EVENT1("cc", "CompositorImpl::SetVisible", "visible", visible);
   if (!visible) {
     DCHECK(host_->visible());
     host_->SetVisible(false);
     if (!host_->output_surface_lost())
       host_->ReleaseOutputSurface();
     pending_swapbuffers_ = 0;
-    establish_gpu_channel_timeout_.Stop();
     display_.reset();
   } else {
     host_->SetVisible(true);
     if (output_surface_request_pending_)
       RequestNewOutputSurface();
   }
 }
 
 void CompositorImpl::setDeviceScaleFactor(float factor) {
   device_scale_factor_ = factor;
@@ skipping 27 matching lines @@
 }
 
 void CompositorImpl::UpdateLayerTreeHost() {
   client_->UpdateLayerTreeHost();
   if (needs_animate_) {
     needs_animate_ = false;
     root_window_->Animate(base::TimeTicks::Now());
   }
 }
 
-void CompositorImpl::OnGpuChannelEstablished() {
-  establish_gpu_channel_timeout_.Stop();
-  CreateOutputSurface();
-}
-
-void CompositorImpl::OnGpuChannelTimeout() {
-  LOG(FATAL) << "Timed out waiting for GPU channel.";
+void CompositorImpl::OnGpuChannelEstablished(
+    scoped_refptr<gpu::GpuChannelHost> gpu_channel_host) {
+  CreateOutputSurface(std::move(gpu_channel_host));
 }
 
 void CompositorImpl::RequestNewOutputSurface() {
   output_surface_request_pending_ = true;
-
-#if defined(ADDRESS_SANITIZER) || defined(THREAD_SANITIZER) || \
-  defined(SYZYASAN) || defined(CYGPROFILE_INSTRUMENTATION)
-  const int64_t kGpuChannelTimeoutInSeconds = 40;
-#else
-  const int64_t kGpuChannelTimeoutInSeconds = 10;
-#endif
-
-  BrowserGpuChannelHostFactory* factory =
-      BrowserGpuChannelHostFactory::instance();
-  if (!factory->GetGpuChannel()) {
-    factory->EstablishGpuChannel(
-        CAUSE_FOR_GPU_LAUNCH_DISPLAY_COMPOSITOR_CONTEXT,
-        base::Bind(&CompositorImpl::OnGpuChannelEstablished,
-                   weak_factory_.GetWeakPtr()));
-    establish_gpu_channel_timeout_.Start(
-        FROM_HERE, base::TimeDelta::FromSeconds(kGpuChannelTimeoutInSeconds),
-        this, &CompositorImpl::OnGpuChannelTimeout);
-    return;
-  }
-
-  CreateOutputSurface();
+  CreateOutputSurface(nullptr);
 }
 
 void CompositorImpl::DidInitializeOutputSurface() {
   num_successive_context_creation_failures_ = 0;
   output_surface_request_pending_ = false;
 }
 
 void CompositorImpl::DidFailToInitializeOutputSurface() {
   LOG(ERROR) << "Failed to init OutputSurface for compositor.";
   LOG_IF(FATAL, ++num_successive_context_creation_failures_ >= 2)
       << "Too many context creation failures. Giving up... ";
   RequestNewOutputSurface();
 }
 
-void CompositorImpl::CreateOutputSurface() {
+void CompositorImpl::CreateOutputSurface(
+    scoped_refptr<gpu::GpuChannelHost> gpu_channel_host) {
   // We might have had a request from a LayerTreeHost that was then
   // hidden (and hidden means we don't have a native surface).
   // Also make sure we only handle this once.
   if (!output_surface_request_pending_ || !host_->visible())
     return;
 
   scoped_refptr<ContextProviderCommandBuffer> context_provider;
   scoped_refptr<cc::VulkanInProcessContextProvider> vulkan_context_provider =
-      SharedVulkanContextProviderAndroid();
+      ContextProviderFactoryImpl::GetInstance()
+          ->GetSharedVulkanContextProviderAndroid();
   std::unique_ptr<cc::OutputSurface> display_output_surface;
 #if defined(ENABLE_VULKAN)
   std::unique_ptr<VulkanOutputSurface> vulkan_surface;
   if (vulkan_context_provider) {
     vulkan_surface.reset(
         new VulkanOutputSurface(std::move(vulkan_context_provider)));
     if (!vulkan_surface->Initialize(window_)) {
       vulkan_surface->Destroy();
       vulkan_surface.reset();
     } else {
       display_output_surface = std::move(vulkan_surface);
     }
   }
 #endif
 
+  if (!gpu_channel_host) {
+    ContextProviderFactoryImpl::GetInstance()->RequestGpuChannel(base::Bind(
+        &CompositorImpl::OnGpuChannelEstablished, weak_factory_.GetWeakPtr()));
+    return;
+  }
+
   if (!display_output_surface) {
     // This is used for the browser compositor (offscreen) and for the display
     // compositor (onscreen), so ask for capabilities needed by either one.
     // The default framebuffer for an offscreen context is not used, so it does
     // not need alpha, stencil, depth, antialiasing. The display compositor does
     // not use these things either, except for alpha when it has a transparent
     // background.
     gpu::gles2::ContextCreationAttribHelper attributes;
     attributes.alpha_size = -1;
     attributes.stencil_size = 0;
@@ skipping 16 matching lines @@
       attributes.red_size = 5;
       attributes.green_size = 6;
       attributes.blue_size = 5;
     }
 
     pending_swapbuffers_ = 0;
 
     DCHECK(window_);
     DCHECK_NE(surface_handle_, gpu::kNullSurfaceHandle);
 
-    BrowserGpuChannelHostFactory* factory =
-        BrowserGpuChannelHostFactory::instance();
-    scoped_refptr<gpu::GpuChannelHost> gpu_channel_host(
-        factory->GetGpuChannel());
-    // If the channel was already lost, we'll get null back here and need to
-    // try again.
-    if (!gpu_channel_host) {
-      RequestNewOutputSurface();
-      return;
-    }
-
     GURL url("chrome://gpu/CompositorImpl::CreateOutputSurface");
     constexpr bool automatic_flushes = false;
     constexpr bool support_locking = false;
 
     constexpr size_t kBytesPerPixel = 4;
     const size_t full_screen_texture_size_in_bytes =
         gfx::DeviceDisplayInfo().GetDisplayHeight() *
         gfx::DeviceDisplayInfo().GetDisplayWidth() * kBytesPerPixel;
 
     gpu::SharedMemoryLimits limits;
@@ skipping 130 matching lines @@
 void CompositorImpl::SetNeedsAnimate() {
   needs_animate_ = true;
   if (!host_->visible())
     return;
 
   TRACE_EVENT0("compositor", "Compositor::SetNeedsAnimate");
   host_->SetNeedsAnimate();
 }
 
 }  // namespace content