Update InterceptingResourceHandler tests to use MockResourceLoader.

content/browser/loader/intercepting_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/intercepting_resource_handler.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <string>
 
 #include "base/files/file_path.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
+#include "content/browser/loader/mock_resource_loader.h"
 #include "content/browser/loader/resource_controller.h"
 #include "content/browser/loader/test_resource_handler.h"
 #include "content/public/browser/resource_request_info.h"
-#include "content/public/common/previews_state.h"
 #include "content/public/common/resource_response.h"
 #include "content/public/common/webplugininfo.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/public/test/test_utils.h"
 #include "net/base/net_errors.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_status.h"
+#include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace content {
 
 namespace {
 
 class TestResourceController : public ResourceController {
  public:
   TestResourceController() = default;
   void Cancel() override {}
   void CancelAndIgnore() override {}
   void CancelWithError(int error_code) override {}
   void Resume() override { ++resume_calls_; }
 
   int resume_calls() const { return resume_calls_; }
 
  private:
   int resume_calls_ = 0;
 
   DISALLOW_COPY_AND_ASSIGN(TestResourceController);
 };
 
 class InterceptingResourceHandlerTest : public testing::Test {
  public:
-  InterceptingResourceHandlerTest() {}
+  InterceptingResourceHandlerTest()
+      : request_(context_.CreateRequest(GURL("http://www.google.com"),
+                                        net::DEFAULT_PRIORITY,
+                                        nullptr)),
+        old_handler_status_(
+            net::URLRequestStatus::FromError(net::ERR_IO_PENDING)),
+        raw_old_handler_(
+            new TestResourceHandler(&old_handler_status_, &old_handler_body_)) {
+    ResourceRequestInfo::AllocateForTesting(request_.get(),
+                                            RESOURCE_TYPE_MAIN_FRAME,
+                                            nullptr,  // context
+                                            0,        // render_process_id
+                                            0,        // render_view_id
+                                            0,        // render_frame_id
+                                            true,     // is_main_frame
+                                            false,    // parent_is_main_frame
+                                            true,     // allow_download
+                                            true,     // is_async
+                                            PREVIEWS_OFF);  // previews_state
 
- private:
+    intercepting_handler_.reset(new InterceptingResourceHandler(

[Randy Smith (Not in Mondays), 2017/01/18 00:36:33]

Isn't std::make_unique the new hotness?

[mmenke, 2017/01/18 16:27:30]

I guess?  Switched to base::MakeUnique, though it's more characters.  :(

I tend to prefer new because I hate the associated pattern:
auto foo = base::MakeUnique<Foo>(...), which I feel obscures the type of foo.

+        base::WrapUnique(raw_old_handler_), request_.get()));
+    mock_loader_.reset(new MockResourceLoader(intercepting_handler_.get()));
+  }
+
+ protected:
   TestBrowserThreadBundle thread_bundle_;
+  net::TestURLRequestContext context_;
+  std::unique_ptr<net::URLRequest> request_;
+
+  net::URLRequestStatus old_handler_status_;
+  std::string old_handler_body_;
+  TestResourceHandler* raw_old_handler_;
+
+  std::unique_ptr<InterceptingResourceHandler> intercepting_handler_;
+  std::unique_ptr<MockResourceLoader> mock_loader_;
 };
 
 // Tests that the handler behaves properly when it doesn't have to use an
 // alternate next handler.
 TEST_F(InterceptingResourceHandlerTest, NoSwitching) {
-  net::URLRequestContext context;
-  std::unique_ptr<net::URLRequest> request(context.CreateRequest(
-      GURL("http://www.google.com"), net::DEFAULT_PRIORITY, nullptr));
-  ResourceRequestInfo::AllocateForTesting(request.get(),
-                                          RESOURCE_TYPE_MAIN_FRAME,
-                                          nullptr,  // context
-                                          0,        // render_process_id
-                                          0,        // render_view_id
-                                          0,        // render_frame_id
-                                          true,     // is_main_frame
-                                          false,    // parent_is_main_frame
-                                          true,     // allow_download
-                                          true,     // is_async
-                                          PREVIEWS_OFF);  // previews_state

[mmenke, 2017/01/13 16:18:33]

All calls to this method through this entire file are identical.

-
-  net::URLRequestStatus old_handler_status;
-  std::string old_handler_body;
-  std::unique_ptr<TestResourceHandler> old_handler(
-      new TestResourceHandler(&old_handler_status, &old_handler_body));
-  TestResourceHandler* old_test_handler = old_handler.get();
-  std::unique_ptr<InterceptingResourceHandler> intercepting_handler(
-      new InterceptingResourceHandler(std::move(old_handler), request.get()));
-
-  scoped_refptr<ResourceResponse> response(new ResourceResponse);
-
   // Simulate the MimeSniffingResourceHandler buffering the data.
-  scoped_refptr<net::IOBuffer> read_buffer;
-  int buf_size = 0;
-  bool defer = false;
-  EXPECT_TRUE(intercepting_handler->OnWillStart(GURL(), &defer));
-  EXPECT_FALSE(defer);
-  EXPECT_TRUE(intercepting_handler->OnWillRead(&read_buffer, &buf_size, -1));
+  ASSERT_EQ(MockResourceLoader::Status::IDLE,
+            mock_loader_->OnWillStart(request_->url()));
+  ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->OnWillRead(-1));
 
   const std::string kData = "The data";

[mmenke, 2017/01/13 16:18:33]

I've left these declarations where they are, instead of moving them to just
before first use (Or to the top of the methods) to make review marginally
simpler.

-  EXPECT_NE(kData, std::string(old_test_handler->buffer()->data()));

[mmenke, 2017/01/13 16:18:33]

Some of these expects seem a bit silly, and make even less sense in the new code
than in the old code.

[Randy Smith (Not in Mondays), 2017/01/18 00:36:33]

I take it by implication you removed the ones that seemed silly to you?

(Also, just so I'm not missing anything: the string "The data" was never shown
to the RH stack before this point in the test, so there's no reason other than
very lucky random uninitialize memory why the above "NE" would ever be false?)

[mmenke, 2017/01/18 16:27:30]

Yes, these seemed silly, and don't really have an analog when using the
MockResourceLoader (Though suppose we could put similar tests in there instead).
Correct.

-
-  ASSERT_NE(read_buffer.get(), old_test_handler->buffer());
-  ASSERT_GT(static_cast<size_t>(buf_size), kData.length());
-  memcpy(read_buffer->data(), kData.c_str(), kData.length());
+  ASSERT_NE(mock_loader_->io_buffer(), raw_old_handler_->buffer());
 
   // The response is received. The handler should not change.
-  EXPECT_TRUE(intercepting_handler->OnResponseStarted(response.get(), &defer));
-  EXPECT_FALSE(defer);
+  ASSERT_EQ(MockResourceLoader::Status::IDLE,
+            mock_loader_->OnResponseStarted(
+                make_scoped_refptr(new ResourceResponse())));
 
   // The read is replayed by the MimeSniffingResourceHandler. The data should
   // have been received by the old intercepting_handler.
-  EXPECT_TRUE(intercepting_handler->OnReadCompleted(kData.length(), &defer));
-  EXPECT_FALSE(defer);
-  EXPECT_EQ(kData, std::string(old_test_handler->buffer()->data()));
+  ASSERT_EQ(MockResourceLoader::Status::IDLE,
+            mock_loader_->OnReadCompleted(kData));
+  EXPECT_EQ(kData, old_handler_body_);
 
-  // Make sure another read behave as expected.
-  buf_size = 0;
-  EXPECT_TRUE(intercepting_handler->OnWillRead(&read_buffer, &buf_size, -1));
-  ASSERT_EQ(read_buffer.get(), old_test_handler->buffer());
+  // Make sure another read behaves as expected.
+  ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->OnWillRead(-1));
+  ASSERT_EQ(mock_loader_->io_buffer(), raw_old_handler_->buffer());
 
   const std::string kData2 = "Data 2";
