Use maximum capacity instead of a ratio of capacity for BufferedResourceLoader.

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 54 matching lines @@
 
 // A factory method to create BufferedResourceLoader using the read parameters.
 // This method can be overridden to inject mock BufferedResourceLoader object
 // for testing purpose.
 BufferedResourceLoader* BufferedDataSource::CreateResourceLoader(
     int64 first_byte_position, int64 last_byte_position) {
   DCHECK(MessageLoop::current() == render_loop_);
 
   BufferedResourceLoader::DeferStrategy strategy = preload_ == METADATA ?
       BufferedResourceLoader::kReadThenDefer :
-      BufferedResourceLoader::kThresholdDefer;
+      BufferedResourceLoader::kCapacityDefer;
 
   return new BufferedResourceLoader(url_,
                                     cors_mode_,
                                     first_byte_position,
                                     last_byte_position,
                                     strategy,
                                     bitrate_,
                                     playback_rate_,
                                     media_log_);
 }
@@ skipping 216 matching lines @@
   if (playback_rate != 0)
     media_has_played_ = true;
 
   playback_rate_ = playback_rate;
   loader_->SetPlaybackRate(playback_rate);
 
   if (!loader_->range_supported()) {
     // 200 responses end up not being reused to satisfy future range requests,
     // and we don't want to get too far ahead of the read-head (and thus require
     // a restart), so keep to the thresholds.
-    loader_->UpdateDeferStrategy(BufferedResourceLoader::kThresholdDefer);
+    loader_->UpdateDeferStrategy(BufferedResourceLoader::kCapacityDefer);
   } else if (media_has_played_ && playback_rate == 0) {
     // 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 (the loader will
-    // fall back to kThresholdDefer if it knows the current response won't be
+    // fall back to kCapacityDefer if it knows the current response won't be
     // useful from the cache in the future).
     loader_->UpdateDeferStrategy(BufferedResourceLoader::kNeverDefer);
   } else {
     // If media is currently playing or the page indicated preload=auto,
     // use threshold strategy to enable/disable deferring when the buffer
     // is full/depleted.
-    loader_->UpdateDeferStrategy(BufferedResourceLoader::kThresholdDefer);
+    loader_->UpdateDeferStrategy(BufferedResourceLoader::kCapacityDefer);
   }
 }
 
 void BufferedDataSource::SetBitrateTask(int bitrate) {
   DCHECK(MessageLoop::current() == render_loop_);
   DCHECK(loader_.get());
 
   bitrate_ = bitrate;
   loader_->SetBitrate(bitrate);
 }
@@ skipping 274 matching lines @@
     return;
 
   if (total_bytes_ != kPositionNotSpecified)
     host()->SetTotalBytes(total_bytes_);
   int64 start = loader_->first_byte_position();
   if (buffered_bytes_ > start)
     host()->AddBufferedByteRange(start, buffered_bytes_);
 }
 
 }  // namespace webkit_media