Merge 105121 - 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 "media/base/filter_host.h"
 #include "media/base/media_log.h"
 #include "net/base/net_errors.h"
 #include "webkit/glue/media/web_data_source_factory.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 55 matching lines @@
       NewRunnableMethod(this, &BufferedDataSource::SetPlaybackRateTask,
                         playback_rate));
 }
 
 void BufferedDataSource::SetPreload(media::Preload preload) {
   render_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &BufferedDataSource::SetPreloadTask,
                         preload));
 }
 
+void BufferedDataSource::SetBitrate(int bitrate) {
+  render_loop_->PostTask(FROM_HERE,
+      NewRunnableMethod(this, &BufferedDataSource::SetBitrateTask, bitrate));
+}
+
 /////////////////////////////////////////////////////////////////////////////
 // media::DataSource implementation.
 void BufferedDataSource::Read(int64 position, size_t size, uint8* data,
                               media::DataSource::ReadCallback* read_callback) {
   VLOG(1) << "Read: " << position << " offset, " << size << " bytes";
   DCHECK(read_callback);
 
   {
     base::AutoLock auto_lock(lock_);
     DCHECK(!read_callback_.get());
@@ skipping 130 matching lines @@
     return;
 
   {
     // If there's no outstanding read then return early.
     base::AutoLock auto_lock(lock_);
     if (!read_callback_.get())
       return;
   }
 
   loader_ = CreateResourceLoader(read_position_, kPositionNotSpecified);
-  BufferedResourceLoader::DeferStrategy strategy = ChooseDeferStrategy();
-  loader_->UpdateDeferStrategy(strategy);
   loader_->Start(
       NewCallback(this, &BufferedDataSource::PartialReadStartCallback),
       NewCallback(this, &BufferedDataSource::NetworkEventCallback),
       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 media is currently playing or the page indicated preload=auto,
+  // use threshold strategy to enable/disable deferring when the buffer
+  // is full/depleted.
   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 41 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