Add support for GL_CHROMIUM_pixel_transfer_buffer_object.

gpu/command_buffer/service/buffer_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/service/buffer_manager.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
@@ skipping 61 matching lines @@
   UpdateMemRepresented();
 }
 
 BufferManager::BufferInfo::BufferInfo(BufferManager* manager, GLuint service_id)
     : manager_(manager),
       deleted_(false),
       service_id_(service_id),
       target_(0),
       size_(0),
       usage_(GL_STATIC_DRAW),
-      shadowed_(false) {
+      shadowed_(false),
+      shm_id_(0),
+      shm_offset_(0) {
   manager_->StartTracking(this);
 }
 
 BufferManager::BufferInfo::~BufferInfo() {
   if (manager_) {
     if (manager_->have_context_) {
       GLuint id = service_id();
       glDeleteBuffersARB(1, &id);
     }
     manager_->StopTracking(this);
     manager_ = NULL;
   }
 }
 
 void BufferManager::BufferInfo::SetInfo(
     GLsizeiptr size, GLenum usage, bool shadow) {
   usage_ = usage;
-  if (size != size_ || shadow != shadowed_) {
+  shm_id_ = 0;
+  shm_offset_ = 0;
+  if (size != size_ || shadow != shadowed_ || decoder_.get()) {
     shadowed_ = shadow;
     size_ = size;
     ClearCache();
     if (shadowed_) {
       shadow_.reset(new int8[size]);
       memset(shadow_.get(), 0, size);
     }
+    decoder_.reset();
   }
 }
 
+void BufferManager::BufferInfo::SetInfo(
+    GLsizeiptr size, GLenum usage, CommonDecoder* decoder, int32 shm_id,
+    uint32 shm_offset) {
+  usage_ = usage;
+  shm_id_ = shm_id;
+  shm_offset_ = shm_offset;
+  if (size != size_ || shadowed_ || decoder_.get() != decoder) {
+    size_ = size;
+    ClearCache();
+    if (shadowed_) {
+      shadow_.reset();
+      shadowed_ = false;
+    }
+    decoder_ = decoder->AsWeakPtr();
+  }
+}
+
 bool BufferManager::BufferInfo::SetRange(
     GLintptr offset, GLsizeiptr size, const GLvoid * data) {
   if (offset < 0 || offset + size < offset || offset + size > size_) {
     return false;
   }
   if (shadowed_) {
     memcpy(shadow_.get() + offset, data, size);
     ClearCache();
   }
+  if (decoder_) {
+    int8* shm_data = decoder_->GetSharedMemoryAs<int8*>(

[greggman, 2012/05/24 20:56:00]

I'm confused. Why would you need to copy memory in set range? If the whole point
is that you're using shared memory so that client has already put the data in
the buffer. Am I mis-understanding

[reveman, 2012/05/25 15:45:10]

This is for when a client calls glBufferSubData, which should really be handled
on the client side. This can be removed once that's fixed.

+        shm_id_, shm_offset_, size_);
+    if (shm_data)
+      memcpy(shm_data + offset, data, size);
+  }
   return true;
 }
 
 const void* BufferManager::BufferInfo::GetRange(
     GLintptr offset, GLsizeiptr size) const {
-  if (!shadowed_) {
-    return NULL;
-  }
   if (offset < 0 || offset + size < offset || offset + size > size_) {
     return NULL;
   }
-  return shadow_.get() + offset;
+  if (shadowed_) {
+    return shadow_.get() + offset;
+  }
+  if (decoder_) {

[greggman, 2012/05/24 20:56:00]

If this is a shared memory buffer should this go before the shadowed_ check?

[reveman, 2012/05/25 15:45:10]

Doesn't really matter as making a buffer a shm buffer makes shadowed_ = false.

+    int8* shm_data = decoder_->GetSharedMemoryAs<int8*>(
+        shm_id_, shm_offset_, size_);
+    if (!shm_data)
+      return NULL;
+    return shm_data + offset;
+  }
+  return NULL;
 }
 
 void BufferManager::BufferInfo::ClearCache() {
   range_set_.clear();
 }
 
 template <typename T>
 GLuint GetMaxValue(const void* data, GLuint offset, GLsizei count) {
   GLuint max_value = 0;
   const T* element = reinterpret_cast<const T*>(
@@ skipping 79 matching lines @@
     BufferManager::BufferInfo* info, GLsizeiptr size, GLenum usage) {
   DCHECK(info);
   mem_represented_ -= info->size();
   info->SetInfo(size,
                 usage,
                 info->target() == GL_ELEMENT_ARRAY_BUFFER ||
                 allow_buffers_on_multiple_targets_);
   mem_represented_ += info->size();
 }
 
+void BufferManager::SetInfo(
+    BufferManager::BufferInfo* info, GLsizeiptr size, GLenum usage,
+    CommonDecoder* decoder, int32 shm_id, uint32 shm_offset) {
+  DCHECK(info);
+  mem_represented_ -= info->size();
+  info->SetInfo(size, usage, decoder, shm_id, shm_offset);
+  mem_represented_ += info->size();
+}
+
 bool BufferManager::SetTarget(BufferManager::BufferInfo* info, GLenum target) {
   // Check that we are not trying to bind it to a different target.
   if (info->target() != 0 && info->target() != target &&
       !allow_buffers_on_multiple_targets_) {
     return false;
   }
   if (info->target() == 0) {
     info->set_target(target);
   }
   return true;
 }
 
 }  // namespace gles2
 }  // namespace gpu