Numerous fixes to audio/video buffered resource loading.

webkit/glue/media/buffered_data_source.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 "webkit/glue/media/buffered_data_source.h"
 
 #include "base/bind.h"
 #include "media/base/filter_host.h"
 #include "media/base/media_log.h"
 #include "net/base/net_errors.h"
@@ skipping 43 matching lines @@
       read_position_(0),
       read_size_(0),
       read_buffer_(NULL),
       intermediate_read_buffer_(new uint8[kInitialReadBufferSize]),
       intermediate_read_buffer_size_(kInitialReadBufferSize),
       render_loop_(render_loop),
       stop_signal_received_(false),
       stopped_on_render_loop_(false),
       media_is_paused_(true),
       media_has_played_(false),
-      preload_(media::METADATA),
+      preload_(media::AUTO),
       using_range_request_(true),
       cache_miss_retries_left_(kNumCacheMissRetries),
+      bitrate_(0),
+      playback_rate_(0.0),
       media_log_(media_log) {
 }
 
 BufferedDataSource::~BufferedDataSource() {}
 
 // A factory method to create BufferedResourceLoader using the read parameters.
 // This method can be overrided to inject mock BufferedResourceLoader object
 // for testing purpose.
 BufferedResourceLoader* BufferedDataSource::CreateResourceLoader(
     int64 first_byte_position, int64 last_byte_position) {
   DCHECK(MessageLoop::current() == render_loop_);
 
   return new BufferedResourceLoader(url_,
                                     first_byte_position,
                                     last_byte_position,
+                                    ChooseDeferStrategy(),
+                                    bitrate_,
+                                    playback_rate_,
                                     media_log_);
 }
 
 void BufferedDataSource::set_host(media::FilterHost* host) {
   DataSource::set_host(host);
 
   if (loader_.get()) {
     base::AutoLock auto_lock(lock_);
     UpdateHostState_Locked();
   }
@@ skipping 205 matching lines @@
     return;
 
   {
     // If there's no outstanding read then return early.
     base::AutoLock auto_lock(lock_);
     if (read_callback_.is_null())
       return;
   }
 
   loader_ = CreateResourceLoader(read_position_, kPositionNotSpecified);
-  BufferedResourceLoader::DeferStrategy strategy = ChooseDeferStrategy();
-  loader_->UpdateDeferStrategy(strategy);
   loader_->Start(
       NewCallback(this, &BufferedDataSource::PartialReadStartCallback),
       base::Bind(&BufferedDataSource::NetworkEventCallback, this),
       frame_);
 }
 
 void BufferedDataSource::SetPlaybackRateTask(float playback_rate) {
   DCHECK(MessageLoop::current() == render_loop_);
   DCHECK(loader_.get());
 
+  playback_rate_ = playback_rate;
   loader_->SetPlaybackRate(playback_rate);
 
   bool previously_paused = media_is_paused_;
   media_is_paused_ = (playback_rate == 0.0);
 
   if (!media_has_played_ && previously_paused && !media_is_paused_)
     media_has_played_ = true;
 
   BufferedResourceLoader::DeferStrategy strategy = ChooseDeferStrategy();
   loader_->UpdateDeferStrategy(strategy);
 }
 
 void BufferedDataSource::SetPreloadTask(media::Preload preload) {
   DCHECK(MessageLoop::current() == render_loop_);
   preload_ = preload;
 }
 
 void BufferedDataSource::SetBitrateTask(int bitrate) {
   DCHECK(MessageLoop::current() == render_loop_);
   DCHECK(loader_.get());
+
+  bitrate_ = bitrate;
   loader_->SetBitrate(bitrate);
 }
 
 BufferedResourceLoader::DeferStrategy
 BufferedDataSource::ChooseDeferStrategy() {
   DCHECK(MessageLoop::current() == render_loop_);
-  // If the user indicates preload=metadata, then just load exactly
-  // what is needed for starting the pipeline and prerolling frames.
-  if (preload_ == media::METADATA && !media_has_played_)
+  // If the page indicated preload=metadata, then load exactly what is needed
+  // needed for starting playback.
+  if (!media_has_played_ && preload_ == media::METADATA)
     return BufferedResourceLoader::kReadThenDefer;
 
-  // In general, we want to try to buffer the entire video when the video
-  // is paused. But we don't want to do this if the video hasn't played yet
-  // and preload!=auto.
-  if (media_is_paused_ &&
-      (preload_ == media::AUTO || media_has_played_)) {
+  // If the playback has started (at which point the preload value is ignored)
+  // and we're paused, then try to load as much as possible.
+  if (media_has_played_ && media_is_paused_)
     return BufferedResourceLoader::kNeverDefer;
-  }
 
-  // When the video is playing, regardless of preload state, we buffer up
-  // to a hard limit and enable/disable deferring when the buffer is
-  // depleted/full.
+  // If playback hasn't started or the page indicated preload=auto,

[vrk (LEFT CHROMIUM), 2011/10/11 18:23:21]

"If playback hasn't started" should be "if video is in the middle of playback"

[scherkus (not reviewing), 2011/10/11 20:13:19]

Done.

+  // buffer enable/disable deferring when the buffer is full/depleted.

[vrk (LEFT CHROMIUM), 2011/10/11 18:23:21]

If playback hasn't started *and* the page indicated preload=auto, the logic has
changed from (before) aggressively download as much of the video as possible to
(in this CL) download only up to a threshold.

Why the change? The spec is shady in the whole preload area but it gives us
permission to load the entire resource
(http://www.w3.org/TR/html5/video.html#attr-media-preload)

Not necessarily opposed, but curious!

[scherkus (not reviewing), 2011/10/11 20:13:19]

kNeverDefer isn't preferable in all cases.

On a video larger than the media cache (i.e., ~50MB), or for a page with many
files, using kNeverDefer will "download" the content hoping that it'll get
cached.

When we actually go to play the content there's an increased risk we'll have an
immediate cache miss and have to re-fetch the media again negating any benefits
from using kNeverDefer.

   return BufferedResourceLoader::kThresholdDefer;
 }
 
 // This method is the place where actual read happens, |loader_| must be valid
 // prior to make this method call.
 void BufferedDataSource::ReadInternal() {
   DCHECK(MessageLoop::current() == render_loop_);
   DCHECK(loader_);
 
   // First we prepare the intermediate read buffer for BufferedResourceLoader
@@ skipping 40 matching lines @@
 
 /////////////////////////////////////////////////////////////////////////////
 // BufferedResourceLoader callback methods.
 void BufferedDataSource::HttpInitialStartCallback(int error) {
   DCHECK(MessageLoop::current() == render_loop_);
   DCHECK(loader_.get());
 
   int64 instance_size = loader_->instance_size();
   bool success = error == net::OK;
 
-
   bool initialize_cb_is_null = false;
   {
     base::AutoLock auto_lock(lock_);
     initialize_cb_is_null = initialize_cb_.is_null();
   }
   if (initialize_cb_is_null) {
     loader_->Stop();
     return;
   }
 
@@ skipping 229 matching lines @@
 
   if (streaming_) {
     filter_host->SetStreaming(true);
   } else {
     filter_host->SetTotalBytes(total_bytes_);
     filter_host->SetBufferedBytes(buffered_bytes_);
   }
 }
 
 }  // namespace webkit_glue