Move DataSource::SetPreload() to BufferedDataSource.

webkit/media/buffered_data_source.cc

 // Copyright (c) 2012 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/media/buffered_data_source.h"
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "media/base/media_log.h"
 #include "net/base/net_errors.h"
@@ skipping 24 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::AUTO),
+      preload_(AUTO),
       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
@@ skipping 45 matching lines @@
   // the full range of the resource to obtain the instance size because
   // we won't be served HTTP headers.
   loader_.reset(CreateResourceLoader(kPositionNotSpecified,
                                      kPositionNotSpecified));
   loader_->Start(
       base::Bind(&BufferedDataSource::NonHttpInitialStartCallback, this),
       base::Bind(&BufferedDataSource::NetworkEventCallback, this),
       frame_);
 }
 
+void BufferedDataSource::SetPreload(Preload preload) {
+  DCHECK(MessageLoop::current() == render_loop_);
+  preload_ = preload;
+}
+
 bool BufferedDataSource::HasSingleOrigin() {
   DCHECK(MessageLoop::current() == render_loop_);
   return loader_.get() ? loader_->HasSingleOrigin() : true;
 }
 
 void BufferedDataSource::Abort() {
   DCHECK(MessageLoop::current() == render_loop_);
 
   CleanupTask();
   frame_ = NULL;
@@ skipping 11 matching lines @@
 
   render_loop_->PostTask(FROM_HERE,
       base::Bind(&BufferedDataSource::CleanupTask, this));
 }
 
 void BufferedDataSource::SetPlaybackRate(float playback_rate) {
   render_loop_->PostTask(FROM_HERE, base::Bind(
       &BufferedDataSource::SetPlaybackRateTask, this, playback_rate));
 }
 
-void BufferedDataSource::SetPreload(media::Preload preload) {
-  render_loop_->PostTask(FROM_HERE, base::Bind(
-      &BufferedDataSource::SetPreloadTask, this, preload));
-}
-
 void BufferedDataSource::SetBitrate(int bitrate) {
   render_loop_->PostTask(FROM_HERE, base::Bind(
       &BufferedDataSource::SetBitrateTask, this, bitrate));
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // media::DataSource implementation.
 void BufferedDataSource::Read(
     int64 position, size_t size, uint8* data,
     const media::DataSource::ReadCB& read_cb) {
@@ skipping 112 matching lines @@
   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 page indicated preload=metadata, then load exactly what is needed
   // needed for starting playback.
-  if (!media_has_played_ && preload_ == media::METADATA)
+  if (!media_has_played_ && preload_ == METADATA)
     return BufferedResourceLoader::kReadThenDefer;
 
   // 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;
 
   // If media is currently playing or the page indicated preload=auto,
   // use threshold strategy to enable/disable deferring when the buffer
   // is full/depleted.
@@ skipping 280 matching lines @@
 
   if (!host())
     return;
 
   if (total_bytes_ != kPositionNotSpecified)
     host()->SetTotalBytes(total_bytes_);
   host()->SetBufferedBytes(buffered_bytes_);
 }
 
 }  // namespace webkit_media