Have MimeSniffingResourceHandler call WillStartRequest on new Handlers.

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_sniffing_resource_handler.h"
 
 #include <stdint.h>
 
 #include <memory>
 
@@ skipping 16 matching lines @@
 #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(bool response_started_succeeds,
+  // TODO(mmenke): This constructor is a bit crazy.  Switch to taking a bitfield
+  // instead, or  maybe use setters?
+  TestResourceHandler(bool will_start_succeeds,
+                      bool defer_on_will_start,
+                      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)),
+        will_start_succeeds_(will_start_succeeds),
+        defer_on_will_start_(defer_on_will_start),
         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),
         on_will_start_called_(0),
         on_request_redirected_called_(0),
         on_response_started_called_(0),
         on_will_read_called_(0),
         on_read_completed_called_(0) {}
 
-  void SetController(ResourceController* controller) override {}
-
   bool OnRequestRedirected(const net::RedirectInfo& redirect_info,
                            ResourceResponse* response,
                            bool* defer) override {
     on_request_redirected_called_++;
     NOTREACHED();
     return false;
   }
 
   bool OnResponseStarted(ResourceResponse* response, bool* defer) override {
+    EXPECT_TRUE(on_will_start_called_);
+
     on_response_started_called_++;
     if (defer_on_response_started_)
       *defer = true;
     return response_started_succeeds_;
   }
 
   bool OnWillStart(const GURL& url, bool* defer) override {
     on_will_start_called_++;
-    return false;
+
+    *defer = defer_on_will_start_;
+    return will_start_succeeds_;
   }
 
   bool OnWillRead(scoped_refptr<net::IOBuffer>* buf,
                   int* buf_size,
                   int min_size) override {
     on_will_read_called_++;
     *buf = buffer_;
     *buf_size = 2048;
     return will_read_succeeds_;
   }
 
   bool OnReadCompleted(int bytes_read, bool* defer) override {
+    EXPECT_TRUE(on_will_start_called_);
+    EXPECT_TRUE(on_response_started_called_);
+
     DCHECK_LT(bytes_read, 2048);
     on_read_completed_called_++;
     if (defer_on_read_completed_)
       *defer = true;
     return read_completed_succeeds_;
   }
 
   void OnResponseCompleted(const net::URLRequestStatus& status,
-                           bool* defer) override {}
+                           bool* defer) override {
+    // If the request succeeded, OnWillRead and OnResponseStarted must have been
+    // called.
+    if (status.is_success()) {
+      EXPECT_TRUE(on_will_start_called_);
+      EXPECT_TRUE(on_response_started_called_);
+    }
+  }
 
   void OnDataDownloaded(int bytes_downloaded) override { NOTREACHED(); }
 
+  // Give text fixture access to ResourceController, for resuming.
+  using ResourceHandler::controller;
+
   scoped_refptr<net::IOBuffer> buffer() { return buffer_; }
 
   int on_will_start_called() const { return on_will_start_called_; }
   int on_request_redirected_called() const {
     return on_request_redirected_called_;
   }
   int on_response_started_called() const { return on_response_started_called_; }
   int on_will_read_called() const { return on_will_read_called_; }
   int on_read_completed_called() const { return on_read_completed_called_; }
 
  private:
   scoped_refptr<net::IOBuffer> buffer_;
+
+  bool will_start_succeeds_;
+  bool defer_on_will_start_;
   bool response_started_succeeds_;
   bool defer_on_response_started_;
   bool will_read_succeeds_;
   bool read_completed_succeeds_;
   bool defer_on_read_completed_;
 
   int on_will_start_called_;
   int on_request_redirected_called_;
   int on_response_started_called_;
   int on_will_read_called_;
@@ skipping 14 matching lines @@
   }
 
  private:
   const bool must_download_;
 };
 
 class TestResourceDispatcherHost : public ResourceDispatcherHostImpl {
  public:
   explicit TestResourceDispatcherHost(bool stream_has_handler)
       : stream_has_handler_(stream_has_handler),
+        new_handler_will_start_succeeds_(true),
+        new_handler_defer_on_will_start_(false),
         intercepted_as_stream_(false),
         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 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_)
       intercepted_as_stream_ = true;
     return CreateNewResourceHandler();
   }
 
