Centralize the setting of Accept headers

content/browser/loader/mime_type_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 <stdint.h>
 
 #include "base/files/file_path.h"
 #include "base/logging.h"
@@ skipping 27 matching lines @@
                            bool* defer) override {
     NOTREACHED();
     return false;
   }
 
   bool OnResponseStarted(ResourceResponse* response, bool* defer) override {
     return false;
   }
 
   bool OnWillStart(const GURL& url, bool* defer) override {
-    NOTREACHED();
     return false;
   }
 
   bool OnBeforeNetworkStart(const GURL& url, bool* defer) override {
     NOTREACHED();
     return false;
   }
 
   bool OnWillRead(scoped_refptr<net::IOBuffer>* buf,
                   int* buf_size,
@@ skipping 154 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);
 
+  std::string TestAcceptHeaderSetting(ResourceType request_resource_type);
+  std::string TestAcceptHeaderSettingWithURLRequest(
+      ResourceType request_resource_type,
+      net::URLRequest* request);
+
  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(
@@ skipping 33 matching lines @@
   response->head.mime_type = "application/pdf";
 
   bool defer = false;
   mime_sniffing_handler->OnResponseStarted(response.get(), &defer);
 
   content::RunAllPendingInMessageLoop();
   EXPECT_LT(host.intercepted_as_stream_count(), 2);
   return host.intercepted_as_stream();
 }
 
+std::string MimeTypeResourceHandlerTest::TestAcceptHeaderSetting(
+    ResourceType request_resource_type) {
+  net::URLRequestContext context;
+  scoped_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_);
+  TestResourceDispatcherHostDelegate host_delegate(false);
+  host.SetDelegate(&host_delegate);
+
+  scoped_ptr<ResourceHandler> mime_sniffing_handler(new MimeTypeResourceHandler(
+      scoped_ptr<ResourceHandler>(new TestResourceHandler()), &host,
+      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;
+}
+
+// Test that the proper Accept: header is set based on the ResourceType
+TEST_F(MimeTypeResourceHandlerTest, AcceptHeaders) {
+  EXPECT_EQ(
+      "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,"
+          "*/*;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));
+  EXPECT_EQ("text/css,*/*;q=0.1",
+      TestAcceptHeaderSetting(RESOURCE_TYPE_STYLESHEET));
+  EXPECT_EQ("*/*",
+      TestAcceptHeaderSetting(RESOURCE_TYPE_SCRIPT));
+  EXPECT_EQ("image/webp,image/*,*/*;q=0.8",
+      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;
+  scoped_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()));
+}
+
 // 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) {
   bool allow_download;
   bool must_download;
   ResourceType resource_type;
 
   // Ensure the stream is handled by MaybeInterceptAsStream in the
   // ResourceDispatcherHost.
@@ skipping 79 matching lines @@
   must_download = false;
   resource_type = RESOURCE_TYPE_OBJECT;
   EXPECT_TRUE(
       TestStreamIsIntercepted(allow_download, must_download, resource_type));
 }
 #endif
 
 }  // namespace
 
 }  // namespace content