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 "net/base/net_errors.h"
  11 #include "third_party/WebKit/public/platform/WebHTTPHeaderVisitor.h"
  12 #include "third_party/WebKit/public/platform/WebString.h"
  13 #include "third_party/WebKit/public/platform/WebURL.h"
  14 #include "third_party/WebKit/public/platform/WebURLError.h"
  15 #include "third_party/WebKit/public/platform/WebURLRequest.h"
  16
  17 using blink::WebHTTPBody;
  18 using blink::WebString;
  19 using blink::WebURLRequest;
  20
  21 namespace content {
  22
  23 namespace {
  24
  25 const char kThrottledErrorDescription[] =
  26     "Request throttled. Visit http://dev.chromium.org/throttling for more "
  27     "information.";
  28
  29 class HeaderFlattener : public blink::WebHTTPHeaderVisitor {
  30  public:
  31   HeaderFlattener() : has_accept_header_(false) {}
  32
  33   virtual void visitHeader(const WebString& name, const WebString& value) {
  34     // Headers are latin1.
  35     const std::string& name_latin1 = name.latin1();
  36     const std::string& value_latin1 = value.latin1();
  37
  38     // Skip over referrer headers found in the header map because we already
  39     // pulled it out as a separate parameter.
  40     if (base::LowerCaseEqualsASCII(name_latin1, "referer"))
  41       return;
  42
  43     if (base::LowerCaseEqualsASCII(name_latin1, "accept"))
  44       has_accept_header_ = true;
  45
  46     if (!buffer_.empty())
  47       buffer_.append("\r\n");
  48     buffer_.append(name_latin1 + ": " + value_latin1);
  49   }
  50
  51   const std::string& GetBuffer() {
  52     // In some cases, WebKit doesn't add an Accept header, but not having the
  53     // header confuses some web servers.  See bug 808613.
  54     if (!has_accept_header_) {
  55       if (!buffer_.empty())
  56         buffer_.append("\r\n");
  57       buffer_.append("Accept: */*");
  58       has_accept_header_ = true;
  59     }
  60     return buffer_;
  61   }
  62
  63  private:
  64   std::string buffer_;
  65   bool has_accept_header_;
  66 };
  67
  68 }  // namespace
  69
  70 ResourceType WebURLRequestToResourceType(const WebURLRequest& request) {
  71   WebURLRequest::RequestContext requestContext = request.requestContext();
  72   if (request.frameType() != WebURLRequest::FrameTypeNone) {
  73     DCHECK(requestContext == WebURLRequest::RequestContextForm ||
  74            requestContext == WebURLRequest::RequestContextFrame ||
  75            requestContext == WebURLRequest::RequestContextHyperlink ||
  76            requestContext == WebURLRequest::RequestContextIframe ||
  77            requestContext == WebURLRequest::RequestContextInternal ||
  78            requestContext == WebURLRequest::RequestContextLocation);
  79     if (request.frameType() == WebURLRequest::FrameTypeTopLevel ||
  80         request.frameType() == WebURLRequest::FrameTypeAuxiliary) {
  81       return RESOURCE_TYPE_MAIN_FRAME;
  82     }
  83     if (request.frameType() == WebURLRequest::FrameTypeNested)
  84       return RESOURCE_TYPE_SUB_FRAME;
  85     NOTREACHED();
  86     return RESOURCE_TYPE_SUB_RESOURCE;
  87   }
  88
  89   switch (requestContext) {
  90     // Favicon
  91     case WebURLRequest::RequestContextFavicon:
  92       return RESOURCE_TYPE_FAVICON;
  93
  94     // Font
  95     case WebURLRequest::RequestContextFont:
  96       return RESOURCE_TYPE_FONT_RESOURCE;
  97
  98     // Image
  99     case WebURLRequest::RequestContextImage:
 100     case WebURLRequest::RequestContextImageSet:
 101       return RESOURCE_TYPE_IMAGE;
 102
 103     // Media
 104     case WebURLRequest::RequestContextAudio:
 105     case WebURLRequest::RequestContextVideo:
 106       return RESOURCE_TYPE_MEDIA;
 107
 108     // Object
 109     case WebURLRequest::RequestContextEmbed:
 110     case WebURLRequest::RequestContextObject:
 111       return RESOURCE_TYPE_OBJECT;
 112
 113     // Ping
 114     case WebURLRequest::RequestContextBeacon:
 115     case WebURLRequest::RequestContextCSPReport:
 116     case WebURLRequest::RequestContextPing:
 117       return RESOURCE_TYPE_PING;
 118
 119     // Prefetch
 120     case WebURLRequest::RequestContextPrefetch:
 121       return RESOURCE_TYPE_PREFETCH;
 122
 123     // Script
 124     case WebURLRequest::RequestContextImport:
 125     case WebURLRequest::RequestContextScript:
 126       return RESOURCE_TYPE_SCRIPT;
 127
 128     // Style
 129     case WebURLRequest::RequestContextXSLT:
 130     case WebURLRequest::RequestContextStyle:
 131       return RESOURCE_TYPE_STYLESHEET;
 132
 133     // Subresource
 134     case WebURLRequest::RequestContextDownload:
 135     case WebURLRequest::RequestContextManifest:
 136     case WebURLRequest::RequestContextSubresource:
 137     case WebURLRequest::RequestContextPlugin:
 138       return RESOURCE_TYPE_SUB_RESOURCE;
 139
 140     // TextTrack
 141     case WebURLRequest::RequestContextTrack:
 142       return RESOURCE_TYPE_MEDIA;
 143
 144     // Workers
 145     case WebURLRequest::RequestContextServiceWorker:
 146       return RESOURCE_TYPE_SERVICE_WORKER;
 147     case WebURLRequest::RequestContextSharedWorker:
 148       return RESOURCE_TYPE_SHARED_WORKER;
 149     case WebURLRequest::RequestContextWorker:
 150       return RESOURCE_TYPE_WORKER;
 151
 152     // Unspecified
 153     case WebURLRequest::RequestContextInternal:
 154     case WebURLRequest::RequestContextUnspecified:
 155       return RESOURCE_TYPE_SUB_RESOURCE;
 156
 157     // XHR
 158     case WebURLRequest::RequestContextEventSource:
 159     case WebURLRequest::RequestContextFetch:
 160     case WebURLRequest::RequestContextXMLHttpRequest:
 161       return RESOURCE_TYPE_XHR;
 162
 163     // These should be handled by the FrameType checks at the top of the
 164     // function.
 165     case WebURLRequest::RequestContextForm:
 166     case WebURLRequest::RequestContextHyperlink:
 167     case WebURLRequest::RequestContextLocation:
 168     case WebURLRequest::RequestContextFrame:
 169     case WebURLRequest::RequestContextIframe:
 170       NOTREACHED();
 171       return RESOURCE_TYPE_SUB_RESOURCE;
 172
 173     default:
 174       NOTREACHED();
 175       return RESOURCE_TYPE_SUB_RESOURCE;
 176   }
 177 }
 178
 179 std::string GetWebURLRequestHeaders(const blink::WebURLRequest& request) {
 180   HeaderFlattener flattener;
 181   request.visitHTTPHeaderFields(&flattener);
 182   return flattener.GetBuffer();
 183 }
 184
 185 int GetLoadFlagsForWebURLRequest(const blink::WebURLRequest& request) {
 186   int load_flags = net::LOAD_NORMAL;
 187   GURL url = request.url();
 188   switch (request.cachePolicy()) {
 189     case WebURLRequest::ReloadIgnoringCacheData:
 190       // Required by LayoutTests/http/tests/misc/refresh-headers.php
 191       load_flags |= net::LOAD_VALIDATE_CACHE;
 192       break;
 193     case WebURLRequest::ReloadBypassingCache:
 194       load_flags |= net::LOAD_BYPASS_CACHE;
 195       break;
 196     case WebURLRequest::ReturnCacheDataElseLoad:
 197       load_flags |= net::LOAD_PREFERRING_CACHE;
 198       break;
 199     case WebURLRequest::ReturnCacheDataDontLoad:
 200       load_flags |= net::LOAD_ONLY_FROM_CACHE;
 201       break;
 202     case WebURLRequest::UseProtocolCachePolicy:
 203       break;
 204     default:
 205       NOTREACHED();
 206   }
 207
 208   if (!request.allowStoredCredentials()) {
 209     load_flags |= net::LOAD_DO_NOT_SAVE_COOKIES;
 210     load_flags |= net::LOAD_DO_NOT_SEND_COOKIES;
 211   }
 212
 213   if (!request.allowStoredCredentials())
 214     load_flags |= net::LOAD_DO_NOT_SEND_AUTH_DATA;
 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 blink::WebURLError CreateWebURLError(const blink::WebURL& unreachable_url,
 280                                      bool stale_copy_in_cache,
 281                                      int reason) {
 282   blink::WebURLError error;
 283   error.domain = WebString::fromUTF8(net::kErrorDomain);
 284   error.reason = reason;
 285   error.unreachableURL = unreachable_url;
 286   error.staleCopyInCache = stale_copy_in_cache;
 287   if (reason == net::ERR_ABORTED) {
 288     error.isCancellation = true;
 289   } else if (reason == net::ERR_TEMPORARILY_THROTTLED) {
 290     error.localizedDescription =
 291         WebString::fromUTF8(kThrottledErrorDescription);
 292   } else {
 293     error.localizedDescription =
 294         WebString::fromUTF8(net::ErrorToString(reason));
 295   }
 296   return error;
 297 }
 298
 299 blink::WebURLError CreateWebURLError(const blink::WebURL& unreachable_url,
 300                                      bool stale_copy_in_cache,
 301                                      int reason,
 302                                      bool was_ignored_by_handler) {
 303   blink::WebURLError error =
 304       CreateWebURLError(unreachable_url, stale_copy_in_cache, reason);
 305   error.wasIgnoredByHandler = was_ignored_by_handler;
 306   return error;
 307 }
 308
 309 }  // namespace content