viz: Use a simple GpuMemoryBufferManager implementation.

services/ui/gpu/gpu_main.cc

Index: services/ui/gpu/gpu_main.cc
diff --git a/services/ui/gpu/gpu_main.cc b/services/ui/gpu/gpu_main.cc
index e590b355ac22ca6a93f94c3cd01a345626b7623f..62824bce4ae381a633d72e58e78579eff18f3f21 100644
--- a/services/ui/gpu/gpu_main.cc
+++ b/services/ui/gpu/gpu_main.cc
@@ -13,6 +13,7 @@
 #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"
@@ -44,6 +45,57 @@ std::unique_ptr<base::MessagePump> CreateMessagePumpMac() {
 }
 #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 {
@@ -175,35 +227,26 @@ void GpuMain::CreateFrameSinkManagerInternal(
       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>(
@@ -215,7 +258,6 @@ void GpuMain::CreateFrameSinkManagerOnCompositorThread(
 void GpuMain::TearDownOnCompositorThread() {
   frame_sink_manager_.reset();
   display_provider_.reset();
-  gpu_internal_.reset();
 }
 
 void GpuMain::TearDownOnGpuThread() {
@@ -242,10 +284,6 @@ void GpuMain::CreateGpuServiceOnGpuThread(
   }
 }
 
-void GpuMain::BindGpuInternalOnGpuThread(mojom::GpuServiceRequest request) {
-  gpu_service_->Bind(std::move(request));
-}
-
 void GpuMain::PreSandboxStartup() {
   // TODO(sad): https://crbug.com/645602
 }