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::WebHTTPBody;
  15 using blink::WebString;
  16 using blink::WebURLRequest;
  17
  18 namespace content {
  19
  20 namespace {
  21
  22 class HeaderFlattener : public blink::WebHTTPHeaderVisitor {
  23  public:
  24   HeaderFlattener() : has_accept_header_(false) {}
  25
  26   virtual void visitHeader(const WebString& name, const WebString& value) {
  27     // Headers are latin1.
  28     const std::string& name_latin1 = name.latin1();
  29     const std::string& value_latin1 = value.latin1();
  30
  31     // Skip over referrer headers found in the header map because we already
  32     // pulled it out as a separate parameter.
  33     if (LowerCaseEqualsASCII(name_latin1, "referer"))
  34       return;
  35
  36     if (LowerCaseEqualsASCII(name_latin1, "accept"))
  37       has_accept_header_ = true;
  38
  39     if (!buffer_.empty())
  40       buffer_.append("\r\n");
  41     buffer_.append(name_latin1 + ": " + value_latin1);
  42   }
  43
  44   const std::string& GetBuffer() {
  45     // In some cases, WebKit doesn't add an Accept header, but not having the
  46     // header confuses some web servers.  See bug 808613.
  47     if (!has_accept_header_) {
  48       if (!buffer_.empty())
  49         buffer_.append("\r\n");
  50       buffer_.append("Accept: */*");
  51       has_accept_header_ = true;
  52     }
  53     return buffer_;
  54   }
  55
  56  private:
  57   std::string buffer_;
  58   bool has_accept_header_;
  59 };
  60
  61 }  // namespace
  62
  63 ResourceType WebURLRequestToResourceType(const WebURLRequest& request) {
  64   WebURLRequest::RequestContext requestContext = request.requestContext();
  65   if (request.frameType() != WebURLRequest::FrameTypeNone) {
  66     DCHECK(requestContext == WebURLRequest::RequestContextForm ||
  67            requestContext == WebURLRequest::RequestContextFrame ||
  68            requestContext == WebURLRequest::RequestContextHyperlink ||
  69            requestContext == WebURLRequest::RequestContextIframe ||
  70            requestContext == WebURLRequest::RequestContextInternal ||
  71            requestContext == WebURLRequest::RequestContextLocation);
  72     if (request.frameType() == WebURLRequest::FrameTypeTopLevel ||
  73         request.frameType() == WebURLRequest::FrameTypeAuxiliary) {
  74       return RESOURCE_TYPE_MAIN_FRAME;
  75     }
  76     if (request.frameType() == WebURLRequest::FrameTypeNested)
  77       return RESOURCE_TYPE_SUB_FRAME;
  78     NOTREACHED();
  79     return RESOURCE_TYPE_SUB_RESOURCE;
  80   }
  81
  82   switch (requestContext) {
  83     // Favicon
  84     case WebURLRequest::RequestContextFavicon:
  85       return RESOURCE_TYPE_FAVICON;
  86
  87     // Font
  88     case WebURLRequest::RequestContextFont:
  89       return RESOURCE_TYPE_FONT_RESOURCE;
  90
  91     // Image
  92     case WebURLRequest::RequestContextImage:
  93     case WebURLRequest::RequestContextImageSet:
  94       return RESOURCE_TYPE_IMAGE;
  95
  96     // Media
  97     case WebURLRequest::RequestContextAudio:
  98     case WebURLRequest::RequestContextVideo:
  99       return RESOURCE_TYPE_MEDIA;
 100
 101     // Object
 102     case WebURLRequest::RequestContextEmbed:
 103     case WebURLRequest::RequestContextObject:
 104       return RESOURCE_TYPE_OBJECT;
 105
 106     // Ping
 107     case WebURLRequest::RequestContextBeacon:
 108     case WebURLRequest::RequestContextCSPReport:
 109     case WebURLRequest::RequestContextPing:
 110       return RESOURCE_TYPE_PING;
 111
 112     // Prefetch
 113     case WebURLRequest::RequestContextPrefetch:
 114       return RESOURCE_TYPE_PREFETCH;
 115
 116     // Script
 117     case WebURLRequest::RequestContextImport:
 118     case WebURLRequest::RequestContextScript:
 119       return RESOURCE_TYPE_SCRIPT;
 120
 121     // Style
 122     case WebURLRequest::RequestContextXSLT:
 123     case WebURLRequest::RequestContextStyle:
 124       return RESOURCE_TYPE_STYLESHEET;
 125
 126     // Subresource
 127     case WebURLRequest::RequestContextDownload:
 128     case WebURLRequest::RequestContextManifest:
 129     case WebURLRequest::RequestContextSubresource:
 130     case WebURLRequest::RequestContextPlugin:
 131       return RESOURCE_TYPE_SUB_RESOURCE;
 132
 133     // TextTrack
 134     case WebURLRequest::RequestContextTrack:
 135       return RESOURCE_TYPE_MEDIA;
 136
 137     // Workers
 138     case WebURLRequest::RequestContextServiceWorker:
 139       return RESOURCE_TYPE_SERVICE_WORKER;
 140     case WebURLRequest::RequestContextSharedWorker:
 141       return RESOURCE_TYPE_SHARED_WORKER;
 142     case WebURLRequest::RequestContextWorker:
 143       return RESOURCE_TYPE_WORKER;
 144
 145     // Unspecified
 146     case WebURLRequest::RequestContextInternal:
 147     case WebURLRequest::RequestContextUnspecified:
 148       return RESOURCE_TYPE_SUB_RESOURCE;
 149
 150     // XHR
 151     case WebURLRequest::RequestContextEventSource:
 152     case WebURLRequest::RequestContextFetch:
 153     case WebURLRequest::RequestContextXMLHttpRequest:
 154       return RESOURCE_TYPE_XHR;
 155
 156     // These should be handled by the FrameType checks at the top of the
 157     // function.
 158     case WebURLRequest::RequestContextForm:
 159     case WebURLRequest::RequestContextHyperlink:
 160     case WebURLRequest::RequestContextLocation:
 161     case WebURLRequest::RequestContextFrame:
 162     case WebURLRequest::RequestContextIframe:
 163       NOTREACHED();
 164       return RESOURCE_TYPE_SUB_RESOURCE;
 165
 166     default:
 167       NOTREACHED();
 168       return RESOURCE_TYPE_SUB_RESOURCE;
 169   }
 170 }
 171
 172 std::string GetWebURLRequestHeaders(const blink::WebURLRequest& request) {
 173   HeaderFlattener flattener;
 174   request.visitHTTPHeaderFields(&flattener);
 175   return flattener.GetBuffer();
 176 }
 177
 178 int GetLoadFlagsForWebURLRequest(const blink::WebURLRequest& request) {
 179   int load_flags = net::LOAD_NORMAL;
 180   GURL url = request.url();
 181   switch (request.cachePolicy()) {
 182     case WebURLRequest::ReloadIgnoringCacheData:
 183       // Required by LayoutTests/http/tests/misc/refresh-headers.php
 184       load_flags |= net::LOAD_VALIDATE_CACHE;
 185       break;
 186     case WebURLRequest::ReloadBypassingCache:
 187       load_flags |= net::LOAD_BYPASS_CACHE;
 188       break;
 189     case WebURLRequest::ReturnCacheDataElseLoad:
 190       load_flags |= net::LOAD_PREFERRING_CACHE;
 191       break;
 192     case WebURLRequest::ReturnCacheDataDontLoad:
 193       load_flags |= net::LOAD_ONLY_FROM_CACHE;
 194       break;
 195     case WebURLRequest::UseProtocolCachePolicy:
 196       break;
 197     default:
 198       NOTREACHED();
 199   }
 200
 201   if (request.reportRawHeaders())
 202     load_flags |= net::LOAD_REPORT_RAW_HEADERS;
 203
 204   if (!request.allowStoredCredentials()) {
 205     load_flags |= net::LOAD_DO_NOT_SAVE_COOKIES;
 206     load_flags |= net::LOAD_DO_NOT_SEND_COOKIES;
 207   }
 208
 209   if (!request.allowStoredCredentials())
 210     load_flags |= net::LOAD_DO_NOT_SEND_AUTH_DATA;
 211
 212   if (request.requestContext() == WebURLRequest::RequestContextXMLHttpRequest &&
 213       (url.has_username() || url.has_password())) {
 214     load_flags |= net::LOAD_DO_NOT_PROMPT_FOR_LOGIN;
 215   }
 216   return load_flags;
 217 }
 218
 219 scoped_refptr<ResourceRequestBody> GetRequestBodyForWebURLRequest(
 220     const blink::WebURLRequest& request) {
 221   scoped_refptr<ResourceRequestBody> request_body;
 222
 223   if (request.httpBody().isNull()) {
 224     return request_body;
 225   }
 226
 227   const std::string& method = request.httpMethod().latin1();
 228   // GET and HEAD requests shouldn't have http bodies.
 229   DCHECK(method != "GET" && method != "HEAD");
 230
 231   const WebHTTPBody& httpBody = request.httpBody();
 232   request_body = new ResourceRequestBody();
 233   size_t i = 0;
 234   WebHTTPBody::Element element;
 235   while (httpBody.elementAt(i++, element)) {
 236     switch (element.type) {
 237       case WebHTTPBody::Element::TypeData:
 238         if (!element.data.isEmpty()) {
 239           // Blink sometimes gives empty data to append. These aren't
 240           // necessary so they are just optimized out here.
 241           request_body->AppendBytes(
 242               element.data.data(), static_cast<int>(element.data.size()));
 243         }
 244         break;
 245       case WebHTTPBody::Element::TypeFile:
 246         if (element.fileLength == -1) {
 247           request_body->AppendFileRange(
 248               base::FilePath::FromUTF16Unsafe(element.filePath),
 249               0, kuint64max, base::Time());
 250         } else {
 251           request_body->AppendFileRange(
 252               base::FilePath::FromUTF16Unsafe(element.filePath),
 253               static_cast<uint64>(element.fileStart),
 254               static_cast<uint64>(element.fileLength),
 255               base::Time::FromDoubleT(element.modificationTime));
 256         }
 257         break;
 258       case WebHTTPBody::Element::TypeFileSystemURL: {
 259         GURL file_system_url = element.fileSystemURL;
 260         DCHECK(file_system_url.SchemeIsFileSystem());
 261         request_body->AppendFileSystemFileRange(
 262             file_system_url,
 263             static_cast<uint64>(element.fileStart),
 264             static_cast<uint64>(element.fileLength),
 265             base::Time::FromDoubleT(element.modificationTime));
 266         break;
 267       }
 268       case WebHTTPBody::Element::TypeBlob:
 269         request_body->AppendBlob(element.blobUUID.utf8());
 270         break;
 271       default:
 272         NOTREACHED();
 273     }
 274   }
 275   request_body->set_identifier(request.httpBody().identifier());
 276   return request_body;
 277 }
 278
 279 }  // namespace content