ResourceFetcher: Add POST support and the ability to set headers

content/renderer/fetchers/resource_fetcher_impl.cc

 // Copyright (c) 2012 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/renderer/fetchers/resource_fetcher_impl.h"
 
 #include "base/logging.h"
 #include "base/time/time.h"
 #include "third_party/WebKit/public/platform/Platform.h"
+#include "third_party/WebKit/public/platform/WebHTTPBody.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/WebKit/public/platform/WebURLError.h"
 #include "third_party/WebKit/public/platform/WebURLLoader.h"
 #include "third_party/WebKit/public/platform/WebURLRequest.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebKit.h"
 
 using base::TimeDelta;
 using blink::WebFrame;
+using blink::WebHTTPBody;
 using blink::WebURLError;
 using blink::WebURLLoader;
 using blink::WebURLRequest;
 using blink::WebURLResponse;
 
 namespace content {
 
 // static
-ResourceFetcher* ResourceFetcher::Create(
-    const GURL& url, WebFrame* frame, WebURLRequest::TargetType target_type,
-    const Callback& callback) {
-  return new ResourceFetcherImpl(url, frame, target_type, callback);
+ResourceFetcher* ResourceFetcher::Create(const GURL& url) {
+  return new ResourceFetcherImpl(url);
 }
 
-ResourceFetcherImpl::ResourceFetcherImpl(const GURL& url, WebFrame* frame,
-                                         WebURLRequest::TargetType target_type,
-                                         const Callback& callback)
-    : completed_(false),
-      callback_(callback) {
-  // Can't do anything without a frame.  However, delegate can be NULL (so we
-  // can do a http request and ignore the results).
-  DCHECK(frame);
-  Start(url, frame, target_type);
+ResourceFetcherImpl::ResourceFetcherImpl(const GURL& url)
+    : request_(url),
+      completed_(false) {
 }
 
 ResourceFetcherImpl::~ResourceFetcherImpl() {
   if (!completed_ && loader_)
     loader_->cancel();
 }
 
+void ResourceFetcherImpl::SetMethod(const std::string& method) {
+  DCHECK(!request_.isNull());
+  DCHECK(!loader_);
+
+  request_.setHTTPMethod(blink::WebString::fromUTF8(method));
+}
+
+void ResourceFetcherImpl::SetBody(const std::string& body) {
+  DCHECK(!request_.isNull());
+  DCHECK(!loader_);
+
+  WebHTTPBody web_http_body;
+  web_http_body.initialize();
+  web_http_body.appendData(blink::WebData(body));
+  request_.setHTTPBody(web_http_body);
+}
+
+void ResourceFetcherImpl::SetHeader(const std::string& header,
+                                    const std::string& value) {
+  DCHECK(!request_.isNull());
+  DCHECK(!loader_);
+
+  request_.setHTTPHeaderField(blink::WebString::fromUTF8(header),
+                              blink::WebString::fromUTF8(value));
+}
+
+void ResourceFetcherImpl::Start(WebFrame* frame,
+                                WebURLRequest::TargetType target_type,
+                                const Callback& callback) {
+  DCHECK(!loader_);
+  DCHECK(!request_.isNull());
+  DCHECK(callback_.is_null());
+  DCHECK(!completed_);
+  if (!request_.httpBody().isNull())
+    DCHECK_NE("GET", request_.httpMethod().utf8()) << "GETs can't have bodies.";
+
+  callback_ = callback;
+
+  request_.setTargetType(target_type);
+  request_.setFirstPartyForCookies(frame->document().firstPartyForCookies());
+  frame->dispatchWillSendRequest(request_);
+  loader_.reset(blink::Platform::current()->createURLLoader());
+  loader_->loadAsynchronously(request_, this);
+
+  // No need to hold on to the request.
+  request_.reset();
+}
+
 void ResourceFetcherImpl::SetTimeout(const base::TimeDelta& timeout) {
   DCHECK(loader_);
   DCHECK(!completed_);
+
   timeout_timer_.Start(FROM_HERE, timeout, this,
                        &ResourceFetcherImpl::TimeoutFired);
 }
 
-void ResourceFetcherImpl::Start(const GURL& url, WebFrame* frame,
-                                WebURLRequest::TargetType target_type) {
-  WebURLRequest request(url);
-  request.setTargetType(target_type);
-  request.setFirstPartyForCookies(frame->document().firstPartyForCookies());
-  frame->dispatchWillSendRequest(request);
-
-  loader_.reset(blink::Platform::current()->createURLLoader());
-  loader_->loadAsynchronously(request, this);
-}
-
 void ResourceFetcherImpl::RunCallback(const WebURLResponse& response,
                                       const std::string& data) {
   completed_ = true;
   timeout_timer_.Stop();
   if (callback_.is_null())
     return;
 
   // Take a reference to the callback as running the callback may lead to our
   // destruction.
   Callback callback = callback_;
@@ skipping 51 matching lines @@
 
 void ResourceFetcherImpl::didFail(WebURLLoader* loader,
                                   const WebURLError& error) {
   DCHECK(!completed_);
 
   // Go ahead and tell our delegate that we're done.
   RunCallback(WebURLResponse(), std::string());
 }
 
 }  // namespace content