Centralize the setting of Accept headers

content/browser/loader/mime_type_resource_handler.cc

 // Copyright (c) 2012 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 <utility>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 17 matching lines @@
 #include "content/public/browser/resource_context.h"
 #include "content/public/browser/resource_dispatcher_host_delegate.h"
 #include "content/public/common/resource_response.h"
 #include "content/public/common/webplugininfo.h"
 #include "net/base/io_buffer.h"
 #include "net/base/mime_sniffer.h"
 #include "net/base/mime_util.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_content_disposition.h"
 #include "net/http/http_response_headers.h"
+#include "net/url_request/url_request.h"
 
 namespace content {
 
 namespace {
 
+const char kAcceptHeader[] = "Accept";
+const char kFrameAcceptHeader[] =
+    "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,"
+    "*/*;q=0.8";
+const char kStylesheetAcceptHeader[] = "text/css,*/*;q=0.1";
+const char kImageAcceptHeader[] = "image/webp,image/*,*/*;q=0.8";
+const char kDefaultAcceptHeader[] = "*/*";
+
 // Used to write into an existing IOBuffer at a given offset.
 class DependentIOBuffer : public net::WrappedIOBuffer {
  public:
   DependentIOBuffer(net::IOBuffer* buf, int offset)
       : net::WrappedIOBuffer(buf->data() + offset),
         buf_(buf) {
   }
 
  private:
   ~DependentIOBuffer() override {}
@@ skipping 56 matching lines @@
     if (response_->head.mime_type == "application/rss+xml" ||
         response_->head.mime_type == "application/atom+xml") {
       response_->head.mime_type.assign("text/plain");
     }
   }
 
   state_ = STATE_PROCESSING;
   return ProcessResponse(defer);
 }
 
+bool MimeTypeResourceHandler::OnWillStart(const GURL& url, bool* defer) {
+  const char* accept_value = nullptr;
+  switch (GetRequestInfo()->GetResourceType()) {
+    case RESOURCE_TYPE_MAIN_FRAME:
+    case RESOURCE_TYPE_SUB_FRAME:
+      accept_value = kFrameAcceptHeader;
+      break;
+    case RESOURCE_TYPE_STYLESHEET:
+      accept_value = kStylesheetAcceptHeader;
+      break;
+    case RESOURCE_TYPE_IMAGE:
+      accept_value = kImageAcceptHeader;
+      break;
+    case RESOURCE_TYPE_SCRIPT:
+    case RESOURCE_TYPE_FONT_RESOURCE:
+    case RESOURCE_TYPE_SUB_RESOURCE:
+    case RESOURCE_TYPE_OBJECT:
+    case RESOURCE_TYPE_MEDIA:
+    case RESOURCE_TYPE_WORKER:
+    case RESOURCE_TYPE_SHARED_WORKER:
+    case RESOURCE_TYPE_PREFETCH:
+    case RESOURCE_TYPE_FAVICON:
+    case RESOURCE_TYPE_XHR:
+    case RESOURCE_TYPE_PING:
+    case RESOURCE_TYPE_SERVICE_WORKER:
+    case RESOURCE_TYPE_CSP_REPORT:
+    case RESOURCE_TYPE_PLUGIN_RESOURCE:
+      accept_value = kDefaultAcceptHeader;
+      break;
+    case RESOURCE_TYPE_LAST_TYPE:
+      NOTREACHED();
+      break;
+  }

[Yoav Weiss, 2016/04/01 17:54:10]

Could we add a test here that makes sure that the resourceType=>Accept header
translation happens as it should be?

We're losing some testing coverage on the Blink side, so it'd be great to catch
up on this end.

[Nate Chapin, 2016/04/01 19:01:24]

Done.

+
+  // The false parameter prevents overwriting an existing accept header value,
+  // which we need because JS can manually set an accept header on an XHR.

[mmenke, 2016/04/01 15:29:08]

nit:  Avoid "we" in heaers

[mmenke, 2016/04/01 17:57:00]

Err..."heaers" -> comments (Don't ask me how that happened).

[Nate Chapin, 2016/04/01 19:01:24]

I figured it out :) Done.

+  request()->SetExtraRequestHeaderByName(kAcceptHeader, accept_value, false);
+  return next_handler_->OnWillStart(url, defer);
+}
+
 bool MimeTypeResourceHandler::OnWillRead(scoped_refptr<net::IOBuffer>* buf,
                                          int* buf_size,
                                          int min_size) {
   if (state_ == STATE_STREAMING)
     return next_handler_->OnWillRead(buf, buf_size, min_size);
 
   DCHECK_EQ(-1, min_size);
 
   if (read_buffer_.get()) {
     CHECK_LT(bytes_read_, read_buffer_size_);
@@ skipping 355 matching lines @@
   request()->LogUnblocked();
   bool defer = false;
   if (!ProcessResponse(&defer)) {
     controller()->Cancel();
   } else if (!defer) {
     controller()->Resume();
   }
 }
 
 }  // namespace content