Move GpuMemoryBufferManager and SharedBitmapManager to CompositorFrameSink

cc/test/layer_tree_host_remote_for_testing.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 "cc/test/layer_tree_host_remote_for_testing.h"
 
 #include "base/memory/ptr_util.h"
 #include "cc/animation/animation_host.h"
 #include "cc/blimp/compositor_proto_state.h"
 #include "cc/blimp/compositor_state_deserializer.h"
@@ skipping 95 matching lines @@
   return base::MakeUnique<RemoteCompositorBridgeImpl>(
       std::move(main_task_runner));
 }
 
 // static
 std::unique_ptr<LayerTreeHostRemoteForTesting>
 LayerTreeHostRemoteForTesting::Create(
     LayerTreeHostClient* client,
     std::unique_ptr<AnimationHost> animation_host,
     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 = std::move(animation_host);
   params.remote_compositor_bridge =
       CreateRemoteCompositorBridge(main_task_runner);
   params.engine_picture_cache =
       image_serialization_processor->CreateEnginePictureCache();
   params.settings = settings;
 
   std::unique_ptr<LayerTreeHostRemoteForTesting> layer_tree_host =
       base::WrapUnique(new LayerTreeHostRemoteForTesting(&params));
-  layer_tree_host->Initialize(shared_bitmap_manager, gpu_memory_buffer_manager,
-                              task_graph_runner, main_task_runner,
+  layer_tree_host->Initialize(task_graph_runner, main_task_runner,
                               impl_task_runner,
                               std::move(image_serialization_processor));
   return layer_tree_host;
 }
 
 LayerTreeHostRemoteForTesting::LayerTreeHostRemoteForTesting(InitParams* params)
     : LayerTreeHostRemote(params),
       layer_tree_host_in_process_client_(
           base::MakeUnique<LayerTreeHostInProcessClient>(this)) {}
 
@@ skipping 38 matching lines @@
   // Pass through because the InProcessHost has the input handler.
   layer_tree_host_in_process_->NotifyInputThrottledUntilCommit();
 }
 
 const base::WeakPtr<InputHandler>&
 LayerTreeHostRemoteForTesting::GetInputHandler() const {
   return layer_tree_host_in_process_->GetInputHandler();
 }
 
 void LayerTreeHostRemoteForTesting::Initialize(
-    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) {
   image_serialization_processor_ = std::move(image_serialization_processor);
   RemoteCompositorBridgeImpl* remote_compositor_bridge_impl =
       static_cast<RemoteCompositorBridgeImpl*>(remote_compositor_bridge());
   remote_compositor_bridge_impl->SetRemoteHost(this);
 
   layer_tree_host_in_process_ = CreateLayerTreeHostInProcess(
-      layer_tree_host_in_process_client_.get(), shared_bitmap_manager,
-      gpu_memory_buffer_manager, task_graph_runner, GetSettings(),
-      main_task_runner, impl_task_runner);
+      layer_tree_host_in_process_client_.get(), task_graph_runner,
+      GetSettings(), main_task_runner, impl_task_runner);
 
   compositor_state_deserializer_ =
       base::MakeUnique<CompositorStateDeserializer>(
           layer_tree_host_in_process_.get(),
           image_serialization_processor_->CreateClientPictureCache(),
           base::Bind(&LayerTreeHostRemoteForTesting::LayerDidScroll,
                      base::Unretained(this)),
           this);
 
   // Override the LayerFactory since a lot of tests rely on the fact that Layers
   // and LayerImpls have matching ids.
   compositor_state_deserializer_->SetLayerFactoryForTesting(
       base::MakeUnique<RemoteClientLayerFactory>());
 
   // Override the TaskRunnerProvider since tests may rely on accessing the impl
   // task runner using it.
   SetTaskRunnerProviderForTesting(
       TaskRunnerProvider::Create(main_task_runner, impl_task_runner));
 }
 
 std::unique_ptr<LayerTreeHostInProcess>
 LayerTreeHostRemoteForTesting::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) {
   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.main_task_runner = main_task_runner;
   params.animation_host = AnimationHost::CreateMainInstance();
 
   return LayerTreeHostInProcess::CreateThreaded(impl_task_runner, &params);
 }
 
 void LayerTreeHostRemoteForTesting::DispatchDrawAndSubmitCallbacks() {
   // Don't dispatch callbacks right after the commit on the remote host. Since
@@ skipping 56 matching lines @@
   }
 
   // The only case where the remote host would give a compositor update is if
   // they wanted the main frame to go till the commit pipeline stage. So
   // request one to make sure that the in process main frame also goes till
   // the commit step.
   layer_tree_host_in_process_->SetNeedsCommit();
 }
 
 }  // namespace cc