Suppress redundant seeks to within same usec

content/renderer/media/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 "content/renderer/media/webmediaplayer_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 #include <vector>
@@ skipping 120 matching lines @@
     WebKit::WebMediaPlayerClient* client,
     base::WeakPtr<WebMediaPlayerDelegate> delegate,
     const WebMediaPlayerParams& params)
     : frame_(frame),
       network_state_(WebMediaPlayer::NetworkStateEmpty),
       ready_state_(WebMediaPlayer::ReadyStateHaveNothing),
       main_loop_(base::MessageLoopProxy::current()),
       media_loop_(params.message_loop_proxy()),
       paused_(true),
       seeking_(false),
-      playback_rate_(0.0f),
+      playback_rate_(0.0),
       pending_seek_(false),
-      pending_seek_seconds_(0.0f),
       client_(client),
       delegate_(delegate),
       defer_load_cb_(params.defer_load_cb()),
       media_log_(params.media_log()),
       accelerated_compositing_reported_(false),
       incremented_externally_allocated_memory_(false),
       gpu_factories_(params.gpu_factories()),
       is_local_source_(false),
       supports_save_(true),
       starting_(false),
@@ skipping 176 matching lines @@
 }
 
 bool WebMediaPlayerImpl::supportsSave() const {
   DCHECK(main_loop_->BelongsToCurrentThread());
   return supports_save_;
 }
 
 void WebMediaPlayerImpl::seek(double seconds) {
   DCHECK(main_loop_->BelongsToCurrentThread());
 
-  base::TimeDelta seek_time = ConvertSecondsToTimestamp(seconds);
+  base::TimeDelta new_seek_time = ConvertSecondsToTimestamp(seconds);
+
+  // Suppress redundant seek to same microsecond as current seek. Clear any
+  // pending seek in this case, too. For example, seek(1), seek(2), seek(1)
+  // without any intervening seek completion should result in only a current
+  // seek to (1) without any left-over pending seek.
+  if (seeking_ && new_seek_time == seek_time_) {

[wolenetz, 2013/10/01 19:51:49]

This is incorrect; I'll need to fix this in subsequent PS.
seek(1)+seek(2)+seek(1) collapses to just seek(1) with a CancelPendingSeek(2)
that causes kAborted demuxer buffer reads until someone later issues seek(2)
that issues StartWaitingForSeek(2) or until someone later issues a non-redundant
set of seeks such that there eventually is a matching
CancelPendingSeek+StartWaitingForSeek call.

See where similar broken optimization was fixed for Chrome for Android in
https://src.chromium.org/viewvc/chrome?view=rev&revision=226166

+    pending_seek_ = false;
+    return;
+  }
 
   if (starting_ || seeking_) {
     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;
   }
 
+  seek_time_ = new_seek_time;
   media_log_->AddEvent(media_log_->CreateSeekEvent(seconds));
 
   // Update our paused time.
   if (paused_)
-    paused_time_ = seek_time;
+    paused_time_ = seek_time_;
 
   seeking_ = true;
 
   if (chunk_demuxer_)
-    chunk_demuxer_->StartWaitingForSeek(seek_time);
+    chunk_demuxer_->StartWaitingForSeek(seek_time_);
 
   // Kick off the asynchronous seek!
   pipeline_->Seek(
-      seek_time,
+      seek_time_,
       BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnPipelineSeek));
 }
 
 void WebMediaPlayerImpl::setRate(double rate) {
   DCHECK(main_loop_->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 457 matching lines @@
 
   GetClient()->repaint();
 }
 
 void WebMediaPlayerImpl::OnPipelineSeek(PipelineStatus status) {
   DCHECK(main_loop_->BelongsToCurrentThread());
   starting_ = false;
   seeking_ = false;
   if (pending_seek_) {
     pending_seek_ = false;
-    seek(pending_seek_seconds_);
+    seek(pending_seek_time_.InSecondsF());
     return;
   }
 
   if (status != media::PIPELINE_OK) {
     OnPipelineError(status);
     return;
   }
 
   // Update our paused time.
   if (paused_)
@@ skipping 23 matching lines @@
 
   if (error == media::PIPELINE_ERROR_DECRYPT)
     EmeUMAHistogramCounts(current_key_system_, "DecryptError", 1);
 
   // Repaint to trigger UI update.
   Repaint();
 }
 
 void WebMediaPlayerImpl::OnPipelineBufferingState(
     media::Pipeline::BufferingState buffering_state) {
+  DCHECK(main_loop_->BelongsToCurrentThread());
   DVLOG(1) << "OnPipelineBufferingState(" << buffering_state << ")";
 
   switch (buffering_state) {
     case media::Pipeline::kHaveMetadata:
       SetReadyState(WebMediaPlayer::ReadyStateHaveMetadata);
 
       if (hasVideo() && GetClient()->needsWebLayerForVideo()) {
         DCHECK(!video_weblayer_);
         video_weblayer_.reset(
             new webkit::WebLayerImpl(cc::VideoLayer::Create(this)));
@@ skipping 342 matching lines @@
 
   if (pending_repaint_)
     return;
 
   pending_repaint_ = true;
   main_loop_->PostTask(FROM_HERE, base::Bind(
       &WebMediaPlayerImpl::Repaint, AsWeakPtr()));
 }
 
 }  // namespace content