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)
+      : TestResourceHandler(request_status, true, true, true) {}
+
+  TestResourceHandler(net::URLRequestStatus* request_status,
+                      bool on_response_started,
+                      bool on_will_read,
+                      bool on_read_completed)
+      : ResourceHandler(nullptr),
+        buffer_(new net::IOBuffer(2048)),
+        request_status_(request_status),
+        on_response_started_(on_response_started),
+        on_will_read_(on_will_read),
+        on_read_completed_(on_read_completed),
+        bytes_read_(0) {
+    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 {
+    return on_response_started_;
+  }
+
+  bool OnWillStart(const GURL& url, bool* defer) override { return false; }
+
+  bool OnWillRead(scoped_refptr<net::IOBuffer>* buf,
+                  int* buf_size,
+                  int min_size) override {
+    *buf = buffer_;
+    *buf_size = 2048;
+    return on_will_read_;
+  }
+
+  bool OnReadCompleted(int bytes_read, bool* defer) override {
+    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 {
+    *request_status_ = status;

[mmenke, 2016/07/27 19:34:00]

Should we set an is_completed_ bool here to true, and EXPECT that it's false at
the start of all these override methods?

[clamy, 2016/08/17 12:47:34]

Done.

+  }
+
+  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_;
+  bool on_response_started_;
+  bool on_will_read_;
+  bool on_read_completed_;
+  size_t bytes_read_;
+
+  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;
+  std::unique_ptr<ResourceHandler> old_handler(
+      new TestResourceHandler(&old_handler_status));
+  scoped_refptr<net::IOBuffer> old_buffer =
+      static_cast<TestResourceHandler*>(old_handler.get())->buffer();
+  std::unique_ptr<ResourceHandler> handler(
+      new InterceptingResourceHandler(std::move(old_handler), request.get()));
+  InterceptingResourceHandler* intercepting_handler =
+      static_cast<InterceptingResourceHandler*>(handler.get());
+
+  scoped_refptr<ResourceResponse> response(new ResourceResponse);
+
+  // Simulate the MimeSniffingResourceHandler buffering the data.
+  scoped_refptr<net::IOBuffer> read_buffer;
+  int buf_size = 0;
+  handler->OnWillRead(&read_buffer, &buf_size, -1);

[mmenke, 2016/07/27 19:34:00]

Seems like we should always call OnWillStart first, just to more accurately
mimic what happens in production.  It's less important in this test than others,
but seems less regression prone.

[clamy, 2016/08/17 12:47:34]

Done.

+
+  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;
+  std::unique_ptr<ResourceHandler> new_handler(
+      new TestResourceHandler(&new_handler_status));
+  TestResourceHandler* new_test_handler =
+      static_cast<TestResourceHandler*>(new_handler.get());
+  intercepting_handler->UseNewHandler(std::move(new_handler), std::string());
+
+  // The response is received. The new ResourceHandler should be used handle
+  // the download.
+  bool defer = false;
+  handler->OnResponseStarted(response.get(), &defer);
+  EXPECT_FALSE(defer);
+
+  EXPECT_EQ(net::URLRequestStatus::CANCELED, old_handler_status.status());

[mmenke, 2016/07/27 19:33:59]

EXPECT_FALSE(old_handler_status.is_success());

This avoids depending on the CANCELED/FAILED distinction.  I eventually want to
get rid of CANCELED.

[clamy, 2016/08/17 12:47:34]

Done.

+  EXPECT_EQ(net::ERR_ABORTED, old_handler_status.error());

[mmenke, 2016/07/27 19:34:00]

Should check the old handler hasn't received anything yet.

[clamy, 2016/08/17 12:47:34]

Done.

+
+  // 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.
+  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());

[mmenke, 2016/07/27 19:33:59]

This should probably go before comparing memory, and be an ASSERT_EQ.  Same goes
for the other instances of this pattern in this file.

[clamy, 2016/08/17 12:47:34]

Done.

+
+  // Make sure another read behave as expected.
+  memset(new_test_handler->buffer()->data(), '\0', 2048);
+  buf_size = 0;
+  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));
+
+  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 payload to the old ResourceHandler.

