content/renderer/fetchers/resource_fetcher_impl.cc

   1 // Copyright (c) 2012 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/renderer/fetchers/resource_fetcher_impl.h"
   6
   7 #include "base/logging.h"
   8 #include "base/strings/string_util.h"
   9 #include "base/time/time.h"
  10 #include "third_party/WebKit/public/platform/Platform.h"
  11 #include "third_party/WebKit/public/platform/WebHTTPBody.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/WebURLLoader.h"
  15 #include "third_party/WebKit/public/platform/WebURLRequest.h"
  16 #include "third_party/WebKit/public/web/WebDocument.h"
  17 #include "third_party/WebKit/public/web/WebFrame.h"
  18 #include "third_party/WebKit/public/web/WebKit.h"
  19 #include "third_party/WebKit/public/web/WebSecurityPolicy.h"
  20
  21 namespace content {
  22
  23 // static
  24 ResourceFetcher* ResourceFetcher::Create(const GURL& url) {
  25   return new ResourceFetcherImpl(url);
  26 }
  27
  28 ResourceFetcherImpl::ResourceFetcherImpl(const GURL& url)
  29     : request_(url) {
  30 }
  31
  32 ResourceFetcherImpl::~ResourceFetcherImpl() {
  33   if (!completed() && loader_)
  34     loader_->cancel();
  35 }
  36
  37 void ResourceFetcherImpl::SetMethod(const std::string& method) {
  38   DCHECK(!request_.isNull());
  39   DCHECK(!loader_);
  40
  41   request_.setHTTPMethod(blink::WebString::fromUTF8(method));
  42 }
  43
  44 void ResourceFetcherImpl::SetBody(const std::string& body) {
  45   DCHECK(!request_.isNull());
  46   DCHECK(!loader_);
  47
  48   blink::WebHTTPBody web_http_body;
  49   web_http_body.initialize();
  50   web_http_body.appendData(blink::WebData(body));
  51   request_.setHTTPBody(web_http_body);
  52 }
  53
  54 void ResourceFetcherImpl::SetHeader(const std::string& header,
  55                                     const std::string& value) {
  56   DCHECK(!request_.isNull());
  57   DCHECK(!loader_);
  58
  59   if (LowerCaseEqualsASCII(header, "referer")) {
  60     blink::WebString referrer =
  61         blink::WebSecurityPolicy::generateReferrerHeader(
  62             blink::WebReferrerPolicyDefault,
  63             request_.url(),
  64             blink::WebString::fromUTF8(value));
  65     request_.setHTTPReferrer(referrer, blink::WebReferrerPolicyDefault);
  66   } else {
  67     request_.setHTTPHeaderField(blink::WebString::fromUTF8(header),
  68                                 blink::WebString::fromUTF8(value));
  69   }
  70 }
  71
  72 void ResourceFetcherImpl::SetSkipServiceWorker(bool skip_service_worker) {
  73   DCHECK(!request_.isNull());
  74   DCHECK(!loader_);
  75
  76   request_.setSkipServiceWorker(skip_service_worker);
  77 }
  78
  79 void ResourceFetcherImpl::SetLoaderOptions(
  80     const blink::WebURLLoaderOptions& options) {
  81   DCHECK(!request_.isNull());
  82   DCHECK(!loader_);
  83
  84   options_ = options;
  85 }
  86
  87 void ResourceFetcherImpl::Start(
  88     blink::WebFrame* frame,
  89     blink::WebURLRequest::RequestContext request_context,
  90     blink::WebURLRequest::FrameType frame_type,
  91     LoaderType loader_type,
  92     const Callback& callback) {
  93   DCHECK(!loader_);
  94   DCHECK(!request_.isNull());
  95   DCHECK(callback_.is_null());
  96   DCHECK(!completed());
  97   if (!request_.httpBody().isNull())
  98     DCHECK_NE("GET", request_.httpMethod().utf8()) << "GETs can't have bodies.";
  99
 100   callback_ = callback;
 101
 102   request_.setRequestContext(request_context);
 103   request_.setFrameType(frame_type);
 104   request_.setFirstPartyForCookies(frame->document().firstPartyForCookies());
 105   frame->dispatchWillSendRequest(request_);
 106
 107   switch (loader_type) {
 108     case PLATFORM_LOADER:
 109       loader_.reset(blink::Platform::current()->createURLLoader());
 110       break;
 111     case FRAME_ASSOCIATED_LOADER:
 112       loader_.reset(frame->createAssociatedURLLoader(options_));
 113       break;
 114   }
 115   loader_->loadAsynchronously(request_, this);
 116
 117   // No need to hold on to the request.
 118   request_.reset();
 119 }
 120
 121 void ResourceFetcherImpl::SetTimeout(const base::TimeDelta& timeout) {
 122   DCHECK(loader_);
 123   DCHECK(!completed());
 124
 125   timeout_timer_.Start(FROM_HERE, timeout, this, &ResourceFetcherImpl::Cancel);
 126 }
 127
 128 void ResourceFetcherImpl::OnLoadComplete() {
 129   timeout_timer_.Stop();
 130   if (callback_.is_null())
 131     return;
 132
 133   // Take a reference to the callback as running the callback may lead to our
 134   // destruction.
 135   Callback callback = callback_;
 136   callback.Run(status() == LOAD_FAILED ? blink::WebURLResponse() : response(),
 137                status() == LOAD_FAILED ? std::string() : data());
 138 }
 139
 140 void ResourceFetcherImpl::Cancel() {
 141   loader_->cancel();
 142   WebURLLoaderClientImpl::Cancel();
 143 }
 144
 145 }  // namespace content