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) {
+      // 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();
+    }
+    if (ready_state_ == ReadyState::ReadyStateHaveFutureData &&
+        CanPlayThrough()) {
+      SetReadyState(WebMediaPlayer::ReadyStateHaveEnoughData);
+    }
   }
 
   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);

[chcunningham, 2017/04/06 16:55:41]

Do we need this logic both here and in didLoadingProgress? Can we just have this
on? I'm not a fan of how didLoadingProgress has sideffects.

[hubbe, 2017/04/06 21:25:38]

I can remove it from didLoadingProgress()

+  }
+}
+
+bool WebMediaPlayerImpl::CanPlayThrough() {
+  return buffered_data_source_host_.CanPlayThrough(

[chcunningham, 2017/04/06 16:55:41]

What about MSE (no buffered_data_source_host_)?

[hubbe, 2017/04/06 21:25:38]

There is always a buffered_data_source_host_, but of course it's not used. Added
code to make it behave as before for MSE.

+      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()) {
+      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)
+    SetReadyState(WebMediaPlayer::ReadyStateHaveEnoughData);

[mlamouri (slow - plz ping), 2017/04/06 11:32:56]

If I understand correctly, that means that we will advertise as being able to
play through if we have future data and not downloading? Why?

[hubbe, 2017/04/06 21:25:38]

That's what the standard says to do when the buffer is full.

[mlamouri (slow - plz ping), 2017/04/07 11:23:44]

FWIW, what I understood by reading the code is that we are no longer downloading
not that the buffer was full. The buffer being full makes sense but do we stop
downloading only if the buffer is full? Maybe add a comment if this can only
happen when the buffer is full?

   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