gpu: Refactor GpuMemoryBuffer framework for multi-process support.

gpu/command_buffer/service/command_buffer_service.cc

 // Copyright (c) 2012 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/command_buffer_service.h"
 
 #include <limits>
 
+#include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/debug/trace_event.h"
+#include "gpu/command_buffer/client/gpu_memory_buffer_factory.h"
 #include "gpu/command_buffer/common/cmd_buffer_common.h"
 #include "gpu/command_buffer/common/command_buffer_shared.h"
+#include "gpu/command_buffer/service/image_manager.h"
 #include "gpu/command_buffer/service/transfer_buffer_manager.h"
+#include "ui/gl/gl_image.h"
 
 using ::base::SharedMemory;
 
 namespace gpu {
 
 CommandBufferService::CommandBufferService(
-    TransferBufferManagerInterface* transfer_buffer_manager)
+    TransferBufferManagerInterface* transfer_buffer_manager,
+    gles2::ImageManager* image_manager,
+    GpuMemoryBufferFactory* gpu_memory_buffer_factory)
     : ring_buffer_id_(-1),
       shared_state_(NULL),
       num_entries_(0),
       get_offset_(0),
       put_offset_(0),
       transfer_buffer_manager_(transfer_buffer_manager),
       token_(0),
       generation_(0),
       error_(error::kNoError),
-      context_lost_reason_(error::kUnknown) {
+      context_lost_reason_(error::kUnknown),
+      gpu_memory_buffer_factory_(gpu_memory_buffer_factory),
+      image_manager_(image_manager) {
 }
 
 CommandBufferService::~CommandBufferService() {
 }
 
 bool CommandBufferService::Initialize() {
   return true;
 }
 
 CommandBufferService::State CommandBufferService::GetState() {
@@ skipping 159 matching lines @@
 void CommandBufferService::SetParseErrorCallback(
     const base::Closure& callback) {
   parse_error_callback_ = callback;
 }
 
 uint32 CommandBufferService::InsertSyncPoint() {
   NOTREACHED();
   return 0;
 }
 
+bool CommandBufferService::RegisterGpuMemoryBuffer(
+    int32 id,
+    gfx::GpuMemoryBufferHandle buffer,
+    size_t width,
+    size_t height,
+    unsigned internalformat) {
+  if (id <= 0) {
+    DVLOG(0) << "Cannot register GPU memory buffer with non-positive ID.";
+    return false;
+  }
+
+  if (image_manager_->LookupImage(id)) {
+    DVLOG(0) << "GPU memory buffer ID already in use.";
+    return false;
+  }
+
+  scoped_refptr<gfx::GLImage> gl_image =
+      gfx::GLImage::CreateGLImageForGpuMemoryBuffer(buffer,
+                                                    gfx::Size(width, height));
+  if (!gl_image)
+    return false;
+
+  image_manager_->AddImage(gl_image.get(), id);
+  return true;
+}
+
+gfx::GpuMemoryBuffer* CommandBufferService::CreateGpuMemoryBuffer(
+    size_t width,
+    size_t height,
+    unsigned internalformat,
+    int32* id) {
+  *id = -1;
+
+  CHECK(gpu_memory_buffer_factory_) << "No GPU memory buffer factory provided";
+  scoped_ptr<gfx::GpuMemoryBuffer> buffer = make_scoped_ptr(
+      gpu_memory_buffer_factory_->CreateGpuMemoryBuffer(width,
+                                                        height,
+                                                        internalformat));
+  if (!buffer)
+    return NULL;
+
+  static int32 next_id = 1;
+  *id = next_id++;
+
+  if (!RegisterGpuMemoryBuffer(*id,
+                               buffer->GetHandle(),
+                               width,
+                               height,
+                               internalformat)) {
+    *id = -1;
+    return NULL;
+  }
+
+  gpu_memory_buffers_[*id] = buffer.get();
+  return buffer.release();
+}
+
+void CommandBufferService::DestroyGpuMemoryBuffer(int32 id) {
+  GpuMemoryBufferMap::iterator it = gpu_memory_buffers_.find(id);
+  if (it != gpu_memory_buffers_.end()) {
+    delete it->second;
+    gpu_memory_buffers_.erase(it);
+  }
+
+  image_manager_->RemoveImage(id);
+}
+
 }  // namespace gpu