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

content/common/gpu/gpu_channel.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.
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 
 #include "content/common/gpu/gpu_channel.h"
 
@@ skipping 108 matching lines @@
 
     if (message.type() == GpuCommandBufferMsg_RetireSyncPoint::ID) {
       // This message should not be sent explicitly by the renderer.
       NOTREACHED();
       handled = true;
     }
 
     // All other messages get processed by the GpuChannel.
     if (!handled) {
       messages_forwarded_to_channel_++;
-      if (preempting_flag_)
+      if (preempting_flag_.get())
         pending_messages_.push(PendingMessage(messages_forwarded_to_channel_));
       UpdatePreemptionState();
     }
 
     if (message.type() == GpuCommandBufferMsg_InsertSyncPoint::ID) {
       uint32 sync_point = sync_point_manager_->GenerateSyncPoint();
       IPC::Message* reply = IPC::SyncMessage::GenerateReply(&message);
       GpuCommandBufferMsg_InsertSyncPoint::WriteReplyParams(reply, sync_point);
       Send(reply);
       message_loop_->PostTask(FROM_HERE, base::Bind(
@@ skipping 339 matching lines @@
 
   base::WeakPtr<GpuChannel>* weak_ptr(new base::WeakPtr<GpuChannel>(
       weak_factory_.GetWeakPtr()));
 
   filter_ = new GpuChannelMessageFilter(
       mailbox_manager_->private_key(),
       weak_ptr,
       gpu_channel_manager_->sync_point_manager(),
       base::MessageLoopProxy::current());
   io_message_loop_ = io_message_loop;
-  channel_->AddFilter(filter_);
+  channel_->AddFilter(filter_.get());
 
   return true;
 }
 
 std::string GpuChannel::GetChannelName() {
   return channel_id_;
 }
 
 #if defined(OS_POSIX)
 int GpuChannel::TakeRendererFileDescriptor() {
@@ skipping 96 matching lines @@
   if (scheduled) {
     num_stubs_descheduled_--;
     OnScheduled();
   } else {
     num_stubs_descheduled_++;
   }
   DCHECK_LE(num_stubs_descheduled_, stubs_.size());
   bool a_stub_is_descheduled = num_stubs_descheduled_ > 0;
 
   if (a_stub_is_descheduled != a_stub_was_descheduled) {
-    if (preempting_flag_) {
+    if (preempting_flag_.get()) {
       io_message_loop_->PostTask(
           FROM_HERE,
           base::Bind(&GpuChannelMessageFilter::UpdateStubSchedulingState,
-                     filter_, a_stub_is_descheduled));
+                     filter_,
+                     a_stub_is_descheduled));
     }
   }
 }
 
 void GpuChannel::CreateViewCommandBuffer(
     const gfx::GLSurfaceHandle& window,
     int32 surface_id,
     const GPUCreateCommandBufferConfig& init_params,
     int32* route_id) {
   TRACE_EVENT1("gpu",
                "GpuChannel::CreateViewCommandBuffer",
                "surface_id",
                surface_id);
 
   *route_id = MSG_ROUTING_NONE;
 
 #if defined(ENABLE_GPU)
 
   GpuCommandBufferStub* share_group = stubs_.Lookup(init_params.share_group_id);
 
   // Virtualize compositor contexts on OS X to prevent performance regressions
   // when enabling FCM.
   // http://crbug.com/180463
   bool use_virtualized_gl_context = false;
 #if defined(OS_MACOSX)
   use_virtualized_gl_context = true;
 #endif
 
   *route_id = GenerateRouteID();
-  scoped_ptr<GpuCommandBufferStub> stub(new GpuCommandBufferStub(
-      this,
-      share_group,
-      window,
-      mailbox_manager_,
-      image_manager_,
-      gfx::Size(),
-      disallowed_features_,
-      init_params.allowed_extensions,
-      init_params.attribs,
-      init_params.gpu_preference,
-      use_virtualized_gl_context,
-      *route_id,
-      surface_id,
-      watchdog_,
-      software_,
-      init_params.active_url));
-  if (preempted_flag_)
+  scoped_ptr<GpuCommandBufferStub> stub(
+      new GpuCommandBufferStub(this,
+                               share_group,
+                               window,
+                               mailbox_manager_.get(),
+                               image_manager_.get(),
+                               gfx::Size(),
+                               disallowed_features_,
+                               init_params.allowed_extensions,
+                               init_params.attribs,
+                               init_params.gpu_preference,
+                               use_virtualized_gl_context,
+                               *route_id,
+                               surface_id,
+                               watchdog_,
+                               software_,
+                               init_params.active_url));
+  if (preempted_flag_.get())
     stub->SetPreemptByFlag(preempted_flag_);
   router_.AddRoute(*route_id, stub.get());
   stubs_.AddWithID(stub.release(), *route_id);
 #endif  // ENABLE_GPU
 }
 
 GpuCommandBufferStub* GpuChannel::LookupCommandBuffer(int32 route_id) {
   return stubs_.Lookup(route_id);
 }
 
 void GpuChannel::CreateImage(
     gfx::PluginWindowHandle window,
     int32 image_id,
     gfx::Size* size) {
   TRACE_EVENT1("gpu",
                "GpuChannel::CreateImage",
                "image_id",
                image_id);
 
   *size = gfx::Size();
 
   if (image_manager_->LookupImage(image_id)) {
     LOG(ERROR) << "CreateImage failed, image_id already in use.";
     return;
   }
 
   scoped_refptr<gfx::GLImage> image = gfx::GLImage::CreateGLImage(window);
-  if (!image)
+  if (!image.get())
     return;
 
   image_manager_->AddImage(image.get(), image_id);
   *size = image->GetSize();
 }
 
 void GpuChannel::DeleteImage(int32 image_id) {
   TRACE_EVENT1("gpu",
                "GpuChannel::DeleteImage",
                "image_id",
@@ skipping 18 matching lines @@
 
 void GpuChannel::AddRoute(int32 route_id, IPC::Listener* listener) {
   router_.AddRoute(route_id, listener);
 }
 
 void GpuChannel::RemoveRoute(int32 route_id) {
   router_.RemoveRoute(route_id);
 }
 
 gpu::PreemptionFlag* GpuChannel::GetPreemptionFlag() {
-  if (!preempting_flag_) {
+  if (!preempting_flag_.get()) {
     preempting_flag_ = new gpu::PreemptionFlag;
     io_message_loop_->PostTask(
         FROM_HERE, base::Bind(
             &GpuChannelMessageFilter::SetPreemptingFlagAndSchedulingState,
             filter_, preempting_flag_, num_stubs_descheduled_ > 0));
   }
   return preempting_flag_.get();
 }
 
 void GpuChannel::SetPreemptByFlag(
     scoped_refptr<gpu::PreemptionFlag> preempted_flag) {
   preempted_flag_ = preempted_flag;
 
   for (StubMap::Iterator<GpuCommandBufferStub> it(&stubs_);
        !it.IsAtEnd(); it.Advance()) {
     it.GetCurrentValue()->SetPreemptByFlag(preempted_flag_);
   }
 }
 
 GpuChannel::~GpuChannel() {
-  if (preempting_flag_)
+  if (preempting_flag_.get())
     preempting_flag_->Reset();
 }
 
 void GpuChannel::OnDestroy() {
   TRACE_EVENT0("gpu", "GpuChannel::OnDestroy");
   gpu_channel_manager_->RemoveChannel(client_id_);
 }
 
 bool GpuChannel::OnControlMessageReceived(const IPC::Message& msg) {
   bool handled = true;
@@ skipping 109 matching lines @@
       disallowed_features_,
       init_params.allowed_extensions,
       init_params.attribs,
       init_params.gpu_preference,
       false,
       *route_id,
       0,
       watchdog_,
       software_,
       init_params.active_url));
-  if (preempted_flag_)
+  if (preempted_flag_.get())
     stub->SetPreemptByFlag(preempted_flag_);
   router_.AddRoute(*route_id, stub.get());
   stubs_.AddWithID(stub.release(), *route_id);
   TRACE_EVENT1("gpu", "GpuChannel::OnCreateOffscreenCommandBuffer",
                "route_id", route_id);
 }
 
 void GpuChannel::OnDestroyCommandBuffer(int32 route_id) {
   TRACE_EVENT1("gpu", "GpuChannel::OnDestroyCommandBuffer",
                "route_id", route_id);
@@ skipping 48 matching lines @@
     if (it.GetCurrentValue()->surface_id() == surface_id) {
       stats->texture_upload_count += texture_upload_count;
       stats->total_texture_upload_time += total_texture_upload_time;
       stats->total_processing_commands_time += total_processing_commands_time;
     }
   }
 }
 
 void GpuChannel::MessageProcessed() {
   messages_processed_++;
-  if (preempting_flag_) {
+  if (preempting_flag_.get()) {
     io_message_loop_->PostTask(
         FROM_HERE,
         base::Bind(&GpuChannelMessageFilter::MessageProcessed,
-                   filter_, messages_processed_));
+                   filter_,
+                   messages_processed_));
   }
 }
 
 void GpuChannel::CacheShader(const std::string& key,
                              const std::string& shader) {
   gpu_channel_manager_->Send(
       new GpuHostMsg_CacheShader(client_id_, key, shader));
 }
 
 }  // namespace content