Not for submission. fastSeek prototype.

media/blink/webmediaplayer_impl.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 "media/blink/webmediaplayer_impl.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <string>
@@ skipping 16 matching lines @@
 #include "build/build_config.h"
 #include "cc/blink/web_layer_impl.h"
 #include "cc/layers/video_layer.h"
 #include "media/audio/null_audio_sink.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/cdm_context.h"
 #include "media/base/limits.h"
 #include "media/base/media_content_type.h"
 #include "media/base/media_log.h"
 #include "media/base/media_switches.h"
+#include "media/base/stream_position.h"
 #include "media/base/text_renderer.h"
 #include "media/base/timestamp_constants.h"
 #include "media/base/video_frame.h"
 #include "media/blink/texttrack_impl.h"
 #include "media/blink/watch_time_reporter.h"
 #include "media/blink/webaudiosourceprovider_impl.h"
 #include "media/blink/webcontentdecryptionmodule_impl.h"
 #include "media/blink/webinbandtexttrack_impl.h"
 #include "media/blink/webmediaplayer_delegate.h"
 #include "media/blink/webmediaplayer_util.h"
@@ skipping 391 matching lines @@
 }
 
 bool WebMediaPlayerImpl::supportsSave() const {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   return supports_save_;
 }
 
 void WebMediaPlayerImpl::seek(double seconds) {
   DVLOG(1) << __func__ << "(" << seconds << "s)";
   DCHECK(main_task_runner_->BelongsToCurrentThread());
-  DoSeek(base::TimeDelta::FromSecondsD(seconds), true);
+  DoSeek(StreamPosition::KeyFramePrecedingTime(
+             base::TimeDelta::FromSecondsD(seconds)),
+         true);
 }
 
-void WebMediaPlayerImpl::DoSeek(base::TimeDelta time, bool time_updated) {
+void WebMediaPlayerImpl::fastSeek(double seconds) {
+  DVLOG(1) << __func__ << "(" << seconds << "s)";
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
+  DoSeek(StreamPosition::Precise(base::TimeDelta::FromSecondsD(seconds)), true);
+}
+
+void WebMediaPlayerImpl::DoSeek(StreamPosition position, bool time_updated) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
 #if defined(OS_ANDROID)  // WMPI_CAST
   if (isRemote()) {
-    cast_impl_.seek(time);
+    // XXX: Revisit.
+    cast_impl_.seek(position.time);
     return;
   }
 #endif
 
   ReadyState old_state = ready_state_;
   if (ready_state_ > WebMediaPlayer::ReadyStateHaveMetadata)
     SetReadyState(WebMediaPlayer::ReadyStateHaveMetadata);
 
   // When paused, we know exactly what the current time is and can elide seeks
   // to it. However, there are two cases that are not elided:
   //   1) When the pipeline state is not stable.
   //      In this case we just let |pipeline_controller_| decide what to do, as
   //      it has complete information.
   //   2) For MSE.
   //      Because the buffers may have changed between seeks, MSE seeks are
   //      never elided.
-  if (paused_ && pipeline_controller_.IsStable() && paused_time_ == time &&
-      !chunk_demuxer_) {
+  if (paused_ && pipeline_controller_.IsStable() &&
+      paused_time_ == position.time && !chunk_demuxer_) {
     // If the ready state was high enough before, we can indicate that the seek
     // completed just by restoring it. Otherwise we will just wait for the real
     // ready state change to eventually happen.
     if (old_state == ReadyStateHaveEnoughData) {
       main_task_runner_->PostTask(
           FROM_HERE, base::Bind(&WebMediaPlayerImpl::OnBufferingStateChange,
                                 AsWeakPtr(), BUFFERING_HAVE_ENOUGH));
     }
     return;
   }
 
   // Call this before setting |seeking_| so that the current media time can be
   // recorded by the reporter.
   if (watch_time_reporter_)
     watch_time_reporter_->OnSeeking();
 
   // TODO(sandersd): Ideally we would not clear the idle state if
   // |pipeline_controller_| can elide the seek.
   is_idle_ = false;
   ended_ = false;
 
   seeking_ = true;
-  seek_time_ = time;
+  // XXX: Revisit. The page can observe time going backwards, but Android has
+  // always had this problem.
+  seek_time_ = position.time;
   if (paused_)
-    paused_time_ = time;
-  pipeline_controller_.Seek(time, time_updated);
+    paused_time_ = position.time;
+  pipeline_controller_.Seek(position, time_updated);
 
   // This needs to be called after Seek() so that if a resume is triggered, it
   // is to the correct time.
   UpdatePlayState();
 }
 
 void WebMediaPlayerImpl::setRate(double rate) {
   DVLOG(1) << __func__ << "(" << rate << ")";
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
@@ skipping 801 matching lines @@
 
 void WebMediaPlayerImpl::OnRemotePlaybackEnded() {
   DVLOG(1) << __func__;
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   ended_ = true;
   client_->timeChanged();
 }
 
 void WebMediaPlayerImpl::OnDisconnectedFromRemoteDevice(double t) {
-  DoSeek(base::TimeDelta::FromSecondsD(t), false);
+  DoSeek(StreamPosition::Precise(base::TimeDelta::FromSecondsD(t)), false);
 
   // We already told the delegate we're paused when remoting started.
   client_->playbackStateChanged();
   client_->disconnectedFromRemoteDevice();
 
   UpdatePlayState();
 }
 
 void WebMediaPlayerImpl::SuspendForRemote() {
   if (pipeline_controller_.IsPipelineSuspended()) {
@@ skipping 482 matching lines @@
       pipeline_metadata_.natural_size,
       base::Bind(&GetCurrentTimeInternal, this)));
   watch_time_reporter_->OnVolumeChange(volume_);
   if (delegate_ && delegate_->IsHidden())
     watch_time_reporter_->OnHidden();
   else
     watch_time_reporter_->OnShown();
 }
 
 }  // namespace media