Remove implicit conversions from scoped_refptr to T* in content/renderer/media/

content/renderer/media/video_track_adapter.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 "content/renderer/media/video_track_adapter.h"
 
 #include <algorithm>
 #include <limits>
 #include <utility>
 
@@ skipping 106 matching lines @@
     double min_aspect_ratio,
     double max_aspect_ratio,
     double max_frame_rate)
     : renderer_task_runner_(render_message_loop),
       max_frame_size_(max_size),
       min_aspect_ratio_(min_aspect_ratio),
       max_aspect_ratio_(max_aspect_ratio),
       frame_rate_(MediaStreamVideoSource::kDefaultFrameRate),
       max_frame_rate_(max_frame_rate),
       keep_frame_counter_(0.0f) {
-  DCHECK(renderer_task_runner_);
+  DCHECK(renderer_task_runner_.get());
   DCHECK(io_thread_checker_.CalledOnValidThread());
   DCHECK_GE(max_aspect_ratio_, min_aspect_ratio_);
   CHECK_NE(0, max_aspect_ratio_);
   DVLOG(3) << "VideoFrameResolutionAdapter("
           << "{ max_width =" << max_frame_size_.width() << "}, "
           << "{ max_height =" << max_frame_size_.height() << "}, "
           << "{ min_aspect_ratio =" << min_aspect_ratio << "}, "
           << "{ max_aspect_ratio_ =" << max_aspect_ratio_ << "}"
           << "{ max_frame_rate_ =" << max_frame_rate_ << "}) ";
 }
@@ skipping 166 matching lines @@
   DCHECK(io_thread_checker_.CalledOnValidThread());
   return callbacks_.empty();
 }
 
 VideoTrackAdapter::VideoTrackAdapter(
     const scoped_refptr<base::MessageLoopProxy>& io_message_loop)
     : io_message_loop_(io_message_loop),
       renderer_task_runner_(base::MessageLoopProxy::current()),
       frame_counter_(0),
       source_frame_rate_(0.0f) {
-  DCHECK(io_message_loop_);
+  DCHECK(io_message_loop_.get());
 }
 
 VideoTrackAdapter::~VideoTrackAdapter() {
   DCHECK(adapters_.empty());
   UMA_HISTOGRAM_BOOLEAN("Media.VideoTrackAdapter.FramesReceived",
                         frame_counter_ > 0);
 }
 
 void VideoTrackAdapter::AddTrack(
     const MediaStreamVideoTrack* track,
@@ skipping 29 matching lines @@
   DCHECK(io_message_loop_->BelongsToCurrentThread());
   scoped_refptr<VideoFrameResolutionAdapter> adapter;
   for (FrameAdapters::const_iterator it = adapters_.begin();
        it != adapters_.end(); ++it) {
     if ((*it)->ConstraintsMatch(max_frame_size, min_aspect_ratio,
                                 max_aspect_ratio, max_frame_rate)) {
       adapter = it->get();
       break;
     }
   }
-  if (!adapter) {
+  if (!adapter.get()) {
     adapter = new VideoFrameResolutionAdapter(renderer_task_runner_,
                                               max_frame_size,
                                               min_aspect_ratio,
                                               max_aspect_ratio,
                                               max_frame_rate);
     adapters_.push_back(adapter);
   }
 
   adapter->AddCallback(track, frame_callback);
 }
@@ skipping 61 matching lines @@
   // Rearm the monitoring while there are active Tracks, i.e. as long as the
   // owner MediaStreamSource is active.
   io_message_loop_->PostDelayedTask(FROM_HERE,
       base::Bind(&VideoTrackAdapter::CheckFramesReceivedOnIO, this,
           set_muted_state_callback, frame_counter_),
       base::TimeDelta::FromSecondsD(kNormalFrameTimeoutInFrameIntervals /
                                     source_frame_rate_));
 }
 
 }  // namespace content