Tweak multibuffer buffering strategy.

media/blink/multibuffer_reader.h

 // Copyright 2015 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.
 
 #ifndef MEDIA_BLINK_MULTIBUFFER_READER_H_
 #define MEDIA_BLINK_MULTIBUFFER_READER_H_
 
 #include <stdint.h>
 
 #include <limits>
@@ skipping 60 matching lines @@
   // stop until we fall below preload_low bytes. Note that preload can be
   // set higher than max_buffer_forward, but the result is usually that
   // some blocks will be freed between the current position and the preload
   // position.
   void SetPreload(int64_t preload_high, int64_t preload_low);
 
   // Change how much data we pin to the cache.
   // The range [current_position - backward ... current_position + forward)
   // will be locked in the cache. Calling Wait() or TryRead() with values
   // larger than |forward| is not supported.
-  void SetMaxBuffer(int64_t backward, int64_t forward);
+  void SetPinRange(int64_t backward, int64_t forward);
+
+  // Set how much memory usage we target. This memory is added to the global
+  // LRU and shared between all multibuffers. We may end up using more memory
+  // if no memory can be freed due to pinning.
+  void SetMaxBuffer(int64_t bytes);
 
   // Returns true if we are currently loading data.
   bool IsLoading() const;
 
   // Reader implementation.
   void NotifyAvailableRange(const Interval<MultiBufferBlockId>& range) override;
 
   // Getters
   int64_t preload_high() const { return preload_high_; }
   int64_t preload_low() const { return preload_low_; }
@@ skipping 37 matching lines @@
 
   // Defer reading once we have this much data.
   int64_t preload_high_;
   // Stop deferring once we have this much data.
   int64_t preload_low_;
 
   // Pin this much data in the cache from the current position.
   int64_t max_buffer_forward_;
   int64_t max_buffer_backward_;
 
+  // The amount of buffer we've added to the global LRU.
+  int64_t current_buffer_size_;
+
   // Currently pinned range.
   Interval<MultiBuffer::BlockId> pinned_range_;
 
   // Current position in bytes.
   int64_t pos_;
 
   // [block(pos_)..preload_pos_) are known to be in the cache.
   // preload_pos_ is only allowed to point to a filled
   // cache position if it is equal to end_ or pos_+preload_.
   // This is a pointer to a slot in the cache, so the unit is
   // blocks.
   MultiBufferBlockId preload_pos_;
 
   // True if we've requested data from the cache by calling WaitFor().
   bool loading_;
 
   // When Available() > current_wait_size_ we call cb_.
   int64_t current_wait_size_;
   base::Closure cb_;
 
   // Progress callback.
   base::Callback<void(int64_t, int64_t)> progress_callback_;
 
   base::WeakPtrFactory<MultiBufferReader> weak_factory_;
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BLINK_MULTIBUFFER_READER_H_