Move AudioRenderer out of Filter heirarchy.

media/base/pipeline.cc

Index: media/base/pipeline.cc
diff --git a/media/base/pipeline.cc b/media/base/pipeline.cc
index 2b26541a75109c87feafa993501dfc3d2699ba23..907aa77f8318e05c6ea4e18c8fe1f0066a2ccc61 100644
--- a/media/base/pipeline.cc
+++ b/media/base/pipeline.cc
@@ -17,6 +17,7 @@
 #include "base/synchronization/condition_variable.h"
 #include "media/base/audio_decoder.h"
 #include "media/base/audio_renderer.h"
+#include "media/base/callback_util.h"
 #include "media/base/clock.h"
 #include "media/base/composite_filter.h"
 #include "media/base/filter_collection.h"
@@ -64,7 +65,6 @@ media::PipelineStatus PipelineStatusNotification::status() {
 struct Pipeline::PipelineInitState {
   scoped_refptr<AudioDecoder> audio_decoder;
   scoped_refptr<VideoDecoder> video_decoder;
-  scoped_refptr<AudioRenderer> audio_renderer;
   scoped_refptr<VideoRenderer> video_renderer;
   scoped_refptr<CompositeFilter> composite;
 };
@@ -390,6 +390,14 @@ TimeDelta Pipeline::GetDuration() const {
   return GetMediaDuration();
 }
 
+void Pipeline::OnAudioDisabled() {
+  DCHECK(IsRunning());
+  message_loop_->PostTask(FROM_HERE, base::Bind(
+      &Pipeline::AudioDisabledTask, this));
+  media_log_->AddEvent(
+      media_log_->CreateEvent(MediaLogEvent::AUDIO_RENDERER_DISABLED));
+}
+
 void Pipeline::OnAudioTimeUpdate(TimeDelta time, TimeDelta max_time) {
   DCHECK(time <= max_time);
   DCHECK(IsRunning());
@@ -460,6 +468,57 @@ TimeDelta Pipeline::TimeForByteOffset_Locked(int64 byte_offset) const {
   return time_offset;
 }
 
+void Pipeline::DoPause(const base::Closure& done_cb) {
+  scoped_ptr<std::queue<ClosureCB> > closures(new std::queue<ClosureCB>);
+
+  if (audio_renderer_)
+    closures->push(base::Bind(&AudioRenderer::Pause, audio_renderer_));
+
+  if (pipeline_filter_)
+    closures->push(base::Bind(&Filter::Pause, pipeline_filter_));
+
+  RunInSeries(closures.Pass(), done_cb);
+}
+
+void Pipeline::DoFlush(const base::Closure& done_cb) {
+  scoped_ptr<std::queue<ClosureCB> > closures(new std::queue<ClosureCB>);
+
+  if (audio_renderer_)
+    closures->push(base::Bind(&AudioRenderer::Flush, audio_renderer_));
+
+  if (pipeline_filter_)
+    closures->push(base::Bind(&Filter::Flush, pipeline_filter_));
+
+  RunInParallel(closures.Pass(), done_cb);
+}
+
+void Pipeline::DoPlay(const base::Closure& done_cb) {
+  scoped_ptr<std::queue<ClosureCB> > closures(new std::queue<ClosureCB>);
+
+  if (audio_renderer_)
+    closures->push(base::Bind(&AudioRenderer::Play, audio_renderer_));
+
+  if (pipeline_filter_)
+    closures->push(base::Bind(&Filter::Play, pipeline_filter_));
+
+  RunInSeries(closures.Pass(), done_cb);
+}
+
+void Pipeline::DoStop(const base::Closure& done_cb) {
+  scoped_ptr<std::queue<ClosureCB> > closures(new std::queue<ClosureCB>);
+
+  if (demuxer_)
+    closures->push(base::Bind(&Demuxer::Stop, demuxer_));
+
+  if (audio_renderer_)
+    closures->push(base::Bind(&AudioRenderer::Stop, audio_renderer_));
+
+  if (pipeline_filter_)
+    closures->push(base::Bind(&Filter::Stop, pipeline_filter_));
+
+  RunInSeries(closures.Pass(), done_cb);
+}
+
 void Pipeline::AddBufferedByteRange(int64 start, int64 end) {
   DCHECK(IsRunning());
   base::AutoLock auto_lock(lock_);
@@ -491,16 +550,6 @@ void Pipeline::NotifyEnded() {
   media_log_->AddEvent(media_log_->CreateEvent(MediaLogEvent::ENDED));
 }
 
-void Pipeline::DisableAudioRenderer() {
-  DCHECK(IsRunning());
-
-  // Disable renderer on the message loop.
-  message_loop_->PostTask(FROM_HERE, base::Bind(
-      &Pipeline::DisableAudioRendererTask, this));
-  media_log_->AddEvent(
-      media_log_->CreateEvent(MediaLogEvent::AUDIO_RENDERER_DISABLED));
-}
-
 // Called from any thread.
 void Pipeline::OnFilterInitialize(PipelineStatus status) {
   // Continue the initialize task by proceeding to the next stage.
@@ -663,7 +712,9 @@ void Pipeline::InitializeTask(PipelineStatus last_stage_status) {
     seek_pending_ = true;
     SetState(kSeeking);
     seek_timestamp_ = demuxer_->GetStartTime();
-    OnDemuxerSeekDone(seek_timestamp_, PIPELINE_OK);
+    OnDemuxerSeekDone(
+        base::Bind(&Pipeline::OnFilterStateTransitionWithStatus, this),
+        seek_timestamp_, PIPELINE_OK);
   }
 }
 
@@ -752,9 +803,11 @@ void Pipeline::PlaybackRateChangedTask(float playback_rate) {
   // hasn't completed yet, the playback rate will be set when initialization
   // completes.
   if (pipeline_filter_) {
-    DCHECK(demuxer_);
     demuxer_->SetPlaybackRate(playback_rate);
     pipeline_filter_->SetPlaybackRate(playback_rate);
+
+    if (audio_renderer_)
+      audio_renderer_->SetPlaybackRate(playback_rate_);
   }
 }
 
@@ -800,8 +853,7 @@ void Pipeline::SeekTask(TimeDelta time, const PipelineStatusCB& seek_cb) {
     if (clock_->IsPlaying())
       clock_->Pause();
   }
-  pipeline_filter_->Pause(
-      base::Bind(&Pipeline::OnFilterStateTransition, this));
+  DoPause(base::Bind(&Pipeline::OnFilterStateTransition, this));
 }
 
 void Pipeline::NotifyEndedTask() {
@@ -841,7 +893,7 @@ void Pipeline::NotifyEndedTask() {
   ReportStatus(ended_cb_, status_);
 }
 
-void Pipeline::DisableAudioRendererTask() {
+void Pipeline::AudioDisabledTask() {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   base::AutoLock auto_lock(lock_);
@@ -888,16 +940,14 @@ void Pipeline::FilterStateTransitionTask() {
   // Carry out the action for the current state.
   if (TransientState(state_)) {
     if (state_ == kPausing) {
-      pipeline_filter_->Pause(
-          base::Bind(&Pipeline::OnFilterStateTransition, this));
+      DoPause(base::Bind(&Pipeline::OnFilterStateTransition, this));
     } else if (state_ == kFlushing) {
-      pipeline_filter_->Flush(
-          base::Bind(&Pipeline::OnFilterStateTransition, this));
+      DoFlush(base::Bind(&Pipeline::OnFilterStateTransition, this));
     } else if (state_ == kSeeking) {
-      DoSeek(seek_timestamp_);
+      DoSeek(base::Bind(&Pipeline::OnFilterStateTransitionWithStatus, this),
+             seek_timestamp_);
     } else if (state_ == kStarting) {
-      pipeline_filter_->Play(
-          base::Bind(&Pipeline::OnFilterStateTransition, this));
+      DoPlay(base::Bind(&Pipeline::OnFilterStateTransition, this));
     } else if (state_ == kStopping) {
       DoStop(base::Bind(&Pipeline::OnFilterStateTransition, this));
     } else {
@@ -943,8 +993,7 @@ void Pipeline::TeardownStateTransitionTask() {
       break;
     case kPausing:
       SetState(kFlushing);
-      pipeline_filter_->Flush(
-          base::Bind(&Pipeline::OnTeardownStateTransition, this));
+      DoFlush(base::Bind(&Pipeline::OnTeardownStateTransition, this));
       break;
     case kFlushing:
       SetState(kStopping);
@@ -1092,23 +1141,19 @@ bool Pipeline::InitializeAudioRenderer(
   if (!decoder)
     return false;
 
-  filter_collection_->SelectAudioRenderer(
-      &pipeline_init_state_->audio_renderer);
-  if (!pipeline_init_state_->audio_renderer) {
+  filter_collection_->SelectAudioRenderer(&audio_renderer_);
+  if (!audio_renderer_) {
     SetError(PIPELINE_ERROR_REQUIRED_FILTER_MISSING);
     return false;
   }
 
-  pipeline_init_state_->composite->AddFilter(
-      pipeline_init_state_->audio_renderer);
-
-  pipeline_init_state_->audio_renderer->Initialize(
+  audio_renderer_->Initialize(
       decoder,
       base::Bind(&Pipeline::OnFilterInitialize, this),
       base::Bind(&Pipeline::OnAudioUnderflow, this),
-      base::Bind(&Pipeline::OnAudioTimeUpdate, this));
-
-  audio_renderer_ = pipeline_init_state_->audio_renderer;
+      base::Bind(&Pipeline::OnAudioTimeUpdate, this),
+      base::Bind(&Pipeline::NotifyEnded, this),
+      base::Bind(&Pipeline::OnAudioDisabled, this));
   return true;
 }
 
@@ -1194,8 +1239,7 @@ void Pipeline::TearDownPipeline() {
     case kStarted:
     case kEnded:
       SetState(kPausing);
-      pipeline_filter_->Pause(
-          base::Bind(&Pipeline::OnTeardownStateTransition, this));
+      DoPause(base::Bind(&Pipeline::OnTeardownStateTransition, this));
       break;
 
     case kStopping:
@@ -1207,49 +1251,54 @@ void Pipeline::TearDownPipeline() {
   };
 }
 
-void Pipeline::DoStop(const base::Closure& callback) {
-  if (demuxer_) {
-    demuxer_->Stop(base::Bind(
-        &Pipeline::OnDemuxerStopDone, this, callback));
-    return;
-  }
-
-  OnDemuxerStopDone(callback);
+void Pipeline::DoSeek(const PipelineStatusCB& done_cb,
+                      TimeDelta seek_timestamp) {
+  demuxer_->Seek(seek_timestamp, base::Bind(

[acolwell GONE FROM CHROMIUM, 2012/07/19 00:58:18]

It feels like you should be able to do the same thing as RunInSeries() here.
Create a queue of base::Callback<void((base::TimeDelta const PipelineStatusCB&)
and then create a function that has the trampoline code, calls ReportStatus() on
errors, and pops & runs the next callback on the queue. done_cb gets called when
the queue is empty.

[scherkus (not reviewing), 2012/07/19 21:29:02]

Done and using the power of Bind() we don't need to keep carrying the
seek_timestamp param either!

+      &Pipeline::OnDemuxerSeekDone, this, done_cb, seek_timestamp));
 }
 
-void Pipeline::OnDemuxerStopDone(const base::Closure& callback) {
+void Pipeline::OnDemuxerSeekDone(const PipelineStatusCB& done_cb,
+                                 TimeDelta seek_timestamp,
+                                 PipelineStatus status) {
   if (!message_loop_->BelongsToCurrentThread()) {
     message_loop_->PostTask(FROM_HERE, base::Bind(
-        &Pipeline::OnDemuxerStopDone, this, callback));
+        &Pipeline::OnDemuxerSeekDone, this, done_cb, seek_timestamp, status));
     return;
   }
 
-  if (pipeline_filter_) {
-    pipeline_filter_->Stop(callback);
+  if (status == PIPELINE_OK && audio_renderer_) {
+    audio_renderer_->Seek(seek_timestamp, base::Bind(
+        &Pipeline::OnAudioRendererSeekDone, this, done_cb, seek_timestamp));
     return;
   }
 
-  callback.Run();
-}
-
-void Pipeline::DoSeek(TimeDelta seek_timestamp) {
-  demuxer_->Seek(seek_timestamp, base::Bind(
-      &Pipeline::OnDemuxerSeekDone, this, seek_timestamp));
+  OnAudioRendererSeekDone(done_cb, seek_timestamp, status);
 }
 
-void Pipeline::OnDemuxerSeekDone(TimeDelta seek_timestamp,
-                                 PipelineStatus status) {
+void Pipeline::OnAudioRendererSeekDone(const PipelineStatusCB& done_cb,
+                                       base::TimeDelta seek_timestamp,
+                                       PipelineStatus status) {
   if (!message_loop_->BelongsToCurrentThread()) {
     message_loop_->PostTask(FROM_HERE, base::Bind(
-        &Pipeline::OnDemuxerSeekDone, this, seek_timestamp, status));
+        &Pipeline::OnAudioRendererSeekDone, this, done_cb, seek_timestamp,
+        status));
     return;
   }
 
-  PipelineStatusCB done_cb =
-      base::Bind(&Pipeline::OnFilterStateTransitionWithStatus, this);
-
   if (status == PIPELINE_OK && pipeline_filter_) {
-    pipeline_filter_->Seek(seek_timestamp, done_cb);
+    pipeline_filter_->Seek(seek_timestamp, base::Bind(
+        &Pipeline::OnPipelineFilterSeekDone, this, done_cb));
+    return;
+  }
+
+  OnPipelineFilterSeekDone(done_cb, status);
+}
+
+void Pipeline::OnPipelineFilterSeekDone(const PipelineStatusCB& done_cb,
+                                        PipelineStatus status) {
+  if (!message_loop_->BelongsToCurrentThread()) {
+    message_loop_->PostTask(FROM_HERE, base::Bind(
+        &Pipeline::OnPipelineFilterSeekDone, this, done_cb, status));
     return;
   }