viz: Use a simple GpuMemoryBufferManager implementation.

components/viz/service/display_compositor/gpu_display_provider.cc

 // Copyright 2017 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 "components/viz/service/display_compositor/gpu_display_provider.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "cc/base/switches.h"
 #include "cc/output/in_process_context_provider.h"
 #include "cc/output/texture_mailbox_deleter.h"
 #include "cc/scheduler/begin_frame_source.h"
 #include "cc/surfaces/display.h"
 #include "cc/surfaces/display_scheduler.h"
 #include "components/viz/service/display_compositor/display_output_surface.h"
 #include "components/viz/service/display_compositor/host_shared_bitmap_manager.h"
+#include "components/viz/service/display_compositor/in_process_gpu_memory_buffer_manager.h"
 #include "gpu/command_buffer/client/shared_memory_limits.h"
 #include "gpu/command_buffer/service/image_factory.h"
+#include "gpu/ipc/service/gpu_channel_manager.h"
+#include "gpu/ipc/service/gpu_memory_buffer_factory.h"
 
 #if defined(USE_OZONE)
 #include "components/viz/service/display_compositor/display_output_surface_ozone.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #endif
 
+namespace {
+
+gpu::ImageFactory* GetImageFactory(gpu::GpuChannelManager* channel_manager) {
+  auto* buffer_factory = channel_manager->gpu_memory_buffer_factory();
+  return buffer_factory ? buffer_factory->AsImageFactory() : nullptr;
+}
+
+}  // namespace
+
 namespace viz {
 
 GpuDisplayProvider::GpuDisplayProvider(
     scoped_refptr<gpu::InProcessCommandBuffer::Service> gpu_service,
-    std::unique_ptr<gpu::GpuMemoryBufferManager> gpu_memory_buffer_manager,
-    gpu::ImageFactory* image_factory)
+    gpu::GpuChannelManager* gpu_channel_manager)
     : gpu_service_(std::move(gpu_service)),
-      gpu_memory_buffer_manager_(std::move(gpu_memory_buffer_manager)),
-      image_factory_(image_factory),
+      gpu_memory_buffer_manager_(
+          base::MakeUnique<InProcessGpuMemoryBufferManager>(
+              gpu_channel_manager)),
+      image_factory_(GetImageFactory(gpu_channel_manager)),
       task_runner_(base::ThreadTaskRunnerHandle::Get()) {}
 
 GpuDisplayProvider::~GpuDisplayProvider() = default;
 
 std::unique_ptr<cc::Display> GpuDisplayProvider::CreateDisplay(
     const cc::FrameSinkId& frame_sink_id,
     gpu::SurfaceHandle surface_handle,
     std::unique_ptr<cc::BeginFrameSource>* begin_frame_source) {
   auto synthetic_begin_frame_source =
       base::MakeUnique<cc::DelayBasedBeginFrameSource>(
@@ skipping 40 matching lines @@
   *begin_frame_source = std::move(synthetic_begin_frame_source);
 
   return base::MakeUnique<cc::Display>(
       HostSharedBitmapManager::current(), gpu_memory_buffer_manager_.get(),
       settings, frame_sink_id, std::move(display_output_surface),
       std::move(scheduler),
       base::MakeUnique<cc::TextureMailboxDeleter>(task_runner_.get()));
 }
 
 }  // namespace viz