Not for submission. fastSeek prototype.

media/filters/pipeline_controller.cc

 // Copyright 2016 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/filters/pipeline_controller.h"
 
 #include "base/bind.h"
 #include "media/base/demuxer.h"
 
 namespace media {
@@ skipping 37 matching lines @@
   state_ = State::STARTING;
 
   demuxer_ = demuxer;
   is_streaming_ = is_streaming;
   is_static_ = is_static;
   pipeline_->Start(demuxer, renderer_factory_cb_.Run(), client,
                    base::Bind(&PipelineController::OnPipelineStatus,
                               weak_factory_.GetWeakPtr(), State::PLAYING));
 }
 
-void PipelineController::Seek(base::TimeDelta time, bool time_updated) {
+void PipelineController::Seek(StreamPosition position, bool time_updated) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // It would be slightly more clear to set this in Dispatch(), but we want to
   // be sure it gets updated even if the seek is elided.
   if (time_updated)
     pending_time_updated_ = true;
   pending_seeked_cb_ = true;
 
   // If we are already seeking to |time|, and the media is static, elide the
   // seek.
   if ((state_ == State::SEEKING || state_ == State::RESUMING) &&
-      seek_time_ == time && is_static_) {
+      seek_position_ == position && is_static_) {
     pending_seek_ = false;
     return;
   }
 
-  pending_seek_time_ = time;
+  pending_seek_position_ = position;
   pending_seek_ = true;
   Dispatch();
 }
 
 // TODO(sandersd): It may be easier to use this interface if |suspended_cb_| is
 // executed when Suspend() is called while already suspended.
 void PipelineController::Suspend() {
   DCHECK(thread_checker_.CalledOnValidThread());
   pending_resume_ = false;
   if (state_ != State::SUSPENDING && state_ != State::SUSPENDED) {
@@ skipping 64 matching lines @@
     state_ = State::SUSPENDING;
     pipeline_->Suspend(base::Bind(&PipelineController::OnPipelineStatus,
                                   weak_factory_.GetWeakPtr(),
                                   State::SUSPENDED));
     return;
   }
 
   if (pending_resume_ && state_ == State::SUSPENDED) {
     // If there is a pending seek, resume to that time instead...
     if (pending_seek_) {
-      seek_time_ = pending_seek_time_;
+      seek_position_ = StreamPosition::Precise(pending_seek_position_.time);
       pending_seek_ = false;
     } else {
-      seek_time_ = pipeline_->GetMediaTime();
+      seek_position_ = StreamPosition::Precise(pipeline_->GetMediaTime());
     }
 
     // ...unless the media is streaming, in which case we resume at the start
     // because seeking doesn't work well.
-    if (is_streaming_ && !seek_time_.is_zero()) {
-      seek_time_ = base::TimeDelta();
+    if (is_streaming_ && !seek_position_.time.is_zero()) {
+      seek_position_ = StreamPosition::Precise(base::TimeDelta());
 
       // In this case we want to make sure that the controls get updated
       // immediately, so we don't try to hide the seek.
       pending_time_updated_ = true;
     }
 
     // Tell |demuxer_| to expect our resume.
     DCHECK(!waiting_for_seek_);
     waiting_for_seek_ = true;
-    demuxer_->StartWaitingForSeek(seek_time_);
+    demuxer_->StartWaitingForSeek(seek_position_.time);
 
     pending_resume_ = false;
     state_ = State::RESUMING;
-    pipeline_->Resume(renderer_factory_cb_.Run(), seek_time_,
+    pipeline_->Resume(renderer_factory_cb_.Run(), seek_position_.time,
                       base::Bind(&PipelineController::OnPipelineStatus,
                                  weak_factory_.GetWeakPtr(), State::PLAYING));
     return;
   }
 
   // If we have pending operations, and a seek is ongoing, abort it.
   if ((pending_seek_ || pending_suspend_) && waiting_for_seek_) {
     // If there is no pending seek, return the current seek to pending status.
     if (!pending_seek_) {
-      pending_seek_time_ = seek_time_;
+      pending_seek_position_ = seek_position_;
       pending_seek_ = true;
     }
 
     // CancelPendingSeek() may be reentrant, so update state first and return
     // immediately.
     waiting_for_seek_ = false;
-    demuxer_->CancelPendingSeek(pending_seek_time_);
+    demuxer_->CancelPendingSeek(pending_seek_position_.time);
     return;
   }
 
   // Ordinary seeking.
   if (pending_seek_ && state_ == State::PLAYING) {
-    seek_time_ = pending_seek_time_;
+    seek_position_ = pending_seek_position_;
 
     // Tell |demuxer_| to expect our seek.
     DCHECK(!waiting_for_seek_);
     waiting_for_seek_ = true;
-    demuxer_->StartWaitingForSeek(seek_time_);
+    demuxer_->StartWaitingForSeek(seek_position_.time);
 
     pending_seek_ = false;
     state_ = State::SEEKING;
-    pipeline_->Seek(seek_time_,
+    pipeline_->Seek(seek_position_,
                     base::Bind(&PipelineController::OnPipelineStatus,
                                weak_factory_.GetWeakPtr(), State::PLAYING));
     return;
   }
 
   // If |state_| is PLAYING and we didn't trigger an operation above then we
   // are in a stable state. If there is a seeked callback pending, emit it.
   if (state_ == State::PLAYING) {
     if (pending_seeked_cb_) {
       // |seeked_cb_| may be reentrant, so update state first and return
       // immediately.
       pending_seeked_cb_ = false;
       bool was_pending_time_updated = pending_time_updated_;
       pending_time_updated_ = false;
       seeked_cb_.Run(was_pending_time_updated);
       return;
     }
   }
 }
 
 }  // namespace media