+  void set_new_handler_will_start_succeeds(
+      bool new_handler_will_start_succeeds) {
+    new_handler_will_start_succeeds_ = new_handler_will_start_succeeds;
+  }
+
+  void set_new_handler_defer_on_will_start(
+      bool new_handler_defer_on_will_start) {
+    new_handler_defer_on_will_start_ = new_handler_defer_on_will_start;
+  }
+
   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 TestResourceHandler(
+            new_handler_will_start_succeeds_, new_handler_defer_on_will_start_,
+            false /* response_started_succeeds */,
+            false /* defer_on_response_started */,
+            true /* will_read_succeeds */, true /* read_completed_succeeds */,
+            false /* defer_on_read_completed */));
     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_;
 
+  // Behavior of the OnWillStart method of any created ResourceHandlers.
+  bool new_handler_will_start_succeeds_;
+  bool new_handler_defer_on_will_start_;
+
   // 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_;
 
   // The last alternative TestResourceHandler created by this
   // TestResourceDispatcherHost.
   TestResourceHandler* new_resource_handler_;
@@ skipping 81 matching lines @@
   }
 
   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);
+                               ResourceType request_resource_type,
+                               bool new_handler_will_start_succeeds,
+                               bool new_handler_defer_on_will_start);
 
   // 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
@@ skipping 33 matching lines @@
                                           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)),
+          std::unique_ptr<ResourceHandler>(new TestResourceHandler(
+              true, false, false, false, false, false, false)),
           nullptr, nullptr, nullptr, request,
           REQUEST_CONTEXT_TYPE_UNSPECIFIED));
 
   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) {
+    ResourceType request_resource_type,
+    bool new_handler_will_start_succeeds,
+    bool new_handler_defer_on_will_start) {
   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
 
   TestResourceDispatcherHost host(stream_has_handler_);
+  host.set_new_handler_will_start_succeeds(new_handler_will_start_succeeds);
+  host.set_new_handler_defer_on_will_start(new_handler_defer_on_will_start);
+
   TestResourceDispatcherHostDelegate host_delegate(must_download);
   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<ResourceHandler> mime_handler(new MimeSniffingResourceHandler(
-      std::unique_ptr<ResourceHandler>(
-          new TestResourceHandler(false, false, false, false, false)),
-      &host, &plugin_service, intercepting_handler.get(), request.get(),
-      REQUEST_CONTEXT_TYPE_UNSPECIFIED));
+  InterceptingResourceHandler* intercepting_handler =
+      new InterceptingResourceHandler(
+          base::MakeUnique<TestResourceHandler>(true, false, false, false, true,
+                                                false, false),
+          nullptr);
+  std::unique_ptr<MimeSniffingResourceHandler> mime_handler(
+      new MimeSniffingResourceHandler(base::WrapUnique(intercepting_handler),
+                                      &host, &plugin_service,
+                                      intercepting_handler, request.get(),
+                                      REQUEST_CONTEXT_TYPE_UNSPECIFIED));
 
   TestResourceController 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_handler->OnResponseStarted(response.get(), &defer);
+  EXPECT_TRUE(mime_handler->OnWillStart(request->url(), &defer));
+  EXPECT_FALSE(defer);
+  bool result = mime_handler->OnResponseStarted(response.get(), &defer);
+
+  // Exit early if the new ResourceHandler should have failed in OnWillStart.
+  if (!new_handler_will_start_succeeds) {
+    EXPECT_FALSE(result);
+    EXPECT_TRUE(host.new_resource_handler()->on_will_start_called());
+    EXPECT_FALSE(host.new_resource_handler()->on_response_started_called());
+    return host.intercepted_as_stream();
+  }
+
+  // If the new ResourceHandler's OnWillStart method should have deferred the
+  // request, check state and resume it.
+  if (new_handler_defer_on_will_start) {
+    EXPECT_TRUE(defer);
+    EXPECT_TRUE(result);
+    EXPECT_TRUE(host.new_resource_handler()->on_will_start_called());
+    EXPECT_FALSE(host.new_resource_handler()->on_response_started_called());
+    host.new_resource_handler()->controller()->Resume();
+  }
 
   content::RunAllPendingInMessageLoop();
   EXPECT_LT(host.intercepted_as_stream_count(), 2);
+
   if (allow_download)
-    EXPECT_TRUE(intercepting_handler->new_handler_for_testing());
+    EXPECT_TRUE(host.new_resource_handler());
+
+  // If a new resource handler was created, make sure it was successfully
+  // swapped in, and its OnWillStart and OnResponseStarted methods were called.
+  if (host.new_resource_handler()) {
+    EXPECT_EQ(host.new_resource_handler(),
+              intercepting_handler->next_handler_for_testing());
+    EXPECT_TRUE(host.new_resource_handler()->on_will_start_called());
+    EXPECT_TRUE(host.new_resource_handler()->on_response_started_called());
+  }
+
   return host.intercepted_as_stream();
 }
 
 void MimeSniffingResourceHandlerTest::TestHandlerSniffing(
     bool response_started,
     bool defer_response_started,
     bool will_read,
     bool read_completed,
     bool defer_read_completed) {
   net::URLRequestContext context;
@@ skipping 14 matching lines @@
   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<TestResourceHandler> scoped_test_handler =
       std::unique_ptr<TestResourceHandler>(new TestResourceHandler(
-          response_started, defer_response_started, will_read, read_completed,
-          defer_read_completed));
+          true, false, response_started, defer_response_started, will_read,
+          read_completed, defer_read_completed));
   TestResourceHandler* test_handler = scoped_test_handler.get();
   std::unique_ptr<MimeSniffingResourceHandler> mime_sniffing_handler(
       new MimeSniffingResourceHandler(std::move(scoped_test_handler), &host,
                                       &plugin_service,
                                       intercepting_handler.get(), request.get(),
                                       REQUEST_CONTEXT_TYPE_UNSPECIFIED));
 
   TestResourceController resource_controller;
   mime_sniffing_handler->SetController(&resource_controller);
 