-  EXPECT_NE(kData, std::string(old_test_handler->buffer()->data()));
-  ASSERT_GT(static_cast<size_t>(buf_size), kData2.length());
-  memcpy(read_buffer->data(), kData2.c_str(), kData2.length());
-
-  EXPECT_TRUE(intercepting_handler->OnReadCompleted(kData2.length(), &defer));
-  EXPECT_FALSE(defer);
-  EXPECT_EQ(kData2, std::string(old_test_handler->buffer()->data()));
-  EXPECT_EQ(kData + kData2, old_handler_body);
+  ASSERT_EQ(MockResourceLoader::Status::IDLE,
+            mock_loader_->OnReadCompleted(kData2));
+  EXPECT_EQ(kData + kData2, old_handler_body_);
 }
 
 // Tests that the data received is transmitted to the newly created
 // ResourceHandler.
 TEST_F(InterceptingResourceHandlerTest, HandlerSwitchNoPayload) {
-  net::URLRequestContext context;
-  std::unique_ptr<net::URLRequest> request(context.CreateRequest(
-      GURL("http://www.google.com"), net::DEFAULT_PRIORITY, nullptr));
-  ResourceRequestInfo::AllocateForTesting(request.get(),
-                                          RESOURCE_TYPE_MAIN_FRAME,
-                                          nullptr,  // context
-                                          0,        // render_process_id
-                                          0,        // render_view_id
-                                          0,        // render_frame_id
-                                          true,     // is_main_frame
-                                          false,    // parent_is_main_frame
-                                          true,     // allow_download
-                                          true,     // is_async
-                                          PREVIEWS_OFF);  // previews_state
-
-  net::URLRequestStatus old_handler_status;
-  std::string old_handler_body;
-  std::unique_ptr<TestResourceHandler> old_handler(
-      new TestResourceHandler(&old_handler_status, &old_handler_body));
-  scoped_refptr<net::IOBuffer> old_buffer = old_handler.get()->buffer();
-  std::unique_ptr<InterceptingResourceHandler> intercepting_handler(
-      new InterceptingResourceHandler(std::move(old_handler), request.get()));
-
   scoped_refptr<ResourceResponse> response(new ResourceResponse);
 
   // Simulate the MimeSniffingResourceHandler buffering the data.
-  scoped_refptr<net::IOBuffer> read_buffer;
-  int buf_size = 0;
-  bool defer = false;
-  EXPECT_TRUE(intercepting_handler->OnWillStart(GURL(), &defer));
-  EXPECT_FALSE(defer);
-  EXPECT_TRUE(intercepting_handler->OnWillRead(&read_buffer, &buf_size, -1));
+  ASSERT_EQ(MockResourceLoader::Status::IDLE,
+            mock_loader_->OnWillStart(request_->url()));
+  ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->OnWillRead(-1));
 
   const std::string kData = "The data";
-  ASSERT_NE(read_buffer.get(), old_buffer.get());
-  ASSERT_GT(static_cast<size_t>(buf_size), kData.length());
-  memcpy(read_buffer->data(), kData.c_str(), kData.length());
+  ASSERT_NE(mock_loader_->io_buffer(), raw_old_handler_->buffer());
 
   // Simulate the MimeSniffingResourceHandler asking the
   // InterceptingResourceHandler to switch to a new handler.
   net::URLRequestStatus new_handler_status;
   std::string new_handler_body;
   std::unique_ptr<TestResourceHandler> new_handler_scoped(
       new TestResourceHandler(&new_handler_status, &new_handler_body));
   TestResourceHandler* new_test_handler = new_handler_scoped.get();
-  intercepting_handler->UseNewHandler(std::move(new_handler_scoped),
-                                      std::string());
+  intercepting_handler_->UseNewHandler(std::move(new_handler_scoped),
+                                       std::string());
 
   // The response is received. The new ResourceHandler should be used handle

[Randy Smith (Not in Mondays), 2017/01/18 00:36:33]

nit: "*to* handle"?

[mmenke, 2017/01/18 16:27:30]

Done.

   // the download.
-  EXPECT_TRUE(intercepting_handler->OnResponseStarted(response.get(), &defer));
-  EXPECT_FALSE(defer);
+  ASSERT_EQ(MockResourceLoader::Status::IDLE,
+            mock_loader_->OnResponseStarted(
+                make_scoped_refptr(new ResourceResponse())));
 
-  EXPECT_FALSE(old_handler_status.is_success());
-  EXPECT_EQ(net::ERR_ABORTED, old_handler_status.error());
-  EXPECT_EQ(std::string(), old_handler_body);
-
-  // It should not have received the download data yet.
-  EXPECT_NE(kData, std::string(new_test_handler->buffer()->data()));
+  EXPECT_FALSE(old_handler_status_.is_success());
+  EXPECT_EQ(net::ERR_ABORTED, old_handler_status_.error());
+  EXPECT_EQ(std::string(), old_handler_body_);
 
   // The read is replayed by the MimeSniffingResourceHandler. The data should
   // have been received by the new handler.
-  EXPECT_TRUE(intercepting_handler->OnReadCompleted(kData.length(), &defer));
-  EXPECT_FALSE(defer);
-  EXPECT_EQ(kData, std::string(new_test_handler->buffer()->data()));
+  ASSERT_EQ(MockResourceLoader::Status::IDLE,
+            mock_loader_->OnReadCompleted(kData));
+  EXPECT_EQ(kData, new_handler_body);
 
   // Make sure another read behaves as expected.
-  buf_size = 0;
-  EXPECT_TRUE(intercepting_handler->OnWillRead(&read_buffer, &buf_size, -1));
-  ASSERT_EQ(read_buffer.get(), new_test_handler->buffer());
-  ASSERT_GT(static_cast<size_t>(buf_size), kData.length());
+  ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->OnWillRead(-1));
+  ASSERT_EQ(mock_loader_->io_buffer(), new_test_handler->buffer());
 
   const std::string kData2 = "Data 2";
-  EXPECT_NE(kData2, std::string(new_test_handler->buffer()->data()));
-  memcpy(read_buffer->data(), kData2.c_str(), kData2.length());
-
-  EXPECT_TRUE(intercepting_handler->OnReadCompleted(kData2.length(), &defer));
-  EXPECT_FALSE(defer);
-  EXPECT_EQ(kData2, std::string(new_test_handler->buffer()->data()));
+  ASSERT_EQ(MockResourceLoader::Status::IDLE,
+            mock_loader_->OnReadCompleted(kData2));
   EXPECT_EQ(kData + kData2, new_handler_body);
 }
 
 // Tests that the data received is transmitted to the newly created
 // ResourceHandler and the specified payload to the old ResourceHandler.
 TEST_F(InterceptingResourceHandlerTest, HandlerSwitchWithPayload) {
-  net::URLRequestContext context;
-  std::unique_ptr<net::URLRequest> request(context.CreateRequest(
-      GURL("http://www.google.com"), net::DEFAULT_PRIORITY, nullptr));
-  ResourceRequestInfo::AllocateForTesting(request.get(),
-                                          RESOURCE_TYPE_MAIN_FRAME,
-                                          nullptr,  // context
-                                          0,        // render_process_id
-                                          0,        // render_view_id
-                                          0,        // render_frame_id
-                                          true,     // is_main_frame
-                                          false,    // parent_is_main_frame
-                                          true,     // allow_download
-                                          true,     // is_async
-                                          PREVIEWS_OFF);  // previews_state
-
-  net::URLRequestStatus old_handler_status;
-  std::string old_handler_body;
-  std::unique_ptr<TestResourceHandler> old_handler_scoped(
-      new TestResourceHandler(&old_handler_status, &old_handler_body));
   // When sending a payload to the old ResourceHandler, the
   // InterceptingResourceHandler doesn't send a final EOF read.
   // TODO(mmenke):  Should it?  Or can we just get rid of that 0-byte read
   // entirely?
-  old_handler_scoped->set_expect_eof_read(false);
-  TestResourceHandler* old_handler = old_handler_scoped.get();
-  scoped_refptr<net::IOBuffer> old_buffer = old_handler->buffer();
-  std::unique_ptr<InterceptingResourceHandler> intercepting_handler(
-      new InterceptingResourceHandler(std::move(old_handler_scoped),
-                                      request.get()));
-
-  scoped_refptr<ResourceResponse> response(new ResourceResponse);
+  raw_old_handler_->set_expect_eof_read(false);
+  scoped_refptr<net::IOBuffer> old_buffer = raw_old_handler_->buffer();
 
   // Simulate the MimeSniffingResourceHandler buffering the data.
-  scoped_refptr<net::IOBuffer> read_buffer;
-  int buf_size = 0;
-  bool defer = false;
-  EXPECT_TRUE(intercepting_handler->OnWillStart(GURL(), &defer));
-  EXPECT_FALSE(defer);
-  EXPECT_TRUE(intercepting_handler->OnWillRead(&read_buffer, &buf_size, -1));
+  ASSERT_EQ(MockResourceLoader::Status::IDLE,
+            mock_loader_->OnWillStart(request_->url()));
+  ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->OnWillRead(-1));
 
   const std::string kData = "The data";
