Expose Blimp dependencies to the embedder

blimp/client/app/compositor/browser_compositor.cc

Index: blimp/client/app/compositor/browser_compositor.cc
diff --git a/blimp/client/app/compositor/browser_compositor.cc b/blimp/client/app/compositor/browser_compositor.cc
index 899db6abc14651a1db594d29ced5e9f2dae414cf..2d4fb7f46d31fc1f648a277ef0450b6472dbad1c 100644
--- a/blimp/client/app/compositor/browser_compositor.cc
+++ b/blimp/client/app/compositor/browser_compositor.cc
@@ -4,10 +4,10 @@
 
 #include "blimp/client/app/compositor/browser_compositor.h"
 
+#include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/threading/thread_task_runner_handle.h"
-#include "blimp/client/feature/compositor/blimp_context_provider.h"
-#include "blimp/client/feature/compositor/blimp_gpu_memory_buffer_manager.h"
+#include "blimp/client/public/compositor/compositor_dependencies.h"
 #include "cc/animation/animation_host.h"
 #include "cc/layers/layer.h"
 #include "cc/output/compositor_frame.h"
@@ -19,6 +19,7 @@
 #include "cc/surfaces/surface_manager.h"
 #include "cc/trees/layer_tree_host.h"
 #include "gpu/command_buffer/client/context_support.h"
