make multibuffer work with layout tests

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 "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"
 
@@ skipping 144 matching lines @@
         FROM_HERE,
         base::Bind(&MultiBufferReader::Call, weak_factory_.GetWeakPtr(),
                    base::ResetAndReturn(&cb_)));
   }
 }
 
 void MultiBufferReader::Call(const base::Closure& cb) const {
   cb.Run();
 }
 
+void MultiBufferReader::UpdateEnd(MultiBufferBlockId p) {
+  auto i = multibuffer_->map().find(p - 1);
+  if (i != multibuffer_->map().end() && i->second->end_of_stream()) {
+    // This is an upper limit because the last-to-one block is allowed
+    // to be smaller than the rest of the blocks.
+    int64_t size_upper_limit = static_cast<int64_t>(p)
+                               << multibuffer_->block_size_shift();
+    end_ = std::min(end_, size_upper_limit);
+  }
+}
+
 void MultiBufferReader::NotifyAvailableRange(
     const Interval<MultiBufferBlockId>& range) {
   // Update end_ if we can.
   if (range.end > range.begin) {
-    auto i = multibuffer_->map().find(range.end - 1);
-    DCHECK(i != multibuffer_->map().end());
-    if (i->second->end_of_stream()) {
-      // This is an upper limit because the last-to-one block is allowed
-      // to be smaller than the rest of the blocks.
-      int64_t size_upper_limit = static_cast<int64_t>(range.end)
-                                 << multibuffer_->block_size_shift();
-      end_ = std::min(end_, size_upper_limit);
-    }
+    UpdateEnd(range.end);
   }
   UpdateInternalState();
   if (!progress_callback_.is_null()) {
     // We redirect the call through a weak pointer to ourselves to guarantee
     // there are no callbacks from us after we've been destroyed.
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&MultiBufferReader::Call, weak_factory_.GetWeakPtr(),
                    base::Bind(progress_callback_,
                               static_cast<int64_t>(range.begin)
                                   << multibuffer_->block_size_shift(),
                               static_cast<int64_t>(range.end)
                                   << multibuffer_->block_size_shift())));
     // We may be destroyed, do not touch |this|.
   }
 }
 
 void MultiBufferReader::UpdateInternalState() {
   int64_t effective_preload = loading_ ? preload_high_ : preload_low_;
 
   loading_ = false;
   if (preload_pos_ == -1) {
     preload_pos_ = block(pos_);
     DCHECK_GE(preload_pos_, 0);
   }
-  MultiBuffer::BlockId max_preload = block_ceil(
-      std::min(end_, pos_ + std::max(effective_preload, current_wait_size_)));
 
   // Note that we might not have been added to the multibuffer,
   // removing ourselves is a no-op in that case.
   multibuffer_->RemoveReader(preload_pos_, this);
 
   // We explicitly allow preloading to go beyond the pinned region in the cache.
   // It only happens when we want to preload something into the disk cache.
   // Thus it is possible to have blocks between our current reading position
   // and preload_pos_ be unavailable. When we get a Seek() call (possibly
   // through TryRead()) we reset the preload_pos_ to the current reading
   // position, and preload_pos_ will become the first unavailable block after
   // our current reading position again.
   preload_pos_ = multibuffer_->FindNextUnavailable(preload_pos_);
+  UpdateEnd(preload_pos_);
   DCHECK_GE(preload_pos_, 0);
 
+  MultiBuffer::BlockId max_preload = block_ceil(
+      std::min(end_, pos_ + std::max(effective_preload, current_wait_size_)));
+
   DVLOG(3) << "UpdateInternalState"
            << " pp = " << preload_pos_
            << " block_ceil(end_) = " << block_ceil(end_) << " end_ = " << end_
            << " max_preload " << max_preload;
 
   if (preload_pos_ < block_ceil(end_)) {
     if (preload_pos_ < max_preload) {
       loading_ = true;
       multibuffer_->AddReader(preload_pos_, this);
     } else if (multibuffer_->Contains(preload_pos_ - 1)) {
       --preload_pos_;
       multibuffer_->AddReader(preload_pos_, this);
     }
   }
   CheckWait();
 }
 
 }  // namespace media