Home | History | Annotate | Download | only in exported 
      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 "public/platform/WebURLRequest.h"
     33 
     34 #include "platform/exported/WebURLRequestPrivate.h"
     35 #include "platform/network/ResourceRequest.h"
     36 #include "public/platform/WebHTTPBody.h"
     37 #include "public/platform/WebHTTPHeaderVisitor.h"
     38 #include "public/platform/WebURL.h"
     39 
     40 namespace blink {
     41 
     42 namespace {
     43 
     44 class ExtraDataContainer : public ResourceRequest::ExtraData {
     45 public:
     46     static PassRefPtr<ExtraDataContainer> create(WebURLRequest::ExtraData* extraData) { return adoptRef(new ExtraDataContainer(extraData)); }
     47 
     48     virtual ~ExtraDataContainer() { }
     49 
     50     WebURLRequest::ExtraData* extraData() const { return m_extraData.get(); }
     51 
     52 private:
     53     explicit ExtraDataContainer(WebURLRequest::ExtraData* extraData)
     54         : m_extraData(adoptPtr(extraData))
     55     {
     56     }
     57 
     58     OwnPtr<WebURLRequest::ExtraData> m_extraData;
     59 };
     60 
     61 } // namespace
     62 
     63 // The standard implementation of WebURLRequestPrivate, which maintains
     64 // ownership of a ResourceRequest instance.
     65 class WebURLRequestPrivateImpl : public WebURLRequestPrivate {
     66 public:
     67     WebURLRequestPrivateImpl()
     68     {
     69         m_resourceRequest = &m_resourceRequestAllocation;
     70     }
     71 
     72     WebURLRequestPrivateImpl(const WebURLRequestPrivate* p)
     73         : m_resourceRequestAllocation(*p->m_resourceRequest)
     74     {
     75         m_resourceRequest = &m_resourceRequestAllocation;
     76     }
     77 
     78     virtual void dispose() { delete this; }
     79 
     80 private:
     81     virtual ~WebURLRequestPrivateImpl() { }
     82 
     83     ResourceRequest m_resourceRequestAllocation;
     84 };
     85 
     86 void WebURLRequest::initialize()
     87 {
     88     assign(new WebURLRequestPrivateImpl());
     89 }
     90 
     91 void WebURLRequest::reset()
     92 {
     93     assign(0);
     94 }
     95 
     96 void WebURLRequest::assign(const WebURLRequest& r)
     97 {
     98     if (&r != this)
     99         assign(r.m_private ? new WebURLRequestPrivateImpl(r.m_private) : 0);
    100 }
    101 
    102 bool WebURLRequest::isNull() const
    103 {
    104     return !m_private || m_private->m_resourceRequest->isNull();
    105 }
    106 
    107 WebURL WebURLRequest::url() const
    108 {
    109     return m_private->m_resourceRequest->url();
    110 }
    111 
    112 void WebURLRequest::setURL(const WebURL& url)
    113 {
    114     m_private->m_resourceRequest->setURL(url);
    115 }
    116 
    117 WebURL WebURLRequest::firstPartyForCookies() const
    118 {
    119     return m_private->m_resourceRequest->firstPartyForCookies();
    120 }
    121 
    122 void WebURLRequest::setFirstPartyForCookies(const WebURL& firstPartyForCookies)
    123 {
    124     m_private->m_resourceRequest->setFirstPartyForCookies(firstPartyForCookies);
    125 }
    126 
    127 bool WebURLRequest::allowStoredCredentials() const
    128 {
    129     return m_private->m_resourceRequest->allowStoredCredentials();
    130 }
    131 
    132 void WebURLRequest::setAllowStoredCredentials(bool allowStoredCredentials)
    133 {
    134     m_private->m_resourceRequest->setAllowStoredCredentials(allowStoredCredentials);
    135 }
    136 
    137 WebURLRequest::CachePolicy WebURLRequest::cachePolicy() const
    138 {
    139     return static_cast<WebURLRequest::CachePolicy>(
    140         m_private->m_resourceRequest->cachePolicy());
    141 }
    142 
    143 void WebURLRequest::setCachePolicy(CachePolicy cachePolicy)
    144 {
    145     m_private->m_resourceRequest->setCachePolicy(
    146         static_cast<ResourceRequestCachePolicy>(cachePolicy));
    147 }
    148 
    149 WebString WebURLRequest::httpMethod() const
    150 {
    151     return m_private->m_resourceRequest->httpMethod();
    152 }
    153 
    154 void WebURLRequest::setHTTPMethod(const WebString& httpMethod)
    155 {
    156     m_private->m_resourceRequest->setHTTPMethod(httpMethod);
    157 }
    158 
    159 WebString WebURLRequest::httpHeaderField(const WebString& name) const
    160 {
    161     return m_private->m_resourceRequest->httpHeaderField(name);
    162 }
    163 
    164 void WebURLRequest::setHTTPHeaderField(const WebString& name, const WebString& value)
    165 {
    166     RELEASE_ASSERT(!equalIgnoringCase(name, "referer"));
    167     m_private->m_resourceRequest->setHTTPHeaderField(name, value);
    168 }
    169 
    170 void WebURLRequest::setHTTPReferrer(const WebString& referrer, WebReferrerPolicy referrerPolicy)
    171 {
    172     if (referrer.isEmpty())
    173         m_private->m_resourceRequest->clearHTTPReferrer();
    174     else
    175         m_private->m_resourceRequest->setHTTPReferrer(Referrer(referrer, static_cast<ReferrerPolicy>(referrerPolicy)));
    176 }
    177 
    178 void WebURLRequest::addHTTPHeaderField(const WebString& name, const WebString& value)
    179 {
    180     m_private->m_resourceRequest->addHTTPHeaderField(name, value);
    181 }
    182 
    183 void WebURLRequest::clearHTTPHeaderField(const WebString& name)
    184 {
    185     m_private->m_resourceRequest->clearHTTPHeaderField(name);
    186 }
    187 
    188 void WebURLRequest::visitHTTPHeaderFields(WebHTTPHeaderVisitor* visitor) const
    189 {
    190     const HTTPHeaderMap& map = m_private->m_resourceRequest->httpHeaderFields();
    191     for (HTTPHeaderMap::const_iterator it = map.begin(); it != map.end(); ++it)
    192         visitor->visitHeader(it->key, it->value);
    193 }
    194 
    195 WebHTTPBody WebURLRequest::httpBody() const
    196 {
    197     return WebHTTPBody(m_private->m_resourceRequest->httpBody());
    198 }
    199 
    200 void WebURLRequest::setHTTPBody(const WebHTTPBody& httpBody)
    201 {
    202     m_private->m_resourceRequest->setHTTPBody(httpBody);
    203 }
    204 
    205 bool WebURLRequest::reportUploadProgress() const
    206 {
    207     return m_private->m_resourceRequest->reportUploadProgress();
    208 }
    209 
    210 void WebURLRequest::setReportUploadProgress(bool reportUploadProgress)
    211 {
    212     m_private->m_resourceRequest->setReportUploadProgress(reportUploadProgress);
    213 }
    214 
    215 void WebURLRequest::setReportRawHeaders(bool reportRawHeaders)
    216 {
    217     m_private->m_resourceRequest->setReportRawHeaders(reportRawHeaders);
    218 }
    219 
    220 bool WebURLRequest::reportRawHeaders() const
    221 {
    222     return m_private->m_resourceRequest->reportRawHeaders();
    223 }
    224 
    225 WebURLRequest::RequestContext WebURLRequest::requestContext() const
    226 {
    227     return m_private->m_resourceRequest->requestContext();
    228 }
    229 
    230 WebURLRequest::FrameType WebURLRequest::frameType() const
    231 {
    232     return m_private->m_resourceRequest->frameType();
    233 }
    234 
    235 WebReferrerPolicy WebURLRequest::referrerPolicy() const
    236 {
    237     return static_cast<WebReferrerPolicy>(m_private->m_resourceRequest->referrerPolicy());
    238 }
    239 
    240 void WebURLRequest::addHTTPOriginIfNeeded(const WebString& origin)
    241 {
    242     m_private->m_resourceRequest->addHTTPOriginIfNeeded(origin);
    243 }
    244 
    245 bool WebURLRequest::hasUserGesture() const
    246 {
    247     return m_private->m_resourceRequest->hasUserGesture();
    248 }
    249 
    250 void WebURLRequest::setHasUserGesture(bool hasUserGesture)
    251 {
    252     m_private->m_resourceRequest->setHasUserGesture(hasUserGesture);
    253 }
    254 
    255 void WebURLRequest::setRequestContext(RequestContext requestContext)
    256 {
    257     m_private->m_resourceRequest->setRequestContext(requestContext);
    258 }
    259 
    260 void WebURLRequest::setFrameType(FrameType frameType)
    261 {
    262     m_private->m_resourceRequest->setFrameType(frameType);
    263 }
    264 
    265 int WebURLRequest::requestorID() const
    266 {
    267     return m_private->m_resourceRequest->requestorID();
    268 }
    269 
    270 void WebURLRequest::setRequestorID(int requestorID)
    271 {
    272     m_private->m_resourceRequest->setRequestorID(requestorID);
    273 }
    274 
    275 int WebURLRequest::requestorProcessID() const
    276 {
    277     return m_private->m_resourceRequest->requestorProcessID();
    278 }
    279 
    280 void WebURLRequest::setRequestorProcessID(int requestorProcessID)
    281 {
    282     m_private->m_resourceRequest->setRequestorProcessID(requestorProcessID);
    283 }
    284 
    285 int WebURLRequest::appCacheHostID() const
    286 {
    287     return m_private->m_resourceRequest->appCacheHostID();
    288 }
    289 
    290 void WebURLRequest::setAppCacheHostID(int appCacheHostID)
    291 {
    292     m_private->m_resourceRequest->setAppCacheHostID(appCacheHostID);
    293 }
    294 
    295 bool WebURLRequest::downloadToFile() const
    296 {
    297     return m_private->m_resourceRequest->downloadToFile();
    298 }
    299 
    300 void WebURLRequest::setDownloadToFile(bool downloadToFile)
    301 {
    302     m_private->m_resourceRequest->setDownloadToFile(downloadToFile);
    303 }
    304 
    305 bool WebURLRequest::skipServiceWorker() const
    306 {
    307     return m_private->m_resourceRequest->skipServiceWorker();
    308 }
    309 
    310 void WebURLRequest::setSkipServiceWorker(bool skipServiceWorker)
    311 {
    312     m_private->m_resourceRequest->setSkipServiceWorker(skipServiceWorker);
    313 }
    314 
    315 WebURLRequest::ExtraData* WebURLRequest::extraData() const
    316 {
    317     RefPtr<ResourceRequest::ExtraData> data = m_private->m_resourceRequest->extraData();
    318     if (!data)
    319         return 0;
    320     return static_cast<ExtraDataContainer*>(data.get())->extraData();
    321 }
    322 
    323 void WebURLRequest::setExtraData(WebURLRequest::ExtraData* extraData)
    324 {
    325     m_private->m_resourceRequest->setExtraData(ExtraDataContainer::create(extraData));
    326 }
    327 
    328 ResourceRequest& WebURLRequest::toMutableResourceRequest()
    329 {
    330     ASSERT(m_private);
    331     ASSERT(m_private->m_resourceRequest);
    332 
    333     return *m_private->m_resourceRequest;
    334 }
    335 
    336 WebURLRequest::Priority WebURLRequest::priority() const
    337 {
    338     return static_cast<WebURLRequest::Priority>(
    339         m_private->m_resourceRequest->priority());
    340 }
    341 
    342 void WebURLRequest::setPriority(WebURLRequest::Priority priority)
    343 {
    344     m_private->m_resourceRequest->setPriority(
    345         static_cast<ResourceLoadPriority>(priority));
    346 }
    347 
    348 const ResourceRequest& WebURLRequest::toResourceRequest() const
    349 {
    350     ASSERT(m_private);
    351     ASSERT(m_private->m_resourceRequest);
    352 
    353     return *m_private->m_resourceRequest;
    354 }
    355 
    356 void WebURLRequest::assign(WebURLRequestPrivate* p)
    357 {
    358     // Subclasses may call this directly so a self-assignment check is needed
    359     // here as well as in the public assign method.
    360     if (m_private == p)
    361         return;
    362     if (m_private)
    363         m_private->dispose();
    364     m_private = p;
    365 }
    366 
    367 } // namespace blink
    368