Fire CanPlayThrough immediately for local and streaming media files

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 55 matching lines @@
 void DownloadRateMonitor::Sample::RestartAtEndBufferingPoint() {
   start_ = end_;
   end_ = BufferingPoint();
 }
 
 DownloadRateMonitor::DownloadRateMonitor() {
   Reset();
 }
 
 void DownloadRateMonitor::Start(
-    const base::Closure& canplaythrough_cb, int media_bitrate) {
+    const base::Closure& canplaythrough_cb, int media_bitrate,
+    bool streaming, bool local_source) {
   canplaythrough_cb_ = canplaythrough_cb;
+  streaming_ = streaming;
+  local_source_ = local_source;
   stopped_ = false;
   bitrate_ = media_bitrate;
   current_sample_.Reset();
   buffered_bytes_ = 0;
 
   NotifyCanPlayThroughIfNeeded();
 }
 
 void DownloadRateMonitor::SetBufferedBytes(
     int64 buffered_bytes, const base::Time& timestamp) {
@@ skipping 44 matching lines @@
 }
 
 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;
-  loaded_ = false;
+  local_source_ = false;
   bitrate_ = 0;
   stopped_ = true;
+  streaming_ = 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 36 matching lines @@
 }
 
 bool DownloadRateMonitor::ShouldNotifyCanPlayThrough() {
   if (stopped_)
     return false;
 
   // Only notify CanPlayThrough once for now.
   if (has_notified_can_play_through_)
     return false;
 
-  // If the media is from a local file (|loaded_|) or if all bytes are
-  // buffered, fire CanPlayThrough.
-  if (loaded_ || buffered_bytes_ == total_bytes_)
+  // 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;
 
-  // Cannot approximate when the media can play through if bitrate is unknown.
+  // If all bytes are buffered, fire CanPlayThrough.
+  if (buffered_bytes_ == total_bytes_)
+    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 false;
+    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
@@ skipping 21 matching lines @@
 }
 
 void DownloadRateMonitor::NotifyCanPlayThroughIfNeeded() {
   if (ShouldNotifyCanPlayThrough() && !canplaythrough_cb_.is_null()) {
     canplaythrough_cb_.Run();
     has_notified_can_play_through_ = true;
   }
 }
 
 }  // namespace media