-  ASSERT_NE(read_buffer.get(), old_buffer.get());
-  ASSERT_GT(static_cast<size_t>(buf_size), kData.length());
-  memcpy(read_buffer->data(), kData.c_str(), kData.length());
+  ASSERT_NE(mock_loader_->io_buffer(), old_buffer.get());
 
   // Simulate the MimeSniffingResourceHandler asking the
   // InterceptingResourceHandler to switch to a new handler.
   const std::string kPayload = "The payload";
   net::URLRequestStatus new_handler_status;
   std::string new_handler_body;
   std::unique_ptr<TestResourceHandler> new_handler_scoped(
       new TestResourceHandler(&new_handler_status, &new_handler_body));
   TestResourceHandler* new_test_handler = new_handler_scoped.get();
-  intercepting_handler->UseNewHandler(std::move(new_handler_scoped), kPayload);
+  intercepting_handler_->UseNewHandler(std::move(new_handler_scoped), kPayload);
 
   // The old handler should not have received the payload yet.
-  ASSERT_EQ(std::string(), old_handler_body);
+  ASSERT_EQ(std::string(), old_handler_body_);
 
   // The response is received. The new ResourceHandler should be used to handle
   // the download.
-  EXPECT_TRUE(intercepting_handler->OnResponseStarted(response.get(), &defer));
-  EXPECT_FALSE(defer);
+  ASSERT_EQ(MockResourceLoader::Status::IDLE,
+            mock_loader_->OnResponseStarted(
+                make_scoped_refptr(new ResourceResponse())));
 
   // The old handler should have received the payload.
-  EXPECT_EQ(kPayload, old_handler_body);
+  EXPECT_EQ(kPayload, old_handler_body_);
 
-  EXPECT_TRUE(old_handler_status.is_success());
-  EXPECT_EQ(net::OK, old_handler_status.error());
-
-  // It should not have received the download data yet.
-  EXPECT_NE(kData, std::string(new_test_handler->buffer()->data()));
+  EXPECT_TRUE(old_handler_status_.is_success());
+  EXPECT_EQ(net::OK, old_handler_status_.error());
 
   // The read is replayed by the MimeSniffingResourceHandler. The data should
   // have been received by the new handler.
-  EXPECT_TRUE(intercepting_handler->OnReadCompleted(kData.length(), &defer));
-  EXPECT_FALSE(defer);
-  EXPECT_EQ(kData, std::string(new_test_handler->buffer()->data()));
+  ASSERT_EQ(MockResourceLoader::Status::IDLE,
+            mock_loader_->OnReadCompleted(kData));
+  EXPECT_EQ(kData, new_handler_body);
 
-  // Make sure another read behave as expected.
-  buf_size = 0;
+  // Make sure another read behaves as expected.
   const std::string kData2 = "Data 2";
-  EXPECT_TRUE(intercepting_handler->OnWillRead(&read_buffer, &buf_size, -1));
-  ASSERT_EQ(read_buffer.get(), new_test_handler->buffer());
-  ASSERT_GT(static_cast<size_t>(buf_size), kData.length());
+  ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->OnWillRead(-1));
+  ASSERT_EQ(mock_loader_->io_buffer(), new_test_handler->buffer());
 
-  EXPECT_NE(kData2, std::string(new_test_handler->buffer()->data()));
-  memcpy(read_buffer->data(), kData2.c_str(), kData2.length());
-
-  EXPECT_TRUE(intercepting_handler->OnReadCompleted(kData2.length(), &defer));
-  EXPECT_FALSE(defer);
-  EXPECT_EQ(kData2, std::string(new_test_handler->buffer()->data()));
+  ASSERT_EQ(MockResourceLoader::Status::IDLE,
+            mock_loader_->OnReadCompleted(kData2));
   EXPECT_EQ(kData + kData2, new_handler_body);
 }
 
 // Tests that the handler behaves properly if the old handler fails will read.
 TEST_F(InterceptingResourceHandlerTest, OldHandlerFailsWillRead) {
-  net::URLRequestContext context;
-  std::unique_ptr<net::URLRequest> request(context.CreateRequest(
-      GURL("http://www.google.com"), net::DEFAULT_PRIORITY, nullptr));
-  ResourceRequestInfo::AllocateForTesting(request.get(),
-                                          RESOURCE_TYPE_MAIN_FRAME,
-                                          nullptr,  // context
-                                          0,        // render_process_id
-                                          0,        // render_view_id
-                                          0,        // render_frame_id
-                                          true,     // is_main_frame
-                                          false,    // parent_is_main_frame
-                                          true,     // allow_download
-                                          true,     // is_async
-                                          PREVIEWS_OFF);  // previews_state
-
-  net::URLRequestStatus old_handler_status;
-  std::string old_handler_body;
-  std::unique_ptr<TestResourceHandler> old_handler(
-      new TestResourceHandler(&old_handler_status, &old_handler_body));
-  old_handler->set_on_will_read_result(false);
-  std::unique_ptr<InterceptingResourceHandler> intercepting_handler(
-      new InterceptingResourceHandler(std::move(old_handler), request.get()));
-
-  scoped_refptr<ResourceResponse> response(new ResourceResponse);
+  raw_old_handler_->set_on_will_read_result(false);
 
   // Simulate the MimeSniffingResourceHandler buffering the data. The old
   // handler should tell the caller to fail.
-  scoped_refptr<net::IOBuffer> read_buffer;
-  int buf_size = 0;
-  bool defer = false;
-  EXPECT_TRUE(intercepting_handler->OnWillStart(GURL(), &defer));
-  EXPECT_FALSE(defer);
-  EXPECT_FALSE(intercepting_handler->OnWillRead(&read_buffer, &buf_size, -1));
+  ASSERT_EQ(MockResourceLoader::Status::IDLE,
+            mock_loader_->OnWillStart(request_->url()));
+  ASSERT_EQ(MockResourceLoader::Status::CANCELED, mock_loader_->OnWillRead(-1));
+  EXPECT_EQ(net::ERR_ABORTED, mock_loader_->error_code());
 }
 
 // Tests that the handler behaves properly if the new handler fails in
 // OnWillStart.
 TEST_F(InterceptingResourceHandlerTest, NewHandlerFailsOnWillStart) {
-  net::URLRequestContext context;
-  std::unique_ptr<net::URLRequest> request(context.CreateRequest(
-      GURL("http://www.google.com"), net::DEFAULT_PRIORITY, nullptr));
-  ResourceRequestInfo::AllocateForTesting(request.get(),
-                                          RESOURCE_TYPE_MAIN_FRAME,
-                                          nullptr,  // context
-                                          0,        // render_process_id
-                                          0,        // render_view_id
-                                          0,        // render_frame_id
-                                          true,     // is_main_frame
-                                          false,    // parent_is_main_frame
-                                          true,     // allow_download
-                                          true,     // is_async
-                                          PREVIEWS_OFF);  // previews_state
-
-  net::URLRequestStatus old_handler_status;
-  std::string old_handler_body;
-  std::unique_ptr<TestResourceHandler> old_handler(
-      new TestResourceHandler(&old_handler_status, &old_handler_body));
-  scoped_refptr<net::IOBuffer> old_buffer = old_handler.get()->buffer();
-  std::unique_ptr<InterceptingResourceHandler> intercepting_handler(
-      new InterceptingResourceHandler(std::move(old_handler), request.get()));
-
-  scoped_refptr<ResourceResponse> response(new ResourceResponse);
+  scoped_refptr<net::IOBuffer> old_buffer = raw_old_handler_->buffer();
 
   // Simulate the MimeSniffingResourceHandler buffering the data.
-  scoped_refptr<net::IOBuffer> read_buffer;
-  int buf_size = 0;
-  bool defer = false;
-  EXPECT_TRUE(intercepting_handler->OnWillStart(GURL(), &defer));
-  EXPECT_FALSE(defer);
-  EXPECT_TRUE(intercepting_handler->OnWillRead(&read_buffer, &buf_size, -1));
+  ASSERT_EQ(MockResourceLoader::Status::IDLE,
+            mock_loader_->OnWillStart(request_->url()));
+  ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->OnWillRead(-1));
 
