Remove implicit conversions from scoped_refptr to T* in remoting/

remoting/host/video_frame_recorder.cc

 // Copyright 2014 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 "remoting/host/video_frame_recorder.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
@@ skipping 16 matching lines @@
  public:
   RecordingVideoEncoder(scoped_ptr<VideoEncoder> encoder,
                         scoped_refptr<base::TaskRunner> recorder_task_runner,
                         base::WeakPtr<VideoFrameRecorder> recorder)
       : encoder_(encoder.Pass()),
         recorder_task_runner_(recorder_task_runner),
         recorder_(recorder),
         enable_recording_(false),
         weak_factory_(this) {
     DCHECK(encoder_);
-    DCHECK(recorder_task_runner_);
+    DCHECK(recorder_task_runner_.get());
   }
 
   base::WeakPtr<RecordingVideoEncoder> AsWeakPtr() {
     return weak_factory_.GetWeakPtr();
   }
 
   void SetEnableRecording(bool enable_recording) {
-    DCHECK(!encoder_task_runner_ ||
+    DCHECK(!encoder_task_runner_.get() ||
            encoder_task_runner_->BelongsToCurrentThread());
     enable_recording_ = enable_recording;
   }
 
   // remoting::VideoEncoder interface.
   virtual void SetLosslessEncode(bool want_lossless) OVERRIDE {
     encoder_->SetLosslessEncode(want_lossless);
   }
   virtual void SetLosslessColor(bool want_lossless) OVERRIDE {
     encoder_->SetLosslessColor(want_lossless);
   }
   virtual scoped_ptr<VideoPacket> Encode(
       const webrtc::DesktopFrame& frame) OVERRIDE {
     // If this is the first Encode() then store the TaskRunner and inform the
     // VideoFrameRecorder so it can post SetEnableRecording() on it.
-    if (!encoder_task_runner_) {
+    if (!encoder_task_runner_.get()) {
       encoder_task_runner_ = base::ThreadTaskRunnerHandle::Get();
       recorder_task_runner_->PostTask(FROM_HERE,
           base::Bind(&VideoFrameRecorder::SetEncoderTaskRunner,
                      recorder_,
                      encoder_task_runner_));
     }
 
     DCHECK(encoder_task_runner_->BelongsToCurrentThread());
 
     if (enable_recording_) {
@@ skipping 33 matching lines @@
       enable_recording_(false),
       weak_factory_(this) {
 }
 
 VideoFrameRecorder::~VideoFrameRecorder() {
   DetachVideoEncoderWrapper();
 }
 
 scoped_ptr<VideoEncoder> VideoFrameRecorder::WrapVideoEncoder(
     scoped_ptr<VideoEncoder> encoder) {
-  DCHECK(!encoder_task_runner_);
-  DCHECK(!caller_task_runner_);
+  DCHECK(!encoder_task_runner_.get());
+  DCHECK(!caller_task_runner_.get());
   caller_task_runner_ = base::ThreadTaskRunnerHandle::Get();
 
   scoped_ptr<RecordingVideoEncoder> recording_encoder(
       new RecordingVideoEncoder(encoder.Pass(),
                                 caller_task_runner_,
                                 weak_factory_.GetWeakPtr()));
   recording_encoder_ = recording_encoder->AsWeakPtr();
 
   return recording_encoder.PassAs<VideoEncoder>();
 }
 
 void VideoFrameRecorder::DetachVideoEncoderWrapper() {
-  DCHECK(!caller_task_runner_ || caller_task_runner_->BelongsToCurrentThread());
+  DCHECK(!caller_task_runner_.get() ||
+         caller_task_runner_->BelongsToCurrentThread());
 
   // Immediately detach the wrapper from this recorder.
   weak_factory_.InvalidateWeakPtrs();
 
   // Clean up any pending recorded frames.
   STLDeleteElements(&recorded_frames_);
   content_bytes_ = 0;
 
   // Tell the wrapper to stop recording and posting frames to us.
-  if (encoder_task_runner_) {
+  if (encoder_task_runner_.get()) {
     encoder_task_runner_->PostTask(FROM_HERE,
         base::Bind(&RecordingVideoEncoder::SetEnableRecording,
                    recording_encoder_, false));
   }
 
   // Detach this recorder from the calling and encode threads.
   caller_task_runner_ = NULL;
   encoder_task_runner_ = NULL;
 }
 
 void VideoFrameRecorder::SetEnableRecording(bool enable_recording) {
-  DCHECK(!caller_task_runner_ || caller_task_runner_->BelongsToCurrentThread());
+  DCHECK(!caller_task_runner_.get() ||
+         caller_task_runner_->BelongsToCurrentThread());
 
   if (enable_recording_ == enable_recording) {
     return;
   }
   enable_recording_ = enable_recording;
 
-  if (encoder_task_runner_) {
+  if (encoder_task_runner_.get()) {
     encoder_task_runner_->PostTask(FROM_HERE,
         base::Bind(&RecordingVideoEncoder::SetEnableRecording,
                    recording_encoder_,
                    enable_recording_));
   }
 }
 
 void VideoFrameRecorder::SetMaxContentBytes(int64_t max_content_bytes) {
-  DCHECK(!caller_task_runner_ || caller_task_runner_->BelongsToCurrentThread());
+  DCHECK(!caller_task_runner_.get() ||
+         caller_task_runner_->BelongsToCurrentThread());
   DCHECK_GE(max_content_bytes, 0);
 
   max_content_bytes_ = max_content_bytes;
 }
 
 scoped_ptr<webrtc::DesktopFrame> VideoFrameRecorder::NextFrame() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   scoped_ptr<webrtc::DesktopFrame> frame;
   if (!recorded_frames_.empty()) {
     frame.reset(recorded_frames_.front());
     recorded_frames_.pop_front();
     content_bytes_ -= FrameContentSize(frame.get());
     DCHECK_GE(content_bytes_, 0);
   }
 
   return frame.Pass();
 }
 
 void VideoFrameRecorder::SetEncoderTaskRunner(
     scoped_refptr<base::TaskRunner> task_runner) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
-  DCHECK(!encoder_task_runner_);
-  DCHECK(task_runner);
+  DCHECK(!encoder_task_runner_.get());
+  DCHECK(task_runner.get());
 
   encoder_task_runner_ = task_runner;
 
   // If the caller already enabled recording, inform the recording encoder.
-  if (enable_recording_ && encoder_task_runner_) {
+  if (enable_recording_ && encoder_task_runner_.get()) {
     encoder_task_runner_->PostTask(FROM_HERE,
         base::Bind(&RecordingVideoEncoder::SetEnableRecording,
                    recording_encoder_,
                    enable_recording_));
   }
 }
 
 void VideoFrameRecorder::RecordFrame(scoped_ptr<webrtc::DesktopFrame> frame) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
@@ skipping 13 matching lines @@
   if (content_bytes_ + frame_bytes > max_content_bytes_) {
     return;
   }
 
   // Store the frame and update the content byte count.
   recorded_frames_.push_back(frame.release());
   content_bytes_ += frame_bytes;
 }
 
 }  // namespace remoting