Move GpuMemoryBufferManager and SharedBitmapManager to CompositorFrameSink

content/browser/compositor/gpu_process_transport_factory.cc

 // Copyright 2014 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 "content/browser/compositor/gpu_process_transport_factory.h"
 
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 496 matching lines @@
         if (!use_mus) {
           display_output_surface =
               base::MakeUnique<GpuBrowserCompositorOutputSurface>(
                   context_provider, compositor->vsync_manager(),
                   begin_frame_source.get(), std::move(validator));
         } else {
 #if defined(USE_AURA)
           display_output_surface =
               base::MakeUnique<MusBrowserCompositorOutputSurface>(
                   compositor->window(), context_provider,
-                  compositor->vsync_manager(), begin_frame_source.get(),
-                  std::move(validator));
+                  GetGpuMemoryBufferManager(), compositor->vsync_manager(),
+                  begin_frame_source.get(), std::move(validator));
 #else
           NOTREACHED();
 #endif
         }
       }
     }
   }
 
   data->display_output_surface = display_output_surface.get();
   data->begin_frame_source = begin_frame_source.get();
@@ skipping 24 matching lines @@
   auto compositor_frame_sink =
       vulkan_context_provider
           ? base::MakeUnique<cc::DirectCompositorFrameSink>(
                 compositor->frame_sink_id(), surface_manager_.get(),
                 data->display.get(),
                 static_cast<scoped_refptr<cc::VulkanContextProvider>>(
                     vulkan_context_provider))
           : base::MakeUnique<cc::DirectCompositorFrameSink>(
                 compositor->frame_sink_id(), surface_manager_.get(),
                 data->display.get(), context_provider,
-                shared_worker_context_provider_);
+                shared_worker_context_provider_, GetGpuMemoryBufferManager(),
+                HostSharedBitmapManager::current());
   data->display->Resize(compositor->size());
   data->display->SetOutputIsSecure(data->output_is_secure);
   compositor->SetCompositorFrameSink(std::move(compositor_frame_sink));
 }
 
 std::unique_ptr<ui::Reflector> GpuProcessTransportFactory::CreateReflector(
     ui::Compositor* source_compositor,
     ui::Layer* target_layer) {
   PerCompositorData* source_data =
       per_compositor_data_[source_compositor].get();
@@ skipping 52 matching lines @@
 }
 
 bool GpuProcessTransportFactory::DoesCreateTestContexts() { return false; }
 
 uint32_t GpuProcessTransportFactory::GetImageTextureTarget(
     gfx::BufferFormat format,
     gfx::BufferUsage usage) {
   return BrowserGpuMemoryBufferManager::GetImageTextureTarget(format, usage);
 }
 
-cc::SharedBitmapManager* GpuProcessTransportFactory::GetSharedBitmapManager() {
-  return HostSharedBitmapManager::current();
-}
-
 gpu::GpuMemoryBufferManager*
 GpuProcessTransportFactory::GetGpuMemoryBufferManager() {
   return gpu_channel_factory_->GetGpuMemoryBufferManager();
 }
 
 cc::TaskGraphRunner* GpuProcessTransportFactory::GetTaskGraphRunner() {
   return task_graph_runner_.get();
 }
 
 ui::ContextFactory* GpuProcessTransportFactory::GetContextFactory() {
@@ skipping 221 matching lines @@
       shared_vulkan_context_provider_ =
           cc::VulkanInProcessContextProvider::Create();
     }
 
     shared_vulkan_context_provider_initialized_ = true;
   }
   return shared_vulkan_context_provider_;
 }
 
 }  // namespace content