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 127 matching lines @@
   return natural_size;
 }
 
 base::TimeDelta GetCurrentTimeInternal(WebMediaPlayerImpl* p_this) {
   // We wrap currentTime() instead of using pipeline_.GetMediaTime() since there
   // are a variety of cases in which that time is not accurate; e.g., while
   // remoting and during a pause or seek.
   return base::TimeDelta::FromSecondsD(p_this->currentTime());
 }
 
+// How much time must have elapsed since loading last progressed before the
+// player is eligible for idle suspension.
+constexpr base::TimeDelta kLoadingToIdleTimeout =
+    base::TimeDelta::FromSeconds(3);
+
 }  // namespace
 
 class BufferedDataSourceHostImpl;
 
 STATIC_ASSERT_ENUM(WebMediaPlayer::CORSModeUnspecified,
                    UrlData::CORS_UNSPECIFIED);
 STATIC_ASSERT_ENUM(WebMediaPlayer::CORSModeAnonymous, UrlData::CORS_ANONYMOUS);
 STATIC_ASSERT_ENUM(WebMediaPlayer::CORSModeUseCredentials,
                    UrlData::CORS_USE_CREDENTIALS);
 
@@ skipping 71 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_.reset(new base::DefaultTickClock());
+
   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 530 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 506 matching lines @@
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   if (watch_time_reporter_)
     watch_time_reporter_->OnShown();
 
   must_suspend_ = false;
   background_pause_timer_.Stop();
 
   UpdatePlayState();
 }
 
-void WebMediaPlayerImpl::OnSuspendRequested(bool must_suspend) {
+bool WebMediaPlayerImpl::OnSuspendRequested(bool must_suspend) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
-  if (must_suspend)
+  if (must_suspend) {
     must_suspend_ = true;
-  else
+    UpdatePlayState();
+    return true;
+  }
+
+  // If we're beyond HaveFutureData, we can safely suspend at any time.
+  if (highest_ready_state_ >= WebMediaPlayer::ReadyStateHaveFutureData) {
     is_idle_ = true;
+    UpdatePlayState();
+    return true;
+  }
 
-  UpdatePlayState();
+  // Before HaveFutureData blink will not call play(), so we must be careful to
+  // only suspend if we'll eventually receive an event that will trigger a
+  // resume. If the last time loading progressed was a while ago, and we still
+  // haven't reached HaveFutureData, we assume that we're waiting on more data
+  // to continue pre-rolling. 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_) >
+          kLoadingToIdleTimeout) {
+    is_idle_ = true;
+    UpdatePlayState();
+    return true;
+  }
+
+  return false;
 }
 
 void WebMediaPlayerImpl::OnPlay() {
   play();
   client_->playbackStateChanged();
 }
 
 void WebMediaPlayerImpl::OnPause() {
   pause();
   client_->playbackStateChanged();
@@ skipping 573 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