Don't short-circuit MSE seeks in WebMediaPlayer impls

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>
 
@@ skipping 285 matching lines @@
 
   ReadyState old_state = ready_state_;
   if (ready_state_ > WebMediaPlayer::ReadyStateHaveMetadata)
     SetReadyState(WebMediaPlayer::ReadyStateHaveMetadata);
 
   base::TimeDelta new_seek_time = base::TimeDelta::FromSecondsD(seconds);
 
   if (seeking_) {
     if (new_seek_time == seek_time_) {
       if (chunk_demuxer_) {
         if (!pending_seek_) {

[wolenetz, 2015/08/31 21:15:31]

This is another instance of short-circuiting redundant seeks for MSE, but in the
case where a seek is still outstanding (from the P.O.V. of the renderer main
thread). I'll take a further look, though, since maybe an "onPipelineSeeked" is
on it's way from the media thread when we get to this logic, and maybe the media
thread (and renderers) have already started to consume old buffers. It seems to
me to be less fragile to remove this short-circuiting, so I'll probably have
another patch set coming that does this (for MSE).

[wolenetz, 2015/08/31 22:19:11]

Patch set 2 removes this kind of short-circuiting from both WMPI and WMPA.

           // If using media source demuxer, only suppress redundant seeks if
           // there is no pending seek. This enforces that any pending seek that
           // results in a demuxer seek is preceded by matching
           // CancelPendingSeek() and StartWaitingForSeek() calls.
           return;
         }
       } else {
         // Suppress all redundant seeks if unrestricted by media source demuxer
         // API.
         pending_seek_ = false;
         pending_seek_time_ = base::TimeDelta();
         return;
       }
     }
 
     pending_seek_ = true;
     pending_seek_time_ = new_seek_time;
     if (chunk_demuxer_)
       chunk_demuxer_->CancelPendingSeek(pending_seek_time_);
     return;
   }
 
   media_log_->AddEvent(media_log_->CreateSeekEvent(seconds));
 
   // Update our paused time.
-  // In paused state ignore the seek operations to current time if the loading
-  // is completed and generate OnPipelineBufferingStateChanged event to
-  // eventually fire seeking and seeked events
+  // For non-MSE playbacks, in paused state ignore the seek operations to
+  // current time if the loading is completed and generate
+  // OnPipelineBufferingStateChanged event to eventually fire seeking and seeked
+  // events. We don't short-circuit MSE seeks in this logic because the
+  // underlying buffers around the seek time might have changed (or even been
+  // removed) since previous seek/preroll/pause action, and the pipeline might
+  // need to flush so the new buffers are decoded and rendered instead of the
+  // old ones.
   if (paused_) {
-    if (paused_time_ != new_seek_time) {
+    if (paused_time_ != new_seek_time || chunk_demuxer_) {
       paused_time_ = new_seek_time;
     } else if (old_state == ReadyStateHaveEnoughData) {
       main_task_runner_->PostTask(
           FROM_HERE,
           base::Bind(&WebMediaPlayerImpl::OnPipelineBufferingStateChanged,
                      AsWeakPtr(), BUFFERING_HAVE_ENOUGH));
       return;
     }
   }
 
@@ skipping 706 matching lines @@
 
   // pause() may be called after playback has ended and the HTMLMediaElement
   // requires that currentTime() == duration() after ending.  We want to ensure
   // |paused_time_| matches currentTime() in this case or a future seek() may
   // incorrectly discard what it thinks is a seek to the existing time.
   paused_time_ =
       ended_ ? pipeline_.GetMediaDuration() : pipeline_.GetMediaTime();
 }
 
 }  // namespace media