Fix media timeline so that thumb never exceeds buffered data

media/filters/video_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 "base/bind.h"
 #include "base/callback.h"
 #include "base/threading/platform_thread.h"
 #include "media/base/buffers.h"
 #include "media/base/filter_host.h"
 #include "media/base/limits.h"
@@ skipping 45 matching lines @@
 
   AttemptFlush_Locked();
 }
 
 void VideoRendererBase::Stop(const base::Closure& callback) {
   base::PlatformThreadHandle thread_to_join = base::kNullThreadHandle;
   {
     base::AutoLock auto_lock(lock_);
     state_ = kStopped;
 
+    statistics_callback_.Reset();
+    video_time_cb_.Reset();
     if (!pending_paint_ && !pending_paint_with_last_available_)
       DoStopOrError_Locked();
 
     // Clean up our thread if present.
     if (thread_ != base::kNullThreadHandle) {
       // Signal the thread since it's possible to get stopped with the video
       // thread waiting for a read to complete.
       frame_available_.Signal();
       thread_to_join = thread_;
       thread_ = base::kNullThreadHandle;
@@ skipping 16 matching lines @@
   DCHECK(!cb.is_null());
   DCHECK(seek_cb_.is_null());
 
   state_ = kSeeking;
   seek_cb_ = cb;
   seek_timestamp_ = time;
   AttemptRead_Locked();
 }
 
 void VideoRendererBase::Initialize(VideoDecoder* decoder,
-                                   const base::Closure& callback,
-                                   const StatisticsCallback& stats_callback) {
+                                   const base::Closure& init_cb,
+                                   const StatisticsCallback& stats_callback,
+                                   const VideoTimeCB& video_time_cb) {
   base::AutoLock auto_lock(lock_);
   DCHECK(decoder);
-  DCHECK(!callback.is_null());
+  DCHECK(!init_cb.is_null());
   DCHECK(!stats_callback.is_null());
+  DCHECK(!video_time_cb.is_null());
   DCHECK_EQ(kUninitialized, state_);
   decoder_ = decoder;
 
   statistics_callback_ = stats_callback;
+  video_time_cb_ = video_time_cb;
 
   // Notify the pipeline of the video dimensions.
   host()->SetNaturalVideoSize(decoder_->natural_size());
 
   // We're all good!  Consider ourselves flushed. (ThreadMain() should never
   // see us in the kUninitialized state).
   // Since we had an initial Seek, we consider ourself flushed, because we
   // have not populated any buffers yet.
   state_ = kFlushed;
 
   set_opaque_cb_.Run(!decoder->HasAlpha());
   set_opaque_cb_.Reset();
 
   // Create our video thread.
   if (!base::PlatformThread::Create(0, this, &thread_)) {
     NOTREACHED() << "Video thread creation failed";
     state_ = kError;
     host()->SetError(PIPELINE_ERROR_INITIALIZATION_FAILED);
-    callback.Run();
+    init_cb.Run();
     return;
   }
 
 #if defined(OS_WIN)
   // Bump up our priority so our sleeping is more accurate.
   // TODO(scherkus): find out if this is necessary, but it seems to help.
   ::SetThreadPriority(thread_, THREAD_PRIORITY_ABOVE_NORMAL);
 #endif  // defined(OS_WIN)
-  callback.Run();
+  init_cb.Run();
 }
 
 bool VideoRendererBase::HasEnded() {
   base::AutoLock auto_lock(lock_);
   return state_ == kEnded;
 }
 
 // PlatformThread::Delegate implementation.
 void VideoRendererBase::ThreadMain() {
   base::PlatformThread::SetName("CrVideoRenderer");
@@ skipping 212 matching lines @@
   // frame rate.
   if (!frame->IsEndOfStream() &&
       (frame->GetTimestamp() + frame->GetDuration()) > host()->GetDuration()) {
     frame->SetDuration(host()->GetDuration() - frame->GetTimestamp());
   }
 
   // This one's a keeper! Place it in the ready queue.
   ready_frames_.push_back(frame);
   DCHECK_LE(ready_frames_.size(),
             static_cast<size_t>(limits::kMaxVideoFrames));
+  video_time_cb_.Run(frame->GetTimestamp() + frame->GetDuration());
   frame_available_.Signal();
 
   PipelineStatistics statistics;
   statistics.video_frames_decoded = 1;
   statistics_callback_.Run(statistics);
 
   int outstanding_frames =
       (current_frame_ ? 1 : 0) + (last_available_frame_ ? 1 : 0) +
       (current_frame_ && (current_frame_ == last_available_frame_) ? -1 : 0);
   // Always request more decoded video if we have capacity. This serves two
@@ skipping 77 matching lines @@
 
 void VideoRendererBase::DoStopOrError_Locked() {
   DCHECK(!pending_paint_);
   DCHECK(!pending_paint_with_last_available_);
   lock_.AssertAcquired();
   current_frame_ = NULL;
   last_available_frame_ = NULL;
 }
 
 }  // namespace media