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

content/browser/renderer_host/media/web_contents_video_capture_device.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.
 //
 // Implementation notes: This needs to work on a variety of hardware
 // configurations where the speed of the CPU and GPU greatly affect overall
 // performance. Spanning several threads, the process of capturing has been
 // split up into four conceptual stages:
 //
 //   1. Reserve Buffer: Before a frame can be captured, a slot in the consumer's
@@ skipping 420 matching lines @@
       oracle_->ObserveEventAndDecideCapture(event, event_time);
   const bool content_is_dirty =
       (event == VideoCaptureOracle::kCompositorUpdate ||
        event == VideoCaptureOracle::kSoftwarePaint);
   const char* event_name =
       (event == VideoCaptureOracle::kTimerPoll ? "poll" :
        (event == VideoCaptureOracle::kCompositorUpdate ? "gpu" :
        "paint"));
 
   // Consider the various reasons not to initiate a capture.
-  if (should_capture && !output_buffer) {
-    TRACE_EVENT_INSTANT1("mirroring", "EncodeLimited",
+  if (should_capture && !output_buffer.get()) {
+    TRACE_EVENT_INSTANT1("mirroring",
+                         "EncodeLimited",
                          TRACE_EVENT_SCOPE_THREAD,
-                         "trigger", event_name);
+                         "trigger",
+                         event_name);
     return false;
-  } else if (!should_capture && output_buffer) {
+  } else if (!should_capture && output_buffer.get()) {
     if (content_is_dirty) {
       // This is a normal and acceptable way to drop a frame. We've hit our
       // capture rate limit: for example, the content is animating at 60fps but
       // we're capturing at 30fps.
       TRACE_EVENT_INSTANT1("mirroring", "FpsRateLimited",
                            TRACE_EVENT_SCOPE_THREAD,
                            "trigger", event_name);
     }
     return false;
-  } else if (!should_capture && !output_buffer) {
+  } else if (!should_capture && !output_buffer.get()) {
     // We decided not to capture, but we wouldn't have been able to if we wanted
     // to because no output buffer was available.
     TRACE_EVENT_INSTANT1("mirroring", "NearlyEncodeLimited",
                          TRACE_EVENT_SCOPE_THREAD,
                          "trigger", event_name);
     return false;
   }
   int frame_number = oracle_->RecordCapture();
   TRACE_EVENT_ASYNC_BEGIN2("mirroring", "Capture", output_buffer.get(),
                            "frame_number", frame_number,
@@ skipping 212 matching lines @@
   }
 
   TRACE_EVENT_ASYNC_STEP0("mirroring", "Capture", output.get(), "YUV");
   {
     SkAutoLockPixels scaled_bitmap_locker(scaled_bitmap);
 
     media::CopyRGBToVideoFrame(
         reinterpret_cast<uint8*>(scaled_bitmap.getPixels()),
         scaled_bitmap.rowBytes(),
         region_in_frame,
-        output);
+        output.get());
   }
 
   // The result is now ready.
   failure_handler.Release();
   done_cb.Run(true);
 }
 
 VideoFrameDeliveryLog::VideoFrameDeliveryLog()
     : last_frame_rate_log_time_(),
       count_frames_rendered_(0),
@@ skipping 33 matching lines @@
   }
 }
 
 // static
 scoped_ptr<CaptureMachine> CaptureMachine::Create(
     int render_process_id,
     int render_view_id,
     const scoped_refptr<base::SequencedTaskRunner>& render_task_runner,
     const scoped_refptr<ThreadSafeCaptureOracle>& oracle_proxy) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK(render_task_runner);
-  DCHECK(oracle_proxy);
+  DCHECK(render_task_runner.get());
+  DCHECK(oracle_proxy.get());
   scoped_ptr<CaptureMachine> machine(
       new CaptureMachine(render_task_runner, oracle_proxy));
 
   if (!machine->StartObservingWebContents(render_process_id, render_view_id))
     machine.reset();
 
   return machine.Pass();
 }
 
 CaptureMachine::CaptureMachine(
@@ skipping 507 matching lines @@
 void WebContentsVideoCaptureDevice::DeAllocate() {
   impl_->DeAllocate();
 }
 
 const media::VideoCaptureDevice::Name&
 WebContentsVideoCaptureDevice::device_name() {
   return device_name_;
 }
 
 }  // namespace content