Update gpu/ to use scoped_refptr<T>::get() rather than implicit "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 541 matching lines @@
   ProgramCache* cache = manager_->program_cache_;
   if (cache) {
     ProgramCache::LinkedProgramStatus status = cache->GetLinkedProgramStatus(
         *attached_shaders_[0]->deferred_compilation_source(),
         vertex_translator,
         *attached_shaders_[1]->deferred_compilation_source(),
         fragment_translator,
         &bind_attrib_location_map_);
 
     if (status == ProgramCache::LINK_SUCCEEDED) {
-      ProgramCache::ProgramLoadResult success = cache->LoadLinkedProgram(
-                  service_id(),
-                  attached_shaders_[0],
-                  vertex_translator,
-                  attached_shaders_[1],
-                  fragment_translator,
-                  &bind_attrib_location_map_,
-                  shader_callback);
+      ProgramCache::ProgramLoadResult success =
+          cache->LoadLinkedProgram(service_id(),
+                                   attached_shaders_[0].get(),
+                                   vertex_translator,
+                                   attached_shaders_[1].get(),
+                                   fragment_translator,
+                                   &bind_attrib_location_map_,
+                                   shader_callback);
       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 = Program::kMaxAttachedShaders;
       for (int i = 0; i < kShaders; ++i) {
         Shader* shader = attached_shaders_[i].get();
         if (shader->compilation_status() ==
             Shader::PENDING_DEFERRED_COMPILE) {
           ShaderTranslator* translator = ShaderIndexToTranslator(
               i,
               vertex_translator,
               fragment_translator);
           manager_->ForceCompileShader(shader->deferred_compilation_source(),
-                                       attached_shaders_[i],
+                                       attached_shaders_[i].get(),
                                        translator,
                                        feature_info);
           DCHECK(shader->IsValid());
         }
       }
     }
   }
 
   if (link) {
     ExecuteBindAttribLocationCalls();
     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_[0].get(),
                                  vertex_translator,
-                                 attached_shaders_[1],
+                                 attached_shaders_[1].get(),
                                  fragment_translator,
                                  &bind_attrib_location_map_,
                                  shader_callback);
       }
       UMA_HISTOGRAM_CUSTOM_COUNTS(
           "GPU.ProgramCache.BinaryCacheMissTime",
           (TimeTicks::HighResNow() - before_time).InMicroseconds(),
           0,
           TimeDelta::FromSeconds(10).InMicroseconds(),
           50);
@@ skipping 318 matching lines @@
       break;
   }
 }
 
 bool Program::AttachShader(
     ShaderManager* shader_manager,
     Shader* shader) {
   DCHECK(shader_manager);
   DCHECK(shader);
   int index = ShaderTypeToIndex(shader->shader_type());
-  if (attached_shaders_[index] != NULL) {
+  if (attached_shaders_[index].get() != NULL) {
     return false;
   }
   attached_shaders_[index] = scoped_refptr<Shader>(shader);
   shader_manager->UseShader(shader);
   return true;
 }
 
 bool Program::DetachShader(
     ShaderManager* shader_manager,
     Shader* shader) {
   DCHECK(shader_manager);
   DCHECK(shader);
   if (attached_shaders_[ShaderTypeToIndex(shader->shader_type())].get() !=
       shader) {
     return false;
   }
   attached_shaders_[ShaderTypeToIndex(shader->shader_type())] = NULL;
   shader_manager->UnuseShader(shader);
   return true;
 }
 
 void Program::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 Program::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 Program::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) {
     // 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)
@@ skipping 126 matching lines @@
 }
 
 Program* ProgramManager::CreateProgram(
     GLuint client_id, GLuint service_id) {
   std::pair<ProgramMap::iterator, bool> result =
       programs_.insert(
           std::make_pair(client_id,
                          scoped_refptr<Program>(
                              new Program(this, service_id))));
   DCHECK(result.second);
-  return result.first->second;
+  return result.first->second.get();
 }
 
 Program* ProgramManager::GetProgram(GLuint client_id) {
   ProgramMap::iterator it = programs_.find(client_id);
   return it != programs_.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 (ProgramMap::const_iterator it = programs_.begin();
@@ skipping 71 matching lines @@
     program->ClearUniforms(&zero_);
   }
 }
 
 int32 ProgramManager::MakeFakeLocation(int32 index, int32 element) {
   return index + element * 0x10000;
 }
 
 }  // namespace gles2
 }  // namespace gpu