gpu: Remove Create/DeleteImage IPC by adding an X11_PIXMAP_BUFFER GpuMemoryBuffer type.

gpu/command_buffer/tests/gl_manager.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/tests/gl_manager.h"
 
+#include <GLES2/gl2.h>
+#include <GLES2/gl2ext.h>
+
 #include <vector>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
+#include "base/memory/ref_counted_memory.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "gpu/command_buffer/client/gles2_lib.h"
-#include "gpu/command_buffer/client/gpu_memory_buffer_factory.h"
 #include "gpu/command_buffer/client/transfer_buffer.h"
 #include "gpu/command_buffer/common/constants.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/service/command_buffer_service.h"
 #include "gpu/command_buffer/service/context_group.h"
 #include "gpu/command_buffer/service/gl_context_virtual.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "gpu/command_buffer/service/gpu_control_service.h"
 #include "gpu/command_buffer/service/gpu_scheduler.h"
 #include "gpu/command_buffer/service/image_manager.h"
 #include "gpu/command_buffer/service/mailbox_manager.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/gpu_memory_buffer.h"
 #include "ui/gl/gl_context.h"
+#include "ui/gl/gl_image_ref_counted_memory.h"
 #include "ui/gl/gl_share_group.h"
 #include "ui/gl/gl_surface.h"
 
 namespace gpu {
+namespace {
+
+int BytesPerPixel(unsigned internalformat) {
+  switch (internalformat) {
+    case GL_RGBA8_OES:
+      return 4;
+    default:
+      NOTREACHED();
+      return 0;
+  }
+}
+
+class GpuMemoryBufferImpl : public gfx::GpuMemoryBuffer {
+ public:
+  GpuMemoryBufferImpl(base::RefCountedBytes* bytes,
+                      const gfx::Size& size,
+                      unsigned internalformat)
+      : bytes_(bytes),
+        size_(size),
+        internalformat_(internalformat),
+        mapped_(false) {}
+
+  // Overridden from gfx::GpuMemoryBuffer:
+  virtual void* Map() OVERRIDE {
+    mapped_ = true;
+    return &bytes_->data().front();
+  }
+  virtual void Unmap() OVERRIDE { mapped_ = false; }
+  virtual bool IsMapped() const OVERRIDE { return mapped_; }
+  virtual uint32 GetStride() const OVERRIDE {
+    return size_.width() * BytesPerPixel(internalformat_);
+  }
+  virtual gfx::GpuMemoryBufferHandle GetHandle() const OVERRIDE {
+    NOTREACHED();
+    return gfx::GpuMemoryBufferHandle();
+  }
+
+ private:
+  scoped_refptr<base::RefCountedBytes> bytes_;
+  const gfx::Size size_;
+  unsigned internalformat_;
+  bool mapped_;
+};
+
+}  // namespace
 
 int GLManager::use_count_;
 scoped_refptr<gfx::GLShareGroup>* GLManager::base_share_group_;
 scoped_refptr<gfx::GLSurface>* GLManager::base_surface_;
 scoped_refptr<gfx::GLContext>* GLManager::base_context_;
 
 GLManager::Options::Options()
     : size(4, 4),
       share_group_manager(NULL),
       share_mailbox_manager(NULL),
       virtual_manager(NULL),
       bind_generates_resource(false),
       lose_context_when_out_of_memory(false),
-      context_lost_allowed(false),
-      image_manager(NULL) {}
+      context_lost_allowed(false) {
+}
 
-GLManager::GLManager()
-    : context_lost_allowed_(false), gpu_memory_buffer_factory_(NULL) {
+GLManager::GLManager() : context_lost_allowed_(false) {
   SetupBaseContext();
 }
 
 GLManager::~GLManager() {
   --use_count_;
   if (!use_count_) {
     if (base_share_group_) {
       delete base_context_;
       base_context_ = NULL;
     }
@@ skipping 54 matching lines @@
   attrib_helper.red_size_ = 8;
   attrib_helper.green_size_ = 8;
   attrib_helper.blue_size_ = 8;
   attrib_helper.alpha_size_ = 8;
   attrib_helper.depth_size_ = 16;
   attrib_helper.Serialize(&attribs);
 
   if (!context_group) {
     context_group =
         new gles2::ContextGroup(mailbox_manager_.get(),
-                                options.image_manager,
                                 NULL,
                                 new gpu::gles2::ShaderTranslatorCache,
                                 NULL,
                                 options.bind_generates_resource);
   }
 
   decoder_.reset(::gpu::gles2::GLES2Decoder::Create(context_group));
 
   command_buffer_.reset(new CommandBufferService(
       decoder_->GetContextGroup()->transfer_buffer_manager()));
@@ skipping 32 matching lines @@
 
   ASSERT_TRUE(decoder_->Initialize(
       surface_.get(),
       context_.get(),
       true,
       options.size,
       ::gpu::gles2::DisallowedFeatures(),
       attribs)) << "could not initialize decoder";
 
   gpu_control_service_.reset(
-      new GpuControlService(decoder_->GetContextGroup()->image_manager(),
-                            decoder_->GetQueryManager()));
-  gpu_memory_buffer_factory_ = options.gpu_memory_buffer_factory;
+      new GpuControlService(decoder_->GetQueryManager()));
 
   command_buffer_->SetPutOffsetChangeCallback(
       base::Bind(&GLManager::PumpCommands, base::Unretained(this)));
   command_buffer_->SetGetBufferChangeCallback(
       base::Bind(&GLManager::GetBufferChanged, base::Unretained(this)));
 
   // Create the GLES2 helper, which writes the command buffer protocol.
   gles2_helper_.reset(new gles2::GLES2CmdHelper(command_buffer_.get()));
   ASSERT_TRUE(gles2_helper_->Initialize(kCommandBufferSize));
 
@@ skipping 82 matching lines @@
 Capabilities GLManager::GetCapabilities() {
   return decoder_->GetCapabilities();
 }
 
 gfx::GpuMemoryBuffer* GLManager::CreateGpuMemoryBuffer(
     size_t width,
     size_t height,
     unsigned internalformat,
     unsigned usage,
     int32* id) {
-  *id = -1;
-  scoped_ptr<gfx::GpuMemoryBuffer> buffer(
-      gpu_memory_buffer_factory_->CreateGpuMemoryBuffer(
-          width, height, internalformat, usage));
-  if (!buffer.get())
+  gfx::Size size(width, height);
+
+  std::vector<unsigned char> data(
+      size.GetArea() * BytesPerPixel(internalformat), 0);
+  scoped_refptr<base::RefCountedBytes> bytes(new base::RefCountedBytes(data));
+
+  scoped_ptr<GpuMemoryBufferImpl> gpu_memory_buffer(
+      new GpuMemoryBufferImpl(bytes.get(), size, internalformat));
+
+  scoped_refptr<gfx::GLImageRefCountedMemory> gl_image(
+      new gfx::GLImageRefCountedMemory(size, internalformat));
+  if (!gl_image->Initialize(bytes.get()))
     return NULL;
 
   static int32 next_id = 1;
   *id = next_id++;
-  gpu_control_service_->RegisterGpuMemoryBuffer(
-      *id, buffer->GetHandle(), width, height, internalformat);
-  gfx::GpuMemoryBuffer* raw_buffer = buffer.get();
-  memory_buffers_.add(*id, buffer.Pass());
-  return raw_buffer;
+
+  decoder()->GetImageManager()->AddImage(gl_image.get(), *id);
+  gpu_memory_buffers_.add(*id,
+                          gpu_memory_buffer.PassAs<gfx::GpuMemoryBuffer>());
+  return gpu_memory_buffers_.get(*id);
 }
 
 void GLManager::DestroyGpuMemoryBuffer(int32 id) {
-  memory_buffers_.erase(id);
-  gpu_control_service_->UnregisterGpuMemoryBuffer(id);
+  decoder()->GetImageManager()->RemoveImage(id);
+  gpu_memory_buffers_.erase(id);
 }
 
 uint32 GLManager::InsertSyncPoint() {
   NOTIMPLEMENTED();
   return 0u;
 }
 
 void GLManager::SignalSyncPoint(uint32 sync_point,
                              const base::Closure& callback) {
   NOTIMPLEMENTED();
@@ skipping 10 matching lines @@
 void GLManager::Echo(const base::Closure& callback) {
   NOTIMPLEMENTED();
 }
 
 uint32 GLManager::CreateStreamTexture(uint32 texture_id) {
   NOTIMPLEMENTED();
   return 0;
 }
 
 }  // namespace gpu