Remove reference counting from media::Pipeline.

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 64 matching lines @@
                      const PipelineStatusCB& error_cb,
                      const PipelineStatusCB& seek_cb,
                      const BufferingStateCB& buffering_state_cb,
                      const base::Closure& duration_change_cb) {
   base::AutoLock auto_lock(lock_);
   CHECK(!running_) << "Media pipeline is already running";
   DCHECK(!buffering_state_cb.is_null());
 
   running_ = true;
   message_loop_->PostTask(FROM_HERE, base::Bind(
-      &Pipeline::StartTask, this, base::Passed(&collection),
+      &Pipeline::StartTask, base::Unretained(this), base::Passed(&collection),
       ended_cb, error_cb, seek_cb, buffering_state_cb, duration_change_cb));
 }
 
 void Pipeline::Stop(const base::Closure& stop_cb) {
   base::AutoLock auto_lock(lock_);
   message_loop_->PostTask(FROM_HERE, base::Bind(
-      &Pipeline::StopTask, this, stop_cb));
+      &Pipeline::StopTask, base::Unretained(this), stop_cb));
 }
 
 void Pipeline::Seek(TimeDelta time, const PipelineStatusCB& seek_cb) {
   base::AutoLock auto_lock(lock_);
   if (!running_) {
     NOTREACHED() << "Media pipeline isn't running";
     return;
   }
 
   message_loop_->PostTask(FROM_HERE, base::Bind(
-      &Pipeline::SeekTask, this, time, seek_cb));
+      &Pipeline::SeekTask, base::Unretained(this), time, seek_cb));
 }
 
 bool Pipeline::IsRunning() const {
   base::AutoLock auto_lock(lock_);
   return running_;
 }
 
 bool Pipeline::HasAudio() const {
   base::AutoLock auto_lock(lock_);
   return has_audio_;
@@ skipping 10 matching lines @@
 }
 
 void Pipeline::SetPlaybackRate(float playback_rate) {
   if (playback_rate < 0.0f)
     return;
 
   base::AutoLock auto_lock(lock_);
   playback_rate_ = playback_rate;
   if (running_) {
     message_loop_->PostTask(FROM_HERE, base::Bind(
-        &Pipeline::PlaybackRateChangedTask, this, playback_rate));
+        &Pipeline::PlaybackRateChangedTask, base::Unretained(this),
+        playback_rate));
   }
 }
 
 float Pipeline::GetVolume() const {
   base::AutoLock auto_lock(lock_);
   return volume_;
 }
 
 void Pipeline::SetVolume(float volume) {
   if (volume < 0.0f || volume > 1.0f)
     return;
 
   base::AutoLock auto_lock(lock_);
   volume_ = volume;
   if (running_) {
     message_loop_->PostTask(FROM_HERE, base::Bind(
-        &Pipeline::VolumeChangedTask, this, volume));
+        &Pipeline::VolumeChangedTask, base::Unretained(this), volume));
   }
 }
 
 TimeDelta Pipeline::GetMediaTime() const {
   base::AutoLock auto_lock(lock_);
   return clock_->Elapsed();
 }
 
 Ranges<TimeDelta> Pipeline::GetBufferedTimeRanges() {
   base::AutoLock auto_lock(lock_);
@@ skipping 133 matching lines @@
 void Pipeline::OnDemuxerError(PipelineStatus error) {
   SetError(error);
 }
 
 void Pipeline::SetError(PipelineStatus error) {
   DCHECK(IsRunning());
   DCHECK_NE(PIPELINE_OK, error);
   VLOG(1) << "Media pipeline error: " << error;
 
   message_loop_->PostTask(FROM_HERE, base::Bind(
-      &Pipeline::ErrorChangedTask, this, error));
+      &Pipeline::ErrorChangedTask, base::Unretained(this), error));
 
   media_log_->AddEvent(media_log_->CreatePipelineErrorEvent(error));
 }
 
 void Pipeline::OnAudioDisabled() {
   DCHECK(IsRunning());
   message_loop_->PostTask(FROM_HERE, base::Bind(
-      &Pipeline::AudioDisabledTask, this));
+      &Pipeline::AudioDisabledTask, base::Unretained(this)));
   media_log_->AddEvent(
       media_log_->CreateEvent(MediaLogEvent::AUDIO_RENDERER_DISABLED));
 }
 
 void Pipeline::OnAudioTimeUpdate(TimeDelta time, TimeDelta max_time) {
   DCHECK_LE(time.InMicroseconds(), max_time.InMicroseconds());
   DCHECK(IsRunning());
   base::AutoLock auto_lock(lock_);
 
   if (!has_audio_)
@@ skipping 64 matching lines @@
   if (time_offset < epsilon)
     return TimeDelta();
   if (time_offset + epsilon > clock_->Duration())
     return clock_->Duration();
   return time_offset;
 }
 
 void Pipeline::OnStateTransition(PipelineStatus status) {
   // Force post to process state transitions after current execution frame.
   message_loop_->PostTask(FROM_HERE, base::Bind(
-      &Pipeline::StateTransitionTask, this, status));
+      &Pipeline::StateTransitionTask, base::Unretained(this), status));
 }
 
 void Pipeline::StateTransitionTask(PipelineStatus status) {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   // No-op any state transitions if we're stopping.
   if (state_ == kStopping || state_ == kStopped)
     return;
 
   // Preserve existing abnormal status, otherwise update based on the result of
   // the previous operation.
   status_ = (status_ != PIPELINE_OK ? status_ : status);
 
   if (status_ != PIPELINE_OK) {
     ErrorChangedTask(status_);
     return;
   }
 
   // Guard against accidentally clearing |pending_callbacks_| for states that
   // use it as well as states that should not be using it.
   //
   // TODO(scherkus): Make every state transition use |pending_callbacks_|.
   DCHECK_EQ(pending_callbacks_.get() != NULL,
             (state_ == kInitPrerolling || state_ == kStarting ||
              state_ == kSeeking));
   pending_callbacks_.reset();
 
-  PipelineStatusCB done_cb = base::Bind(&Pipeline::OnStateTransition, this);
+  PipelineStatusCB done_cb = base::Bind(
+      &Pipeline::OnStateTransition, base::Unretained(this));
 
   // Switch states, performing any entrance actions for the new state as well.
   SetState(GetNextState());
   switch (state_) {
     case kInitDemuxer:
       return InitializeDemuxer(done_cb);
 
     case kInitAudioRenderer:
       return InitializeAudioRenderer(done_cb);
 
@@ skipping 228 matching lines @@
   media_log_->AddEvent(media_log_->CreateVideoSizeSetEvent(
       size.width(), size.height()));
 
   base::AutoLock auto_lock(lock_);
   natural_size_ = size;
 }
 
 void Pipeline::OnAudioRendererEnded() {
   // Force post to process ended messages after current execution frame.
   message_loop_->PostTask(FROM_HERE, base::Bind(
-      &Pipeline::DoAudioRendererEnded, this));
+      &Pipeline::DoAudioRendererEnded, base::Unretained(this)));
   media_log_->AddEvent(media_log_->CreateEvent(MediaLogEvent::AUDIO_ENDED));
 }
 
 void Pipeline::OnVideoRendererEnded() {
   // Force post to process ended messages after current execution frame.
   message_loop_->PostTask(FROM_HERE, base::Bind(
-      &Pipeline::DoVideoRendererEnded, this));
+      &Pipeline::DoVideoRendererEnded, base::Unretained(this)));
   media_log_->AddEvent(media_log_->CreateEvent(MediaLogEvent::VIDEO_ENDED));
 }
 
 // Called from any thread.
 void Pipeline::OnUpdateStatistics(const PipelineStatistics& stats) {
   base::AutoLock auto_lock(lock_);
   statistics_.audio_bytes_decoded += stats.audio_bytes_decoded;
   statistics_.video_bytes_decoded += stats.video_bytes_decoded;
   statistics_.video_frames_decoded += stats.video_frames_decoded;
   statistics_.video_frames_dropped += stats.video_frames_dropped;
@@ skipping 25 matching lines @@
 
   if (state_ == kStopped) {
     stop_cb.Run();
     return;
   }
 
   SetState(kStopping);
   pending_callbacks_.reset();
   stop_cb_ = stop_cb;
 
-  DoStop(base::Bind(&Pipeline::OnStopCompleted, this));
+  DoStop(base::Bind(&Pipeline::OnStopCompleted, base::Unretained(this)));
 }
 
 void Pipeline::ErrorChangedTask(PipelineStatus error) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK_NE(PIPELINE_OK, error) << "PIPELINE_OK isn't an error!";
 
   if (state_ == kStopping || state_ == kStopped)
     return;
 
   SetState(kStopping);
   pending_callbacks_.reset();
   status_ = error;
 