[mmenke, 2016/07/27 19:34:00]

nit:  Maybe the payload -> "a payload", "the specified payload" or even just
"|payload|".  "the payload" alone seems a bit ambiguous.

[clamy, 2016/08/17 12:47:34]

Done.

+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;
+  std::unique_ptr<ResourceHandler> old_handler(
+      new TestResourceHandler(&old_handler_status));
+  scoped_refptr<net::IOBuffer> old_buffer =
+      static_cast<TestResourceHandler*>(old_handler.get())->buffer();
+  std::unique_ptr<ResourceHandler> handler(
+      new InterceptingResourceHandler(std::move(old_handler), request.get()));
+  InterceptingResourceHandler* intercepting_handler =
+      static_cast<InterceptingResourceHandler*>(handler.get());

[mmenke, 2016/07/27 19:33:59]

Please try and remove all static_casts in this file.

[clamy, 2016/08/17 12:47:34]

Done.

+
+  scoped_refptr<ResourceResponse> response(new ResourceResponse);
+
+  // Simulate the MimeSniffingResourceHandler buffering the data.
+  scoped_refptr<net::IOBuffer> read_buffer;
+  int buf_size = 0;
+  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 char kPayload[] = "The payload";
+  net::URLRequestStatus new_handler_status;
+  std::unique_ptr<ResourceHandler> new_handler(
+      new TestResourceHandler(&new_handler_status));
+  TestResourceHandler* new_test_handler =
+      static_cast<TestResourceHandler*>(new_handler.get());
+  intercepting_handler->UseNewHandler(std::move(new_handler), kPayload);
+
+  // The old handler should not have received the payload yet.
+  EXPECT_FALSE(!memcmp(kPayload, old_buffer->data(), sizeof(kPayload)));

[mmenke, 2016/07/27 19:34:00]

Seems safer the ASSERT bytes_read is 0 instead.

[clamy, 2016/08/17 12:47:34]

Done.

+
+  // The response is received. The new ResourceHandler should be used to handle
+  // the download.
+  bool defer = false;
+  handler->OnResponseStarted(response.get(), &defer);
+  EXPECT_FALSE(defer);
+
+  // The old handler should have received the payload.
+  EXPECT_TRUE(!memcmp(kPayload, old_buffer->data(), sizeof(kPayload)));

[mmenke, 2016/07/27 19:34:00]

Again, should ASSERT on size first.  Alternatively, you could make
TestResourceHandler::OnReadCompleted append the data that was read to a
std::string, and just compare the string, instead of comparing bytes read + a
memcmp.

[clamy, 2016/08/17 12:47:34]

Done. Went with the size ASSERT since the Handler can be deleted in the middle
(but we keep a ref on the buffer).

+
+  EXPECT_EQ(net::URLRequestStatus::SUCCESS, old_handler_status.status());

[mmenke, 2016/07/27 19:34:00]

EXPECT_TRUE(old_handler_status.status().is_success()); is preferred.

[clamy, 2016/08/17 12:47:34]

Done.

+  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.
+  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;
+  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));
+
+  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) {
+  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;
+  std::unique_ptr<ResourceHandler> old_handler(
+      new TestResourceHandler(&old_handler_status));
+  TestResourceHandler* old_test_handler =
+      static_cast<TestResourceHandler*>(old_handler.get());
+  std::unique_ptr<ResourceHandler> 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;
+  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 new handler should not change.

[mmenke, 2016/07/27 19:34:00]

There is no new handler in this test, is there?

[clamy, 2016/08/17 12:47:34]

Yes. I meant "The handler should not change.". Corrected the comment.

+  bool defer = false;
+  handler->OnResponseStarted(response.get(), &defer);
+  EXPECT_FALSE(defer);
+
+  // The read is replayed by the MimeSniffingResourceHandler. The data should
+  // have been received by the old handler.
+  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;
+  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));
+
+  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;
+  std::unique_ptr<ResourceHandler> old_handler(
+      new TestResourceHandler(&old_handler_status, true, false, true));

[mmenke, 2016/07/27 19:33:59]

One all new TestResourceHandler calls, the bools should be labelled.

