Tweak multibuffer buffering strategy.

media/blink/multibuffer_reader.cc

 // 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.
 
 #include <stddef.h>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/message_loop/message_loop.h"
 #include "media/blink/multibuffer_reader.h"
 #include "net/base/net_errors.h"
 
 namespace media {
 
 MultiBufferReader::MultiBufferReader(
     MultiBuffer* multibuffer,
     int64_t start,
     int64_t end,
     const base::Callback<void(int64_t, int64_t)>& progress_callback)
     : multibuffer_(multibuffer),
       // If end is -1, we use a very large (but still supported) value instead.
       end_(end == -1LL ? (1LL << (multibuffer->block_size_shift() + 30)) : end),
       preload_high_(0),
       preload_low_(0),
       max_buffer_forward_(0),
       max_buffer_backward_(0),
+      current_buffer_size_(0),
       pinned_range_(0, 0),
       pos_(start),
       preload_pos_(-1),
       loading_(true),
       current_wait_size_(0),
       progress_callback_(progress_callback),
       weak_factory_(this) {
   DCHECK_GE(start, 0);
   DCHECK_GE(end_, 0);
 }
 
 MultiBufferReader::~MultiBufferReader() {
   PinRange(0, 0);
   multibuffer_->RemoveReader(preload_pos_, this);
-  multibuffer_->IncrementMaxSize(
-      -block_ceil(max_buffer_forward_ + max_buffer_backward_));
+  multibuffer_->IncrementMaxSize(-current_buffer_size_);
   multibuffer_->CleanupWriters(preload_pos_);
 }
 
 void MultiBufferReader::Seek(int64_t pos) {
   DCHECK_GE(pos, 0);
   if (pos == pos_)
     return;
   PinRange(block(pos - max_buffer_backward_),
            block_ceil(pos + max_buffer_forward_));
 
   multibuffer_->RemoveReader(preload_pos_, this);
   MultiBufferBlockId old_preload_pos = preload_pos_;
   preload_pos_ = block(pos);
   pos_ = pos;
   UpdateInternalState();
   multibuffer_->CleanupWriters(old_preload_pos);
 }
 
-void MultiBufferReader::SetMaxBuffer(int64_t backward, int64_t forward) {
+void MultiBufferReader::SetMaxBuffer(int64_t buffer_size) {
   // Safe, because we know this doesn't actually prune the cache right away.
-  multibuffer_->IncrementMaxSize(
-      -block_ceil(max_buffer_forward_ + max_buffer_backward_));
+  int64_t new_buffer_size = block_ceil(buffer_size);
+  ;

[DaleCurtis, 2016/05/04 21:39:32]

extra ;

[hubbe, 2016/05/04 21:55:06]

Done.

+  multibuffer_->IncrementMaxSize(new_buffer_size - current_buffer_size_);

[DaleCurtis, 2016/05/04 21:39:32]

dcheck cur <= new_buffer_size ?

[hubbe, 2016/05/04 21:55:06]

Decreasing the buffer size is allowed.
(As is calling IncrementMaxSize with a negative value.)

+  current_buffer_size_ = new_buffer_size;
+}
+
+void MultiBufferReader::SetPinRange(int64_t backward, int64_t forward) {
+  // Safe, because we know this doesn't actually prune the cache right away.
   max_buffer_backward_ = backward;
   max_buffer_forward_ = forward;
   PinRange(block(pos_ - max_buffer_backward_),
            block_ceil(pos_ + max_buffer_forward_));
-
-  multibuffer_->IncrementMaxSize(
-      block_ceil(max_buffer_forward_ + max_buffer_backward_));
 }
 
 int64_t MultiBufferReader::Available() const {
   int64_t unavailable_byte_pos =
       static_cast<int64_t>(multibuffer_->FindNextUnavailable(block(pos_)))
       << multibuffer_->block_size_shift();
   return std::max<int64_t>(0, unavailable_byte_pos - pos_);
 }
 
 int64_t MultiBufferReader::TryRead(uint8_t* data, int64_t len) {
@@ skipping 155 matching lines @@
   // Use a rangemap to compute the diff in pinning.
   IntervalMap<MultiBuffer::BlockId, int32_t> tmp;
   tmp.IncrementInterval(pinned_range_.begin, pinned_range_.end, -1);
   tmp.IncrementInterval(begin, end, 1);
   multibuffer_->PinRanges(tmp);
   pinned_range_.begin = begin;
   pinned_range_.end = end;
 }
 
 }  // namespace media