Use maximum capacity instead of a ratio of capacity for BufferedResourceLoader.

webkit/media/buffered_resource_loader_unittest.cc

 // Copyright (c) 2012 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 <algorithm>
 #include <string>
 
 #include "base/bind.h"
 #include "base/format_macros.h"
 #include "base/message_loop.h"
@@ skipping 69 matching lines @@
   }
 
   void Initialize(const char* url, int first_position, int last_position) {
     gurl_ = GURL(url);
     first_position_ = first_position;
     last_position_ = last_position;
 
     loader_.reset(new BufferedResourceLoader(
         gurl_, BufferedResourceLoader::kUnspecified,
         first_position_, last_position_,
-        BufferedResourceLoader::kThresholdDefer, 0, 0,
+        BufferedResourceLoader::kCapacityDefer, 0, 0,
         new media::MediaLog()));
 
     // |test_loader_| will be used when Start() is called.
     url_loader_ = new NiceMock<MockWebURLLoader>();
     loader_->test_loader_ = scoped_ptr<WebKit::WebURLLoader>(url_loader_);
   }
 
   void SetLoaderBuffer(int forward_capacity, int backward_capacity) {
     loader_->buffer_.set_forward_capacity(forward_capacity);
     loader_->buffer_.set_backward_capacity(backward_capacity);
@@ skipping 289 matching lines @@
                                   "%d-%d/%d", 1, 10, 1024)));
   response.setExpectedContentLength(10);
   response.setHTTPStatusCode(kHttpPartialContent);
   loader_->didReceiveResponse(url_loader_, response);
   StopWhenLoad();
 }
 
 // Tests the logic of sliding window for data buffering and reading.
 TEST_F(BufferedResourceLoaderTest, BufferAndRead) {
   Initialize(kHttpUrl, 10, 29);
-  loader_->UpdateDeferStrategy(BufferedResourceLoader::kThresholdDefer);
+  loader_->UpdateDeferStrategy(BufferedResourceLoader::kCapacityDefer);
   Start();
   PartialResponse(10, 29, 30);
 
   uint8 buffer[10];
   InSequence s;
 
   // Writes 10 bytes and read them back.
   WriteLoader(10, 10);
   EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 10));
   ReadLoader(10, 10, buffer);
@@ skipping 239 matching lines @@
   // Fulfill requested bytes, then deferring should be enabled again.
   EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingDeferred));
   EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 10));
   WriteLoader(60, 40);
 
   VerifyBuffer(buffer, 80, 10);
 
   StopWhenLoad();
 }
 
-// Tests the data buffering logic of ThresholdDefer strategy.
+// Tests the data buffering logic of kCapacityDefer strategy.
 TEST_F(BufferedResourceLoaderTest, ThresholdDeferStrategy) {
   Initialize(kHttpUrl, 10, 99);
   SetLoaderBuffer(10, 20);
   Start();
   PartialResponse(10, 99, 100);
 
   uint8 buffer[10];
   InSequence s;
 
-  // Write half of threshold: keep not deferring.
+  // Write half of capacity: keep not deferring.
   WriteData(5);
 
-  // Write rest of space until threshold: start deferring.
+  // Write rest of space until capacity: start deferring.
   EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingDeferred));
   WriteData(5);
 
-  // Read a little from the buffer: keep deferring.
+  // Read a byte from the buffer: stop deferring.
   EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 1));
+  EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoading));
   ReadLoader(10, 1, buffer);
 
-  // Read a little more and go under threshold: stop deferring.
-  EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 4));
-  EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoading));
-  ReadLoader(12, 4, buffer);
-
-  // Write rest of space until threshold: start deferring.
+  // Write a byte to hit capacity: start deferring.
   EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingDeferred));
   WriteData(6);
 
-  // Read a little from the buffer: keep deferring.
-  EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 1));
-  ReadLoader(16, 1, buffer);
-
   StopWhenLoad();
 }
 
 TEST_F(BufferedResourceLoaderTest, Tricky_ReadForwardsPastBuffered) {
   Initialize(kHttpUrl, 10, 99);
   SetLoaderBuffer(10, 10);
   Start();
   PartialResponse(10, 99, 100);
 
   uint8 buffer[256];
   InSequence s;
 
   // PRECONDITION
   WriteUntilThreshold();
   EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 1));
+  EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoading));
   ReadLoader(10, 1, buffer);
   ConfirmBufferState(1, 10, 9, 10);
   ConfirmLoaderOffsets(11, 0, 0);
 
   // *** TRICKY BUSINESS, PT. I ***
   // Read past buffered: stop deferring.
   //
   // In order for the read to complete we must:
   //   1) Stop deferring to receive more data.
   //
   // BEFORE
   //   offset=11 [xxxxxxxxx_]
   //                       ^ ^^^ requested 4 bytes @ offset 20
   // AFTER
   //   offset=24 [__________]
   //
-  EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoading));
   ReadLoader(20, 4, buffer);
 
   // Write a little, make sure we didn't start deferring.
   WriteData(2);
 
   // Write the rest, read should complete.
   EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 4));
   WriteData(2);
 
   // POSTCONDITION
@@ skipping 44 matching lines @@
 
   uint8 buffer[256];
   InSequence s;
 
   // PRECONDITION
   WriteUntilThreshold();
   ConfirmBufferState(0, 10, 10, 10);
   ConfirmLoaderOffsets(10, 0, 0);
 
   // *** TRICKY BUSINESS, PT. III ***
-  // Read past forward capacity but within threshold: stop deferring.
+  // Read past forward capacity but within capacity: stop deferring.
   //
   // In order for the read to complete we must:
   //   1) Adjust offset forward to create capacity.
   //   2) Stop deferring to receive more data.
   //
   // BEFORE
   //   offset=10 [xxxxxxxxxx]
   //                             ^^^^ requested 4 bytes @ offset 24
   // ADJUSTED OFFSET
   //   offset=20 [__________]
@@ skipping 28 matching lines @@
   uint8 buffer[256];
   InSequence s;
 
   // PRECONDITION
   WriteUntilThreshold();
   ConfirmBufferState(0, 10, 10, 10);
   ConfirmLoaderOffsets(10, 0, 0);
 
   // *** TRICKY BUSINESS, PT. IV ***
   // Read a large amount past forward capacity but within
-  // threshold: stop deferring.
+  // capacity: stop deferring.
   //
   // In order for the read to complete we must:
   //   1) Adjust offset forward to create capacity.
   //   2) Expand capacity to make sure we don't defer as data arrives.
   //   3) Stop deferring to receive more data.
   //
   // BEFORE
   //   offset=10 [xxxxxxxxxx]
   //                             ^^^^^^^^^^^^ requested 12 bytes @ offset 24
   // ADJUSTED OFFSET
@@ skipping 285 matching lines @@
   ExpectContentRangeFailure("bytes 20-10/400");
 
   ExpectContentRangeSuccess("bytes 0-499/500", 0, 499, 500);
   ExpectContentRangeSuccess("bytes 0-0/500", 0, 0, 500);
   ExpectContentRangeSuccess("bytes 10-11/50", 10, 11, 50);
   ExpectContentRangeSuccess("bytes 10-11/*", 10, 11,
                             kPositionNotSpecified);
 }
 
 }  // namespace webkit_media