Split a portion of BufferedResourceLoader into a separate class ActiveLoader.

webkit/media/buffered_resource_loader_unittest.cc

 // Copyright (c) 2011 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/stringprintf.h"
@@ skipping 35 matching lines @@
 static const int kDataSize = 1024;
 static const int kHttpOK = 200;
 static const int kHttpPartialContent = 206;
 
 enum NetworkState {
   NONE,
   LOADED,
   LOADING
 };
 
-// Submit a request completed event to the resource loader due to request
-// being canceled. Pretending the event is from external.
-ACTION_P(RequestCanceled, loader) {
-  WebURLError error;
-  error.reason = net::ERR_ABORTED;
-  error.domain = WebString::fromUTF8(net::kErrorDomain);
-  loader->didFail(NULL, error);
-}
-
 // Predicate that tests that request disallows compressed data.
 static bool CorrectAcceptEncoding(const WebKit::WebURLRequest &request) {
   std::string value = request.httpHeaderField(
       WebString::fromUTF8(net::HttpRequestHeaders::kAcceptEncoding)).utf8();
   return (value.find("identity;q=1") != std::string::npos) &&
          (value.find("*;q=0") != std::string::npos);
 }
 
 class BufferedResourceLoaderTest : public testing::Test {
  public:
@@ skipping 38 matching lines @@
                    base::Unretained(this)),
         view_->mainFrame());
   }
 
   void FullResponse(int64 instance_size) {
     FullResponse(instance_size, net::OK);
   }
 
   void FullResponse(int64 instance_size, int status) {
     EXPECT_CALL(*this, StartCallback(status));
-    if (status != net::OK) {
-      EXPECT_CALL(*url_loader_, cancel())
-          .WillOnce(RequestCanceled(loader_));
-    }
 
     WebURLResponse response(gurl_);
     response.setHTTPHeaderField(WebString::fromUTF8("Content-Length"),
                                 WebString::fromUTF8(base::StringPrintf("%"
                                     PRId64, instance_size)));
     response.setExpectedContentLength(instance_size);
     response.setHTTPStatusCode(kHttpOK);
     loader_->didReceiveResponse(url_loader_, response);
 
     if (status == net::OK) {
@@ skipping 57 matching lines @@
     WebKit::WebURLRequest newRequest(redirectUrl);
     WebKit::WebURLResponse redirectResponse(gurl_);
 
     loader_->willSendRequest(url_loader_, newRequest, redirectResponse);
 
     MessageLoop::current()->RunAllPending();
   }
 
   void StopWhenLoad() {
     InSequence s;
-    EXPECT_CALL(*url_loader_, cancel())
-        .WillOnce(RequestCanceled(loader_));
+    EXPECT_CALL(*url_loader_, cancel());
     loader_->Stop();
     loader_ = NULL;
   }
 
   // Helper method to write to |loader_| from |data_|.
   void WriteLoader(int position, int size) {
     EXPECT_CALL(*this, NetworkCallback())
         .RetiresOnSaturation();
     loader_->didReceiveData(url_loader_,
                             reinterpret_cast<char*>(data_ + position),
@@ skipping 51 matching lines @@
   void ConfirmLoaderBufferBackwardCapacity(size_t expected_backward_capacity) {
     EXPECT_EQ(loader_->buffer_->backward_capacity(),
               expected_backward_capacity);
   }
 
   void ConfirmLoaderBufferForwardCapacity(size_t expected_forward_capacity) {
     EXPECT_EQ(loader_->buffer_->forward_capacity(), expected_forward_capacity);
   }
 
   void ConfirmLoaderDeferredState(bool expectedVal) {
-    EXPECT_EQ(loader_->deferred_, expectedVal);
+    EXPECT_EQ(loader_->active_loader_->deferred(), expectedVal);
   }
 
   // Makes sure the |loader_| buffer window is in a reasonable range.
   void CheckBufferWindowBounds() {
     // Corresponds to value defined in buffered_resource_loader.cc.
     static const size_t 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.
@@ skipping 32 matching lines @@
   Start();
   StopWhenLoad();
 }
 
 // Tests that a bad HTTP response is recived, e.g. file not found.
 TEST_F(BufferedResourceLoaderTest, BadHttpResponse) {
   Initialize(kHttpUrl, -1, -1);
   Start();
 
   EXPECT_CALL(*this, StartCallback(net::ERR_FAILED));
-  EXPECT_CALL(*url_loader_, cancel())
-      .WillOnce(RequestCanceled(loader_));
 
   WebURLResponse response(gurl_);
   response.setHTTPStatusCode(404);
   response.setHTTPStatusText("Not Found\n");
   loader_->didReceiveResponse(url_loader_, response);
+  StopWhenLoad();
 }
 
 // Tests that partial content is requested but not fulfilled.
 TEST_F(BufferedResourceLoaderTest, NotPartialResponse) {
   Initialize(kHttpUrl, 100, -1);
   Start();
   FullResponse(1024, net::ERR_INVALID_RESPONSE);
+  StopWhenLoad();
 }
 
 // Tests that a 200 response is received.
 TEST_F(BufferedResourceLoaderTest, FullResponse) {
   Initialize(kHttpUrl, -1, -1);
   Start();
   FullResponse(1024);
   StopWhenLoad();
 }
 
@@ skipping 25 matching lines @@
   PartialResponse(100, 200, 1024, true, false);
   StopWhenLoad();
 }
 
 // Tests that an invalid partial response is received.
 TEST_F(BufferedResourceLoaderTest, InvalidPartialResponse) {
   Initialize(kHttpUrl, 0, 10);
   Start();
 
   EXPECT_CALL(*this, StartCallback(net::ERR_INVALID_RESPONSE));
-  EXPECT_CALL(*url_loader_, cancel())
-      .WillOnce(RequestCanceled(loader_));
 
   WebURLResponse response(gurl_);
   response.setHTTPHeaderField(WebString::fromUTF8("Content-Range"),
                               WebString::fromUTF8(base::StringPrintf("bytes "
                                   "%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);
   Start();
   PartialResponse(10, 29, 30);
 
   uint8 buffer[10];
@@ skipping 111 matching lines @@
   ReadLoader(10, 10, buffer);
 
   // Writing to loader will fulfill the read request.
   EXPECT_CALL(*this, ReadCallback(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, ReadCallback(5));
-  EXPECT_CALL(*this, NetworkCallback());
   loader_->didFinishLoading(url_loader_, 0);
 }
 
 TEST_F(BufferedResourceLoaderTest, RequestFailedWhenRead) {
   Initialize(kHttpUrl, 10, 29);
   Start();
   PartialResponse(10, 29, 30);
 
   uint8 buffer[10];
   InSequence s;
 
   ReadLoader(10, 10, buffer);
+  EXPECT_CALL(*this, NetworkCallback());
   EXPECT_CALL(*this, ReadCallback(net::ERR_FAILED));
-  EXPECT_CALL(*this, NetworkCallback());
   WebURLError error;
   error.reason = net::ERR_FAILED;
   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);
@@ skipping 18 matching lines @@
 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.
-  // We should disable deferring after the read request, so expect
-  // a network event.
-  EXPECT_CALL(*this, NetworkCallback());
   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, ReadCallback(10));
   WriteLoader(19, 1);
@@ skipping 505 matching lines @@
 
 TEST_F(BufferedResourceLoaderTest, BufferWindow_PlaybackRate_AboveUpperBound) {
   Initialize(kHttpUrl, -1, -1);
   Start();
   loader_->SetPlaybackRate(100);
   CheckBufferWindowBounds();
   StopWhenLoad();
 }
 
 }  // namespace webkit_media