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