Refactor GPU code. Buffer* info to Buffer* buffer

BUG=none


Review URL: https://chromiumcodereview.appspot.com/12649002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@186896 0039d316-1c4b-4281-b951-d872f2087c98

5 files changed, 58 insertions, 59 deletions

diff --git a/gpu/command_buffer/service/buffer_manager.cc b/gpu/command_buffer/service/buffer_manager.cc
index 207ae3b..3a34152 100644
--- a/gpu/command_buffer/service/buffer_manager.cc
+++ b/gpu/command_buffer/service/buffer_manager.cc
@@ -22,7 +22,7 @@ BufferManager::BufferManager(
           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(
@@ -30,45 +30,45 @@ BufferManager::BufferManager(
 }
 
 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)
@@ -226,8 +226,8 @@ bool Buffer::GetMaxValueForRange(
 
 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;
@@ -241,15 +241,15 @@ bool BufferManager::IsUsageClientSideArray(GLenum usage) {
 }
 
 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(
@@ -296,14 +296,14 @@ void BufferManager::DoBufferSubData(
   }
 }
 
-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;
 }
diff --git a/gpu/command_buffer/service/buffer_manager.h b/gpu/command_buffer/service/buffer_manager.h
index 0d99e9b..ad32be0 100644
--- a/gpu/command_buffer/service/buffer_manager.h
+++ b/gpu/command_buffer/service/buffer_manager.h
@@ -209,7 +209,7 @@ class GPU_EXPORT BufferManager {
       const GLvoid* data);
 
   // Sets the target of a buffer. Returns false if the target can not be set.
-  bool SetTarget(Buffer* info, GLenum target);
+  bool SetTarget(Buffer* buffer, GLenum target);
 
   void set_allow_buffers_on_multiple_targets(bool allow) {
     allow_buffers_on_multiple_targets_ = allow;
@@ -224,26 +224,27 @@ class GPU_EXPORT BufferManager {
 
  private:
   friend class Buffer;
-  void StartTracking(Buffer* info);
-  void StopTracking(Buffer* info);
+  void StartTracking(Buffer* buffer);
+  void StopTracking(Buffer* buffer);
 
   // Sets the size, usage and initial data of a buffer.
   // If data is NULL buffer will be initialized to 0 if shadowed.
-  void SetInfo(Buffer* info, GLsizeiptr size, GLenum usage, const GLvoid* data);
+  void SetInfo(
+      Buffer* buffer, GLsizeiptr size, GLenum usage, const GLvoid* data);
 
   scoped_ptr<MemoryTypeTracker> memory_tracker_;
   scoped_refptr<FeatureInfo> feature_info_;
 
   // Info for each buffer in the system.
-  typedef base::hash_map<GLuint, scoped_refptr<Buffer> > BufferInfoMap;
-  BufferInfoMap buffer_infos_;
+  typedef base::hash_map<GLuint, scoped_refptr<Buffer> > BufferMap;
+  BufferMap buffers_;
 
   // Whether or not buffers can be bound to multiple targets.
   bool allow_buffers_on_multiple_targets_;
 
   // Counts the number of Buffer allocated with 'this' as its manager.
   // Allows to check no Buffer will outlive this.
-  unsigned int buffer_info_count_;
+  unsigned int buffer_count_;
 
   bool have_context_;
   bool use_client_side_arrays_for_stream_buffers_;
diff --git a/gpu/command_buffer/service/context_state.cc b/gpu/command_buffer/service/context_state.cc
index 59b0220..7927001 100644
--- a/gpu/command_buffer/service/context_state.cc
+++ b/gpu/command_buffer/service/context_state.cc
@@ -103,9 +103,8 @@ void ContextState::RestoreAttribute(GLuint attrib) const {
   const VertexAttrib* info =
       vertex_attrib_manager->GetVertexAttrib(attrib);
   const void* ptr = reinterpret_cast<const void*>(info->offset());
-  Buffer* buffer_info = info->buffer();
-  glBindBuffer(
-      GL_ARRAY_BUFFER, buffer_info ? buffer_info->service_id() : 0);
+  Buffer* buffer = info->buffer();
+  glBindBuffer(GL_ARRAY_BUFFER, buffer ? buffer->service_id() : 0);
   glVertexAttribPointer(
       attrib, info->size(), info->type(), info->normalized(),
       info->gl_stride(), ptr);
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder.cc b/gpu/command_buffer/service/gles2_cmd_decoder.cc
index aa16f96..6c202c8 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder.cc
@@ -967,9 +967,8 @@ class GLES2DecoderImpl : public GLES2Decoder {
 
   // Gets the buffer info for the given buffer.
   Buffer* GetBuffer(GLuint client_id) {
-    Buffer* info =
-        buffer_manager()->GetBuffer(client_id);
-    return info;
+    Buffer* buffer = buffer_manager()->GetBuffer(client_id);
+    return buffer;
   }
 
   // Removes any buffers in the VertexAtrribInfos and BufferInfos. This is used
@@ -3545,41 +3544,41 @@ void GLES2DecoderImpl::DoActiveTexture(GLenum texture_unit) {
 }
 
 void GLES2DecoderImpl::DoBindBuffer(GLenum target, GLuint client_id) {
-  Buffer* info = NULL;
+  Buffer* buffer = NULL;
   GLuint service_id = 0;
   if (client_id != 0) {
-    info = GetBuffer(client_id);
-    if (!info) {
+    buffer = GetBuffer(client_id);
+    if (!buffer) {
       if (!group_->bind_generates_resource()) {
         LOG(ERROR) << "glBindBuffer: id not generated by glGenBuffers";
         current_decoder_error_ = error::kGenericError;
         return;
       }
 
-      // It's a new id so make a buffer info for it.
+      // It's a new id so make a buffer buffer for it.
       glGenBuffersARB(1, &service_id);
       CreateBuffer(client_id, service_id);
-      info = GetBuffer(client_id);
+      buffer = GetBuffer(client_id);
       IdAllocatorInterface* id_allocator =
           group_->GetIdAllocator(id_namespaces::kBuffers);
       id_allocator->MarkAsUsed(client_id);
     }
   }
-  LogClientServiceForInfo(info, client_id, "glBindBuffer");
-  if (info) {
-    if (!buffer_manager()->SetTarget(info, target)) {
+  LogClientServiceForInfo(buffer, client_id, "glBindBuffer");
+  if (buffer) {
+    if (!buffer_manager()->SetTarget(buffer, target)) {
       SetGLError(GL_INVALID_OPERATION,
                  "glBindBuffer", "buffer bound to more than 1 target");
       return;
     }
-    service_id = info->service_id();
+    service_id = buffer->service_id();
   }
   switch (target) {
     case GL_ARRAY_BUFFER:
-      state_.bound_array_buffer = info;
+      state_.bound_array_buffer = buffer;
       break;
     case GL_ELEMENT_ARRAY_BUFFER:
-      state_.vertex_attrib_manager->SetElementArrayBuffer(info);
+      state_.vertex_attrib_manager->SetElementArrayBuffer(buffer);
       break;
     default:
       NOTREACHED();  // Validation should prevent us getting here.
@@ -5848,8 +5847,8 @@ void GLES2DecoderImpl::RestoreStateForAttrib(GLuint attrib) {
   const VertexAttrib* info =
       state_.vertex_attrib_manager->GetVertexAttrib(attrib);
   const void* ptr = reinterpret_cast<const void*>(info->offset());
-  Buffer* buffer_info = info->buffer();
-  glBindBuffer(GL_ARRAY_BUFFER, buffer_info ? buffer_info->service_id() : 0);
+  Buffer* buffer = info->buffer();
+  glBindBuffer(GL_ARRAY_BUFFER, buffer ? buffer->service_id() : 0);
   glVertexAttribPointer(
       attrib, info->size(), info->type(), info->normalized(), info->gl_stride(),
       ptr);
@@ -6224,13 +6223,14 @@ error::Error GLES2DecoderImpl::HandleDrawElementsInstancedANGLE(
 GLuint GLES2DecoderImpl::DoGetMaxValueInBufferCHROMIUM(
     GLuint buffer_id, GLsizei count, GLenum type, GLuint offset) {
   GLuint max_vertex_accessed = 0;
-  Buffer* info = GetBuffer(buffer_id);
-  if (!info) {
+  Buffer* buffer = GetBuffer(buffer_id);
+  if (!buffer) {
     // TODO(gman): Should this be a GL error or a command buffer error?
     SetGLError(GL_INVALID_VALUE,
                "GetMaxValueInBufferCHROMIUM", "unknown buffer");
   } else {
-    if (!info->GetMaxValueForRange(offset, count, type, &max_vertex_accessed)) {
+    if (!buffer->GetMaxValueForRange(
+        offset, count, type, &max_vertex_accessed)) {
       // TODO(gman): Should this be a GL error or a command buffer error?
       SetGLError(
           GL_INVALID_OPERATION,
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest.cc b/gpu/command_buffer/service/gles2_cmd_decoder_unittest.cc
index 045e35d..ddab2df 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest.cc
@@ -4751,10 +4751,9 @@ TEST_F(GLES2DecoderTest, BufferDataGLError) {
   GLsizeiptr size = 4;
   DoBindBuffer(GL_ARRAY_BUFFER, client_buffer_id_, kServiceBufferId);
   BufferManager* manager = group().buffer_manager();
-  Buffer* info =
-      manager->GetBuffer(client_buffer_id_);
-  ASSERT_TRUE(info != NULL);
-  EXPECT_EQ(0, info->size());
+  Buffer* buffer = manager->GetBuffer(client_buffer_id_);
+  ASSERT_TRUE(buffer != NULL);
+  EXPECT_EQ(0, buffer->size());
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_OUT_OF_MEMORY))
@@ -4766,7 +4765,7 @@ TEST_F(GLES2DecoderTest, BufferDataGLError) {
   cmd.Init(target, size, 0, 0, GL_STREAM_DRAW);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
-  EXPECT_EQ(0, info->size());
+  EXPECT_EQ(0, buffer->size());
 }
 
 TEST_F(GLES2DecoderTest, CopyTexImage2DGLError) {