Implement MusGpuMemoryBufferManager

components/mus/gpu/mus_gpu_memory_buffer_manager.cc

Index: components/mus/gpu/mus_gpu_memory_buffer_manager.cc
diff --git a/components/mus/gpu/mus_gpu_memory_buffer_manager.cc b/components/mus/gpu/mus_gpu_memory_buffer_manager.cc
new file mode 100644
index 0000000000000000000000000000000000000000..e6a697148ab80c46a0295e112d525390da955801
--- /dev/null
+++ b/components/mus/gpu/mus_gpu_memory_buffer_manager.cc
@@ -0,0 +1,125 @@
+// 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 "components/mus/gpu/mus_gpu_memory_buffer_manager.h"
+
+#include "base/logging.h"
+#include "components/mus/common/generic_shared_memory_id_generator.h"
+#include "components/mus/gpu/gpu_service_mus.h"
+#include "gpu/ipc/client/gpu_memory_buffer_impl.h"
+#include "gpu/ipc/client/gpu_memory_buffer_impl_shared_memory.h"
+#include "gpu/ipc/common/gpu_memory_buffer_support.h"
+#include "gpu/ipc/service/gpu_memory_buffer_factory.h"
+
+namespace mus {
+
+namespace {
+
+MusGpuMemoryBufferManager* g_gpu_memory_buffer_manager = nullptr;
+
+bool IsNativeGpuMemoryBufferFactoryConfigurationSupported(
+    gfx::BufferFormat format,
+    gfx::BufferUsage usage) {
+  switch (gpu::GetNativeGpuMemoryBufferType()) {
+    case gfx::SHARED_MEMORY_BUFFER:
+      return false;
+    case gfx::IO_SURFACE_BUFFER:
+    case gfx::SURFACE_TEXTURE_BUFFER:
+    case gfx::OZONE_NATIVE_PIXMAP:
+      return gpu::IsNativeGpuMemoryBufferConfigurationSupported(format, usage);
+    default:
+      NOTREACHED();
+      return false;
+  }
+}
+}
+
+MusGpuMemoryBufferManager* MusGpuMemoryBufferManager::current() {
+  return g_gpu_memory_buffer_manager;
+}
+
+MusGpuMemoryBufferManager::MusGpuMemoryBufferManager(int client_id)
+    : client_id_(client_id),
+      weak_factory_(this) {
+  DCHECK(!g_gpu_memory_buffer_manager);
+  g_gpu_memory_buffer_manager = this;
+}
+
+MusGpuMemoryBufferManager::~MusGpuMemoryBufferManager() {
+  g_gpu_memory_buffer_manager = nullptr;
+}
+
+std::unique_ptr<gfx::GpuMemoryBuffer>
+MusGpuMemoryBufferManager::AllocateGpuMemoryBuffer(
+    const gfx::Size& size,
+    gfx::BufferFormat format,
+    gfx::BufferUsage usage,
+    gpu::SurfaceHandle surface_handle) {
+  gfx::GpuMemoryBufferId id = GetNextGenericSharedMemoryId();
+  const bool is_native =
+      IsNativeGpuMemoryBufferFactoryConfigurationSupported(format, usage);
+  if (is_native) {
+    gpu::GpuMemoryBufferFactory* factory =
+        GpuServiceMus::GetInstance()->gpu_memory_buffer_factory();

[piman, 2016/06/09 19:31:32]

nit: because MusGpuMemoryBufferManager is created by GpuServiceMus, it would be
nice to pass GpuServiceMus explicitly in the constructor, to make the dependency
clear (and avoid global lookups, which can help testing and/or later
refactoring). 

[Peng, 2016/06/09 20:32:45]

Done.

+    gfx::GpuMemoryBufferHandle handle = factory->CreateGpuMemoryBuffer(
+        id, size, format, usage, client_id_, surface_handle);
+    if (handle.is_null())
+      return nullptr;
+    return gpu::GpuMemoryBufferImpl::CreateFromHandle(
+        handle, size, format, usage,
+        base::Bind(&MusGpuMemoryBufferManager::DestroyGpuMemoryBuffer,
+                   weak_factory_.GetWeakPtr(), id, client_id_, is_native));
+  }
+
+  DCHECK(gpu::GpuMemoryBufferImplSharedMemory::IsUsageSupported(usage))
+      << static_cast<int>(usage);
+  return gpu::GpuMemoryBufferImplSharedMemory::Create(
+      id, size, format,
+      base::Bind(&MusGpuMemoryBufferManager::DestroyGpuMemoryBuffer,
+                 weak_factory_.GetWeakPtr(), id, client_id_, is_native));
+}
+
+std::unique_ptr<gfx::GpuMemoryBuffer>
+MusGpuMemoryBufferManager::CreateGpuMemoryBufferFromHandle(
+    const gfx::GpuMemoryBufferHandle& handle,
+    const gfx::Size& size,
+    gfx::BufferFormat format) {
+  NOTIMPLEMENTED();
+  return nullptr;
+}
+
+std::unique_ptr<gfx::GpuMemoryBuffer>
+MusGpuMemoryBufferManager::CreateGpuMemoryBufferFromClientId(
+    int client_id,
+    const gfx::GpuMemoryBufferId& gpu_memory_buffer_id) {
+  NOTIMPLEMENTED();
+  return nullptr;
+}
+
+gfx::GpuMemoryBuffer*
+MusGpuMemoryBufferManager::GpuMemoryBufferFromClientBuffer(
+    ClientBuffer buffer) {
+  return gpu::GpuMemoryBufferImpl::FromClientBuffer(buffer);
+}
+
+void MusGpuMemoryBufferManager::SetDestructionSyncToken(
+    gfx::GpuMemoryBuffer* buffer,
+    const gpu::SyncToken& sync_token) {
+  static_cast<gpu::GpuMemoryBufferImpl*>(buffer)->set_destruction_sync_token(
+      sync_token);
+}
+
+void MusGpuMemoryBufferManager::DestroyGpuMemoryBuffer(
+    gfx::GpuMemoryBufferId id,
+    int client_id,
+    bool is_native,
+    const gpu::SyncToken& sync_token) {
+  if (is_native) {
+    gpu::GpuChannelManager* manager =
+        GpuServiceMus::GetInstance()->gpu_channel_manager();
+    manager->DestroyGpuMemoryBuffer(id, client_id, sync_token);
+  }
+}
+
+}  // namespace mus