Rename media::Clock to media::TimeDeltaInterpolator and update API.

media/base/pipeline.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/base/pipeline.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/metrics/histogram.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/synchronization/condition_variable.h"
 #include "media/base/audio_decoder.h"
 #include "media/base/audio_renderer.h"
-#include "media/base/clock.h"
 #include "media/base/filter_collection.h"
 #include "media/base/media_log.h"
 #include "media/base/text_renderer.h"
 #include "media/base/text_track_config.h"
+#include "media/base/time_delta_interpolator.h"
 #include "media/base/video_decoder.h"
 #include "media/base/video_decoder_config.h"
 #include "media/base/video_renderer.h"
 
 using base::TimeDelta;
 
 namespace media {
 
 Pipeline::Pipeline(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     MediaLog* media_log)
     : task_runner_(task_runner),
       media_log_(media_log),
       running_(false),
       did_loading_progress_(false),
       volume_(1.0f),
       playback_rate_(0.0f),
-      clock_(new Clock(&default_tick_clock_)),
-      clock_state_(CLOCK_PAUSED),
+      interpolator_(new TimeDeltaInterpolator(&default_tick_clock_)),
+      interpolation_state_(INTERPOLATION_STOPPED),
       status_(PIPELINE_OK),
       state_(kCreated),
       audio_ended_(false),
       video_ended_(false),
       text_ended_(false),
       audio_buffering_state_(BUFFERING_HAVE_NOTHING),
       video_buffering_state_(BUFFERING_HAVE_NOTHING),
       demuxer_(NULL),
       underflow_disabled_for_testing_(false) {
   media_log_->AddEvent(media_log_->CreatePipelineStateChangedEvent(kCreated));
   media_log_->AddEvent(
       media_log_->CreateEvent(MediaLogEvent::PIPELINE_CREATED));
-  clock_->SetTime(base::TimeDelta(), base::TimeDelta());
+  interpolator_->SetBounds(base::TimeDelta(), base::TimeDelta());
 }
 
 Pipeline::~Pipeline() {
   DCHECK(thread_checker_.CalledOnValidThread())
       << "Pipeline must be destroyed on same thread that created it";
   DCHECK(!running_) << "Stop() must complete before destroying object";
   DCHECK(stop_cb_.is_null());
   DCHECK(seek_cb_.is_null());
 
   media_log_->AddEvent(
@@ skipping 81 matching lines @@
   base::AutoLock auto_lock(lock_);
   volume_ = volume;
   if (running_) {
     task_runner_->PostTask(FROM_HERE, base::Bind(
         &Pipeline::VolumeChangedTask, base::Unretained(this), volume));
   }
 }
 
 TimeDelta Pipeline::GetMediaTime() const {
   base::AutoLock auto_lock(lock_);
-  return std::min(clock_->Elapsed(), duration_);
+  return std::min(interpolator_->GetInterpolatedTime(), duration_);
 }
 
 Ranges<TimeDelta> Pipeline::GetBufferedTimeRanges() const {
   base::AutoLock auto_lock(lock_);
   return buffered_time_ranges_;
 }
 
 TimeDelta Pipeline::GetMediaDuration() const {
   base::AutoLock auto_lock(lock_);
   return duration_;
 }
 
 bool Pipeline::DidLoadingProgress() {
   base::AutoLock auto_lock(lock_);
   bool ret = did_loading_progress_;
   did_loading_progress_ = false;
   return ret;
 }
 
 PipelineStatistics Pipeline::GetStatistics() const {
   base::AutoLock auto_lock(lock_);
   return statistics_;
 }
 
-void Pipeline::SetClockForTesting(Clock* clock) {
-  clock_.reset(clock);
+void Pipeline::SetTimeDeltaInterpolatorForTesting(
+    TimeDeltaInterpolator* interpolator) {
+  interpolator_.reset(interpolator);
 }
 
 void Pipeline::SetErrorForTesting(PipelineStatus status) {
   SetError(status);
 }
 
 void Pipeline::SetState(State next_state) {
   DVLOG(1) << GetStateString(state_) << " -> " << GetStateString(next_state);
 
   state_ = next_state;
@@ skipping 83 matching lines @@
       &Pipeline::ErrorChangedTask, base::Unretained(this), error));
 
   media_log_->AddEvent(media_log_->CreatePipelineErrorEvent(error));
 }
 
 void Pipeline::OnAudioTimeUpdate(TimeDelta time, TimeDelta max_time) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_LE(time.InMicroseconds(), max_time.InMicroseconds());
   base::AutoLock auto_lock(lock_);
 
-  if (clock_state_ == CLOCK_WAITING_FOR_AUDIO_TIME_UPDATE &&
-      time < clock_->Elapsed()) {
+  if (interpolation_state_ == INTERPOLATION_WAITING_FOR_AUDIO_TIME_UPDATE &&
+      time < interpolator_->GetInterpolatedTime()) {
     return;
   }
 
   if (state_ == kSeeking)
     return;
 
-  clock_->SetTime(time, max_time);
+  interpolator_->SetBounds(time, max_time);
   StartClockIfWaitingForTimeUpdate_Locked();
 }
 
 void Pipeline::OnVideoTimeUpdate(TimeDelta max_time) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   if (audio_renderer_)
     return;
 
   if (state_ == kSeeking)
     return;
 
   base::AutoLock auto_lock(lock_);
-  DCHECK_NE(clock_state_, CLOCK_WAITING_FOR_AUDIO_TIME_UPDATE);
-  clock_->SetMaxTime(max_time);
+  DCHECK_NE(interpolation_state_, INTERPOLATION_WAITING_FOR_AUDIO_TIME_UPDATE);
+  interpolator_->SetUpperBound(max_time);
 }
 
 void Pipeline::SetDuration(TimeDelta duration) {
   DCHECK(IsRunning());
   media_log_->AddEvent(
       media_log_->CreateTimeEvent(
           MediaLogEvent::DURATION_SET, "duration", duration));
   UMA_HISTOGRAM_LONG_TIMES("Media.Duration", duration);
 
   base::AutoLock auto_lock(lock_);
@@ skipping 66 matching lines @@
                 stream->video_decoder_config().natural_size();
           }
           metadata_cb_.Run(metadata);
         }
       }
 
       base::ResetAndReturn(&seek_cb_).Run(PIPELINE_OK);
 
       {
         base::AutoLock auto_lock(lock_);
-        clock_->SetTime(start_timestamp_, start_timestamp_);
+        interpolator_->SetBounds(start_timestamp_, start_timestamp_);
       }
 
       if (audio_renderer_)
         audio_renderer_->StartPlayingFrom(start_timestamp_);
       if (video_renderer_)
         video_renderer_->StartPlayingFrom(start_timestamp_);
       if (text_renderer_)
         text_renderer_->StartPlaying();
 
       PlaybackRateChangedTask(GetPlaybackRate());
