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

media/base/android/media_source_player.cc

 // Copyright (c) 2013 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/android/media_source_player.h"
 
 #include <limits>
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
@@ skipping 20 matching lines @@
     scoped_ptr<DemuxerAndroid> demuxer,
     const GURL& frame_url)
     : MediaPlayerAndroid(player_id,
                          manager,
                          request_media_resources_cb,
                          release_media_resources_cb,
                          frame_url),
       demuxer_(demuxer.Pass()),
       pending_event_(NO_EVENT_PENDING),
       playing_(false),
-      clock_(&default_tick_clock_),
+      interpolator_(&default_tick_clock_),
       doing_browser_seek_(false),
       pending_seek_(false),
       drm_bridge_(NULL),
       cdm_registration_id_(0),
       is_waiting_for_key_(false),
       is_waiting_for_audio_decoder_(false),
       is_waiting_for_video_decoder_(false),
       weak_factory_(this) {
   audio_decoder_job_.reset(new AudioDecoderJob(
       base::Bind(&DemuxerAndroid::RequestDemuxerData,
                  base::Unretained(demuxer_.get()),
                  DemuxerStream::AUDIO),
       base::Bind(&MediaSourcePlayer::OnDemuxerConfigsChanged,
                  weak_factory_.GetWeakPtr())));
   video_decoder_job_.reset(new VideoDecoderJob(
       base::Bind(&DemuxerAndroid::RequestDemuxerData,
                  base::Unretained(demuxer_.get()),
                  DemuxerStream::VIDEO),
       base::Bind(request_media_resources_cb_, player_id),
       base::Bind(release_media_resources_cb_, player_id),
       base::Bind(&MediaSourcePlayer::OnDemuxerConfigsChanged,
                  weak_factory_.GetWeakPtr())));
   demuxer_->Initialize(this);
-  clock_.SetMaxTime(base::TimeDelta());
+  interpolator_.SetUpperBound(base::TimeDelta());
   weak_this_ = weak_factory_.GetWeakPtr();
 }
 
 MediaSourcePlayer::~MediaSourcePlayer() {
   Release();
   DCHECK_EQ(!drm_bridge_, !cdm_registration_id_);
   if (drm_bridge_) {
     drm_bridge_->UnregisterPlayer(cdm_registration_id_);
     cdm_registration_id_ = 0;
   }
 }
 
 void MediaSourcePlayer::SetVideoSurface(gfx::ScopedJavaSurface surface) {
   DVLOG(1) << __FUNCTION__;
   if (!video_decoder_job_->SetVideoSurface(surface.Pass()))
     return;
   // Retry video decoder creation.
   RetryDecoderCreation(false, true);
 }
 
 void MediaSourcePlayer::ScheduleSeekEventAndStopDecoding(
     base::TimeDelta seek_time) {
   DVLOG(1) << __FUNCTION__ << "(" << seek_time.InSecondsF() << ")";
   DCHECK(!IsEventPending(SEEK_EVENT_PENDING));
 
   pending_seek_ = false;
 
-  clock_.SetTime(seek_time, seek_time);
+  interpolator_.SetBounds(seek_time, seek_time);
 
   if (audio_decoder_job_->is_decoding())
     audio_decoder_job_->StopDecode();
   if (video_decoder_job_->is_decoding())
     video_decoder_job_->StopDecode();
 
   SetPendingEvent(SEEK_EVENT_PENDING);
   ProcessPendingEvents();
 }
 
