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));
+}
+
+BufferedResourceLoader::DeferStrategy
+    BufferedDataSource::ChooseDeferStrategy() {

[acolwell GONE FROM CHROMIUM, 2011/03/25 23:08:14]

Remove the indent. I looked at the style rules and they don't address this
directly. I consulted with Ami and he suggested removing the indent.

If you've seen examples elsewhere with the indent let me know.

[vrk (LEFT CHROMIUM), 2011/03/29 00:53:00]

Yeah, it looked weird to me, too; I just made it that way because the script
complained about >80 chars. Done!

+  // 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::ReadThenDefer;
+
+  // 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::NeverDefer;
+  }
+
+  // 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::ThresholdDefer;
+}
+
 /////////////////////////////////////////////////////////////////////////////
 // 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_->SetDeferStrategy(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_->SetDeferStrategy(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_->SetDeferStrategy(strategy);
+  loader_->UpdateDeferBehavior();

[acolwell GONE FROM CHROMIUM, 2011/03/25 23:08:14]

SetDeferStrategy() doesn't update the behavior? Why is an UpdateDeferBehavior()
call needed here? Is it because the previous calls happen before Start()? It
might be better to hide this difference in SetDeferStrategy() so that this
object doesn't have to worry about which situations require a
UpdateDeferBehavior() call.

[vrk (LEFT CHROMIUM), 2011/03/29 00:53:00]

Good idea, done!

+}
+
+void BufferedDataSource::SetPreloadTask(media::Preload preload) {
+  DCHECK(MessageLoop::current() == render_loop_);
+  preload_ = preload;
 }
 
 // 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