Interpolate media time for mojo rendering pipeline.

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 <stddef.h>
 #include <stdint.h>
 #include <limits>
 #include <utility>
@@ skipping 86 matching lines @@
   RetryDecoderCreation(false, true);
 }
 
 void MediaSourcePlayer::ScheduleSeekEventAndStopDecoding(
     base::TimeDelta seek_time) {
   DVLOG(1) << __FUNCTION__ << "(" << seek_time.InSecondsF() << ")";
   DCHECK(!IsEventPending(SEEK_EVENT_PENDING));
 
   pending_seek_ = false;
 
-  interpolator_.SetBounds(seek_time, seek_time);
+  interpolator_.SetBounds(seek_time, seek_time, default_tick_clock_.NowTicks());
 
   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 241 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();
-    interpolator_.SetBounds(seek_time, seek_time);
+    interpolator_.SetBounds(seek_time, seek_time,
+                            default_tick_clock_.NowTicks());
     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_);
   prerolling_ = true;
 
   if (!doing_browser_seek_)
     manager()->OnSeekComplete(player_id(), current_time);
 
   ProcessPendingEvents();
 }
 
 void MediaSourcePlayer::UpdateTimestamps(
     base::TimeDelta current_presentation_timestamp,
     base::TimeDelta max_presentation_timestamp) {
+  base::TimeTicks now_ticks = default_tick_clock_.NowTicks();
   interpolator_.SetBounds(current_presentation_timestamp,
-                          max_presentation_timestamp);
-  manager()->OnTimeUpdate(player_id(),
-                          GetCurrentTime(),
-                          base::TimeTicks::Now());
+                          max_presentation_timestamp, now_ticks);
+  manager()->OnTimeUpdate(player_id(), GetCurrentTime(), now_ticks);
 }
 
 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 446 matching lines @@
   is_waiting_for_key_ = false;
   key_added_while_decode_pending_ = false;
 
   // StartInternal() will trigger a prefetch, where in most cases we'll just
   // use previously received data.
   if (playing_)
     StartInternal();
 }
 
 }  // namespace media