Move MimeTypeResourceHandler before ThrottlingResourceHandler

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 "base/files/file_path.h"
+#include "base/location.h"
+#include "base/logging.h"
+#include "base/macros.h"
+#include "base/single_thread_task_runner.h"
+#include "base/threading/thread_task_runner_handle.h"
+#include "content/public/browser/resource_controller.h"
+#include "content/public/browser/resource_request_info.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 "testing/gtest/include/gtest/gtest.h"
+#include "url/gurl.h"
+
+namespace content {
+
+namespace {
+
+class TestResourceHandler : public ResourceHandler {
+ public:
+  explicit TestResourceHandler(net::URLRequestStatus* request_status,
+                               size_t* final_bytes_read)

[mmenke, 2016/08/22 20:39:04]

Think these should be documented.

[clamy, 2016/09/01 23:19:41]

Done.

+      : TestResourceHandler(request_status,
+                            final_bytes_read,
+                            true,
+                            true,
+                            true) {}
+
+  TestResourceHandler(net::URLRequestStatus* request_status,
+                      size_t* final_bytes_read,
+                      bool on_response_started,
+                      bool on_will_read,
+                      bool on_read_completed)

[mmenke, 2016/08/22 20:39:04]

Maybe add _result to the last 3 values (And update comments labeling them around
callsites)?  Or document them, just want it to be clearer they're the return
values of the corresponding functions.  Or could make an enum FailureMode {
FAIL_ON_RESPONSE_STARTED, FAIL_ON_WILL_READ, ... }.  I'm happy with any option.

[clamy, 2016/09/01 23:19:41]

Done.

+      : ResourceHandler(nullptr),
+        buffer_(new net::IOBuffer(2048)),
+        request_status_(request_status),
+        final_bytes_read_(final_bytes_read),
+        on_response_started_(on_response_started),
+        on_will_read_(on_will_read),
+        on_read_completed_(on_read_completed),
+        bytes_read_(0),
+        is_completed_(false) {
+    memset(buffer_->data(), '\0', 2048);
+  }
+
+  ~TestResourceHandler() override {}
+
+  void SetController(ResourceController* controller) override {}
+
+  bool OnRequestRedirected(const net::RedirectInfo& redirect_info,
+                           ResourceResponse* response,
+                           bool* defer) override {
+    NOTREACHED();
+    return false;
+  }
+
+  bool OnResponseStarted(ResourceResponse* response, bool* defer) override {
+    EXPECT_FALSE(is_completed_);
+    return on_response_started_;
+  }
+
+  bool OnWillStart(const GURL& url, bool* defer) override {
+    EXPECT_FALSE(is_completed_);
+    return false;
+  }
+
+  bool OnWillRead(scoped_refptr<net::IOBuffer>* buf,
+                  int* buf_size,
+                  int min_size) override {
+    EXPECT_FALSE(is_completed_);
+    *buf = buffer_;
+    *buf_size = 2048;
+    return on_will_read_;
+  }
+
+  bool OnReadCompleted(int bytes_read, bool* defer) override {
+    EXPECT_FALSE(is_completed_);
+    DCHECK_LT(bytes_read, 2048);
+    bytes_read_ += bytes_read;
+    return on_read_completed_;
+  }
+
+  void OnResponseCompleted(const net::URLRequestStatus& status,
+                           const std::string& security_info,
+                           bool* defer) override {
+    EXPECT_FALSE(is_completed_);
+    is_completed_ = true;
+    *request_status_ = status;
+    *final_bytes_read_ = bytes_read_;
+  }
+
+  void OnDataDownloaded(int bytes_downloaded) override { NOTREACHED(); }
+
+  scoped_refptr<net::IOBuffer> buffer() const { return buffer_; }
+
+  size_t bytes_read() const { return bytes_read_; }
+
+ private:
+  scoped_refptr<net::IOBuffer> buffer_;
+  net::URLRequestStatus* request_status_;
+  size_t* final_bytes_read_;
+  bool on_response_started_;
+  bool on_will_read_;
+  bool on_read_completed_;
+  size_t bytes_read_;
+  bool is_completed_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestResourceHandler);
+};
+
+class InterceptingResourceHandlerTest : public testing::Test {
+ public:
+  InterceptingResourceHandlerTest() {}
+
+ private:
+  TestBrowserThreadBundle thread_bundle_;
+};
+
+// 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
+                                          false);   // is_using_lofi
+
+  net::URLRequestStatus old_handler_status;
+  size_t old_handler_final_bytes_read = 0;
+  std::unique_ptr<TestResourceHandler> old_handler(new TestResourceHandler(
+      &old_handler_status, &old_handler_final_bytes_read));
+  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;
+  intercepting_handler->OnWillStart(GURL(), &defer);

