Split BufferedResourceLoader's network callback into separate loading state and progress callbacks.

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"
 #include "base/stringprintf.h"
 #include "media/base/media_log.h"
 #include "media/base/seekable_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_util.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebString.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebURLError.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebURLRequest.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebURLResponse.h"
 #include "webkit/media/buffered_resource_loader.h"
 #include "webkit/mocks/mock_webframeclient.h"
 #include "webkit/mocks/mock_weburlloader.h"
 
+using ::testing::_;
 using ::testing::InSequence;
 using ::testing::Return;
 using ::testing::Truly;
 using ::testing::NiceMock;
 
 using WebKit::WebString;
 using WebKit::WebURLError;
 using WebKit::WebURLResponse;
 using WebKit::WebView;
 
@@ skipping 59 matching lines @@
   void SetLoaderBuffer(int forward_capacity, int backward_capacity) {
     loader_->buffer_.set_forward_capacity(forward_capacity);
     loader_->buffer_.set_backward_capacity(backward_capacity);
     loader_->buffer_.Clear();
   }
 
   void Start() {
     InSequence s;
     EXPECT_CALL(*url_loader_, loadAsynchronously(Truly(CorrectAcceptEncoding),
                                                  loader_.get()));
+
+    EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoading));
     loader_->Start(
         base::Bind(&BufferedResourceLoaderTest::StartCallback,
                    base::Unretained(this)),
-        base::Bind(&BufferedResourceLoaderTest::NetworkCallback,
+        base::Bind(&BufferedResourceLoaderTest::LoadingCallback,
+                   base::Unretained(this)),
+        base::Bind(&BufferedResourceLoaderTest::ProgressCallback,
                    base::Unretained(this)),
         view_->mainFrame());
   }
 
   void FullResponse(int64 instance_size) {
     FullResponse(instance_size, BufferedResourceLoader::kOk);
   }
 
   void FullResponse(int64 instance_size,
                     BufferedResourceLoader::Status status) {
@@ skipping 75 matching lines @@
 
   void StopWhenLoad() {
     InSequence s;
     EXPECT_CALL(*url_loader_, cancel());
     loader_->Stop();
     loader_.reset();
   }
 
   // Helper method to write to |loader_| from |data_|.
   void WriteLoader(int position, int size) {
-    EXPECT_CALL(*this, NetworkCallback())
-        .RetiresOnSaturation();
+    EXPECT_CALL(*this, ProgressCallback(position + size - 1));
     loader_->didReceiveData(url_loader_,
                             reinterpret_cast<char*>(data_ + position),
                             size,
                             size);
   }
 
   void WriteData(int size) {
-    EXPECT_CALL(*this, NetworkCallback())
-        .RetiresOnSaturation();
+    EXPECT_CALL(*this, ProgressCallback(_));
 
     scoped_array<char> data(new char[size]);
     loader_->didReceiveData(url_loader_, data.get(), size, size);
   }
 
   void WriteUntilThreshold() {
     int buffered = loader_->buffer_.forward_bytes();
     int capacity = loader_->buffer_.forward_capacity();
     CHECK_LT(buffered, capacity);
 
-    EXPECT_CALL(*this, NetworkCallback());
+    EXPECT_CALL(*this, LoadingCallback(
+        BufferedResourceLoader::kLoadingDeferred));
     WriteData(capacity - buffered);
-    ConfirmLoaderDeferredState(true);
   }
 
   // Helper method to read from |loader_|.
   void ReadLoader(int64 position, int size, uint8* buffer) {
     loader_->Read(position, size, buffer,
                   base::Bind(&BufferedResourceLoaderTest::ReadCallback,
                              base::Unretained(this)));
   }
 
   // Verifies that data in buffer[0...size] is equal to data_[pos...pos+size].
@@ skipping 21 matching lines @@
 
   void ConfirmLoaderBufferBackwardCapacity(int expected_backward_capacity) {
     EXPECT_EQ(loader_->buffer_.backward_capacity(),
               expected_backward_capacity);
   }
 
   void ConfirmLoaderBufferForwardCapacity(int expected_forward_capacity) {
     EXPECT_EQ(loader_->buffer_.forward_capacity(), expected_forward_capacity);
   }
 
-  void ConfirmLoaderDeferredState(bool expectedVal) {
-    EXPECT_EQ(loader_->active_loader_->deferred(), expectedVal);

[Ami GONE FROM CHROMIUM, 2012/07/09 00:25:46]

Does allow de-friend'ing some tests from BRL?

[scherkus (not reviewing), 2012/07/09 18:53:30]

Not yet -- BRL is my experiment in friending all of BufferedResourceLoaderTest
(for example we're still accessing buffer_, offset_, first_offset_, etc...)

-  }
-
   // Makes sure the |loader_| buffer window is in a reasonable range.
   void CheckBufferWindowBounds() {
     // Corresponds to value defined in buffered_resource_loader.cc.
     static const int kMinBufferCapacity = 2 * 1024 * 1024;
     EXPECT_GE(loader_->buffer_.forward_capacity(), kMinBufferCapacity);
     EXPECT_GE(loader_->buffer_.backward_capacity(), kMinBufferCapacity);
 
     // Corresponds to value defined in buffered_resource_loader.cc.
     static const int kMaxBufferCapacity = 20 * 1024 * 1024;
     EXPECT_LE(loader_->buffer_.forward_capacity(), kMaxBufferCapacity);
     EXPECT_LE(loader_->buffer_.backward_capacity(), kMaxBufferCapacity);
   }
 
   MOCK_METHOD1(StartCallback, void(BufferedResourceLoader::Status));
   MOCK_METHOD2(ReadCallback, void(BufferedResourceLoader::Status, int));
-  MOCK_METHOD0(NetworkCallback, void());
+  MOCK_METHOD1(LoadingCallback, void(BufferedResourceLoader::LoadingState));
+  MOCK_METHOD1(ProgressCallback, void(int64));
 
   // Accessors for private variables on |loader_|.
   int forward_bytes() { return loader_->buffer_.forward_bytes(); }
   int forward_capacity() { return loader_->buffer_.forward_capacity(); }
 
  protected:
   GURL gurl_;
   int64 first_position_;
   int64 last_position_;
 
@@ skipping 121 matching lines @@
   // Read backward within buffer.
   EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 10));
   ReadLoader(10, 10, buffer);
   VerifyBuffer(buffer, 10, 10);
 
   // Read backward outside buffer.
   EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kCacheMiss, 0));
   ReadLoader(9, 10, buffer);
 
   // Response has completed.
