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

media/filters/audio_clock.cc

 // Copyright 2014 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/filters/audio_clock.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "media/base/buffers.h"
 
 namespace media {
 
 AudioClock::AudioClock(base::TimeDelta start_timestamp, int sample_rate)
     : start_timestamp_(start_timestamp),
       sample_rate_(sample_rate),
       microseconds_per_frame_(
           static_cast<double>(base::Time::kMicrosecondsPerSecond) /
           sample_rate),
       total_buffered_frames_(0),
       current_media_timestamp_(start_timestamp),
-      audio_data_buffered_(0) {
+      latest_media_timestamp_(start_timestamp) {
 }
 
 AudioClock::~AudioClock() {
 }
 
 void AudioClock::WroteAudio(int frames_written,
                             int frames_requested,
                             int delay_frames,
                             float playback_rate) {
   DCHECK_GE(frames_written, 0);
@@ skipping 10 matching lines @@
   //
   // The ordering of compute -> push -> pop eliminates unnecessary memory
   // reallocations in cases where |buffered_| gets emptied.
   int64_t frames_played =
       std::max(INT64_C(0), total_buffered_frames_ - delay_frames);
   current_media_timestamp_ += ComputeBufferedMediaTime(frames_played);
   PushBufferedAudioData(frames_written, playback_rate);
   PushBufferedAudioData(frames_requested - frames_written, 0.0f);
   PopBufferedAudioData(frames_played);
 
+  latest_media_timestamp_ += base::TimeDelta::FromMicroseconds(
+      frames_written * playback_rate * microseconds_per_frame_);
+
   // Update cached values.
   double scaled_frames = 0;
   double scaled_frames_at_same_rate = 0;
   bool found_silence = false;
-  audio_data_buffered_ = false;
   for (size_t i = 0; i < buffered_.size(); ++i) {
     if (buffered_[i].playback_rate == 0) {
       found_silence = true;
       continue;
     }
 
-    audio_data_buffered_ = true;
-
     // Any buffered silence breaks our contiguous stretch of audio data.
     if (found_silence)
       break;
 
     scaled_frames += (buffered_[i].frames * buffered_[i].playback_rate);
 
     if (i == 0)
       scaled_frames_at_same_rate = scaled_frames;
   }
 
@@ skipping 55 matching lines @@
     int64_t min_frames = std::min(buffered_[i].frames, frames);
     scaled_frames += min_frames * buffered_[i].playback_rate;
     frames -= min_frames;
   }
 
   return base::TimeDelta::FromMicroseconds(scaled_frames *
                                            microseconds_per_frame_);
 }
 
 }  // namespace media