[mmenke, 2016/08/22 20:39:04]

EXPECT_TRUE(intercepting_handler->OnWillStart(GURL(), &defer));?
EXPECT_FALSE(&defer);?

[clamy, 2016/09/01 23:19:40]

Done.

+  intercepting_handler->OnWillRead(&read_buffer, &buf_size, -1);

[mmenke, 2016/08/22 20:39:04]

EXPECT_TRUE(intercepting_handler->OnWillRead(&read_buffer, &buf_size, -1));

Not going to go through and annotate all of these, but think we should check all
return/buffer values (Not because defer isn't allowed to be set to true here,
but the test fixture doesn't support it)

[clamy, 2016/09/01 23:19:41]

Done.

+
+  const char kData[] = "The data";
+  CHECK_EQ(read_buffer.get(), old_buffer.get());

[mmenke, 2016/08/22 20:39:04]

ASSERT_EQ?  (Same goes for other lines like this, further down)

[mmenke, 2016/08/22 20:39:04]

check buf_size as well?

[clamy, 2016/09/01 23:19:41]

Done.

+  memcpy(read_buffer->data(), kData, sizeof(kData));
+
+  // Simulate the MimeSniffingResourceHandler asking the
+  // InterceptingResourceHandler to switch to a new handler.
+  net::URLRequestStatus new_handler_status;
+  size_t new_handler_final_bytes_read = 0;
+  std::unique_ptr<TestResourceHandler> new_handler_scoped(
+      new TestResourceHandler(&new_handler_status,
+                              &new_handler_final_bytes_read));
+  TestResourceHandler* new_test_handler = new_handler_scoped.get();
+  intercepting_handler->UseNewHandler(std::move(new_handler_scoped),
+                                      std::string());
+
+  // The response is received. The new ResourceHandler should be used handle
+  // the download.
+  intercepting_handler->OnResponseStarted(response.get(), &defer);
+  EXPECT_FALSE(defer);
+
+  EXPECT_FALSE(old_handler_status.is_success());
+  EXPECT_EQ(net::ERR_ABORTED, old_handler_status.error());
+  EXPECT_EQ(0ul, old_handler_final_bytes_read);
+
+  // It should not have received the download data yet.
+  EXPECT_FALSE(
+      !memcmp(kData, new_test_handler->buffer()->data(), sizeof(kData)));

[mmenke, 2016/08/22 20:39:04]

Check that the new handler hasn't read any bytes yet, too?

[clamy, 2016/09/01 23:19:41]

Done.

+
+  // The read is replayed by the MimeSniffingResourceHandler. The data should
+  // have been received by the new handler.
+  intercepting_handler->OnReadCompleted(sizeof(kData), &defer);

[mmenke, 2016/08/22 20:39:04]

EXPECT_TRUE

[clamy, 2016/09/01 23:19:41]

Done.

+  EXPECT_FALSE(defer);
+  EXPECT_EQ(sizeof(kData), new_test_handler->bytes_read());
+  EXPECT_TRUE(
+      !memcmp(kData, new_test_handler->buffer()->data(), sizeof(kData)));

[mmenke, 2016/08/22 20:39:04]

Suggest "EXPECT_EQ(kData, std::string(new_test_handler->buffer()->data(),
new_test_handler->bytes_read()));"  That results in more useful output on
failure.

Or better, you could make new_test_handler have a method to return
std:string(new_test_handler->buffer()->data(), new_test_handler->bytes_read()),
and just use that.

You could then also remove the "EXPECT_EQ(sizeof(kData),
new_test_handler->bytes_read());" lines, since the comparisons now implicitly
include that information.

