Remove implicit scoped_refptr operator T*

media/base/pipeline.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 "media/base/pipeline.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 273 matching lines @@
   DCHECK(stop_cb_.is_null())
       << "State transitions don't happen when stopping";
   DCHECK_EQ(status_, PIPELINE_OK)
       << "State transitions don't happen when there's an error: " << status_;
 
   switch (state_) {
     case kCreated:
       return kInitDemuxer;
 
     case kInitDemuxer:
-      if (demuxer_->GetStream(DemuxerStream::AUDIO))
+      if (demuxer_->GetStream(DemuxerStream::AUDIO).get())
         return kInitAudioRenderer;
-      if (demuxer_->GetStream(DemuxerStream::VIDEO))
+      if (demuxer_->GetStream(DemuxerStream::VIDEO).get())
         return kInitVideoRenderer;
       return kInitPrerolling;
 
     case kInitAudioRenderer:
-      if (demuxer_->GetStream(DemuxerStream::VIDEO))
+      if (demuxer_->GetStream(DemuxerStream::VIDEO).get())
         return kInitVideoRenderer;
       return kInitPrerolling;
 
     case kInitVideoRenderer:
       return kInitPrerolling;
 
     case kInitPrerolling:
       return kStarting;
 
     case kSeeking:
@@ skipping 159 matching lines @@
       {
         base::AutoLock l(lock_);
         // We do not want to start the clock running. We only want to set the
         // base media time so our timestamp calculations will be correct.
         clock_->SetTime(demuxer_->GetStartTime(), demuxer_->GetStartTime());
 
         // TODO(scherkus): |has_audio_| should be true no matter what --
         // otherwise people with muted/disabled sound cards will make our
         // default controls look as if every video doesn't contain an audio
         // track.
-        has_audio_ = audio_renderer_ != NULL && !audio_disabled_;
-        has_video_ = video_renderer_ != NULL;
+        has_audio_ = audio_renderer_.get() != NULL && !audio_disabled_;
+        has_video_ = video_renderer_.get() != NULL;
       }
-      if (!audio_renderer_ && !video_renderer_) {
+      if (!audio_renderer_.get() && !video_renderer_.get()) {
         done_cb.Run(PIPELINE_ERROR_COULD_NOT_RENDER);
         return;
       }
 
       buffering_state_cb_.Run(kHaveMetadata);
 
       return DoInitialPreroll(done_cb);
 
     case kStarting:
       return DoPlay(done_cb);
@@ skipping 29 matching lines @@
 }
 
 void Pipeline::DoInitialPreroll(const PipelineStatusCB& done_cb) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK(!pending_callbacks_.get());
   SerialRunner::Queue bound_fns;
 
   base::TimeDelta seek_timestamp = demuxer_->GetStartTime();
 
   // Preroll renderers.
-  if (audio_renderer_) {
+  if (audio_renderer_.get()) {
     bound_fns.Push(base::Bind(
         &AudioRenderer::Preroll, audio_renderer_, seek_timestamp));
   }
 
-  if (video_renderer_) {
+  if (video_renderer_.get()) {
     bound_fns.Push(base::Bind(
         &VideoRenderer::Preroll, video_renderer_, seek_timestamp));
   }
 
   pending_callbacks_ = SerialRunner::Run(bound_fns, done_cb);
 }
 
 void Pipeline::DoSeek(
     base::TimeDelta seek_timestamp,
     const PipelineStatusCB& done_cb) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK(!pending_callbacks_.get());
   SerialRunner::Queue bound_fns;
 
   // Pause.
-  if (audio_renderer_)
+  if (audio_renderer_.get())
     bound_fns.Push(base::Bind(&AudioRenderer::Pause, audio_renderer_));
-  if (video_renderer_)
+  if (video_renderer_.get())
     bound_fns.Push(base::Bind(&VideoRenderer::Pause, video_renderer_));
 
   // Flush.
-  if (audio_renderer_)
+  if (audio_renderer_.get())
     bound_fns.Push(base::Bind(&AudioRenderer::Flush, audio_renderer_));
-  if (video_renderer_)
+  if (video_renderer_.get())
     bound_fns.Push(base::Bind(&VideoRenderer::Flush, video_renderer_));
 
   // Seek demuxer.
   bound_fns.Push(base::Bind(
       &Demuxer::Seek, demuxer_, seek_timestamp));
 
   // Preroll renderers.
-  if (audio_renderer_) {
+  if (audio_renderer_.get()) {
     bound_fns.Push(base::Bind(
         &AudioRenderer::Preroll, audio_renderer_, seek_timestamp));
   }
 
-  if (video_renderer_) {
+  if (video_renderer_.get()) {
     bound_fns.Push(base::Bind(
         &VideoRenderer::Preroll, video_renderer_, seek_timestamp));
   }
 
   pending_callbacks_ = SerialRunner::Run(bound_fns, done_cb);
 }
 
 void Pipeline::DoPlay(const PipelineStatusCB& done_cb) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK(!pending_callbacks_.get());
   SerialRunner::Queue bound_fns;
 
   PlaybackRateChangedTask(GetPlaybackRate());
   VolumeChangedTask(GetVolume());
 
-  if (audio_renderer_)
+  if (audio_renderer_.get())
     bound_fns.Push(base::Bind(&AudioRenderer::Play, audio_renderer_));
 
-  if (video_renderer_)
+  if (video_renderer_.get())
     bound_fns.Push(base::Bind(&VideoRenderer::Play, video_renderer_));
 
   pending_callbacks_ = SerialRunner::Run(bound_fns, done_cb);
 }
 
 void Pipeline::DoStop(const PipelineStatusCB& done_cb) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK(!pending_callbacks_.get());
   SerialRunner::Queue bound_fns;
 
-  if (demuxer_)
+  if (demuxer_.get())
     bound_fns.Push(base::Bind(&Demuxer::Stop, demuxer_));
 
-  if (audio_renderer_)
+  if (audio_renderer_.get())
     bound_fns.Push(base::Bind(&AudioRenderer::Stop, audio_renderer_));
 
-  if (video_renderer_)
+  if (video_renderer_.get())
     bound_fns.Push(base::Bind(&VideoRenderer::Stop, video_renderer_));
 
   pending_callbacks_ = SerialRunner::Run(bound_fns, done_cb);
 }
 
 void Pipeline::OnStopCompleted(PipelineStatus status) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK_EQ(state_, kStopping);
   {
     base::AutoLock l(lock_);
@@ skipping 123 matching lines @@
 
   // Playback rate changes are only carried out while playing.
   if (state_ != kStarting && state_ != kStarted)
     return;
 
   {
     base::AutoLock auto_lock(lock_);
     clock_->SetPlaybackRate(playback_rate);
   }
 
-  if (demuxer_)
+  if (demuxer_.get())
     demuxer_->SetPlaybackRate(playback_rate);
-  if (audio_renderer_)
+  if (audio_renderer_.get())
     audio_renderer_->SetPlaybackRate(playback_rate_);
-  if (video_renderer_)
+  if (video_renderer_.get())
     video_renderer_->SetPlaybackRate(playback_rate_);
 }
 
 void Pipeline::VolumeChangedTask(float volume) {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   // Volume changes are only carried out while playing.
   if (state_ != kStarting && state_ != kStarted)
     return;
 
-  if (audio_renderer_)
+  if (audio_renderer_.get())
     audio_renderer_->SetVolume(volume);
 }
 
 void Pipeline::SeekTask(TimeDelta time, const PipelineStatusCB& seek_cb) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK(stop_cb_.is_null());
 
   // Suppress seeking if we're not fully started.
   if (state_ != kStarted) {
     DCHECK(state_ == kStopping || state_ == kStopped)
@@ skipping 51 matching lines @@
 
   DCHECK(!video_ended_);
   video_ended_ = true;
 
   RunEndedCallbackIfNeeded();
 }
 
 void Pipeline::RunEndedCallbackIfNeeded() {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
-  if (audio_renderer_ && !audio_ended_ && !audio_disabled_)
+  if (audio_renderer_.get() && !audio_ended_ && !audio_disabled_)
     return;
 
-  if (video_renderer_ && !video_ended_)
+  if (video_renderer_.get() && !video_ended_)
     return;
 
   {
     base::AutoLock auto_lock(lock_);
     clock_->EndOfStream();
   }
 
   // TODO(scherkus): Change |ended_cb_| into a Closure.
   DCHECK_EQ(status_, PIPELINE_OK);
   ended_cb_.Run(status_);
@@ skipping 74 matching lines @@
 void Pipeline::OnAudioUnderflow() {
   if (!message_loop_->BelongsToCurrentThread()) {
     message_loop_->PostTask(FROM_HERE, base::Bind(
         &Pipeline::OnAudioUnderflow, this));
     return;
   }
 
   if (state_ != kStarted)
     return;
 
-  if (audio_renderer_)
+  if (audio_renderer_.get())
     audio_renderer_->ResumeAfterUnderflow(true);
 }
 
 void Pipeline::StartClockIfWaitingForTimeUpdate_Locked() {
   lock_.AssertAcquired();
   if (!waiting_for_clock_update_)
     return;
 
   waiting_for_clock_update_ = false;
   clock_->Play();
 }
 
 }  // namespace media