-  const char kData[] = "The data";
-  ASSERT_NE(read_buffer.get(), old_buffer.get());
-  ASSERT_GT(static_cast<size_t>(buf_size), sizeof(kData));
-  memcpy(read_buffer->data(), kData, sizeof(kData));
+  ASSERT_NE(mock_loader_->io_buffer(), old_buffer.get());
 
   // Simulate the MimeSniffingResourceHandler asking the
   // InterceptingResourceHandler to switch to a new handler.
   net::URLRequestStatus new_handler_status;
   std::string new_handler_body;
   std::unique_ptr<TestResourceHandler> new_handler(
       new TestResourceHandler(&new_handler_status, &new_handler_body));
   new_handler->set_on_will_start_result(false);
-  intercepting_handler->UseNewHandler(std::move(new_handler), std::string());
+  intercepting_handler_->UseNewHandler(std::move(new_handler), std::string());
 
   // The response is received. The new ResourceHandler should tell us to fail.
-  EXPECT_FALSE(intercepting_handler->OnResponseStarted(response.get(), &defer));
-  EXPECT_FALSE(defer);
+  ASSERT_EQ(MockResourceLoader::Status::CANCELED,
+            mock_loader_->OnResponseStarted(
+                make_scoped_refptr(new ResourceResponse())));
+  EXPECT_EQ(net::ERR_ABORTED, mock_loader_->error_code());
 }
 
 // Tests that the handler behaves properly if the new handler fails response
 // started.
 TEST_F(InterceptingResourceHandlerTest, NewHandlerFailsResponseStarted) {
-  net::URLRequestContext context;
-  std::unique_ptr<net::URLRequest> request(context.CreateRequest(
-      GURL("http://www.google.com"), net::DEFAULT_PRIORITY, nullptr));
-  ResourceRequestInfo::AllocateForTesting(request.get(),
-                                          RESOURCE_TYPE_MAIN_FRAME,
-                                          nullptr,  // context
-                                          0,        // render_process_id
-                                          0,        // render_view_id
-                                          0,        // render_frame_id
-                                          true,     // is_main_frame
-                                          false,    // parent_is_main_frame
-                                          true,     // allow_download
-                                          true,     // is_async
-                                          PREVIEWS_OFF);  // previews_state
-
-  net::URLRequestStatus old_handler_status;
-  std::string old_handler_body;
-  std::unique_ptr<TestResourceHandler> old_handler(
-      new TestResourceHandler(&old_handler_status, &old_handler_body));
-  scoped_refptr<net::IOBuffer> old_buffer = old_handler.get()->buffer();
-  std::unique_ptr<InterceptingResourceHandler> intercepting_handler(
-      new InterceptingResourceHandler(std::move(old_handler), request.get()));
-
-  scoped_refptr<ResourceResponse> response(new ResourceResponse);
+  scoped_refptr<net::IOBuffer> old_buffer = raw_old_handler_->buffer();
 
   // Simulate the MimeSniffingResourceHandler buffering the data.
-  scoped_refptr<net::IOBuffer> read_buffer;
-  int buf_size = 0;
-  bool defer = false;
-  EXPECT_TRUE(intercepting_handler->OnWillStart(GURL(), &defer));
-  EXPECT_FALSE(defer);
-  EXPECT_TRUE(intercepting_handler->OnWillRead(&read_buffer, &buf_size, -1));
+  ASSERT_EQ(MockResourceLoader::Status::IDLE,
+            mock_loader_->OnWillStart(request_->url()));
+  ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->OnWillRead(-1));
 
-  const char kData[] = "The data";
-  ASSERT_NE(read_buffer.get(), old_buffer.get());
-  ASSERT_GT(static_cast<size_t>(buf_size), sizeof(kData));
-  memcpy(read_buffer->data(), kData, sizeof(kData));
+  ASSERT_NE(mock_loader_->io_buffer(), old_buffer.get());
 
   // Simulate the MimeSniffingResourceHandler asking the
   // InterceptingResourceHandler to switch to a new handler.
   net::URLRequestStatus new_handler_status;
   std::string new_handler_body;
   std::unique_ptr<TestResourceHandler> new_handler(
       new TestResourceHandler(&new_handler_status, &new_handler_body));
   new_handler->set_on_response_started_result(false);
-  intercepting_handler->UseNewHandler(std::move(new_handler), std::string());
+  intercepting_handler_->UseNewHandler(std::move(new_handler), std::string());
 
   // The response is received. The new ResourceHandler should tell us to fail.
-  EXPECT_FALSE(intercepting_handler->OnResponseStarted(response.get(), &defer));
-  EXPECT_FALSE(defer);
+  ASSERT_EQ(MockResourceLoader::Status::CANCELED,
+            mock_loader_->OnResponseStarted(
+                make_scoped_refptr(new ResourceResponse())));
+  EXPECT_EQ(net::ERR_ABORTED, mock_loader_->error_code());
 }
 
 // Tests that the handler behaves properly if the new handler fails will read.
 TEST_F(InterceptingResourceHandlerTest, NewHandlerFailsWillRead) {
-  net::URLRequestContext context;
-  std::unique_ptr<net::URLRequest> request(context.CreateRequest(
-      GURL("http://www.google.com"), net::DEFAULT_PRIORITY, nullptr));
-  ResourceRequestInfo::AllocateForTesting(request.get(),
-                                          RESOURCE_TYPE_MAIN_FRAME,
-                                          nullptr,  // context
-                                          0,        // render_process_id
-                                          0,        // render_view_id
-                                          0,        // render_frame_id
-                                          true,     // is_main_frame
-                                          false,    // parent_is_main_frame
-                                          true,     // allow_download
-                                          true,     // is_async
-                                          PREVIEWS_OFF);  // previews_state
-
-  net::URLRequestStatus old_handler_status;
-  std::string old_handler_body;
-  std::unique_ptr<TestResourceHandler> old_handler(
-      new TestResourceHandler(&old_handler_status, &old_handler_body));
-  scoped_refptr<net::IOBuffer> old_buffer = old_handler.get()->buffer();
-  std::unique_ptr<InterceptingResourceHandler> intercepting_handler(
-      new InterceptingResourceHandler(std::move(old_handler), request.get()));
-
-  scoped_refptr<ResourceResponse> response(new ResourceResponse);
+  scoped_refptr<net::IOBuffer> old_buffer = raw_old_handler_->buffer();
 
   // Simulate the MimeSniffingResourceHandler buffering the data.
-  scoped_refptr<net::IOBuffer> read_buffer;
-  int buf_size = 0;
-  bool defer = false;
-  EXPECT_TRUE(intercepting_handler->OnWillStart(GURL(), &defer));
-  EXPECT_FALSE(defer);
-  EXPECT_TRUE(intercepting_handler->OnWillRead(&read_buffer, &buf_size, -1));
+  ASSERT_EQ(MockResourceLoader::Status::IDLE,
+            mock_loader_->OnWillStart(request_->url()));
+  ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->OnWillRead(-1));
 
   const char kData[] = "The data";
