Remove implicit scoped_refptr operator T*

gpu/command_buffer/service/program_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/program_manager.h"
 
 #include <algorithm>
 #include <set>
 #include <utility>
 #include <vector>
@@ skipping 483 matching lines @@
   ProgramCache* cache = manager_->program_cache_;
   if (cache) {
     ProgramCache::LinkedProgramStatus status = cache->GetLinkedProgramStatus(
         *attached_shaders_[0]->deferred_compilation_source(),
         *attached_shaders_[1]->deferred_compilation_source(),
         &bind_attrib_location_map_);
 
     if (status == ProgramCache::LINK_SUCCEEDED) {
       ProgramCache::ProgramLoadResult success = cache->LoadLinkedProgram(
                   service_id(),
-                  attached_shaders_[0],
-                  attached_shaders_[1],
-                  &bind_attrib_location_map_);
+                  attached_shaders_[0].get(),
+                  attached_shaders_[1].get(),
+          &bind_attrib_location_map_);
       link = success != ProgramCache::PROGRAM_LOAD_SUCCESS;
       UMA_HISTOGRAM_BOOLEAN("GPU.ProgramCache.LoadBinarySuccess", !link);
     }
 
     if (link) {
       // compile our shaders if they're pending
       const int kShaders = ProgramManager::ProgramInfo::kMaxAttachedShaders;
       for (int i = 0; i < kShaders; ++i) {
         ShaderManager::ShaderInfo* info = attached_shaders_[i].get();
         if (info->compilation_status() ==
             ShaderManager::ShaderInfo::PENDING_DEFERRED_COMPILE) {
           ShaderTranslator* translator = ShaderIndexToTranslator(
               i,
               vertex_translator,
               fragment_translator);
           manager_->ForceCompileShader(info->deferred_compilation_source(),
-                                       attached_shaders_[i],
+                                       attached_shaders_[i].get(),
                                        translator,
                                        feature_info);
           CHECK(info->IsValid());
         }
       }
     }
   }
 
   if (link) {
     before_time = TimeTicks::HighResNow();
     if (cache && gfx::g_driver_gl.ext.b_GL_ARB_get_program_binary) {
       glProgramParameteri(service_id(),
                           PROGRAM_BINARY_RETRIEVABLE_HINT,
                           GL_TRUE);
     }
     glLinkProgram(service_id());
   }
 
   GLint success = 0;
   glGetProgramiv(service_id(), GL_LINK_STATUS, &success);
   if (success == GL_TRUE) {
     Update();
     if (link) {
       if (cache) {
         cache->SaveLinkedProgram(service_id(),
-                                 attached_shaders_[0],
-                                 attached_shaders_[1],
+                                 attached_shaders_[0].get(),
+                                 attached_shaders_[1].get(),
                                  &bind_attrib_location_map_);
       }
       UMA_HISTOGRAM_CUSTOM_COUNTS(
           "GPU.ProgramCache.BinaryCacheMissTime",
           (TimeTicks::HighResNow() - before_time).InMicroseconds(),
           0,
           TimeDelta::FromSeconds(10).InMicroseconds(),
           50);
     } else {
       UMA_HISTOGRAM_CUSTOM_COUNTS(
@@ skipping 127 matching lines @@
   DCHECK(size);
   DCHECK(type);
   const char* kArraySpec = "[0]";
   for (int jj = 0; jj < 2; ++jj) {
     std::string test_name(name + ((jj == 1) ? kArraySpec : ""));
     for (int ii = 0; ii < kMaxAttachedShaders; ++ii) {
       ShaderManager::ShaderInfo* shader_info = attached_shaders_[ii].get();
       if (shader_info) {
         const ShaderManager::ShaderInfo::VariableInfo* variable_info =
             use_uniforms ? shader_info->GetUniformInfo(test_name) :
-                           shader_info->GetAttribInfo(test_name);
+            shader_info->GetAttribInfo(test_name);
         // Note: There is an assuption here that if an attrib is defined in more
         // than 1 attached shader their types and sizes match. Should we check
         // for that case?
         if (variable_info) {
           *corrected_name = test_name;
           *original_name = variable_info->name;
           *type = variable_info->type;
           *size = variable_info->size;
           return;
         }
       }
     }
   }
   *corrected_name = name;
   *original_name = name;
 }
 
 bool ProgramManager::ProgramInfo::AddUniformInfo(
-        GLsizei size, GLenum type, GLint location, GLint fake_base_location,
-        const std::string& name, const std::string& original_name,
-        size_t* next_available_index) {
+    GLsizei size, GLenum type, GLint location, GLint fake_base_location,
+    const std::string& name, const std::string& original_name,
+    size_t* next_available_index) {
   DCHECK(next_available_index);
   const char* kArraySpec = "[0]";
   size_t uniform_index =
       fake_base_location >= 0 ? fake_base_location : *next_available_index;
   if (uniform_infos_.size() < uniform_index + 1) {
     uniform_infos_.resize(uniform_index + 1);
   }
 
   // return if this location is already in use.
   if (uniform_infos_[uniform_index].IsValid()) {
@@ skipping 27 matching lines @@
       }
     }
     for (GLsizei ii = 1; ii < info.size; ++ii) {
       std::string element_name(base_name + "[" + base::IntToString(ii) + "]");
       info.element_locations[ii] =
           glGetUniformLocation(service_id_, element_name.c_str());
     }
   }
 
   info.is_array =
-     (size > 1 ||
-      (info.name.size() > 3 &&
-       info.name.rfind(kArraySpec) == info.name.size() - 3));
+      (size > 1 ||
+       (info.name.size() > 3 &&
+        info.name.rfind(kArraySpec) == info.name.size() - 3));
 
   if (info.IsSampler()) {
     sampler_indices_.push_back(info.fake_location_base);
   }
   max_uniform_name_length_ =
       std::max(max_uniform_name_length_,
                static_cast<GLsizei>(info.name.size()));
 
   while (*next_available_index < uniform_infos_.size() &&
          uniform_infos_[*next_available_index].IsValid()) {
@@ skipping 41 matching lines @@
         return true;
       }
     }
   }
   return true;
 }
 
 void ProgramManager::ProgramInfo::GetProgramiv(GLenum pname, GLint* params) {
   switch (pname) {
     case GL_ACTIVE_ATTRIBUTES:
-      *params = attrib_infos_.size();
-      break;
+        *params = attrib_infos_.size();
+    break;
     case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH:
-      // Notice +1 to accomodate NULL terminator.
-      *params = max_attrib_name_length_ + 1;
-      break;
+        // Notice +1 to accomodate NULL terminator.
+        *params = max_attrib_name_length_ + 1;
+    break;
     case GL_ACTIVE_UNIFORMS:
-      *params = num_uniforms_;
-      break;
+        *params = num_uniforms_;
+    break;
     case GL_ACTIVE_UNIFORM_MAX_LENGTH:
-      // Notice +1 to accomodate NULL terminator.
-      *params = max_uniform_name_length_ + 1;
-      break;
+        // Notice +1 to accomodate NULL terminator.
+        *params = max_uniform_name_length_ + 1;
+    break;
     case GL_LINK_STATUS:
-      *params = link_status_;
-      break;
+        *params = link_status_;
+    break;
     case GL_INFO_LOG_LENGTH:
-      // Notice +1 to accomodate NULL terminator.
-      *params = log_info_.get() ? (log_info_->size() + 1) : 0;
-      break;
+        // Notice +1 to accomodate NULL terminator.
+        *params = log_info_.get() ? (log_info_->size() + 1) : 0;
+    break;
     case GL_DELETE_STATUS:
-      *params = deleted_;
-      break;
+        *params = deleted_;
+    break;
     case GL_VALIDATE_STATUS:
-      if (!IsValid()) {
-        *params = GL_FALSE;
-      } else {
+        if (!IsValid()) {
+      *params = GL_FALSE;
+    } else {
+      glGetProgramiv(service_id_, pname, params);
+    }
+    break;
+    default:
         glGetProgramiv(service_id_, pname, params);
-      }
-      break;
-    default:
-      glGetProgramiv(service_id_, pname, params);
-      break;
+    break;
   }
 }
 
 bool ProgramManager::ProgramInfo::AttachShader(
     ShaderManager* shader_manager,
     ShaderManager::ShaderInfo* info) {
   DCHECK(shader_manager);
   DCHECK(info);
   int index = ShaderTypeToIndex(info->shader_type());
-  if (attached_shaders_[index] != NULL) {
+  if (attached_shaders_[index].get() != NULL) {
     return false;
   }
   attached_shaders_[index] = ShaderManager::ShaderInfo::Ref(info);
   shader_manager->UseShader(info);
   return true;
 }
 
 bool ProgramManager::ProgramInfo::DetachShader(
     ShaderManager* shader_manager,
     ShaderManager::ShaderInfo* info) {
   DCHECK(shader_manager);
   DCHECK(info);
   if (attached_shaders_[ShaderTypeToIndex(info->shader_type())].get() != info) {
     return false;
   }
   attached_shaders_[ShaderTypeToIndex(info->shader_type())] = NULL;
   shader_manager->UnuseShader(info);
   return true;
 }
 
 void ProgramManager::ProgramInfo::DetachShaders(ShaderManager* shader_manager) {
   DCHECK(shader_manager);
   for (int ii = 0; ii < kMaxAttachedShaders; ++ii) {
-    if (attached_shaders_[ii]) {
-      DetachShader(shader_manager, attached_shaders_[ii]);
+    if (attached_shaders_[ii].get()) {
+      DetachShader(shader_manager, attached_shaders_[ii].get());
     }
   }
 }
 
 bool ProgramManager::ProgramInfo::CanLink() const {
   for (int ii = 0; ii < kMaxAttachedShaders; ++ii) {
-    if (!attached_shaders_[ii] || !attached_shaders_[ii]->IsValid()) {
+    if (!attached_shaders_[ii].get() || !attached_shaders_[ii]->IsValid()) {
       return false;
     }
   }
   return true;
 }
 
 bool ProgramManager::ProgramInfo::DetectAttribLocationBindingConflicts() const {
   std::set<GLint> location_binding_used;
   for (LocationMap::const_iterator it = bind_attrib_location_map_.begin();
-       it != bind_attrib_location_map_.end(); ++it) {
+  it != bind_attrib_location_map_.end(); ++it) {
     // Find out if an attribute is declared in this program's shaders.
     bool active = false;
     for (int ii = 0; ii < kMaxAttachedShaders; ++ii) {
-      if (!attached_shaders_[ii] || !attached_shaders_[ii]->IsValid())
+      if (!attached_shaders_[ii].get() || !attached_shaders_[ii]->IsValid())
         continue;
       if (attached_shaders_[ii]->GetAttribInfo(it->first)) {
         active = true;
         break;
       }
     }
     if (active) {
       std::pair<std::set<GLint>::iterator, bool> result =
           location_binding_used.insert(it->second);
       if (!result.second)
         return true;
     }
   }
   return false;
 }
 
 static uint32 ComputeOffset(const void* start, const void* position) {
   return static_cast<const uint8*>(position) -
-         static_cast<const uint8*>(start);
+      static_cast<const uint8*>(start);
 }
 
 void ProgramManager::ProgramInfo::GetProgramInfo(
     ProgramManager* manager, CommonDecoder::Bucket* bucket) const {
   // NOTE: It seems to me the math in here does not need check for overflow
   // because the data being calucated from has various small limits. The max
   // number of attribs + uniforms is somewhere well under 1024. The maximum size
   // of an identifier is 256 characters.
   uint32 num_locations = 0;
   uint32 total_string_size = 0;
@@ skipping 76 matching lines @@
       glDeleteProgram(service_id());
     }
     manager_->StopTracking(this);
     manager_ = NULL;
   }
 }
 
 
 ProgramManager::ProgramManager(ProgramCache* program_cache)
     : program_info_count_(0),
-      have_context_(true),
-      disable_workarounds_(
-          CommandLine::ForCurrentProcess()->HasSwitch(
-              switches::kDisableGpuDriverBugWorkarounds)),
-      program_cache_(program_cache) { }
+    have_context_(true),
+    disable_workarounds_(
+        CommandLine::ForCurrentProcess()->HasSwitch(
+            switches::kDisableGpuDriverBugWorkarounds)),
+            program_cache_(program_cache) { }
 
 ProgramManager::~ProgramManager() {
   DCHECK(program_infos_.empty());
 }
 
 void ProgramManager::Destroy(bool have_context) {
   have_context_ = have_context;
   program_infos_.clear();
 }
 
 void ProgramManager::StartTracking(ProgramManager::ProgramInfo* /* program */) {
   ++program_info_count_;
 }
 
 void ProgramManager::StopTracking(ProgramManager::ProgramInfo* /* program */) {
   --program_info_count_;
 }
 
 ProgramManager::ProgramInfo* ProgramManager::CreateProgramInfo(
     GLuint client_id, GLuint service_id) {
   std::pair<ProgramInfoMap::iterator, bool> result =
       program_infos_.insert(
           std::make_pair(client_id,
                          ProgramInfo::Ref(new ProgramInfo(this, service_id))));
   DCHECK(result.second);
-  return result.first->second;
+  return result.first->second.get();
 }
 
 ProgramManager::ProgramInfo* ProgramManager::GetProgramInfo(GLuint client_id) {
   ProgramInfoMap::iterator it = program_infos_.find(client_id);
-  return it != program_infos_.end() ? it->second : NULL;
+  return .get()
+      return it != program_infos_.end() ? it->second : NULL;
 }
 
 bool ProgramManager::GetClientId(GLuint service_id, GLuint* client_id) const {
   // This doesn't need to be fast. It's only used during slow queries.
   for (ProgramInfoMap::const_iterator it = program_infos_.begin();
        it != program_infos_.end(); ++it) {
     if (it->second->service_id() == service_id) {
       *client_id = it->first;
       return true;
     }
@@ skipping 66 matching lines @@
     info->ClearUniforms(&zero_);
   }
 }
 
 int32 ProgramManager::MakeFakeLocation(int32 index, int32 element) {
   return index + element * 0x10000;
 }
 
 }  // namespace gles2
 }  // namespace gpu