Move GpuMemoryBufferManager and SharedBitmapManager to CompositorFrameSink

cc/test/layer_tree_test.cc

 // Copyright 2011 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 "cc/test/layer_tree_test.h"
 
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
@@ skipping 80 matching lines @@
 }
 
 // Adapts LayerTreeHostImpl for test. Runs real code, then invokes test hooks.
 class LayerTreeHostImplForTesting : public LayerTreeHostImpl {
  public:
   static std::unique_ptr<LayerTreeHostImplForTesting> Create(
       TestHooks* test_hooks,
       const LayerTreeSettings& settings,
       LayerTreeHostImplClient* host_impl_client,
       TaskRunnerProvider* task_runner_provider,
-      SharedBitmapManager* shared_bitmap_manager,
-      gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
       TaskGraphRunner* task_graph_runner,
       RenderingStatsInstrumentation* stats_instrumentation) {
     return base::WrapUnique(new LayerTreeHostImplForTesting(
         test_hooks, settings, host_impl_client, task_runner_provider,
-        shared_bitmap_manager, gpu_memory_buffer_manager, task_graph_runner,
-        stats_instrumentation));
+        task_graph_runner, stats_instrumentation));
   }
 
  protected:
   LayerTreeHostImplForTesting(
       TestHooks* test_hooks,
       const LayerTreeSettings& settings,
       LayerTreeHostImplClient* host_impl_client,
       TaskRunnerProvider* task_runner_provider,
-      SharedBitmapManager* shared_bitmap_manager,
-      gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
       TaskGraphRunner* task_graph_runner,
       RenderingStatsInstrumentation* stats_instrumentation)
       : LayerTreeHostImpl(settings,
                           host_impl_client,
                           task_runner_provider,
                           stats_instrumentation,
-                          shared_bitmap_manager,
-                          gpu_memory_buffer_manager,
                           task_graph_runner,
                           AnimationHost::CreateForTesting(ThreadInstance::IMPL),
                           0),
         test_hooks_(test_hooks),
         block_notify_ready_to_activate_for_testing_(false),
         notify_ready_to_activate_was_blocked_(false) {}
 
   void CreateResourceAndRasterBufferProvider(
       std::unique_ptr<RasterBufferProvider>* raster_buffer_provider,
       std::unique_ptr<ResourcePool>* resource_pool) override {
@@ skipping 203 matching lines @@
 };
 
 // Adapts LayerTreeHost for test. Injects LayerTreeHostImplForTesting.
 class LayerTreeHostForTesting : public LayerTreeHostInProcess {
  public:
   static std::unique_ptr<LayerTreeHostForTesting> Create(
       TestHooks* test_hooks,
       CompositorMode mode,
       LayerTreeHostClient* client,
       LayerTreeHostSingleThreadClient* single_thread_client,
-      SharedBitmapManager* shared_bitmap_manager,
-      gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
       TaskGraphRunner* task_graph_runner,
       const LayerTreeSettings& settings,
       scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner) {
     LayerTreeHostInProcess::InitParams params;
     params.client = client;
-    params.shared_bitmap_manager = shared_bitmap_manager;
-    params.gpu_memory_buffer_manager = gpu_memory_buffer_manager;
     params.task_graph_runner = task_graph_runner;
     params.settings = &settings;
 
     params.animation_host =
         AnimationHost::CreateForTesting(ThreadInstance::MAIN);
     std::unique_ptr<LayerTreeHostForTesting> layer_tree_host(
         new LayerTreeHostForTesting(test_hooks, &params, mode));
     std::unique_ptr<TaskRunnerProvider> task_runner_provider =
         TaskRunnerProvider::Create(main_task_runner, impl_task_runner);
     std::unique_ptr<Proxy> proxy;
@@ skipping 14 matching lines @@
     layer_tree_host->InitializeForTesting(std::move(task_runner_provider),
                                           std::move(proxy));
     return layer_tree_host;
   }
 
   std::unique_ptr<LayerTreeHostImpl> CreateLayerTreeHostImpl(
       LayerTreeHostImplClient* host_impl_client) override {
     std::unique_ptr<LayerTreeHostImpl> host_impl =
         LayerTreeHostImplForTesting::Create(
             test_hooks_, GetSettings(), host_impl_client,
-            GetTaskRunnerProvider(), shared_bitmap_manager(),
-            gpu_memory_buffer_manager(), task_graph_runner(),
+            GetTaskRunnerProvider(), task_graph_runner(),
             rendering_stats_instrumentation());
     input_handler_weak_ptr_ = host_impl->AsWeakPtr();
     return host_impl;
   }
 
   void SetNeedsCommit() override {
     if (!test_started_)
       return;
     LayerTreeHostInProcess::SetNeedsCommit();
   }
@@ skipping 20 matching lines @@
 
 // Adapts the LayerTreeHostRemoteForTesting to inject the
 // LayerTreeHostInProcess.
 class LayerTreeHostRemoteForLayerTreeTest
     : public LayerTreeHostRemoteForTesting {
  public:
   static std::unique_ptr<LayerTreeHostRemoteForLayerTreeTest> Create(
       TestHooks* test_hooks,
       LayerTreeHostClient* client,
       LayerTreeSettings const* settings,
-      SharedBitmapManager* shared_bitmap_manager,
-      gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
       TaskGraphRunner* task_graph_runner,
       scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner) {
     std::unique_ptr<FakeImageSerializationProcessor>
         image_serialization_processor =
             base::MakeUnique<FakeImageSerializationProcessor>();
 
     LayerTreeHostRemote::InitParams params;
     params.client = client;
     params.main_task_runner = main_task_runner;
     params.animation_host =
         AnimationHost::CreateForTesting(ThreadInstance::MAIN);
     params.remote_compositor_bridge =
         CreateRemoteCompositorBridge(main_task_runner);
     params.engine_picture_cache =
         image_serialization_processor->CreateEnginePictureCache();
     params.settings = settings;
 
     std::unique_ptr<LayerTreeHostRemoteForLayerTreeTest> layer_tree_host =
         base::WrapUnique(
             new LayerTreeHostRemoteForLayerTreeTest(&params, test_hooks));
-    layer_tree_host->Initialize(shared_bitmap_manager,
-                                gpu_memory_buffer_manager, task_graph_runner,
-                                main_task_runner, impl_task_runner,
+    layer_tree_host->Initialize(task_graph_runner, main_task_runner,
+                                impl_task_runner,
                                 std::move(image_serialization_processor));
     return layer_tree_host;
   }
 
   ~LayerTreeHostRemoteForLayerTreeTest() override = default;
 
   std::unique_ptr<LayerTreeHostInProcess> CreateLayerTreeHostInProcess(
       LayerTreeHostClient* client,
-      SharedBitmapManager* shared_bitmap_manager,
-      gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
       TaskGraphRunner* task_graph_runner,
       const LayerTreeSettings& settings,
       scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner) override {
     return LayerTreeHostForTesting::Create(
         test_hooks_, CompositorMode::THREADED, client, nullptr,
-        shared_bitmap_manager, gpu_memory_buffer_manager, task_graph_runner,
-        settings, main_task_runner, impl_task_runner);
+        task_graph_runner, settings, main_task_runner, impl_task_runner);
   }
 
  private:
   LayerTreeHostRemoteForLayerTreeTest(InitParams* params, TestHooks* test_hooks)
       : LayerTreeHostRemoteForTesting(params), test_hooks_(test_hooks) {}
 
   TestHooks* test_hooks_;
 };
 
 class LayerTreeTestCompositorFrameSinkClient
@@ skipping 175 matching lines @@
 
   DCHECK(!impl_thread_ || impl_thread_->task_runner().get());
 
   scoped_refptr<base::SingleThreadTaskRunner> main_task_runner =
       base::ThreadTaskRunnerHandle::Get();
   scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner =
       impl_thread_ ? impl_thread_->task_runner() : nullptr;
   if (IsRemoteTest()) {
     std::unique_ptr<LayerTreeHostRemoteForLayerTreeTest>
         layer_tree_host_remote = LayerTreeHostRemoteForLayerTreeTest::Create(
-            this, client_.get(), &settings_, shared_bitmap_manager_.get(),
-            gpu_memory_buffer_manager_.get(), task_graph_runner_.get(),
+            this, client_.get(), &settings_, task_graph_runner_.get(),
             main_task_runner, impl_task_runner);
     layer_tree_host_in_process_ =
         layer_tree_host_remote->layer_tree_host_in_process();
     layer_tree_host_ = std::move(layer_tree_host_remote);
   } else {
     std::unique_ptr<LayerTreeHostForTesting> layer_tree_host_for_testing =
         LayerTreeHostForTesting::Create(
-            this, mode_, client_.get(), client_.get(),
-            shared_bitmap_manager_.get(), gpu_memory_buffer_manager_.get(),
-            task_graph_runner_.get(), settings_, main_task_runner,
-            impl_task_runner);
+            this, mode_, client_.get(), client_.get(), task_graph_runner_.get(),
+            settings_, main_task_runner, impl_task_runner);
     layer_tree_host_in_process_ = layer_tree_host_for_testing.get();
     layer_tree_host_ = std::move(layer_tree_host_for_testing);
   }
 
   ASSERT_TRUE(layer_tree_host_);
 
   main_task_runner_ =
       layer_tree_host_->GetTaskRunnerProvider()->MainThreadTaskRunner();
   impl_task_runner_ =
       layer_tree_host_->GetTaskRunnerProvider()->ImplThreadTaskRunner();
@@ skipping 235 matching lines @@
   DCHECK(!IsRemoteTest());
   return layer_tree_host_in_process_;
 }
 
 Proxy* LayerTreeTest::proxy() {
   return layer_tree_host_in_process() ? layer_tree_host_in_process()->proxy()
                                       : NULL;
 }
 
 }  // namespace cc