Move OnDecoderInitDone() from decoder to pipeline thread.

media/filters/audio_renderer_impl.cc

Index: media/filters/audio_renderer_impl.cc
diff --git a/media/filters/audio_renderer_impl.cc b/media/filters/audio_renderer_impl.cc
index 2805ed05837293fa6ea1c6f245393f8f8a35bf8f..2181d48599531c8855e30bb4179a6db4bacee550 100644
--- a/media/filters/audio_renderer_impl.cc
+++ b/media/filters/audio_renderer_impl.cc
@@ -13,38 +13,42 @@
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/logging.h"
+#include "base/message_loop_proxy.h"
 #include "media/audio/audio_util.h"
+#include "media/base/bind_to_loop.h"
 #include "media/base/demuxer_stream.h"
 #include "media/base/media_switches.h"
 
 namespace media {
 
 AudioRendererImpl::AudioRendererImpl(media::AudioRendererSink* sink)
-    : state_(kUninitialized),
+    : sink_(sink),
+      state_(kUninitialized),
       pending_read_(false),
       received_end_of_stream_(false),
       rendered_end_of_stream_(false),
       audio_time_buffered_(kNoTimestamp()),
       current_time_(kNoTimestamp()),
-      bytes_per_frame_(0),
-      stopped_(false),
-      sink_(sink),
       underflow_disabled_(false),
-      preroll_aborted_(false) {
+      preroll_aborted_(false),
+      actual_frames_per_buffer_(0) {
+  // We're created on the render thread, but this thread checker is for another.
+  pipeline_thread_checker_.DetachFromThread();
 }
 
 void AudioRendererImpl::Play(const base::Closure& callback) {
+  DCHECK(pipeline_thread_checker_.CalledOnValidThread());
+
+  float playback_rate = 0;
   {
     base::AutoLock auto_lock(lock_);
     DCHECK_EQ(kPaused, state_);
     state_ = kPlaying;
     callback.Run();
+    playback_rate = algorithm_->playback_rate();
   }
 
-  if (stopped_)
-    return;
-
-  if (GetPlaybackRate() != 0.0f) {
+  if (playback_rate != 0.0f) {
     DoPlay();
   } else {
     DoPause();
@@ -52,11 +56,18 @@ void AudioRendererImpl::Play(const base::Closure& callback) {
 }
 
 void AudioRendererImpl::DoPlay() {
-  earliest_end_time_ = base::Time::Now();
+  DCHECK(pipeline_thread_checker_.CalledOnValidThread());
+  DCHECK(sink_);
+  {
+    base::AutoLock auto_lock(lock_);
+    earliest_end_time_ = base::Time::Now();
+  }
   sink_->Play();
 }
 
 void AudioRendererImpl::Pause(const base::Closure& callback) {
+  DCHECK(pipeline_thread_checker_.CalledOnValidThread());
+
   {
     base::AutoLock auto_lock(lock_);
     DCHECK(state_ == kPlaying || state_ == kUnderflow ||
@@ -69,30 +80,31 @@ void AudioRendererImpl::Pause(const base::Closure& callback) {
       base::ResetAndReturn(&pause_cb_).Run();
   }
 
-  if (stopped_)
-    return;
-
   DoPause();
 }
 
 void AudioRendererImpl::DoPause() {
+  DCHECK(pipeline_thread_checker_.CalledOnValidThread());
+  DCHECK(sink_);
   sink_->Pause(false);
 }
 
 void AudioRendererImpl::Flush(const base::Closure& callback) {
+  DCHECK(pipeline_thread_checker_.CalledOnValidThread());
   decoder_->Reset(callback);
 }
 
 void AudioRendererImpl::Stop(const base::Closure& callback) {
+  DCHECK(pipeline_thread_checker_.CalledOnValidThread());
   DCHECK(!callback.is_null());
 
+  if (sink_) {
+    sink_->Stop();
+    sink_ = NULL;
+  }
+
   {
     base::AutoLock auto_lock(lock_);
-    if (!stopped_) {
-      sink_->Stop();
-      stopped_ = true;
-    }
-
     state_ = kStopped;
     algorithm_.reset(NULL);
     init_cb_.Reset();
@@ -105,30 +117,32 @@ void AudioRendererImpl::Stop(const base::Closure& callback) {
 
 void AudioRendererImpl::Preroll(base::TimeDelta time,
                                 const PipelineStatusCB& cb) {
-  base::AutoLock auto_lock(lock_);
-  DCHECK_EQ(kPaused, state_);
-  DCHECK(!pending_read_) << "Pending read must complete before seeking";
-  DCHECK(pause_cb_.is_null());
-  DCHECK(preroll_cb_.is_null());
-  state_ = kPrerolling;
-  preroll_cb_ = cb;
-  preroll_timestamp_ = time;
-
-  // Throw away everything and schedule our reads.
-  audio_time_buffered_ = kNoTimestamp();
-  current_time_ = kNoTimestamp();
-  received_end_of_stream_ = false;
-  rendered_end_of_stream_ = false;
-  preroll_aborted_ = false;
-
-  // |algorithm_| will request more reads.
-  algorithm_->FlushBuffers();
-
-  if (stopped_)
-    return;
+  DCHECK(pipeline_thread_checker_.CalledOnValidThread());
+  DCHECK(sink_);
+
+  {
+    base::AutoLock auto_lock(lock_);
+    DCHECK_EQ(kPaused, state_);
+    DCHECK(!pending_read_) << "Pending read must complete before seeking";
+    DCHECK(pause_cb_.is_null());
+    DCHECK(preroll_cb_.is_null());
+    state_ = kPrerolling;
+    preroll_cb_ = cb;
+    preroll_timestamp_ = time;
+
+    // Throw away everything and schedule our reads.
+    audio_time_buffered_ = kNoTimestamp();
+    current_time_ = kNoTimestamp();
+    received_end_of_stream_ = false;
+    rendered_end_of_stream_ = false;
+    preroll_aborted_ = false;
+
+    // |algorithm_| will request more reads.
+    algorithm_->FlushBuffers();
+    earliest_end_time_ = base::Time::Now();
+  }
 
   // Pause and flush the stream when we preroll to a new location.
-  earliest_end_time_ = base::Time::Now();
   sink_->Pause(true);
 }
 
@@ -141,7 +155,7 @@ void AudioRendererImpl::Initialize(const scoped_refptr<DemuxerStream>& stream,
                                    const base::Closure& ended_cb,
                                    const base::Closure& disabled_cb,
                                    const PipelineStatusCB& error_cb) {
-  base::AutoLock auto_lock(lock_);
+  DCHECK(pipeline_thread_checker_.CalledOnValidThread());
   DCHECK(stream);
   DCHECK(!decoders.empty());
   DCHECK_EQ(stream->type(), DemuxerStream::AUDIO);
@@ -153,6 +167,7 @@ void AudioRendererImpl::Initialize(const scoped_refptr<DemuxerStream>& stream,
   DCHECK(!disabled_cb.is_null());
   DCHECK(!error_cb.is_null());
   DCHECK_EQ(kUninitialized, state_);
+  DCHECK(sink_);
 
   init_cb_ = init_cb;
   statistics_cb_ = statistics_cb;
@@ -169,7 +184,7 @@ void AudioRendererImpl::Initialize(const scoped_refptr<DemuxerStream>& stream,
 void AudioRendererImpl::InitializeNextDecoder(
     const scoped_refptr<DemuxerStream>& demuxer_stream,
     scoped_ptr<AudioDecoderList> decoders) {
-  lock_.AssertAcquired();
+  DCHECK(pipeline_thread_checker_.CalledOnValidThread());
   DCHECK(!decoders->empty());
 
   scoped_refptr<AudioDecoder> decoder = decoders->front();
@@ -177,13 +192,10 @@ void AudioRendererImpl::InitializeNextDecoder(
 
   DCHECK(decoder);
   decoder_ = decoder;
-
-  base::AutoUnlock auto_unlock(lock_);
   decoder->Initialize(
-      demuxer_stream,
-      base::Bind(&AudioRendererImpl::OnDecoderInitDone, this,
-                 demuxer_stream,
-                 base::Passed(&decoders)),
+      demuxer_stream, BindToLoop(base::MessageLoopProxy::current(), base::Bind(
+          &AudioRendererImpl::OnDecoderInitDone, this, demuxer_stream,
+          base::Passed(&decoders))),
       statistics_cb_);
 }
 
@@ -191,10 +203,10 @@ void AudioRendererImpl::OnDecoderInitDone(
     const scoped_refptr<DemuxerStream>& demuxer_stream,
     scoped_ptr<AudioDecoderList> decoders,
     PipelineStatus status) {
-  base::AutoLock auto_lock(lock_);
+  DCHECK(pipeline_thread_checker_.CalledOnValidThread());
 
   if (state_ == kStopped) {
-    DCHECK(stopped_);
+    DCHECK(!sink_);
     return;
   }
 
@@ -215,8 +227,6 @@ void AudioRendererImpl::OnDecoderInitDone(
   int channels = ChannelLayoutToChannelCount(channel_layout);
   int bits_per_channel = decoder_->bits_per_channel();
   int sample_rate = decoder_->samples_per_second();
-  // TODO(vrk): Add method to AudioDecoder to compute bytes per frame.
-  bytes_per_frame_ = channels * bits_per_channel / 8;
 
   algorithm_.reset(new AudioRendererAlgorithm());
   if (!algorithm_->ValidateConfig(channels, sample_rate, bits_per_channel)) {
@@ -267,14 +277,16 @@ void AudioRendererImpl::OnDecoderInitDone(
   audio_parameters_ = AudioParameters(
       format, channel_layout, sample_rate, bits_per_channel, buffer_size);
 
+  state_ = kPaused;
+
   sink_->Initialize(audio_parameters_, this);
   sink_->Start();
 
-  state_ = kPaused;
   base::ResetAndReturn(&init_cb_).Run(PIPELINE_OK);
 }
 
 void AudioRendererImpl::ResumeAfterUnderflow(bool buffer_more_audio) {
+  DCHECK(pipeline_thread_checker_.CalledOnValidThread());
   base::AutoLock auto_lock(lock_);
   if (state_ == kUnderflow) {
     // The "&& preroll_aborted_" is a hack. If preroll is aborted, then we
@@ -291,8 +303,8 @@ void AudioRendererImpl::ResumeAfterUnderflow(bool buffer_more_audio) {
 }
 
 void AudioRendererImpl::SetVolume(float volume) {
-  if (stopped_)
-    return;
+  DCHECK(pipeline_thread_checker_.CalledOnValidThread());
+  DCHECK(sink_);
   sink_->SetVolume(volume);
 }
 
@@ -376,29 +388,25 @@ void AudioRendererImpl::ScheduleRead_Locked() {
 }
 
 void AudioRendererImpl::SetPlaybackRate(float playback_rate) {
+  DCHECK(pipeline_thread_checker_.CalledOnValidThread());
   DCHECK_LE(0.0f, playback_rate);
+  DCHECK(sink_);
 
-  if (!stopped_) {
-    // We have two cases here:
-    // Play: GetPlaybackRate() == 0.0 && playback_rate != 0.0
-    // Pause: GetPlaybackRate() != 0.0 && playback_rate == 0.0
-    if (GetPlaybackRate() == 0.0f && playback_rate != 0.0f) {
-      DoPlay();
-    } else if (GetPlaybackRate() != 0.0f && playback_rate == 0.0f) {
-      // Pause is easy, we can always pause.
-      DoPause();
-    }
+  // We have two cases here:
+  // Play: current_playback_rate == 0.0 && playback_rate != 0.0
+  // Pause: current_playback_rate != 0.0 && playback_rate == 0.0
+  float current_playback_rate = algorithm_->playback_rate();
+  if (current_playback_rate == 0.0f && playback_rate != 0.0f) {
+    DoPlay();
+  } else if (current_playback_rate != 0.0f && playback_rate == 0.0f) {
+    // Pause is easy, we can always pause.
+    DoPause();
   }
 
   base::AutoLock auto_lock(lock_);
   algorithm_->SetPlaybackRate(playback_rate);
 }
 
-float AudioRendererImpl::GetPlaybackRate() {
-  base::AutoLock auto_lock(lock_);
-  return algorithm_->playback_rate();
-}
-
 bool AudioRendererImpl::IsBeforePrerollTime(
     const scoped_refptr<Buffer>& buffer) {
   return (state_ == kPrerolling) && buffer && !buffer->IsEndOfStream() &&
@@ -407,43 +415,27 @@ bool AudioRendererImpl::IsBeforePrerollTime(
 
 int AudioRendererImpl::Render(AudioBus* audio_bus,
                               int audio_delay_milliseconds) {
-  if (stopped_ || GetPlaybackRate() == 0.0f) {
-    // Output silence if stopped.
-    audio_bus->Zero();
-    return 0;
-  }
-
-  // Adjust the playback delay.
-  base::TimeDelta request_delay =
-      base::TimeDelta::FromMilliseconds(audio_delay_milliseconds);
-
-  // Finally we need to adjust the delay according to playback rate.
-  if (GetPlaybackRate() != 1.0f) {
-    request_delay = base::TimeDelta::FromMicroseconds(
-        static_cast<int64>(ceil(request_delay.InMicroseconds() *
-                                GetPlaybackRate())));
+  if (actual_frames_per_buffer_ != audio_bus->frames()) {
+    audio_buffer_.reset(
+        new uint8[audio_bus->frames() * audio_parameters_.GetBytesPerFrame()]);
+    actual_frames_per_buffer_ = audio_bus->frames();
   }
 
-  int bytes_per_frame = audio_parameters_.GetBytesPerFrame();
-
-  const int buf_size = audio_bus->frames() * bytes_per_frame;
-  scoped_array<uint8> buf(new uint8[buf_size]);
-
-  int frames_filled = FillBuffer(buf.get(), audio_bus->frames(), request_delay);
-  int bytes_filled = frames_filled * bytes_per_frame;
-  DCHECK_LE(bytes_filled, buf_size);
-  UpdateEarliestEndTime(bytes_filled, request_delay, base::Time::Now());
+  int frames_filled = FillBuffer(
+      audio_buffer_.get(), audio_bus->frames(), audio_delay_milliseconds);
+  DCHECK_LE(frames_filled, actual_frames_per_buffer_);
 
   // Deinterleave audio data into the output bus.
   audio_bus->FromInterleaved(
-      buf.get(), frames_filled, audio_parameters_.bits_per_sample() / 8);
+      audio_buffer_.get(), frames_filled,
+      audio_parameters_.bits_per_sample() / 8);
 
   return frames_filled;
 }
 
 uint32 AudioRendererImpl::FillBuffer(uint8* dest,
                                      uint32 requested_frames,
-                                     const base::TimeDelta& playback_delay) {
+                                     int audio_delay_milliseconds) {
   base::TimeDelta current_time = kNoTimestamp();
   base::TimeDelta max_time = kNoTimestamp();
 
@@ -452,6 +444,22 @@ uint32 AudioRendererImpl::FillBuffer(uint8* dest,
   {
     base::AutoLock auto_lock(lock_);
 
+    // Ensure Stop() hasn't destroyed our |algorithm_| on the pipeline thread.
+    if (!algorithm_)
+      return 0;
+
+    float playback_rate = algorithm_->playback_rate();
+    if (playback_rate == 0.0f)
+      return 0;
+
+    // Adjust the delay according to playback rate.
+    base::TimeDelta playback_delay =
+        base::TimeDelta::FromMilliseconds(audio_delay_milliseconds);
+    if (playback_rate != 1.0f) {
+      playback_delay = base::TimeDelta::FromMicroseconds(static_cast<int64>(
+          ceil(playback_delay.InMicroseconds() * playback_rate)));
+    }
+
     if (state_ == kRebuffering && algorithm_->IsQueueFull())
       state_ = kPlaying;
 
@@ -464,10 +472,10 @@ uint32 AudioRendererImpl::FillBuffer(uint8* dest,
       //
       // This should get handled by the subclass http://crbug.com/106600
       const uint32 kZeroLength = 8192;
-      size_t zeros_to_write =
-          std::min(kZeroLength, requested_frames * bytes_per_frame_);
+      size_t zeros_to_write = std::min(
+          kZeroLength, requested_frames * audio_parameters_.GetBytesPerFrame());
       memset(dest, 0, zeros_to_write);
-      return zeros_to_write / bytes_per_frame_;
+      return zeros_to_write / audio_parameters_.GetBytesPerFrame();
     }
 
     // We use the following conditions to determine end of playback:
@@ -533,6 +541,9 @@ uint32 AudioRendererImpl::FillBuffer(uint8* dest,
     // buffered audio data. Update the new amount of time buffered.
     max_time = algorithm_->GetTime();
     audio_time_buffered_ = max_time;
+
+    UpdateEarliestEndTime_Locked(
+        frames_written, playback_rate, playback_delay, base::Time::Now());
   }
 
   if (current_time != kNoTimestamp() && max_time != kNoTimestamp()) {
@@ -545,28 +556,25 @@ uint32 AudioRendererImpl::FillBuffer(uint8* dest,
   return frames_written;
 }
 
-void AudioRendererImpl::UpdateEarliestEndTime(int bytes_filled,
-                                              base::TimeDelta request_delay,
-                                              base::Time time_now) {
-  if (bytes_filled != 0) {
-    base::TimeDelta predicted_play_time = ConvertToDuration(bytes_filled);
-    float playback_rate = GetPlaybackRate();
-    if (playback_rate != 1.0f) {
-      predicted_play_time = base::TimeDelta::FromMicroseconds(
-          static_cast<int64>(ceil(predicted_play_time.InMicroseconds() *
-                                  playback_rate)));
-    }
-    earliest_end_time_ =
-        std::max(earliest_end_time_,
-                 time_now + request_delay + predicted_play_time);
+void AudioRendererImpl::UpdateEarliestEndTime_Locked(
+    int frames_filled, float playback_rate, base::TimeDelta playback_delay,
+    base::Time time_now) {
+  if (frames_filled <= 0)
+    return;
+
+  base::TimeDelta predicted_play_time = base::TimeDelta::FromMicroseconds(
+      static_cast<float>(frames_filled) * base::Time::kMicrosecondsPerSecond /
+      audio_parameters_.sample_rate());
+
+  if (playback_rate != 1.0f) {
+    predicted_play_time = base::TimeDelta::FromMicroseconds(
+        static_cast<int64>(ceil(predicted_play_time.InMicroseconds() *
+                                playback_rate)));
   }
-}
 
-base::TimeDelta AudioRendererImpl::ConvertToDuration(int bytes) {
-  int bytes_per_second = audio_parameters_.GetBytesPerSecond();
-  CHECK(bytes_per_second);
-  return base::TimeDelta::FromMicroseconds(
-      base::Time::kMicrosecondsPerSecond * bytes / bytes_per_second);
+  lock_.AssertAcquired();
+  earliest_end_time_ = std::max(
+      earliest_end_time_, time_now + playback_delay + predicted_play_time);
 }
 
 void AudioRendererImpl::OnRenderError() {