Refactor ResourceHandler API.

content/browser/loader/mojo_async_resource_handler_unittest.cc

 // Copyright 2016 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 "content/browser/loader/mojo_async_resource_handler.h"
 
 #include <string.h>
 
 #include <utility>
 
@@ skipping 160 matching lines @@
   int num_on_response_started_calls_expectation_ = 0;
 
   DISALLOW_COPY_AND_ASSIGN(TestResourceDispatcherHostDelegate);
 };
 
 class TestResourceController : public ResourceController {
  public:
   TestResourceController() {}
   ~TestResourceController() override {}
 
-  void Cancel() override { ADD_FAILURE() << "Cancel should not be called."; }
+  void Cancel() override { CancelWithError(net::ERR_ABORTED); }
 
   void CancelAndIgnore() override {
     ADD_FAILURE() << "CancelAndIgnore should not be called.";
   }
 
   void CancelWithError(int error_code) override {
     // While cancelling more than once is legal, none of these tests should do
     // it.
     EXPECT_FALSE(is_cancel_with_error_called_);
 
@@ skipping 172 matching lines @@
 
   virtual ~MojoAsyncResourceHandlerTestBase() {
     net::URLRequestFilter::GetInstance()->ClearHandlers();
     MojoAsyncResourceHandler::SetAllocationSizeForTesting(
         MojoAsyncResourceHandler::kDefaultAllocationSize);
     base::RunLoop().RunUntilIdle();
   }
 
   // Returns false if something bad happens.
   bool CallOnWillStart() {
-    bool defer = false;
-    if (!handler_->OnWillStart(request_->url(), &defer)) {
-      ADD_FAILURE() << "OnWillStart returns false.";
+    bool defer_or_cancel = false;
+    handler_->OnWillStart(request_->url(), &defer_or_cancel);
+    if (resource_controller_.is_cancel_with_error_called()) {
+      ADD_FAILURE() << "OnWillStart canceled the request.";
       return false;
     }
-    if (defer) {
-      ADD_FAILURE() << "OnWillStart sets |defer| true.";
+    if (defer_or_cancel) {
+      ADD_FAILURE() << "OnResponseStarted set |defer_or_cancel| to true.";
       return false;
     }
     return true;
   }
 
   // Returns false if something bad happens.
   bool CallOnWillStartAndOnResponseStarted() {
     rdh_delegate_.set_num_on_response_started_calls_expectation(1);
     if (!CallOnWillStart())
       return false;
 
     scoped_refptr<ResourceResponse> response = new ResourceResponse();
-    bool defer = false;
-    if (!handler_->OnResponseStarted(response.get(), &defer)) {
-      ADD_FAILURE() << "OnResponseStarted returns false.";
+    bool defer_or_cancel = false;
+    handler_->OnResponseStarted(response.get(), &defer_or_cancel);
+    if (resource_controller_.is_cancel_with_error_called()) {
+      ADD_FAILURE() << "OnResponseStarted canceled the request.";
       return false;
     }
-    if (defer) {
-      ADD_FAILURE() << "OnResponseStarted sets |defer| true.";
+    if (defer_or_cancel) {
+      ADD_FAILURE() << "OnResponseStarted set |defer_or_cancel| to true.";
       return false;
     }
     if (url_loader_client_.has_received_response()) {
-      ADD_FAILURE() << "URLLoaderClient unexpectedly gets a response.";
+      ADD_FAILURE() << "URLLoaderClient unexpectedly received a response.";
       return false;
     }
     url_loader_client_.RunUntilResponseReceived();
     return true;
   }
 
   TestBrowserThreadBundle thread_bundle_;
   TestResourceDispatcherHostDelegate rdh_delegate_;
   ResourceDispatcherHostImpl rdh_;
   mojom::URLLoaderFactoryPtr url_loader_factory_;
@@ skipping 23 matching lines @@
   }
 };
 
 TEST_F(MojoAsyncResourceHandlerTest, InFlightRequests) {
   EXPECT_EQ(0, rdh_.num_in_flight_requests_for_testing());
   handler_ = nullptr;
   EXPECT_EQ(0, rdh_.num_in_flight_requests_for_testing());
 }
 
 TEST_F(MojoAsyncResourceHandlerTest, OnWillStart) {
-  bool defer = false;
-  EXPECT_TRUE(handler_->OnWillStart(request_->url(), &defer));
-  EXPECT_FALSE(defer);
+  bool defer_or_cancel = false;
+  handler_->OnWillStart(request_->url(), &defer_or_cancel);
+  EXPECT_FALSE(resource_controller_.is_cancel_with_error_called());
+  EXPECT_FALSE(defer_or_cancel);
 }
 
 TEST_F(MojoAsyncResourceHandlerTest, OnResponseStarted) {
   rdh_delegate_.set_num_on_response_started_calls_expectation(1);
   ASSERT_TRUE(CallOnWillStart());
 
   scoped_refptr<ResourceResponse> response = new ResourceResponse();
   response->head.content_length = 99;
   response->head.request_start =
       base::TimeTicks::UnixEpoch() + base::TimeDelta::FromDays(14);
   response->head.response_start =
       base::TimeTicks::UnixEpoch() + base::TimeDelta::FromDays(28);
 
-  bool defer = false;
+  bool defer_or_cancel = false;
 
   EXPECT_EQ(0, rdh_delegate_.num_on_response_started_calls());
   base::TimeTicks now1 = base::TimeTicks::Now();
-  ASSERT_TRUE(handler_->OnResponseStarted(response.get(), &defer));
+  handler_->OnResponseStarted(response.get(), &defer_or_cancel);
   base::TimeTicks now2 = base::TimeTicks::Now();
 
-  EXPECT_FALSE(defer);
+  EXPECT_FALSE(resource_controller_.is_cancel_with_error_called());
+  EXPECT_FALSE(defer_or_cancel);
   EXPECT_EQ(request_->creation_time(), response->head.request_start);
   EXPECT_LE(now1, response->head.response_start);
   EXPECT_LE(response->head.response_start, now2);
   EXPECT_EQ(1, rdh_delegate_.num_on_response_started_calls());
 
   url_loader_client_.RunUntilResponseReceived();
   EXPECT_EQ(response->head.request_start,
             url_loader_client_.response_head().request_start);
   EXPECT_EQ(response->head.response_start,
             url_loader_client_.response_head().response_start);
@@ skipping 21 matching lines @@
   EXPECT_FALSE(io_buffer);
   EXPECT_EQ(0, io_buffer_size);
   EXPECT_EQ(1, rdh_.num_in_flight_requests_for_testing());
   EXPECT_TRUE(resource_controller_.is_cancel_with_error_called());
   EXPECT_EQ(net::ERR_INSUFFICIENT_RESOURCES, resource_controller_.error());
   handler_ = nullptr;
   EXPECT_EQ(0, rdh_.num_in_flight_requests_for_testing());
 }
 
 TEST_F(MojoAsyncResourceHandlerTest, OnWillReadAndOnReadCompleted) {
-  bool defer = false;
+  bool defer_or_cancel = false;
   scoped_refptr<net::IOBuffer> io_buffer;
   int io_buffer_size = 0;
 
   ASSERT_TRUE(CallOnWillStartAndOnResponseStarted());
   ASSERT_TRUE(handler_->OnWillRead(&io_buffer, &io_buffer_size, -1));
   ASSERT_TRUE(io_buffer);
   // The buffer size that the mime sniffer requires implicitly.
   ASSERT_GE(io_buffer_size, kSizeMimeSnifferRequiresForFirstOnWillRead);
 
   url_loader_client_.RunUntilResponseBodyArrived();
   ASSERT_TRUE(url_loader_client_.response_body().is_valid());
 
   io_buffer->data()[0] = 'A';
   io_buffer->data()[1] = 'B';
-  ASSERT_TRUE(handler_->OnReadCompleted(2, &defer));
-  EXPECT_FALSE(defer);
+  handler_->OnReadCompleted(2, &defer_or_cancel);
+  EXPECT_FALSE(resource_controller_.is_cancel_with_error_called());
+  EXPECT_FALSE(defer_or_cancel);
 
   std::string contents;
   while (contents.size() < 2) {
     char buffer[16];
     uint32_t read_size = sizeof(buffer);
     MojoResult result =
         mojo::ReadDataRaw(url_loader_client_.response_body(), buffer,
                           &read_size, MOJO_READ_DATA_FLAG_NONE);
     if (result == MOJO_RESULT_SHOULD_WAIT) {
       base::RunLoop().RunUntilIdle();
       continue;
     }
     contents.append(buffer, read_size);
   }
   EXPECT_EQ("AB", contents);
 }
 
 TEST_F(MojoAsyncResourceHandlerTest,
        OnWillReadAndOnReadCompletedWithInsufficientInitialCapacity) {
   MojoAsyncResourceHandler::SetAllocationSizeForTesting(2);
 
-  bool defer = false;
+  bool defer_or_cancel = false;
   scoped_refptr<net::IOBuffer> io_buffer;
   int io_buffer_size = 0;
 
   ASSERT_TRUE(CallOnWillStartAndOnResponseStarted());
   ASSERT_TRUE(handler_->OnWillRead(&io_buffer, &io_buffer_size, -1));
   ASSERT_TRUE(io_buffer);
   // The buffer size that the mime sniffer requires implicitly.
   ASSERT_GE(io_buffer_size, kSizeMimeSnifferRequiresForFirstOnWillRead);
 
   url_loader_client_.RunUntilResponseBodyArrived();
   ASSERT_TRUE(url_loader_client_.response_body().is_valid());
 
   const std::string data("abcdefgh");
   strcpy(io_buffer->data(), data.c_str());
-  ASSERT_TRUE(handler_->OnReadCompleted(data.size(), &defer));
-  EXPECT_TRUE(defer);
+  handler_->OnReadCompleted(data.size(), &defer_or_cancel);
+  EXPECT_FALSE(resource_controller_.is_cancel_with_error_called());
+  EXPECT_TRUE(defer_or_cancel);
 
   std::string contents;
   while (contents.size() < data.size()) {
     // This is needed for Resume to be called.
     base::RunLoop().RunUntilIdle();
     char buffer[16];
     uint32_t read_size = sizeof(buffer);
     MojoResult result =
         mojo::ReadDataRaw(url_loader_client_.response_body(), buffer,
                           &read_size, MOJO_READ_DATA_FLAG_NONE);
@@ skipping 19 matching lines @@
 
   handler_ = nullptr;
   url_loader_client_.Unbind();
   base::RunLoop().RunUntilIdle();
 
   // Hopefully ASAN checks this operation's validity.
   io_buffer->data()[0] = 'A';
 }
 
 TEST_F(MojoAsyncResourceHandlerTest, OnResponseCompleted) {
-  bool defer = false;
+  bool defer_or_cancel = false;
   ASSERT_TRUE(CallOnWillStartAndOnResponseStarted());
 
   ResourceRequestInfoImpl::ForRequest(request_.get())
       ->set_was_ignored_by_handler(false);
   net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, net::OK);
 
   base::TimeTicks now1 = base::TimeTicks::Now();
-  handler_->OnResponseCompleted(status, &defer);
+  handler_->OnResponseCompleted(status, &defer_or_cancel);
   base::TimeTicks now2 = base::TimeTicks::Now();
-  EXPECT_FALSE(defer);
+  EXPECT_FALSE(resource_controller_.is_cancel_with_error_called());
+  EXPECT_FALSE(defer_or_cancel);
 
   url_loader_client_.RunUntilComplete();
   EXPECT_TRUE(url_loader_client_.has_received_completion());
   EXPECT_EQ(net::OK, url_loader_client_.completion_status().error_code);
   EXPECT_FALSE(url_loader_client_.completion_status().was_ignored_by_handler);
   EXPECT_LE(now1, url_loader_client_.completion_status().completion_time);
   EXPECT_LE(url_loader_client_.completion_status().completion_time, now2);
   EXPECT_EQ(request_->GetTotalReceivedBytes(),
             url_loader_client_.completion_status().encoded_data_length);
 }
 
 // This test case sets different status values from OnResponseCompleted.
 TEST_F(MojoAsyncResourceHandlerTest, OnResponseCompleted2) {
   rdh_.SetDelegate(nullptr);
-  bool defer = false;
+  bool defer_or_cancel = false;
   // Don't use CallOnWillStartAndOnResponseStarted as this test case manually
   // sets the null delegate.
   ASSERT_TRUE(CallOnWillStart());
   scoped_refptr<ResourceResponse> response = new ResourceResponse();
-  ASSERT_TRUE(handler_->OnResponseStarted(response.get(), &defer));
-  ASSERT_FALSE(defer);
+  handler_->OnResponseStarted(response.get(), &defer_or_cancel);
+  ASSERT_FALSE(resource_controller_.is_cancel_with_error_called());
+  ASSERT_FALSE(defer_or_cancel);
   ASSERT_FALSE(url_loader_client_.has_received_response());
   url_loader_client_.RunUntilResponseReceived();
 
   ResourceRequestInfoImpl::ForRequest(request_.get())
       ->set_was_ignored_by_handler(true);
   net::URLRequestStatus status(net::URLRequestStatus::CANCELED,
                                net::ERR_ABORTED);
 
   base::TimeTicks now1 = base::TimeTicks::Now();
-  handler_->OnResponseCompleted(status, &defer);
+  handler_->OnResponseCompleted(status, &defer_or_cancel);
   base::TimeTicks now2 = base::TimeTicks::Now();
-  EXPECT_FALSE(defer);
+  EXPECT_FALSE(resource_controller_.is_cancel_with_error_called());
+  EXPECT_FALSE(defer_or_cancel);
 
   url_loader_client_.RunUntilComplete();
   EXPECT_TRUE(url_loader_client_.has_received_completion());
   EXPECT_EQ(net::ERR_ABORTED,
             url_loader_client_.completion_status().error_code);
   EXPECT_TRUE(url_loader_client_.completion_status().was_ignored_by_handler);
   EXPECT_LE(now1, url_loader_client_.completion_status().completion_time);
   EXPECT_LE(url_loader_client_.completion_status().completion_time, now2);
   EXPECT_EQ(request_->GetTotalReceivedBytes(),
             url_loader_client_.completion_status().encoded_data_length);
 }
 
 TEST_F(MojoAsyncResourceHandlerTest, OnResponseCompletedWithCanceledTimedOut) {
   net::URLRequestStatus status(net::URLRequestStatus::CANCELED,
                                net::ERR_TIMED_OUT);
-  bool defer = false;
+  bool defer_or_cancel = false;
 
   ASSERT_TRUE(CallOnWillStartAndOnResponseStarted());
-  handler_->OnResponseCompleted(status, &defer);
-  EXPECT_FALSE(defer);
+  handler_->OnResponseCompleted(status, &defer_or_cancel);
+  EXPECT_FALSE(resource_controller_.is_cancel_with_error_called());
+  EXPECT_FALSE(defer_or_cancel);
 
   url_loader_client_.RunUntilComplete();
   EXPECT_TRUE(url_loader_client_.has_received_completion());
   EXPECT_EQ(net::ERR_TIMED_OUT,
             url_loader_client_.completion_status().error_code);
 }
 
 TEST_F(MojoAsyncResourceHandlerTest, OnResponseCompletedWithFailedTimedOut) {
   net::URLRequestStatus status(net::URLRequestStatus::FAILED,
                                net::ERR_TIMED_OUT);
-  bool defer = false;
+  bool defer_or_cancel = false;
 
   ASSERT_TRUE(CallOnWillStartAndOnResponseStarted());
-  handler_->OnResponseCompleted(status, &defer);
-  EXPECT_FALSE(defer);
+  handler_->OnResponseCompleted(status, &defer_or_cancel);
+  EXPECT_FALSE(resource_controller_.is_cancel_with_error_called());
+  EXPECT_FALSE(defer_or_cancel);
 
   url_loader_client_.RunUntilComplete();
   EXPECT_TRUE(url_loader_client_.has_received_completion());
   EXPECT_EQ(net::ERR_TIMED_OUT,
             url_loader_client_.completion_status().error_code);
 }
 
 TEST_F(MojoAsyncResourceHandlerTest, ResponseCompletionShouldCloseDataPipe) {
   ASSERT_TRUE(CallOnWillStartAndOnResponseStarted());
 
   scoped_refptr<net::IOBuffer> io_buffer;
   int io_buffer_size = 0;
-  bool defer = false;
+  bool defer_or_cancel = false;
   ASSERT_TRUE(handler_->OnWillRead(&io_buffer, &io_buffer_size, -1));
   url_loader_client_.RunUntilResponseBodyArrived();
   ASSERT_TRUE(url_loader_client_.response_body().is_valid());
-  ASSERT_TRUE(handler_->OnReadCompleted(0, &defer));
-  EXPECT_FALSE(defer);
+  handler_->OnReadCompleted(0, &defer_or_cancel);
+  EXPECT_FALSE(resource_controller_.is_cancel_with_error_called());
+  EXPECT_FALSE(defer_or_cancel);
 
   net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, net::OK);
-  handler_->OnResponseCompleted(status, &defer);
-  EXPECT_FALSE(defer);
+  handler_->OnResponseCompleted(status, &defer_or_cancel);
+  EXPECT_FALSE(resource_controller_.is_cancel_with_error_called());
+  EXPECT_FALSE(defer_or_cancel);
 
   url_loader_client_.RunUntilComplete();
   EXPECT_TRUE(url_loader_client_.has_received_completion());
   EXPECT_EQ(net::OK, url_loader_client_.completion_status().error_code);
 
   // This is needed because |*io_buffer| may keep the data producer alive.
   io_buffer = nullptr;
 
   while (true) {
     char buffer[16];
@@ skipping 10 matching lines @@
 TEST_F(MojoAsyncResourceHandlerTest, ResponseErrorDuringBodyTransmission) {
   ASSERT_TRUE(CallOnWillStartAndOnResponseStarted());
 
   scoped_refptr<net::IOBuffer> io_buffer;
   int io_buffer_size = 0;
   ASSERT_TRUE(handler_->OnWillRead(&io_buffer, &io_buffer_size, -1));
   url_loader_client_.RunUntilResponseBodyArrived();
   ASSERT_TRUE(url_loader_client_.response_body().is_valid());
   ASSERT_GT(io_buffer_size, 0);
   memset(io_buffer->data(), 'a', io_buffer_size);
-  bool defer = false;
-  ASSERT_TRUE(handler_->OnReadCompleted(io_buffer_size, &defer));
-  // We don't care |defer|'s value here.
+  bool defer_or_cancel = false;
+  handler_->OnReadCompleted(io_buffer_size, &defer_or_cancel);
+  EXPECT_FALSE(resource_controller_.is_cancel_with_error_called());
 
-  defer = false;
+  // Don't care about |defer_or_cancel|'s value here.
+  defer_or_cancel = false;
   net::URLRequestStatus status(net::URLRequestStatus::FAILED, net::ERR_FAILED);
-  handler_->OnResponseCompleted(status, &defer);
-  EXPECT_FALSE(defer);
+  handler_->OnResponseCompleted(status, &defer_or_cancel);
+  EXPECT_FALSE(resource_controller_.is_cancel_with_error_called());
+  EXPECT_FALSE(defer_or_cancel);
 
   url_loader_client_.RunUntilComplete();
   EXPECT_TRUE(url_loader_client_.has_received_completion());
   EXPECT_EQ(net::ERR_FAILED, url_loader_client_.completion_status().error_code);
 
   // This is needed because |*io_buffer| may keep the data producer alive.
   io_buffer = nullptr;
 
   std::string actual;
   while (true) {
@@ skipping 16 matching lines @@
 
 // In this case, an error is notified after OnWillRead, before OnReadCompleted.
 TEST_F(MojoAsyncResourceHandlerTest, ResponseErrorDuringBodyTransmission2) {
   ASSERT_TRUE(CallOnWillStartAndOnResponseStarted());
 
   scoped_refptr<net::IOBuffer> io_buffer;
   int io_buffer_size = 0;
   ASSERT_TRUE(handler_->OnWillRead(&io_buffer, &io_buffer_size, -1));
   url_loader_client_.RunUntilResponseBodyArrived();
   ASSERT_TRUE(url_loader_client_.response_body().is_valid());
-  bool defer = false;
+  bool defer_or_cancel = false;
   net::URLRequestStatus status(net::URLRequestStatus::FAILED, net::ERR_FAILED);
-  handler_->OnResponseCompleted(status, &defer);
-  EXPECT_FALSE(defer);
+  handler_->OnResponseCompleted(status, &defer_or_cancel);
+  EXPECT_FALSE(resource_controller_.is_cancel_with_error_called());
+  EXPECT_FALSE(defer_or_cancel);
 
   url_loader_client_.RunUntilComplete();
   EXPECT_TRUE(url_loader_client_.has_received_completion());
   EXPECT_EQ(net::ERR_FAILED, url_loader_client_.completion_status().error_code);
 
   // This is needed because |*io_buffer| may keep the data producer alive.
   io_buffer = nullptr;
 
   while (true) {
     char buf[16];
@@ skipping 33 matching lines @@
   ASSERT_TRUE(CallOnWillStartAndOnResponseStarted());
   size_t written = 0;
   while (true) {
     scoped_refptr<net::IOBuffer> io_buffer;
     int io_buffer_size = 0;
     ASSERT_TRUE(handler_->OnWillRead(&io_buffer, &io_buffer_size, -1));
     EXPECT_TRUE(io_buffer);
     EXPECT_GT(io_buffer_size, 0);
     memset(io_buffer->data(), 'X', io_buffer_size);
     written += io_buffer_size;
-    bool defer = false;
-    ASSERT_TRUE(handler_->OnReadCompleted(io_buffer_size, &defer));
-    if (defer)
+    bool defer_or_cancel = false;
+    handler_->OnReadCompleted(io_buffer_size, &defer_or_cancel);
+    EXPECT_FALSE(resource_controller_.is_cancel_with_error_called());
+    if (defer_or_cancel)
       break;
   }
 
   url_loader_client_.RunUntilResponseBodyArrived();
   ASSERT_TRUE(url_loader_client_.response_body().is_valid());
   handler_->ResetBeginWriteExpectation();
   handler_->OnWritableForTesting();
 
   std::string actual;
   while (actual.size() < written) {
@@ skipping 18 matching lines @@
   ASSERT_TRUE(CallOnWillStartAndOnResponseStarted());
   handler_->set_end_write_expectation(MOJO_RESULT_UNKNOWN);
   scoped_refptr<net::IOBuffer> io_buffer;
   int io_buffer_size = 0;
   ASSERT_FALSE(handler_->OnWillRead(&io_buffer, &io_buffer_size, -1));
 }
 
 TEST_F(MojoAsyncResourceHandlerTest, EndWriteFailsOnReadCompleted) {
   scoped_refptr<net::IOBuffer> io_buffer;
   int io_buffer_size = 0;
-  bool defer = false;
+  bool defer_or_cancel = false;
   ASSERT_TRUE(CallOnWillStartAndOnResponseStarted());
   ASSERT_TRUE(handler_->OnWillRead(&io_buffer, &io_buffer_size, -1));
 
   handler_->set_end_write_expectation(MOJO_RESULT_SHOULD_WAIT);
-  ASSERT_FALSE(handler_->OnReadCompleted(io_buffer_size, &defer));
+  handler_->OnReadCompleted(io_buffer_size, &defer_or_cancel);
+  EXPECT_TRUE(resource_controller_.is_cancel_with_error_called());
+  EXPECT_EQ(net::ERR_ABORTED, resource_controller_.error());
+  EXPECT_TRUE(defer_or_cancel);
 }
 
 TEST_F(MojoAsyncResourceHandlerTest,
        EndWriteFailsOnReadCompletedWithInsufficientInitialCapacity) {
   MojoAsyncResourceHandler::SetAllocationSizeForTesting(2);
   scoped_refptr<net::IOBuffer> io_buffer;
   int io_buffer_size = 0;
-  bool defer = false;
+  bool defer_or_cancel = false;
   ASSERT_TRUE(CallOnWillStartAndOnResponseStarted());
   ASSERT_TRUE(handler_->OnWillRead(&io_buffer, &io_buffer_size, -1));
 
   handler_->set_end_write_expectation(MOJO_RESULT_SHOULD_WAIT);
-  ASSERT_FALSE(handler_->OnReadCompleted(io_buffer_size, &defer));
+  handler_->OnReadCompleted(io_buffer_size, &defer_or_cancel);
+  EXPECT_TRUE(resource_controller_.is_cancel_with_error_called());
+  EXPECT_EQ(net::ERR_ABORTED, resource_controller_.error());
+  EXPECT_TRUE(defer_or_cancel);
 }
 
 TEST_F(MojoAsyncResourceHandlerTest,
        EndWriteFailsOnResumeWithInsufficientInitialCapacity) {
   MojoAsyncResourceHandler::SetAllocationSizeForTesting(8);
   ASSERT_TRUE(CallOnWillStartAndOnResponseStarted());
   scoped_refptr<net::IOBuffer> io_buffer;
   int io_buffer_size = 0;
   ASSERT_TRUE(handler_->OnWillRead(&io_buffer, &io_buffer_size, -1));
   url_loader_client_.RunUntilResponseBodyArrived();
   ASSERT_TRUE(url_loader_client_.response_body().is_valid());
 
   while (true) {
-    bool defer = false;
-    ASSERT_TRUE(handler_->OnReadCompleted(io_buffer_size, &defer));
+    bool defer_or_cancel = false;
+    handler_->OnReadCompleted(io_buffer_size, &defer_or_cancel);
+    EXPECT_FALSE(resource_controller_.is_cancel_with_error_called());
     ASSERT_GE(io_buffer_size, 0);
-    if (defer)
+    if (defer_or_cancel)
       break;
     ASSERT_TRUE(handler_->OnWillRead(&io_buffer, &io_buffer_size, -1));
   }
 
   while (true) {
     char buf[16];
     uint32_t read_size = sizeof(buf);
     MojoResult result =
         mojo::ReadDataRaw(url_loader_client_.response_body(), buf, &read_size,
                           MOJO_READ_DATA_FLAG_NONE);
     if (result == MOJO_RESULT_SHOULD_WAIT)
       break;
     ASSERT_EQ(MOJO_RESULT_OK, result);
   }
 
   handler_->set_end_write_expectation(MOJO_RESULT_SHOULD_WAIT);
   resource_controller_.RunUntilCancelWithErrorCalled();
   EXPECT_FALSE(url_loader_client_.has_received_completion());
   EXPECT_TRUE(resource_controller_.is_cancel_with_error_called());
   EXPECT_EQ(net::ERR_FAILED, resource_controller_.error());
 }
 
 TEST_P(MojoAsyncResourceHandlerWithAllocationSizeTest,
        OnWillReadWithLongContents) {
-  bool defer = false;
+  bool defer_or_cancel = false;
   scoped_refptr<net::IOBuffer> io_buffer;
   int io_buffer_size = 0;
 
   ASSERT_TRUE(CallOnWillStartAndOnResponseStarted());
   ASSERT_TRUE(handler_->OnWillRead(&io_buffer, &io_buffer_size, -1));
   ASSERT_TRUE(io_buffer);
   // The io_buffer size that the mime sniffer requires implicitly.
   ASSERT_GE(io_buffer_size, kSizeMimeSnifferRequiresForFirstOnWillRead);
   std::string expected;
   for (int i = 0; i < 3 * io_buffer_size + 2; ++i)
     expected += ('A' + i % 26);
 
-  ASSERT_TRUE(handler_->OnReadCompleted(0, &defer));
-  ASSERT_FALSE(defer);
+  handler_->OnReadCompleted(0, &defer_or_cancel);
+  ASSERT_FALSE(resource_controller_.is_cancel_with_error_called());
+  ASSERT_FALSE(defer_or_cancel);
 
   url_loader_client_.RunUntilResponseBodyArrived();
   ASSERT_TRUE(url_loader_client_.response_body().is_valid());
 
   size_t written = 0;
   std::string actual;
   while (actual.size() < expected.size()) {
-    while (written < expected.size() && !defer) {
+    while (written < expected.size() && !defer_or_cancel) {
       ASSERT_TRUE(handler_->OnWillRead(&io_buffer, &io_buffer_size, -1));
       const size_t to_be_written = std::min(static_cast<size_t>(io_buffer_size),
                                             expected.size() - written);
       memcpy(io_buffer->data(), &expected[written], to_be_written);
-      ASSERT_TRUE(handler_->OnReadCompleted(to_be_written, &defer));
+      handler_->OnReadCompleted(to_be_written, &defer_or_cancel);
+      ASSERT_FALSE(resource_controller_.is_cancel_with_error_called());
       written += to_be_written;
     }
 
     char buf[16];
     uint32_t read_size = sizeof(buf);
     MojoResult result =
         mojo::ReadDataRaw(url_loader_client_.response_body(), buf, &read_size,
                           MOJO_READ_DATA_FLAG_NONE);
     if (result != MOJO_RESULT_SHOULD_WAIT) {
       ASSERT_EQ(MOJO_RESULT_OK, result);
       actual.append(buf, read_size);
     }
     int resume_count = resource_controller_.num_resume_calls();
     base::RunLoop().RunUntilIdle();
     // Continue writing if controller->Resume() is called.
-    defer = (resume_count == resource_controller_.num_resume_calls());
+    defer_or_cancel = (resume_count == resource_controller_.num_resume_calls());
   }
   EXPECT_EQ(expected, actual);
 }
 
 TEST_P(MojoAsyncResourceHandlerWithAllocationSizeTest,
        BeginWriteFailsOnReadCompleted) {
   scoped_refptr<net::IOBuffer> io_buffer;
   int io_buffer_size = 0;
-  bool defer = false;
+  bool defer_or_cancel = false;
   ASSERT_TRUE(CallOnWillStartAndOnResponseStarted());
   ASSERT_TRUE(handler_->OnWillRead(&io_buffer, &io_buffer_size, -1));
 
   handler_->set_begin_write_expectation(MOJO_RESULT_UNKNOWN);
-  ASSERT_FALSE(handler_->OnReadCompleted(io_buffer_size, &defer));
+  handler_->OnReadCompleted(io_buffer_size, &defer_or_cancel);
+  EXPECT_TRUE(resource_controller_.is_cancel_with_error_called());
+  EXPECT_EQ(net::ERR_ABORTED, resource_controller_.error());
+  EXPECT_TRUE(defer_or_cancel);
 }
 
 TEST_P(MojoAsyncResourceHandlerWithAllocationSizeTest,
        BeginWriteReturnsShouldWaitOnReadCompleted) {
   scoped_refptr<net::IOBuffer> io_buffer;
   int io_buffer_size = 0;
-  bool defer = false;
+  bool defer_or_cancel = false;
   ASSERT_TRUE(CallOnWillStartAndOnResponseStarted());
   ASSERT_TRUE(handler_->OnWillRead(&io_buffer, &io_buffer_size, -1));
 
   handler_->set_begin_write_expectation(MOJO_RESULT_SHOULD_WAIT);
-  ASSERT_TRUE(handler_->OnReadCompleted(io_buffer_size, &defer));
-  EXPECT_TRUE(defer);
+  handler_->OnReadCompleted(io_buffer_size, &defer_or_cancel);
+  EXPECT_FALSE(resource_controller_.is_cancel_with_error_called());
+  EXPECT_TRUE(defer_or_cancel);
 }
 
 TEST_P(MojoAsyncResourceHandlerWithAllocationSizeTest,
        BeginWriteFailsOnResume) {
-  bool defer = false;
+  bool defer_or_cancel = false;
   int io_buffer_size = 0;
   scoped_refptr<net::IOBuffer> io_buffer;
 
   ASSERT_TRUE(CallOnWillStartAndOnResponseStarted());
   ASSERT_TRUE(handler_->OnWillRead(&io_buffer, &io_buffer_size, -1));
-  ASSERT_TRUE(handler_->OnReadCompleted(0, &defer));
-  ASSERT_FALSE(defer);
+  handler_->OnReadCompleted(0, &defer_or_cancel);
+  ASSERT_FALSE(resource_controller_.is_cancel_with_error_called());
+  ASSERT_FALSE(defer_or_cancel);
   url_loader_client_.RunUntilResponseBodyArrived();
+  ASSERT_FALSE(resource_controller_.is_cancel_with_error_called());
   ASSERT_TRUE(url_loader_client_.response_body().is_valid());
 
-  while (!defer) {
+  while (!defer_or_cancel) {
     ASSERT_TRUE(handler_->OnWillRead(&io_buffer, &io_buffer_size, -1));
-    ASSERT_TRUE(handler_->OnReadCompleted(io_buffer_size, &defer));
+    handler_->OnReadCompleted(io_buffer_size, &defer_or_cancel);
   }
   handler_->set_begin_write_expectation(MOJO_RESULT_UNKNOWN);
 
   while (!resource_controller_.is_cancel_with_error_called()) {
     char buf[256];
     uint32_t read_size = sizeof(buf);
     MojoResult result =
         mojo::ReadDataRaw(url_loader_client_.response_body(), buf, &read_size,
                           MOJO_READ_DATA_FLAG_NONE);
     ASSERT_TRUE(result == MOJO_RESULT_OK || result == MOJO_RESULT_SHOULD_WAIT);
     base::RunLoop().RunUntilIdle();
   }
 
   EXPECT_FALSE(url_loader_client_.has_received_completion());
   EXPECT_EQ(net::ERR_FAILED, resource_controller_.error());
   EXPECT_EQ(0, resource_controller_.num_resume_calls());
 }
 
 TEST_P(MojoAsyncResourceHandlerWithAllocationSizeTest, CancelWhileWaiting) {
-  bool defer = false;
+  bool defer_or_cancel = false;
   ASSERT_TRUE(CallOnWillStartAndOnResponseStarted());
 
-  while (!defer) {
+  while (!defer_or_cancel) {
     scoped_refptr<net::IOBuffer> io_buffer;
     int io_buffer_size = 0;
     ASSERT_TRUE(handler_->OnWillRead(&io_buffer, &io_buffer_size, -1));
-    ASSERT_TRUE(handler_->OnReadCompleted(io_buffer_size, &defer));
+    handler_->OnReadCompleted(io_buffer_size, &defer_or_cancel);
+    ASSERT_FALSE(resource_controller_.is_cancel_with_error_called());
   }
 
   url_loader_client_.RunUntilResponseBodyArrived();
   ASSERT_TRUE(url_loader_client_.response_body().is_valid());
 
-  defer = false;
+  defer_or_cancel = false;
   net::URLRequestStatus status(net::URLRequestStatus::CANCELED,
                                net::ERR_ABORTED);
-  handler_->OnResponseCompleted(status, &defer);
+  handler_->OnResponseCompleted(status, &defer_or_cancel);
+  ASSERT_FALSE(resource_controller_.is_cancel_with_error_called());
 
   ASSERT_FALSE(url_loader_client_.has_received_completion());
   url_loader_client_.RunUntilComplete();
   EXPECT_EQ(net::ERR_ABORTED,
             url_loader_client_.completion_status().error_code);
 
   while (true) {
     char buffer[16];
     uint32_t read_size = sizeof(buffer);
     MojoResult result =
         mojo::ReadDataRaw(url_loader_client_.response_body(), buffer,
                           &read_size, MOJO_READ_DATA_FLAG_NONE);
     if (result == MOJO_RESULT_FAILED_PRECONDITION)
       break;
     base::RunLoop().RunUntilIdle();
     DCHECK(result == MOJO_RESULT_SHOULD_WAIT || result == MOJO_RESULT_OK);
   }
 
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(0, resource_controller_.num_resume_calls());
 }
 
 TEST_P(MojoAsyncResourceHandlerWithAllocationSizeTest, RedirectHandling) {
   rdh_delegate_.set_num_on_response_started_calls_expectation(1);
-  bool defer = false;
+  bool defer_or_cancel = false;
 
-  ASSERT_TRUE(handler_->OnWillStart(request_->url(), &defer));
-  ASSERT_FALSE(defer);
+  handler_->OnWillStart(request_->url(), &defer_or_cancel);
+  ASSERT_FALSE(resource_controller_.is_cancel_with_error_called());
+  ASSERT_FALSE(defer_or_cancel);
   scoped_refptr<ResourceResponse> response = new ResourceResponse();
   net::RedirectInfo redirect_info;
   redirect_info.status_code = 301;
-  ASSERT_TRUE(
-      handler_->OnRequestRedirected(redirect_info, response.get(), &defer));
-  ASSERT_TRUE(defer);
+  handler_->OnRequestRedirected(redirect_info, response.get(),
+                                &defer_or_cancel);
+  ASSERT_FALSE(resource_controller_.is_cancel_with_error_called());
+  ASSERT_TRUE(defer_or_cancel);
 
   ASSERT_FALSE(url_loader_client_.has_received_response());
   ASSERT_FALSE(url_loader_client_.has_received_redirect());
   url_loader_client_.RunUntilRedirectReceived();
 
   ASSERT_FALSE(url_loader_client_.has_received_response());
   ASSERT_TRUE(url_loader_client_.has_received_redirect());
   EXPECT_EQ(301, url_loader_client_.redirect_info().status_code);
 
   EXPECT_EQ(0, resource_controller_.num_resume_calls());
   handler_->FollowRedirect();
   EXPECT_EQ(1, resource_controller_.num_resume_calls());
 
   url_loader_client_.ClearHasReceivedRedirect();
   // Redirect once more.
-  defer = false;
+  defer_or_cancel = false;
   redirect_info.status_code = 302;
-  ASSERT_TRUE(
-      handler_->OnRequestRedirected(redirect_info, response.get(), &defer));
-  ASSERT_TRUE(defer);
+  handler_->OnRequestRedirected(redirect_info, response.get(),
+                                &defer_or_cancel);
+  ASSERT_FALSE(resource_controller_.is_cancel_with_error_called());
+  ASSERT_TRUE(defer_or_cancel);
 
   ASSERT_FALSE(url_loader_client_.has_received_response());
   ASSERT_FALSE(url_loader_client_.has_received_redirect());
   url_loader_client_.RunUntilRedirectReceived();
 
   ASSERT_FALSE(url_loader_client_.has_received_response());
   ASSERT_TRUE(url_loader_client_.has_received_redirect());
   EXPECT_EQ(302, url_loader_client_.redirect_info().status_code);
 
   EXPECT_EQ(1, resource_controller_.num_resume_calls());
   handler_->FollowRedirect();
   EXPECT_EQ(2, resource_controller_.num_resume_calls());
 
   // Give the final response.
-  defer = false;
-  ASSERT_TRUE(handler_->OnResponseStarted(response.get(), &defer));
-  ASSERT_FALSE(defer);
+  defer_or_cancel = false;
+  handler_->OnResponseStarted(response.get(), &defer_or_cancel);
+  ASSERT_FALSE(resource_controller_.is_cancel_with_error_called());
+  ASSERT_FALSE(defer_or_cancel);
 
   net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, net::OK);
-  handler_->OnResponseCompleted(status, &defer);
-  ASSERT_FALSE(defer);
+  handler_->OnResponseCompleted(status, &defer_or_cancel);
+  ASSERT_FALSE(resource_controller_.is_cancel_with_error_called());
+  ASSERT_FALSE(defer_or_cancel);
 
   ASSERT_FALSE(url_loader_client_.has_received_completion());
   url_loader_client_.RunUntilComplete();
 
   ASSERT_TRUE(url_loader_client_.has_received_response());
   ASSERT_TRUE(url_loader_client_.has_received_completion());
   EXPECT_EQ(net::OK, url_loader_client_.completion_status().error_code);
 }
 
 TEST_P(MojoAsyncResourceHandlerWithAllocationSizeTest,
        MalformedFollowRedirectRequest) {
   handler_->FollowRedirect();
 
   EXPECT_TRUE(handler_->has_received_bad_message());
   EXPECT_EQ(0, resource_controller_.num_resume_calls());
 }
 
 // Typically ResourceHandler methods are called in this order.
 TEST_P(
     MojoAsyncResourceHandlerWithAllocationSizeTest,
     OnWillStartThenOnResponseStartedThenOnWillReadThenOnReadCompletedThenOnResponseCompleted) {
   rdh_delegate_.set_num_on_response_started_calls_expectation(1);
-  bool defer = false;
+  bool defer_or_cancel = false;
 
-  ASSERT_TRUE(handler_->OnWillStart(request_->url(), &defer));
-  ASSERT_FALSE(defer);
+  handler_->OnWillStart(request_->url(), &defer_or_cancel);
+  ASSERT_FALSE(resource_controller_.is_cancel_with_error_called());
+  ASSERT_FALSE(defer_or_cancel);
   scoped_refptr<ResourceResponse> response = new ResourceResponse();
-  ASSERT_TRUE(handler_->OnResponseStarted(response.get(), &defer));
-  ASSERT_FALSE(defer);
+  handler_->OnResponseStarted(response.get(), &defer_or_cancel);
+  ASSERT_FALSE(resource_controller_.is_cancel_with_error_called());
+  ASSERT_FALSE(defer_or_cancel);
 
   ASSERT_FALSE(url_loader_client_.has_received_response());
   url_loader_client_.RunUntilResponseReceived();
 
   int io_buffer_size = 0;
   scoped_refptr<net::IOBuffer> io_buffer;
   ASSERT_TRUE(handler_->OnWillRead(&io_buffer, &io_buffer_size, -1));
   ASSERT_TRUE(io_buffer);
   ASSERT_GT(io_buffer_size, 0);
   io_buffer->data()[0] = 'A';
 
   ASSERT_FALSE(url_loader_client_.response_body().is_valid());
   url_loader_client_.RunUntilResponseBodyArrived();
   ASSERT_TRUE(url_loader_client_.response_body().is_valid());
 
-  ASSERT_TRUE(handler_->OnReadCompleted(1, &defer));
-  ASSERT_FALSE(defer);
+  handler_->OnReadCompleted(1, &defer_or_cancel);
+  ASSERT_FALSE(resource_controller_.is_cancel_with_error_called());
+  ASSERT_FALSE(defer_or_cancel);
   net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, net::OK);
-  handler_->OnResponseCompleted(status, &defer);
-  ASSERT_FALSE(defer);
+  handler_->OnResponseCompleted(status, &defer_or_cancel);
+  ASSERT_FALSE(resource_controller_.is_cancel_with_error_called());
+  ASSERT_FALSE(defer_or_cancel);
 
   ASSERT_FALSE(url_loader_client_.has_received_completion());
   url_loader_client_.RunUntilComplete();
   EXPECT_EQ(net::OK, url_loader_client_.completion_status().error_code);
 
   // This is needed because |*io_buffer| may keep the data producer alive.
   io_buffer = nullptr;
 
   std::string body;
   while (true) {
@@ skipping 12 matching lines @@
     }
   }
   EXPECT_EQ("A", body);
 }
 
 // MimeResourceHandler calls delegated ResourceHandler's methods in this order.
 TEST_P(
     MojoAsyncResourceHandlerWithAllocationSizeTest,
     OnWillStartThenOnWillReadThenOnResponseStartedThenOnReadCompletedThenOnResponseCompleted) {
   rdh_delegate_.set_num_on_response_started_calls_expectation(1);
-  bool defer = false;
+  bool defer_or_cancel = false;
 
-  ASSERT_TRUE(handler_->OnWillStart(request_->url(), &defer));
-  ASSERT_FALSE(defer);
+  handler_->OnWillStart(request_->url(), &defer_or_cancel);
+  ASSERT_FALSE(resource_controller_.is_cancel_with_error_called());
+  ASSERT_FALSE(defer_or_cancel);
 
   int io_buffer_size = 0;
   scoped_refptr<net::IOBuffer> io_buffer;
   ASSERT_TRUE(handler_->OnWillRead(&io_buffer, &io_buffer_size, -1));
   ASSERT_TRUE(io_buffer);
   ASSERT_GT(io_buffer_size, 0);
   io_buffer->data()[0] = 'B';
 
   ASSERT_FALSE(url_loader_client_.response_body().is_valid());
   url_loader_client_.RunUntilResponseBodyArrived();
   ASSERT_TRUE(url_loader_client_.response_body().is_valid());
 
   scoped_refptr<ResourceResponse> response = new ResourceResponse();
-  ASSERT_TRUE(handler_->OnResponseStarted(response.get(), &defer));
-  ASSERT_FALSE(defer);
+  handler_->OnResponseStarted(response.get(), &defer_or_cancel);
+  ASSERT_FALSE(resource_controller_.is_cancel_with_error_called());
+  ASSERT_FALSE(defer_or_cancel);
 
   ASSERT_FALSE(url_loader_client_.has_received_response());
   url_loader_client_.RunUntilResponseReceived();
 
-  ASSERT_TRUE(handler_->OnReadCompleted(1, &defer));
-  ASSERT_FALSE(defer);
+  handler_->OnReadCompleted(1, &defer_or_cancel);
+  ASSERT_FALSE(resource_controller_.is_cancel_with_error_called());
+  ASSERT_FALSE(defer_or_cancel);
   net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, net::OK);
-  handler_->OnResponseCompleted(status, &defer);
-  ASSERT_FALSE(defer);
+  handler_->OnResponseCompleted(status, &defer_or_cancel);
+  ASSERT_FALSE(resource_controller_.is_cancel_with_error_called());
+  ASSERT_FALSE(defer_or_cancel);
 
   ASSERT_FALSE(url_loader_client_.has_received_completion());
   url_loader_client_.RunUntilComplete();
   EXPECT_EQ(net::OK, url_loader_client_.completion_status().error_code);
 
   // This is needed because |*io_buffer| may keep the data producer alive.
   io_buffer = nullptr;
 
   std::string body;
   while (true) {
@@ skipping 12 matching lines @@
     }
   }
   EXPECT_EQ("B", body);
 }
 
 INSTANTIATE_TEST_CASE_P(MojoAsyncResourceHandlerWithAllocationSizeTest,
                         MojoAsyncResourceHandlerWithAllocationSizeTest,
                         ::testing::Values(8, 32 * 2014));
 }  // namespace
 }  // namespace content