gpu: Refactor memory buffer handling code out of content.

services/ui/public/cpp/mojo_gpu_memory_buffer_manager.cc

 // Copyright 2015 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/public/cpp/mojo_gpu_memory_buffer_manager.h"
 
 #include "base/logging.h"
+#include "base/synchronization/waitable_event.h"
+#include "gpu/ipc/client/gpu_memory_buffer_impl.h"
+#include "mojo/public/cpp/bindings/sync_call_restrictions.h"
+#include "services/service_manager/public/cpp/connector.h"
+#include "services/ui/common/generic_shared_memory_id_generator.h"
 #include "services/ui/public/cpp/mojo_gpu_memory_buffer.h"
 
 namespace ui {
 
-MojoGpuMemoryBufferManager::MojoGpuMemoryBufferManager() {}
+namespace {
+
+#if 1  // !defined(OS_WIN)
+void DeletedGpuMemoryBuffer(gfx::GpuMemoryBufferId id,
+                            const gpu::SyncToken& sync_token) {
+  NOTIMPLEMENTED();
+}
+#endif  // !defined(OS_WIN)
+
+}  // namespace
+
+MojoGpuMemoryBufferManager::MojoGpuMemoryBufferManager(
+    mojom::GpuService* gpu_service)
+    : main_task_runner_(base::ThreadTaskRunnerHandle::Get()),
+      gpu_service_(gpu_service) {}
 
 MojoGpuMemoryBufferManager::~MojoGpuMemoryBufferManager() {}
 
 std::unique_ptr<gfx::GpuMemoryBuffer>
 MojoGpuMemoryBufferManager::AllocateGpuMemoryBuffer(
     const gfx::Size& size,
     gfx::BufferFormat format,
     gfx::BufferUsage usage,
     gpu::SurfaceHandle surface_handle) {
+#if defined(OS_WIN)
+  // TODO(sad): Because the host needs a valid base::ProcessHandle to this
+  // client.
   return MojoGpuMemoryBufferImpl::Create(size, format, usage);
+#else
+#if 1
+  DCHECK(!main_task_runner_->BelongsToCurrentThread());
+  base::WaitableEvent event(base::WaitableEvent::ResetPolicy::AUTOMATIC,
+                            base::WaitableEvent::InitialState::NOT_SIGNALED);
+  gfx::GpuMemoryBufferHandle handle;
+  gfx::GpuMemoryBufferId id = GetNextGenericSharedMemoryId();
+  main_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&MojoGpuMemoryBufferManager::AllocateGpuMemoryBufferOnMain,
+                 base::Unretained(this), id, size, format, usage, &handle,
+                 &event));
+  event.Wait();
+  std::unique_ptr<gpu::GpuMemoryBufferImpl> buffer =
+      handle.is_null() ? nullptr
+                       : gpu::GpuMemoryBufferImpl::CreateFromHandle(
+                             handle, size, format, usage,
+                             base::Bind(&DeletedGpuMemoryBuffer, handle.id));
+  if (buffer)
+    return buffer;
+// XXX: This needs to happen in the main thread.
+// gpu_service_->DestroyGpuMemoryBuffer(id, gpu::SyncToken());
+#endif
+  return MojoGpuMemoryBufferImpl::Create(size, format, usage);
+#endif
+}
+
+void MojoGpuMemoryBufferManager::AllocateGpuMemoryBufferOnMain(
+    gfx::GpuMemoryBufferId id,
+    const gfx::Size& size,
+    gfx::BufferFormat format,
+    gfx::BufferUsage usage,
+    gfx::GpuMemoryBufferHandle* handle,
+    base::WaitableEvent* event) {
+  EnsureGpuServiceConnection();
+  mojo::SyncCallRestrictions::ScopedAllowSyncCall allow_sync_call;
+  gpu_service_->CreateGpuMemoryBuffer(id, size, format, usage, handle);
+  event->Signal();
 }
 
 std::unique_ptr<gfx::GpuMemoryBuffer>
 MojoGpuMemoryBufferManager::CreateGpuMemoryBufferFromHandle(
     const gfx::GpuMemoryBufferHandle& handle,
     const gfx::Size& size,
     gfx::BufferFormat format) {
   const gfx::BufferUsage usage = gfx::BufferUsage::GPU_READ;
   return MojoGpuMemoryBufferImpl::CreateFromHandle(handle, size, format, usage);
 }
 
 gfx::GpuMemoryBuffer*
 MojoGpuMemoryBufferManager::GpuMemoryBufferFromClientBuffer(
     ClientBuffer buffer) {
   return MojoGpuMemoryBufferImpl::FromClientBuffer(buffer);
 }
 
 void MojoGpuMemoryBufferManager::SetDestructionSyncToken(
     gfx::GpuMemoryBuffer* buffer,
     const gpu::SyncToken& sync_token) {
   NOTIMPLEMENTED();
 }
 
+void MojoGpuMemoryBufferManager::EnsureGpuServiceConnection() {
+#if 0
+  CHECK(base::ThreadTaskRunnerHandle::Get());
+  if (gpu_service_ && !gpu_service_.encountered_error())
+    return;
+  connector_->ConnectToInterface("service:ui", &gpu_service_);
+#endif
+}
+
 }  // namespace ui