Fire canplaythrough as soon as download defers to fix autoplay

media/base/download_rate_monitor.cc

 // Copyright (c) 2011 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/base/download_rate_monitor.h"
 
 #include "base/bind.h"
 #include "base/time.h"
 
 namespace media {
@@ skipping 73 matching lines @@
   buffered_bytes_ = 0;
 
   NotifyCanPlayThroughIfNeeded();
 }
 
 void DownloadRateMonitor::SetBufferedBytes(
     int64 buffered_bytes, const base::Time& timestamp) {
   if (stopped_)
     return;
 
-  is_downloading_data_ = true;
-
   // Check monotonically nondecreasing constraint.
   base::Time previous_time;
   if (!current_sample_.is_null())
     previous_time = current_sample_.end().timestamp;
   else if (!sample_window_.empty())
     previous_time = sample_window_.back().end().timestamp;
 
   // If we go backward in time, dismiss the sample.
   if (!previous_time.is_null() && timestamp < previous_time)
     return;
 
   // If the buffer level has dropped, invalidate current sample.
   if (buffered_bytes < buffered_bytes_)
     current_sample_.Reset();
   buffered_bytes_ = buffered_bytes;
 
   BufferingPoint latest_point = { buffered_bytes, timestamp };
   if (current_sample_.is_null())
     current_sample_ = Sample(latest_point, latest_point);
   else
     current_sample_.set_end(latest_point);
 
   UpdateSampleWindow();
   NotifyCanPlayThroughIfNeeded();
 }
 
 void DownloadRateMonitor::SetNetworkActivity(bool is_downloading_data) {
-  if (is_downloading_data == is_downloading_data_)
-    return;
   // Invalidate the current sample if downloading is going from start to stopped
   // or vice versa.
-  current_sample_.Reset();
-  is_downloading_data_ = is_downloading_data;
+  if (is_downloading_data != is_downloading_data_) {
+    current_sample_.Reset();
+    is_downloading_data_ = is_downloading_data;
+  }
+
+  // Record when download defers for the first time.
+  if (!is_downloading_data && !has_deferred_) {

[acolwell GONE FROM CHROMIUM, 2012/01/11 18:51:01]

Is it possible for this method to get called with is_downloading_data == false
before we get a call with is_downloading_data == true? If so I think we might
accidentally trigger this code. 

Perhaps put this in the section above with a (is_downloading_data_ &&
!is_downloading_data && !has_deferred_) ?

[vrk (LEFT CHROMIUM), 2012/01/13 01:22:49]

Yes, on very short files or very fast downloads, where the download defers as a
result of the first call to didReceiveData.
Actually, I don't think it's wrong to trigger this code in this case.
SetNetworkActivity() will always be called after data has started downloading --
it wouldn't make sense for the BufferedResourceLoader to "defer" if it wasn't
already downloading.

But now that you mention it, I think the code *above* this block is unnecessary.
Since we're going to trigger CanPlayThrough when downloading |has_deferred_|
regardless, there's no need to keep track of the transitions between the state
of |is_downloading_data_|. 

I deleted this code and the |is_downloading_data_| field.

+    has_deferred_ = true;
+    NotifyCanPlayThroughIfNeeded();
+  }
 }
 
 void DownloadRateMonitor::Stop() {
   stopped_ = true;
   current_sample_.Reset();
   buffered_bytes_ = 0;
 }
 
 void DownloadRateMonitor::Reset() {
   canplaythrough_cb_.Reset();
   has_notified_can_play_through_ = false;
   current_sample_.Reset();
   sample_window_.clear();
   is_downloading_data_ = false;
   total_bytes_ = -1;
   buffered_bytes_ = 0;
   local_source_ = false;
   bitrate_ = 0;
   stopped_ = true;
   streaming_ = false;
+  has_deferred_ = false;
 }
 
 DownloadRateMonitor::~DownloadRateMonitor() { }
 
 int64 DownloadRateMonitor::bytes_downloaded_in_window() const {
   // There are max |kNumberOfSamples| so we might as well recompute each time.
   int64 total = 0;
   for (size_t i = 0; i < sample_window_.size(); ++i)
     total += sample_window_[i].bytes_downloaded();
   return total;
@@ skipping 44 matching lines @@
     return false;
 
   // Fire CanPlayThrough immediately if the source is local or streaming.
   //
   // NOTE: It is a requirement for CanPlayThrough to fire immediately if the
   // source is local, but the choice to optimistically fire the event for any
   // streaming media element is a design decision that may need to be tweaked.
   if (local_source_ || streaming_)
     return true;
 
-  // If all bytes are buffered, fire CanPlayThrough.
-  if (buffered_bytes_ == total_bytes_)
+  // If all bytes are buffered or if enough bytes were buffered such that
+  // downloading has deferred, fire CanPlayThrough.
+  if (buffered_bytes_ == total_bytes_ || has_deferred_)
     return true;
 
   // If bitrate is unknown, optimistically fire CanPlayThrough immediately.
   // This is so a video with an unknown bitrate with the "autoplay" attribute
   // will not wait until the entire file is downloaded before playback begins.
   if (bitrate_ <= 0)
     return true;
 
   float bytes_needed_per_second = bitrate_ / 8;
   float download_rate = ApproximateDownloadByteRate();
 
   // If we are downloading at or faster than the media's bitrate, then we can
   // play through to the end of the media without stopping to buffer.
   if (download_rate > 0)
     return download_rate >= bytes_needed_per_second;
 
-  // If download rate is unknown, it may be because the media is being
-  // downloaded so fast that it cannot collect an adequate number of samples
-  // before the download gets deferred.
-  //
-  // To catch this case, we also look at how much data is being downloaded
-  // immediately after the download begins.
+  // With very fast connections, we may want to fire CanPlayThrough before
+  // waiting for the sample window size to reach |kNumberOfSamples|. Check for
+  // this scenario.
   if (sample_window_.size() < kNumberOfSamples) {
     int64 bytes_downloaded_since_start =
         bytes_downloaded_in_window() + current_sample_.bytes_downloaded();
     float seconds_elapsed_since_start =
         seconds_elapsed_in_window() + current_sample_.seconds_elapsed();
 
     // If we download 4 seconds of data in less than 2 seconds of time, we're
     // probably downloading at a fast enough rate that we can play through.
     // This is an arbitrary metric that will likely need tweaking.
     if (seconds_elapsed_since_start < 2.0 &&
         bytes_downloaded_since_start > 4.0 * bytes_needed_per_second) {
       return true;
     }
   }
 
   return false;
 }
 
 void DownloadRateMonitor::NotifyCanPlayThroughIfNeeded() {
   if (ShouldNotifyCanPlayThrough() && !canplaythrough_cb_.is_null()) {
     canplaythrough_cb_.Run();
     has_notified_can_play_through_ = true;
   }
 }
 
 }  // namespace media