Refactor GPU code. Buffer* info to Buffer* buffer

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/feature_info.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "gpu/command_buffer/service/memory_tracking.h"
 #include "ui/gl/gl_bindings.h"
 
 namespace gpu {
 namespace gles2 {
 
 BufferManager::BufferManager(
     MemoryTracker* memory_tracker,
     FeatureInfo* feature_info)
     : memory_tracker_(
           new MemoryTypeTracker(memory_tracker, MemoryTracker::kManaged)),
       feature_info_(feature_info),
       allow_buffers_on_multiple_targets_(false),
-      buffer_info_count_(0),
+      buffer_count_(0),
       have_context_(true),
       use_client_side_arrays_for_stream_buffers_(
           feature_info ? feature_info->workarounds(
               ).use_client_side_arrays_for_stream_buffers : 0) {
 }
 
 BufferManager::~BufferManager() {
-  DCHECK(buffer_infos_.empty());
-  CHECK_EQ(buffer_info_count_, 0u);
+  DCHECK(buffers_.empty());
+  CHECK_EQ(buffer_count_, 0u);
 }
 
 void BufferManager::Destroy(bool have_context) {
   have_context_ = have_context;
-  buffer_infos_.clear();
+  buffers_.clear();
   DCHECK_EQ(0u, memory_tracker_->GetMemRepresented());
 }
 
 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));
+  std::pair<BufferMap::iterator, bool> result =
+      buffers_.insert(std::make_pair(client_id, buffer));
   DCHECK(result.second);
 }
 
 Buffer* BufferManager::GetBuffer(
     GLuint client_id) {
-  BufferInfoMap::iterator it = buffer_infos_.find(client_id);
-  return it != buffer_infos_.end() ? it->second : NULL;
+  BufferMap::iterator it = buffers_.find(client_id);
+  return it != buffers_.end() ? it->second : NULL;
 }
 
 void BufferManager::RemoveBuffer(GLuint client_id) {
-  BufferInfoMap::iterator it = buffer_infos_.find(client_id);
-  if (it != buffer_infos_.end()) {
+  BufferMap::iterator it = buffers_.find(client_id);
+  if (it != buffers_.end()) {
     Buffer* buffer = it->second;
     buffer->MarkAsDeleted();
-    buffer_infos_.erase(it);
+    buffers_.erase(it);
   }
 }
 
 void BufferManager::StartTracking(Buffer* /* buffer */) {
-  ++buffer_info_count_;
+  ++buffer_count_;
 }
 
 void BufferManager::StopTracking(Buffer* buffer) {
   memory_tracker_->TrackMemFree(buffer->size());
-  --buffer_info_count_;
+  --buffer_count_;
 }
 
 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),
@@ skipping 137 matching lines @@
       NOTREACHED();  // should never get here by validation.
       break;
   }
   range_set_.insert(std::make_pair(range, max_v));
   *max_value = max_v;
   return true;
 }
 
 bool BufferManager::GetClientId(GLuint service_id, GLuint* client_id) const {
   // This doesn't need to be fast. It's only used during slow queries.
-  for (BufferInfoMap::const_iterator it = buffer_infos_.begin();
-       it != buffer_infos_.end(); ++it) {
+  for (BufferMap::const_iterator it = buffers_.begin();
+       it != buffers_.end(); ++it) {
     if (it->second->service_id() == service_id) {
       *client_id = it->first;
       return true;
     }
   }
   return false;
 }
 
 bool BufferManager::IsUsageClientSideArray(GLenum usage) {
   return usage == GL_STREAM_DRAW && use_client_side_arrays_for_stream_buffers_;
 }
 
 void BufferManager::SetInfo(
-    Buffer* info, GLsizeiptr size, GLenum usage, const GLvoid* data) {
-  DCHECK(info);
-  memory_tracker_->TrackMemFree(info->size());
+    Buffer* buffer, GLsizeiptr size, GLenum usage, const GLvoid* data) {
+  DCHECK(buffer);
+  memory_tracker_->TrackMemFree(buffer->size());
   bool is_client_side_array = IsUsageClientSideArray(usage);
-  bool shadow = info->target() == GL_ELEMENT_ARRAY_BUFFER ||
+  bool shadow = buffer->target() == GL_ELEMENT_ARRAY_BUFFER ||
                 allow_buffers_on_multiple_targets_ ||
                 is_client_side_array;
-  info->SetInfo(size, usage, shadow, data, is_client_side_array);
-  memory_tracker_->TrackMemAlloc(info->size());
+  buffer->SetInfo(size, usage, shadow, data, is_client_side_array);
+  memory_tracker_->TrackMemAlloc(buffer->size());
 }
 
 void BufferManager::DoBufferData(
     GLES2Decoder* decoder,
     Buffer* buffer,
     GLsizeiptr size,
     GLenum usage,
     const GLvoid* data) {
   // Clear the buffer to 0 if no initial data was passed in.
   scoped_array<int8> zero;
@@ skipping 26 matching lines @@
   if (!buffer->SetRange(offset, size, data)) {
     decoder->SetGLError(GL_INVALID_VALUE, "glBufferSubData", "out of range");
     return;
   }
 
   if (!buffer->IsClientSideArray()) {
     glBufferSubData(buffer->target(), offset, size, data);
   }
 }
 
-bool BufferManager::SetTarget(Buffer* info, GLenum target) {
+bool BufferManager::SetTarget(Buffer* buffer, GLenum target) {
   // Check that we are not trying to bind it to a different target.
-  if (info->target() != 0 && info->target() != target &&
+  if (buffer->target() != 0 && buffer->target() != target &&
       !allow_buffers_on_multiple_targets_) {
     return false;
   }
-  if (info->target() == 0) {
-    info->set_target(target);
+  if (buffer->target() == 0) {
+    buffer->set_target(target);
   }
   return true;
 }
 
 }  // namespace gles2
 }  // namespace gpu