@@ skipping 57 matching lines @@
     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,
+    EXPECT_EQ(MimeSniffingResourceHandler::STATE_REPLAYING_RECEIVED_RESPONSE,
               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 {
@@ skipping 62 matching lines @@
   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<TestResourceHandler> scoped_test_handler =
       std::unique_ptr<TestResourceHandler>(new TestResourceHandler(
-          response_started, defer_response_started, will_read, read_completed,
-          defer_read_completed));
+          true, false, response_started, defer_response_started, will_read,
+          read_completed, defer_read_completed));
   TestResourceHandler* test_handler = scoped_test_handler.get();
   std::unique_ptr<MimeSniffingResourceHandler> mime_sniffing_handler(
       new MimeSniffingResourceHandler(std::move(scoped_test_handler), &host,
                                       &plugin_service,
                                       intercepting_handler.get(), request.get(),
                                       REQUEST_CONTEXT_TYPE_UNSPECIFIED));
 
   TestResourceController resource_controller;
   mime_sniffing_handler->SetController(&resource_controller);
 
@@ skipping 21 matching lines @@
     EXPECT_EQ(0, test_handler->on_will_read_called());
     EXPECT_EQ(0, test_handler->on_read_completed_called());
 
     // 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,
+    EXPECT_EQ(MimeSniffingResourceHandler::STATE_REPLAYING_RECEIVED_RESPONSE,
               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;
@@ skipping 83 matching lines @@
                                                        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(MimeSniffingResourceHandlerTest, StreamHandling) {
   bool allow_download;
   bool must_download;
   ResourceType resource_type;
+  bool new_handler_will_start_succeeds;
+  bool new_handler_defer_on_will_start;
 
   // 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
   // intercepted.
   allow_download = false;
   must_download = false;
   resource_type = RESOURCE_TYPE_MAIN_FRAME;
-  EXPECT_FALSE(
-      TestStreamIsIntercepted(allow_download, must_download, resource_type));
+  new_handler_will_start_succeeds = true;
+  new_handler_defer_on_will_start = false;
+  EXPECT_FALSE(TestStreamIsIntercepted(
+      false /* allow_download */, false /* must_download */,
+      RESOURCE_TYPE_MAIN_FRAME, true /* new_handler_will_start_succeeds */,
+      false /* new_handler_defer_on_will_start */));
 
   // Main frame request with download allowed. Stream should be intercepted.
   allow_download = true;
   must_download = false;
   resource_type = RESOURCE_TYPE_MAIN_FRAME;
-  EXPECT_TRUE(
-      TestStreamIsIntercepted(allow_download, must_download, resource_type));
+  new_handler_will_start_succeeds = true;
+  new_handler_defer_on_will_start = false;
+  EXPECT_TRUE(TestStreamIsIntercepted(
+      allow_download, must_download, resource_type,
+      new_handler_will_start_succeeds, new_handler_defer_on_will_start));
+
+  // Main frame request with download allowed, but OnWillStart for the new
+  // handler succeeds asynchronously. Stream should be intercepted.
+  allow_download = true;
+  must_download = false;
+  resource_type = RESOURCE_TYPE_MAIN_FRAME;
+  new_handler_will_start_succeeds = true;
+  new_handler_defer_on_will_start = true;
+  EXPECT_TRUE(TestStreamIsIntercepted(
+      allow_download, must_download, resource_type,
+      new_handler_will_start_succeeds, new_handler_defer_on_will_start));
+
+  // Main frame request with download allowed, but OnWillStart of new handler
+  // fails.
+  allow_download = true;
+  must_download = false;
+  resource_type = RESOURCE_TYPE_MAIN_FRAME;
+  new_handler_will_start_succeeds = false;
+  new_handler_defer_on_will_start = false;
+  EXPECT_TRUE(TestStreamIsIntercepted(
+      allow_download, must_download, resource_type,
+      new_handler_will_start_succeeds, new_handler_defer_on_will_start));
 
   // Main frame request with download forced. Stream shouldn't be intercepted.
   allow_download = true;
   must_download = true;
   resource_type = RESOURCE_TYPE_MAIN_FRAME;
-  EXPECT_FALSE(
-      TestStreamIsIntercepted(allow_download, must_download, resource_type));
+  new_handler_will_start_succeeds = true;
+  new_handler_defer_on_will_start = false;
+  EXPECT_FALSE(TestStreamIsIntercepted(
+      allow_download, must_download, resource_type,
+      new_handler_will_start_succeeds, new_handler_defer_on_will_start));
 
   // Sub-resource request with download not allowed. Stream shouldn't be
   // intercepted.
   allow_download = false;
   must_download = false;
   resource_type = RESOURCE_TYPE_SUB_RESOURCE;
-  EXPECT_FALSE(
-      TestStreamIsIntercepted(allow_download, must_download, resource_type));
+  new_handler_will_start_succeeds = true;
+  new_handler_defer_on_will_start = false;
+  EXPECT_FALSE(TestStreamIsIntercepted(
+      allow_download, must_download, resource_type,
+      new_handler_will_start_succeeds, new_handler_defer_on_will_start));
 
   // Plugin resource request with download not allowed. Stream shouldn't be
   // intercepted.
   allow_download = false;
   must_download = false;
   resource_type = RESOURCE_TYPE_PLUGIN_RESOURCE;
-  EXPECT_FALSE(
-      TestStreamIsIntercepted(allow_download, must_download, resource_type));
+  new_handler_will_start_succeeds = true;
+  new_handler_defer_on_will_start = false;
+  EXPECT_FALSE(TestStreamIsIntercepted(
+      allow_download, must_download, resource_type,
+      new_handler_will_start_succeeds, new_handler_defer_on_will_start));
 
   // Object request with download not allowed. Stream should be intercepted.
   allow_download = false;
   must_download = false;
   resource_type = RESOURCE_TYPE_OBJECT;
-  EXPECT_TRUE(
-      TestStreamIsIntercepted(allow_download, must_download, resource_type));
+  new_handler_will_start_succeeds = true;
+  new_handler_defer_on_will_start = false;
+  EXPECT_TRUE(TestStreamIsIntercepted(
+      allow_download, must_download, resource_type,
+      new_handler_will_start_succeeds, new_handler_defer_on_will_start));
 
   // 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));
+  new_handler_will_start_succeeds = true;
+  new_handler_defer_on_will_start = false;
+  EXPECT_FALSE(TestStreamIsIntercepted(
+      allow_download, must_download, resource_type,
+      new_handler_will_start_succeeds, new_handler_defer_on_will_start));
 
   // 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));
+  new_handler_will_start_succeeds = true;
+  new_handler_defer_on_will_start = false;
+  EXPECT_TRUE(TestStreamIsIntercepted(
+      allow_download, must_download, resource_type,
+      new_handler_will_start_succeeds, new_handler_defer_on_will_start));
 
   // 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));
+  new_handler_will_start_succeeds = true;
+  new_handler_defer_on_will_start = false;
+  EXPECT_TRUE(TestStreamIsIntercepted(
+      allow_download, must_download, resource_type,
+      new_handler_will_start_succeeds, new_handler_defer_on_will_start));
 }
 #endif
 
 // 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 */,
@@ skipping 146 matching lines @@
   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)),
