viz: Use a simple GpuMemoryBufferManager implementation.

services/ui/gpu/gpu_main.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 "services/ui/gpu/gpu_main.h"
 
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/power_monitor/power_monitor_device_source.h"
 #include "base/single_thread_task_runner.h"
 #include "components/viz/common/server_gpu_memory_buffer_manager.h"
 #include "components/viz/service/display_compositor/gpu_display_provider.h"
 #include "components/viz/service/frame_sinks/mojo_frame_sink_manager.h"
 #include "gpu/command_buffer/common/activity_flags.h"
+#include "gpu/ipc/client/gpu_memory_buffer_impl.h"
 #include "gpu/ipc/common/gpu_memory_buffer_support.h"
 #include "gpu/ipc/gpu_in_process_thread_service.h"
 #include "gpu/ipc/service/gpu_memory_buffer_factory.h"
 #include "gpu/ipc/service/gpu_watchdog_thread.h"
 #include "services/ui/gpu/gpu_service.h"
 
 #if defined(USE_OZONE)
 #include "ui/ozone/public/ozone_platform.h"
 #endif
 
@@ skipping 11 matching lines @@
       base::MessageLoop::TYPE_DEFAULT);
 }
 #endif  // defined(USE_X11)
 
 #if defined(OS_MACOSX)
 std::unique_ptr<base::MessagePump> CreateMessagePumpMac() {
   return base::MakeUnique<base::MessagePumpCFRunLoop>();
 }
 #endif  // defined(OS_MACOSX)
 