[clamy, 2016/09/01 23:19:41]

This method doesn't work if we do more than one read, since bytes_read is the
total amount of bytes read. This happens below.

+
+  // Make sure another read behave as expected.

[mmenke, 2016/08/22 20:39:04]

nit:  behaves.

[clamy, 2016/09/01 23:19:41]

Done.

+  memset(new_test_handler->buffer()->data(), '\0', 2048);

[mmenke, 2016/08/22 20:39:04]

Should this be done in TestHandler::OnWillRead instead?

[clamy, 2016/09/01 23:19:41]

Done.

+  buf_size = 0;
+  intercepting_handler->OnWillRead(&read_buffer, &buf_size, -1);
+  CHECK_EQ(read_buffer.get(), new_test_handler->buffer());

[mmenke, 2016/08/22 20:39:04]

ASSERT_EQ

[clamy, 2016/09/01 23:19:41]

Done.

+
+  const char kData2[] = "Data 2";
+  EXPECT_FALSE(
+      !memcmp(kData2, new_test_handler->buffer()->data(), sizeof(kData2)));
+  memcpy(read_buffer->data(), kData2, sizeof(kData2));
+
+  intercepting_handler->OnReadCompleted(sizeof(kData2), &defer);
+  EXPECT_FALSE(defer);
+  EXPECT_TRUE(
+      !memcmp(kData2, new_test_handler->buffer()->data(), sizeof(kData2)));
+  EXPECT_EQ(sizeof(kData) + sizeof(kData2), new_test_handler->bytes_read());
+}
+
+// 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
+                                          false);   // is_using_lofi
+
+  net::URLRequestStatus old_handler_status;
+  size_t old_handler_final_bytes_read = 0;
+  std::unique_ptr<TestResourceHandler> old_handler_scoped(
+      new TestResourceHandler(&old_handler_status,
+                              &old_handler_final_bytes_read));
+  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);
+
+  // Simulate the MimeSniffingResourceHandler buffering the data.
+  scoped_refptr<net::IOBuffer> read_buffer;
+  int buf_size = 0;
+  bool defer = false;
+  intercepting_handler->OnWillStart(GURL(), &defer);
+  intercepting_handler->OnWillRead(&read_buffer, &buf_size, -1);
+
+  const char kData[] = "The data";
+  CHECK_EQ(read_buffer.get(), old_buffer.get());
+  memcpy(read_buffer->data(), kData, sizeof(kData));
+
+  // Simulate the MimeSniffingResourceHandler asking the
+  // InterceptingResourceHandler to switch to a new handler.
+  const std::string kPayload = "The payload";
+  net::URLRequestStatus new_handler_status;
+  size_t new_handler_final_bytes_read = 0;
+  std::unique_ptr<TestResourceHandler> new_handler_scoped(
+      new TestResourceHandler(&new_handler_status,
+                              &new_handler_final_bytes_read));
+  TestResourceHandler* new_test_handler = new_handler_scoped.get();
+  intercepting_handler->UseNewHandler(std::move(new_handler_scoped), kPayload);
+
+  // The old handler should not have received the payload yet.
+  ASSERT_FALSE(old_handler->bytes_read());
+  EXPECT_FALSE(!memcmp(kPayload.c_str(), old_buffer->data(), kPayload.size()));
+
+  // The response is received. The new ResourceHandler should be used to handle
+  // the download.
+  intercepting_handler->OnResponseStarted(response.get(), &defer);
+  EXPECT_FALSE(defer);
+
+  // The old handler should have received the payload.
+  ASSERT_TRUE(old_handler_final_bytes_read == kPayload.size());
+  EXPECT_TRUE(!memcmp(kPayload.c_str(), old_buffer->data(), kPayload.size()));
+
+  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_FALSE(
+      !memcmp(kData, new_test_handler->buffer()->data(), sizeof(kData)));
+
+  // The read is replayed by the MimeSniffingResourceHandler. The data should
+  // have been received by the new handler.
+  intercepting_handler->OnReadCompleted(sizeof(kData), &defer);
+  EXPECT_FALSE(defer);
+  EXPECT_TRUE(
+      !memcmp(kData, new_test_handler->buffer()->data(), sizeof(kData)));
+  EXPECT_EQ(sizeof(kData), new_test_handler->bytes_read());
+
+  // Make sure another read behave as expected.
+  memset(new_test_handler->buffer()->data(), '\0', 2048);
+  buf_size = 0;
+  intercepting_handler->OnWillRead(&read_buffer, &buf_size, -1);
+  CHECK_EQ(read_buffer.get(), new_test_handler->buffer());
+
+  const char kData2[] = "Data 2";
+  EXPECT_FALSE(
+      !memcmp(kData2, new_test_handler->buffer()->data(), sizeof(kData2)));
+  memcpy(read_buffer->data(), kData2, sizeof(kData2));
+
+  intercepting_handler->OnReadCompleted(sizeof(kData2), &defer);
+  EXPECT_FALSE(defer);
+  EXPECT_TRUE(
+      !memcmp(kData2, new_test_handler->buffer()->data(), sizeof(kData2)));
+  EXPECT_EQ(sizeof(kData) + sizeof(kData2), new_test_handler->bytes_read());
+}
+
+// Tests that the handler behaves properly when it doesn't have to use an
+// alternate next handler.
+TEST_F(InterceptingResourceHandlerTest, NoSwitching) {

[mmenke, 2016/08/22 20:39:04]

nit:  Suggest this test first, as the base / simple case.

[clamy, 2016/09/01 23:19:41]

Done.

+  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
+                                          false);   // is_using_lofi
+
+  net::URLRequestStatus old_handler_status;
+  size_t old_handler_final_bytes_read = 0;
+  std::unique_ptr<TestResourceHandler> old_handler(new TestResourceHandler(
+      &old_handler_status, &old_handler_final_bytes_read));
+  TestResourceHandler* old_test_handler = old_handler.get();
+  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;
+  intercepting_handler->OnWillStart(GURL(), &defer);
+  intercepting_handler->OnWillRead(&read_buffer, &buf_size, -1);
+
+  const char kData[] = "The data";
+  EXPECT_FALSE(
+      !memcmp(kData, old_test_handler->buffer()->data(), sizeof(kData)));
+
+  CHECK_EQ(read_buffer.get(), old_test_handler->buffer());
+  memcpy(read_buffer->data(), kData, sizeof(kData));
+
+  // The response is received. The handler should not change.
+  intercepting_handler->OnResponseStarted(response.get(), &defer);
+  EXPECT_FALSE(defer);
+
+  // The read is replayed by the MimeSniffingResourceHandler. The data should
+  // have been received by the old intercepting_handler.
+  intercepting_handler->OnReadCompleted(sizeof(kData), &defer);
+  EXPECT_FALSE(defer);
+  EXPECT_TRUE(
+      !memcmp(kData, old_test_handler->buffer()->data(), sizeof(kData)));
+  EXPECT_EQ(sizeof(kData), old_test_handler->bytes_read());
+
+  // Make sure another read behave as expected.
+  memset(old_test_handler->buffer()->data(), '\0', 2048);
+  buf_size = 0;
+  intercepting_handler->OnWillRead(&read_buffer, &buf_size, -1);
+  CHECK_EQ(read_buffer.get(), old_test_handler->buffer());
+
+  const char kData2[] = "Data 2";
+  EXPECT_FALSE(
+      !memcmp(kData2, old_test_handler->buffer()->data(), sizeof(kData2)));
+  memcpy(read_buffer->data(), kData2, sizeof(kData2));
+
+  intercepting_handler->OnReadCompleted(sizeof(kData2), &defer);
+  EXPECT_FALSE(defer);
+  EXPECT_TRUE(
+      !memcmp(kData2, old_test_handler->buffer()->data(), sizeof(kData2)));
+  EXPECT_EQ(sizeof(kData) + sizeof(kData2), old_test_handler->bytes_read());
+}
+
+// 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
+                                          false);   // is_using_lofi
+
+  net::URLRequestStatus old_handler_status;
+  size_t old_handler_final_bytes_read = 0;
+  std::unique_ptr<TestResourceHandler> old_handler(new TestResourceHandler(
+      &old_handler_status, &old_handler_final_bytes_read,
+      true,    // on_response_started
+      false,   // on_will_read
+      true));  // on_read_completed
+  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. The old
+  // handler should tell the caller to fail.
+  scoped_refptr<net::IOBuffer> read_buffer;
+  int buf_size = 0;
+  bool defer = false;
+  intercepting_handler->OnWillStart(GURL(), &defer);
+  EXPECT_FALSE(intercepting_handler->OnWillRead(&read_buffer, &buf_size, -1));
+}
+
+// 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
+                                          false);   // is_using_lofi
+
+  net::URLRequestStatus old_handler_status;
+  size_t old_handler_final_bytes_read = 0;
+  std::unique_ptr<TestResourceHandler> old_handler(new TestResourceHandler(
+      &old_handler_status, &old_handler_final_bytes_read));
+  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;
+  intercepting_handler->OnWillStart(GURL(), &defer);
+  EXPECT_TRUE(intercepting_handler->OnWillRead(&read_buffer, &buf_size, -1));
+
+  const char kData[] = "The data";
+  CHECK_EQ(read_buffer.get(), old_buffer.get());
+  memcpy(read_buffer->data(), kData, sizeof(kData));
+
+  // Simulate the MimeSniffingResourceHandler asking the
+  // InterceptingResourceHandler to switch to a new handler.
+  net::URLRequestStatus new_handler_status;
+  size_t new_handler_final_bytes_read = 0;
+  std::unique_ptr<TestResourceHandler> new_handler(new TestResourceHandler(
+      &new_handler_status, &new_handler_final_bytes_read,
+      false,   // on_response_started
+      true,    // on_will_read
+      true));  // on_read_completed
+  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);
+}
+
+// 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
+                                          false);   // is_using_lofi
+
+  net::URLRequestStatus old_handler_status;
+  size_t old_handler_final_bytes_read = 0;
+  std::unique_ptr<TestResourceHandler> old_handler(new TestResourceHandler(
+      &old_handler_status, &old_handler_final_bytes_read));
+  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;
+  intercepting_handler->OnWillStart(GURL(), &defer);
+  EXPECT_TRUE(intercepting_handler->OnWillRead(&read_buffer, &buf_size, -1));
+
+  const char kData[] = "The data";
+  CHECK_EQ(read_buffer.get(), old_buffer.get());
+  memcpy(read_buffer->data(), kData, sizeof(kData));
+
+  // Simulate the MimeSniffingResourceHandler asking the
+  // InterceptingResourceHandler to switch to a new handler.
+  net::URLRequestStatus new_handler_status;
+  size_t new_handler_final_bytes_read = 0;
+  std::unique_ptr<TestResourceHandler> new_handler(new TestResourceHandler(
+      &new_handler_status, &new_handler_final_bytes_read,
+      true,    // on_response_started
+      false,   // on_will_read
+      true));  // on_read_completed
+  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());
+
+  // 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);
+}
+
+// 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
+                                          false);   // is_using_lofi
+
+  net::URLRequestStatus old_handler_status;
+  size_t old_handler_final_bytes_read = 0;
+  std::unique_ptr<TestResourceHandler> old_handler(new TestResourceHandler(
+      &old_handler_status, &old_handler_final_bytes_read));
+  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;
+  intercepting_handler->OnWillStart(GURL(), &defer);
+  EXPECT_TRUE(intercepting_handler->OnWillRead(&read_buffer, &buf_size, -1));
+
+  const char kData[] = "The data";
+  CHECK_EQ(read_buffer.get(), old_buffer.get());
+  memcpy(read_buffer->data(), kData, sizeof(kData));
+
+  // Simulate the MimeSniffingResourceHandler asking the
+  // InterceptingResourceHandler to switch to a new handler.
+  net::URLRequestStatus new_handler_status;
+  size_t new_handler_final_bytes_read = 0;
+  std::unique_ptr<TestResourceHandler> new_handler(new TestResourceHandler(
+      &new_handler_status, &new_handler_final_bytes_read,
+      true,     // on_response_started
+      true,     // on_will_read
+      false));  // on_read_completed
+  intercepting_handler->UseNewHandler(std::move(new_handler), std::string());
+
+  // 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());
+
+  // 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);
+}
+
+}  // namespace
+
+}  // namespace content