Expose Blimp dependencies to the embedder

blimp/client/feature/compositor/blimp_compositor_manager.cc

Index: blimp/client/feature/compositor/blimp_compositor_manager.cc
diff --git a/blimp/client/feature/compositor/blimp_compositor_manager.cc b/blimp/client/feature/compositor/blimp_compositor_manager.cc
index 1e5a1c3040250d72bd1f5f5ae2a553181ec0e32b..d65e07cad30e88586affe96ef1c2b79930656273 100644
--- a/blimp/client/feature/compositor/blimp_compositor_manager.cc
+++ b/blimp/client/feature/compositor/blimp_compositor_manager.cc
@@ -4,48 +4,33 @@
 
 #include "blimp/client/feature/compositor/blimp_compositor_manager.h"
 
-#include "base/lazy_instance.h"
 #include "base/memory/ptr_util.h"
-#include "blimp/client/core/compositor/blob_image_serialization_processor.h"
-#include "blimp/client/feature/compositor/blimp_gpu_memory_buffer_manager.h"
-#include "blimp/client/feature/compositor/blimp_layer_tree_settings.h"
-#include "blimp/common/compositor/blimp_task_graph_runner.h"
+#include "blimp/client/core/compositor/blimp_compositor_dependencies.h"
 #include "cc/proto/compositor_message.pb.h"
 
 namespace blimp {
 namespace client {
 
 namespace {
-base::LazyInstance<blimp::BlimpTaskGraphRunner> g_task_graph_runner =
-    LAZY_INSTANCE_INITIALIZER;
-
 const int kDummyTabId = 0;
 }  // namespace
 
 BlimpCompositorManager::BlimpCompositorManager(
     RenderWidgetFeature* render_widget_feature,
-    cc::SurfaceManager* surface_manager,
-    BlimpGpuMemoryBufferManager* gpu_memory_buffer_manager,
-    SurfaceIdAllocationCallback callback)
+    BlimpCompositorDependencies* compositor_dependencies)
     : render_widget_feature_(render_widget_feature),
-      surface_manager_(surface_manager),
-      gpu_memory_buffer_manager_(gpu_memory_buffer_manager),
-      surface_id_allocation_callback_(callback),
       visible_(false),
       layer_(cc::Layer::Create()),
-      active_compositor_(nullptr) {
+      active_compositor_(nullptr),
+      compositor_dependencies_(compositor_dependencies) {
   DCHECK(render_widget_feature_);
-  DCHECK(surface_manager_);
-  DCHECK(gpu_memory_buffer_manager_);
-  DCHECK(!surface_id_allocation_callback_.is_null());
+  DCHECK(compositor_dependencies_);
 
   render_widget_feature_->SetDelegate(kDummyTabId, this);
 }
 
 BlimpCompositorManager::~BlimpCompositorManager() {
   render_widget_feature_->RemoveDelegate(kDummyTabId);
-  if (compositor_thread_)
-    compositor_thread_->Stop();
 }
 
 void BlimpCompositorManager::SetVisible(bool visible) {
@@ -60,26 +45,19 @@ bool BlimpCompositorManager::OnTouchEvent(const ui::MotionEvent& motion_event) {
   return false;
 }
 
-void BlimpCompositorManager::GenerateLayerTreeSettings(
-    cc::LayerTreeSettings* settings) {
-  PopulateCommonLayerTreeSettings(settings);
-}
-
 std::unique_ptr<BlimpCompositor> BlimpCompositorManager::CreateBlimpCompositor(
     int render_widget_id,
-    cc::SurfaceManager* surface_manager,
-    uint32_t surface_client_id,
+    BlimpCompositorDependencies* compositor_dependencies,
     BlimpCompositorClient* client) {
-  return base::MakeUnique<BlimpCompositor>(render_widget_id, surface_manager,
-                                           surface_client_id, client);
+  return base::MakeUnique<BlimpCompositor>(render_widget_id,
+                                           compositor_dependencies, client);
 }
 
 void BlimpCompositorManager::OnRenderWidgetCreated(int render_widget_id) {
   CHECK(!GetCompositor(render_widget_id));
 
   compositors_[render_widget_id] =
-      CreateBlimpCompositor(render_widget_id, surface_manager_,
-                            surface_id_allocation_callback_.Run(), this);
+      CreateBlimpCompositor(render_widget_id, compositor_dependencies_, this);
 }
 
 void BlimpCompositorManager::OnRenderWidgetInitialized(int render_widget_id) {
@@ -125,62 +103,6 @@ void BlimpCompositorManager::OnCompositorMessageReceived(
   compositor->OnCompositorMessageReceived(std::move(message));
 }
 
-cc::LayerTreeSettings* BlimpCompositorManager::GetLayerTreeSettings() {
-  if (!settings_) {
-    settings_.reset(new cc::LayerTreeSettings);
-
-    // TODO(khushalsagar): The server should selectively send only those
-    // LayerTreeSettings which should remain consistent across the server and
-    // client. Since it currently overrides all settings, ignore them.
-    // See crbug/577985.
-    GenerateLayerTreeSettings(settings_.get());
-    settings_
-      ->abort_commit_before_output_surface_creation = false;
-    settings_->renderer_settings.buffer_to_texture_target_map =
-        BlimpGpuMemoryBufferManager::GetDefaultBufferToTextureTargetMap();
-    settings_->use_output_surface_begin_frame_source = true;
-  }
-
-  return settings_.get();
-}
-
-scoped_refptr<base::SingleThreadTaskRunner>
-BlimpCompositorManager::GetCompositorTaskRunner() {
-  if (compositor_thread_)
-    return compositor_thread_->task_runner();
-
-  base::Thread::Options thread_options;
-#if defined(OS_ANDROID)
-  thread_options.priority = base::ThreadPriority::DISPLAY;
-#endif
-  compositor_thread_.reset(new base::Thread("Compositor"));
-  compositor_thread_->StartWithOptions(thread_options);
-
-  scoped_refptr<base::SingleThreadTaskRunner> task_runner =
-      compositor_thread_->task_runner();
-  task_runner->PostTask(
-      FROM_HERE,
-      base::Bind(base::IgnoreResult(&base::ThreadRestrictions::SetIOAllowed),
-                 false));
-  // TODO(dtrainor): Determine whether or not we can disallow waiting.
-
-  return task_runner;
-}
-
-cc::TaskGraphRunner* BlimpCompositorManager::GetTaskGraphRunner() {
-  return g_task_graph_runner.Pointer();
-}
-
-gpu::GpuMemoryBufferManager*
-BlimpCompositorManager::GetGpuMemoryBufferManager() {
-  return gpu_memory_buffer_manager_;
-}
-
-cc::ImageSerializationProcessor*
-BlimpCompositorManager::GetImageSerializationProcessor() {
-  return BlobImageSerializationProcessor::current();
-}
-
 void BlimpCompositorManager::SendWebGestureEvent(
     int render_widget_id,
     const blink::WebGestureEvent& gesture_event) {