PlzNavigate: Implement RequestNavigation on the renderer side

content/child/web_url_request_util.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/child/web_url_request_util.h"
 
 #include "base/logging.h"
+#include "base/strings/string_util.h"
+#include "net/base/load_flags.h"
+#include "third_party/WebKit/public/platform/WebHTTPHeaderVisitor.h"
+#include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebURLRequest.h"
 
 using blink::WebURLRequest;
+using blink::WebString;
 
 namespace content {
 
+namespace {
+
+class HeaderFlattener : public blink::WebHTTPHeaderVisitor {
+ public:
+  HeaderFlattener() : has_accept_header_(false) {}
+
+  virtual void visitHeader(const WebString& name, const WebString& value) {
+    // Headers are latin1.
+    const std::string& name_latin1 = name.latin1();
+    const std::string& value_latin1 = value.latin1();
+
+    // Skip over referrer headers found in the header map because we already
+    // pulled it out as a separate parameter.
+    if (LowerCaseEqualsASCII(name_latin1, "referer"))
+      return;
+
+    if (LowerCaseEqualsASCII(name_latin1, "accept"))
+      has_accept_header_ = true;
+
+    if (!buffer_.empty())
+      buffer_.append("\r\n");
+    buffer_.append(name_latin1 + ": " + value_latin1);
+  }
+
+  const std::string& GetBuffer() {
+    // In some cases, WebKit doesn't add an Accept header, but not having the
+    // header confuses some web servers.  See bug 808613.
+    if (!has_accept_header_) {
+      if (!buffer_.empty())
+        buffer_.append("\r\n");
+      buffer_.append("Accept: */*");
+      has_accept_header_ = true;
+    }
+    return buffer_;
+  }
+
+ private:
+  std::string buffer_;
+  bool has_accept_header_;
+};
+
+}  // namespace
+
 ResourceType WebURLRequestToResourceType(const WebURLRequest& request) {
   WebURLRequest::RequestContext requestContext = request.requestContext();
   if (request.frameType() != WebURLRequest::FrameTypeNone) {
     DCHECK(requestContext == WebURLRequest::RequestContextForm ||
            requestContext == WebURLRequest::RequestContextFrame ||
            requestContext == WebURLRequest::RequestContextHyperlink ||
            requestContext == WebURLRequest::RequestContextIframe ||
            requestContext == WebURLRequest::RequestContextInternal ||
            requestContext == WebURLRequest::RequestContextLocation);
     if (request.frameType() == WebURLRequest::FrameTypeTopLevel ||
@@ skipping 89 matching lines @@
     case WebURLRequest::RequestContextIframe:
       NOTREACHED();
       return RESOURCE_TYPE_SUB_RESOURCE;
 
     default:
       NOTREACHED();
       return RESOURCE_TYPE_SUB_RESOURCE;
   }
 }
 
+std::string GetWebURLRequestHeaders(const blink::WebURLRequest& request) {
+  HeaderFlattener flattener;
+  request.visitHTTPHeaderFields(&flattener);
+  return flattener.GetBuffer();
+}
+
+int GetLoadFlagsForWebURLRequest(const blink::WebURLRequest& request) {
+  int load_flags = net::LOAD_NORMAL;
+  GURL url = request.url();
+  switch (request.cachePolicy()) {
+    case WebURLRequest::ReloadIgnoringCacheData:
+      // Required by LayoutTests/http/tests/misc/refresh-headers.php
+      load_flags |= net::LOAD_VALIDATE_CACHE;
+      break;
+    case WebURLRequest::ReloadBypassingCache:
+      load_flags |= net::LOAD_BYPASS_CACHE;
+      break;
+    case WebURLRequest::ReturnCacheDataElseLoad:
+      load_flags |= net::LOAD_PREFERRING_CACHE;
+      break;
+    case WebURLRequest::ReturnCacheDataDontLoad:
+      load_flags |= net::LOAD_ONLY_FROM_CACHE;
+      break;
+    case WebURLRequest::UseProtocolCachePolicy:
+      break;
+    default:
+      NOTREACHED();
+  }
+
+  if (request.reportUploadProgress())
+    load_flags |= net::LOAD_ENABLE_UPLOAD_PROGRESS;
+  if (request.reportRawHeaders())
+    load_flags |= net::LOAD_REPORT_RAW_HEADERS;
+
+  if (!request.allowStoredCredentials()) {
+    load_flags |= net::LOAD_DO_NOT_SAVE_COOKIES;
+    load_flags |= net::LOAD_DO_NOT_SEND_COOKIES;
+  }
+
+  if (!request.allowStoredCredentials())
+    load_flags |= net::LOAD_DO_NOT_SEND_AUTH_DATA;
+
+  if (request.requestContext() == WebURLRequest::RequestContextXMLHttpRequest &&
+      (url.has_username() || url.has_password())) {
+    load_flags |= net::LOAD_DO_NOT_PROMPT_FOR_LOGIN;
+  }
+  return load_flags;
+}
+
 }  // namespace content