Media: Delete Pause-To-Buffer.

media/blink/multibuffer_data_source.cc

 // Copyright 2013 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 "media/blink/multibuffer_data_source.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 104 matching lines @@
     : cors_mode_(cors_mode),
       total_bytes_(kPositionNotSpecified),
       streaming_(false),
       loading_(false),
       failed_(false),
       render_task_runner_(task_runner),
       url_index_(url_index),
       frame_(frame),
       stop_signal_received_(false),
       media_has_played_(false),
-      buffering_strategy_(BUFFERING_STRATEGY_NORMAL),
       single_origin_(true),
       cancel_on_defer_(false),
       preload_(AUTO),
       bitrate_(0),
       playback_rate_(0.0),
       media_log_(media_log),
       host_(host),
       downloading_cb_(downloading_cb),
       weak_factory_(this) {
   weak_ptr_ = weak_factory_.GetWeakPtr();
@@ skipping 106 matching lines @@
   }
 }
 
 void MultibufferDataSource::SetPreload(Preload preload) {
   DVLOG(1) << __func__ << "(" << preload << ")";
   DCHECK(render_task_runner_->BelongsToCurrentThread());
   preload_ = preload;
   UpdateBufferSizes();
 }
 
-void MultibufferDataSource::SetBufferingStrategy(
-    BufferingStrategy buffering_strategy) {
-  DCHECK(render_task_runner_->BelongsToCurrentThread());
-  buffering_strategy_ = buffering_strategy;
-  UpdateBufferSizes();
-}
-
 bool MultibufferDataSource::HasSingleOrigin() {
   DCHECK(render_task_runner_->BelongsToCurrentThread());
   // Before initialization completes there is no risk of leaking data. Callers
   // are required to order checks such that this isn't a race.
   return single_origin_;
 }
 
 bool MultibufferDataSource::DidPassCORSAccessCheck() const {
   if (cors_mode_ == UrlData::CORS_UNSPECIFIED)
     return false;
@@ skipping 304 matching lines @@
     uint64_t pos = reader_->Tell();
     ProgressCallback(pos, pos + available);
   }
 }
 
 void MultibufferDataSource::UpdateBufferSizes() {
   DVLOG(1) << __func__;
   if (!reader_)
     return;
 
-  if (!assume_fully_buffered()) {
-    // If the playback has started and the strategy is aggressive, then try to
-    // load as much as possible, assuming that the file is cacheable. (If not,
-    // why bother?)
-    bool aggressive = (buffering_strategy_ == BUFFERING_STRATEGY_AGGRESSIVE);
-    if (media_has_played_ && aggressive && url_data_ &&
-        url_data_->range_supported() && url_data_->cacheable()) {
-      reader_->SetPreload(1LL << 40, 1LL << 40);  // 1 Tb
-      return;
-    }
-  }
-
   // Use a default bit rate if unknown and clamp to prevent overflow.
   int64_t bitrate = clamp<int64_t>(bitrate_, 0, kMaxBitrate);
   if (bitrate == 0)
     bitrate = kDefaultBitrate;
 
   // Only scale the buffer window for playback rates greater than 1.0 in
   // magnitude and clamp to prevent overflow.
   double playback_rate = playback_rate_;
 
   playback_rate = std::max(playback_rate, 1.0);
@@ skipping 29 matching lines @@
   reader_->SetPinRange(pin_backward, pin_forward);
 
   if (preload_ == METADATA) {
     reader_->SetPreload(0, 0);
   } else {
     reader_->SetPreload(preload_high, preload);
   }
 }
 
 }  // namespace media