+class InProcessGpuMemoryBufferManager : public gpu::GpuMemoryBufferManager {

[Fady Samuel, 2017/06/16 22:33:17]

Move this to a separate file please

+ public:
+  InProcessGpuMemoryBufferManager(gpu::GpuChannelManager* channel_manager,
+                                  gpu::GpuMemoryBufferFactory* memory_factory)
+      : client_id_(1),
+        channel_manager_(channel_manager),
+        memory_factory_(memory_factory),
+        weak_factory_(this) {
+    weak_ptr_ = weak_factory_.GetWeakPtr();
+  }
+
+  ~InProcessGpuMemoryBufferManager() override {}
+
+ private:
+  void DestroyGpuMemoryBuffer(gfx::GpuMemoryBufferId id,
+                              int client_id,
+                              const gpu::SyncToken& sync_token) {
+    channel_manager_->DestroyGpuMemoryBuffer(id, client_id, sync_token);
+  }
+
+  // gpu::GpuMemoryBufferManager:
+  std::unique_ptr<gfx::GpuMemoryBuffer> CreateGpuMemoryBuffer(
+      const gfx::Size& size,
+      gfx::BufferFormat format,
+      gfx::BufferUsage usage,
+      gpu::SurfaceHandle surface_handle) override {
+    gfx::GpuMemoryBufferId id(next_gpu_memory_id_++);
+    gfx::GpuMemoryBufferHandle buffer_handle =
+        memory_factory_->CreateGpuMemoryBuffer(id, size, format, usage,
+                                               client_id_, surface_handle);
+    return gpu::GpuMemoryBufferImpl::CreateFromHandle(
+        buffer_handle, size, format, usage,
+        base::Bind(&InProcessGpuMemoryBufferManager::DestroyGpuMemoryBuffer,
+                   weak_ptr_, id, client_id_));
+  }
+
+  void SetDestructionSyncToken(gfx::GpuMemoryBuffer* buffer,
+                               const gpu::SyncToken& sync_token) override {
+    static_cast<gpu::GpuMemoryBufferImpl*>(buffer)->set_destruction_sync_token(
+        sync_token);
+  }
+
+  const int client_id_;
+  int next_gpu_memory_id_ = 1;
+  gpu::GpuChannelManager* channel_manager_;
+  gpu::GpuMemoryBufferFactory* memory_factory_;
+  base::WeakPtr<InProcessGpuMemoryBufferManager> weak_ptr_;
+  base::WeakPtrFactory<InProcessGpuMemoryBufferManager> weak_factory_;
+  DISALLOW_COPY_AND_ASSIGN(InProcessGpuMemoryBufferManager);
+};
+
 }  // namespace
 
 namespace ui {
 
 GpuMain::GpuMain(mojom::GpuMainRequest request)
     : gpu_thread_("GpuThread"),
       io_thread_("GpuIOThread"),
       compositor_thread_("DisplayCompositorThread"),
       power_monitor_(base::MakeUnique<base::PowerMonitorDeviceSource>()),
       binding_(this) {
@@ skipping 111 matching lines @@
     cc::mojom::FrameSinkManagerRequest request,
     cc::mojom::FrameSinkManagerClientPtrInfo client_info) {
   DCHECK(!gpu_command_service_);
   DCHECK(gpu_service_);
   DCHECK(gpu_thread_task_runner_->BelongsToCurrentThread());
   gpu_command_service_ = new gpu::GpuInProcessThreadService(
       gpu_thread_task_runner_, gpu_service_->sync_point_manager(),
       gpu_service_->mailbox_manager(), gpu_service_->share_group());
 
   gpu::ImageFactory* image_factory = gpu_service_->gpu_image_factory();
-
-  // If the FrameSinkManager creation was delayed because GpuService had not
-  // been created yet, then this is called, in gpu thread, right after
-  // GpuService is created.
-  mojom::GpuServicePtr gpu_service;
-  BindGpuInternalOnGpuThread(mojo::MakeRequest(&gpu_service));
   compositor_thread_task_runner_->PostTask(
       FROM_HERE, base::Bind(&GpuMain::CreateFrameSinkManagerOnCompositorThread,
                             base::Unretained(this), image_factory,
-                            base::Passed(gpu_service.PassInterface()),
                             base::Passed(std::move(request)),
                             base::Passed(std::move(client_info))));
 }
 
 void GpuMain::CreateFrameSinkManagerOnCompositorThread(
     gpu::ImageFactory* image_factory,
-    mojom::GpuServicePtrInfo gpu_service_info,
     cc::mojom::FrameSinkManagerRequest request,
     cc::mojom::FrameSinkManagerClientPtrInfo client_info) {
   DCHECK(!frame_sink_manager_);
   cc::mojom::FrameSinkManagerClientPtr client;
   client.Bind(std::move(client_info));
 
-  gpu_internal_.Bind(std::move(gpu_service_info));
-
   display_provider_ = base::MakeUnique<viz::GpuDisplayProvider>(
       gpu_command_service_,
-      base::MakeUnique<viz::ServerGpuMemoryBufferManager>(gpu_internal_.get(),
-                                                          1 /* client_id */),
+      base::MakeUnique<InProcessGpuMemoryBufferManager>(
+          gpu_service_->gpu_channel_manager(),
+          gpu_service_->gpu_memory_buffer_factory()),
       image_factory);
 
   frame_sink_manager_ = base::MakeUnique<viz::MojoFrameSinkManager>(
       true, display_provider_.get());
   frame_sink_manager_->BindPtrAndSetClient(std::move(request),
                                            std::move(client));
 }
 
 void GpuMain::TearDownOnCompositorThread() {
   frame_sink_manager_.reset();
   display_provider_.reset();
-  gpu_internal_.reset();
 }
 
 void GpuMain::TearDownOnGpuThread() {
   binding_.Close();
   gpu_service_.reset();
   gpu_memory_buffer_factory_.reset();
   gpu_init_.reset();
 }
 
 void GpuMain::CreateGpuServiceOnGpuThread(
     mojom::GpuServiceRequest request,
     mojom::GpuHostPtr gpu_host,
     const gpu::GpuPreferences& preferences,
     gpu::GpuProcessActivityFlags activity_flags) {
   gpu_service_->UpdateGPUInfoFromPreferences(preferences);
   gpu_service_->InitializeWithHost(std::move(gpu_host),
                                    std::move(activity_flags));
   gpu_service_->Bind(std::move(request));
 
   if (pending_frame_sink_manager_request_.is_pending()) {
     CreateFrameSinkManagerInternal(
         std::move(pending_frame_sink_manager_request_),
         std::move(pending_frame_sink_manager_client_info_));
   }
 }
 
-void GpuMain::BindGpuInternalOnGpuThread(mojom::GpuServiceRequest request) {
-  gpu_service_->Bind(std::move(request));
-}
-
 void GpuMain::PreSandboxStartup() {
   // TODO(sad): https://crbug.com/645602
 }
 
 bool GpuMain::EnsureSandboxInitialized(
     gpu::GpuWatchdogThread* watchdog_thread) {
   // TODO(sad): https://crbug.com/645602
   return true;
 }
 
 }  // namespace ui