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

content/renderer/render_widget.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/renderer/render_widget.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
@@ skipping 598 matching lines @@
 }
 
 void RenderWidget::OnViewContextSwapBuffersPosted() {
   TRACE_EVENT0("renderer", "RenderWidget::OnSwapBuffersPosted");
 
   if (using_asynchronous_swapbuffers_) {
     ViewHostMsg_UpdateRect* msg = NULL;
     // pending_update_params_ can be NULL if the swap doesn't correspond to an
     // DoDeferredUpdate compositing pass, hence doesn't require an UpdateRect
     // message.
-    if (pending_update_params_.get()) {
+    if (pending_update_params_) {
       msg = new ViewHostMsg_UpdateRect(routing_id_, *pending_update_params_);
       pending_update_params_.reset();
     }
     updates_pending_swap_.push_back(msg);
     num_swapbuffers_complete_pending_++;
   }
 }
 
 void RenderWidget::OnViewContextSwapBuffersComplete() {
   TRACE_EVENT0("renderer", "RenderWidget::OnSwapBuffersComplete");
@@ skipping 130 matching lines @@
                     compositor_->commitRequested();
   }
 
   bool is_input_throttled =
       throttle_input_events_ &&
       frame_pending;
 
   if (event_type_gets_rate_limited && is_input_throttled && !is_hidden_) {
     // We want to rate limit the input events in this case, so we'll wait for
     // painting to finish before ACKing this message.
-    if (pending_input_event_ack_.get()) {
+    if (pending_input_event_ack_) {
       // As two different kinds of events could cause us to postpone an ack
       // we send it now, if we have one pending. The Browser should never
       // send us the same kind of event we are delaying the ack for.
       Send(pending_input_event_ack_.release());
     }
     pending_input_event_ack_.reset(response);
   } else {
     Send(response);
   }
 
@@ skipping 248 matching lines @@
 
 void RenderWidget::InvalidationCallback() {
   TRACE_EVENT0("renderer", "RenderWidget::InvalidationCallback");
   invalidation_task_posted_ = false;
   DoDeferredUpdateAndSendInputAck();
 }
 
 void RenderWidget::DoDeferredUpdateAndSendInputAck() {
   DoDeferredUpdate();
 
-  if (pending_input_event_ack_.get())
+  if (pending_input_event_ack_)
     Send(pending_input_event_ack_.release());
 }
 
 void RenderWidget::DoDeferredUpdate() {
   TRACE_EVENT0("renderer", "RenderWidget::DoDeferredUpdate");
 
   if (!webwidget_)
     return;
 
   if (!init_complete_) {
@@ skipping 138 matching lines @@
       bounds.Inset(-1, -1);
       bounds.Intersect(gfx::Rect(size_));
     }
 
     gfx::Rect pixel_bounds = gfx::ToEnclosingRect(
         gfx::ScaleRect(bounds, device_scale_factor_));
 
     scoped_ptr<skia::PlatformCanvas> canvas(
         RenderProcess::current()->GetDrawingCanvas(&current_paint_buf_,
                                                    pixel_bounds));
-    if (!canvas.get()) {
+    if (!canvas) {
       NOTREACHED();
       return;
     }
 
     // We may get back a smaller canvas than we asked for.
     // TODO(darin): This seems like it could cause painting problems!
     DCHECK_EQ(pixel_bounds.width(), canvas->getDevice()->width());
     DCHECK_EQ(pixel_bounds.height(), canvas->getDevice()->height());
     pixel_bounds.set_width(canvas->getDevice()->width());
     pixel_bounds.set_height(canvas->getDevice()->height());
@@ skipping 35 matching lines @@
     // If it needs to (e.g. composited UI), the GPU process does its own ACK
     // with the browser for the GPU surface.
     pending_update_params_->needs_ack = false;
     Composite(frame_begin_ticks);
   }
 
   // If we're holding a pending input event ACK, send the ACK before sending the
   // UpdateReply message so we can receive another input event before the
   // UpdateRect_ACK on platforms where the UpdateRect_ACK is sent from within
   // the UpdateRect IPC message handler.
-  if (pending_input_event_ack_.get())
+  if (pending_input_event_ack_)
     Send(pending_input_event_ack_.release());
 
   // If Composite() called SwapBuffers, pending_update_params_ will be reset (in
   // OnSwapBuffersPosted), meaning a message has been added to the
   // updates_pending_swap_ queue, that will be sent later. Otherwise, we send
   // the message now.
-  if (pending_update_params_.get()) {
+  if (pending_update_params_) {
     // sending an ack to browser process that the paint is complete...
     update_reply_pending_ = pending_update_params_->needs_ack;
     Send(new ViewHostMsg_UpdateRect(routing_id_, *pending_update_params_));
     pending_update_params_.reset();
   }
 
   // If we're software rendering then we're done initiating the paint.
   if (!is_accelerated_compositing_active_)
     DidInitiatePaint();
 }
@@ skipping 184 matching lines @@
   // enable GPU acceleration so they need to be called before any painting
   // is done.
   UpdateTextInputState(DO_NOT_SHOW_IME);
   UpdateSelectionBounds();
 
   WillInitiatePaint();
 }
 
 void RenderWidget::didBecomeReadyForAdditionalInput() {
   TRACE_EVENT0("renderer", "RenderWidget::didBecomeReadyForAdditionalInput");
-  if (pending_input_event_ack_.get())
+  if (pending_input_event_ack_)
     Send(pending_input_event_ack_.release());
 }
 
 void RenderWidget::DidCommitCompositorFrame() {
 }
 
 void RenderWidget::didCommitAndDrawCompositorFrame() {
   TRACE_EVENT0("gpu", "RenderWidget::didCommitAndDrawCompositorFrame");
   // Accelerated FPS tick for performance tests. See throughput_tests.cc.
   // NOTE: Tests may break if this event is renamed or moved.
@@ skipping 311 matching lines @@
                   static_cast<float>(canvas_size.height());
 
   gfx::Rect orig_bounds(canvas_size);
   canvas_size.set_width(static_cast<int>(canvas_size.width() * x_scale));
   canvas_size.set_height(static_cast<int>(canvas_size.height() * y_scale));
   gfx::Rect bounds(canvas_size);
 
   scoped_ptr<skia::PlatformCanvas> canvas(
       paint_at_size_buffer->GetPlatformCanvas(canvas_size.width(),
                                               canvas_size.height()));
-  if (!canvas.get()) {
+  if (!canvas) {
     NOTREACHED();
     return;
   }
 
   // Reset bounds to what we actually received, but they should be the
   // same.
   DCHECK_EQ(bounds.width(), canvas->getDevice()->width());
   DCHECK_EQ(bounds.height(), canvas->getDevice()->height());
   bounds.set_width(canvas->getDevice()->width());
   bounds.set_height(canvas->getDevice()->height());
@@ skipping 37 matching lines @@
 
   gfx::Rect viewport_size = gfx::IntersectRects(
       src_subrect, gfx::Rect(physical_backing_size_));
 
   skia::RefPtr<SkCanvas> canvas = skia::AdoptRef(
       skia::CreatePlatformCanvas(viewport_size.width(),
                                  viewport_size.height(),
                                  true,
                                  NULL,
                                  skia::RETURN_NULL_ON_FAILURE));
-  if (!canvas.get())
+  if (!canvas)
     return false;
 
   canvas->save();
   webwidget_->layout();
 
   PaintRect(viewport_size, viewport_size.origin(), canvas.get());
   canvas->restore();
 
   const SkBitmap& bitmap = skia::GetTopDevice(*canvas)->accessBitmap(false);
   if (!bitmap.copyTo(snapshot, SkBitmap::kARGB_8888_Config))
@@ skipping 444 matching lines @@
 
   if (!context->Initialize(
           attributes,
           false /* bind generates resources */,
           CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE))
     return NULL;
   return context.release();
 }
 
 }  // namespace content