Move MimeTypeResourceHandler before ThrottlingResourceHandler

content/browser/loader/mime_sniffing_resource_handler_unittest.cc

 // Copyright 2014 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/mime_type_resource_handler.h"
+#include "content/browser/loader/mime_sniffing_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/browser/loader/intercepting_resource_handler.h"
 #include "content/browser/loader/resource_dispatcher_host_impl.h"
 #include "content/public/browser/resource_controller.h"
 #include "content/public/browser/resource_dispatcher_host_delegate.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 "content/test/fake_plugin_service.h"
 #include "net/url_request/url_request_context.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace content {
 
 namespace {
 
 class TestResourceHandler : public ResourceHandler {
  public:
-  TestResourceHandler() : ResourceHandler(nullptr) {}
+  TestResourceHandler(bool response_started_succeeds,
+                      bool defer_on_response_started,
+                      bool will_read_succeeds,
+                      bool read_completed_succeeds,
+                      bool defer_on_read_completed)
+      : ResourceHandler(nullptr),
+        buffer_(new net::IOBuffer(2048)),
+        response_started_succeeds_(response_started_succeeds),
+        defer_on_response_started_(defer_on_response_started),
+        will_read_succeeds_(will_read_succeeds),
+        read_completed_succeeds_(read_completed_succeeds),
+        defer_on_read_completed_(defer_on_read_completed) {}
 
   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 false;
+    if (defer_on_response_started_)
+      *defer = true;
+    return response_started_succeeds_;
   }
 
-  bool OnWillStart(const GURL& url, bool* defer) override {
-    return false;
-  }
+  bool OnWillStart(const GURL& url, bool* defer) override { return false; }
 
   bool OnWillRead(scoped_refptr<net::IOBuffer>* buf,
                   int* buf_size,
                   int min_size) override {
-    NOTREACHED();
-    return false;
+    *buf = buffer_;
+    *buf_size = 2048;
+    return will_read_succeeds_;
   }
 
   bool OnReadCompleted(int bytes_read, bool* defer) override {
-    NOTREACHED();
-    return false;
+    DCHECK_LT(bytes_read, 2048);
+    if (defer_on_read_completed_)
+      *defer = true;
+    return read_completed_succeeds_;
   }
 
   void OnResponseCompleted(const net::URLRequestStatus& status,
                            const std::string& security_info,
-                           bool* defer) override {
-  }
+                           bool* defer) override {}
 
-  void OnDataDownloaded(int bytes_downloaded) override {
-    NOTREACHED();
+  void OnDataDownloaded(int bytes_downloaded) override { NOTREACHED(); }
+
+  scoped_refptr<net::IOBuffer> buffer() { return buffer_; }
+
+ private:
+  scoped_refptr<net::IOBuffer> buffer_;
+  bool response_started_succeeds_;
+  bool defer_on_response_started_;
+  bool will_read_succeeds_;
+  bool read_completed_succeeds_;
+  bool defer_on_read_completed_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestResourceHandler);
+};
+
+class TestResourceDispatcherHostDelegate
+    : public ResourceDispatcherHostDelegate {
+ public:
+  explicit TestResourceDispatcherHostDelegate(bool must_download)
+      : must_download_(must_download) {}
+
+  bool ShouldForceDownloadResource(const GURL& url,
+                                   const std::string& mime_type) override {
+    return must_download_;
   }
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(TestResourceHandler);
+  const bool must_download_;
 };
 
 class TestResourceDispatcherHost : public ResourceDispatcherHostImpl {
  public:
   explicit TestResourceDispatcherHost(bool stream_has_handler)
       : stream_has_handler_(stream_has_handler),
         intercepted_as_stream_(false),
-        intercepted_as_stream_count_(0) {}
+        intercepted_as_stream_count_(0),
+        new_resource_handler_(nullptr) {}
 
   bool intercepted_as_stream() const { return intercepted_as_stream_; }
 
   std::unique_ptr<ResourceHandler> CreateResourceHandlerForDownload(
       net::URLRequest* request,
       bool is_content_initiated,
       bool must_download) override {
-    return std::unique_ptr<ResourceHandler>(new TestResourceHandler);
+    return CreateNewResourceHandler();
   }
 
   std::unique_ptr<ResourceHandler> MaybeInterceptAsStream(
       const base::FilePath& plugin_path,
       net::URLRequest* request,
       ResourceResponse* response,
       std::string* payload) override {
     intercepted_as_stream_count_++;
-    if (stream_has_handler_) {
+    if (stream_has_handler_)
       intercepted_as_stream_ = true;
-      return std::unique_ptr<ResourceHandler>(new TestResourceHandler);
-    } else {
-      return std::unique_ptr<ResourceHandler>();
-    }
+    return CreateNewResourceHandler();
   }
 
   int intercepted_as_stream_count() const {
     return intercepted_as_stream_count_;
   }
 
+  TestResourceHandler* new_resource_handler() const {
+    return new_resource_handler_;
+  }
+
  private:
+  std::unique_ptr<ResourceHandler> CreateNewResourceHandler() {
+    std::unique_ptr<TestResourceHandler> new_resource_handler(
+        new TestResourceHandler(false, false, true, true, false));
+    new_resource_handler_ = new_resource_handler.get();
+    return std::move(new_resource_handler);
+  }
+
   // Whether the URL request should be intercepted as a stream.
   bool stream_has_handler_;
 
   // Whether the URL request has been intercepted as a stream.
   bool intercepted_as_stream_;
 
   // Count of number of times MaybeInterceptAsStream function get called in a
   // test.
   int intercepted_as_stream_count_;
-};
 
