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 26 matching lines @@
 #include "cc/output/output_surface.h"
 #include "cc/output/output_surface_client.h"
 #include "cc/output/texture_mailbox_deleter.h"
 #include "cc/output/vulkan_in_process_context_provider.h"
 #include "cc/raster/single_thread_task_graph_runner.h"
 #include "cc/scheduler/begin_frame_source.h"
 #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() {
     Start("CompositorTileWorker1", base::SimpleThread::Options());
   }
 
   ~SingleThreadTaskGraphRunner() override {
     Shutdown();
   }
 };
@@ skipping 13 matching lines @@
 void Compositor::Initialize() {
   DCHECK(!CompositorImpl::IsInitialized());
   g_initialized = true;
 }
 
 // static
 bool CompositorImpl::IsInitialized() {
   return g_initialized;
 }
 
-// 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())),
+          new cc::SurfaceIdAllocator(ui::ContextProviderFactory::GetInstance()
+                                         ->AllocateSurfaceClientId())),
       resource_manager_(root_window),
       has_transparent_background_(false),
       device_scale_factor_(1),
       window_(NULL),
       surface_handle_(gpu::kNullSurfaceHandle),
       client_(client),
       root_window_(root_window),
       needs_animate_(false),
       pending_swapbuffers_(0U),
       num_successive_context_creation_failures_(0),
       output_surface_request_pending_(false),
       needs_begin_frames_(false),
       weak_factory_(this) {
-  GetSurfaceManager()->RegisterSurfaceClientId(
-      surface_id_allocator_->client_id());
+  ui::ContextProviderFactory::GetInstance()
+      ->GetSurfaceManager()
+      ->RegisterSurfaceClientId(surface_id_allocator_->client_id());
   DCHECK(client);
   DCHECK(root_window);
   DCHECK(root_window->GetLayer() == nullptr);
   root_window->SetLayer(cc::Layer::Create());
   root_window->AttachCompositor(this);
   CreateLayerTreeHost();
   resource_manager_.Init(host_.get());
 }
 
 CompositorImpl::~CompositorImpl() {
   root_window_->DetachCompositor();
   root_window_->SetLayer(nullptr);
   // Clean-up any surface references.
   SetSurface(NULL);
-  GetSurfaceManager()->InvalidateSurfaceClientId(
-      surface_id_allocator_->client_id());
+  ui::ContextProviderFactory::GetInstance()
+      ->GetSurfaceManager()
+      ->InvalidateSurfaceClientId(surface_id_allocator_->client_id());
 }
 
 ui::UIResourceProvider& CompositorImpl::GetUIResourceProvider() {
   return *this;
 }
 
 ui::ResourceManager& CompositorImpl::GetResourceManager() {
   return resource_manager_;
 }
 
@@ skipping 81 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();

[no sievers, 2016/07/29 19:14:30]

Hmm I wonder why this was here, and how we could convince ourselves that it's
not needed anymore (or never was).

[Khushal, 2016/07/29 21:30:55]

This happens when the surface goes away. Is that related to the gpu channel
initialization in anyway? If we reset the timeout now in the
ContextProviderFactoryImpl when this happens, we could still have context
requests from other compositors.

[no sievers, 2016/07/29 21:42:41]

I don't remember why this is here. It seems to somehow suggest that
OnGpuChannelEstablished() might not happen if we became invisible.

Don't worry about it for now.

     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 15 matching lines @@
         gpu::GpuStreamPriority::NORMAL, surface_handle_, url, automatic_flushes,
         support_locking, limits, attributes, nullptr,
         command_buffer_metrics::DISPLAY_COMPOSITOR_ONSCREEN_CONTEXT);
     DCHECK(context_provider.get());
 
     display_output_surface = base::WrapUnique(new OutputSurfaceWithoutParent(
         context_provider, base::Bind(&CompositorImpl::PopulateGpuCapabilities,
                                      base::Unretained(this))));
   }
 
-  cc::SurfaceManager* manager = GetSurfaceManager();
+  cc::SurfaceManager* manager =
+      ui::ContextProviderFactory::GetInstance()->GetSurfaceManager();
   auto* task_runner = base::ThreadTaskRunnerHandle::Get().get();
   std::unique_ptr<ExternalBeginFrameSource> begin_frame_source(
       new ExternalBeginFrameSource(this));
   std::unique_ptr<cc::DisplayScheduler> scheduler(new cc::DisplayScheduler(
       begin_frame_source.get(), task_runner,
       display_output_surface->capabilities().max_frames_pending));
 
   display_.reset(new cc::Display(
       HostSharedBitmapManager::current(),
       BrowserGpuMemoryBufferManager::current(),
@@ skipping 94 matching lines @@
 void CompositorImpl::SetNeedsAnimate() {
   needs_animate_ = true;
   if (!host_->visible())
     return;
 
   TRACE_EVENT0("compositor", "Compositor::SetNeedsAnimate");
   host_->SetNeedsAnimate();
 }
 
 }  // namespace content