-  DoStop(base::Bind(&Pipeline::OnStopCompleted, this));
+  DoStop(base::Bind(&Pipeline::OnStopCompleted, base::Unretained(this)));
 }
 
 void Pipeline::PlaybackRateChangedTask(float playback_rate) {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   // Playback rate changes are only carried out while playing.
   if (state_ != kStarting && state_ != kStarted)
     return;
 
   {
@@ skipping 44 matching lines @@
   audio_ended_ = false;
   video_ended_ = false;
 
   // Kick off seeking!
   {
     base::AutoLock auto_lock(lock_);
     if (clock_->IsPlaying())
       clock_->Pause();
     clock_->SetTime(seek_timestamp, seek_timestamp);
   }
-  DoSeek(seek_timestamp, base::Bind(&Pipeline::OnStateTransition, this));
+  DoSeek(seek_timestamp, base::Bind(
+      &Pipeline::OnStateTransition, base::Unretained(this)));
 }
 
 void Pipeline::DoAudioRendererEnded() {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   if (state_ != kStarted)
     return;
 
   DCHECK(!audio_ended_);
   audio_ended_ = true;
@@ skipping 60 matching lines @@
   demuxer_->Initialize(this, done_cb);
 }
 
 void Pipeline::InitializeAudioRenderer(const PipelineStatusCB& done_cb) {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   audio_renderer_ = filter_collection_->GetAudioRenderer();
   audio_renderer_->Initialize(
       demuxer_->GetStream(DemuxerStream::AUDIO),
       done_cb,
-      base::Bind(&Pipeline::OnUpdateStatistics, this),
-      base::Bind(&Pipeline::OnAudioUnderflow, this),
-      base::Bind(&Pipeline::OnAudioTimeUpdate, this),
-      base::Bind(&Pipeline::OnAudioRendererEnded, this),
-      base::Bind(&Pipeline::OnAudioDisabled, this),
-      base::Bind(&Pipeline::SetError, this));
+      base::Bind(&Pipeline::OnUpdateStatistics, base::Unretained(this)),
+      base::Bind(&Pipeline::OnAudioUnderflow, base::Unretained(this)),
+      base::Bind(&Pipeline::OnAudioTimeUpdate, base::Unretained(this)),
+      base::Bind(&Pipeline::OnAudioRendererEnded, base::Unretained(this)),
+      base::Bind(&Pipeline::OnAudioDisabled, base::Unretained(this)),
+      base::Bind(&Pipeline::SetError, base::Unretained(this)));
 }
 
 void Pipeline::InitializeVideoRenderer(const PipelineStatusCB& done_cb) {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::VIDEO);
 
   {
     // Get an initial natural size so we have something when we signal
     // the kHaveMetadata buffering state.
     base::AutoLock l(lock_);
     natural_size_ = stream->video_decoder_config().natural_size();
   }
 
   video_renderer_ = filter_collection_->GetVideoRenderer();
   video_renderer_->Initialize(
       stream,
       done_cb,
-      base::Bind(&Pipeline::OnUpdateStatistics, this),
-      base::Bind(&Pipeline::OnVideoTimeUpdate, this),
-      base::Bind(&Pipeline::OnNaturalVideoSizeChanged, this),
-      base::Bind(&Pipeline::OnVideoRendererEnded, this),
-      base::Bind(&Pipeline::SetError, this),
-      base::Bind(&Pipeline::GetMediaTime, this),
-      base::Bind(&Pipeline::GetMediaDuration, this));
+      base::Bind(&Pipeline::OnUpdateStatistics, base::Unretained(this)),
+      base::Bind(&Pipeline::OnVideoTimeUpdate, base::Unretained(this)),
+      base::Bind(&Pipeline::OnNaturalVideoSizeChanged, base::Unretained(this)),
+      base::Bind(&Pipeline::OnVideoRendererEnded, base::Unretained(this)),
+      base::Bind(&Pipeline::SetError, base::Unretained(this)),
+      base::Bind(&Pipeline::GetMediaTime, base::Unretained(this)),
+      base::Bind(&Pipeline::GetMediaDuration, base::Unretained(this)));
 }
 
 void Pipeline::OnAudioUnderflow() {
   if (!message_loop_->BelongsToCurrentThread()) {
     message_loop_->PostTask(FROM_HERE, base::Bind(
-        &Pipeline::OnAudioUnderflow, this));
+        &Pipeline::OnAudioUnderflow, base::Unretained(this)));
     return;
   }
 
   if (state_ != kStarted)
     return;
 
   if (audio_renderer_)
     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