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 124 matching lines @@
   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;
   bitrate_ = 0;
   stopped_ = true;
+  media_stream_ = false;
+  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 loaded or streaming.
+  //
+  // NOTE: It is a requirement for CanPlayThrough to fire immediately if the
+  // source is |loaded_|, but the choice to fire the event for any streaming
+  // element is an optimistic design decision that may need to be tweaked. The
+  // only streaming element that *must* fire CanPlayThrough immediately is a
+  // media_stream_ whose source is local, such as from a webcam.
+  if (loaded_ || streaming_ || media_stream_)

[wjia(left Chromium), 2011/11/22 23:01:17]

should it be: if (loaded_ || !streaming_ || media_stream_) ?

For streaming except media_stream, download control is needed, right?

[vrk (LEFT CHROMIUM), 2011/11/23 21:29:45]

So to be clear, the DownloadRateMonitor does not do any download "controlling."
Its purpose is to decide when CanPlayThrough should be fired. To make this
decision, it needs a variety of input, such as some information about the media
itself (loaded_, total_bytes_, etc) and it does some estimation of the rate of
download by watching calls to SetBufferedBytes.

With that: For streaming outside of media_stream, I intentionally changed the
code to fire CanPlayThrough immediately as a design decision. With a stream,
you're either going to have a fast enough connection to keep up, or you won't.
Instead of trying to estimate whether you can keep up (which can be inaccurate
and has time overhead), might as well just fire the event and try playback. (As
I mention in the comment, this may need tweaking.)

     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