@@ skipping 224 matching lines @@
 
 void Pipeline::PlaybackRateChangedTask(float playback_rate) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   // Playback rate changes are only carried out while playing.
   if (state_ != kPlaying)
     return;
 
   {
     base::AutoLock auto_lock(lock_);
-    clock_->SetPlaybackRate(playback_rate);
+    interpolator_->SetPlaybackRate(playback_rate);
   }
 
   if (audio_renderer_)
     audio_renderer_->SetPlaybackRate(playback_rate_);
   if (video_renderer_)
     video_renderer_->SetPlaybackRate(playback_rate_);
 }
 
 void Pipeline::VolumeChangedTask(float volume) {
   DCHECK(task_runner_->BelongsToCurrentThread());
@@ skipping 40 matching lines @@
 
   if (state_ != kPlaying)
     return;
 
   DCHECK(!audio_ended_);
   audio_ended_ = true;
 
   // Start clock since there is no more audio to trigger clock updates.
   {
     base::AutoLock auto_lock(lock_);
-    clock_->SetMaxTime(duration_);
+    interpolator_->SetUpperBound(duration_);
     StartClockIfWaitingForTimeUpdate_Locked();
   }
 
   RunEndedCallbackIfNeeded();
 }
 
 void Pipeline::DoVideoRendererEnded() {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   if (state_ != kPlaying)
@@ skipping 25 matching lines @@
 
   if (video_renderer_ && !video_ended_)
     return;
 
   if (text_renderer_ && text_renderer_->HasTracks() && !text_ended_)
     return;
 
   {
     base::AutoLock auto_lock(lock_);
     PauseClockAndStopRendering_Locked();
-    clock_->SetTime(duration_, duration_);
+    interpolator_->SetBounds(duration_, duration_);
   }
 
   DCHECK_EQ(status_, PIPELINE_OK);
   ended_cb_.Run();
 }
 
 void Pipeline::AddTextStreamTask(DemuxerStream* text_stream,
                                  const TextTrackConfig& config) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   // TODO(matthewjheaney): fix up text_ended_ when text stream
