Implementing preload=metadata for video

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 "net/base/net_errors.h"
 #include "webkit/glue/media/web_data_source_factory.h"
 #include "webkit/glue/webkit_glue.h"
@@ skipping 46 matching lines @@
       read_position_(0),
       read_size_(0),
       read_buffer_(NULL),
       read_attempts_(0),
       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::PRELOAD_METADATA),
       using_range_request_(true) {
 }
 
 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(
@@ skipping 70 matching lines @@
   render_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &BufferedDataSource::CleanupTask));
 }
 
 void BufferedDataSource::SetPlaybackRate(float playback_rate) {
   render_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &BufferedDataSource::SetPlaybackRateTask,
                         playback_rate));
 }
 
+void BufferedDataSource::SetPreload(media::Preload preload) {
+  render_loop_->PostTask(FROM_HERE,
+      NewRunnableMethod(this, &BufferedDataSource::SetPreloadTask,
+                        preload));
+}
+
 /////////////////////////////////////////////////////////////////////////////
 // media::DataSource implementation.
 void BufferedDataSource::Read(int64 position, size_t size, uint8* data,
                               media::DataSource::ReadCallback* read_callback) {
   DCHECK(read_callback);
 
   {
     base::AutoLock auto_lock(lock_);
     DCHECK(!read_callback_.get());
 
@@ skipping 142 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);
-  loader_->SetAllowDefer(!media_is_paused_);
+  BufferedResourceLoader::DeferStrategy strategy = ChooseDeferStrategy();
+  loader_->UpdateDeferStrategy(strategy);
   loader_->Start(
       NewCallback(this, &BufferedDataSource::PartialReadStartCallback),
       NewCallback(this, &BufferedDataSource::NetworkEventCallback),
       frame_);
 }
 
 void BufferedDataSource::WatchDogTask() {
   DCHECK(MessageLoop::current() == render_loop_);
   if (stopped_on_render_loop_)
     return;
@@ skipping 15 matching lines @@
   if (read_attempts_ >= kReadTrials)
     return;
 
   ++read_attempts_;
   read_submitted_time_ = base::Time::Now();
 
   // Stops the current loader and creates a new resource loader and
   // retry the request.
   loader_->Stop();
   loader_ = CreateResourceLoader(read_position_, kPositionNotSpecified);
-  loader_->SetAllowDefer(!media_is_paused_);
+  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());
 
   bool previously_paused = media_is_paused_;
   media_is_paused_ = (playback_rate == 0.0);
 
-  // Disallow deferring data when we are pausing, allow deferring data
-  // when we resume playing.
-  if (previously_paused && !media_is_paused_) {
-    loader_->SetAllowDefer(true);
-  } else if (!previously_paused && media_is_paused_) {
-    loader_->SetAllowDefer(false);
+  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;
+}
+
+BufferedResourceLoader::DeferStrategy BufferedDataSource::ChooseDeferStrategy() {
+  // If the user indicates preload=metadata, then just load exactly
+  // what is needed for starting the pipeline and prerolling frames.
+  if (preload_ == media::PRELOAD_METADATA && !media_has_played_)
+    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::PRELOAD_AUTO || media_has_played_)) {
+    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.
+  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
   // to write to.
@@ skipping 269 matching lines @@
 
   if (streaming_) {
     filter_host->SetStreaming(true);
   } else {
     filter_host->SetTotalBytes(total_bytes_);
     filter_host->SetBufferedBytes(buffered_bytes_);
   }
 }
 
 }  // namespace webkit_glue