@@ skipping 62 matching lines @@
     pending_seek_ = true;
     pending_seek_time_ = timestamp;
     return;
   }
 
   doing_browser_seek_ = false;
   ScheduleSeekEventAndStopDecoding(timestamp);
 }
 
 base::TimeDelta MediaSourcePlayer::GetCurrentTime() {
-  return std::min(clock_.Elapsed(), duration_);
+  return std::min(interpolator_.GetInterpolatedTime(), duration_);
 }
 
 base::TimeDelta MediaSourcePlayer::GetDuration() {
   return duration_;
 }
 
 void MediaSourcePlayer::Release() {
   DVLOG(1) << __FUNCTION__;
 
   is_surface_in_use_ = false;
@@ skipping 134 matching lines @@
   // I-frame later than the requested one due to data removal or GC. Update
   // player clock to the actual seek target.
   if (doing_browser_seek_) {
     DCHECK(actual_browser_seek_time != kNoTimestamp());
     base::TimeDelta seek_time = actual_browser_seek_time;
     // A browser seek must not jump into the past. Ideally, it seeks to the
     // requested time, but it might jump into the future.
     DCHECK(seek_time >= GetCurrentTime());
     DVLOG(1) << __FUNCTION__ << " : setting clock to actual browser seek time: "
              << seek_time.InSecondsF();
-    clock_.SetTime(seek_time, seek_time);
+    interpolator_.SetBounds(seek_time, seek_time);
     audio_decoder_job_->SetBaseTimestamp(seek_time);
   } else {
     DCHECK(actual_browser_seek_time == kNoTimestamp());
   }
 
   base::TimeDelta current_time = GetCurrentTime();
   // TODO(qinmin): Simplify the logic by using |start_presentation_timestamp_|
   // to preroll media decoder jobs. Currently |start_presentation_timestamp_|
   // is calculated from decoder output, while preroll relies on the access
   // unit's timestamp. There are some differences between the two.
   preroll_timestamp_ = current_time;
   if (HasAudio())
     audio_decoder_job_->BeginPrerolling(preroll_timestamp_);
   if (HasVideo())
     video_decoder_job_->BeginPrerolling(preroll_timestamp_);
 
   if (!doing_browser_seek_)
     manager()->OnSeekComplete(player_id(), current_time);
 
   ProcessPendingEvents();
 }
 
 void MediaSourcePlayer::UpdateTimestamps(
     base::TimeDelta current_presentation_timestamp,
     base::TimeDelta max_presentation_timestamp) {
-  clock_.SetTime(current_presentation_timestamp, max_presentation_timestamp);
+  interpolator_.SetBounds(current_presentation_timestamp,
+                          max_presentation_timestamp);
   manager()->OnTimeUpdate(player_id(), GetCurrentTime());
 }
 
 void MediaSourcePlayer::ProcessPendingEvents() {
   DVLOG(1) << __FUNCTION__ << " : 0x" << std::hex << pending_event_;
   // Wait for all the decoding jobs to finish before processing pending tasks.
   if (video_decoder_job_->is_decoding()) {
     DVLOG(1) << __FUNCTION__ << " : A video job is still decoding.";
     return;
   }
@@ skipping 114 matching lines @@
   if (pending_event_ != NO_EVENT_PENDING) {
     ProcessPendingEvents();
     return;
   }
 
   if (status == MEDIA_CODEC_OUTPUT_END_OF_STREAM)
     return;
 
   if (!playing_) {
     if (is_clock_manager)
-      clock_.Pause();
+      interpolator_.StopInterpolating();
     return;
   }
 
   if (status == MEDIA_CODEC_NO_KEY) {
     is_waiting_for_key_ = true;
     return;
   }
 
   // If the status is MEDIA_CODEC_STOPPED, stop decoding new data. The player is
   // in the middle of a seek or stop event and needs to wait for the IPCs to
@@ skipping 61 matching lines @@
   is_waiting_for_video_decoder_ = true;
   if (!IsEventPending(DECODER_CREATION_EVENT_PENDING))
     SetPendingEvent(DECODER_CREATION_EVENT_PENDING);
 }
 
 void MediaSourcePlayer::PlaybackCompleted(bool is_audio) {
   DVLOG(1) << __FUNCTION__ << "(" << is_audio << ")";
 
   if (AudioFinished() && VideoFinished()) {
     playing_ = false;
-    clock_.Pause();
+    interpolator_.StopInterpolating();
     start_time_ticks_ = base::TimeTicks();
     manager()->OnPlaybackComplete(player_id());
   }
 }
 
 void MediaSourcePlayer::ClearDecodingData() {
   DVLOG(1) << __FUNCTION__;
   audio_decoder_job_->Flush();
   video_decoder_job_->Flush();
   start_time_ticks_ = base::TimeTicks();
@@ skipping 78 matching lines @@
   if (pending_event_ != NO_EVENT_PENDING) {
     ProcessPendingEvents();
     return;
   }
 
   if (!playing_)
     return;
 
   start_time_ticks_ = base::TimeTicks::Now();
   start_presentation_timestamp_ = GetCurrentTime();
-  if (!clock_.IsPlaying())
-    clock_.Play();
+  if (!interpolator_.interpolating())
+    interpolator_.StartInterpolating();
 
   if (!AudioFinished())
     DecodeMoreAudio();
 
   if (!VideoFinished())
     DecodeMoreVideo();
 }
 
 void MediaSourcePlayer::OnDemuxerConfigsChanged() {
   manager()->OnMediaMetadataChanged(
@@ skipping 64 matching lines @@
   // release MediaDrm when the video is paused, or when the device goes to
   // sleep (see http://crbug.com/272421).
   NOTREACHED() << "CDM detachment not supported.";
   DCHECK(drm_bridge_);
   audio_decoder_job_->SetDrmBridge(NULL);
   video_decoder_job_->SetDrmBridge(NULL);
   drm_bridge_ = NULL;
 }
 
 }  // namespace media