Cleanup: Remove unnecessary ".get()" from scoped_ptrs<>.

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_.get())
+      if (preempting_flag_)
         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 350 matching lines @@
 
   return true;
 }
 
 std::string GpuChannel::GetChannelName() {
   return channel_id_;
 }
 
 #if defined(OS_POSIX)
 int GpuChannel::TakeRendererFileDescriptor() {
-  if (!channel_.get()) {
+  if (!channel_) {
     NOTREACHED();
     return -1;
   }
   return channel_->TakeClientFileDescriptor();
 }
 #endif  // defined(OS_POSIX)
 
 bool GpuChannel::OnMessageReceived(const IPC::Message& message) {
   bool message_processed = true;
   if (log_messages_) {
@@ skipping 43 matching lines @@
 
 bool GpuChannel::Send(IPC::Message* message) {
   // The GPU process must never send a synchronous IPC message to the renderer
   // process. This could result in deadlock.
   DCHECK(!message->is_sync());
   if (log_messages_) {
     DVLOG(1) << "sending message @" << message << " on channel @" << this
              << " with type " << message->type();
   }
 
-  if (!channel_.get()) {
+  if (!channel_) {
     delete message;
     return false;
   }
 
   return channel_->Send(message);
 }
 
 void GpuChannel::RequeueMessage() {
   DCHECK(currently_processing_message_);
   deferred_messages_.push_front(
@@ skipping 21 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_.get()) {
+    if (preempting_flag_) {
       io_message_loop_->PostTask(
           FROM_HERE,
           base::Bind(&GpuChannelMessageFilter::UpdateStubSchedulingState,
                      filter_, a_stub_is_descheduled));
     }
   }
 }
 
 void GpuChannel::CreateViewCommandBuffer(
     const gfx::GLSurfaceHandle& window,
@@ skipping 30 matching lines @@
       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())
+  if (preempted_flag_)
     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);
 }
 
@@ skipping 46 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_.get()) {
+  if (!preempting_flag_) {
     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_.get())
+  if (preempting_flag_)
     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_.get())
+  if (preempted_flag_)
     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 49 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_.get()) {
+  if (preempting_flag_) {
     io_message_loop_->PostTask(
         FROM_HERE,
         base::Bind(&GpuChannelMessageFilter::MessageProcessed,
                    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