-  ASSERT_NE(read_buffer.get(), old_buffer.get());
-  ASSERT_GT(static_cast<size_t>(buf_size), sizeof(kData));
-  memcpy(read_buffer->data(), kData, sizeof(kData));
+  ASSERT_NE(mock_loader_->io_buffer(), old_buffer.get());
 
   // Simulate the MimeSniffingResourceHandler asking the
   // InterceptingResourceHandler to switch to a new handler.
   net::URLRequestStatus new_handler_status;
   std::string new_handler_body;
   std::unique_ptr<TestResourceHandler> new_handler(
       new TestResourceHandler(&new_handler_status, &new_handler_body));
   new_handler->set_on_will_read_result(false);
-  intercepting_handler->UseNewHandler(std::move(new_handler), std::string());
+  intercepting_handler_->UseNewHandler(std::move(new_handler), std::string());
 
   // The response is received. The new handler should not have been asked to
   // read yet.
-  EXPECT_TRUE(intercepting_handler->OnResponseStarted(response.get(), &defer));
-  EXPECT_FALSE(defer);
-  EXPECT_EQ(net::URLRequestStatus::CANCELED, old_handler_status.status());
-  EXPECT_EQ(net::ERR_ABORTED, old_handler_status.error());
+  ASSERT_EQ(MockResourceLoader::Status::IDLE,
+            mock_loader_->OnResponseStarted(
+                make_scoped_refptr(new ResourceResponse())));
+  EXPECT_EQ(net::URLRequestStatus::CANCELED, old_handler_status_.status());
+  EXPECT_EQ(net::ERR_ABORTED, old_handler_status_.error());
 
   // The read is replayed by the MimeSniffingResourceHandler. The new
   // handler should tell the caller to fail.
-  EXPECT_FALSE(intercepting_handler->OnReadCompleted(sizeof(kData), &defer));
-  EXPECT_FALSE(defer);
+
+  ASSERT_EQ(MockResourceLoader::Status::CANCELED,
+            mock_loader_->OnReadCompleted(kData));
+  EXPECT_EQ(net::ERR_ABORTED, mock_loader_->error_code());
 }
 
 // Tests that the handler behaves properly if the new handler fails read
 // completed.
 TEST_F(InterceptingResourceHandlerTest, NewHandlerFailsReadCompleted) {
-  net::URLRequestContext context;
-  std::unique_ptr<net::URLRequest> request(context.CreateRequest(
-      GURL("http://www.google.com"), net::DEFAULT_PRIORITY, nullptr));
-  ResourceRequestInfo::AllocateForTesting(request.get(),
-                                          RESOURCE_TYPE_MAIN_FRAME,
-                                          nullptr,  // context
-                                          0,        // render_process_id
-                                          0,        // render_view_id
-                                          0,        // render_frame_id
-                                          true,     // is_main_frame
-                                          false,    // parent_is_main_frame
-                                          true,     // allow_download
-                                          true,     // is_async
-                                          PREVIEWS_OFF);  // previews_state
-
-  net::URLRequestStatus old_handler_status;
-  std::string old_handler_body;
-  std::unique_ptr<TestResourceHandler> old_handler(
-      new TestResourceHandler(&old_handler_status, &old_handler_body));
-  scoped_refptr<net::IOBuffer> old_buffer = old_handler.get()->buffer();
-  std::unique_ptr<InterceptingResourceHandler> intercepting_handler(
-      new InterceptingResourceHandler(std::move(old_handler), request.get()));
-
-  scoped_refptr<ResourceResponse> response(new ResourceResponse);
+  scoped_refptr<net::IOBuffer> old_buffer = raw_old_handler_->buffer();
 
   // Simulate the MimeSniffingResourceHandler buffering the data.
-  scoped_refptr<net::IOBuffer> read_buffer;
-  int buf_size = 0;
-  bool defer = false;
-  EXPECT_TRUE(intercepting_handler->OnWillStart(GURL(), &defer));
-  EXPECT_FALSE(defer);
-  EXPECT_TRUE(intercepting_handler->OnWillRead(&read_buffer, &buf_size, -1));
+  ASSERT_EQ(MockResourceLoader::Status::IDLE,
+            mock_loader_->OnWillStart(request_->url()));
+  ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->OnWillRead(-1));
 
   const char kData[] = "The data";
-  ASSERT_NE(read_buffer.get(), old_buffer.get());
-  ASSERT_GT(static_cast<size_t>(buf_size), sizeof(kData));
-  memcpy(read_buffer->data(), kData, sizeof(kData));
+  ASSERT_NE(mock_loader_->io_buffer(), old_buffer.get());
 
   // Simulate the MimeSniffingResourceHandler asking the
   // InterceptingResourceHandler to switch to a new handler.
   net::URLRequestStatus new_handler_status;
   std::string new_handler_body;
   std::unique_ptr<TestResourceHandler> new_handler(
       new TestResourceHandler(&new_handler_status, &new_handler_body));
   new_handler->set_on_read_completed_result(false);
-  intercepting_handler->UseNewHandler(std::move(new_handler), std::string());
+  intercepting_handler_->UseNewHandler(std::move(new_handler), std::string());

[Randy Smith (Not in Mondays), 2017/01/18 00:36:33]

Thought (i.e. not even a suggestion): This code seems like it happens often
enough that it could be turned into a helper routine.

[mmenke, 2017/01/18 16:27:30]

The problem is that in every test we set different properties on the new
handler.  We could keep an unowned pointer to it and set stuff on it after
passing it along - think that may actually be a little prettier than using
new_handler_status/new_handler_body if we removed them, too...  But think that's
a bit too much for this CL.  Also not sure if it's worth doing.

 
   // The response is received.
-  EXPECT_TRUE(intercepting_handler->OnResponseStarted(response.get(), &defer));
-  EXPECT_FALSE(defer);
-  EXPECT_EQ(net::URLRequestStatus::CANCELED, old_handler_status.status());
-  EXPECT_EQ(net::ERR_ABORTED, old_handler_status.error());
+  ASSERT_EQ(MockResourceLoader::Status::IDLE,
+            mock_loader_->OnResponseStarted(
+                make_scoped_refptr(new ResourceResponse())));
+  EXPECT_EQ(net::URLRequestStatus::CANCELED, old_handler_status_.status());
+  EXPECT_EQ(net::ERR_ABORTED, old_handler_status_.error());
 
   // The read is replayed by the MimeSniffingResourceHandler. The new handler
   // should tell the caller to fail.