+#include "gpu/command_buffer/client/gles2_lib.h"
 
 namespace blimp {
 namespace client {
@@ -51,8 +52,9 @@ class DisplayOutputSurface : public cc::OutputSurface {
   }
 
   uint32_t GetFramebufferCopyTextureFormat() override {
-    auto* gl = static_cast<BlimpContextProvider*>(context_provider());
-    return gl->GetCopyTextureInternalFormat();
+    // We assume we have an alpha channel from the BlimpContextProvider, so use
+    // GL_RGBA here.
+    return GL_RGBA;
   }
 
  private:
@@ -62,44 +64,24 @@ class DisplayOutputSurface : public cc::OutputSurface {
 base::LazyInstance<SimpleTaskGraphRunner> g_task_graph_runner =
     LAZY_INSTANCE_INITIALIZER;
 
-base::LazyInstance<cc::SurfaceManager> g_surface_manager =
-    LAZY_INSTANCE_INITIALIZER;
-
-base::LazyInstance<BlimpGpuMemoryBufferManager> g_gpu_memory_buffer_manager =
-    LAZY_INSTANCE_INITIALIZER;
-
-uint32_t g_surface_id = 0;
-
 }  // namespace
 
-// static
-cc::SurfaceManager* BrowserCompositor::GetSurfaceManager() {
-  return g_surface_manager.Pointer();
-}
-
-// static
-BlimpGpuMemoryBufferManager* BrowserCompositor::GetGpuMemoryBufferManager() {
-  return g_gpu_memory_buffer_manager.Pointer();
-}
-
-// static
-uint32_t BrowserCompositor::AllocateSurfaceClientId() {
-  return ++g_surface_id;
-}
-
-BrowserCompositor::BrowserCompositor()
-    : surface_id_allocator_(base::MakeUnique<cc::SurfaceIdAllocator>(
-          BrowserCompositor::AllocateSurfaceClientId())),
+BrowserCompositor::BrowserCompositor(
+    CompositorDependencies* compositor_dependencies)
+    : compositor_dependencies_(compositor_dependencies),
+      surface_id_allocator_(base::MakeUnique<cc::SurfaceIdAllocator>(
+          compositor_dependencies->AllocateSurfaceId())),
       widget_(gfx::kNullAcceleratedWidget),
       output_surface_request_pending_(false),
-      root_layer_(cc::Layer::Create()) {
-  BrowserCompositor::GetSurfaceManager()->RegisterSurfaceClientId(
+      root_layer_(cc::Layer::Create()),
+      weak_ptr_factory_(this) {
+  compositor_dependencies_->GetSurfaceManager()->RegisterSurfaceClientId(
       surface_id_allocator_->client_id());
 
   cc::LayerTreeHost::InitParams params;
   params.client = this;
   params.gpu_memory_buffer_manager =
-      BrowserCompositor::GetGpuMemoryBufferManager();
+      compositor_dependencies_->GetGpuMemoryBufferManager();
   params.task_graph_runner = g_task_graph_runner.Pointer();
   cc::LayerTreeSettings settings;
   params.settings = &settings;
@@ -113,7 +95,7 @@ BrowserCompositor::BrowserCompositor()
 }
 
 BrowserCompositor::~BrowserCompositor() {
-  BrowserCompositor::GetSurfaceManager()->InvalidateSurfaceClientId(
+  compositor_dependencies_->GetSurfaceManager()->InvalidateSurfaceClientId(
       surface_id_allocator_->client_id());
 }
 
@@ -153,34 +135,27 @@ void BrowserCompositor::SetAcceleratedWidget(gfx::AcceleratedWidget widget) {
   if (widget != gfx::kNullAcceleratedWidget) {
     widget_ = widget;
     host_->SetVisible(true);
-    if (output_surface_request_pending_)
-      HandlePendingOutputSurfaceRequest();
+    if (output_surface_request_pending_) {
+      // Request a ContextProvider now that we have a valid widget.
+      compositor_dependencies_->GetContextProvider(
+          base::Bind(&BrowserCompositor::OnContextProviderCreated,

[Khushal, 2016/08/25 05:02:53]

I didn't see this earlier, but we are creating an offscreen context here but we
actually need to create an onscreen one with the widget.

Can we avoid adding the asynchronous context callback here, have this class
create the BlimpContextProvider for itself like right now, since we know it is
always going to be the InProcess one? The OutputSurface setup doesn't need to
change really.

[David Trainor- moved to gerrit, 2016/08/26 17:15:54]

Hah yeah I ran into this this morning before I saw the comment.  Just removed
the usage of the CompositorDependencies for this context provider and built a
BlimpContextProvider, like you suggested.  Thanks!

+                     weak_ptr_factory_.GetWeakPtr()));
+    }
   }
 }
 
-void BrowserCompositor::RequestNewOutputSurface() {
-  DCHECK(!output_surface_request_pending_)
-      << "We already have a pending request?";
-  output_surface_request_pending_ = true;
-  HandlePendingOutputSurfaceRequest();
-}
-
-void BrowserCompositor::DidInitializeOutputSurface() {
-  output_surface_request_pending_ = false;
-}
+void BrowserCompositor::OnContextProviderCreated(
+    scoped_refptr<cc::ContextProvider> provider) {
+  DCHECK(output_surface_request_pending_);
 
-void BrowserCompositor::DidFailToInitializeOutputSurface() {
-  NOTREACHED() << "Can't fail to initialize the OutputSurface here";
-}
+  // TODO(dtrainor, khushalsagar): Handle ContextProvider creation failures.
+  LOG_IF(FATAL, !provider)
+      << "Failed ContextProvider requests are unsupported.";
 
-void BrowserCompositor::DidCompleteSwapBuffers() {
-  if (!did_complete_swap_buffers_.is_null()) {
-    did_complete_swap_buffers_.Run();
-  }
-}
-
-void BrowserCompositor::HandlePendingOutputSurfaceRequest() {
-  DCHECK(output_surface_request_pending_);
+  // While we were waiting we state changed and we no longer require an
+  // OutputSurface.  Bail out.
+  if (widget_ == gfx::kNullAcceleratedWidget)
+    return;
 
   // Can't handle the request right now since we don't have a widget.
   if (!host_->visible())
@@ -188,12 +163,11 @@ void BrowserCompositor::HandlePendingOutputSurfaceRequest() {
 
   DCHECK_NE(gfx::kNullAcceleratedWidget, widget_);
 
-  scoped_refptr<cc::ContextProvider> context_provider =
-      BlimpContextProvider::Create(
-          widget_, BrowserCompositor::GetGpuMemoryBufferManager());
+  gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager =
+      compositor_dependencies_->GetGpuMemoryBufferManager();
 
   std::unique_ptr<cc::OutputSurface> display_output_surface =
-      base::MakeUnique<DisplayOutputSurface>(context_provider);
+      base::MakeUnique<DisplayOutputSurface>(provider);
 
   auto* task_runner = base::ThreadTaskRunnerHandle::Get().get();
   std::unique_ptr<cc::SyntheticBeginFrameSource> begin_frame_source(
@@ -204,8 +178,7 @@ void BrowserCompositor::HandlePendingOutputSurfaceRequest() {
       display_output_surface->capabilities().max_frames_pending));
 
   display_ = base::MakeUnique<cc::Display>(
-      nullptr /*shared_bitmap_manager*/,
-      BrowserCompositor::GetGpuMemoryBufferManager(),
+      nullptr /*shared_bitmap_manager*/, gpu_memory_buffer_manager,
       host_->settings().renderer_settings, std::move(begin_frame_source),
       std::move(display_output_surface), std::move(scheduler),
       base::MakeUnique<cc::TextureMailboxDeleter>(task_runner));
@@ -215,11 +188,37 @@ void BrowserCompositor::HandlePendingOutputSurfaceRequest() {
   // The Browser compositor and display share the same context provider.
   std::unique_ptr<cc::OutputSurface> delegated_output_surface =
       base::MakeUnique<cc::SurfaceDisplayOutputSurface>(
-          BrowserCompositor::GetSurfaceManager(), surface_id_allocator_.get(),
-          display_.get(), context_provider, nullptr);
+          compositor_dependencies_->GetSurfaceManager(),
+          surface_id_allocator_.get(), display_.get(), provider, nullptr);
 
   host_->SetOutputSurface(std::move(delegated_output_surface));
 }
 
+void BrowserCompositor::RequestNewOutputSurface() {
+  DCHECK(!output_surface_request_pending_)
+      << "We already have a pending request?";
+  output_surface_request_pending_ = true;
+  if (widget_ != gfx::kNullAcceleratedWidget) {
+    // Request a ContextProvider if we have a valid widget.
+    compositor_dependencies_->GetContextProvider(
+        base::Bind(&BrowserCompositor::OnContextProviderCreated,
+                   weak_ptr_factory_.GetWeakPtr()));
+  }
+}
+
+void BrowserCompositor::DidInitializeOutputSurface() {
+  output_surface_request_pending_ = false;
+}
+
+void BrowserCompositor::DidFailToInitializeOutputSurface() {
+  NOTREACHED() << "Can't fail to initialize the OutputSurface here";
+}
+
+void BrowserCompositor::DidCompleteSwapBuffers() {
+  if (!did_complete_swap_buffers_.is_null()) {
+    did_complete_swap_buffers_.Run();
+  }
+}
+
 }  // namespace client
 }  // namespace blimp