-  EXPECT_CALL(*this, NetworkCallback());
+  EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingFinished));
   loader_->didFinishLoading(url_loader_, 0);
 
   // Try to read 10 from position 25 will just return with 5 bytes.
   EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 5));
   ReadLoader(25, 10, buffer);
   VerifyBuffer(buffer, 25, 5);
 
   // Try to read outside buffered range after request has completed.
   EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kCacheMiss, 0));
   ReadLoader(5, 10, buffer);
 
   // Try to read beyond the instance size.
   EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 0));
   ReadLoader(30, 10, buffer);
 }
 
 // Tests the logic of expanding the data buffer for large reads.
 TEST_F(BufferedResourceLoaderTest, ReadExtendBuffer) {
   Initialize(kHttpUrl, 10, 0x014FFFFFF);
   SetLoaderBuffer(10, 20);
   Start();
   PartialResponse(10, 0x014FFFFFF, 0x015000000);
 
-  // Don't test for network callbacks (covered by *Strategy tests).
-  EXPECT_CALL(*this, NetworkCallback())
-      .WillRepeatedly(Return());
-
   uint8 buffer[20];
   InSequence s;
 
   // Write more than forward capacity and read it back. Ensure forward capacity
-  // gets reset.
+  // gets reset after reading.
+  EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingDeferred));
   WriteLoader(10, 20);