-  EXPECT_FALSE(intercepting_handler->OnReadCompleted(sizeof(kData), &defer));
-  EXPECT_FALSE(defer);
+  ASSERT_EQ(MockResourceLoader::Status::CANCELED,
+            mock_loader_->OnReadCompleted(kData));
+  EXPECT_EQ(net::ERR_ABORTED, mock_loader_->error_code());
 }
 
 // The old handler sets |defer| to true in OnReadCompleted and
 // OnResponseCompleted. The new handler sets |defer| to true in
 // OnResponseStarted and OnReadCompleted.
 TEST_F(InterceptingResourceHandlerTest, DeferredOperations) {
-  net::URLRequestContext context;
-  std::unique_ptr<net::URLRequest> request(context.CreateRequest(
-      GURL("http://www.google.com"), net::DEFAULT_PRIORITY, nullptr));
-  ResourceRequestInfo::AllocateForTesting(request.get(),
-                                          RESOURCE_TYPE_MAIN_FRAME,
-                                          nullptr,  // context
-                                          0,        // render_process_id
-                                          0,        // render_view_id
-                                          0,        // render_frame_id
-                                          true,     // is_main_frame
-                                          false,    // parent_is_main_frame
-                                          true,     // allow_download
-                                          true,     // is_async
-                                          PREVIEWS_OFF);  // previews_state
-
-  std::unique_ptr<TestResourceController> resource_controller =
-      base::MakeUnique<TestResourceController>();
-  net::URLRequestStatus old_handler_status = {net::URLRequestStatus::IO_PENDING,
-                                              0};
-  std::string old_handler_body;
-  std::unique_ptr<TestResourceHandler> old_handler(
-      new TestResourceHandler(&old_handler_status, &old_handler_body));
   // When sending a payload to the old ResourceHandler, the
   // InterceptingResourceHandler doesn't send a final EOF read.
   // TODO(mmenke):  Should it?  Or can we just get rid of that 0-byte read
   // entirely?
-  old_handler->set_expect_eof_read(false);
-  old_handler->SetBufferSize(10);
-  old_handler->set_defer_on_read_completed(true);
-
-  scoped_refptr<net::IOBuffer> old_buffer = old_handler.get()->buffer();
-  std::unique_ptr<InterceptingResourceHandler> intercepting_handler(
-      new InterceptingResourceHandler(std::move(old_handler), request.get()));
-  intercepting_handler->SetController(resource_controller.get());
-
-  scoped_refptr<ResourceResponse> response(new ResourceResponse);
+  raw_old_handler_->set_expect_eof_read(false);
+  raw_old_handler_->SetBufferSize(10);
+  raw_old_handler_->set_defer_on_read_completed(true);
+  scoped_refptr<net::IOBuffer> old_buffer = raw_old_handler_->buffer();
 
   // Simulate the MimeSniffingResourceHandler buffering the data.
-  scoped_refptr<net::IOBuffer> read_buffer;
-  int buf_size = 0;
-  bool defer = false;
-  EXPECT_TRUE(intercepting_handler->OnWillStart(GURL(), &defer));
-  EXPECT_FALSE(defer);
-  EXPECT_TRUE(intercepting_handler->OnWillRead(&read_buffer, &buf_size, -1));
+  ASSERT_EQ(MockResourceLoader::Status::IDLE,
+            mock_loader_->OnWillStart(request_->url()));
+  ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->OnWillRead(-1));
 
   const char kData[] = "The data";
-  ASSERT_NE(read_buffer.get(), old_buffer.get());
-  ASSERT_GT(static_cast<size_t>(buf_size), strlen(kData));
-  memcpy(read_buffer->data(), kData, strlen(kData));
+  ASSERT_NE(mock_loader_->io_buffer(), old_buffer.get());
 
   // Simulate the MimeSniffingResourceHandler asking the
   // InterceptingResourceHandler to switch to a new handler.
   net::URLRequestStatus new_handler_status = {net::URLRequestStatus::IO_PENDING,
                                               0};
 
   std::string new_handler_body;
   const std::string kPayload = "The long long long long long payload";
-  ASSERT_GT(kPayload.size(), static_cast<size_t>(buf_size));
   std::unique_ptr<TestResourceHandler> new_handler(
       new TestResourceHandler(&new_handler_status, &new_handler_body));
+  TestResourceHandler* raw_new_handler = new_handler.get();
   new_handler->SetBufferSize(1);
   new_handler->set_defer_on_will_start(true);
   new_handler->set_defer_on_response_started(true);
   new_handler->set_defer_on_read_completed(true);
   new_handler->set_defer_on_response_completed(true);
-  intercepting_handler->UseNewHandler(std::move(new_handler), kPayload);
+  intercepting_handler_->UseNewHandler(std::move(new_handler), kPayload);
 
   // The response is received, and then deferred by the old handler's
   // OnReadCompleted method.
-  ASSERT_TRUE(intercepting_handler->OnResponseStarted(response.get(), &defer));
-  ASSERT_TRUE(defer);
+  ASSERT_EQ(MockResourceLoader::Status::CALLBACK_PENDING,
+            mock_loader_->OnResponseStarted(
+                make_scoped_refptr(new ResourceResponse())));
 
   // The old handler has received the first N bytes of the payload synchronously
   // where N is the size of the buffer exposed via OnWillRead.
-  EXPECT_EQ("The long l", old_handler_body);
+  EXPECT_EQ("The long l", old_handler_body_);

[Randy Smith (Not in Mondays), 2017/01/18 00:36:33]

nit, suggestion: Compute "The long l" as per the comment rather than hardcoding
it?

[mmenke, 2017/01/18 16:27:30]

Done.  Also took the opportunity to move all consts to the start of each test,
which I think makes the tests easier to figure out.

   EXPECT_EQ(std::string(), new_handler_body);
-  EXPECT_EQ(old_handler_status.status(), net::URLRequestStatus::IO_PENDING);
-  EXPECT_EQ(new_handler_status.status(), net::URLRequestStatus::IO_PENDING);
+  EXPECT_EQ(net::URLRequestStatus::IO_PENDING, old_handler_status_.status());
+  EXPECT_EQ(net::URLRequestStatus::IO_PENDING, new_handler_status.status());
 
   // Run until the new handler's OnWillStart method defers the request.
-  intercepting_handler->Resume();
-  EXPECT_EQ(0, resource_controller->resume_calls());
-  EXPECT_EQ(kPayload, old_handler_body);
+  raw_old_handler_->Resume();
+  // Resume() call may do work asynchronously. Wait until that's done.
+  base::RunLoop().RunUntilIdle();
+  ASSERT_EQ(MockResourceLoader::Status::CALLBACK_PENDING,
+            mock_loader_->status());
+  EXPECT_EQ(kPayload, old_handler_body_);
   EXPECT_EQ(std::string(), new_handler_body);
-  EXPECT_EQ(old_handler_status.status(), net::URLRequestStatus::SUCCESS);
-  EXPECT_EQ(new_handler_status.status(), net::URLRequestStatus::IO_PENDING);
+  EXPECT_EQ(net::URLRequestStatus::SUCCESS, old_handler_status_.status());
+  EXPECT_EQ(net::URLRequestStatus::IO_PENDING, new_handler_status.status());
 
   // Run until the new handler's OnResponseStarted method defers the request.
-  intercepting_handler->Resume();
-  EXPECT_EQ(0, resource_controller->resume_calls());
+  raw_new_handler->Resume();
+  // Resume() call may do work asynchronously. Wait until that's done.
+  ASSERT_EQ(MockResourceLoader::Status::CALLBACK_PENDING,
+            mock_loader_->status());
   EXPECT_EQ(std::string(), new_handler_body);
-  EXPECT_EQ(old_handler_status.status(), net::URLRequestStatus::SUCCESS);
-  EXPECT_EQ(new_handler_status.status(), net::URLRequestStatus::IO_PENDING);
+  EXPECT_EQ(net::URLRequestStatus::SUCCESS, old_handler_status_.status());

[Randy Smith (Not in Mondays), 2017/01/18 00:36:33]

suggestion: Find a way to assert that the old hander's been torn down?