-class TestResourceDispatcherHostDelegate
-    : public ResourceDispatcherHostDelegate {
- public:
-  TestResourceDispatcherHostDelegate(bool must_download)
-      : must_download_(must_download) {
-  }
-
-  bool ShouldForceDownloadResource(const GURL& url,
-                                   const std::string& mime_type) override {
-    return must_download_;
-  }
-
- private:
-  const bool must_download_;
-};
-
-class TestResourceController : public ResourceController {
- public:
-  void Cancel() override {}
-
-  void CancelAndIgnore() override {
-    NOTREACHED();
-  }
-
-  void CancelWithError(int error_code) override {
-    NOTREACHED();
-  }
-
-  void Resume() override {
-    NOTREACHED();
-  }
+  // The last alternative TestResourceHandler created by this
+  // TestResourceDispatcherHost.
+  TestResourceHandler* new_resource_handler_;
 };
 
 class TestFakePluginService : public FakePluginService {
  public:
   // If |is_plugin_stale| is true, GetPluginInfo will indicate the plugins are
   // stale until GetPlugins is called.
   TestFakePluginService(bool plugin_available, bool is_plugin_stale)
       : plugin_available_(plugin_available),
         is_plugin_stale_(is_plugin_stale) {}
 
@@ skipping 23 matching lines @@
         FROM_HERE, base::Bind(callback, plugins));
   }
 
  private:
   const bool plugin_available_;
   bool is_plugin_stale_;
 
   DISALLOW_COPY_AND_ASSIGN(TestFakePluginService);
 };
 
-class MimeTypeResourceHandlerTest : public testing::Test {
+class TestResourceController : public ResourceController {
  public:
-  MimeTypeResourceHandlerTest()
+  TestResourceController() : cancel_call_count_(0), resume_call_count_(0) {}
+
+  void Cancel() override { cancel_call_count_++; }
+
+  void CancelAndIgnore() override { NOTREACHED(); }
+
+  void CancelWithError(int error_code) override { NOTREACHED(); }
+
+  void Resume() override { resume_call_count_++; }
+
+  int cancel_call_count() const { return cancel_call_count_; }
+  int resume_call_count() const { return resume_call_count_; }
+
+ private:
+  int cancel_call_count_;
+  int resume_call_count_;
+};
+
+}  // namespace
+
+class MimeSniffingResourceHandlerTest : public testing::Test {
+ public:
+  MimeSniffingResourceHandlerTest()
       : stream_has_handler_(false),
         plugin_available_(false),
         plugin_stale_(false) {}
 
+  // Tests that the MimeSniffingHandler properly sets the accept field in the
+  // header. Returns the accept header value.
+  std::string TestAcceptHeaderSetting(ResourceType request_resource_type);
+  std::string TestAcceptHeaderSettingWithURLRequest(
+      ResourceType request_resource_type,
+      net::URLRequest* request);
+
   void set_stream_has_handler(bool stream_has_handler) {
     stream_has_handler_ = stream_has_handler;
   }
 
   void set_plugin_available(bool plugin_available) {
     plugin_available_ = plugin_available;
   }
 
   void set_plugin_stale(bool plugin_stale) { plugin_stale_ = plugin_stale; }
 
   bool TestStreamIsIntercepted(bool allow_download,
                                bool must_download,
                                ResourceType request_resource_type);
 
-  std::string TestAcceptHeaderSetting(ResourceType request_resource_type);
-  std::string TestAcceptHeaderSettingWithURLRequest(
-      ResourceType request_resource_type,
-      net::URLRequest* request);
+  // Tests the operation of the MimeSniffingHandler when it needs to buffer
+  // data (example case: the response is text/plain).
+  void TestHandlerSniffing(bool response_started,
+                           bool defer_response_started,
+                           bool will_read,
+                           bool read_completed,
+                           bool defer_read_completed);
+
+  // Tests the operation of the MimeSniffingHandler when it doesn't buffer
+  // data (example case: the response is text/html).
+  void TestHandlerNoSniffing(bool response_started,
+                             bool defer_response_started,
+                             bool will_read,
+                             bool read_completed,
+                             bool defer_read_completed);
 
  private:
   // Whether the URL request should be intercepted as a stream.
   bool stream_has_handler_;
   bool plugin_available_;
   bool plugin_stale_;
 
   TestBrowserThreadBundle thread_bundle_;
 };
 
