Tweak multibuffer buffering strategy.

media/blink/multibuffer_unittest.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 <stdint.h>
 
 #include <deque>
 #include <string>
 #include <vector>
@@ skipping 248 matching lines @@
 };
 
 TEST_F(MultiBufferTest, ReadAll) {
   multibuffer_.SetMaxWriters(1);
   size_t pos = 0;
   size_t end = 10000;
   multibuffer_.SetFileSize(10000);
   multibuffer_.SetMustReadWholeFile(true);
   MultiBufferReader reader(&multibuffer_, pos, end,
                            base::Callback<void(int64_t, int64_t)>());
-  reader.SetMaxBuffer(2000, 5000);
+  reader.SetPinRange(2000, 5000);
   reader.SetPreload(1000, 1000);
   while (pos < end) {
     unsigned char buffer[27];
     buffer[17] = 17;
     size_t to_read = std::min<size_t>(end - pos, 17);
     int64_t bytes_read = reader.TryRead(buffer, to_read);
     if (bytes_read) {
       EXPECT_EQ(buffer[17], 17);
       for (int64_t i = 0; i < bytes_read; i++) {
         uint8_t expected = static_cast<uint8_t>((pos * 15485863) >> 16);
         EXPECT_EQ(expected, buffer[i]) << " pos = " << pos;
         pos++;
       }
     } else {
       Advance();
     }
   }
 }
 
 TEST_F(MultiBufferTest, ReadAllAdvanceFirst) {
   multibuffer_.SetMaxWriters(1);
   size_t pos = 0;
   size_t end = 10000;
   multibuffer_.SetFileSize(10000);
   multibuffer_.SetMustReadWholeFile(true);
   MultiBufferReader reader(&multibuffer_, pos, end,
                            base::Callback<void(int64_t, int64_t)>());
-  reader.SetMaxBuffer(2000, 5000);
+  reader.SetPinRange(2000, 5000);
   reader.SetPreload(1000, 1000);
   while (pos < end) {
     unsigned char buffer[27];
     buffer[17] = 17;
     size_t to_read = std::min<size_t>(end - pos, 17);
     while (AdvanceAll()) {
     }
     int64_t bytes = reader.TryRead(buffer, to_read);
     EXPECT_GT(bytes, 0);
     EXPECT_EQ(buffer[17], 17);
     for (int64_t i = 0; i < bytes; i++) {
       uint8_t expected = static_cast<uint8_t>((pos * 15485863) >> 16);
       EXPECT_EQ(expected, buffer[i]) << " pos = " << pos;
       pos++;
     }
   }
 }
 
 // Checks that if the data provider provides too much data after we told it
 // to defer, we kill it.
 TEST_F(MultiBufferTest, ReadAllAdvanceFirst_NeverDefer) {
   multibuffer_.SetMaxWriters(1);
   size_t pos = 0;
   size_t end = 10000;
   multibuffer_.SetFileSize(10000);
   multibuffer_.SetMaxBlocksAfterDefer(-10000);
   multibuffer_.SetRangeSupported(true);
   MultiBufferReader reader(&multibuffer_, pos, end,
                            base::Callback<void(int64_t, int64_t)>());
-  reader.SetMaxBuffer(2000, 5000);
+  reader.SetPinRange(2000, 5000);
   reader.SetPreload(1000, 1000);
   while (pos < end) {
     unsigned char buffer[27];
     buffer[17] = 17;
     size_t to_read = std::min<size_t>(end - pos, 17);
     while (AdvanceAll()) {
     }
     int64_t bytes = reader.TryRead(buffer, to_read);
     EXPECT_GT(bytes, 0);
     EXPECT_EQ(buffer[17], 17);
@@ skipping 10 matching lines @@
 // ranges, so we don't destroy it no matter how much data it provides.
 TEST_F(MultiBufferTest, ReadAllAdvanceFirst_NeverDefer2) {
   multibuffer_.SetMaxWriters(1);
   size_t pos = 0;
   size_t end = 10000;
   multibuffer_.SetFileSize(10000);
   multibuffer_.SetMustReadWholeFile(true);
   multibuffer_.SetMaxBlocksAfterDefer(-10000);
   MultiBufferReader reader(&multibuffer_, pos, end,
                            base::Callback<void(int64_t, int64_t)>());
-  reader.SetMaxBuffer(2000, 5000);
+  reader.SetPinRange(2000, 5000);
   reader.SetPreload(1000, 1000);
   while (pos < end) {
     unsigned char buffer[27];
     buffer[17] = 17;
     size_t to_read = std::min<size_t>(end - pos, 17);
     while (AdvanceAll()) {
     }
     int64_t bytes = reader.TryRead(buffer, to_read);
     EXPECT_GT(bytes, 0);
     EXPECT_EQ(buffer[17], 17);
@@ skipping 86 matching lines @@
              TestRandom* rnd)
       : pos_(0),
         end_(end),
         max_read_size_(max_read_size),
         read_size_(0),
         rnd_(rnd),
         reader_(multibuffer,
                 pos_,
                 end_,
                 base::Callback<void(int64_t, int64_t)>()) {
-    reader_.SetMaxBuffer(2000, 5000);
+    reader_.SetPinRange(2000, 5000);
     reader_.SetPreload(1000, 1000);
   }
 
   bool Read() {
     if (read_size_ == 0)
       return true;
     unsigned char buffer[4096];
     CHECK_LE(read_size_, static_cast<int64_t>(sizeof(buffer)));
     CHECK_EQ(pos_, reader_.Tell());
     int64_t bytes_read = reader_.TryRead(buffer, read_size_);
@@ skipping 90 matching lines @@
     multibuffer_.CheckLRUState();
   }
   multibuffer_.CheckPresentState();
   while (!read_helpers.empty()) {
     delete read_helpers.back();
     read_helpers.pop_back();
   }
 }
 
 }  // namespace media