[mmenke, 2017/01/18 16:27:30]

Done.  Made TestResourceHandler expose a WeakPtr, and use that instead of
unowned pointers everywhere in this test.  Also removed the old_handler status
checks below this line, since now we know it's been deleted.

+  EXPECT_EQ(net::URLRequestStatus::IO_PENDING, new_handler_status.status());
 
   // Resuming should finally call back into the ResourceController.
-  intercepting_handler->Resume();
-  EXPECT_EQ(1, resource_controller->resume_calls());
+  raw_new_handler->Resume();
+  mock_loader_->WaitUntilIdleOrCanceled();
+  ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->status());
 
   // Data is read, the new handler defers completion of the read.
-  defer = false;
-  ASSERT_TRUE(intercepting_handler->OnReadCompleted(strlen(kData), &defer));
-  ASSERT_TRUE(defer);
+  ASSERT_EQ(MockResourceLoader::Status::CALLBACK_PENDING,
+            mock_loader_->OnReadCompleted(kData));
 
-  EXPECT_EQ(kPayload, old_handler_body);
+  EXPECT_EQ(kPayload, old_handler_body_);
   EXPECT_EQ("T", new_handler_body);
 
-  intercepting_handler->Resume();
-  EXPECT_EQ(2, resource_controller->resume_calls());
-  EXPECT_EQ(kPayload, old_handler_body);
+  raw_new_handler->Resume();
+  mock_loader_->WaitUntilIdleOrCanceled();
+  ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->status());
+  EXPECT_EQ(kPayload, old_handler_body_);
   EXPECT_EQ(kData, new_handler_body);
 
-  EXPECT_EQ(old_handler_status.status(), net::URLRequestStatus::SUCCESS);
-  EXPECT_EQ(new_handler_status.status(), net::URLRequestStatus::IO_PENDING);
+  EXPECT_EQ(net::URLRequestStatus::SUCCESS, old_handler_status_.status());
+  EXPECT_EQ(net::URLRequestStatus::IO_PENDING, new_handler_status.status());
 
   // Final EOF byte is read.
-  ASSERT_TRUE(intercepting_handler->OnReadCompleted(0, &defer));
-  ASSERT_FALSE(defer);
+  ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->OnWillRead(-1));
+  ASSERT_EQ(MockResourceLoader::Status::IDLE,
+            mock_loader_->OnReadCompleted(""));
 
-  defer = false;
-  intercepting_handler->OnResponseCompleted({net::URLRequestStatus::SUCCESS, 0},
-                                            &defer);
-  ASSERT_TRUE(defer);
-  EXPECT_EQ(old_handler_status.status(), net::URLRequestStatus::SUCCESS);
-  EXPECT_EQ(new_handler_status.status(), net::URLRequestStatus::SUCCESS);
+  ASSERT_EQ(
+      MockResourceLoader::Status::CALLBACK_PENDING,
+      mock_loader_->OnResponseCompleted({net::URLRequestStatus::SUCCESS, 0}));
+  EXPECT_EQ(net::URLRequestStatus::SUCCESS, old_handler_status_.status());
+  EXPECT_EQ(net::URLRequestStatus::SUCCESS, new_handler_status.status());
 }
 
 // Test cancellation where there is only the old handler in an
 // InterceptingResourceHandler.
 TEST_F(InterceptingResourceHandlerTest, CancelOldHandler) {
-  net::URLRequestContext context;
-  std::unique_ptr<net::URLRequest> request(context.CreateRequest(
-      GURL("http://www.google.com"), net::DEFAULT_PRIORITY, nullptr));
-  ResourceRequestInfo::AllocateForTesting(request.get(),
-                                          RESOURCE_TYPE_MAIN_FRAME,
-                                          nullptr,  // context
-                                          0,        // render_process_id
-                                          0,        // render_view_id
-                                          0,        // render_frame_id
-                                          true,     // is_main_frame
-                                          false,    // parent_is_main_frame
-                                          true,     // allow_download
-                                          true,     // is_async
-                                          PREVIEWS_OFF);  // previews_state
+  EXPECT_EQ(net::URLRequestStatus::IO_PENDING, old_handler_status_.status());

[Randy Smith (Not in Mondays), 2017/01/18 00:36:33]

Thought: Not sure this EXPECT makes a lot of sense except for documentation. 
NE(CANCELED) might be a more appropriate test.

[mmenke, 2017/01/18 16:27:30]

Done.  You're right, it doesn't, just blindly kept it from the old test.  Added
error code checks below all net::URLRequestStatus::CANCELED checks.

 
-  std::unique_ptr<TestResourceController> resource_controller =
-      base::MakeUnique<TestResourceController>();
-  net::URLRequestStatus old_handler_status = {net::URLRequestStatus::IO_PENDING,
-                                              0};
-  std::string old_handler_body;
-  std::unique_ptr<TestResourceHandler> old_handler(
-      new TestResourceHandler(&old_handler_status, &old_handler_body));
-
-  std::unique_ptr<InterceptingResourceHandler> intercepting_handler(
-      new InterceptingResourceHandler(std::move(old_handler), request.get()));
-  intercepting_handler->SetController(resource_controller.get());
-
-  EXPECT_EQ(net::URLRequestStatus::IO_PENDING, old_handler_status.status());
-
-  bool defer = false;
-  intercepting_handler->OnResponseCompleted(
-      {net::URLRequestStatus::CANCELED, net::ERR_FAILED}, &defer);
-  ASSERT_FALSE(defer);
-  EXPECT_EQ(0, resource_controller->resume_calls());
-  EXPECT_EQ(net::URLRequestStatus::CANCELED, old_handler_status.status());
+  ASSERT_EQ(MockResourceLoader::Status::IDLE,
+            mock_loader_->OnResponseCompletedFromExternalOutOfBandCancel(
+                {net::URLRequestStatus::CANCELED, net::ERR_FAILED}));
+  EXPECT_EQ(net::URLRequestStatus::CANCELED, old_handler_status_.status());
 }
 
 // Test cancellation where there is only the new handler in an
 // InterceptingResourceHandler.
 TEST_F(InterceptingResourceHandlerTest, CancelNewHandler) {
-  net::URLRequestContext context;
-  std::unique_ptr<net::URLRequest> request(context.CreateRequest(
-      GURL("http://www.google.com"), net::DEFAULT_PRIORITY, nullptr));
-  ResourceRequestInfo::AllocateForTesting(request.get(),
-                                          RESOURCE_TYPE_MAIN_FRAME,
-                                          nullptr,  // context
-                                          0,        // render_process_id
-                                          0,        // render_view_id
-                                          0,        // render_frame_id
-                                          true,     // is_main_frame
-                                          false,    // parent_is_main_frame
-                                          true,     // allow_download
-                                          true,     // is_async
-                                          PREVIEWS_OFF);  // previews_state
-
-  std::unique_ptr<TestResourceController> resource_controller =
-      base::MakeUnique<TestResourceController>();
-  net::URLRequestStatus old_handler_status = {net::URLRequestStatus::IO_PENDING,
-                                              0};
-  std::string old_handler_body;
-  std::unique_ptr<TestResourceHandler> old_handler(
-      new TestResourceHandler(&old_handler_status, &old_handler_body));
   // When sending a payload to the old ResourceHandler, the
   // InterceptingResourceHandler doesn't send a final EOF read.
   // TODO(mmenke):  Should it?  Or can we just get rid of that 0-byte read
   // entirely?
-  old_handler->set_expect_eof_read(false);
-
-  std::unique_ptr<InterceptingResourceHandler> intercepting_handler(
-      new InterceptingResourceHandler(std::move(old_handler), request.get()));
-  intercepting_handler->SetController(resource_controller.get());
-
-  scoped_refptr<ResourceResponse> response(new ResourceResponse);
+  raw_old_handler_->set_expect_eof_read(false);
 
   // Simulate the MimeSniffingResourceHandler buffering the data.
-  scoped_refptr<net::IOBuffer> read_buffer;
-  int buf_size = 0;
-  bool defer = false;
-  EXPECT_TRUE(intercepting_handler->OnWillStart(GURL(), &defer));
-  EXPECT_FALSE(defer);
-  EXPECT_TRUE(intercepting_handler->OnWillRead(&read_buffer, &buf_size, -1));
-
-  const char kData[] = "The data";
-  ASSERT_GT(static_cast<size_t>(buf_size), strlen(kData));
-  memcpy(read_buffer->data(), kData, strlen(kData));
+  ASSERT_EQ(MockResourceLoader::Status::IDLE,
+            mock_loader_->OnWillStart(request_->url()));
+  ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->OnWillRead(-1));
 
   // Simulate the MimeSniffingResourceHandler asking the
   // InterceptingResourceHandler to switch to a new handler.
   net::URLRequestStatus new_handler_status = {net::URLRequestStatus::IO_PENDING,
                                               0};
 
   std::string new_handler_body;
   const std::string kPayload = "The payload";
   std::unique_ptr<TestResourceHandler> new_handler(
       new TestResourceHandler(&new_handler_status, &new_handler_body));
   new_handler->SetBufferSize(1);
   new_handler->set_defer_on_response_started(true);
   new_handler->set_defer_on_response_completed(true);
