Move GpuMemoryBufferManager and SharedBitmapManager to CompositorFrameSink

cc/test/layer_tree_host_remote_for_testing.h

 // 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.
 
 #ifndef CC_TEST_LAYER_TREE_HOST_REMOTE_FOR_TESTING_H_
 #define CC_TEST_LAYER_TREE_HOST_REMOTE_FOR_TESTING_H_
 
 #include "base/macros.h"
 #include "cc/blimp/compositor_state_deserializer_client.h"
 #include "cc/blimp/layer_tree_host_remote.h"
@@ skipping 13 matching lines @@
 // This is a version of LayerTreeHostRemote meant to be used for tests that want
 // to inspect the CompositorFrame produced when state updates from the remote
 // host are used by a compositor on the client.
 class LayerTreeHostRemoteForTesting : public LayerTreeHostRemote,
                                       public CompositorStateDeserializerClient {
  public:
   static std::unique_ptr<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);
 
   static std::unique_ptr<RemoteCompositorBridge> CreateRemoteCompositorBridge(
       scoped_refptr<base::SingleThreadTaskRunner> main_task_runner);
 
   ~LayerTreeHostRemoteForTesting() override;
 
   // LayerTreeHost interface.
   void SetVisible(bool visible) override;
   void SetCompositorFrameSink(
       std::unique_ptr<CompositorFrameSink> compositor_frame_sink) override;
   std::unique_ptr<CompositorFrameSink> ReleaseCompositorFrameSink() override;
   void SetNeedsRedrawRect(const gfx::Rect& damage_rect) override;
   void SetNextCommitForcesRedraw() override;
   void NotifyInputThrottledUntilCommit() override;
   const base::WeakPtr<InputHandler>& GetInputHandler() const override;
 
   LayerTreeHostInProcess* layer_tree_host_in_process() const {
     return layer_tree_host_in_process_.get();
   }
 
  protected:
   explicit LayerTreeHostRemoteForTesting(InitParams* params);
 
-  void Initialize(SharedBitmapManager* shared_bitmap_manager,
-                  gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
-                  TaskGraphRunner* task_graph_runner,
+  void Initialize(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);
 
   virtual 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);
 
  private:
   class LayerTreeHostInProcessClient;
   class RemoteCompositorBridgeImpl;
 
   // CompositorStateDeserializerClient implementation.
@@ skipping 21 matching lines @@
 
   std::unique_ptr<FakeImageSerializationProcessor>
       image_serialization_processor_;
 
   DISALLOW_COPY_AND_ASSIGN(LayerTreeHostRemoteForTesting);
 };
 
 }  // namespace cc
 
 #endif  // CC_TEST_LAYER_TREE_HOST_REMOTE_FOR_TESTING_H_