@@ skipping 52 matching lines @@
            << " " << new_buffering_state << ") "
            << (buffering_state == &audio_buffering_state_ ? "audio" : "video");
   DCHECK(task_runner_->BelongsToCurrentThread());
   bool was_waiting_for_enough_data = WaitingForEnoughData();
 
   *buffering_state = new_buffering_state;
 
   // Disable underflow by ignoring updates that renderers have ran out of data
   // after we have started the clock.
   if (state_ == kPlaying && underflow_disabled_for_testing_ &&
-      clock_state_ != CLOCK_PAUSED) {
+      interpolation_state_ != INTERPOLATION_STOPPED) {
     return;
   }
 
   // Renderer underflowed.
   if (!was_waiting_for_enough_data && WaitingForEnoughData()) {
     PausePlayback();
 
     // TODO(scherkus): Fire BUFFERING_HAVE_NOTHING callback to alert clients of
     // underflow state http://crbug.com/144683
     return;
@@ skipping 24 matching lines @@
   DCHECK(WaitingForEnoughData());
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   base::AutoLock auto_lock(lock_);
   PauseClockAndStopRendering_Locked();
 }
 
 void Pipeline::StartPlayback() {
   DVLOG(1) << __FUNCTION__;
   DCHECK_EQ(state_, kPlaying);
-  DCHECK_EQ(clock_state_, CLOCK_PAUSED);
+  DCHECK_EQ(interpolation_state_, INTERPOLATION_STOPPED);
   DCHECK(!WaitingForEnoughData());
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   if (audio_renderer_) {
     // 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.
     base::AutoLock auto_lock(lock_);
-    clock_state_ = CLOCK_WAITING_FOR_AUDIO_TIME_UPDATE;
+    interpolation_state_ = INTERPOLATION_WAITING_FOR_AUDIO_TIME_UPDATE;
     audio_renderer_->StartRendering();
   } else {
     base::AutoLock auto_lock(lock_);
-    clock_state_ = CLOCK_PLAYING;
-    clock_->SetMaxTime(duration_);
-    clock_->Play();
+    interpolation_state_ = INTERPOLATION_STARTED;
+    interpolator_->SetUpperBound(duration_);
+    interpolator_->StartInterpolating();
   }
 }
 
 void Pipeline::PauseClockAndStopRendering_Locked() {
   lock_.AssertAcquired();
-  switch (clock_state_) {
-    case CLOCK_PAUSED:
+  switch (interpolation_state_) {
+    case INTERPOLATION_STOPPED:
       return;
 
-    case CLOCK_WAITING_FOR_AUDIO_TIME_UPDATE:
+    case INTERPOLATION_WAITING_FOR_AUDIO_TIME_UPDATE:
       audio_renderer_->StopRendering();
       break;
 
-    case CLOCK_PLAYING:
+    case INTERPOLATION_STARTED:
       if (audio_renderer_)
         audio_renderer_->StopRendering();
-      clock_->Pause();
+      interpolator_->StopInterpolating();
       break;
   }
 
-  clock_state_ = CLOCK_PAUSED;
+  interpolation_state_ = INTERPOLATION_STOPPED;
 }
 
 void Pipeline::StartClockIfWaitingForTimeUpdate_Locked() {
   lock_.AssertAcquired();
-  if (clock_state_ != CLOCK_WAITING_FOR_AUDIO_TIME_UPDATE)
+  if (interpolation_state_ != INTERPOLATION_WAITING_FOR_AUDIO_TIME_UPDATE)
     return;
 
-  clock_state_ = CLOCK_PLAYING;
-  clock_->Play();
+  interpolation_state_ = INTERPOLATION_STARTED;
+  interpolator_->StartInterpolating();
 }
 
 }  // namespace media