gpu: Refactor GpuMemoryBuffer framework for multi-process support.

gpu/command_buffer/client/gles2_implementation.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.
 
 // A class to emulate GLES2 over command buffers.
 
 #include "gpu/command_buffer/client/gles2_implementation.h"
 
 #include <algorithm>
 #include <map>
 #include <queue>
 #include <set>
 #include <limits>
 #include <stdio.h>
 #include <string.h>
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
 #include "gpu/command_buffer/client/buffer_tracker.h"
-#include "gpu/command_buffer/client/gpu_memory_buffer.h"
 #include "gpu/command_buffer/client/gpu_memory_buffer_tracker.h"
 #include "gpu/command_buffer/client/mapped_memory.h"
 #include "gpu/command_buffer/client/program_info_manager.h"
 #include "gpu/command_buffer/client/query_tracker.h"
 #include "gpu/command_buffer/client/transfer_buffer.h"
 #include "gpu/command_buffer/client/vertex_array_object_manager.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/common/trace_event.h"
+#include "ui/gfx/gpu_memory_buffer.h"
 
 #if defined(__native_client__) && !defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
 #define GLES2_SUPPORT_CLIENT_SIDE_ARRAYS
 #endif
 
 #if defined(GPU_CLIENT_DEBUG)
 #include "ui/gl/gl_switches.h"
 #include "base/command_line.h"
 #endif
 
@@ skipping 41 matching lines @@
 GLES2Implementation::SingleThreadChecker::~SingleThreadChecker() {
   --gles2_implementation_->use_count_;
   GPU_CHECK_EQ(0, gles2_implementation_->use_count_);
 }
 
 GLES2Implementation::GLES2Implementation(
       GLES2CmdHelper* helper,
       ShareGroup* share_group,
       TransferBufferInterface* transfer_buffer,
       bool share_resources,
-      bool bind_generates_resource,
-      ImageFactory* image_factory)
+      bool bind_generates_resource)
     : helper_(helper),
       transfer_buffer_(transfer_buffer),
       angle_pack_reverse_row_order_status_(kUnknownExtensionStatus),
       chromium_framebuffer_multisample_(kUnknownExtensionStatus),
       pack_alignment_(4),
       unpack_alignment_(4),
       unpack_flip_y_(false),
       unpack_row_length_(0),
       unpack_skip_rows_(0),
       unpack_skip_pixels_(0),
       pack_reverse_row_order_(false),
       active_texture_unit_(0),
       bound_framebuffer_(0),
       bound_read_framebuffer_(0),
       bound_renderbuffer_(0),
       current_program_(0),
       bound_array_buffer_id_(0),
       bound_pixel_pack_transfer_buffer_id_(0),
       bound_pixel_unpack_transfer_buffer_id_(0),
       error_bits_(0),
       debug_(false),
       use_count_(0),
       current_query_(NULL),