+          new TestResourceHandler(true, false, true, false, true, true, false)),
       &host, &plugin_service,
       static_cast<InterceptingResourceHandler*>(intercepting_handler.get()),
       request.get(), REQUEST_CONTEXT_TYPE_UNSPECIFIED));
 
   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);
+  ASSERT_TRUE(mime_handler->OnWillStart(request->url(), &defer));
+  ASSERT_FALSE(defer);
+
+  ASSERT_TRUE(mime_handler->OnResponseStarted(response.get(), &defer));
   EXPECT_FALSE(defer);
   EXPECT_FALSE(host.new_resource_handler());
 
   content::RunAllPendingInMessageLoop();
 }
 
 TEST_F(MimeSniffingResourceHandlerTest, FetchShouldDisableMimeSniffing) {
   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);
 
   TestFakePluginService plugin_service(false, false);
   std::unique_ptr<InterceptingResourceHandler> intercepting_handler(
       new InterceptingResourceHandler(nullptr, nullptr));
 
   std::unique_ptr<TestResourceHandler> scoped_test_handler(
-      new TestResourceHandler(false,    // response_started
-                              false,    // defer_response_started
-                              true,     // will_read,
-                              true,     // read_completed,
+      new TestResourceHandler(true,     // will_start_succeeds
+                              false,    // defer_on_will_start
+                              false,    // response_started_succeeds
+                              false,    // defer_on_response_started
+                              true,     // will_read_succeeds
+                              true,     // read_completed_succeeds
                               false));  // defer_read_completed
   std::unique_ptr<ResourceHandler> mime_sniffing_handler(
       new MimeSniffingResourceHandler(std::move(scoped_test_handler), &host,
                                       &plugin_service,
                                       intercepting_handler.get(), request.get(),
                                       REQUEST_CONTEXT_TYPE_FETCH));
 
   TestResourceController resource_controller;
   mime_sniffing_handler->SetController(&resource_controller);
 
   bool defer = false;
   mime_sniffing_handler->OnWillStart(GURL(), &defer);
   ASSERT_FALSE(defer);
 
   scoped_refptr<ResourceResponse> response(new ResourceResponse);
   response->head.mime_type = "text/plain";
 
   // |mime_sniffing_handler->OnResponseStarted| should return false because
   // mime sniffing is disabled and the wrapped resource handler returns false
   // on OnResponseStarted.
   EXPECT_FALSE(
       mime_sniffing_handler->OnResponseStarted(response.get(), &defer));
 
   // Process all messages to ensure proper test teardown.
   content::RunAllPendingInMessageLoop();
 }
 
 }  // namespace content