+
   EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 20));
+  EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoading));
   ReadLoader(10, 20, buffer);
 
   VerifyBuffer(buffer, 10, 20);
   ConfirmLoaderBufferForwardCapacity(10);
 
   // Make and outstanding read request larger than forward capacity. Ensure
   // forward capacity gets extended.
   ReadLoader(30, 20, buffer);
-
   ConfirmLoaderBufferForwardCapacity(20);
 
   // Fulfill outstanding request. Ensure forward capacity gets reset.
   EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 20));
   WriteLoader(30, 20);
 
   VerifyBuffer(buffer, 30, 20);
   ConfirmLoaderBufferForwardCapacity(10);
 
   // Try to read further ahead than kForwardWaitThreshold allows. Ensure
@@ skipping 30 matching lines @@
   ReadLoader(10, 10, buffer);
 
   // Writing to loader will fulfill the read request.
   EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 10));
   WriteLoader(10, 20);
   VerifyBuffer(buffer, 10, 10);
 
   // The following call cannot be fulfilled now.
   ReadLoader(25, 10, buffer);
 
-  EXPECT_CALL(*this, NetworkCallback());
+  EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingFinished));
   EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 5));
   loader_->didFinishLoading(url_loader_, 0);
 }
 
 TEST_F(BufferedResourceLoaderTest, RequestFailedWhenRead) {
   Initialize(kHttpUrl, 10, 29);
   Start();
   PartialResponse(10, 29, 30);
 
   uint8 buffer[10];
   InSequence s;
 
   // We should convert any error we receive to BufferedResourceLoader::kFailed.
   ReadLoader(10, 10, buffer);
-  EXPECT_CALL(*this, NetworkCallback());
+  EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingFailed));
   EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kFailed, 0));
   WebURLError error;
   error.reason = net::ERR_TIMED_OUT;
   error.isCancellation = false;
   loader_->didFail(url_loader_, error);
 }
 
 TEST_F(BufferedResourceLoaderTest, RequestFailedWithNoPendingReads) {
   Initialize(kHttpUrl, 10, 29);
   Start();
   PartialResponse(10, 29, 30);
 
   uint8 buffer[10];
   InSequence s;
 
   // Write enough data so that a read would technically complete had the request
   // not failed.
   WriteLoader(10, 20);
 
   // Fail without a pending read.
   WebURLError error;
   error.reason = net::ERR_TIMED_OUT;
   error.isCancellation = false;
-  EXPECT_CALL(*this, NetworkCallback());
+  EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingFailed));
   loader_->didFail(url_loader_, error);
 
   // Now we should immediately fail any read even if we have data buffered.
   EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kFailed, 0));
   ReadLoader(10, 10, buffer);
 }
 
 TEST_F(BufferedResourceLoaderTest, RequestCancelledWhenRead) {
   Initialize(kHttpUrl, 10, 29);
   Start();
   PartialResponse(10, 29, 30);
 
   uint8 buffer[10];
   InSequence s;
 
   // We should convert any error we receive to BufferedResourceLoader::kFailed.
   ReadLoader(10, 10, buffer);
-  EXPECT_CALL(*this, NetworkCallback());
+  EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingFailed));
   EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kFailed, 0));
   WebURLError error;
   error.reason = 0;
   error.isCancellation = true;
   loader_->didFail(url_loader_, error);
 }
 
 // Tests the data buffering logic of NeverDefer strategy.
 TEST_F(BufferedResourceLoaderTest, NeverDeferStrategy) {
   Initialize(kHttpUrl, 10, 99);
   SetLoaderBuffer(10, 20);
   loader_->UpdateDeferStrategy(BufferedResourceLoader::kNeverDefer);
   Start();
   PartialResponse(10, 99, 100);
 
   uint8 buffer[10];
 
   // Read past the buffer size; should not defer regardless.
   WriteLoader(10, 10);
   WriteLoader(20, 50);
-  ConfirmLoaderDeferredState(false);
 
   // Should move past window.
   EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kCacheMiss, 0));
   ReadLoader(10, 10, buffer);
 
   StopWhenLoad();
 }
 
 // Tests the data buffering logic of ReadThenDefer strategy.
 TEST_F(BufferedResourceLoaderTest, ReadThenDeferStrategy) {
   Initialize(kHttpUrl, 10, 99);
   SetLoaderBuffer(10, 20);
   loader_->UpdateDeferStrategy(BufferedResourceLoader::kReadThenDefer);
   Start();
   PartialResponse(10, 99, 100);
 
   uint8 buffer[10];
 
   // Make an outstanding read request.
   ReadLoader(10, 10, buffer);
 
   // Receive almost enough data to cover, shouldn't defer.
   WriteLoader(10, 9);
-  ConfirmLoaderDeferredState(false);
 
   // As soon as we have received enough data to fulfill the read, defer.
-  EXPECT_CALL(*this, NetworkCallback());
+  EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingDeferred));
   EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 10));
   WriteLoader(19, 1);
 
