Suppress slider thumb jumping around during seeking...

media/base/pipeline_impl.cc

 // Copyright (c) 2008-2009 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.
 //
 // TODO(scherkus): clean up PipelineImpl... too many crazy function names,
 // potential deadlocks, etc...
 
 #include "base/compiler_specific.h"
 #include "base/condition_variable.h"
 #include "base/stl_util-inl.h"
@@ skipping 56 matching lines @@
   if (*count == 0) {
     cond_var->Signal();
   }
 }
 
 }  // namespace
 
 PipelineImpl::PipelineImpl(MessageLoop* message_loop)
     : message_loop_(message_loop),
       clock_(&base::Time::Now),
+      waiting_for_clock_update_(false),
       state_(kCreated),
       remaining_transitions_(0) {
   ResetState();
 }
 
 PipelineImpl::~PipelineImpl() {
   AutoLock auto_lock(lock_);
   DCHECK(!running_) << "Stop() must complete before destroying object";
 }
 
@@ skipping 198 matching lines @@
   duration_         = kZero;
   buffered_time_    = kZero;
   buffered_bytes_   = 0;
   streaming_        = false;
   total_bytes_      = 0;
   video_width_      = 0;
   video_height_     = 0;
   volume_           = 1.0f;
   playback_rate_    = 0.0f;
   error_            = PIPELINE_OK;
+  waiting_for_clock_update_ = false;
   clock_.SetTime(kZero);
   rendered_mime_types_.clear();
 }
 
 bool PipelineImpl::IsPipelineOk() {
   return PIPELINE_OK == GetError();
 }
 
 bool PipelineImpl::IsPipelineInitializing() {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
@@ skipping 34 matching lines @@
 }
 
 base::TimeDelta PipelineImpl::GetTime() const {
   DCHECK(IsRunning());
   return GetCurrentTime();
 }
 
 void PipelineImpl::SetTime(base::TimeDelta time) {
   DCHECK(IsRunning());
   AutoLock auto_lock(lock_);
+
+  // If we were waiting for a valid timestamp and such timestamp arrives, we
+  // need to clear the flag for waiting and start the clock.
+  if (waiting_for_clock_update_) {
+    if (time < clock_.Elapsed())
+      return;
+    waiting_for_clock_update_ = false;
+    clock_.SetTime(time);
+    clock_.Play();
+    return;
+  }
   clock_.SetTime(time);
 }
 
 void PipelineImpl::SetDuration(base::TimeDelta duration) {
   DCHECK(IsRunning());
   AutoLock auto_lock(lock_);
   duration_ = duration;
 }
 
 void PipelineImpl::SetBufferedTime(base::TimeDelta buffered_time) {
@@ skipping 241 matching lines @@
 
   // If our owner has requested to be notified of an error, execute
   // |error_callback_| unless we have a "good" error.
   if (error_callback_.get() && error != PIPELINE_STOPPING) {
     error_callback_->Run();
   }
 }
 
 void PipelineImpl::PlaybackRateChangedTask(float playback_rate) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
-  clock_.SetPlaybackRate(playback_rate);
+  {
+    AutoLock auto_lock(lock_);
+    clock_.SetPlaybackRate(playback_rate);
+  }
   for (FilterVector::iterator iter = filters_.begin();
        iter != filters_.end();
        ++iter) {
     (*iter)->SetPlaybackRate(playback_rate);
   }
 }
 
 void PipelineImpl::VolumeChangedTask(float volume) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
 
@@ skipping 24 matching lines @@
   //   kPausing (for each filter)
   //   kSeeking (for each filter)
   //   kStarting (for each filter)
   //   kStarted
   state_ = kPausing;
   seek_timestamp_ = time;
   seek_callback_.reset(seek_callback);
   remaining_transitions_ = filters_.size();
 
   // Kick off seeking!
-  clock_.Pause();
+  {
+    AutoLock auto_lock(lock_);
+    // If we are waiting for a clock update, the clock hasn't been played yet.
+    if (!waiting_for_clock_update_)
+      clock_.Pause();
+  }
   filters_.front()->Pause(
       NewCallback(this, &PipelineImpl::OnFilterStateTransition));
 }
 
 void PipelineImpl::NotifyEndedTask() {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
 
   // We can only end if we were actually playing.
   if (state_ != kStarted) {
     return;
@@ skipping 15 matching lines @@
   // Transition to ended, executing the callback if present.
   state_ = kEnded;
   if (ended_callback_.get()) {
     ended_callback_->Run();
   }
 }
 
 void PipelineImpl::BroadcastMessageTask(FilterMessage message) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
 
-  // TODO(kylep): This is a horribly ugly hack, but we have no better way to log
-  // that audio is not and will not be working.
-  if (message == media::kMsgDisableAudio)
+  // TODO(kylep): This is a horribly ugly hack, but we have no better way to
+  // log that audio is not and will not be working.
+  if (message == media::kMsgDisableAudio) {
+    // |rendered_mime_types_| is read through public methods so we need to lock
+    // this variable.
+    AutoLock auto_lock(lock_);
     rendered_mime_types_.erase(mime_type::kMajorTypeAudio);
+  }
 
   // Broadcast the message to all filters.
   for (FilterVector::iterator iter = filters_.begin();
        iter != filters_.end();
        ++iter) {
     (*iter)->OnReceivedMessage(message);
   }
 }
 
 void PipelineImpl::FilterStateTransitionTask() {
@@ skipping 10 matching lines @@
     return;
   }
 
   // Decrement the number of remaining transitions, making sure to transition
   // to the next state if needed.
   CHECK(remaining_transitions_ <= filters_.size());
   CHECK(remaining_transitions_ > 0u);
   if (--remaining_transitions_ == 0) {
     state_ = FindNextState(state_);
     if (state_ == kSeeking) {
+      AutoLock auto_lock(lock_);
       clock_.SetTime(seek_timestamp_);
-    } else if (state_ == kStarting) {
-      clock_.Play();
     }
 
     if (StateTransitionsToStarted(state_)) {
       remaining_transitions_ = filters_.size();
     }
   }
 
   // Carry out the action for the current state.
   if (StateTransitionsToStarted(state_)) {
     MediaFilter* filter = filters_[filters_.size() - remaining_transitions_];
@@ skipping 10 matching lines @@
   } else if (state_ == kStarted) {
     // Execute the seek callback, if present.  Note that this might be the
     // initial callback passed into Start().
     if (seek_callback_.get()) {
       seek_callback_->Run();
       seek_callback_.reset();
     }
 
     // Finally, reset our seeking timestamp back to zero.
     seek_timestamp_ = base::TimeDelta();
+
+    AutoLock auto_lock(lock_);
+    // We use audio stream to update the clock. So if there is such a stream,
+    // we pause the clock until we receive a valid timestamp.
+    waiting_for_clock_update_ =
+        rendered_mime_types_.find(mime_type::kMajorTypeAudio) !=
+        rendered_mime_types_.end();
+    if (!waiting_for_clock_update_)
+      clock_.Play();
   } else {
     NOTREACHED();
   }
 }
 
 template <class Filter, class Source>
 void PipelineImpl::CreateFilter(FilterFactory* filter_factory,
                                 Source source,
                                 const MediaFormat& media_format) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
@@ skipping 148 matching lines @@
 
   // Reset the pipeline, which will decrement a reference to this object.
   // We will get destroyed as soon as the remaining tasks finish executing.
   // To be safe, we'll set our pipeline reference to NULL.
   filters_.clear();
   filter_types_.clear();
   STLDeleteElements(&filter_threads_);
 }
 
 }  // namespace media