Update gpu/ to use scoped_refptr<T>::get() rather than implicit "operator T*"

gpu/command_buffer/service/texture_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/texture_manager.h"
 #include "base/bits.h"
 #include "base/stringprintf.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/service/error_state.h"
 #include "gpu/command_buffer/service/feature_info.h"
@@ skipping 338 matching lines @@
   // Can't generate mips for depth or stencil textures.
   const Texture::LevelInfo& first = level_infos_[0][0];
   uint32 channels = GLES2Util::GetChannelsForFormat(first.format);
   if (channels & (GLES2Util::kDepth | GLES2Util::kStencil)) {
     return false;
   }
 
   // TODO(gman): Check internal_format, format and type.
   for (size_t ii = 0; ii < level_infos_.size(); ++ii) {
     const LevelInfo& info = level_infos_[ii][0];
-    if ((info.target == 0) ||
-        (info.width != first.width) ||
-        (info.height != first.height) ||
-        (info.depth != 1) ||
+    if ((info.target == 0) || (info.width != first.width) ||
+        (info.height != first.height) || (info.depth != 1) ||
         (info.format != first.format) ||
         (info.internal_format != first.internal_format) ||
         (info.type != first.type) ||
         feature_info->validators()->compressed_texture_format.IsValid(
             info.internal_format) ||
-        info.image) {
-        return false;
+        info.image.get()) {
+      return false;
     }
   }
   return true;
 }
 
 void Texture::SetLevelCleared(GLenum target, GLint level, bool cleared) {
   DCHECK_GE(level, 0);
   DCHECK_LT(static_cast<size_t>(GLTargetToFaceIndex(target)),
             level_infos_.size());
   DCHECK_LT(static_cast<size_t>(level),
@@ skipping 406 matching lines @@
   UpdateCanRenderCondition();
 }
 
 gfx::GLImage* Texture::GetLevelImage(
   GLint target, GLint level) const {
   size_t face_index = GLTargetToFaceIndex(target);
   if (level >= 0 && face_index < level_infos_.size() &&
       static_cast<size_t>(level) < level_infos_[face_index].size()) {
     const LevelInfo& info = level_infos_[GLTargetToFaceIndex(target)][level];
     if (info.target != 0) {
-      return info.image;
+      return info.image.get();
     }
   }
   return 0;
 }
 
 
 TextureRef::TextureRef(TextureManager* manager,
                        GLuint client_id,
                        Texture* texture)
     : manager_(manager),
@@ skipping 94 matching lines @@
       } else {
         glTexImage2D(target, 0, GL_RGBA, 1, 1, 0, GL_RGBA,
                      GL_UNSIGNED_BYTE, black);
       }
     }
   }
   glBindTexture(target, 0);
 
   scoped_refptr<TextureRef> default_texture(
       TextureRef::Create(this, 0, ids[1]));
