fix canplaythrough

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 197 matching lines @@
       client_(client),
       encrypted_client_(encrypted_client),
       delegate_(delegate),
       delegate_id_(0),
       defer_load_cb_(params.defer_load_cb()),
       context_3d_cb_(params.context_3d_cb()),
       adjust_allocated_memory_cb_(params.adjust_allocated_memory_cb()),
       last_reported_memory_usage_(0),
       supports_save_(true),
       chunk_demuxer_(NULL),
+      buffered_data_source_host_(
+          base::Bind(&WebMediaPlayerImpl::OnProgress, AsWeakPtr())),
       url_index_(url_index),
       // Threaded compositing isn't enabled universally yet.
       compositor_task_runner_(params.compositor_task_runner()
                                   ? params.compositor_task_runner()
                                   : base::ThreadTaskRunnerHandle::Get()),
       compositor_(new VideoFrameCompositor(compositor_task_runner_)),
 #if defined(OS_ANDROID)  // WMPI_CAST
       cast_impl_(this, client_, params.context_3d_cb()),
 #endif
       volume_(1.0),
@@ skipping 610 matching lines @@
 }
 
 bool WebMediaPlayerImpl::didLoadingProgress() {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   // Note: Separate variables used to ensure both methods are called every time.
   const bool pipeline_progress = pipeline_controller_.DidLoadingProgress();
   const bool data_progress = buffered_data_source_host_.DidLoadingProgress();
   const bool did_loading_progress = pipeline_progress || data_progress;
 
-  if (did_loading_progress &&
-      highest_ready_state_ < ReadyState::ReadyStateHaveFutureData) {
-    // Reset the preroll attempt clock.
-    preroll_attempt_pending_ = true;
-    preroll_attempt_start_time_ = base::TimeTicks();
+  if (did_loading_progress) {
+    if (highest_ready_state_ < ReadyState::ReadyStateHaveFutureData) {

[DaleCurtis, 2017/04/06 22:51:40]

This whole block can actually be moved to OnProgress() now without the first
conditional.

[hubbe, 2017/04/07 19:35:51]

Done.

+      // Reset the preroll attempt clock.
+      preroll_attempt_pending_ = true;
+      preroll_attempt_start_time_ = base::TimeTicks();
 
-    // Clear any 'stale' flag and give the pipeline a chance to resume. If we
-    // are already resumed, this will cause |preroll_attempt_start_time_| to be
-    // set.
-    // TODO(sandersd): Should this be on the same stack? It might be surprising
-    // that didLoadingProgress() can synchronously change state.
-    delegate_->ClearStaleFlag(delegate_id_);
-    UpdatePlayState();
+      // Clear any 'stale' flag and give the pipeline a chance to resume. If we
+      // are already resumed, this will cause |preroll_attempt_start_time_| to
+      // be set.
+      // TODO(sandersd): Should this be on the same stack? It might be
+      // surprising that didLoadingProgress() can synchronously change state.
+      delegate_->ClearStaleFlag(delegate_id_);
+      UpdatePlayState();
+    }
   }
 
   return did_loading_progress;
 }
 
 void WebMediaPlayerImpl::paint(blink::WebCanvas* canvas,
                                const blink::WebRect& rect,
                                cc::PaintFlags& flags) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   TRACE_EVENT0("media", "WebMediaPlayerImpl:paint");
@@ skipping 396 matching lines @@
     client_->setWebLayer(video_weblayer_.get());
   }
 
   if (observer_)
     observer_->OnMetadataChanged(pipeline_metadata_);
 
   CreateWatchTimeReporter();
   UpdatePlayState();
 }
 
