Refactor/Rename a bunch of GPU stuff

gpu/command_buffer/client/program_info_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 <map>
 
 #include "base/compiler_specific.h"
 #include "../client/program_info_manager.h"
 #include "../client/atomicops.h"
 #include "../client/gles2_implementation.h"
@@ skipping 124 matching lines @@
   virtual bool GetActiveUniform(GLES2Implementation* gl,
                                 GLuint program,
                                 GLuint index,
                                 GLsizei bufsize,
                                 GLsizei* length,
                                 GLint* size,
                                 GLenum* type,
                                 char* name) OVERRIDE;
 
  private:
-  class ProgramInfo {
+  class Program {
    public:
     struct UniformInfo {
       UniformInfo(GLsizei _size, GLenum _type, const std::string& _name);
 
       GLsizei size;
       GLenum type;
       bool is_array;
       std::string name;
       std::vector<GLint> element_locations;
     };
-    struct VertexAttribInfo {
-      VertexAttribInfo(GLsizei _size, GLenum _type, const std::string& _name,
+    struct VertexAttrib {
+      VertexAttrib(GLsizei _size, GLenum _type, const std::string& _name,
                        GLint _location)
           : size(_size),
             type(_type),
             location(_location),
             name(_name) {
       }
       GLsizei size;
       GLenum type;
       GLint location;
       std::string name;
     };
 
     typedef std::vector<UniformInfo> UniformInfoVector;
-    typedef std::vector<VertexAttribInfo> AttribInfoVector;
+    typedef std::vector<VertexAttrib> AttribInfoVector;
 
-    ProgramInfo();
+    Program();
 
     const AttribInfoVector& GetAttribInfos() const {
       return attrib_infos_;
     }
 
-    const VertexAttribInfo* GetAttribInfo(GLint index) const {
+    const VertexAttrib* GetAttribInfo(GLint index) const {
       return (static_cast<size_t>(index) < attrib_infos_.size()) ?
          &attrib_infos_[index] : NULL;
     }
 
     GLint GetAttribLocation(const std::string& name) const;
 
     const UniformInfo* GetUniformInfo(GLint index) const {
       return (static_cast<size_t>(index) < uniform_infos_.size()) ?
          &uniform_infos_[index] : NULL;
     }
@@ skipping 16 matching lines @@
 
     GLsizei max_uniform_name_length_;
 
     // Uniform info by index.
     UniformInfoVector uniform_infos_;
 
     // This is true if glLinkProgram was successful last time it was called.
     bool link_status_;
   };
 
-  ProgramInfo* GetProgramInfo(GLES2Implementation* gl, GLuint program);
+  Program* GetProgramInfo(GLES2Implementation* gl, GLuint program);
 
   // TODO(gman): Switch to a faster container.
-  typedef std::map<GLuint, ProgramInfo> ProgramInfoMap;
+  typedef std::map<GLuint, Program> ProgramInfoMap;
 
   ProgramInfoMap program_infos_;
 
   mutable Lock lock_;
 };
 
-CachedProgramInfoManager::ProgramInfo::UniformInfo::UniformInfo(
+CachedProgramInfoManager::Program::UniformInfo::UniformInfo(
     GLsizei _size, GLenum _type, const std::string& _name)
     : size(_size),
       type(_type),
       name(_name) {
   is_array = (!name.empty() && name[name.size() - 1] == ']');
   GPU_DCHECK(!(size > 1 && !is_array));
 }
 
-CachedProgramInfoManager::ProgramInfo::ProgramInfo()
+CachedProgramInfoManager::Program::Program()
     : cached_(false),
       max_attrib_name_length_(0),
       max_uniform_name_length_(0),
       link_status_(false) {
 }
 
 // TODO(gman): Add a faster lookup.
-GLint CachedProgramInfoManager::ProgramInfo::GetAttribLocation(
+GLint CachedProgramInfoManager::Program::GetAttribLocation(
     const std::string& name) const {
   for (GLuint ii = 0; ii < attrib_infos_.size(); ++ii) {
-    const VertexAttribInfo& info = attrib_infos_[ii];
+    const VertexAttrib& info = attrib_infos_[ii];
     if (info.name == name) {
       return info.location;
     }
   }
   return -1;
 }
 
-GLint CachedProgramInfoManager::ProgramInfo::GetUniformLocation(
+GLint CachedProgramInfoManager::Program::GetUniformLocation(
     const std::string& name) const {
   bool getting_array_location = false;
   size_t open_pos = std::string::npos;
   int index = 0;
   if (!GLES2Util::ParseUniformName(
       name, &open_pos, &index, &getting_array_location)) {
     return -1;
   }
   for (GLuint ii = 0; ii < uniform_infos_.size(); ++ii) {
     const UniformInfo& info = uniform_infos_[ii];
     if (info.name == name ||
         (info.is_array &&
          info.name.compare(0, info.name.size() - 3, name) == 0)) {
       return info.element_locations[0];
     } else if (getting_array_location && info.is_array) {
       // Look for an array specification.
       size_t open_pos_2 = info.name.find_last_of('[');
       if (open_pos_2 == open_pos &&
           name.compare(0, open_pos, info.name, 0, open_pos) == 0) {
         if (index >= 0 && index < info.size) {
           return info.element_locations[index];
         }
       }
     }
   }
   return -1;
 }
 
-bool CachedProgramInfoManager::ProgramInfo::GetProgramiv(
+bool CachedProgramInfoManager::Program::GetProgramiv(
     GLenum pname, GLint* params) {
   switch (pname) {
     case GL_LINK_STATUS:
       *params = link_status_;
       return true;
     case GL_ACTIVE_ATTRIBUTES:
       *params = attrib_infos_.size();
       return true;
     case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH:
       *params = max_attrib_name_length_;
@@ skipping 13 matching lines @@
 template<typename T> static T LocalGetAs(
     const std::vector<int8>& data, uint32 offset, size_t size) {
   const int8* p = &data[0] + offset;
   if (offset + size > data.size()) {
     GPU_NOTREACHED();
     return NULL;
   }
   return static_cast<T>(static_cast<const void*>(p));
 }
 
-void CachedProgramInfoManager::ProgramInfo::Update(
+void CachedProgramInfoManager::Program::Update(
     GLES2Implementation* gl, GLuint program) {
   if (cached_) {
     return;
   }
   std::vector<int8> result;
   gl->GetProgramInfoCHROMIUMHelper(program, &result);
   if (result.empty()) {
     // This should only happen on a lost context.
     return;
   }
@@ skipping 12 matching lines @@
       result, sizeof(*header),
       sizeof(ProgramInput) * (header->num_attribs + header->num_uniforms));
   const ProgramInput* input = inputs;
   for (uint32 ii = 0; ii < header->num_attribs; ++ii) {
     const int32* location = LocalGetAs<const int32*>(
         result, input->location_offset, sizeof(int32));
     const char* name_buf = LocalGetAs<const char*>(
         result, input->name_offset, input->name_length);
     std::string name(name_buf, input->name_length);
     attrib_infos_.push_back(
-        VertexAttribInfo(input->size, input->type, name, *location));
+        VertexAttrib(input->size, input->type, name, *location));
     max_attrib_name_length_ = std::max(
         static_cast<GLsizei>(name.size() + 1), max_attrib_name_length_);
     ++input;
   }
   for (uint32 ii = 0; ii < header->num_uniforms; ++ii) {
     const int32* locations = LocalGetAs<const int32*>(
         result, input->location_offset, sizeof(int32) * input->size);
     const char* name_buf = LocalGetAs<const char*>(
         result, input->name_offset, input->name_length);
     std::string name(name_buf, input->name_length);
@@ skipping 11 matching lines @@
   cached_ = true;
 }
 
 CachedProgramInfoManager::CachedProgramInfoManager() {
 }
 
 CachedProgramInfoManager::~CachedProgramInfoManager() {
 
 }
 
-CachedProgramInfoManager::ProgramInfo*
+CachedProgramInfoManager::Program*
     CachedProgramInfoManager::GetProgramInfo(
         GLES2Implementation* gl, GLuint program) {
   ProgramInfoMap::iterator it = program_infos_.find(program);
   if (it == program_infos_.end()) {
     return NULL;
   }
-  ProgramInfo* info = &it->second;
+  Program* info = &it->second;
   info->Update(gl, program);
   return info;
 }
 
 void CachedProgramInfoManager::CreateInfo(GLuint program) {
   AutoLock auto_lock(lock_);
   DeleteInfo(program);
   std::pair<ProgramInfoMap::iterator, bool> result =
-      program_infos_.insert(std::make_pair(program, ProgramInfo()));
+      program_infos_.insert(std::make_pair(program, Program()));
 
   GPU_DCHECK(result.second);
 }
 
 void CachedProgramInfoManager::DeleteInfo(GLuint program) {
   program_infos_.erase(program);
 }
 
 bool CachedProgramInfoManager::GetProgramiv(
     GLES2Implementation* gl, GLuint program, GLenum pname, GLint* params) {
   AutoLock auto_lock(lock_);
-  ProgramInfo* info = GetProgramInfo(gl, program);
+  Program* info = GetProgramInfo(gl, program);
   if (!info) {
     return false;
   }
   return info->GetProgramiv(pname, params);
 }
 
 GLint CachedProgramInfoManager::GetAttribLocation(
     GLES2Implementation* gl, GLuint program, const char* name) {
   AutoLock auto_lock(lock_);
-  ProgramInfo* info = GetProgramInfo(gl, program);
+  Program* info = GetProgramInfo(gl, program);
   if (info) {
     return info->GetAttribLocation(name);
   }
   return gl->GetAttribLocationHelper(program, name);
 }
 
 GLint CachedProgramInfoManager::GetUniformLocation(
     GLES2Implementation* gl, GLuint program, const char* name) {
   AutoLock auto_lock(lock_);
-  ProgramInfo* info = GetProgramInfo(gl, program);
+  Program* info = GetProgramInfo(gl, program);
   if (info) {
     return info->GetUniformLocation(name);
   }
   return gl->GetUniformLocationHelper(program, name);
 }
 
 bool CachedProgramInfoManager::GetActiveAttrib(
     GLES2Implementation* gl,
     GLuint program, GLuint index, GLsizei bufsize, GLsizei* length,
     GLint* size, GLenum* type, char* name) {
   AutoLock auto_lock(lock_);
-  ProgramInfo* info = GetProgramInfo(gl, program);
+  Program* info = GetProgramInfo(gl, program);
   if (info) {
-    const ProgramInfo::VertexAttribInfo* attrib_info =
+    const Program::VertexAttrib* attrib_info =
         info->GetAttribInfo(index);
     if (attrib_info) {
       if (size) {
         *size = attrib_info->size;
       }
       if (type) {
         *type = attrib_info->type;
       }
       if (length || name) {
         GLsizei max_size = std::min(static_cast<size_t>(bufsize) - 1,
@@ skipping 12 matching lines @@
   }
   return gl->GetActiveAttribHelper(
       program, index, bufsize, length, size, type, name);
 }
 
 bool CachedProgramInfoManager::GetActiveUniform(
     GLES2Implementation* gl,
     GLuint program, GLuint index, GLsizei bufsize, GLsizei* length,
     GLint* size, GLenum* type, char* name) {
   AutoLock auto_lock(lock_);
-  ProgramInfo* info = GetProgramInfo(gl, program);
+  Program* info = GetProgramInfo(gl, program);
   if (info) {
-    const ProgramInfo::UniformInfo* uniform_info = info->GetUniformInfo(index);
+    const Program::UniformInfo* uniform_info = info->GetUniformInfo(index);
     if (uniform_info) {
       if (size) {
         *size = uniform_info->size;
       }
       if (type) {
         *type = uniform_info->type;
       }
       if (length || name) {
         GLsizei max_size = std::min(static_cast<size_t>(bufsize) - 1,
                                     std::max(static_cast<size_t>(0),
@@ skipping 24 matching lines @@
   if (shared_resources_across_processes) {
     return new NonCachedProgramInfoManager();
   } else {
     return new CachedProgramInfoManager();
   }
 }
 
 }  // namespace gles2
 }  // namespace gpu