-  SetTarget(default_texture, target);
+  SetTarget(default_texture.get(), target);
   if (needs_faces) {
     for (int ii = 0; ii < GLES2Util::kNumFaces; ++ii) {
-      SetLevelInfo(
-          default_texture, GLES2Util::IndexToGLFaceTarget(ii),
-          0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
+      SetLevelInfo(default_texture.get(),
+                   GLES2Util::IndexToGLFaceTarget(ii),
+                   0,
+                   GL_RGBA,
+                   1,
+                   1,
+                   1,
+                   0,
+                   GL_RGBA,
+                   GL_UNSIGNED_BYTE,
+                   true);
     }
   } else {
     if (needs_initialization) {
-      SetLevelInfo(default_texture,
-                   GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0,
-                   GL_RGBA, GL_UNSIGNED_BYTE, true);
+      SetLevelInfo(default_texture.get(),
+                   GL_TEXTURE_2D,
+                   0,
+                   GL_RGBA,
+                   1,
+                   1,
+                   1,
+                   0,
+                   GL_RGBA,
+                   GL_UNSIGNED_BYTE,
+                   true);
     } else {
-      SetLevelInfo(
-          default_texture, GL_TEXTURE_EXTERNAL_OES, 0,
-          GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
+      SetLevelInfo(default_texture.get(),
+                   GL_TEXTURE_EXTERNAL_OES,
+                   0,
+                   GL_RGBA,
+                   1,
+                   1,
+                   1,
+                   0,
+                   GL_RGBA,
+                   GL_UNSIGNED_BYTE,
+                   true);
     }
   }
 
   *black_texture = ids[0];
   return default_texture;
 }
 
 bool TextureManager::ValidForTarget(
     GLenum target, GLint level, GLsizei width, GLsizei height, GLsizei depth) {
   GLsizei max_size = MaxSizeForTarget(target) >> level;
   return level >= 0 &&
          width >= 0 &&
          height >= 0 &&
          depth >= 0 &&
          level < MaxLevelsForTarget(target) &&
          width <= max_size &&
          height <= max_size &&
          depth <= max_size &&
          (level == 0 || feature_info_->feature_flags().npot_ok ||
           (!GLES2Util::IsNPOT(width) &&
            !GLES2Util::IsNPOT(height) &&
            !GLES2Util::IsNPOT(depth))) &&
          (target != GL_TEXTURE_CUBE_MAP || (width == height && depth == 1)) &&
          (target != GL_TEXTURE_2D || (depth == 1));
 }
 
 void TextureManager::SetTarget(TextureRef* ref, GLenum target) {
   DCHECK(ref);
-  ref->texture()->SetTarget(feature_info_, target, MaxLevelsForTarget(target));
+  ref->texture()
+      ->SetTarget(feature_info_.get(), target, MaxLevelsForTarget(target));
 }
 
 void TextureManager::SetStreamTexture(TextureRef* ref, bool stream_texture) {
   DCHECK(ref);
   ref->texture()->SetStreamTexture(stream_texture);
 }
 
 void TextureManager::SetLevelCleared(TextureRef* ref,
                                      GLenum target,
                                      GLint level,
@@ skipping 30 matching lines @@
     GLsizei height,
     GLsizei depth,
     GLint border,
     GLenum format,
     GLenum type,
     bool cleared) {
   DCHECK(ref);
   Texture* texture = ref->texture();
 
   texture->GetMemTracker()->TrackMemFree(texture->estimated_size());
-  texture->SetLevelInfo(
-      feature_info_, target, level, internal_format, width, height, depth,
-      border, format, type, cleared);
+  texture->SetLevelInfo(feature_info_.get(),
+                        target,
+                        level,
+                        internal_format,
+                        width,
+                        height,
+                        depth,
+                        border,
+                        format,
+                        type,
+                        cleared);
   texture->GetMemTracker()->TrackMemAlloc(texture->estimated_size());
 }
 
 Texture* TextureManager::Produce(TextureRef* ref) {
   DCHECK(ref);
   Texture* texture = ref->texture();
   if (!texture->owned_)
     return NULL;
   return texture;
 }
 
 TextureRef* TextureManager::Consume(
     GLuint client_id,
     Texture* texture) {
   DCHECK(client_id);
   scoped_refptr<TextureRef> ref(new TextureRef(this, client_id, texture));
   bool result = textures_.insert(std::make_pair(client_id, ref)).second;
   DCHECK(result);
   return ref.get();
 }
 
 void TextureManager::SetParameter(
     const char* function_name, ErrorState* error_state,
     TextureRef* ref, GLenum pname, GLint param) {
   DCHECK(error_state);
   DCHECK(ref);
   Texture* texture = ref->texture();
-  GLenum result = texture->SetParameter(feature_info_, pname, param);
+  GLenum result = texture->SetParameter(feature_info_.get(), pname, param);
   if (result != GL_NO_ERROR) {
     if (result == GL_INVALID_ENUM) {
       ERRORSTATE_SET_GL_ERROR_INVALID_ENUM(
           error_state, function_name, param, "param");
     } else {
       ERRORSTATE_SET_GL_ERROR_INVALID_PARAM(
           error_state, result, function_name, pname, static_cast<GLint>(param));
     }
   } else {
     // Texture tracking pools exist only for the command decoder, so
     // do not pass them on to the native GL implementation.
     if (pname != GL_TEXTURE_POOL_CHROMIUM) {
       glTexParameteri(texture->target(), pname, param);
     }
   }
 }
 
 bool TextureManager::MarkMipmapsGenerated(TextureRef* ref) {
   DCHECK(ref);
   Texture* texture = ref->texture();
   texture->GetMemTracker()->TrackMemFree(texture->estimated_size());
-  bool result = texture->MarkMipmapsGenerated(feature_info_);
+  bool result = texture->MarkMipmapsGenerated(feature_info_.get());
   texture->GetMemTracker()->TrackMemAlloc(texture->estimated_size());
   return result;
 }
 
 TextureRef* TextureManager::CreateTexture(
     GLuint client_id, GLuint service_id) {
   DCHECK_NE(0u, service_id);
   scoped_refptr<TextureRef> ref(TextureRef::Create(
       this, client_id, service_id));
   std::pair<TextureMap::iterator, bool> result =
@@ skipping 15 matching lines @@
     textures_.erase(it);
   }
 }
 
 void TextureManager::StartTracking(TextureRef* ref) {
   Texture* texture = ref->texture();
   ++texture_count_;
   num_uncleared_mips_ += texture->num_uncleared_mips();
   if (!texture->SafeToRenderFrom())
     ++num_unsafe_textures_;
-  if (!texture->CanRender(feature_info_))
+  if (!texture->CanRender(feature_info_.get()))
     ++num_unrenderable_textures_;
 }
 
 void TextureManager::StopTracking(TextureRef* ref) {
   FOR_EACH_OBSERVER(DestructionObserver,
                     destruction_observers_,
                     OnTextureRefDestroying(ref));
 
   Texture* texture = ref->texture();
   --texture_count_;
-  if (!texture->CanRender(feature_info_)) {
+  if (!texture->CanRender(feature_info_.get())) {
     DCHECK_NE(0, num_unrenderable_textures_);
     --num_unrenderable_textures_;
   }
   if (!texture->SafeToRenderFrom()) {
     DCHECK_NE(0, num_unsafe_textures_);
     --num_unsafe_textures_;
   }
   num_uncleared_mips_ -= texture->num_uncleared_mips();
   DCHECK_GE(num_uncleared_mips_, 0);
 }
@@ skipping 28 matching lines @@
     GLsizei width, GLsizei height, GLsizei depth) {
   return 1 + base::bits::Log2Floor(std::max(std::max(width, height), depth));
 }
 
 void TextureManager::SetLevelImage(
     TextureRef* ref,
     GLenum target,
     GLint level,
     gfx::GLImage* image) {
   DCHECK(ref);
-  ref->texture()->SetLevelImage(feature_info_, target, level, image);
+  ref->texture()->SetLevelImage(feature_info_.get(), target, level, image);
 }
 
 void TextureManager::AddToSignature(
     TextureRef* ref,
     GLenum target,
     GLint level,
     std::string* signature) const {
   ref->texture()->AddToSignature(feature_info_.get(), target, level, signature);
 }
 
@@ skipping 23 matching lines @@
 }
 
 void TextureManager::IncFramebufferStateChangeCount() {
   if (framebuffer_manager_)
     framebuffer_manager_->IncFramebufferStateChangeCount();
 
 }
 
 }  // namespace gles2
 }  // namespace gpu