-  ConfirmLoaderDeferredState(true);
   VerifyBuffer(buffer, 10, 10);
 
   // Read again which should disable deferring since there should be nothing
   // left in our internal buffer.
-  EXPECT_CALL(*this, NetworkCallback());
+  EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoading));
   ReadLoader(20, 10, buffer);
 
-  ConfirmLoaderDeferredState(false);
-
   // Over-fulfill requested bytes, then deferring should be enabled again.
-  EXPECT_CALL(*this, NetworkCallback());
+  EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingDeferred));
   EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 10));
   WriteLoader(20, 40);
 
-  ConfirmLoaderDeferredState(true);
   VerifyBuffer(buffer, 20, 10);
 
   // Read far ahead, which should disable deferring. In this case we still have
   // bytes in our internal buffer.
-  EXPECT_CALL(*this, NetworkCallback());
+  EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoading));
   ReadLoader(80, 10, buffer);
 
-  ConfirmLoaderDeferredState(false);
-
   // Fulfill requested bytes, then deferring should be enabled again.
-  EXPECT_CALL(*this, NetworkCallback());
+  EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingDeferred));
   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.
 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.
   WriteData(5);
-  ConfirmLoaderDeferredState(false);
 
   // Write rest of space until threshold: start deferring.
-  EXPECT_CALL(*this, NetworkCallback());
+  EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingDeferred));
   WriteData(5);
-  ConfirmLoaderDeferredState(true);
 
   // Read a little from the buffer: keep deferring.
   EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 1));
   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());
+  EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoading));
   ReadLoader(12, 4, buffer);
-  ConfirmLoaderDeferredState(false);
 
   // Write rest of space until threshold: start deferring.
-  EXPECT_CALL(*this, NetworkCallback());
+  EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoadingDeferred));
   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));
   ReadLoader(10, 1, buffer);
   ConfirmBufferState(1, 10, 9, 10);
   ConfirmLoaderOffsets(11, 0, 0);
-  ConfirmLoaderDeferredState(true);
 
   // *** 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());
+  EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoading));
   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);
-  ConfirmLoaderDeferredState(false);
 
   // POSTCONDITION
   ConfirmBufferState(4, 10, 0, 10);
   ConfirmLoaderOffsets(24, 0, 0);
