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

content/common/gpu/gpu_channel_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 "content/common/gpu/gpu_channel_manager.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "content/common/child_thread.h"
 #include "content/common/gpu/gpu_channel.h"
@@ skipping 31 matching lines @@
       watchdog_(watchdog),
       sync_point_manager_(new SyncPointManager),
       program_cache_(NULL) {
   DCHECK(gpu_child_thread);
   DCHECK(io_message_loop);
   DCHECK(shutdown_event);
 }
 
 GpuChannelManager::~GpuChannelManager() {
   gpu_channels_.clear();
-  if (default_offscreen_surface_) {
+  if (default_offscreen_surface_.get()) {
     default_offscreen_surface_->Destroy();
     default_offscreen_surface_ = NULL;
   }
   DCHECK(image_operations_.empty());
 }
 
 gpu::gles2::ProgramCache* GpuChannelManager::program_cache() {
   if (!program_cache_.get() &&
       (gfx::g_driver_gl.ext.b_ARB_get_program_binary ||
        gfx::g_driver_gl.ext.b_OES_get_program_binary) &&
@@ skipping 20 matching lines @@
 
 void GpuChannelManager::RemoveRoute(int32 routing_id) {
   gpu_child_thread_->RemoveRoute(routing_id);
 }
 
 GpuChannel* GpuChannelManager::LookupChannel(int32 client_id) {
   GpuChannelMap::const_iterator iter = gpu_channels_.find(client_id);
   if (iter == gpu_channels_.end())
     return NULL;
   else
-    return iter->second;
+    return iter->second.get();
 }
 
 bool GpuChannelManager::OnMessageReceived(const IPC::Message& msg) {
   bool msg_is_ok = true;
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP_EX(GpuChannelManager, msg, msg_is_ok)
     IPC_MESSAGE_HANDLER(GpuMsg_EstablishChannel, OnEstablishChannel)
     IPC_MESSAGE_HANDLER(GpuMsg_CloseChannel, OnCloseChannel)
     IPC_MESSAGE_HANDLER(GpuMsg_CreateViewCommandBuffer,
                         OnCreateViewCommandBuffer)
     IPC_MESSAGE_HANDLER(GpuMsg_CreateImage, OnCreateImage)
     IPC_MESSAGE_HANDLER(GpuMsg_DeleteImage, OnDeleteImage)
     IPC_MESSAGE_HANDLER(GpuMsg_LoadedShader, OnLoadedShader)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP_EX()
   return handled;
 }
 
 bool GpuChannelManager::Send(IPC::Message* msg) {
   return gpu_child_thread_->Send(msg);
 }
 
 void GpuChannelManager::OnEstablishChannel(int client_id, bool share_context) {
   IPC::ChannelHandle channel_handle;
 
   gfx::GLShareGroup* share_group = NULL;
   gpu::gles2::MailboxManager* mailbox_manager = NULL;
   if (share_context) {
-    if (!share_group_) {
+    if (!share_group_.get()) {
       share_group_ = new gfx::GLShareGroup;
-      DCHECK(!mailbox_manager_);
+      DCHECK(!mailbox_manager_.get());
       mailbox_manager_ = new gpu::gles2::MailboxManager;
     }
-    share_group = share_group_;
-    mailbox_manager = mailbox_manager_;
+    share_group = share_group_.get();
+    mailbox_manager = mailbox_manager_.get();
   }
 
   scoped_refptr<GpuChannel> channel = new GpuChannel(this,
                                                      watchdog_,
                                                      share_group,
                                                      mailbox_manager,
                                                      client_id,
                                                      false);
-  if (channel->Init(io_message_loop_, shutdown_event_)) {
+  if (channel->Init(io_message_loop_.get(), shutdown_event_)) {
     gpu_channels_[client_id] = channel;
     channel_handle.name = channel->GetChannelName();
 
 #if defined(OS_POSIX)
     // On POSIX, pass the renderer-side FD. Also mark it as auto-close so
     // that it gets closed after it has been sent.
     int renderer_fd = channel->TakeRendererFileDescriptor();
     DCHECK_NE(-1, renderer_fd);
     channel_handle.socket = base::FileDescriptor(renderer_fd, true);
 #endif
@@ skipping 134 matching lines @@
       FROM_HERE,
       base::Bind(&GpuChannelManager::OnLoseAllContexts,
                  weak_factory_.GetWeakPtr()));
 }
 
 void GpuChannelManager::OnLoseAllContexts() {
   gpu_channels_.clear();
 }
 
 gfx::GLSurface* GpuChannelManager::GetDefaultOffscreenSurface() {
-  if (!default_offscreen_surface_) {
-    default_offscreen_surface_ = gfx::GLSurface::CreateOffscreenGLSurface(
-        false, gfx::Size(1, 1));
+  if (!default_offscreen_surface_.get()) {
+    default_offscreen_surface_ =
+        gfx::GLSurface::CreateOffscreenGLSurface(false, gfx::Size(1, 1));
   }
   return default_offscreen_surface_.get();
 }
 
 }  // namespace content