[clamy, 2016/08/17 12:47:34]

Done.

+  scoped_refptr<net::IOBuffer> old_buffer =
+      static_cast<TestResourceHandler*>(old_handler.get())->buffer();
+  std::unique_ptr<ResourceHandler> 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 us to fail.
+  scoped_refptr<net::IOBuffer> read_buffer;
+  int buf_size = 0;
+  EXPECT_FALSE(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;
+  std::unique_ptr<ResourceHandler> old_handler(
+      new TestResourceHandler(&old_handler_status));
+  scoped_refptr<net::IOBuffer> old_buffer =
+      static_cast<TestResourceHandler*>(old_handler.get())->buffer();
+  std::unique_ptr<ResourceHandler> handler(
+      new InterceptingResourceHandler(std::move(old_handler), request.get()));
+  InterceptingResourceHandler* intercepting_handler =
+      static_cast<InterceptingResourceHandler*>(handler.get());
+
+  scoped_refptr<ResourceResponse> response(new ResourceResponse);
+
+  // Simulate the MimeSniffingResourceHandler buffering the data.
+  scoped_refptr<net::IOBuffer> read_buffer;
+  int buf_size = 0;
+  EXPECT_TRUE(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;
+  std::unique_ptr<ResourceHandler> new_handler(
+      new TestResourceHandler(&new_handler_status, false, true, true));
+  intercepting_handler->UseNewHandler(std::move(new_handler), std::string());
+
+  // The response is received. The new ResourceHandler should tell us to fail.
+  bool defer = false;
+  EXPECT_FALSE(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;
+  std::unique_ptr<ResourceHandler> old_handler(
+      new TestResourceHandler(&old_handler_status));
+  scoped_refptr<net::IOBuffer> old_buffer =
+      static_cast<TestResourceHandler*>(old_handler.get())->buffer();
+  std::unique_ptr<ResourceHandler> handler(
+      new InterceptingResourceHandler(std::move(old_handler), request.get()));
+  InterceptingResourceHandler* intercepting_handler =
+      static_cast<InterceptingResourceHandler*>(handler.get());
+
+  scoped_refptr<ResourceResponse> response(new ResourceResponse);
+
+  // Simulate the MimeSniffingResourceHandler buffering the data.
+  scoped_refptr<net::IOBuffer> read_buffer;
+  int buf_size = 0;
+  EXPECT_TRUE(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;
+  std::unique_ptr<ResourceHandler> new_handler(
+      new TestResourceHandler(&new_handler_status, true, false, true));
+  intercepting_handler->UseNewHandler(std::move(new_handler), std::string());
+
+  // The response is received. The new handler should not have been asked to
+  // read yet.
+  bool defer = false;
+  EXPECT_TRUE(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 us to fail.
+  EXPECT_FALSE(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;
+  std::unique_ptr<ResourceHandler> old_handler(
+      new TestResourceHandler(&old_handler_status));
+  scoped_refptr<net::IOBuffer> old_buffer =
+      static_cast<TestResourceHandler*>(old_handler.get())->buffer();
+  std::unique_ptr<ResourceHandler> handler(
+      new InterceptingResourceHandler(std::move(old_handler), request.get()));
+  InterceptingResourceHandler* intercepting_handler =
+      static_cast<InterceptingResourceHandler*>(handler.get());
+
+  scoped_refptr<ResourceResponse> response(new ResourceResponse);
+
+  // Simulate the MimeSniffingResourceHandler buffering the data.
+  scoped_refptr<net::IOBuffer> read_buffer;
+  int buf_size = 0;
+  EXPECT_TRUE(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;
+  std::unique_ptr<ResourceHandler> new_handler(
+      new TestResourceHandler(&new_handler_status, true, true, false));
+  intercepting_handler->UseNewHandler(std::move(new_handler), std::string());
+
+  // The response is received.
+  bool defer = false;
+  EXPECT_TRUE(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 us to fail.
+  EXPECT_FALSE(handler->OnReadCompleted(sizeof(kData), &defer));
+  EXPECT_FALSE(defer);
+}
+
+}  // namespace
+
+}  // namespace content