Fix multibuffer crashing bug

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),
+      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_->PinRange(block(pos_ - max_buffer_backward_),
-                         block_ceil(pos_ + max_buffer_forward_), -1);
   multibuffer_->CleanupWriters(preload_pos_);
 }
 
 void MultiBufferReader::Seek(int64_t pos) {
   DCHECK_GE(pos, 0);
   if (pos == pos_)
     return;
-  // Use a rangemap to compute the diff in pinning.
-  IntervalMap<MultiBuffer::BlockId, int32_t> tmp;
-  tmp.IncrementInterval(block(pos_ - max_buffer_backward_),

[liberato (no reviews please), 2016/03/02 21:45:46]

x -= y;
x += y;
// success! :)

[hubbe, 2016/03/02 22:10:15]

que?

[liberato (no reviews please), 2016/03/02 22:13:33]

|pos_| vs |pos| .  maybe time for me to increase the font size.  :)

[hubbe, 2016/03/02 22:22:54]

Acknowledged.

-                        block_ceil(pos_ + max_buffer_forward_), -1);
-  tmp.IncrementInterval(block(pos - max_buffer_backward_),
-                        block_ceil(pos + max_buffer_forward_), 1);
-
-  multibuffer_->PinRanges(tmp);
+  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) {
   // Safe, because we know this doesn't actually prune the cache right away.
   multibuffer_->IncrementMaxSize(
       -block_ceil(max_buffer_forward_ + max_buffer_backward_));
-  // Use a rangemap to compute the diff in pinning.
-  IntervalMap<MultiBuffer::BlockId, int32_t> tmp;
-  tmp.IncrementInterval(block(pos_ - max_buffer_backward_),
-                        block_ceil(pos_ + max_buffer_forward_), -1);
   max_buffer_backward_ = backward;
   max_buffer_forward_ = forward;
-  tmp.IncrementInterval(block(pos_ - max_buffer_backward_),
-                        block_ceil(pos_ + max_buffer_forward_), 1);
-  multibuffer_->PinRanges(tmp);
+  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_);
@@ skipping 146 matching lines @@
       loading_ = true;
       multibuffer_->AddReader(preload_pos_, this);
     } else if (multibuffer_->Contains(preload_pos_ - 1)) {
       --preload_pos_;
       multibuffer_->AddReader(preload_pos_, this);
     }
   }
   CheckWait();
 }
 
+void MultiBufferReader::PinRange(MultiBuffer::BlockId begin,
+                                 MultiBuffer::BlockId end) {
+  // 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