+void WebMediaPlayerImpl::OnProgress() {
+  if (ready_state_ == ReadyState::ReadyStateHaveFutureData &&
+      CanPlayThrough()) {
+    SetReadyState(WebMediaPlayer::ReadyStateHaveEnoughData);
+  }
+}
+
+bool WebMediaPlayerImpl::CanPlayThrough() {
+  if (chunk_demuxer_)

[DaleCurtis, 2017/04/06 22:51:40]

Ternary?

[hubbe, 2017/04/07 19:35:51]

Makes the expression too long I think.
It's already long...

+    return true;
+  return buffered_data_source_host_.CanPlayThrough(
+      base::TimeDelta::FromSecondsD(currentTime()),
+      base::TimeDelta::FromSecondsD(duration()),
+      playback_rate_ == 0.0 ? 1.0 : playback_rate_);
+}
+
 void WebMediaPlayerImpl::OnBufferingStateChange(BufferingState state) {
   DVLOG(1) << __func__ << "(" << state << ")";
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   // Ignore buffering state changes until we've completed all outstanding
   // operations.
   if (!pipeline_controller_.IsStable())
     return;
 
   media_log_->AddEvent(media_log_->CreateBufferingStateChangedEvent(
       "pipeline_buffering_state", state));
 
   if (state == BUFFERING_HAVE_ENOUGH) {
     if (highest_ready_state_ < WebMediaPlayer::ReadyStateHaveEnoughData) {
       // Record a zero value for underflow histogram so that the histogram
       // includes playbacks which never encounter an underflow event.
       RecordUnderflowDuration(base::TimeDelta());
     }
 
-    // TODO(chcunningham): Monitor playback position vs buffered. Potentially
-    // transition to HAVE_FUTURE_DATA here if not enough is buffered.
-    SetReadyState(WebMediaPlayer::ReadyStateHaveEnoughData);
+    if (CanPlayThrough()) {

[DaleCurtis, 2017/04/06 22:51:40]

drop one line {}

[hubbe, 2017/04/07 19:35:51]

How about ternary? :)

+      SetReadyState(WebMediaPlayer::ReadyStateHaveEnoughData);
+    } else {
+      SetReadyState(WebMediaPlayer::ReadyStateHaveFutureData);
+    }
 
     // Let the DataSource know we have enough data. It may use this information
     // to release unused network connections.
     if (data_source_)
       data_source_->OnBufferingHaveEnough(false);
 
     // Blink expects a timeChanged() in response to a seek().
     if (should_notify_time_changed_) {
       should_notify_time_changed_ = false;
       client_->timeChanged();
@@ skipping 328 matching lines @@
 
   StartPipeline();
 }
 
 void WebMediaPlayerImpl::NotifyDownloading(bool is_downloading) {
   DVLOG(1) << __func__;
   if (!is_downloading && network_state_ == WebMediaPlayer::NetworkStateLoading)
     SetNetworkState(WebMediaPlayer::NetworkStateIdle);
   else if (is_downloading && network_state_ == WebMediaPlayer::NetworkStateIdle)
     SetNetworkState(WebMediaPlayer::NetworkStateLoading);
+  if (ready_state_ == ReadyState::ReadyStateHaveFutureData && !is_downloading)

[DaleCurtis, 2017/04/06 22:51:40]

Don't think this function should call SetReadyState; since it's otherwise only
SetNetworkState. Can we just let this happen via the progress callback above?

[hubbe, 2017/04/07 19:35:51]

No, we won't get progress callbacks after we stop downloading...

+    SetReadyState(WebMediaPlayer::ReadyStateHaveEnoughData);
   media_log_->AddEvent(
       media_log_->CreateBooleanEvent(MediaLogEvent::NETWORK_ACTIVITY_SET,
                                      "is_downloading_data", is_downloading));
 }
 
 void WebMediaPlayerImpl::OnSurfaceCreated(int surface_id) {
   overlay_surface_id_ = surface_id;
   if (!set_surface_cb_.is_null()) {
     // If restart is required, the callback is one-shot only.
     if (decoder_requires_restart_for_overlay_)
@@ skipping 668 matching lines @@
 
 void WebMediaPlayerImpl::RecordUnderflowDuration(base::TimeDelta duration) {
   DCHECK(data_source_ || chunk_demuxer_);
   if (data_source_)
     UMA_HISTOGRAM_TIMES("Media.UnderflowDuration", duration);
   else
     UMA_HISTOGRAM_TIMES("Media.UnderflowDuration.MSE", duration);
 }
 
 }  // namespace media