Remove implicit conversions from scoped_refptr to T* in gpu/

gpu/command_buffer/service/texture_definition.cc

 // Copyright 2014 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_definition.h"
 
 #include <list>
 
 #include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 40 matching lines @@
  private:
   scoped_refptr<NativeImageBuffer> buffer_;
   gfx::Size size_;
 
   DISALLOW_COPY_AND_ASSIGN(GLImageSync);
 };
 
 GLImageSync::GLImageSync(const scoped_refptr<NativeImageBuffer>& buffer,
                          const gfx::Size& size)
     : buffer_(buffer), size_(size) {
-  if (buffer)
+  if (buffer.get())
     buffer->AddClient(this);
 }
 
 GLImageSync::~GLImageSync() {
-  if (buffer_)
+  if (buffer_.get())
     buffer_->RemoveClient(this);
 }
 
 void GLImageSync::Destroy(bool have_context) {
 }
 
 gfx::Size GLImageSync::GetSize() {
   return size_;
 }
 
 bool GLImageSync::BindTexImage(unsigned target) {
   NOTREACHED();
   return false;
 }
 
 void GLImageSync::ReleaseTexImage(unsigned target) {
   NOTREACHED();
 }
 
 void GLImageSync::WillUseTexImage() {
-  if (buffer_)
+  if (buffer_.get())
     buffer_->WillRead(this);
 }
 
 void GLImageSync::DidUseTexImage() {
-  if (buffer_)
+  if (buffer_.get())
     buffer_->DidRead(this);
 }
 
 void GLImageSync::WillModifyTexImage() {
-  if (buffer_)
+  if (buffer_.get())
     buffer_->WillWrite(this);
 }
 
 void GLImageSync::DidModifyTexImage() {
-  if (buffer_)
+  if (buffer_.get())
     buffer_->DidWrite(this);
 }
 
 bool GLImageSync::ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
                                        int z_order,
                                        gfx::OverlayTransform transform,
                                        const gfx::Rect& bounds_rect,
                                        const gfx::RectF& crop_rect) {
   NOTREACHED();
   return false;
@@ skipping 244 matching lines @@
 
 TextureDefinition::LevelInfo::~LevelInfo() {}
 
 TextureDefinition::TextureDefinition(
     GLenum target,
     Texture* texture,
     unsigned int version,
     const scoped_refptr<NativeImageBuffer>& image_buffer)
     : version_(version),
       target_(target),
-      image_buffer_(image_buffer ? image_buffer : NativeImageBuffer::Create(
-                                                      texture->service_id())),
+      image_buffer_(image_buffer.get()
+                        ? image_buffer
+                        : NativeImageBuffer::Create(texture->service_id())),
       min_filter_(texture->min_filter()),
       mag_filter_(texture->mag_filter()),
       wrap_s_(texture->wrap_s()),
       wrap_t_(texture->wrap_t()),
       usage_(texture->usage()),
       immutable_(texture->IsImmutable()) {
-
   // TODO
   DCHECK(!texture->level_infos_.empty());
   DCHECK(!texture->level_infos_[0].empty());
   DCHECK(!texture->NeedsMips());
   DCHECK(texture->level_infos_[0][0].width);
   DCHECK(texture->level_infos_[0][0].height);
 
   scoped_refptr<gfx::GLImage> gl_image(
       new GLImageSync(image_buffer_,
                       gfx::Size(texture->level_infos_[0][0].width,
                                 texture->level_infos_[0][0].height)));
-  texture->SetLevelImage(NULL, target, 0, gl_image);
+  texture->SetLevelImage(NULL, target, 0, gl_image.get());
 
   // TODO: all levels
   level_infos_.clear();
   const Texture::LevelInfo& level = texture->level_infos_[0][0];
   LevelInfo info(level.target,
                  level.internal_format,
                  level.width,
                  level.height,
                  level.depth,
                  level.border,
                  level.format,
                  level.type,
                  level.cleared);
   std::vector<LevelInfo> infos;
   infos.push_back(info);
   level_infos_.push_back(infos);
 }
 
 TextureDefinition::~TextureDefinition() {
 }
 
 Texture* TextureDefinition::CreateTexture() const {
-  if (!image_buffer_)
+  if (!image_buffer_.get())
     return NULL;
 
   GLuint texture_id;
   glGenTextures(1, &texture_id);
 
   Texture* texture(new Texture(texture_id));
   UpdateTexture(texture);
 
   return texture;
 }
 
 void TextureDefinition::UpdateTexture(Texture* texture) const {
   gfx::ScopedTextureBinder texture_binder(target_, texture->service_id());
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, min_filter_);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, mag_filter_);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrap_s_);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrap_t_);
-  if (image_buffer_)
+  if (image_buffer_.get())
     image_buffer_->BindToTexture(target_);
   // We have to make sure the changes are visible to other clients in this share
   // group. As far as the clients are concerned, the mailbox semantics only
   // demand a single flush from the client after changes are first made,
   // and it is not visible to them when another share group boundary is crossed.
   // We could probably track this and be a bit smarter about when to flush
   // though.
   glFlush();
 
   texture->level_infos_.resize(1);
@@ skipping 11 matching lines @@
                             info.internal_format,
                             info.width,
                             info.height,
                             info.depth,
                             info.border,
                             info.format,
                             info.type,
                             info.cleared);
     }
   }
-  if (image_buffer_) {
+  if (image_buffer_.get()) {
     texture->SetLevelImage(
         NULL,
         target_,
         0,
         new GLImageSync(
             image_buffer_,
             gfx::Size(level_infos_[0][0].width, level_infos_[0][0].height)));
   }
 
   texture->target_ = target_;
   texture->SetImmutable(immutable_);
   texture->min_filter_ = min_filter_;
   texture->mag_filter_ = mag_filter_;
   texture->wrap_s_ = wrap_s_;
   texture->wrap_t_ = wrap_t_;
   texture->usage_ = usage_;
 }
 
 bool TextureDefinition::Matches(const Texture* texture) const {
   DCHECK(target_ == texture->target());
   if (texture->min_filter_ != min_filter_ ||
       texture->mag_filter_ != mag_filter_ ||
       texture->wrap_s_ != wrap_s_ ||
       texture->wrap_t_ != wrap_t_) {
     return false;
   }
 
   // All structural changes should have orphaned the texture.
-  if (image_buffer_ && !texture->GetLevelImage(texture->target(), 0))
+  if (image_buffer_.get() && !texture->GetLevelImage(texture->target(), 0))
     return false;
 
   return true;
 }
 
 }  // namespace gles2
 }  // namespace gpu