-bool MimeTypeResourceHandlerTest::TestStreamIsIntercepted(
+std::string MimeSniffingResourceHandlerTest::TestAcceptHeaderSetting(
+    ResourceType request_resource_type) {
+  net::URLRequestContext context;
+  std::unique_ptr<net::URLRequest> request(context.CreateRequest(
+      GURL("http://www.google.com"), net::DEFAULT_PRIORITY, nullptr));
+  return TestAcceptHeaderSettingWithURLRequest(request_resource_type,
+                                               request.get());
+}
+
+std::string
+MimeSniffingResourceHandlerTest::TestAcceptHeaderSettingWithURLRequest(
+    ResourceType request_resource_type,
+    net::URLRequest* request) {
+  bool is_main_frame = request_resource_type == RESOURCE_TYPE_MAIN_FRAME;
+  ResourceRequestInfo::AllocateForTesting(request, request_resource_type,
+                                          nullptr,        // context
+                                          0,              // render_process_id
+                                          0,              // render_view_id
+                                          0,              // render_frame_id
+                                          is_main_frame,  // is_main_frame
+                                          false,   // parent_is_main_frame
+                                          false,   // allow_download
+                                          true,    // is_async
+                                          false);  // is_using_lofi
+
+  std::unique_ptr<ResourceHandler> mime_sniffing_handler(
+      new MimeSniffingResourceHandler(
+          std::unique_ptr<ResourceHandler>(
+              new TestResourceHandler(false, false, false, false, false)),
+          nullptr, nullptr, nullptr, request));
+
+  bool defer = false;
+  mime_sniffing_handler->OnWillStart(request->url(), &defer);
+  content::RunAllPendingInMessageLoop();
+
+  std::string accept_header;
+  request->extra_request_headers().GetHeader("Accept", &accept_header);
+  return accept_header;
+}
+
+bool MimeSniffingResourceHandlerTest::TestStreamIsIntercepted(
     bool allow_download,
     bool must_download,
     ResourceType request_resource_type) {
   net::URLRequestContext context;
   std::unique_ptr<net::URLRequest> request(context.CreateRequest(
       GURL("http://www.google.com"), net::DEFAULT_PRIORITY, nullptr));
   bool is_main_frame = request_resource_type == RESOURCE_TYPE_MAIN_FRAME;
-  ResourceRequestInfo::AllocateForTesting(
-      request.get(),
-      request_resource_type,
-      nullptr,          // context
-      0,                // render_process_id
-      0,                // render_view_id
-      0,                // render_frame_id
-      is_main_frame,    // is_main_frame
-      false,            // parent_is_main_frame
-      allow_download,   // allow_download
-      true,             // is_async
-      false);           // is_using_lofi
+  ResourceRequestInfo::AllocateForTesting(request.get(), request_resource_type,
+                                          nullptr,        // context
+                                          0,              // render_process_id
+                                          0,              // render_view_id
+                                          0,              // render_frame_id
+                                          is_main_frame,  // is_main_frame
+                                          false,  // parent_is_main_frame
+                                          allow_download,  // allow_download
+                                          true,            // is_async
+                                          false);          // is_using_lofi
 
   TestResourceDispatcherHost host(stream_has_handler_);
   TestResourceDispatcherHostDelegate host_delegate(must_download);
   host.SetDelegate(&host_delegate);
 
   TestFakePluginService plugin_service(plugin_available_, plugin_stale_);
-  std::unique_ptr<ResourceHandler> mime_sniffing_handler(
-      new MimeTypeResourceHandler(
-          std::unique_ptr<ResourceHandler>(new TestResourceHandler()), &host,
-          &plugin_service, request.get()));
+  std::unique_ptr<InterceptingResourceHandler> intercepting_handler(
+      new InterceptingResourceHandler(std::unique_ptr<ResourceHandler>(),
+                                      nullptr));
+  std::unique_ptr<ResourceHandler> mime_handler(new MimeSniffingResourceHandler(
+      std::unique_ptr<ResourceHandler>(
+          new TestResourceHandler(false, false, false, false, false)),
+      &host, &plugin_service, intercepting_handler.get(), request.get()));
+
   TestResourceController resource_controller;
-  mime_sniffing_handler->SetController(&resource_controller);
+  mime_handler->SetController(&resource_controller);
 
   scoped_refptr<ResourceResponse> response(new ResourceResponse);
   // The MIME type isn't important but it shouldn't be empty.
   response->head.mime_type = "application/pdf";
 
   bool defer = false;
-  mime_sniffing_handler->OnResponseStarted(response.get(), &defer);
+  mime_handler->OnResponseStarted(response.get(), &defer);
 
   content::RunAllPendingInMessageLoop();
   EXPECT_LT(host.intercepted_as_stream_count(), 2);
+  if (allow_download)
+    EXPECT_TRUE(intercepting_handler->new_handler_for_testing());
   return host.intercepted_as_stream();
 }
 
-std::string MimeTypeResourceHandlerTest::TestAcceptHeaderSetting(
-    ResourceType request_resource_type) {
+void MimeSniffingResourceHandlerTest::TestHandlerSniffing(
+    bool response_started,
+    bool defer_response_started,
+    bool will_read,
+    bool read_completed,
+    bool defer_read_completed) {
   net::URLRequestContext context;
   std::unique_ptr<net::URLRequest> request(context.CreateRequest(
       GURL("http://www.google.com"), net::DEFAULT_PRIORITY, nullptr));
-  return TestAcceptHeaderSettingWithURLRequest(
-      request_resource_type, request.get());
-}
-
-std::string MimeTypeResourceHandlerTest::TestAcceptHeaderSettingWithURLRequest(
-    ResourceType request_resource_type,
-    net::URLRequest* request) {
-  bool is_main_frame = request_resource_type == RESOURCE_TYPE_MAIN_FRAME;
-  ResourceRequestInfo::AllocateForTesting(
-      request,
-      request_resource_type,
-      nullptr,          // context
-      0,                // render_process_id
-      0,                // render_view_id
-      0,                // render_frame_id
-      is_main_frame,    // is_main_frame
-      false,            // parent_is_main_frame
-      false,            // allow_download
-      true,             // is_async
-      false);           // is_using_lofi
-
-  TestResourceDispatcherHost host(stream_has_handler_);
+  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
+                                          false,    // allow_download
+                                          true,     // is_async
+                                          false);   // is_using_lofi
+
+  TestResourceDispatcherHost host(false);
   TestResourceDispatcherHostDelegate host_delegate(false);
   host.SetDelegate(&host_delegate);
 
-  std::unique_ptr<ResourceHandler> mime_sniffing_handler(
-      new MimeTypeResourceHandler(
-          std::unique_ptr<ResourceHandler>(new TestResourceHandler()), &host,
-          nullptr, request));
-
+  TestFakePluginService plugin_service(plugin_available_, plugin_stale_);
+  std::unique_ptr<InterceptingResourceHandler> intercepting_handler(
+      new InterceptingResourceHandler(std::unique_ptr<ResourceHandler>(),
+                                      nullptr));
+  std::unique_ptr<MimeSniffingResourceHandler> mime_sniffing_handler(
+      new MimeSniffingResourceHandler(
+          std::unique_ptr<ResourceHandler>(new TestResourceHandler(
+              response_started, defer_response_started, will_read,
+              read_completed, defer_read_completed)),

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

In this test and the next, should we check that the TestResourceHandler has seen
all of the expected calls?  (We see them, and we see them only once, in the
right order, and we see the final read size?)

The fact that we see the cancel/defer/resumes as expected is a pretty strong
indicator we're calling the expected methods at least once, but may be nice to
be a bit more thorough on that.

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

Done.

+          &host, &plugin_service, intercepting_handler.get(), request.get()));
+
+  TestResourceController resource_controller;
+  mime_sniffing_handler->SetController(&resource_controller);
+
+  // The response should be sniffed.
+  scoped_refptr<ResourceResponse> response(new ResourceResponse);
+  response->head.mime_type.assign("text/plain");
+
+  // Simulate the response starting. We should start buffering, so the return

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

nit:  Avoid "we" in comments

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

Done.

+  // value should always be true.
   bool defer = false;
-  mime_sniffing_handler->OnWillStart(request->url(), &defer);
+  EXPECT_TRUE(mime_sniffing_handler->OnResponseStarted(response.get(), &defer));
+  EXPECT_EQ(0, resource_controller.cancel_call_count());
+  EXPECT_EQ(0, resource_controller.resume_call_count());
+  EXPECT_FALSE(defer);
+
+  // Read some data to sniff the mime type. This will ask the next
+  // ResourceHandler for a buffer.
+  scoped_refptr<net::IOBuffer> read_buffer;
+  int buf_size = 0;
+  EXPECT_EQ(will_read,
+            mime_sniffing_handler->OnWillRead(&read_buffer, &buf_size, -1));

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

Per comment in the other file, should probably start with WillStartRequest, just
to better protect against changes there (Though they aren't too likely)

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

Done.

+  EXPECT_EQ(0, resource_controller.cancel_call_count());
+
+  if (!will_read) {
+    EXPECT_FALSE(defer);

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

Oops - WillRead doesn't take defer as an argument, and we already check it
above, for the OnResponseStarted call.

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

Done.

+
+    // Process all messages to ensure proper test teardown.
+    content::RunAllPendingInMessageLoop();
+    return;
+  }
+
+  // Simulate an HTML page. The mime sniffer will identify the MimeType and
+  // proceed with replay.
+  char data[] = "!DOCTYPE html\n<head>\n<title>Foo</title>\n</head>";
+  memcpy(read_buffer->data(), data, sizeof(data));
+
+  defer = false;
+  bool return_value =
+      mime_sniffing_handler->OnReadCompleted(sizeof(data), &defer);
+
+  // If the next handler cancels the response start, we hsould be notified

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

nit:  Avoid "we" in comments

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

nit:  hsould -> should

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

Done.

+  // immediately.
+  if (!response_started) {
+    EXPECT_FALSE(defer);
+    EXPECT_EQ(response_started, return_value);
+    EXPECT_EQ(0, resource_controller.cancel_call_count());
+
+    // Process all messages to ensure proper test teardown.
+    content::RunAllPendingInMessageLoop();
+    return;
+  }
+
+  // The replay can be deferred both at response started and read replay
+  // stages.
+  EXPECT_EQ(defer, defer_response_started || defer_read_completed);
+  if (defer_response_started) {
+    EXPECT_TRUE(defer);
+    EXPECT_TRUE(return_value);
+    EXPECT_EQ(MimeSniffingResourceHandler::STATE_REPLAYING_RESPONSE_RECEIVED,
+              mime_sniffing_handler->state_);
+    mime_sniffing_handler->Resume();
+  }
+
+  // The body that was sniffed should be transmitted to the next handler. This
+  // may cancel the request.
+  if (!read_completed) {
+    if (defer_response_started) {
+      EXPECT_EQ(1, resource_controller.cancel_call_count());
+    } else {
+      EXPECT_EQ(0, resource_controller.cancel_call_count());
+      EXPECT_FALSE(return_value);
+    }
+    // Process all messages to ensure proper test teardown.
+    content::RunAllPendingInMessageLoop();
+    return;
+  }
+
+  EXPECT_EQ(MimeSniffingResourceHandler::STATE_STREAMING,
+            mime_sniffing_handler->state_);
+
+  // The request may be deferred by the next handler once the read is done.
+  if (defer_read_completed) {
+    EXPECT_TRUE(defer);
+    mime_sniffing_handler->Resume();
+  }
+
+  EXPECT_EQ(MimeSniffingResourceHandler::STATE_STREAMING,
+            mime_sniffing_handler->state_);
+  EXPECT_EQ(0, resource_controller.cancel_call_count());
+
+  // Even if the next handler defers the request twice, the
+  // MimeSniffingResourceHandler should only call Resume on its controller
+  // once.
+  if (defer_response_started || defer_read_completed)
+    EXPECT_EQ(1, resource_controller.resume_call_count());
+  else
+    EXPECT_EQ(0, resource_controller.resume_call_count());

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

nit:  Use braces

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

Done.

+
+  // Process all messages to ensure proper test teardown.
   content::RunAllPendingInMessageLoop();
-
-  std::string accept_header;
-  request->extra_request_headers().GetHeader("Accept", &accept_header);
-  return accept_header;
 }
 
+void MimeSniffingResourceHandlerTest::TestHandlerNoSniffing(
+    bool response_started,
+    bool defer_response_started,
+    bool will_read,
+    bool read_completed,
+    bool defer_read_completed) {
+  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
+                                          false,    // allow_download
+                                          true,     // is_async
+                                          false);   // is_using_lofi
+
+  TestResourceDispatcherHost host(false);
+  TestResourceDispatcherHostDelegate host_delegate(false);
+  host.SetDelegate(&host_delegate);
+
+  TestFakePluginService plugin_service(plugin_available_, plugin_stale_);
+  std::unique_ptr<InterceptingResourceHandler> intercepting_handler(
+      new InterceptingResourceHandler(std::unique_ptr<ResourceHandler>(),
+                                      nullptr));
+
+  std::unique_ptr<MimeSniffingResourceHandler> mime_sniffing_handler(
+      new MimeSniffingResourceHandler(
+          std::unique_ptr<ResourceHandler>(new TestResourceHandler(
+              response_started, defer_response_started, will_read,
+              read_completed, defer_read_completed)),
+          &host, &plugin_service, intercepting_handler.get(), request.get()));
+
+  TestResourceController resource_controller;
+  mime_sniffing_handler->SetController(&resource_controller);
+  int expected_resume_calls = 0;
+
+  // The response should not be sniffed.
+  scoped_refptr<ResourceResponse> response(new ResourceResponse);
+  response->head.mime_type.assign("text/html");
+
+  // Simulate the response starting. There should be no need for buffering, so
+  // the return value should be that of the next handler.
+  bool defer = false;
+  EXPECT_EQ(response_started,
+            mime_sniffing_handler->OnResponseStarted(response.get(), &defer));
+  EXPECT_EQ(0, resource_controller.cancel_call_count());
+
+  if (!response_started) {
+    EXPECT_FALSE(defer);
+
+    // Process all messages to ensure proper test teardown.
+    content::RunAllPendingInMessageLoop();
+    return;
+  }
+
+  EXPECT_EQ(defer_response_started, defer);
+  if (defer) {
+    EXPECT_EQ(MimeSniffingResourceHandler::STATE_REPLAYING_RESPONSE_RECEIVED,
+              mime_sniffing_handler->state_);
+    expected_resume_calls++;
+    mime_sniffing_handler->Resume();
+  }
+
+  EXPECT_EQ(expected_resume_calls, resource_controller.resume_call_count());
+
+  // The MimeSniffingResourceHandler should be acting as a pass-through
+  // ResourceHandler.
+  scoped_refptr<net::IOBuffer> read_buffer;
+  int buf_size = 0;
+  EXPECT_EQ(will_read,
+            mime_sniffing_handler->OnWillRead(&read_buffer, &buf_size, -1));
+  EXPECT_EQ(0, resource_controller.cancel_call_count());
+
+  if (!will_read) {
+    // Process all messages to ensure proper test teardown.
+    content::RunAllPendingInMessageLoop();
+    return;
+  }
+
+  defer = false;
+  EXPECT_EQ(read_completed,
+            mime_sniffing_handler->OnReadCompleted(2000, &defer));
+  EXPECT_EQ(0, resource_controller.cancel_call_count());
+
+  if (!read_completed) {
+    EXPECT_FALSE(defer);
+
+    // Process all messages to ensure proper test teardown.
+    content::RunAllPendingInMessageLoop();
+    return;
+  }
+
+  EXPECT_EQ(defer_read_completed, defer);
+  if (defer) {
+    expected_resume_calls++;
+    mime_sniffing_handler->Resume();
+  }
+  EXPECT_EQ(expected_resume_calls, resource_controller.resume_call_count());
+
+  // Process all messages to ensure proper test teardown.
+  content::RunAllPendingInMessageLoop();
+}
+
 // Test that the proper Accept: header is set based on the ResourceType
-TEST_F(MimeTypeResourceHandlerTest, AcceptHeaders) {
+TEST_F(MimeSniffingResourceHandlerTest, AcceptHeaders) {
   EXPECT_EQ(
       "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,"
-          "*/*;q=0.8",
+      "*/*;q=0.8",
       TestAcceptHeaderSetting(RESOURCE_TYPE_MAIN_FRAME));
   EXPECT_EQ(
       "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,"
-          "*/*;q=0.8",
-    TestAcceptHeaderSetting(RESOURCE_TYPE_SUB_FRAME));
+      "*/*;q=0.8",
+      TestAcceptHeaderSetting(RESOURCE_TYPE_SUB_FRAME));
   EXPECT_EQ("text/css,*/*;q=0.1",
-      TestAcceptHeaderSetting(RESOURCE_TYPE_STYLESHEET));
-  EXPECT_EQ("*/*",
-      TestAcceptHeaderSetting(RESOURCE_TYPE_SCRIPT));
+            TestAcceptHeaderSetting(RESOURCE_TYPE_STYLESHEET));
+  EXPECT_EQ("*/*", TestAcceptHeaderSetting(RESOURCE_TYPE_SCRIPT));
   EXPECT_EQ("image/webp,image/*,*/*;q=0.8",
-      TestAcceptHeaderSetting(RESOURCE_TYPE_IMAGE));
+            TestAcceptHeaderSetting(RESOURCE_TYPE_IMAGE));
   EXPECT_EQ("*/*", TestAcceptHeaderSetting(RESOURCE_TYPE_FONT_RESOURCE));
   EXPECT_EQ("*/*", TestAcceptHeaderSetting(RESOURCE_TYPE_SUB_RESOURCE));
   EXPECT_EQ("*/*", TestAcceptHeaderSetting(RESOURCE_TYPE_OBJECT));
   EXPECT_EQ("*/*", TestAcceptHeaderSetting(RESOURCE_TYPE_MEDIA));
   EXPECT_EQ("*/*", TestAcceptHeaderSetting(RESOURCE_TYPE_WORKER));
   EXPECT_EQ("*/*", TestAcceptHeaderSetting(RESOURCE_TYPE_SHARED_WORKER));
   EXPECT_EQ("*/*", TestAcceptHeaderSetting(RESOURCE_TYPE_PREFETCH));
   EXPECT_EQ("*/*", TestAcceptHeaderSetting(RESOURCE_TYPE_FAVICON));
   EXPECT_EQ("*/*", TestAcceptHeaderSetting(RESOURCE_TYPE_XHR));
   EXPECT_EQ("*/*", TestAcceptHeaderSetting(RESOURCE_TYPE_PING));
   EXPECT_EQ("*/*", TestAcceptHeaderSetting(RESOURCE_TYPE_SERVICE_WORKER));
   EXPECT_EQ("*/*", TestAcceptHeaderSetting(RESOURCE_TYPE_CSP_REPORT));
   EXPECT_EQ("*/*", TestAcceptHeaderSetting(RESOURCE_TYPE_PLUGIN_RESOURCE));
 
   // Ensure that if an Accept header is already set, it is not overwritten.
   net::URLRequestContext context;
   std::unique_ptr<net::URLRequest> request(context.CreateRequest(
       GURL("http://www.google.com"), net::DEFAULT_PRIORITY, nullptr));
   request->SetExtraRequestHeaderByName("Accept", "*", true);
