src/content/child/web_url_request_util.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/child/web_url_request_util.h"
   6
   7 #include "base/logging.h"
   8 #include "base/strings/string_util.h"
   9 #include "net/base/load_flags.h"
  10 #include "third_party/WebKit/public/platform/WebHTTPHeaderVisitor.h"
  11 #include "third_party/WebKit/public/platform/WebString.h"
  12 #include "third_party/WebKit/public/platform/WebURLRequest.h"
  13
  14 using blink::WebURLRequest;
  15 using blink::WebString;
  16
  17 namespace content {
  18
  19 namespace {
  20
  21 class HeaderFlattener : public blink::WebHTTPHeaderVisitor {
  22  public:
  23   HeaderFlattener() : has_accept_header_(false) {}
  24
  25   virtual void visitHeader(const WebString& name, const WebString& value) {
  26     // Headers are latin1.
  27     const std::string& name_latin1 = name.latin1();
  28     const std::string& value_latin1 = value.latin1();
  29
  30     // Skip over referrer headers found in the header map because we already
  31     // pulled it out as a separate parameter.
  32     if (LowerCaseEqualsASCII(name_latin1, "referer"))
  33       return;
  34
  35     if (LowerCaseEqualsASCII(name_latin1, "accept"))
  36       has_accept_header_ = true;
  37
  38     if (!buffer_.empty())
  39       buffer_.append("\r\n");
  40     buffer_.append(name_latin1 + ": " + value_latin1);
  41   }
  42
  43   const std::string& GetBuffer() {
  44     // In some cases, WebKit doesn't add an Accept header, but not having the
  45     // header confuses some web servers.  See bug 808613.
  46     if (!has_accept_header_) {
  47       if (!buffer_.empty())
  48         buffer_.append("\r\n");
  49       buffer_.append("Accept: */*");
  50       has_accept_header_ = true;
  51     }
  52     return buffer_;
  53   }
  54
  55  private:
  56   std::string buffer_;
  57   bool has_accept_header_;
  58 };
  59
  60 }  // namespace
  61
  62 ResourceType WebURLRequestToResourceType(const WebURLRequest& request) {
  63   WebURLRequest::RequestContext requestContext = request.requestContext();
  64   if (request.frameType() != WebURLRequest::FrameTypeNone) {
  65     DCHECK(requestContext == WebURLRequest::RequestContextForm ||
  66            requestContext == WebURLRequest::RequestContextFrame ||
  67            requestContext == WebURLRequest::RequestContextHyperlink ||
  68            requestContext == WebURLRequest::RequestContextIframe ||
  69            requestContext == WebURLRequest::RequestContextInternal ||
  70            requestContext == WebURLRequest::RequestContextLocation);
  71     if (request.frameType() == WebURLRequest::FrameTypeTopLevel ||
  72         request.frameType() == WebURLRequest::FrameTypeAuxiliary) {
  73       return RESOURCE_TYPE_MAIN_FRAME;
  74     }
  75     if (request.frameType() == WebURLRequest::FrameTypeNested)
  76       return RESOURCE_TYPE_SUB_FRAME;
  77     NOTREACHED();
  78     return RESOURCE_TYPE_SUB_RESOURCE;
  79   }
  80
  81   switch (requestContext) {
  82     // Favicon
  83     case WebURLRequest::RequestContextFavicon:
  84       return RESOURCE_TYPE_FAVICON;
  85
  86     // Font
  87     case WebURLRequest::RequestContextFont:
  88       return RESOURCE_TYPE_FONT_RESOURCE;
  89
  90     // Image
  91     case WebURLRequest::RequestContextImage:
  92     case WebURLRequest::RequestContextImageSet:
  93       return RESOURCE_TYPE_IMAGE;
  94
  95     // Media
  96     case WebURLRequest::RequestContextAudio:
  97     case WebURLRequest::RequestContextVideo:
  98       return RESOURCE_TYPE_MEDIA;
  99
 100     // Object
 101     case WebURLRequest::RequestContextEmbed:
 102     case WebURLRequest::RequestContextObject:
 103       return RESOURCE_TYPE_OBJECT;
 104
 105     // Ping
 106     case WebURLRequest::RequestContextBeacon:
 107     case WebURLRequest::RequestContextCSPReport:
 108     case WebURLRequest::RequestContextPing:
 109       return RESOURCE_TYPE_PING;
 110
 111     // Prefetch
 112     case WebURLRequest::RequestContextPrefetch:
 113       return RESOURCE_TYPE_PREFETCH;
 114
 115     // Script
 116     case WebURLRequest::RequestContextImport:
 117     case WebURLRequest::RequestContextScript:
 118       return RESOURCE_TYPE_SCRIPT;
 119
 120     // Style
 121     case WebURLRequest::RequestContextXSLT:
 122     case WebURLRequest::RequestContextStyle:
 123       return RESOURCE_TYPE_STYLESHEET;
 124
 125     // Subresource
 126     case WebURLRequest::RequestContextDownload:
 127     case WebURLRequest::RequestContextManifest:
 128     case WebURLRequest::RequestContextSubresource:
 129     case WebURLRequest::RequestContextPlugin:
 130       return RESOURCE_TYPE_SUB_RESOURCE;
 131
 132     // TextTrack
 133     case WebURLRequest::RequestContextTrack:
 134       return RESOURCE_TYPE_MEDIA;
 135
 136     // Workers
 137     case WebURLRequest::RequestContextServiceWorker:
 138       return RESOURCE_TYPE_SERVICE_WORKER;
 139     case WebURLRequest::RequestContextSharedWorker:
 140       return RESOURCE_TYPE_SHARED_WORKER;
 141     case WebURLRequest::RequestContextWorker:
 142       return RESOURCE_TYPE_WORKER;
 143
 144     // Unspecified
 145     case WebURLRequest::RequestContextInternal:
 146     case WebURLRequest::RequestContextUnspecified:
 147       return RESOURCE_TYPE_SUB_RESOURCE;
 148
 149     // XHR
 150     case WebURLRequest::RequestContextEventSource:
 151     case WebURLRequest::RequestContextFetch:
 152     case WebURLRequest::RequestContextXMLHttpRequest:
 153       return RESOURCE_TYPE_XHR;
 154
 155     // These should be handled by the FrameType checks at the top of the
 156     // function.
 157     case WebURLRequest::RequestContextForm:
 158     case WebURLRequest::RequestContextHyperlink:
 159     case WebURLRequest::RequestContextLocation:
 160     case WebURLRequest::RequestContextFrame:
 161     case WebURLRequest::RequestContextIframe:
 162       NOTREACHED();
 163       return RESOURCE_TYPE_SUB_RESOURCE;
 164
 165     default:
 166       NOTREACHED();
 167       return RESOURCE_TYPE_SUB_RESOURCE;
 168   }
 169 }
 170
 171 std::string GetWebURLRequestHeaders(const blink::WebURLRequest& request) {
 172   HeaderFlattener flattener;
 173   request.visitHTTPHeaderFields(&flattener);
 174   return flattener.GetBuffer();
 175 }
 176
 177 int GetLoadFlagsForWebURLRequest(const blink::WebURLRequest& request) {
 178   int load_flags = net::LOAD_NORMAL;
 179   GURL url = request.url();
 180   switch (request.cachePolicy()) {
 181     case WebURLRequest::ReloadIgnoringCacheData:
 182       // Required by LayoutTests/http/tests/misc/refresh-headers.php
 183       load_flags |= net::LOAD_VALIDATE_CACHE;
 184       break;
 185     case WebURLRequest::ReloadBypassingCache:
 186       load_flags |= net::LOAD_BYPASS_CACHE;
 187       break;
 188     case WebURLRequest::ReturnCacheDataElseLoad:
 189       load_flags |= net::LOAD_PREFERRING_CACHE;
 190       break;
 191     case WebURLRequest::ReturnCacheDataDontLoad:
 192       load_flags |= net::LOAD_ONLY_FROM_CACHE;
 193       break;
 194     case WebURLRequest::UseProtocolCachePolicy:
 195       break;
 196     default:
 197       NOTREACHED();
 198   }
 199
 200   if (request.reportRawHeaders())
 201     load_flags |= net::LOAD_REPORT_RAW_HEADERS;
 202
 203   if (!request.allowStoredCredentials()) {
 204     load_flags |= net::LOAD_DO_NOT_SAVE_COOKIES;
 205     load_flags |= net::LOAD_DO_NOT_SEND_COOKIES;
 206   }
 207
 208   if (!request.allowStoredCredentials())
 209     load_flags |= net::LOAD_DO_NOT_SEND_AUTH_DATA;
 210
 211   if (request.requestContext() == WebURLRequest::RequestContextXMLHttpRequest &&
 212       (url.has_username() || url.has_password())) {
 213     load_flags |= net::LOAD_DO_NOT_PROMPT_FOR_LOGIN;
 214   }
 215   return load_flags;
 216 }
 217
 218 }  // namespace content