Have AudioRendererImpl advance time until it's told to stop.

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 f5f35a84a999f551106448818efd85a0ba925fbe..c2254d8e82065f76b01a16ecb6a17a3a48b629d4 100644
--- a/media/filters/audio_renderer_impl.cc
+++ b/media/filters/audio_renderer_impl.cc
@@ -148,6 +148,7 @@ void AudioRendererImpl::SetMediaTime(base::TimeDelta time) {
   DCHECK_EQ(state_, kFlushed);
 
   start_timestamp_ = time;
+  ended_timestamp_ = kInfiniteDuration();
   audio_clock_.reset(new AudioClock(time, audio_parameters_.sample_rate()));
 }
 
@@ -547,7 +548,6 @@ int AudioRendererImpl::Render(AudioBus* audio_bus,
   const int delay_frames = static_cast<int>(playback_delay.InSecondsF() *
                                             audio_parameters_.sample_rate());
   int frames_written = 0;
-  base::Closure time_cb;
   {
     base::AutoLock auto_lock(lock_);
 
@@ -587,31 +587,32 @@ int AudioRendererImpl::Render(AudioBus* audio_bus,
       frames_written =
           algorithm_->FillBuffer(audio_bus, requested_frames, playback_rate_);
     }
-    audio_clock_->WroteAudio(
-        frames_written, requested_frames, delay_frames, playback_rate_);
 
+    int frames_after_end_of_stream = 0;
     if (frames_written == 0) {
-      if (received_end_of_stream_ && !rendered_end_of_stream_ &&
-          !audio_clock_->audio_data_buffered()) {
-        rendered_end_of_stream_ = true;
-        task_runner_->PostTask(FROM_HERE, ended_cb_);
-      } else if (!received_end_of_stream_ && state_ == kPlaying) {
-        if (buffering_state_ != BUFFERING_HAVE_NOTHING) {
-          algorithm_->IncreaseQueueCapacity();
-          SetBufferingState_Locked(BUFFERING_HAVE_NOTHING);
-        }
+      if (received_end_of_stream_) {
+        if (ended_timestamp_ == kInfiniteDuration())
+          ended_timestamp_ = audio_clock_->latest_media_timestamp();
+        frames_after_end_of_stream = requested_frames;
+      } else if (state_ == kPlaying &&
+                 buffering_state_ != BUFFERING_HAVE_NOTHING) {
+        algorithm_->IncreaseQueueCapacity();
+        SetBufferingState_Locked(BUFFERING_HAVE_NOTHING);

[DaleCurtis, 2014/08/29 20:17:23]

Shouldn't you be accounting for the frames written last cycle here too?

[scherkus (not reviewing), 2014/08/29 20:32:02]

Not sure I follow.

What case are you thinking of?

[DaleCurtis, 2014/08/29 20:59:17]

Audio still advances from the last write cycle despite underflow.  Do you want
to adjust time to compensate?  I don't think I follow why you're treating the
two cases differently. 

[scherkus (not reviewing), 2014/08/29 21:29:00]

The moment we enter underflow we don't want to advance time because we know we
have more decoded audio frames that will eventually arrive when we exit
underflow. If we advanced time at this point we would throw things off.

When we know we *won't* have more decoded frames arriving (end of stream), we
keep inserting silence to keep time advancing.

I hope I understood your question! Let me know if you want to chat offline.

[DaleCurtis, 2014/08/29 22:04:42]

Okay, this makes sense, but could do with a comment explaining why :)

       }
     }
 
+    audio_clock_->WroteAudio(frames_written + frames_after_end_of_stream,
+                             requested_frames,
+                             delay_frames,
+                             playback_rate_);
+
     if (CanRead_Locked()) {
       task_runner_->PostTask(FROM_HERE,
                              base::Bind(&AudioRendererImpl::AttemptRead,
                                         weak_factory_.GetWeakPtr()));
     }
 
-    // Firing |ended_cb_| means we no longer need to run |time_cb_|.
-    if (!rendered_end_of_stream_ &&
-        last_timestamp_update_ != audio_clock_->current_media_timestamp()) {
+    if (last_timestamp_update_ != audio_clock_->current_media_timestamp()) {
       // Since |max_time| uses linear interpolation, only provide an upper bound
       // that is for audio data at the same playback rate. Failing to do so can
       // make time jump backwards when the linear interpolated time advances
@@ -620,13 +621,17 @@ int AudioRendererImpl::Render(AudioBus* audio_bus,
       base::TimeDelta max_time =
           last_timestamp_update_ +
           audio_clock_->contiguous_audio_data_buffered_at_same_rate();
-      time_cb = base::Bind(time_cb_, last_timestamp_update_, max_time);
+      task_runner_->PostTask(
+          FROM_HERE, base::Bind(time_cb_, last_timestamp_update_, max_time));
+
+      if (last_timestamp_update_ >= ended_timestamp_ &&
+          !rendered_end_of_stream_) {
+        rendered_end_of_stream_ = true;
+        task_runner_->PostTask(FROM_HERE, ended_cb_);
+      }
     }
   }
 
-  if (!time_cb.is_null())
-    task_runner_->PostTask(FROM_HERE, time_cb);
-
   DCHECK_LE(frames_written, requested_frames);
   return frames_written;
 }