gpu: Refactor GpuMemoryBuffer framework for multi-process support.

gpu/command_buffer/service/gpu_control_service.cc

+// Copyright (c) 2013 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 "gpu/command_buffer/service/gpu_control_service.h"
+
+#include "gpu/command_buffer/client/gpu_memory_buffer_factory.h"
+#include "gpu/command_buffer/service/gpu_memory_buffer_manager.h"
+
+namespace gpu {
+
+GpuControlService::GpuControlService(
+    GpuMemoryBufferManagerInterface* gpu_memory_buffer_manager,
+    GpuMemoryBufferFactory* gpu_memory_buffer_factory)
+    : gpu_memory_buffer_manager_(gpu_memory_buffer_manager),
+      gpu_memory_buffer_factory_(gpu_memory_buffer_factory) {
+}
+
+GpuControlService::~GpuControlService() {
+}
+
+gfx::GpuMemoryBuffer* GpuControlService::CreateGpuMemoryBuffer(
+    size_t width,
+    size_t height,
+    unsigned internalformat,
+    int32* id) {
+  *id = -1;
+
+  CHECK(gpu_memory_buffer_factory_) << "No GPU memory buffer factory provided";
+  linked_ptr<gfx::GpuMemoryBuffer> buffer = make_linked_ptr(
+      gpu_memory_buffer_factory_->CreateGpuMemoryBuffer(width,
+                                                        height,
+                                                        internalformat));
+  if (!buffer.get())
+    return NULL;
+
+  static int32 next_id = 1;

[no sievers, 2013/08/14 03:43:02]

Do you think we could either let the client pass in the id (and maybe use an id
allocator for namespace::kImages there), or use the existing id allocator on the
service side?

As discussed in chat earlier, it conflicts with
https://codereview.chromium.org/22824009, and what I suggested then turned out
to be a bit ugly too.

[reveman, 2013/08/14 15:48:59]

I don't want register of a buffer with the gpu process to require synchronous
IPC and I'd like to remove the ImageManager from the share group and limit the
scope of image ids to one context asap. Generating ids here prevents us from
making assumptions that will make it hard to achieve these goals.

I was hoping we can use a separate id namespace for stream texture images until
the usage lines up with GLImage.

+  *id = next_id++;
+
+  if (!RegisterGpuMemoryBuffer(*id,
+                               buffer->GetHandle(),
+                               width,
+                               height,
+                               internalformat)) {
+    *id = -1;
+    return NULL;
+  }
+
+  gpu_memory_buffers_[*id] = buffer;
+  return buffer.get();
+}
+
+void GpuControlService::DestroyGpuMemoryBuffer(int32 id) {
+  GpuMemoryBufferMap::iterator it = gpu_memory_buffers_.find(id);
+  if (it != gpu_memory_buffers_.end())
+    gpu_memory_buffers_.erase(it);
+
+  gpu_memory_buffer_manager_->DestroyGpuMemoryBuffer(id);
+}
+
+bool GpuControlService::RegisterGpuMemoryBuffer(
+    int32 id,
+    gfx::GpuMemoryBufferHandle buffer,
+    size_t width,
+    size_t height,
+    unsigned internalformat) {
+  return gpu_memory_buffer_manager_->RegisterGpuMemoryBuffer(id,
+                                                             buffer,
+                                                             width,
+                                                             height,
+                                                             internalformat);
+}
+
+}  // namespace gpu