Refactor/Rename a bunch of GPU stuff

gpu/command_buffer/service/shader_manager.cc

Index: gpu/command_buffer/service/shader_manager.cc
diff --git a/gpu/command_buffer/service/shader_manager.cc b/gpu/command_buffer/service/shader_manager.cc
index 27ab5c9cbc050ff06fedf25c1ddb26b47974add1..b938801704e4e82dc1796456cbf9ff1100c13ee8 100644
--- a/gpu/command_buffer/service/shader_manager.cc
+++ b/gpu/command_buffer/service/shader_manager.cc
@@ -12,7 +12,7 @@
 namespace gpu {
 namespace gles2 {
 
-ShaderManager::ShaderInfo::ShaderInfo(GLuint service_id, GLenum shader_type)
+Shader::Shader(GLuint service_id, GLenum shader_type)
       : use_count_(0),
         service_id_(service_id),
         shader_type_(shader_type),
@@ -20,24 +20,24 @@ ShaderManager::ShaderInfo::ShaderInfo(GLuint service_id, GLenum shader_type)
         compilation_status_(NOT_COMPILED) {
 }
 
-ShaderManager::ShaderInfo::~ShaderInfo() {
+Shader::~Shader() {
 }
 
-void ShaderManager::ShaderInfo::IncUseCount() {
+void Shader::IncUseCount() {
   ++use_count_;
 }
 
-void ShaderManager::ShaderInfo::DecUseCount() {
+void Shader::DecUseCount() {
   --use_count_;
   DCHECK_GE(use_count_, 0);
 }
 
-void ShaderManager::ShaderInfo::MarkAsDeleted() {
+void Shader::MarkAsDeleted() {
   DCHECK_NE(service_id_, 0u);
   service_id_ = 0;
 }
 
-void ShaderManager::ShaderInfo::SetStatus(
+void Shader::SetStatus(
     bool valid, const char* log, ShaderTranslatorInterface* translator) {
   valid_ = valid;
   log_info_.reset(log ? new std::string(log) : NULL);
@@ -52,14 +52,14 @@ void ShaderManager::ShaderInfo::SetStatus(
   }
 }
 
-const ShaderManager::ShaderInfo::VariableInfo*
-    ShaderManager::ShaderInfo::GetAttribInfo(
+const Shader::VariableInfo*
+    Shader::GetAttribInfo(
         const std::string& name) const {
   VariableMap::const_iterator it = attrib_map_.find(name);
   return it != attrib_map_.end() ? &it->second : NULL;
 }
 
-const std::string* ShaderManager::ShaderInfo::GetAttribMappedName(
+const std::string* Shader::GetAttribMappedName(
     const std::string& original_name) const {
   for (VariableMap::const_iterator it = attrib_map_.begin();
        it != attrib_map_.end(); ++it) {
@@ -69,7 +69,7 @@ const std::string* ShaderManager::ShaderInfo::GetAttribMappedName(
   return NULL;
 }
 
-const std::string* ShaderManager::ShaderInfo::GetOriginalNameFromHashedName(
+const std::string* Shader::GetOriginalNameFromHashedName(
     const std::string& hashed_name) const {
   NameMap::const_iterator it = name_map_.find(hashed_name);
   if (it != name_map_.end())
@@ -77,8 +77,8 @@ const std::string* ShaderManager::ShaderInfo::GetOriginalNameFromHashedName(
   return NULL;
 }
 
-const ShaderManager::ShaderInfo::VariableInfo*
-    ShaderManager::ShaderInfo::GetUniformInfo(
+const Shader::VariableInfo*
+    Shader::GetUniformInfo(
         const std::string& name) const {
   VariableMap::const_iterator it = uniform_map_.find(name);
   return it != uniform_map_.end() ? &it->second : NULL;
@@ -93,7 +93,7 @@ ShaderManager::~ShaderManager() {
 void ShaderManager::Destroy(bool have_context) {
   while (!shader_infos_.empty()) {
     if (have_context) {
-      ShaderInfo* info = shader_infos_.begin()->second;
+      Shader* info = shader_infos_.begin()->second;
       if (!info->IsDeleted()) {
         glDeleteShader(info->service_id());
         info->MarkAsDeleted();
@@ -103,18 +103,19 @@ void ShaderManager::Destroy(bool have_context) {
   }
 }
 
-ShaderManager::ShaderInfo* ShaderManager::CreateShaderInfo(
+Shader* ShaderManager::CreateShader(
     GLuint client_id,
     GLuint service_id,
     GLenum shader_type) {
   std::pair<ShaderInfoMap::iterator, bool> result =
       shader_infos_.insert(std::make_pair(
-          client_id, ShaderInfo::Ref(new ShaderInfo(service_id, shader_type))));
+          client_id, scoped_refptr<Shader>(
+              new Shader(service_id, shader_type))));
   DCHECK(result.second);
   return result.first->second;
 }
 
-ShaderManager::ShaderInfo* ShaderManager::GetShaderInfo(GLuint client_id) {
+Shader* ShaderManager::GetShader(GLuint client_id) {
   ShaderInfoMap::iterator it = shader_infos_.find(client_id);
   return it != shader_infos_.end() ? it->second : NULL;
 }
@@ -131,7 +132,7 @@ bool ShaderManager::GetClientId(GLuint service_id, GLuint* client_id) const {
   return false;
 }
 
-bool ShaderManager::IsOwned(ShaderManager::ShaderInfo* info) {
+bool ShaderManager::IsOwned(Shader* info) {
   for (ShaderInfoMap::iterator it = shader_infos_.begin();
        it != shader_infos_.end(); ++it) {
     if (it->second.get() == info) {
@@ -141,7 +142,7 @@ bool ShaderManager::IsOwned(ShaderManager::ShaderInfo* info) {
   return false;
 }
 
-void ShaderManager::RemoveShaderInfoIfUnused(ShaderManager::ShaderInfo* info) {
+void ShaderManager::RemoveShader(Shader* info) {
   DCHECK(info);
   DCHECK(IsOwned(info));
   if (info->IsDeleted() && !info->InUse()) {
@@ -156,24 +157,24 @@ void ShaderManager::RemoveShaderInfoIfUnused(ShaderManager::ShaderInfo* info) {
   }
 }
 
-void ShaderManager::MarkAsDeleted(ShaderManager::ShaderInfo* info) {
+void ShaderManager::MarkAsDeleted(Shader* info) {
   DCHECK(info);
   DCHECK(IsOwned(info));
   info->MarkAsDeleted();
-  RemoveShaderInfoIfUnused(info);
+  RemoveShader(info);
 }
 
-void ShaderManager::UseShader(ShaderManager::ShaderInfo* info) {
+void ShaderManager::UseShader(Shader* info) {
   DCHECK(info);
   DCHECK(IsOwned(info));
   info->IncUseCount();
 }
 
-void ShaderManager::UnuseShader(ShaderManager::ShaderInfo* info) {
+void ShaderManager::UnuseShader(Shader* info) {
   DCHECK(info);
   DCHECK(IsOwned(info));
   info->DecUseCount();
-  RemoveShaderInfoIfUnused(info);
+  RemoveShader(info);
 }
 
 }  // namespace gles2