Expose Blimp dependencies to the embedder

blimp/client/app/compositor/browser_compositor.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 "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"
 #include "cc/output/texture_mailbox_deleter.h"
 #include "cc/raster/single_thread_task_graph_runner.h"
 #include "cc/surfaces/display.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 "gpu/command_buffer/client/context_support.h"
+#include "gpu/command_buffer/client/gles2_lib.h"
 
 namespace blimp {
 namespace client {
 
 namespace {
 
 class SimpleTaskGraphRunner : public cc::SingleThreadTaskGraphRunner {
  public:
   SimpleTaskGraphRunner() {
     Start("BlimpBrowserCompositorWorker",
@@ skipping 12 matching lines @@
   ~DisplayOutputSurface() override {}
 
   // cc::OutputSurface implementation
   void SwapBuffers(cc::CompositorFrame frame) override {
     // See cc::OutputSurface::SwapBuffers() comment for details.
     context_provider_->ContextSupport()->Swap();
     cc::OutputSurface::PostSwapBuffersComplete();
   }
 
   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:
   DISALLOW_COPY_AND_ASSIGN(DisplayOutputSurface);
 };
 
 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;
   params.main_task_runner = base::ThreadTaskRunnerHandle::Get();
   params.animation_host = cc::AnimationHost::CreateMainInstance();
   host_ = cc::LayerTreeHost::CreateSingleThreaded(this, &params);
 
   root_layer_->SetBackgroundColor(SK_ColorWHITE);
   host_->GetLayerTree()->SetRootLayer(root_layer_);
   host_->set_surface_client_id(surface_id_allocator_->client_id());
 }
 
 BrowserCompositor::~BrowserCompositor() {
-  BrowserCompositor::GetSurfaceManager()->InvalidateSurfaceClientId(
+  compositor_dependencies_->GetSurfaceManager()->InvalidateSurfaceClientId(
       surface_id_allocator_->client_id());
 }
 
 void BrowserCompositor::SetContentLayer(
     scoped_refptr<cc::Layer> content_layer) {
   root_layer_->RemoveAllChildren();
   root_layer_->AddChild(content_layer);
 }
 
 void BrowserCompositor::SetSize(const gfx::Size& size_in_px) {
@@ skipping 19 matching lines @@
       host_->ReleaseOutputSurface();
     }
     display_.reset();
   }
 
   widget_ = gfx::kNullAcceleratedWidget;
 
   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::OnContextProviderCreated(
+    scoped_refptr<cc::ContextProvider> provider) {
+  DCHECK(output_surface_request_pending_);
 
-void BrowserCompositor::DidInitializeOutputSurface() {
-  output_surface_request_pending_ = false;
-}
+  // TODO(dtrainor, khushalsagar): Handle ContextProvider creation failures.
+  LOG_IF(FATAL, !provider)
+      << "Failed ContextProvider requests are unsupported.";
 
-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();
-  }
-}
-
-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())
     return;
 
   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(
       new cc::DelayBasedBeginFrameSource(
           base::MakeUnique<cc::DelayBasedTimeSource>(task_runner)));
   std::unique_ptr<cc::DisplayScheduler> scheduler(new cc::DisplayScheduler(
       begin_frame_source.get(), task_runner,
       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));
   display_->SetVisible(true);
   display_->Resize(viewport_size_in_px_);
 
   // 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