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) {
+    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 {

[mmenke, 2016/07/25 17:39:31]

Seems like we should also record and check bytes_read here.

[clamy, 2016/07/26 16:24:15]

Done.

+    DCHECK_LT(bytes_read, 2048);
+    return on_read_completed_;
+  }
+
+  void OnResponseCompleted(const net::URLRequestStatus& status,
+                           const std::string& security_info,
+                           bool* defer) override {
+    *request_status_ = status;
+  }
+
+  void OnDataDownloaded(int bytes_downloaded) override { NOTREACHED(); }
+
+  scoped_refptr<net::IOBuffer> buffer() { return buffer_; }
+
+ private:
+  scoped_refptr<net::IOBuffer> buffer_;
+  net::URLRequestStatus* request_status_;
+  bool on_response_started_;
+  bool on_will_read_;
+  bool on_read_completed_;
+  DISALLOW_COPY_AND_ASSIGN(TestResourceHandler);

[mmenke, 2016/07/25 17:39:31]

nit:  Blank line before DISALLOW_COPY_AND_ASSIGN.

[clamy, 2016/07/26 16:24:15]

Done.

+};
+
+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);
+
+  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());
+  EXPECT_EQ(net::ERR_ABORTED, 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)));
+
+  // 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)));
+}
+
+// Tests that the data received is transmitted to the newly created
+// ResourceHandler and the 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;
+  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);
+
+  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)));
+
+  // 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)));
+
+  EXPECT_EQ(net::URLRequestStatus::SUCCESS, old_handler_status.status());
+  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)));
+
+  // 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)));
+}
+
+// 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));
+  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.
+  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_buffer->data(), sizeof(kData)));
+
+  CHECK_EQ(read_buffer.get(), old_buffer.get());
+  memcpy(read_buffer->data(), kData, sizeof(kData));
+
+  // The response is received. The new handler should not change.
+  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_buffer->data(), sizeof(kData)));
+
+  // Make sure another read behave as expected.
+  memset(old_buffer->data(), '\0', 2048);
+  buf_size = 0;
+  handler->OnWillRead(&read_buffer, &buf_size, -1);
+  CHECK_EQ(read_buffer.get(), old_buffer.get());
+
+  const char kData2[] = "Data 2";
+  EXPECT_FALSE(!memcmp(kData2, old_buffer->data(), sizeof(kData2)));
+  memcpy(read_buffer->data(), kData2, sizeof(kData2));
+
+  handler->OnReadCompleted(sizeof(kData2), &defer);
+  EXPECT_FALSE(defer);
+  EXPECT_TRUE(!memcmp(kData2, old_buffer->data(), sizeof(kData2)));
+}
+
+// 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));
+  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