Update MimeSniffingResourceHandler tests to use MockResourceLoader.

content/browser/loader/mock_resource_loader.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/mock_resource_loader.h"
 
 #include <memory>
 
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
@@ skipping 17 matching lines @@
   EXPECT_EQ(Status::IDLE, status_);
   status_ = Status::CALLING_HANDLER;
 
   bool defer = false;
   bool result = resource_handler_->OnWillStart(url, &defer);
   // The second case isn't really allowed, but a number of classes do it
   // anyways.
   EXPECT_TRUE(status_ == Status::CALLING_HANDLER ||
               (result == false && status_ == Status::CANCELED));
   if (!result) {
+    // In the case of double-cancels, keep the old error code.
+    if (status_ != Status::CANCELED)
+      error_code_ = net::ERR_ABORTED;
     status_ = Status::CANCELED;
   } else if (defer) {
     status_ = Status::CALLBACK_PENDING;
   } else {
     status_ = Status::IDLE;
   }
   return status_;
 }
 
 MockResourceLoader::Status MockResourceLoader::OnRequestRedirected(
     const net::RedirectInfo& redirect_info,
     scoped_refptr<ResourceResponse> response) {
   EXPECT_EQ(Status::IDLE, status_);
   status_ = Status::CALLING_HANDLER;
 
   bool defer = false;
   bool result = resource_handler_->OnRequestRedirected(redirect_info,
                                                        response.get(), &defer);
   // The second case isn't really allowed, but a number of classes do it
   // anyways.
   EXPECT_TRUE(status_ == Status::CALLING_HANDLER ||
               (result == false && status_ == Status::CANCELED));
   if (!result) {
+    // In the case of double-cancels, keep the old error code.
+    if (status_ != Status::CANCELED)
+      error_code_ = net::ERR_ABORTED;
     status_ = Status::CANCELED;
   } else if (defer) {
     status_ = Status::CALLBACK_PENDING;
   } else {
     status_ = Status::IDLE;
   }
   return status_;
 }
 
 MockResourceLoader::Status MockResourceLoader::OnResponseStarted(
     scoped_refptr<ResourceResponse> response) {
   EXPECT_EQ(Status::IDLE, status_);
   status_ = Status::CALLING_HANDLER;
 
   bool defer = false;
   bool result = resource_handler_->OnResponseStarted(response.get(), &defer);
   // The second case isn't really allowed, but a number of classes do it
   // anyways.
   EXPECT_TRUE(status_ == Status::CALLING_HANDLER ||
               (result == false && status_ == Status::CANCELED));
   if (!result) {
+    // In the case of double-cancels, keep the old error code.
+    if (status_ != Status::CANCELED)
+      error_code_ = net::ERR_ABORTED;
     status_ = Status::CANCELED;
   } else if (defer) {
     status_ = Status::CALLBACK_PENDING;
   } else {
     status_ = Status::IDLE;
   }
   return status_;
 }
 
 MockResourceLoader::Status MockResourceLoader::OnWillRead(int min_size) {
   EXPECT_EQ(Status::IDLE, status_);
   EXPECT_FALSE(io_buffer_);
   EXPECT_EQ(0, io_buffer_size_);
 
   status_ = Status::CALLING_HANDLER;
 
   bool result =
       resource_handler_->OnWillRead(&io_buffer_, &io_buffer_size_, min_size);
   // The second case isn't really allowed, but a number of classes do it
   // anyways.
   EXPECT_TRUE(status_ == Status::CALLING_HANDLER ||
               (result == false && status_ == Status::CANCELED));
   if (!result) {
     EXPECT_EQ(0, io_buffer_size_);
     EXPECT_FALSE(io_buffer_);
     status_ = Status::CANCELED;
+    error_code_ = net::ERR_ABORTED;
   } else {
     EXPECT_LE(min_size, io_buffer_size_);
     EXPECT_LT(0, io_buffer_size_);
     EXPECT_TRUE(io_buffer_);
     status_ = Status::IDLE;
   }
   return status_;
 };
 
 MockResourceLoader::Status MockResourceLoader::OnReadCompleted(
     base::StringPiece bytes) {
   EXPECT_EQ(Status::IDLE, status_);
   EXPECT_LE(bytes.size(), static_cast<size_t>(io_buffer_size_));
 
   status_ = Status::CALLING_HANDLER;
   std::copy(bytes.begin(), bytes.end(), io_buffer_->data());
   io_buffer_ = nullptr;
   io_buffer_size_ = 0;
   status_ = Status::CALLING_HANDLER;
 
   bool defer = false;
   bool result = resource_handler_->OnReadCompleted(bytes.size(), &defer);
   // The second case isn't really allowed, but a number of classes do it
   // anyways.
   EXPECT_TRUE(status_ == Status::CALLING_HANDLER ||
               (result == false && status_ == Status::CANCELED));
   if (!result) {
+    // In the case of double-cancels, keep the old error code.
+    if (status_ != Status::CANCELED)
+      error_code_ = net::ERR_ABORTED;
     status_ = Status::CANCELED;
   } else if (defer) {
     status_ = Status::CALLBACK_PENDING;
   } else {
     status_ = Status::IDLE;
   }
   return status_;
 }
 
 MockResourceLoader::Status MockResourceLoader::OnResponseCompleted(
@@ skipping 78 matching lines @@
 }
 
 void MockResourceLoader::Resume() {
   EXPECT_EQ(Status::CALLBACK_PENDING, status_);
   status_ = Status::IDLE;
   if (canceled_or_idle_run_loop_)
     canceled_or_idle_run_loop_->Quit();
 }
 
 }  // namespace content