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

content/common/gpu/texture_image_transport_surface.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 "content/common/gpu/texture_image_transport_surface.h"
 
 #include <string>
 #include <vector>
 
 #include "base/command_line.h"
@@ skipping 39 matching lines @@
   DCHECK(stub_destroyed_);
   Destroy();
 }
 
 bool TextureImageTransportSurface::Initialize() {
   mailbox_manager_ =
       helper_->stub()->decoder()->GetContextGroup()->mailbox_manager();
 
   GpuChannelManager* manager = helper_->manager();
   surface_ = manager->GetDefaultOffscreenSurface();
-  if (!surface_)
+  if (!surface_.get())
     return false;
 
   if (!helper_->Initialize())
     return false;
 
   GpuChannel* parent_channel = manager->LookupChannel(handle_.parent_client_id);
   if (parent_channel) {
     const CommandLine* command_line = CommandLine::ForCurrentProcess();
     if (command_line->HasSwitch(switches::kUIPrioritizeInGpuProcess))
       helper_->SetPreemptByFlag(parent_channel->GetPreemptionFlag());
   }
 
   return true;
 }
 
 void TextureImageTransportSurface::Destroy() {
-  if (surface_)
+  if (surface_.get())
     surface_ = NULL;
 
   helper_->Destroy();
 }
 
 bool TextureImageTransportSurface::DeferDraws() {
   // The command buffer hit a draw/clear command that could clobber the
   // texture in use by the UI compositor. If a Swap is pending, abort
   // processing of the command by returning true and unschedule until the Swap
   // Ack arrives.
@@ skipping 22 matching lines @@
   return fbo_id_;
 }
 
 bool TextureImageTransportSurface::SetBackbufferAllocation(bool allocation) {
   DCHECK(!is_swap_buffers_pending_);
   if (backbuffer_suggested_allocation_ == allocation)
      return true;
   backbuffer_suggested_allocation_ = allocation;
 
   if (backbuffer_suggested_allocation_) {
-    DCHECK(!backbuffer_);
+    DCHECK(!backbuffer_.get());
     CreateBackTexture();
   } else {
     ReleaseBackTexture();
   }
 
   return true;
 }
 
 void TextureImageTransportSurface::SetFrontbufferAllocation(bool allocation) {
   if (frontbuffer_suggested_allocation_ == allocation)
@@ skipping 56 matching lines @@
   latency_info_ = latency_info;
 }
 
 bool TextureImageTransportSurface::SwapBuffers() {
   DCHECK(helper_->stub()->decoder()->GetGLContext()->IsCurrent(NULL));
   DCHECK(backbuffer_suggested_allocation_);
 
   if (!frontbuffer_suggested_allocation_)
     return true;
 
-  if (!backbuffer_) {
+  if (!backbuffer_.get()) {
     LOG(ERROR) << "Swap without valid backing.";
     return true;
   }
 
   DCHECK(backbuffer_size() == current_size_);
   GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params params;
   params.size = backbuffer_size();
   params.scale_factor = scale_factor_;
   params.mailbox_name.assign(
       reinterpret_cast<const char*>(&back_mailbox_name_),
@@ skipping 15 matching lines @@
   DCHECK(backbuffer_suggested_allocation_);
   if (!frontbuffer_suggested_allocation_)
     return true;
   const gfx::Rect new_damage_rect(x, y, width, height);
   DCHECK(gfx::Rect(gfx::Point(), current_size_).Contains(new_damage_rect));
 
   // An empty damage rect is a successful no-op.
   if (new_damage_rect.IsEmpty())
     return true;
 
-  if (!backbuffer_) {
+  if (!backbuffer_.get()) {
     LOG(ERROR) << "Swap without valid backing.";
     return true;
   }
 
   DCHECK(current_size_ == backbuffer_size());
   GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params params;
   params.surface_size = backbuffer_size();
   params.surface_scale_factor = scale_factor_;
   params.x = x;
   params.y = y;
@@ skipping 46 matching lines @@
   }
 }
 
 void TextureImageTransportSurface::BufferPresentedImpl(
     const std::string& mailbox_name) {
   DCHECK(is_swap_buffers_pending_);
   is_swap_buffers_pending_ = false;
   // We should not have allowed the backbuffer to be discarded while the ack
   // was pending.
   DCHECK(backbuffer_suggested_allocation_);
-  DCHECK(backbuffer_);
+  DCHECK(backbuffer_.get());
 
   bool swap = true;
   if (!mailbox_name.empty()) {
     DCHECK(mailbox_name.length() == GL_MAILBOX_SIZE_CHROMIUM);
     if (!memcmp(mailbox_name.data(),
                 &back_mailbox_name_,
                 mailbox_name.length())) {
       // The browser has skipped the frame to unblock the GPU process, waiting
       // for one of the right size, and returned the back buffer, so don't swap.
       swap = false;
     }
   }
   if (swap) {
     std::swap(backbuffer_, frontbuffer_);
     std::swap(back_mailbox_name_, front_mailbox_name_);
   }
 
   // We're relying on the fact that the parent context is
   // finished with its context when it inserts the sync point that
   // triggers this callback.
   if (helper_->MakeCurrent()) {
-    if (frontbuffer_ && !frontbuffer_suggested_allocation_)
+    if (frontbuffer_.get() && !frontbuffer_suggested_allocation_)
       ReleaseFrontTexture();
-    if (!backbuffer_ || backbuffer_size() != current_size_)
+    if (!backbuffer_.get() || backbuffer_size() != current_size_)
       CreateBackTexture();
     else
       AttachBackTextureToFBO();
   }
 
   // Even if MakeCurrent fails, schedule anyway, to trigger the lost context
   // logic.
   if (did_unschedule_) {
     did_unschedule_ = false;
     helper_->SetScheduled(true);
@@ skipping 21 matching lines @@
   GpuHostMsg_AcceleratedSurfaceRelease_Params params;
   helper_->SendAcceleratedSurfaceRelease(params);
 }
 
 void TextureImageTransportSurface::CreateBackTexture() {
   DCHECK(helper_->stub()->decoder()->GetGLContext()->IsCurrent(NULL));
   // If |is_swap_buffers_pending| we are waiting for our backbuffer
   // in the mailbox, so we shouldn't be reallocating it now.
   DCHECK(!is_swap_buffers_pending_);
 
-  if (backbuffer_ && backbuffer_size() == current_size_)
+  if (backbuffer_.get() && backbuffer_size() == current_size_)
     return;
 
   VLOG(1) << "Allocating new backbuffer texture";
 
   // On Qualcomm we couldn't resize an FBO texture past a certain
   // size, after we allocated it as 1x1. So here we simply delete
   // the previous texture on resize, to insure we don't 'run out of
   // memory'.
-  if (backbuffer_ &&
-      helper_->stub()
-             ->decoder()
-             ->GetContextGroup()
-             ->feature_info()
-             ->workarounds()
-             .delete_instead_of_resize_fbo) {
+  if (backbuffer_.get() &&
+      helper_->stub()->decoder()->GetContextGroup()->feature_info()
+          ->workarounds().delete_instead_of_resize_fbo) {
     ReleaseBackTexture();
   }
   GLES2Decoder* decoder = helper_->stub()->decoder();
   TextureManager* texture_manager =
       decoder->GetContextGroup()->texture_manager();
-  if (!backbuffer_) {
+  if (!backbuffer_.get()) {
     mailbox_manager_->GenerateMailboxName(&back_mailbox_name_);
     GLuint service_id;
     glGenTextures(1, &service_id);
     backbuffer_ = TextureRef::Create(texture_manager, 0, service_id);
-    texture_manager->SetTarget(backbuffer_, GL_TEXTURE_2D);
-    Texture* texture = texture_manager->Produce(backbuffer_);
+    texture_manager->SetTarget(backbuffer_.get(), GL_TEXTURE_2D);
+    Texture* texture = texture_manager->Produce(backbuffer_.get());
     bool success = mailbox_manager_->ProduceTexture(
         GL_TEXTURE_2D, back_mailbox_name_, texture);
     DCHECK(success);
   }
 
   {
     gfx::ScopedTextureBinder texture_binder(GL_TEXTURE_2D,
                                             backbuffer_->service_id());
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA,
         current_size_.width(), current_size_.height(), 0,
         GL_RGBA, GL_UNSIGNED_BYTE, NULL);
     gpu::gles2::ErrorState* error_state = decoder->GetErrorState();
-    texture_manager->SetParameter("Backbuffer", error_state, backbuffer_,
-                                  GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-    texture_manager->SetParameter("Backbuffer", error_state, backbuffer_,
-                                  GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-    texture_manager->SetParameter("Backbuffer", error_state, backbuffer_,
-                                  GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-    texture_manager->SetParameter("Backbuffer", error_state, backbuffer_,
-                                  GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-    texture_manager->SetLevelInfo(
-        backbuffer_,
-        GL_TEXTURE_2D,
-        0,
-        GL_RGBA,
-        current_size_.width(),
-        current_size_.height(),
-        1,
-        0,
-        GL_RGBA,
-        GL_UNSIGNED_BYTE,
-        true);
-    DCHECK(texture_manager->CanRender(backbuffer_));
+    texture_manager->SetParameter("Backbuffer",
+                                  error_state,
+                                  backbuffer_.get(),
+                                  GL_TEXTURE_MIN_FILTER,
+                                  GL_LINEAR);
+    texture_manager->SetParameter("Backbuffer",
+                                  error_state,
+                                  backbuffer_.get(),
+                                  GL_TEXTURE_MAG_FILTER,
+                                  GL_LINEAR);
+    texture_manager->SetParameter("Backbuffer",
+                                  error_state,
+                                  backbuffer_.get(),
+                                  GL_TEXTURE_WRAP_S,
+                                  GL_CLAMP_TO_EDGE);
+    texture_manager->SetParameter("Backbuffer",
+                                  error_state,
+                                  backbuffer_.get(),
+                                  GL_TEXTURE_WRAP_T,
+                                  GL_CLAMP_TO_EDGE);
+    texture_manager->SetLevelInfo(backbuffer_.get(),
+                                  GL_TEXTURE_2D,
+                                  0,
+                                  GL_RGBA,
+                                  current_size_.width(),
+                                  current_size_.height(),
+                                  1,
+                                  0,
+                                  GL_RGBA,
+                                  GL_UNSIGNED_BYTE,
+                                  true);
+    DCHECK(texture_manager->CanRender(backbuffer_.get()));
     CHECK_GL_ERROR();
   }
 
   AttachBackTextureToFBO();
 }
 
 void TextureImageTransportSurface::AttachBackTextureToFBO() {
   DCHECK(helper_->stub()->decoder()->GetGLContext()->IsCurrent(NULL));
-  DCHECK(backbuffer_);
+  DCHECK(backbuffer_.get());
   gfx::ScopedFrameBufferBinder fbo_binder(fbo_id_);
   glFramebufferTexture2DEXT(GL_FRAMEBUFFER,
       GL_COLOR_ATTACHMENT0,
       GL_TEXTURE_2D,
       backbuffer_->service_id(),
       0);
   CHECK_GL_ERROR();
 
 #ifndef NDEBUG
   GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER);
   if (status != GL_FRAMEBUFFER_COMPLETE) {
     DLOG(FATAL) << "Framebuffer incomplete: " << status;
   }
 #endif
 }
 
 }  // namespace content