-  intercepting_handler->UseNewHandler(std::move(new_handler), kPayload);
+  intercepting_handler_->UseNewHandler(std::move(new_handler), kPayload);
 
   // The response is received.
-  ASSERT_TRUE(intercepting_handler->OnResponseStarted(response.get(), &defer));
-  ASSERT_TRUE(defer);
+  ASSERT_EQ(MockResourceLoader::Status::CALLBACK_PENDING,
+            mock_loader_->OnResponseStarted(
+                make_scoped_refptr(new ResourceResponse())));
 
-  EXPECT_EQ(net::URLRequestStatus::SUCCESS, old_handler_status.status());
+  EXPECT_EQ(net::URLRequestStatus::SUCCESS, old_handler_status_.status());
   EXPECT_EQ(net::URLRequestStatus::IO_PENDING, new_handler_status.status());
 
-  defer = false;
-  intercepting_handler->OnResponseCompleted(
-      {net::URLRequestStatus::CANCELED, net::ERR_FAILED}, &defer);
-  ASSERT_TRUE(defer);
-  EXPECT_EQ(0, resource_controller->resume_calls());
-  EXPECT_EQ(net::URLRequestStatus::SUCCESS, old_handler_status.status());
+  ASSERT_EQ(MockResourceLoader::Status::CALLBACK_PENDING,
+            mock_loader_->OnResponseCompletedFromExternalOutOfBandCancel(
+                {net::URLRequestStatus::CANCELED, net::ERR_FAILED}));
+  EXPECT_EQ(net::URLRequestStatus::SUCCESS, old_handler_status_.status());
   EXPECT_EQ(net::URLRequestStatus::CANCELED, new_handler_status.status());
 }
 
 // Test cancellation where there are both the old and the new handlers in an
 // InterceptingResourceHandler.
 TEST_F(InterceptingResourceHandlerTest, CancelBothHandlers) {
-  net::URLRequestContext context;
-  std::unique_ptr<net::URLRequest> request(context.CreateRequest(
-      GURL("http://www.google.com"), net::DEFAULT_PRIORITY, nullptr));
-  ResourceRequestInfo::AllocateForTesting(request.get(),
-                                          RESOURCE_TYPE_MAIN_FRAME,
-                                          nullptr,  // context
-                                          0,        // render_process_id
-                                          0,        // render_view_id
-                                          0,        // render_frame_id
-                                          true,     // is_main_frame
-                                          false,    // parent_is_main_frame
-                                          true,     // allow_download
-                                          true,     // is_async
-                                          PREVIEWS_OFF);  // previews_state
-
-  std::unique_ptr<TestResourceController> resource_controller =
-      base::MakeUnique<TestResourceController>();
-  net::URLRequestStatus old_handler_status = {net::URLRequestStatus::IO_PENDING,
-                                              0};
-  std::string old_handler_body;
-  std::unique_ptr<TestResourceHandler> old_handler(
-      new TestResourceHandler(&old_handler_status, &old_handler_body));
-  old_handler->set_defer_on_read_completed(true);
-
-  std::unique_ptr<InterceptingResourceHandler> intercepting_handler(
-      new InterceptingResourceHandler(std::move(old_handler), request.get()));
-  intercepting_handler->SetController(resource_controller.get());
-
-  scoped_refptr<ResourceResponse> response(new ResourceResponse);
+  raw_old_handler_->set_defer_on_read_completed(true);
 
   // Simulate the MimeSniffingResourceHandler buffering the data.
-  scoped_refptr<net::IOBuffer> read_buffer;
-  int buf_size = 0;
-  bool defer = false;
-  EXPECT_TRUE(intercepting_handler->OnWillStart(GURL(), &defer));
-  EXPECT_FALSE(defer);
-  EXPECT_TRUE(intercepting_handler->OnWillRead(&read_buffer, &buf_size, -1));
-
-  const char kData[] = "The data";
-  ASSERT_GT(static_cast<size_t>(buf_size), strlen(kData));
-  memcpy(read_buffer->data(), kData, strlen(kData));
+  ASSERT_EQ(MockResourceLoader::Status::IDLE,
+            mock_loader_->OnWillStart(request_->url()));
+  ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->OnWillRead(-1));
 
   // Simulate the MimeSniffingResourceHandler asking the
   // InterceptingResourceHandler to switch to a new handler.
   net::URLRequestStatus new_handler_status = {net::URLRequestStatus::IO_PENDING,
                                               0};
 
   std::string new_handler_body;
   const std::string kPayload = "The payload";
   std::unique_ptr<TestResourceHandler> new_handler(
       new TestResourceHandler(&new_handler_status, &new_handler_body));
   new_handler->SetBufferSize(1);
   new_handler->set_defer_on_response_completed(true);
-  intercepting_handler->UseNewHandler(std::move(new_handler), kPayload);
+  intercepting_handler_->UseNewHandler(std::move(new_handler), kPayload);
 
   // The response is received.
-  ASSERT_TRUE(intercepting_handler->OnResponseStarted(response.get(), &defer));
-  ASSERT_TRUE(defer);
+  ASSERT_EQ(MockResourceLoader::Status::CALLBACK_PENDING,
+            mock_loader_->OnResponseStarted(
+                make_scoped_refptr(new ResourceResponse())));
 
-  EXPECT_EQ(net::URLRequestStatus::IO_PENDING, old_handler_status.status());
+  EXPECT_EQ(net::URLRequestStatus::IO_PENDING, old_handler_status_.status());
   EXPECT_EQ(net::URLRequestStatus::IO_PENDING, new_handler_status.status());
 
-  defer = false;
-  intercepting_handler->OnResponseCompleted(
-      {net::URLRequestStatus::CANCELED, net::ERR_FAILED}, &defer);
-  ASSERT_TRUE(defer);
-  EXPECT_EQ(0, resource_controller->resume_calls());
-  EXPECT_EQ(net::URLRequestStatus::CANCELED, old_handler_status.status());
+  ASSERT_EQ(MockResourceLoader::Status::CALLBACK_PENDING,
+            mock_loader_->OnResponseCompletedFromExternalOutOfBandCancel(
+                {net::URLRequestStatus::CANCELED, net::ERR_FAILED}));
+  EXPECT_EQ(net::URLRequestStatus::CANCELED, old_handler_status_.status());
   EXPECT_EQ(net::URLRequestStatus::CANCELED, new_handler_status.status());
 }
 
 }  // namespace
 
 }  // namespace content