Do not sniff mime type for fetch() requests

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 324 matching lines @@
                                           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));
+          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;
 }
 
@@ skipping 20 matching lines @@
   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()));
+      &host, &plugin_service, intercepting_handler.get(), 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);
@@ skipping 33 matching lines @@
   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));
   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()));
+      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);
 
   bool defer = false;
   mime_sniffing_handler->OnWillStart(GURL(), &defer);
 
   // The response should be sniffed.
   scoped_refptr<ResourceResponse> response(new ResourceResponse);
   response->head.mime_type.assign("text/plain");
@@ skipping 138 matching lines @@
   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));
   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()));
+      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);
 
   int expected_resume_calls = 0;
 
   bool defer = false;
   mime_sniffing_handler->OnWillStart(GURL(), &defer);
 
   // The response should not be sniffed.
@@ skipping 368 matching lines @@
 
   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()));
+      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);
   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,
+                              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