Fix media timeline so that thumb never exceeds buffered data

media/filters/audio_renderer_base.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/filters/audio_renderer_base.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 39 matching lines @@
     state_ = kPaused;
   }
 }
 
 void AudioRendererBase::Stop(const base::Closure& callback) {
   OnStop();
   {
     base::AutoLock auto_lock(lock_);
     state_ = kStopped;
     algorithm_.reset(NULL);
+    audio_time_cb_.Reset();
+    underflow_callback_.Reset();
   }
   if (!callback.is_null()) {
     callback.Run();
   }
 }
 
 void AudioRendererBase::Seek(base::TimeDelta time, const FilterStatusCB& cb) {
   base::AutoLock auto_lock(lock_);
   DCHECK_EQ(kPaused, state_);
   DCHECK(!pending_read_) << "Pending read must complete before seeking";
   DCHECK(seek_cb_.is_null());
   state_ = kSeeking;
   seek_cb_ = cb;
   seek_timestamp_ = time;
 
   // Throw away everything and schedule our reads.
   last_fill_buffer_time_ = base::TimeDelta();
   recieved_end_of_stream_ = false;
   rendered_end_of_stream_ = false;
 
   // |algorithm_| will request more reads.
   algorithm_->FlushBuffers();
 }
 
 void AudioRendererBase::Initialize(AudioDecoder* decoder,
                                    const base::Closure& init_callback,
-                                   const base::Closure& underflow_callback) {
+                                   const base::Closure& underflow_callback,
+                                   const AudioTimeCB& audio_time_cb) {
   DCHECK(decoder);
   DCHECK(!init_callback.is_null());
   DCHECK(!underflow_callback.is_null());
+  DCHECK(!audio_time_cb.is_null());
   DCHECK_EQ(kUninitialized, state_);
   decoder_ = decoder;
   underflow_callback_ = underflow_callback;
+  audio_time_cb_ = audio_time_cb;
 
   // Create a callback so our algorithm can request more reads.
   base::Closure cb = base::Bind(&AudioRendererBase::ScheduleRead_Locked, this);
 
   // Construct the algorithm.
   algorithm_.reset(new AudioRendererAlgorithmBase());
 
   // Initialize our algorithm with media properties, initial playback rate,
   // and a callback to request more reads from the data source.
   ChannelLayout channel_layout = decoder_->channel_layout();
@@ skipping 140 matching lines @@
     } else {
       // Otherwise fill the buffer.
       dest_written = algorithm_->FillBuffer(dest, dest_len);
     }
 
     // Get the current time.
     last_fill_buffer_time_ = algorithm_->GetTime();
   }
 
   // Update the pipeline's time if it was set last time.
+  base::TimeDelta new_current_time = last_fill_buffer_time - playback_delay;
   if (last_fill_buffer_time.InMicroseconds() > 0 &&
       (last_fill_buffer_time != last_fill_buffer_time_ ||
-       (last_fill_buffer_time - playback_delay) > host()->GetTime())) {
-    // Adjust the |last_fill_buffer_time| with the playback delay.
-    // TODO(hclam): If there is a playback delay, the pipeline would not be
-    // updated with a correct timestamp when the stream is played at the very
-    // end since we use decoded packets to trigger time updates. A better
-    // solution is to start a timer when an audio packet is decoded to allow
-    // finer time update events.
-    last_fill_buffer_time -= playback_delay;
-    host()->SetTime(last_fill_buffer_time);
+       new_current_time > host()->GetTime())) {
+    audio_time_cb_.Run(new_current_time, last_fill_buffer_time);
   }
 
   if (!underflow_cb.is_null())
     underflow_cb.Run();
 
   return dest_written;
 }
 
 void AudioRendererBase::ScheduleRead_Locked() {
   lock_.AssertAcquired();
   if (pending_read_)
     return;
   pending_read_ = true;
   decoder_->Read(read_cb_);
 }
 
 void AudioRendererBase::SetPlaybackRate(float playback_rate) {
   base::AutoLock auto_lock(lock_);
   algorithm_->SetPlaybackRate(playback_rate);
 }
 
 float AudioRendererBase::GetPlaybackRate() {
   base::AutoLock auto_lock(lock_);
   return algorithm_->playback_rate();
 }
 
 }  // namespace media