Source/WebKit/chromium/src/WebURLRequest.cpp

   1 /*
   2  * Copyright (C) 2009 Google Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are
   6  * met:
   7  *
   8  *     * Redistributions of source code must retain the above copyright
   9  * notice, this list of conditions and the following disclaimer.
  10  *     * Redistributions in binary form must reproduce the above
  11  * copyright notice, this list of conditions and the following disclaimer
  12  * in the documentation and/or other materials provided with the
  13  * distribution.
  14  *     * Neither the name of Google Inc. nor the names of its
  15  * contributors may be used to endorse or promote products derived from
  16  * this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 #include "config.h"
  32 #include "WebURLRequest.h"
  33
  34 #include "ResourceRequest.h"
  35
  36 #include "WebHTTPBody.h"
  37 #include "WebHTTPHeaderVisitor.h"
  38 #include "WebURL.h"
  39 #include "WebURLRequestPrivate.h"
  40
  41 using namespace WebCore;
  42
  43 namespace WebKit {
  44
  45 namespace {
  46
  47 class ExtraDataContainer : public ResourceRequest::ExtraData {
  48 public:
  49     static PassRefPtr<ExtraDataContainer> create(WebURLRequest::ExtraData* extraData) { return adoptRef(new ExtraDataContainer(extraData)); }
  50
  51     virtual ~ExtraDataContainer() { }
  52
  53     WebURLRequest::ExtraData* extraData() const { return m_extraData.get(); }
  54
  55 private:
  56     explicit ExtraDataContainer(WebURLRequest::ExtraData* extraData)
  57         : m_extraData(adoptPtr(extraData))
  58     {
  59     }
  60
  61     OwnPtr<WebURLRequest::ExtraData> m_extraData;
  62 };
  63
  64 } // namespace
  65
  66 // The standard implementation of WebURLRequestPrivate, which maintains
  67 // ownership of a ResourceRequest instance.
  68 class WebURLRequestPrivateImpl : public WebURLRequestPrivate {
  69 public:
  70     WebURLRequestPrivateImpl()
  71     {
  72         m_resourceRequest = &m_resourceRequestAllocation;
  73     }
  74
  75     WebURLRequestPrivateImpl(const WebURLRequestPrivate* p)
  76         : m_resourceRequestAllocation(*p->m_resourceRequest)
  77     {
  78         m_resourceRequest = &m_resourceRequestAllocation;
  79         m_allowStoredCredentials = p->m_allowStoredCredentials;
  80     }
  81
  82     virtual void dispose() { delete this; }
  83
  84 private:
  85     virtual ~WebURLRequestPrivateImpl() { }
  86
  87     ResourceRequest m_resourceRequestAllocation;
  88 };
  89
  90 void WebURLRequest::initialize()
  91 {
  92     assign(new WebURLRequestPrivateImpl());
  93 }
  94
  95 void WebURLRequest::reset()
  96 {
  97     assign(0);
  98 }
  99
 100 void WebURLRequest::assign(const WebURLRequest& r)
 101 {
 102     if (&r != this)
 103         assign(r.m_private ? new WebURLRequestPrivateImpl(r.m_private) : 0);
 104 }
 105
 106 bool WebURLRequest::isNull() const
 107 {
 108     return !m_private || m_private->m_resourceRequest->isNull();
 109 }
 110
 111 WebURL WebURLRequest::url() const
 112 {
 113     return m_private->m_resourceRequest->url();
 114 }
 115
 116 void WebURLRequest::setURL(const WebURL& url)
 117 {
 118     m_private->m_resourceRequest->setURL(url);
 119 }
 120
 121 WebURL WebURLRequest::firstPartyForCookies() const
 122 {
 123     return m_private->m_resourceRequest->firstPartyForCookies();
 124 }
 125
 126 void WebURLRequest::setFirstPartyForCookies(const WebURL& firstPartyForCookies)
 127 {
 128     m_private->m_resourceRequest->setFirstPartyForCookies(firstPartyForCookies);
 129 }
 130
 131 bool WebURLRequest::allowCookies() const
 132 {
 133     return m_private->m_resourceRequest->allowCookies();
 134 }
 135
 136 void WebURLRequest::setAllowCookies(bool allowCookies)
 137 {
 138     m_private->m_resourceRequest->setAllowCookies(allowCookies);
 139 }
 140
 141 bool WebURLRequest::allowStoredCredentials() const
 142 {
 143     return m_private->m_allowStoredCredentials;
 144 }
 145
 146 void WebURLRequest::setAllowStoredCredentials(bool allowStoredCredentials)
 147 {
 148     m_private->m_allowStoredCredentials = allowStoredCredentials;
 149 }
 150
 151 WebURLRequest::CachePolicy WebURLRequest::cachePolicy() const
 152 {
 153     return static_cast<WebURLRequest::CachePolicy>(
 154         m_private->m_resourceRequest->cachePolicy());
 155 }
 156
 157 void WebURLRequest::setCachePolicy(CachePolicy cachePolicy)
 158 {
 159     m_private->m_resourceRequest->setCachePolicy(
 160         static_cast<ResourceRequestCachePolicy>(cachePolicy));
 161 }
 162
 163 WebString WebURLRequest::httpMethod() const
 164 {
 165     return m_private->m_resourceRequest->httpMethod();
 166 }
 167
 168 void WebURLRequest::setHTTPMethod(const WebString& httpMethod)
 169 {
 170     m_private->m_resourceRequest->setHTTPMethod(httpMethod);
 171 }
 172
 173 WebString WebURLRequest::httpHeaderField(const WebString& name) const
 174 {
 175     return m_private->m_resourceRequest->httpHeaderField(name);
 176 }
 177
 178 void WebURLRequest::setHTTPHeaderField(const WebString& name, const WebString& value)
 179 {
 180     m_private->m_resourceRequest->setHTTPHeaderField(name, value);
 181 }
 182
 183 void WebURLRequest::addHTTPHeaderField(const WebString& name, const WebString& value)
 184 {
 185     m_private->m_resourceRequest->addHTTPHeaderField(name, value);
 186 }
 187
 188 void WebURLRequest::clearHTTPHeaderField(const WebString& name)
 189 {
 190     // FIXME: Add a clearHTTPHeaderField method to ResourceRequest.
 191     const HTTPHeaderMap& map = m_private->m_resourceRequest->httpHeaderFields();
 192     const_cast<HTTPHeaderMap*>(&map)->remove(name);
 193 }
 194
 195 void WebURLRequest::visitHTTPHeaderFields(WebHTTPHeaderVisitor* visitor) const
 196 {
 197     const HTTPHeaderMap& map = m_private->m_resourceRequest->httpHeaderFields();
 198     for (HTTPHeaderMap::const_iterator it = map.begin(); it != map.end(); ++it)
 199         visitor->visitHeader(it->first, it->second);
 200 }
 201
 202 WebHTTPBody WebURLRequest::httpBody() const
 203 {
 204     return WebHTTPBody(m_private->m_resourceRequest->httpBody());
 205 }
 206
 207 void WebURLRequest::setHTTPBody(const WebHTTPBody& httpBody)
 208 {
 209     m_private->m_resourceRequest->setHTTPBody(httpBody);
 210 }
 211
 212 bool WebURLRequest::reportUploadProgress() const
 213 {
 214     return m_private->m_resourceRequest->reportUploadProgress();
 215 }
 216
 217 void WebURLRequest::setReportUploadProgress(bool reportUploadProgress)
 218 {
 219     m_private->m_resourceRequest->setReportUploadProgress(reportUploadProgress);
 220 }
 221
 222 bool WebURLRequest::reportLoadTiming() const
 223 {
 224     return m_private->m_resourceRequest->reportLoadTiming();
 225 }
 226
 227 void WebURLRequest::setReportRawHeaders(bool reportRawHeaders)
 228 {
 229     m_private->m_resourceRequest->setReportRawHeaders(reportRawHeaders);
 230 }
 231
 232 bool WebURLRequest::reportRawHeaders() const
 233 {
 234     return m_private->m_resourceRequest->reportRawHeaders();
 235 }
 236
 237 void WebURLRequest::setReportLoadTiming(bool reportLoadTiming)
 238 {
 239     m_private->m_resourceRequest->setReportLoadTiming(reportLoadTiming);
 240 }
 241
 242 WebURLRequest::TargetType WebURLRequest::targetType() const
 243 {
 244     // FIXME: Temporary special case until downstream chromium.org knows of the new TargetTypes.
 245     TargetType targetType = static_cast<TargetType>(m_private->m_resourceRequest->targetType());
 246     if (targetType == TargetIsTextTrack || targetType == TargetIsUnspecified)
 247         return TargetIsSubresource;
 248     return targetType;
 249 }
 250
 251 bool WebURLRequest::hasUserGesture() const
 252 {
 253     return m_private->m_resourceRequest->hasUserGesture();
 254 }
 255
 256 void WebURLRequest::setHasUserGesture(bool hasUserGesture)
 257 {
 258     m_private->m_resourceRequest->setHasUserGesture(hasUserGesture);
 259 }
 260
 261 void WebURLRequest::setTargetType(TargetType targetType)
 262 {
 263     m_private->m_resourceRequest->setTargetType(
 264         static_cast<ResourceRequest::TargetType>(targetType));
 265 }
 266
 267 int WebURLRequest::requestorID() const
 268 {
 269     return m_private->m_resourceRequest->requestorID();
 270 }
 271
 272 void WebURLRequest::setRequestorID(int requestorID)
 273 {
 274     m_private->m_resourceRequest->setRequestorID(requestorID);
 275 }
 276
 277 int WebURLRequest::requestorProcessID() const
 278 {
 279     return m_private->m_resourceRequest->requestorProcessID();
 280 }
 281
 282 void WebURLRequest::setRequestorProcessID(int requestorProcessID)
 283 {
 284     m_private->m_resourceRequest->setRequestorProcessID(requestorProcessID);
 285 }
 286
 287 int WebURLRequest::appCacheHostID() const
 288 {
 289     return m_private->m_resourceRequest->appCacheHostID();
 290 }
 291
 292 void WebURLRequest::setAppCacheHostID(int appCacheHostID)
 293 {
 294     m_private->m_resourceRequest->setAppCacheHostID(appCacheHostID);
 295 }
 296
 297 bool WebURLRequest::downloadToFile() const
 298 {
 299     return m_private->m_resourceRequest->downloadToFile();
 300 }
 301
 302 void WebURLRequest::setDownloadToFile(bool downloadToFile)
 303 {
 304     m_private->m_resourceRequest->setDownloadToFile(downloadToFile);
 305 }
 306
 307 WebURLRequest::ExtraData* WebURLRequest::extraData() const
 308 {
 309     RefPtr<ResourceRequest::ExtraData> data = m_private->m_resourceRequest->extraData();
 310     if (!data)
 311         return 0;
 312     return static_cast<ExtraDataContainer*>(data.get())->extraData();
 313 }
 314
 315 void WebURLRequest::setExtraData(WebURLRequest::ExtraData* extraData)
 316 {
 317     m_private->m_resourceRequest->setExtraData(ExtraDataContainer::create(extraData));
 318 }
 319
 320 ResourceRequest& WebURLRequest::toMutableResourceRequest()
 321 {
 322     ASSERT(m_private);
 323     ASSERT(m_private->m_resourceRequest);
 324
 325     return *m_private->m_resourceRequest;
 326 }
 327
 328 const ResourceRequest& WebURLRequest::toResourceRequest() const
 329 {
 330     ASSERT(m_private);
 331     ASSERT(m_private->m_resourceRequest);
 332
 333     return *m_private->m_resourceRequest;
 334 }
 335
 336 void WebURLRequest::assign(WebURLRequestPrivate* p)
 337 {
 338     // Subclasses may call this directly so a self-assignment check is needed
 339     // here as well as in the public assign method.
 340     if (m_private == p)
 341         return;
 342     if (m_private)
 343         m_private->dispose();
 344     m_private = p;
 345 }
 346
 347 } // namespace WebKit