Fix WMPI::currentTime/seek race causing flaky Blink mediasource-redundant-seek.html on desktop

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 102 matching lines @@
       media_task_runner_(params.media_task_runner()),
       media_log_(params.media_log()),
       pipeline_(media_task_runner_, media_log_.get()),
       load_type_(LoadTypeURL),
       opaque_(false),
       paused_(true),
       seeking_(false),
       playback_rate_(0.0),
       ended_(false),
       pending_seek_(false),
-      pending_seek_seconds_(0.0f),
       should_notify_time_changed_(false),
       client_(client),
       delegate_(delegate),
       defer_load_cb_(params.defer_load_cb()),
       context_3d_cb_(params.context_3d_cb()),
       supports_save_(true),
       chunk_demuxer_(NULL),
       // Threaded compositing isn't enabled universally yet.
       compositor_task_runner_(
           params.compositor_task_runner()
@@ skipping 149 matching lines @@
 void WebMediaPlayerImpl::seek(double seconds) {
   DVLOG(1) << __FUNCTION__ << "(" << seconds << "s)";
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   ended_ = false;
 
   ReadyState old_state = ready_state_;
   if (ready_state_ > WebMediaPlayer::ReadyStateHaveMetadata)
     SetReadyState(WebMediaPlayer::ReadyStateHaveMetadata);
 
-  base::TimeDelta seek_time = ConvertSecondsToTimestamp(seconds);
+  base::TimeDelta new_seek_time = ConvertSecondsToTimestamp(seconds);
 
   if (seeking_) {
+    if (new_seek_time == seek_time_) {
+      if (chunk_demuxer_) {
+        if (!pending_seek_) {
+          // 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;

[Srirama, 2015/06/09 17:08:42]

I think this may not be required, isn't it already false in this case?

[wolenetz, 2015/06/09 19:44:28]

Consider the following sequence of seeks without any intervening completion of
the pipeline seek (the key part is annotated by "**"):
(non MSE, of course, since !chunk_demuxer_ is the path in question in this
comment)
Seek(1.0s) ->
* seeking_ becomes true, seek_time_ becomes 1.0s
* pending_seek_ remains false, pending_seek_time_=n/a
Seek(2.0s) ->
* seeking_ remains true, seek_time_ remains 1.0s
* pending_seek_ becomes true, pending_seek_time_ becomes 2.0s
Seek(1.0s) -:
* seeking_ remains true, seek_time_ remains 1.0s
** we no longer need the pending seek to 2.0s, since the most recently requested
seek was to the same time that we're already seeking to)
* pending_seek_ becomes false, pending_seek_time=n/a

[xhwang, 2015/06/09 21:33:57]

reset |pending_seek_time_| as well?

[wolenetz, 2015/06/09 22:09:58]

Sure, done. |pending_seek_time_| has no meaning when |pending_seek_| is false,
but such reset shouldn't hurt or confuse. I did similar for |seek_time_| and
|seeking_|.

+        return;
+      }
+    }
+
     pending_seek_ = true;
-    pending_seek_seconds_ = seconds;
+    pending_seek_time_ = new_seek_time;
     if (chunk_demuxer_)
-      chunk_demuxer_->CancelPendingSeek(seek_time);
+      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
   if (paused_) {
-    if (paused_time_ != seek_time) {
-      paused_time_ = seek_time;
+    if (paused_time_ != new_seek_time) {
+      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;
     }
   }
 
   seeking_ = true;
+  seek_time_ = new_seek_time;
 
   if (chunk_demuxer_)
-    chunk_demuxer_->StartWaitingForSeek(seek_time);
+    chunk_demuxer_->StartWaitingForSeek(seek_time_);
 
   // Kick off the asynchronous seek!
-  pipeline_.Seek(
-      seek_time,
-      BIND_TO_RENDER_LOOP1(&WebMediaPlayerImpl::OnPipelineSeeked, true));
+  pipeline_.Seek(seek_time_, BIND_TO_RENDER_LOOP1(
+                                 &WebMediaPlayerImpl::OnPipelineSeeked, true));
 }
 
 void WebMediaPlayerImpl::setRate(double rate) {
   DVLOG(1) << __FUNCTION__ << "(" << rate << ")";
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   // TODO(kylep): Remove when support for negatives is added. Also, modify the
   // following checks so rewind uses reasonable values also.
   if (rate < 0.0)
     return;
@@ skipping 96 matching lines @@
 
 double WebMediaPlayerImpl::currentTime() const {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   DCHECK_NE(ready_state_, WebMediaPlayer::ReadyStateHaveNothing);
 
   // TODO(scherkus): Replace with an explicit ended signal to HTMLMediaElement,
   // see http://crbug.com/409280
   if (ended_)
     return duration();
 
+  // We know the current seek time better than pipeline: pipeline may processing
+  // an earlier seek before a pending seek has been started, or it might not yet
+  // have the current seek time returnable via GetMediaTime().
+  if (seeking()) {
+    return pending_seek_ ? pending_seek_time_.InSecondsF()
+                         : seek_time_.InSecondsF();
+  }
+
   return (paused_ ? paused_time_ : pipeline_.GetMediaTime()).InSecondsF();
 }
 
 WebMediaPlayer::NetworkState WebMediaPlayerImpl::networkState() const {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   return network_state_;
 }
 
 WebMediaPlayer::ReadyState WebMediaPlayerImpl::readyState() const {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
@@ skipping 253 matching lines @@
       "Unable to set MediaKeys object");
 }
 
 void WebMediaPlayerImpl::OnPipelineSeeked(bool time_changed,
                                           PipelineStatus status) {
   DVLOG(1) << __FUNCTION__ << "(" << time_changed << ", " << status << ")";
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   seeking_ = false;
   if (pending_seek_) {
     pending_seek_ = false;
-    seek(pending_seek_seconds_);
+    seek(pending_seek_time_.InSecondsF());
     return;
   }
 
   if (status != PIPELINE_OK) {
     OnPipelineError(status);
     return;
   }
 
   // Update our paused time.
   if (paused_)
@@ skipping 275 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