Don't suspend the pipeline before HaveFutureData while decoding progressing

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 218 matching lines @@
       suppress_destruction_errors_(false),
       can_suspend_state_(CanSuspendState::UNKNOWN),
       use_fallback_path_(false),
       is_encrypted_(false),
       underflow_count_(0),
       observer_(params.media_observer()) {
   DCHECK(!adjust_allocated_memory_cb_.is_null());
   DCHECK(renderer_factory_);
   DCHECK(client_);
 
+  tick_clock_ = &default_tick_clock_;
+
   force_video_overlays_ = base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kForceVideoOverlays);
 
   disable_fullscreen_video_overlays_ =
       !base::FeatureList::IsEnabled(media::kOverlayFullscreenVideo);
 
   if (delegate_)
     delegate_id_ = delegate_->AddObserver(this);
 
   media_log_->AddEvent(
@@ skipping 526 matching lines @@
   // If we've idle suspended before reaching kHaveFutureData and loading has
   // progressed we need to spin up the renderer and figure out if we have enough
   // data yet; |client_| may be waiting on this signal to trigger playback. The
   // idle timeout is long enough that this is a low-cost operation.
   if (highest_ready_state_ < ReadyState::ReadyStateHaveFutureData &&
       pipeline_controller_.IsSuspended() && did_loading_progress && is_idle_) {
     is_idle_ = false;
     UpdatePlayState();
   }
 
+  if (did_loading_progress)
+    last_time_loading_progressed_ = tick_clock_->NowTicks();
+
   return did_loading_progress;
 }
 
 void WebMediaPlayerImpl::paint(blink::WebCanvas* canvas,
                                const blink::WebRect& rect,
                                SkPaint& paint) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   TRACE_EVENT0("media", "WebMediaPlayerImpl:paint");
 
   // TODO(sandersd): Move this check into GetCurrentFrameFromCompositor() when
@@ skipping 509 matching lines @@
 
   must_suspend_ = false;
   background_pause_timer_.Stop();
 
   UpdatePlayState();
 }
 
 void WebMediaPlayerImpl::OnSuspendRequested(bool must_suspend) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
-  if (must_suspend)
+  if (must_suspend) {
     must_suspend_ = true;
-  else
+    UpdatePlayState();
+    return;
+  }
+
+  // If we're beyond HaveFutureData, we can safely suspend at any time.
+  if (highest_ready_state_ >= WebMediaPlayer::ReadyStateHaveFutureData) {
     is_idle_ = true;
+    UpdatePlayState();
+    return;
+  }
 
-  UpdatePlayState();
+  // Before HaveFutureData blink will not call play(), so we must be careful to

[DaleCurtis, 2016/10/28 19:11:42]

This will never be called again. So even after 3 seconds elapse the player won't
be suspended. We need to PostDelayTask this check for another few seconds in the
future or change this method from setting is_idle_ to setting something like
suspend_requested_ when < have_future_data. The didLoadingProgress() callback
can then schedule the idle suspend.

[watk, 2016/10/28 20:03:22]

What about calling delegate_->DidPause()? Then the delegate can try to suspend
us again later.

+  // only suspend if we'll eventually receive an event that will trigger a
+  // resume. If the last time loading progressed was longer than 3 seconds ago,
+  // and we still haven't reached HaveFutureData, assume that we're waiting on
+  // more data to proceed. When that data is loaded the pipeline will be resumed
+  // by didLoadingProgress().
+  if (last_time_loading_progressed_.is_null() ||
+      (tick_clock_->NowTicks() - last_time_loading_progressed_) >
+          base::TimeDelta::FromSeconds(3)) {
+    is_idle_ = true;
+    UpdatePlayState();
+  }
 }
 
 void WebMediaPlayerImpl::OnPlay() {
   play();
   client_->playbackStateChanged();
 }
 
 void WebMediaPlayerImpl::OnPause() {
   pause();
   client_->playbackStateChanged();
@@ skipping 563 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