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

content/common/gpu/gpu_command_buffer_stub.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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/hash.h"
 #include "base/shared_memory.h"
@@ skipping 352 matching lines @@
     context = decoder_->GetGLContext();
     decoder_->Destroy(have_context);
     decoder_.reset();
   }
 
   command_buffer_.reset();
 
   // Make sure that context_ is current while we destroy surface_, because
   // surface_ may have GL resources that it needs to destroy, and will need
   // context_ to be current in order to not leak these resources.
-  if (context)
+  if (context.get())
     context->MakeCurrent(surface_.get());
   surface_ = NULL;
-  if (context)
+  if (context.get())
     context->ReleaseCurrent(NULL);
 }
 
 void GpuCommandBufferStub::OnInitializeFailed(IPC::Message* reply_message) {
   Destroy();
   GpuCommandBufferMsg_Initialize::WriteReplyParams(reply_message, false);
   Send(reply_message);
 }
 
 void GpuCommandBufferStub::OnInitialize(
@@ skipping 12 matching lines @@
     DLOG(ERROR) << "CommandBufferService failed to initialize.\n";
     OnInitializeFailed(reply_message);
     return;
   }
 
   decoder_.reset(::gpu::gles2::GLES2Decoder::Create(context_group_.get()));
 
   scheduler_.reset(new gpu::GpuScheduler(command_buffer_.get(),
                                          decoder_.get(),
                                          decoder_.get()));
-  if (preemption_flag_)
+  if (preemption_flag_.get())
     scheduler_->SetPreemptByFlag(preemption_flag_);
 
   decoder_->set_engine(scheduler_.get());
 
   if (!handle_.is_null()) {
 #if defined(OS_MACOSX) || defined(UI_COMPOSITOR_IMAGE_TRANSPORT)
     if (software_) {
       DLOG(ERROR) << "No software support.\n";
       OnInitializeFailed(reply_message);
       return;
     }
 #endif
 
     surface_ = ImageTransportSurface::CreateSurface(
         channel_->gpu_channel_manager(),
         this,
         handle_);
   } else {
     GpuChannelManager* manager = channel_->gpu_channel_manager();
     surface_ = manager->GetDefaultOffscreenSurface();
   }
 
-  if (!surface_) {
+  if (!surface_.get()) {
     DLOG(ERROR) << "Failed to create surface.\n";
     OnInitializeFailed(reply_message);
     return;
   }
 
   scoped_refptr<gfx::GLContext> context;
   if ((CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableVirtualGLContexts) || use_virtualized_gl_context_) &&
       channel_->share_group()) {
     context = channel_->share_group()->GetSharedContext();
-    if (!context) {
+    if (!context.get()) {
       context = gfx::GLContext::CreateGLContext(
           channel_->share_group(),
           channel_->gpu_channel_manager()->GetDefaultOffscreenSurface(),
           gpu_preference_);
-      channel_->share_group()->SetSharedContext(context);
+      channel_->share_group()->SetSharedContext(context.get());
     }
     // This should be a non-virtual GL context.
     DCHECK(context->GetHandle());
-    context = new gpu::GLContextVirtual(channel_->share_group(),
-                                        context,
-                                        decoder_->AsWeakPtr());
-    if (!context->Initialize(surface_, gpu_preference_)) {
+    context = new gpu::GLContextVirtual(
+        channel_->share_group(), context.get(), decoder_->AsWeakPtr());
+    if (!context->Initialize(surface_.get(), gpu_preference_)) {
       // TODO(sievers): The real context created above for the default
       // offscreen surface might not be compatible with this surface.
       // Need to adjust at least GLX to be able to create the initial context
       // with a config that is compatible with onscreen and offscreen surfaces.
       context = NULL;
 
       DLOG(ERROR) << "Failed to initialize virtual GL context.";
       OnInitializeFailed(reply_message);
       return;
     } else {
       LOG(INFO) << "Created virtual GL context.";
     }
   }
-  if (!context) {
+  if (!context.get()) {
     context = gfx::GLContext::CreateGLContext(
-        channel_->share_group(),
-        surface_.get(),
-        gpu_preference_);
+        channel_->share_group(), surface_.get(), gpu_preference_);
   }
-  if (!context) {
+  if (!context.get()) {
     DLOG(ERROR) << "Failed to create context.\n";
     OnInitializeFailed(reply_message);
     return;
   }
 
-  if (!context->MakeCurrent(surface_)) {
+  if (!context->MakeCurrent(surface_.get())) {
     LOG(ERROR) << "Failed to make context current.";
     OnInitializeFailed(reply_message);
     return;
   }
 
   if (!context->GetGLStateRestorer()) {
     context->SetGLStateRestorer(
         new gpu::GLStateRestorerImpl(decoder_->AsWeakPtr()));
   }
 
@@ skipping 262 matching lines @@
 }
 
 void GpuCommandBufferStub::OnSetSurfaceVisible(bool visible) {
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnSetSurfaceVisible");
   if (memory_manager_client_state_)
     memory_manager_client_state_->SetVisible(visible);
 }
 
 void GpuCommandBufferStub::OnDiscardBackbuffer() {
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnDiscardBackbuffer");
-  if (!surface_)
+  if (!surface_.get())
     return;
   if (surface_->DeferDraws()) {
     DCHECK(!IsScheduled());
     channel_->RequeueMessage();
   } else {
     if (!surface_->SetBackbufferAllocation(false))
       channel_->DestroySoon();
   }
 }
 
 void GpuCommandBufferStub::OnEnsureBackbuffer() {
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnEnsureBackbuffer");
-  if (!surface_)
+  if (!surface_.get())
     return;
   if (surface_->DeferDraws()) {
     DCHECK(!IsScheduled());
     channel_->RequeueMessage();
   } else {
     if (!surface_->SetBackbufferAllocation(true))
       channel_->DestroySoon();
   }
 }
 
@@ skipping 102 matching lines @@
   if (scheduler_)
     scheduler_->SetPreemptByFlag(preemption_flag_);
 }
 
 bool GpuCommandBufferStub::GetTotalGpuMemory(uint64* bytes) {
   *bytes = total_gpu_memory_;
   return !!total_gpu_memory_;
 }
 
 gfx::Size GpuCommandBufferStub::GetSurfaceSize() const {
-  if (!surface_)
+  if (!surface_.get())
     return gfx::Size();
   return surface_->GetSize();
 }
 
 gpu::gles2::MemoryTracker* GpuCommandBufferStub::GetMemoryTracker() const {
   return context_group_->memory_tracker();
 }
 
 void GpuCommandBufferStub::SetMemoryAllocation(
     const GpuMemoryAllocation& allocation) {
   if (!last_memory_allocation_valid_ ||
       !allocation.renderer_allocation.Equals(
           last_memory_allocation_.renderer_allocation)) {
     Send(new GpuCommandBufferMsg_SetMemoryAllocation(
         route_id_, allocation.renderer_allocation));
   }
 
   if (!last_memory_allocation_valid_ ||
       !allocation.browser_allocation.Equals(
           last_memory_allocation_.browser_allocation)) {
     // This can be called outside of OnMessageReceived, so the context needs
     // to be made current before calling methods on the surface.
-    if (surface_ && MakeCurrent())
+    if (surface_.get() && MakeCurrent())
       surface_->SetFrontbufferAllocation(
           allocation.browser_allocation.suggest_have_frontbuffer);
   }
 
   last_memory_allocation_valid_ = true;
   last_memory_allocation_ = allocation;
 }
 
 }  // namespace content