Refactor/Rename a bunch of GPU stuff

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 <limits>
 #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 14 matching lines @@
   DCHECK(buffer_infos_.empty());
   CHECK_EQ(buffer_info_count_, 0u);
 }
 
 void BufferManager::Destroy(bool have_context) {
   have_context_ = have_context;
   buffer_infos_.clear();
   DCHECK_EQ(0u, memory_tracker_->GetMemRepresented());
 }
 
-void BufferManager::CreateBufferInfo(GLuint client_id, GLuint service_id) {
-  BufferInfo::Ref buffer(new BufferInfo(this, service_id));
+void BufferManager::CreateBuffer(GLuint client_id, GLuint service_id) {
+  scoped_refptr<Buffer> buffer(new Buffer(this, service_id));
   std::pair<BufferInfoMap::iterator, bool> result =
       buffer_infos_.insert(std::make_pair(client_id, buffer));
   DCHECK(result.second);
 }
 
-BufferManager::BufferInfo* BufferManager::GetBufferInfo(
+BufferManager::Buffer* BufferManager::GetBuffer(
     GLuint client_id) {
   BufferInfoMap::iterator it = buffer_infos_.find(client_id);
   return it != buffer_infos_.end() ? it->second : NULL;
 }
 
-void BufferManager::RemoveBufferInfo(GLuint client_id) {
+void BufferManager::RemoveBuffer(GLuint client_id) {
   BufferInfoMap::iterator it = buffer_infos_.find(client_id);
   if (it != buffer_infos_.end()) {
-    BufferInfo* buffer = it->second;
+    Buffer* buffer = it->second;
     buffer->MarkAsDeleted();
     buffer_infos_.erase(it);
   }
 }
 
-void BufferManager::StartTracking(BufferManager::BufferInfo* /* buffer */) {
+void BufferManager::StartTracking(BufferManager::Buffer* /* buffer */) {
   ++buffer_info_count_;
 }
 
-void BufferManager::StopTracking(BufferManager::BufferInfo* buffer) {
+void BufferManager::StopTracking(BufferManager::Buffer* buffer) {
   memory_tracker_->TrackMemFree(buffer->size());
   --buffer_info_count_;
 }
 
-BufferManager::BufferInfo::BufferInfo(BufferManager* manager, GLuint service_id)
+BufferManager::Buffer::Buffer(BufferManager* manager, GLuint service_id)
     : manager_(manager),
       deleted_(false),
       service_id_(service_id),
       target_(0),
       size_(0),
       usage_(GL_STATIC_DRAW),
       shadowed_(false) {
   manager_->StartTracking(this);
 }
 
-BufferManager::BufferInfo::~BufferInfo() {
+BufferManager::Buffer::~Buffer() {
   if (manager_) {
     if (manager_->have_context_) {
       GLuint id = service_id();
       glDeleteBuffersARB(1, &id);
     }
     manager_->StopTracking(this);
     manager_ = NULL;
   }
 }
 
-void BufferManager::BufferInfo::SetInfo(
+void BufferManager::Buffer::SetInfo(
     GLsizeiptr size, GLenum usage, bool shadow) {
   usage_ = usage;
   if (size != size_ || shadow != shadowed_) {
     shadowed_ = shadow;
     size_ = size;
     ClearCache();
     if (shadowed_) {
       shadow_.reset(new int8[size]);
       memset(shadow_.get(), 0, size);
     }
   }
 }
 
-bool BufferManager::BufferInfo::CheckRange(
+bool BufferManager::Buffer::CheckRange(
     GLintptr offset, GLsizeiptr size) const {
   int32 end = 0;
   return offset >= 0 && size >= 0 &&
          offset <= std::numeric_limits<int32>::max() &&
          size <= std::numeric_limits<int32>::max() &&
          SafeAddInt32(offset, size, &end) && end <= size_;
 }
 
-bool BufferManager::BufferInfo::SetRange(
+bool BufferManager::Buffer::SetRange(
     GLintptr offset, GLsizeiptr size, const GLvoid * data) {
   if (!CheckRange(offset, size)) {
     return false;
   }
   if (shadowed_) {
     memcpy(shadow_.get() + offset, data, size);
     ClearCache();
   }
   return true;
 }
 
-const void* BufferManager::BufferInfo::GetRange(
+const void* BufferManager::Buffer::GetRange(
     GLintptr offset, GLsizeiptr size) const {
   if (!shadowed_) {
     return NULL;
   }
   if (!CheckRange(offset, size)) {
     return NULL;
   }
   return shadow_.get() + offset;
 }
 
-void BufferManager::BufferInfo::ClearCache() {
+void BufferManager::Buffer::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*>(
       static_cast<const int8*>(data) + offset);
   const T* end = element + count;
   for (; element < end; ++element) {
     if (*element > max_value) {
       max_value = *element;
     }
   }
   return max_value;
 }
 
-bool BufferManager::BufferInfo::GetMaxValueForRange(
+bool BufferManager::Buffer::GetMaxValueForRange(
     GLuint offset, GLsizei count, GLenum type, GLuint* max_value) {
   Range range(offset, count, type);
   RangeToMaxValueMap::iterator it = range_set_.find(range);
   if (it != range_set_.end()) {
     *max_value = it->second;
     return true;
   }
 
   uint32 size;
   if (!SafeMultiplyUint32(
@@ skipping 48 matching lines @@
        it != buffer_infos_.end(); ++it) {
     if (it->second->service_id() == service_id) {
       *client_id = it->first;
       return true;
     }
   }
   return false;
 }
 
 void BufferManager::SetInfo(
-    BufferManager::BufferInfo* info, GLsizeiptr size, GLenum usage) {
+    BufferManager::Buffer* info, GLsizeiptr size, GLenum usage) {
   DCHECK(info);
   memory_tracker_->TrackMemFree(info->size());
   info->SetInfo(size,
                 usage,
                 info->target() == GL_ELEMENT_ARRAY_BUFFER ||
                 allow_buffers_on_multiple_targets_);
   memory_tracker_->TrackMemAlloc(info->size());
 }
 
-bool BufferManager::SetTarget(BufferManager::BufferInfo* info, GLenum target) {
+bool BufferManager::SetTarget(BufferManager::Buffer* 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