-  ConfirmLoaderDeferredState(false);
 
   StopWhenLoad();
 }
 
 TEST_F(BufferedResourceLoaderTest, Tricky_ReadBackwardsPastBuffered) {
   Initialize(kHttpUrl, 10, 99);
   SetLoaderBuffer(10, 10);
   Start();
   PartialResponse(10, 99, 100);
 
   uint8 buffer[256];
   InSequence s;
 
   // PRECONDITION
   WriteUntilThreshold();
   ConfirmBufferState(0, 10, 10, 10);
   ConfirmLoaderOffsets(10, 0, 0);
-  ConfirmLoaderDeferredState(true);
 
   // *** TRICKY BUSINESS, PT. II ***
   // Read backwards a little too much: cache miss.
   //
   // BEFORE
   //   offset=10 [__________|xxxxxxxxxx]
   //                       ^ ^^^ requested 10 bytes @ offset 9
   // AFTER
   //   offset=10 [__________|xxxxxxxxxx]  !!! cache miss !!!
   //
   EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kCacheMiss, 0));
   ReadLoader(9, 4, buffer);
 
   // POSTCONDITION
   ConfirmBufferState(0, 10, 10, 10);
   ConfirmLoaderOffsets(10, 0, 0);
-  ConfirmLoaderDeferredState(true);
 
   StopWhenLoad();
 }
 
 TEST_F(BufferedResourceLoaderTest, Tricky_SmallReadWithinThreshold) {
   Initialize(kHttpUrl, 10, 99);
   SetLoaderBuffer(10, 10);
   Start();
   PartialResponse(10, 99, 100);
 
   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.
   //
   // 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 [__________]
   //                  ^^^^ requested 4 bytes @ offset 24
   // AFTER
   //   offset=28 [__________]
   //
-  EXPECT_CALL(*this, NetworkCallback());
+  EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoading));
   ReadLoader(24, 4, buffer);
   ConfirmLoaderOffsets(20, 4, 8);
-  ConfirmLoaderDeferredState(false);
 
   // Write a little, make sure we didn't start deferring.
   WriteData(4);
-  ConfirmLoaderDeferredState(false);
 
   // Write the rest, read should complete.
   EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 4));
   WriteData(4);
-  ConfirmLoaderDeferredState(false);
 
   // POSTCONDITION
   ConfirmBufferState(8, 10, 0, 10);
   ConfirmLoaderOffsets(28, 0, 0);
-  ConfirmLoaderDeferredState(false);
 
   StopWhenLoad();
 }
 
 TEST_F(BufferedResourceLoaderTest, Tricky_LargeReadWithinThreshold) {
   Initialize(kHttpUrl, 10, 99);
   SetLoaderBuffer(10, 10);
   Start();
   PartialResponse(10, 99, 100);
 
   uint8 buffer[256];
   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.
   //
   // 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
   //   offset=20 [__________]
   //                  ^^^^^^ ^^^^^^ requested 12 bytes @ offset 24
   // ADJUSTED CAPACITY
   //   offset=20 [________________]
   //                  ^^^^^^^^^^^^ requested 12 bytes @ offset 24
   // AFTER
   //   offset=36 [__________]
   //
-  EXPECT_CALL(*this, NetworkCallback());
+  EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoading));
   ReadLoader(24, 12, buffer);
   ConfirmLoaderOffsets(20, 4, 16);
   ConfirmBufferState(10, 10, 0, 16);
-  ConfirmLoaderDeferredState(false);
 
   // Write a little, make sure we didn't start deferring.
   WriteData(10);
-  ConfirmLoaderDeferredState(false);
 
   // Write the rest, read should complete and capacity should go back to normal.
   EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 12));
   WriteData(6);
   ConfirmLoaderBufferForwardCapacity(10);
-  ConfirmLoaderDeferredState(false);
 
   // POSTCONDITION
   ConfirmBufferState(6, 10, 0, 10);
   ConfirmLoaderOffsets(36, 0, 0);
-  ConfirmLoaderDeferredState(false);
 
   StopWhenLoad();
 }
 
 TEST_F(BufferedResourceLoaderTest, Tricky_LargeReadBackwards) {
   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, 10));
