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 649 matching lines @@
   EXPECT_CALL(*this, NetworkCallback());
   EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 10));
   WriteLoader(60, 40);
 
   ConfirmLoaderDeferredState(true);
   VerifyBuffer(buffer, 80, 10);
 
   StopWhenLoad();
 }
 
-// Tests the data buffering logic of ThresholdDefer strategy.
+// Tests the data buffering logic of kThresholdDefer strategy.
 TEST_F(BufferedResourceLoaderTest, ThresholdDeferStrategy) {
   Initialize(kHttpUrl, 10, 99);
   SetLoaderBuffer(10, 20);
   Start();
   PartialResponse(10, 99, 100);
 
   uint8 buffer[10];
   InSequence s;
 
   // Initial expectation: we're not deferring.
   ConfirmLoaderDeferredState(false);
 
-  // Write half of threshold: keep not deferring.
+  // Write half of capacity: keep not deferring.
   WriteData(5);
   ConfirmLoaderDeferredState(false);
 
-  // Write rest of space until threshold: start deferring.
+  // Write rest of space until capacity: start deferring.
   EXPECT_CALL(*this, NetworkCallback());
   WriteData(5);
   ConfirmLoaderDeferredState(true);
 
-  // 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, NetworkCallback());
   ReadLoader(10, 1, buffer);
-  ConfirmLoaderDeferredState(true);
-
-  // Read a little more and go under threshold: stop deferring.
-  EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 4));
-  EXPECT_CALL(*this, NetworkCallback());
-  ReadLoader(12, 4, buffer);
   ConfirmLoaderDeferredState(false);
 
-  // Write rest of space until threshold: start deferring.
+  // Write a byte to hit capacity: start deferring.
   EXPECT_CALL(*this, NetworkCallback());
   WriteData(6);
   ConfirmLoaderDeferredState(true);
 
-  // Read a little from the buffer: keep deferring.
-  EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 1));
-  ReadLoader(16, 1, buffer);
-  ConfirmLoaderDeferredState(true);
-
   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, NetworkCallback());
   ReadLoader(10, 1, buffer);
   ConfirmBufferState(1, 10, 9, 10);
   ConfirmLoaderOffsets(11, 0, 0);
-  ConfirmLoaderDeferredState(true);
+  ConfirmLoaderDeferredState(false);
 
   // *** 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, NetworkCallback());
   ReadLoader(20, 4, buffer);
   ConfirmLoaderDeferredState(false);
 
   // Write a little, make sure we didn't start deferring.
   WriteData(2);
   ConfirmLoaderDeferredState(false);
 
   // Write the rest, read should complete.
   EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 4));
   WriteData(2);
@@ skipping 51 matching lines @@
   uint8 buffer[256];
   InSequence s;
 
   // PRECONDITION
   WriteUntilThreshold();
   ConfirmBufferState(0, 10, 10, 10);
   ConfirmLoaderOffsets(10, 0, 0);
   ConfirmLoaderDeferredState(true);
 
   // *** 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 33 matching lines @@
   InSequence s;
 
   // PRECONDITION
   WriteUntilThreshold();
   ConfirmBufferState(0, 10, 10, 10);
   ConfirmLoaderOffsets(10, 0, 0);
   ConfirmLoaderDeferredState(true);
 
   // *** 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 296 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