-  EXPECT_EQ("*",
-      TestAcceptHeaderSettingWithURLRequest(RESOURCE_TYPE_XHR, request.get()));
+  EXPECT_EQ("*", TestAcceptHeaderSettingWithURLRequest(RESOURCE_TYPE_XHR,
+                                                       request.get()));
 }
 
 // Test that stream requests are correctly intercepted under the right
 // circumstances. Test is not relevent when plugins are disabled.
 #if defined(ENABLE_PLUGINS)
-TEST_F(MimeTypeResourceHandlerTest, StreamHandling) {
+TEST_F(MimeSniffingResourceHandlerTest, StreamHandling) {
   bool allow_download;
   bool must_download;
   ResourceType resource_type;
 
   // Ensure the stream is handled by MaybeInterceptAsStream in the
   // ResourceDispatcherHost.
   set_stream_has_handler(true);
   set_plugin_available(true);
 
   // Main frame request with no download allowed. Stream shouldn't be
@@ skipping 43 matching lines @@
 
   // Test the cases where the stream isn't handled by MaybeInterceptAsStream
   // in the ResourceDispatcherHost.
   set_stream_has_handler(false);
   allow_download = false;
   must_download = false;
   resource_type = RESOURCE_TYPE_OBJECT;
   EXPECT_FALSE(
       TestStreamIsIntercepted(allow_download, must_download, resource_type));
 
-  allow_download = true;
-  must_download = false;
-  resource_type = RESOURCE_TYPE_MAIN_FRAME;
-  EXPECT_FALSE(
-      TestStreamIsIntercepted(allow_download, must_download, resource_type));
-
   // Test the cases where the stream handled by MaybeInterceptAsStream
   // with plugin not available. This is the case when intercepting streams for
   // the streamsPrivate extensions API.
   set_stream_has_handler(true);
   set_plugin_available(false);
   allow_download = false;
   must_download = false;
   resource_type = RESOURCE_TYPE_OBJECT;
   EXPECT_TRUE(
       TestStreamIsIntercepted(allow_download, must_download, resource_type));
 
   // Test the cases where the stream handled by MaybeInterceptAsStream
   // with plugin not available. This is the case when intercepting streams for
   // the streamsPrivate extensions API with stale plugin.
   set_plugin_stale(true);
   allow_download = false;
   must_download = false;
   resource_type = RESOURCE_TYPE_OBJECT;
   EXPECT_TRUE(
       TestStreamIsIntercepted(allow_download, must_download, resource_type));
 }
 #endif
 
-}  // namespace
+// Test that the MimeSniffingHandler operates properly when it doesn't sniff
+// resources.
+TEST_F(MimeSniffingResourceHandlerTest, NoSniffing) {
+  // Test simple case.
+  TestHandlerNoSniffing(
+      true  /* response_started_succeeds */,
+      false /* defer_response_started */,
+      true  /* will_read_succeeds */,
+      true  /* read_completed_succeeds */,
+      false /* defer_read_completed */);
+
+  // Test deferral in OnResponseStarted and/or in OnReadCompleted.
+  TestHandlerNoSniffing(
+      true  /* response_started_succeeds */,
+      true  /* defer_response_started */,
+      true  /* will_read_succeeds */,
+      true  /* read_completed_succeeds */,
+      false /* defer_read_completed */);
+  TestHandlerNoSniffing(
+      true  /* response_started_succeeds */,
+      false /* defer_response_started */,
+      true  /* will_read_succeeds */,
+      true  /* read_completed_succeeds */,
+      true  /* defer_read_completed */);
+  TestHandlerNoSniffing(
+      true  /* response_started_succeeds */,
+      true  /* defer_response_started */,
+      true  /* will_read_succeeds */,
+      true  /* read_completed_succeeds */,
+      true  /* defer_read_completed */);
+
+  // Test cancel in OnResponseStarted, OnWillRead, OnReadCompleted.
+  TestHandlerNoSniffing(
+      false /* response_started_succeeds */,
+      false /* defer_response_started */,
+      false /* will_read_succeeds */,
+      false /* read_completed_succeeds */,
+      false /* defer_read_completed */);
+  TestHandlerNoSniffing(
+      true  /* response_started_succeeds */,
+      false /* defer_response_started */,
+      false /* will_read_succeeds */,
+      false /* read_completed_succeeds */,
+      false /* defer_read_completed */);
+  TestHandlerNoSniffing(
+      true  /* response_started_succeeds */,
+      false /* defer_response_started */,
+      true  /* will_read_succeeds */,
+      false /* read_completed_succeeds */,
+      false /* defer_read_completed */);
+
+  // Test cancel after OnResponseStarted deferral.
+  TestHandlerNoSniffing(
+      true  /* response_started_succeeds */,
+      true  /* defer_response_started */,
+      false /* will_read_succeeds */,
+      false /* read_completed_succeeds */,
+      false /* defer_read_completed */);
+  TestHandlerNoSniffing(
+      true  /* response_started_succeeds */,
+      true  /* defer_response_started */,
+      true  /* will_read_succeeds */,
+      false /* read_completed_succeeds */,
+      false /* defer_read_completed */);
+
+  content::RunAllPendingInMessageLoop();
+}
+
+// Test that the MimeSniffingHandler operates properly when it sniffs
+// resources.
+TEST_F(MimeSniffingResourceHandlerTest, Sniffing) {
+  // Test simple case.
+  TestHandlerSniffing(
+      true  /* response_started_succeeds */,
+      false /* defer_response_started */,
+      true  /* will_read_succeeds */,
+      true  /* read_completed_succeeds */,
+      false /* defer_read_completed */);
+
+  // Test deferral in OnResponseStarted and/or in OnReadCompleted.
+  TestHandlerSniffing(
+      true  /* response_started_succeeds */,
+      true  /* defer_response_started */,
+      true  /* will_read_succeeds */,
+      true  /* read_completed_succeeds */,
+      false /* defer_read_completed */);
+  TestHandlerSniffing(
+      true  /* response_started_succeeds */,
+      false /* defer_response_started */,
+      true  /* will_read_succeeds */,
+      true  /* read_completed_succeeds */,
+      true  /* defer_read_completed */);
+  TestHandlerSniffing(
+      true  /* response_started_succeeds */,
+      true  /* defer_response_started */,
+      true  /* will_read_succeeds */,
+      true  /* read_completed_succeeds */,
+      true  /* defer_read_completed */);
+
+  // Test cancel in OnResponseStarted, OnWillRead, OnReadCompleted.
+  TestHandlerSniffing(
+      false /* response_started_succeeds */,
+      false /* defer_response_started */,
+      false /* will_read_succeeds */,
+      false /* read_completed_succeeds */,
+      false /* defer_read_completed */);
+  TestHandlerSniffing(
+      true  /* response_started_succeeds */,
+      false /* defer_response_started */,
+      false /* will_read_succeeds */,
+      false /* read_completed_succeeds */,
+      false /* defer_read_completed */);
+  TestHandlerSniffing(
+      true  /* response_started_succeeds */,
+      false /* defer_response_started */,
+      true  /* will_read_succeeds */,
+      false /* read_completed_succeeds */,
+      false /* defer_read_completed */);
+
+  // Test cancel after OnResponseStarted deferral.
+  TestHandlerSniffing(
+      true  /* response_started_succeeds */,
+      true  /* defer_response_started */,
+      false /* will_read_succeeds */,
+      false /* read_completed_succeeds */,
+      false /* defer_read_completed */);
+  TestHandlerSniffing(
+      true  /* response_started_succeeds */,
+      true  /* defer_response_started */,
+      true  /* will_read_succeeds */,
+      false /* read_completed_succeeds */,
+      false /* defer_read_completed */);
+
+  content::RunAllPendingInMessageLoop();
+}
+
+// Tests that 304s do not trigger a change in handlers.
+TEST_F(MimeSniffingResourceHandlerTest, 304Handling) {
+  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
+
+  TestResourceDispatcherHost host(false);
+  TestResourceDispatcherHostDelegate host_delegate(false);
+  host.SetDelegate(&host_delegate);
+
+  TestFakePluginService plugin_service(false, false);
+  std::unique_ptr<ResourceHandler> intercepting_handler(
+      new InterceptingResourceHandler(std::unique_ptr<ResourceHandler>(),
+                                      nullptr));
+  std::unique_ptr<ResourceHandler> mime_handler(new MimeSniffingResourceHandler(
+      std::unique_ptr<ResourceHandler>(
+          new TestResourceHandler(true, false, true, true, false)),
+      &host, &plugin_service,
+      static_cast<InterceptingResourceHandler*>(intercepting_handler.get()),
+      request.get()));
+
+  TestResourceController resource_controller;
+  mime_handler->SetController(&resource_controller);
+
+  // Simulate a 304 response.
+  scoped_refptr<ResourceResponse> response(new ResourceResponse);
+  // The MIME type isn't important but it shouldn't be empty.
+  response->head.mime_type = "application/pdf";
+  response->head.headers = new net::HttpResponseHeaders("HTTP/1.x 304 OK");
+
+  // The response is received. No new ResourceHandler should be created to
+  // handle the download.
+  bool defer = false;
+  mime_handler->OnResponseStarted(response.get(), &defer);
+  EXPECT_FALSE(defer);
+  TestResourceHandler* new_handler = host.new_resource_handler();
+  EXPECT_TRUE(!new_handler);

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

EXPECT_FALSE(new_handler)?  Could also get rid of the new_handler local.

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

Done.

+
+  content::RunAllPendingInMessageLoop();
+}
 
 }  // namespace content