-      error_message_callback_(NULL),
-      image_factory_(image_factory) {
+      error_message_callback_(NULL) {
   GPU_DCHECK(helper);
   GPU_DCHECK(transfer_buffer);
 
   char temp[128];
   sprintf(temp, "%p", static_cast<void*>(this));
   this_in_hex_ = std::string(temp);
 
   GPU_CLIENT_LOG_CODE_BLOCK({
     debug_ = CommandLine::ForCurrentProcess()->HasSwitch(
         switches::kEnableGPUClientLogging);
@@ skipping 33 matching lines @@
       static_state_.int_state.num_compressed_texture_formats);
   util_.set_num_shader_binary_formats(
       static_state_.int_state.num_shader_binary_formats);
 
   texture_units_.reset(
       new TextureUnit[
           static_state_.int_state.max_combined_texture_image_units]);
 
   query_tracker_.reset(new QueryTracker(mapped_memory_.get()));
   buffer_tracker_.reset(new BufferTracker(mapped_memory_.get()));
-  gpu_memory_buffer_tracker_.reset(new GpuMemoryBufferTracker(image_factory_));
+  gpu_memory_buffer_tracker_.reset(new GpuMemoryBufferTracker(helper_));
 
 #if defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
   GetIdHandler(id_namespaces::kBuffers)->MakeIds(
       this, kClientSideArrayId, arraysize(reserved_ids_), &reserved_ids_[0]);
 #endif
 
   vertex_array_object_manager_.reset(new VertexArrayObjectManager(
       static_state_.int_state.max_vertex_attribs,
       reserved_ids_[0],
       reserved_ids_[1]));
@@ skipping 1905 matching lines @@
   // Clears the bucket so if the command fails nothing will be in it.
   helper_->SetBucketSize(kResultBucketId, 0);
   helper_->GetString(name, kResultBucketId);
   std::string str;
   if (GetBucketAsString(kResultBucketId, &str)) {
     // Adds extensions implemented on client side only.
     switch (name) {
       case GL_EXTENSIONS:
         str += std::string(str.empty() ? "" : " ") +
             "GL_CHROMIUM_flipy "
+            "GL_CHROMIUM_map_image "
             "GL_CHROMIUM_map_sub "
             "GL_CHROMIUM_shallow_flush "
             "GL_EXT_unpack_subimage";
-        if (image_factory_ != NULL) {
-          // The first space character is intentional.
-          str += " GL_CHROMIUM_map_image";
-        }
         break;
       default:
         break;
     }
 
     // Because of WebGL the extensions can change. We have to cache each unique
     // result since we don't know when the client will stop referring to a
     // previous one it queries.
     GLStringMap::iterator it = gl_strings_.find(name);
     if (it == gl_strings_.end()) {
@@ skipping 1586 matching lines @@
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glCreateImageCHROMIUM("
       << width << ", "
       << height << ", "
       << GLES2Util::GetStringTextureInternalFormat(internalformat) << ")");
   GLuint image_id = CreateImageCHROMIUMHelper(width, height, internalformat);
   CheckGLError();
   return image_id;
 }
 
 void GLES2Implementation::DestroyImageCHROMIUMHelper(GLuint image_id) {
-  GpuMemoryBuffer* gpu_buffer = gpu_memory_buffer_tracker_->GetBuffer(image_id);
+  gfx::GpuMemoryBuffer* gpu_buffer = gpu_memory_buffer_tracker_->GetBuffer(
+      image_id);
   if (!gpu_buffer) {
     SetGLError(GL_INVALID_OPERATION, "glDestroyImageCHROMIUM", "invalid image");
     return;
   }
 
   // Flush the command stream to make sure all pending commands
   // that may refer to the image_id are executed on the service side.
   helper_->CommandBufferHelper::Flush();
   gpu_memory_buffer_tracker_->RemoveBuffer(image_id);
 }
 
 void GLES2Implementation::DestroyImageCHROMIUM(GLuint image_id) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glDestroyImageCHROMIUM("
       << image_id << ")");
   DestroyImageCHROMIUMHelper(image_id);
   CheckGLError();
 }
 
 void GLES2Implementation::UnmapImageCHROMIUMHelper(GLuint image_id) {
-  GpuMemoryBuffer* gpu_buffer = gpu_memory_buffer_tracker_->GetBuffer(image_id);
+  gfx::GpuMemoryBuffer* gpu_buffer = gpu_memory_buffer_tracker_->GetBuffer(
+      image_id);
   if (!gpu_buffer) {
     SetGLError(GL_INVALID_OPERATION, "glUnmapImageCHROMIUM", "invalid image");
     return;
   }
 
   if (!gpu_buffer->IsMapped()) {
     SetGLError(GL_INVALID_OPERATION, "glUnmapImageCHROMIUM", "not mapped");
     return;
   }
   gpu_buffer->Unmap();
 }
 
 void GLES2Implementation::UnmapImageCHROMIUM(GLuint image_id) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glUnmapImageCHROMIUM("
        << image_id << ")");
 
   UnmapImageCHROMIUMHelper(image_id);
   CheckGLError();
 }
 
 void* GLES2Implementation::MapImageCHROMIUMHelper(GLuint image_id,
                                                   GLenum access) {
-  GpuMemoryBuffer* gpu_buffer = gpu_memory_buffer_tracker_->GetBuffer(image_id);
+  gfx::GpuMemoryBuffer* gpu_buffer = gpu_memory_buffer_tracker_->GetBuffer(
+      image_id);
   if (!gpu_buffer) {
     SetGLError(GL_INVALID_OPERATION, "glMapImageCHROMIUM", "invalid image");
     return NULL;
   }
-  GpuMemoryBuffer::AccessMode mode;
+  gfx::GpuMemoryBuffer::AccessMode mode;
   switch(access) {
     case GL_WRITE_ONLY:
-      mode = GpuMemoryBuffer::WRITE_ONLY;
+      mode = gfx::GpuMemoryBuffer::WRITE_ONLY;
       break;
     case GL_READ_ONLY:
-      mode = GpuMemoryBuffer::READ_ONLY;
+      mode = gfx::GpuMemoryBuffer::READ_ONLY;
       break;
     case GL_READ_WRITE:
-      mode = GpuMemoryBuffer::READ_WRITE;
+      mode = gfx::GpuMemoryBuffer::READ_WRITE;
       break;
     default:
       SetGLError(GL_INVALID_ENUM, "glMapImageCHROMIUM",
                  "invalid GPU access mode");
       return NULL;
   }
 
   if (gpu_buffer->IsMapped()) {
     SetGLError(GL_INVALID_OPERATION, "glMapImageCHROMIUM", "already mapped");
     return NULL;
@@ skipping 17 matching lines @@
 }
 
 void GLES2Implementation::GetImageParameterivCHROMIUMHelper(
     GLuint image_id, GLenum pname, GLint* params) {
   if (pname != GL_IMAGE_ROWBYTES_CHROMIUM) {
     SetGLError(GL_INVALID_ENUM, "glGetImageParameterivCHROMIUM",
                "invalid parameter");
     return;
   }
 
-  GpuMemoryBuffer* gpu_buffer =
+  gfx::GpuMemoryBuffer* gpu_buffer =
       gpu_memory_buffer_tracker_->GetBuffer(image_id);
   if (!gpu_buffer) {
     SetGLError(GL_INVALID_OPERATION, "glGetImageParameterivCHROMIUM",
                "invalid image");
     return;
   }
 
   *params = gpu_buffer->GetStride();
 }
 
 void GLES2Implementation::GetImageParameterivCHROMIUM(
     GLuint image_id, GLenum pname, GLint* params) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_VALIDATE_DESTINATION_INITALIZATION(GLint, params);
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glImageParameterivCHROMIUM("
       << image_id << ", "
       << GLES2Util::GetStringBufferParameter(pname) << ", "
       << static_cast<const void*>(params) << ")");
   GetImageParameterivCHROMIUMHelper(image_id, pname, params);
   CheckGLError();
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "gpu/command_buffer/client/gles2_implementation_impl_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu