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

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 225 matching lines @@
   return scheduler_.get() && scheduler_->HasMoreWork();
 }
 
 void GpuCommandBufferStub::PollWork() {
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::PollWork");
   delayed_work_scheduled_ = false;
   FastSetActiveURL(active_url_, active_url_hash_);
   if (decoder_.get() && !MakeCurrent())
     return;
 
-  if (scheduler_.get()) {
+  if (scheduler_) {
     bool fences_complete = scheduler_->PollUnscheduleFences();
     // Perform idle work if all fences are complete.
     if (fences_complete) {
       uint64 current_messages_processed =
           channel()->gpu_channel_manager()->MessagesProcessed();
       // We're idle when no messages were processed or scheduled.
       bool is_idle =
           (previous_messages_processed_ == current_messages_processed) &&
           !channel()->gpu_channel_manager()->HandleMessagesScheduled();
       if (!is_idle && !last_idle_time_.is_null()) {
@@ skipping 10 matching lines @@
       if (is_idle) {
         last_idle_time_ = base::TimeTicks::Now();
         scheduler_->PerformIdleWork();
       }
     }
   }
   ScheduleDelayedWork(kHandleMoreWorkPeriodBusyMs);
 }
 
 bool GpuCommandBufferStub::HasUnprocessedCommands() {
-  if (command_buffer_.get()) {
+  if (command_buffer_) {
     gpu::CommandBuffer::State state = command_buffer_->GetLastState();
     return state.put_offset != state.get_offset &&
         !gpu::error::IsError(state.error);
   }
   return false;
 }
 
 void GpuCommandBufferStub::ScheduleDelayedWork(int64 delay) {
   if (!HasMoreWork()) {
     last_idle_time_ = base::TimeTicks();
@@ skipping 51 matching lines @@
     GpuChannelManager* gpu_channel_manager = channel_->gpu_channel_manager();
     gpu_channel_manager->Send(new GpuHostMsg_DidDestroyOffscreenContext(
         active_url_));
   }
 
   memory_manager_client_state_.reset();
 
   while (!sync_points_.empty())
     OnRetireSyncPoint(sync_points_.front());
 
-  if (decoder_.get())
+  if (decoder_)
     decoder_->set_engine(NULL);
 
   // The scheduler has raw references to the decoder and the command buffer so
   // destroy it before those.
   scheduler_.reset();
 
   bool have_context = false;
-  if (decoder_.get())
+  if (decoder_)
     have_context = decoder_->MakeCurrent();
   FOR_EACH_OBSERVER(DestructionObserver,
                     destruction_observers_,
                     OnWillDestroyStub(this));
 
   scoped_refptr<gfx::GLContext> context;
-  if (decoder_.get()) {
+  if (decoder_) {
     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.
@@ skipping 26 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_.get())
+  if (preemption_flag_)
     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_.get()) {
+  if (!surface_) {
     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();
@@ skipping 28 matching lines @@
         channel_->share_group(),
         surface_.get(),
         gpu_preference_);
   }
   if (!context) {
     DLOG(ERROR) << "Failed to create context.\n";
     OnInitializeFailed(reply_message);
     return;
   }
 
-  if (!context->MakeCurrent(surface_.get())) {
+  if (!context->MakeCurrent(surface_)) {
     LOG(ERROR) << "Failed to make context current.";
     OnInitializeFailed(reply_message);
     return;
   }
 
   if (!context->GetTotalGpuMemory(&total_gpu_memory_))
     total_gpu_memory_ = 0;
 
   if (!context_group_->has_program_cache()) {
     context_group_->set_program_cache(
@@ skipping 79 matching lines @@
 }
 
 void GpuCommandBufferStub::SetLatencyInfoCallback(
     const LatencyInfoCallback& callback) {
   latency_info_callback_ = callback;
 }
 
 void GpuCommandBufferStub::OnSetGetBuffer(int32 shm_id,
                                           IPC::Message* reply_message) {
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnSetGetBuffer");
-  if (command_buffer_.get())
+  if (command_buffer_)
     command_buffer_->SetGetBuffer(shm_id);
   Send(reply_message);
 }
 
 void GpuCommandBufferStub::OnSetParent(int32 parent_route_id,
                                        uint32 parent_texture_id,
                                        IPC::Message* reply_message) {
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnSetParent");
   GpuCommandBufferStub* parent_stub = NULL;
   if (parent_route_id != MSG_ROUTING_NONE) {
     parent_stub = channel_->LookupCommandBuffer(parent_route_id);
   }
 
   bool result = true;
-  if (scheduler_.get()) {
+  if (scheduler_) {
     gpu::gles2::GLES2Decoder* parent_decoder =
         parent_stub ? parent_stub->decoder_.get() : NULL;
     result = decoder_->SetParent(parent_decoder, parent_texture_id);
   } else {
     // If we don't have a scheduler, it means that Initialize hasn't been called
     // yet. Keep around the requested parent stub and texture so that we can set
     // it in Initialize().
     parent_stub_for_initialization_ = parent_stub ?
         parent_stub->AsWeakPtr() : base::WeakPtr<GpuCommandBufferStub>();
     parent_texture_for_initialization_ = parent_texture_id;
   }
   GpuCommandBufferMsg_SetParent::WriteReplyParams(reply_message, result);
   Send(reply_message);
 }
 
 void GpuCommandBufferStub::OnGetState(IPC::Message* reply_message) {
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnGetState");
-  if (command_buffer_.get()) {
+  if (command_buffer_) {
     gpu::CommandBuffer::State state = command_buffer_->GetState();
     if (state.error == gpu::error::kLostContext &&
         gfx::GLContext::LosesAllContextsOnContextLost())
       channel_->LoseAllContexts();
 
     GpuCommandBufferMsg_GetState::WriteReplyParams(reply_message, state);
   } else {
     DLOG(ERROR) << "no command_buffer.";
     reply_message->set_reply_error();
   }
@@ skipping 55 matching lines @@
     ReportState();
 }
 
 void GpuCommandBufferStub::OnRegisterTransferBuffer(
     int32 id,
     base::SharedMemoryHandle transfer_buffer,
     uint32 size) {
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnRegisterTransferBuffer");
   base::SharedMemory shared_memory(transfer_buffer, false);
 
-  if (command_buffer_.get())
+  if (command_buffer_)
     command_buffer_->RegisterTransferBuffer(id, &shared_memory, size);
 }
 
 void GpuCommandBufferStub::OnDestroyTransferBuffer(int32 id) {
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnDestroyTransferBuffer");
 
-  if (command_buffer_.get())
+  if (command_buffer_)
     command_buffer_->DestroyTransferBuffer(id);
 }
 
 void GpuCommandBufferStub::OnGetTransferBuffer(
     int32 id,
     IPC::Message* reply_message) {
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnGetTransferBuffer");
-  if (command_buffer_.get()) {
+  if (command_buffer_) {
     base::SharedMemoryHandle transfer_buffer = base::SharedMemoryHandle();
     uint32 size = 0;
 
     gpu::Buffer buffer = command_buffer_->GetTransferBuffer(id);
     if (buffer.shared_memory) {
 #if defined(OS_WIN)
       transfer_buffer = NULL;
       BrokerDuplicateHandle(buffer.shared_memory->handle(),
           channel_->renderer_pid(), &transfer_buffer, FILE_MAP_READ |
           FILE_MAP_WRITE, 0);
@@ skipping 40 matching lines @@
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnCreateVideoDecoder");
   int decoder_route_id = channel_->GenerateRouteID();
   GpuVideoDecodeAccelerator* decoder =
       new GpuVideoDecodeAccelerator(decoder_route_id, this);
   video_decoders_.push_back(decoder);
   decoder->Initialize(profile, reply_message);
 }
 
 void GpuCommandBufferStub::OnSetSurfaceVisible(bool visible) {
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnSetSurfaceVisible");
-  if (memory_manager_client_state_.get())
+  if (memory_manager_client_state_)
     memory_manager_client_state_->SetVisible(visible);
 }
 
 void GpuCommandBufferStub::OnDiscardBackbuffer() {
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnDiscardBackbuffer");
   if (!surface_)
     return;
   if (surface_->DeferDraws()) {
     DCHECK(!IsScheduled());
     channel_->RequeueMessage();
@@ skipping 62 matching lines @@
 
 void GpuCommandBufferStub::OnSignalSyncPointAck(uint32 id) {
   Send(new GpuCommandBufferMsg_SignalSyncPointAck(route_id_, id));
 }
 
 void GpuCommandBufferStub::OnReceivedClientManagedMemoryStats(
     const GpuManagedMemoryStats& stats) {
   TRACE_EVENT0(
       "gpu",
       "GpuCommandBufferStub::OnReceivedClientManagedMemoryStats");
-  if (memory_manager_client_state_.get())
+  if (memory_manager_client_state_)
     memory_manager_client_state_->SetManagedMemoryStats(stats);
 }
 
 void GpuCommandBufferStub::OnSetClientHasMemoryAllocationChangedCallback(
     bool has_callback) {
   TRACE_EVENT0(
       "gpu",
       "GpuCommandBufferStub::OnSetClientHasMemoryAllocationChangedCallback");
   if (has_callback) {
-    if (!memory_manager_client_state_.get()) {
+    if (!memory_manager_client_state_) {
       memory_manager_client_state_.reset(GetMemoryManager()->CreateClientState(
           this, surface_id_ != 0, true));
     }
   } else {
     memory_manager_client_state_.reset();
   }
 }
 
 void GpuCommandBufferStub::SendConsoleMessage(
     int32 id,
@@ skipping 18 matching lines @@
 }
 
 void GpuCommandBufferStub::RemoveDestructionObserver(
     DestructionObserver* observer) {
   destruction_observers_.RemoveObserver(observer);
 }
 
 void GpuCommandBufferStub::SetPreemptByFlag(
     scoped_refptr<gpu::PreemptionFlag> flag) {
   preemption_flag_ = flag;
-  if (scheduler_.get())
+  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_)
@@ skipping 22 matching lines @@
     if (surface_ && MakeCurrent())
       surface_->SetFrontbufferAllocation(
           allocation.browser_allocation.suggest_have_frontbuffer);
   }
 
   last_memory_allocation_valid_ = true;
   last_memory_allocation_ = allocation;
 }
 
 }  // namespace content