-  EXPECT_CALL(*this, NetworkCallback());
+  EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoading));
   ReadLoader(10, 10, buffer);
   WriteUntilThreshold();
   ConfirmBufferState(10, 10, 10, 10);
   ConfirmLoaderOffsets(20, 0, 0);
-  ConfirmLoaderDeferredState(true);
 
   // *** TRICKY BUSINESS, PT. V ***
   // Read a large amount that involves backwards data: stop deferring.
   //
   // In order for the read to complete we must:
   //   1) Adjust offset *backwards* 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=20 [xxxxxxxxxx|xxxxxxxxxx]
   //                    ^^^^ ^^^^^^^^^^ ^^^^ requested 18 bytes @ offset 16
   // ADJUSTED OFFSET
   //   offset=16 [____xxxxxx|xxxxxxxxxx]xxxx
   //                         ^^^^^^^^^^ ^^^^^^^^ requested 18 bytes @ offset 16
   // ADJUSTED CAPACITY
   //   offset=16 [____xxxxxx|xxxxxxxxxxxxxx____]
   //                         ^^^^^^^^^^^^^^^^^^ requested 18 bytes @ offset 16
   // AFTER
   //   offset=34 [xxxxxxxxxx|__________]
   //
-  EXPECT_CALL(*this, NetworkCallback());
+  EXPECT_CALL(*this, LoadingCallback(BufferedResourceLoader::kLoading));
   ReadLoader(16, 18, buffer);
   ConfirmLoaderOffsets(16, 0, 18);
   ConfirmBufferState(6, 10, 14, 18);
-  ConfirmLoaderDeferredState(false);
 
   // Write a little, make sure we didn't start deferring.
   WriteData(2);
-  ConfirmLoaderDeferredState(false);
 
   // Write the rest, read should complete and capacity should go back to normal.
   EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kOk, 18));
   WriteData(2);
   ConfirmLoaderBufferForwardCapacity(10);
-  ConfirmLoaderDeferredState(false);
 
   // POSTCONDITION
   ConfirmBufferState(4, 10, 0, 10);
   ConfirmLoaderOffsets(34, 0, 0);
-  ConfirmLoaderDeferredState(false);
 
   StopWhenLoad();
 }
 
 TEST_F(BufferedResourceLoaderTest, Tricky_ReadPastThreshold) {
   const int kSize = 5 * 1024 * 1024;
   const int kThreshold = 2 * 1024 * 1024;
 
   Initialize(kHttpUrl, 10, kSize);
   SetLoaderBuffer(10, 10);
   Start();
   PartialResponse(10, kSize - 1, kSize);
 
   uint8 buffer[256];
   InSequence s;
 
   // PRECONDITION
   WriteUntilThreshold();
   ConfirmBufferState(0, 10, 10, 10);
   ConfirmLoaderOffsets(10, 0, 0);
-  ConfirmLoaderDeferredState(true);
 
   // *** TRICKY BUSINESS, PT. VI ***
   // Read past the forward wait threshold: cache miss.
   //
   // BEFORE
   //   offset=10 [xxxxxxxxxx] ...
   //                              ^^^^ requested 10 bytes @ threshold
   // AFTER
   //   offset=10 [xxxxxxxxxx]  !!! cache miss !!!
   //
   EXPECT_CALL(*this, ReadCallback(BufferedResourceLoader::kCacheMiss, 0));
   ReadLoader(kThreshold + 20, 10, buffer);
 
   // POSTCONDITION
   ConfirmBufferState(0, 10, 10, 10);
   ConfirmLoaderOffsets(10, 0, 0);
-  ConfirmLoaderDeferredState(true);
 
   StopWhenLoad();
 }
 
 TEST_F(BufferedResourceLoaderTest, HasSingleOrigin) {
   // Make sure no redirect case works as expected.
   Initialize(kHttpUrl, -1, -1);
   Start();
   FullResponse(1024);
   EXPECT_TRUE(loader_->HasSingleOrigin());
@@ skipping 157 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