Interpolate media time for mojo rendering pipeline.

content/renderer/media/android/webmediaplayer_android.cc

 // Copyright 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 "content/renderer/media/android/webmediaplayer_android.h"
 
 #include <stddef.h>
 
 #include <limits>
 
@@ skipping 830 matching lines @@
 
   if (need_to_signal_duration_changed)
     client_->durationChanged();
 }
 
 void WebMediaPlayerAndroid::OnPlaybackComplete() {
   // When playback is about to finish, android media player often stops
   // at a time which is smaller than the duration. This makes webkit never
   // know that the playback has finished. To solve this, we set the
   // current time to media duration when OnPlaybackComplete() get called.
-  interpolator_.SetBounds(duration_, duration_);
+  interpolator_.SetBounds(duration_, duration_, default_tick_clock_.NowTicks());
   client_->timeChanged();
 
   // If the loop attribute is set, timeChanged() will update the current time
   // to 0. It will perform a seek to 0. Issue a command to the player to start
   // playing after seek completes.
   if (is_playing_ && seeking_ && seek_time_.is_zero())
     player_manager_->Start(player_id_);
   else
     playback_completed_ = true;
 }
@@ skipping 13 matching lines @@
 
 void WebMediaPlayerAndroid::OnSeekComplete(
     const base::TimeDelta& current_time) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   seeking_ = false;
   if (pending_seek_) {
     pending_seek_ = false;
     seek(pending_seek_time_.InSecondsF());
     return;
   }
-  interpolator_.SetBounds(current_time, current_time);
+  interpolator_.SetBounds(current_time, current_time,
+                          default_tick_clock_.NowTicks());
 
   UpdateReadyState(WebMediaPlayer::ReadyStateHaveEnoughData);
 
   client_->timeChanged();
 }
 
 void WebMediaPlayerAndroid::OnMediaError(int error_type) {
   switch (error_type) {
     case MediaPlayerAndroid::MEDIA_ERROR_FORMAT:
       UpdateNetworkState(WebMediaPlayer::NetworkStateFormatError);
@@ skipping 73 matching lines @@
 }
 
 void WebMediaPlayerAndroid::OnTimeUpdate(base::TimeDelta current_timestamp,
                                          base::TimeTicks current_time_ticks) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
 
   if (seeking())
     return;
 
   // Compensate the current_timestamp with the IPC latency.
+  base::TimeTicks now_ticks = default_tick_clock_.NowTicks();
   base::TimeDelta lower_bound =
-      base::TimeTicks::Now() - current_time_ticks + current_timestamp;
+      now_ticks - current_time_ticks + current_timestamp;
+
   base::TimeDelta upper_bound = lower_bound;
   // We should get another time update in about |kTimeUpdateInterval|
   // milliseconds.
   if (is_playing_) {
     upper_bound += base::TimeDelta::FromMilliseconds(
         media::kTimeUpdateInterval);
   }
   // if the lower_bound is smaller than the current time, just use the current
   // time so that the timer is always progressing.
   lower_bound =
       std::max(lower_bound, base::TimeDelta::FromSecondsD(currentTime()));
   if (lower_bound > upper_bound)
     upper_bound = lower_bound;
-  interpolator_.SetBounds(lower_bound, upper_bound);
+  interpolator_.SetBounds(lower_bound, upper_bound, now_ticks);
 }
 
 void WebMediaPlayerAndroid::OnConnectedToRemoteDevice(
     const std::string& remote_playback_message) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   DrawRemotePlaybackText(remote_playback_message);
   is_remote_ = true;
   SetNeedsEstablishPeer(false);
   client_->connectedToRemoteDevice();
 }
@@ skipping 699 matching lines @@
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableMediaSuspend)) {
     return false;
   }
 
   return base::FeatureList::IsEnabled(media::kResumeBackgroundVideo) &&
       hasAudio() && !isRemote() && delegate_ && delegate_->IsHidden();
 }
 
 }  // namespace content