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/WebURLResponse.h"
     33 
     34 #include "core/platform/chromium/support/WebURLResponsePrivate.h"
     35 #include "core/platform/network/ResourceLoadTiming.h"
     36 #include "core/platform/network/ResourceResponse.h"
     37 #include "public/platform/WebHTTPHeaderVisitor.h"
     38 #include "public/platform/WebHTTPLoadInfo.h"
     39 #include "public/platform/WebString.h"
     40 #include "public/platform/WebURL.h"
     41 #include "public/platform/WebURLLoadTiming.h"
     42 #include "wtf/RefPtr.h"
     43 
     44 using namespace WebCore;
     45 
     46 namespace WebKit {
     47 
     48 namespace {
     49 
     50 class ExtraDataContainer : public ResourceResponse::ExtraData {
     51 public:
     52     static PassRefPtr<ExtraDataContainer> create(WebURLResponse::ExtraData* extraData) { return adoptRef(new ExtraDataContainer(extraData)); }
     53 
     54     virtual ~ExtraDataContainer() { }
     55 
     56     WebURLResponse::ExtraData* extraData() const { return m_extraData.get(); }
     57 
     58 private:
     59     explicit ExtraDataContainer(WebURLResponse::ExtraData* extraData)
     60         : m_extraData(adoptPtr(extraData))
     61     {
     62     }
     63 
     64     OwnPtr<WebURLResponse::ExtraData> m_extraData;
     65 };
     66 
     67 } // namespace
     68 
     69 // The standard implementation of WebURLResponsePrivate, which maintains
     70 // ownership of a ResourceResponse instance.
     71 class WebURLResponsePrivateImpl : public WebURLResponsePrivate {
     72 public:
     73     WebURLResponsePrivateImpl()
     74     {
     75         m_resourceResponse = &m_resourceResponseAllocation;
     76     }
     77 
     78     WebURLResponsePrivateImpl(const WebURLResponsePrivate* p)
     79         : m_resourceResponseAllocation(*p->m_resourceResponse)
     80     {
     81         m_resourceResponse = &m_resourceResponseAllocation;
     82     }
     83 
     84     virtual void dispose() { delete this; }
     85 
     86 private:
     87     virtual ~WebURLResponsePrivateImpl() { }
     88 
     89     ResourceResponse m_resourceResponseAllocation;
     90 };
     91 
     92 void WebURLResponse::initialize()
     93 {
     94     assign(new WebURLResponsePrivateImpl());
     95 }
     96 
     97 void WebURLResponse::reset()
     98 {
     99     assign(0);
    100 }
    101 
    102 void WebURLResponse::assign(const WebURLResponse& r)
    103 {
    104     if (&r != this)
    105         assign(r.m_private ? new WebURLResponsePrivateImpl(r.m_private) : 0);
    106 }
    107 
    108 bool WebURLResponse::isNull() const
    109 {
    110     return !m_private || m_private->m_resourceResponse->isNull();
    111 }
    112 
    113 WebURL WebURLResponse::url() const
    114 {
    115     return m_private->m_resourceResponse->url();
    116 }
    117 
    118 void WebURLResponse::setURL(const WebURL& url)
    119 {
    120     m_private->m_resourceResponse->setURL(url);
    121 }
    122 
    123 unsigned WebURLResponse::connectionID() const
    124 {
    125     return m_private->m_resourceResponse->connectionID();
    126 }
    127 
    128 void WebURLResponse::setConnectionID(unsigned connectionID)
    129 {
    130     m_private->m_resourceResponse->setConnectionID(connectionID);
    131 }
    132 
    133 bool WebURLResponse::connectionReused() const
    134 {
    135     return m_private->m_resourceResponse->connectionReused();
    136 }
    137 
    138 void WebURLResponse::setConnectionReused(bool connectionReused)
    139 {
    140     m_private->m_resourceResponse->setConnectionReused(connectionReused);
    141 }
    142 
    143 WebURLLoadTiming WebURLResponse::loadTiming()
    144 {
    145     return WebURLLoadTiming(m_private->m_resourceResponse->resourceLoadTiming());
    146 }
    147 
    148 void WebURLResponse::setLoadTiming(const WebURLLoadTiming& timing)
    149 {
    150     RefPtr<ResourceLoadTiming> loadTiming = PassRefPtr<ResourceLoadTiming>(timing);
    151     m_private->m_resourceResponse->setResourceLoadTiming(loadTiming.release());
    152 }
    153 
    154 WebHTTPLoadInfo WebURLResponse::httpLoadInfo()
    155 {
    156     return WebHTTPLoadInfo(m_private->m_resourceResponse->resourceLoadInfo());
    157 }
    158 
    159 void WebURLResponse::setHTTPLoadInfo(const WebHTTPLoadInfo& value)
    160 {
    161     m_private->m_resourceResponse->setResourceLoadInfo(value);
    162 }
    163 
    164 double WebURLResponse::responseTime() const
    165 {
    166     return m_private->m_resourceResponse->responseTime();
    167 }
    168 
    169 void WebURLResponse::setResponseTime(double responseTime)
    170 {
    171     m_private->m_resourceResponse->setResponseTime(responseTime);
    172 }
    173 
    174 WebString WebURLResponse::mimeType() const
    175 {
    176     return m_private->m_resourceResponse->mimeType();
    177 }
    178 
    179 void WebURLResponse::setMIMEType(const WebString& mimeType)
    180 {
    181     m_private->m_resourceResponse->setMimeType(mimeType);
    182 }
    183 
    184 long long WebURLResponse::expectedContentLength() const
    185 {
    186     return m_private->m_resourceResponse->expectedContentLength();
    187 }
    188 
    189 void WebURLResponse::setExpectedContentLength(long long expectedContentLength)
    190 {
    191     m_private->m_resourceResponse->setExpectedContentLength(expectedContentLength);
    192 }
    193 
    194 WebString WebURLResponse::textEncodingName() const
    195 {
    196     return m_private->m_resourceResponse->textEncodingName();
    197 }
    198 
    199 void WebURLResponse::setTextEncodingName(const WebString& textEncodingName)
    200 {
    201     m_private->m_resourceResponse->setTextEncodingName(textEncodingName);
    202 }
    203 
    204 WebString WebURLResponse::suggestedFileName() const
    205 {
    206     return m_private->m_resourceResponse->suggestedFilename();
    207 }
    208 
    209 void WebURLResponse::setSuggestedFileName(const WebString& suggestedFileName)
    210 {
    211     m_private->m_resourceResponse->setSuggestedFilename(suggestedFileName);
    212 }
    213 
    214 WebURLResponse::HTTPVersion WebURLResponse::httpVersion() const
    215 {
    216     return static_cast<HTTPVersion>(m_private->m_resourceResponse->httpVersion());
    217 }
    218 
    219 void WebURLResponse::setHTTPVersion(HTTPVersion version)
    220 {
    221     m_private->m_resourceResponse->setHTTPVersion(static_cast<ResourceResponse::HTTPVersion>(version));
    222 }
    223 
    224 int WebURLResponse::httpStatusCode() const
    225 {
    226     return m_private->m_resourceResponse->httpStatusCode();
    227 }
    228 
    229 void WebURLResponse::setHTTPStatusCode(int httpStatusCode)
    230 {
    231     m_private->m_resourceResponse->setHTTPStatusCode(httpStatusCode);
    232 }
    233 
    234 WebString WebURLResponse::httpStatusText() const
    235 {
    236     return m_private->m_resourceResponse->httpStatusText();
    237 }
    238 
    239 void WebURLResponse::setHTTPStatusText(const WebString& httpStatusText)
    240 {
    241     m_private->m_resourceResponse->setHTTPStatusText(httpStatusText);
    242 }
    243 
    244 WebString WebURLResponse::httpHeaderField(const WebString& name) const
    245 {
    246     return m_private->m_resourceResponse->httpHeaderField(name);
    247 }
    248 
    249 void WebURLResponse::setHTTPHeaderField(const WebString& name, const WebString& value)
    250 {
    251     m_private->m_resourceResponse->setHTTPHeaderField(name, value);
    252 }
    253 
    254 void WebURLResponse::addHTTPHeaderField(const WebString& name, const WebString& value)
    255 {
    256     if (name.isNull() || value.isNull())
    257         return;
    258 
    259     m_private->m_resourceResponse->addHTTPHeaderField(name, value);
    260 }
    261 
    262 void WebURLResponse::clearHTTPHeaderField(const WebString& name)
    263 {
    264     // FIXME: Add a clearHTTPHeaderField method to ResourceResponse.
    265     const HTTPHeaderMap& map = m_private->m_resourceResponse->httpHeaderFields();
    266     const_cast<HTTPHeaderMap*>(&map)->remove(name);
    267 }
    268 
    269 void WebURLResponse::visitHTTPHeaderFields(WebHTTPHeaderVisitor* visitor) const
    270 {
    271     const HTTPHeaderMap& map = m_private->m_resourceResponse->httpHeaderFields();
    272     for (HTTPHeaderMap::const_iterator it = map.begin(); it != map.end(); ++it)
    273         visitor->visitHeader(it->key, it->value);
    274 }
    275 
    276 double WebURLResponse::lastModifiedDate() const
    277 {
    278     return static_cast<double>(m_private->m_resourceResponse->lastModifiedDate());
    279 }
    280 
    281 void WebURLResponse::setLastModifiedDate(double lastModifiedDate)
    282 {
    283     m_private->m_resourceResponse->setLastModifiedDate(static_cast<time_t>(lastModifiedDate));
    284 }
    285 
    286 long long WebURLResponse::appCacheID() const
    287 {
    288     return m_private->m_resourceResponse->appCacheID();
    289 }
    290 
    291 void WebURLResponse::setAppCacheID(long long appCacheID)
    292 {
    293     m_private->m_resourceResponse->setAppCacheID(appCacheID);
    294 }
    295 
    296 WebURL WebURLResponse::appCacheManifestURL() const
    297 {
    298     return m_private->m_resourceResponse->appCacheManifestURL();
    299 }
    300 
    301 void WebURLResponse::setAppCacheManifestURL(const WebURL& url)
    302 {
    303     m_private->m_resourceResponse->setAppCacheManifestURL(url);
    304 }
    305 
    306 WebCString WebURLResponse::securityInfo() const
    307 {
    308     // FIXME: getSecurityInfo is misnamed.
    309     return m_private->m_resourceResponse->getSecurityInfo();
    310 }
    311 
    312 void WebURLResponse::setSecurityInfo(const WebCString& securityInfo)
    313 {
    314     m_private->m_resourceResponse->setSecurityInfo(securityInfo);
    315 }
    316 
    317 ResourceResponse& WebURLResponse::toMutableResourceResponse()
    318 {
    319     ASSERT(m_private);
    320     ASSERT(m_private->m_resourceResponse);
    321 
    322     return *m_private->m_resourceResponse;
    323 }
    324 
    325 const ResourceResponse& WebURLResponse::toResourceResponse() const
    326 {
    327     ASSERT(m_private);
    328     ASSERT(m_private->m_resourceResponse);
    329 
    330     return *m_private->m_resourceResponse;
    331 }
    332 
    333 bool WebURLResponse::wasCached() const
    334 {
    335     return m_private->m_resourceResponse->wasCached();
    336 }
    337 
    338 void WebURLResponse::setWasCached(bool value)
    339 {
    340     m_private->m_resourceResponse->setWasCached(value);
    341 }
    342 
    343 bool WebURLResponse::wasFetchedViaSPDY() const
    344 {
    345     return m_private->m_resourceResponse->wasFetchedViaSPDY();
    346 }
    347 
    348 void WebURLResponse::setWasFetchedViaSPDY(bool value)
    349 {
    350     m_private->m_resourceResponse->setWasFetchedViaSPDY(value);
    351 }
    352 
    353 bool WebURLResponse::wasNpnNegotiated() const
    354 {
    355     return m_private->m_resourceResponse->wasNpnNegotiated();
    356 }
    357 
    358 void WebURLResponse::setWasNpnNegotiated(bool value)
    359 {
    360     m_private->m_resourceResponse->setWasNpnNegotiated(value);
    361 }
    362 
    363 bool WebURLResponse::wasAlternateProtocolAvailable() const
    364 {
    365     return m_private->m_resourceResponse->wasAlternateProtocolAvailable();
    366 }
    367 
    368 void WebURLResponse::setWasAlternateProtocolAvailable(bool value)
    369 {
    370     m_private->m_resourceResponse->setWasAlternateProtocolAvailable(value);
    371 }
    372 
    373 bool WebURLResponse::wasFetchedViaProxy() const
    374 {
    375     return m_private->m_resourceResponse->wasFetchedViaProxy();
    376 }
    377 
    378 void WebURLResponse::setWasFetchedViaProxy(bool value)
    379 {
    380     m_private->m_resourceResponse->setWasFetchedViaProxy(value);
    381 }
    382 
    383 bool WebURLResponse::isMultipartPayload() const
    384 {
    385     return m_private->m_resourceResponse->isMultipartPayload();
    386 }
    387 
    388 void WebURLResponse::setIsMultipartPayload(bool value)
    389 {
    390     m_private->m_resourceResponse->setIsMultipartPayload(value);
    391 }
    392 
    393 WebString WebURLResponse::downloadFilePath() const
    394 {
    395     const File* downloadedFile = m_private->m_resourceResponse->downloadedFile();
    396     if (downloadedFile)
    397         return downloadedFile->path();
    398     return WebString();
    399 }
    400 
    401 void WebURLResponse::setDownloadFilePath(const WebString& downloadFilePath)
    402 {
    403     m_private->m_resourceResponse->setDownloadedFile(downloadFilePath.isEmpty() ? 0 : File::create(downloadFilePath));
    404 }
    405 
    406 WebString WebURLResponse::remoteIPAddress() const
    407 {
    408     return m_private->m_resourceResponse->remoteIPAddress();
    409 }
    410 
    411 void WebURLResponse::setRemoteIPAddress(const WebString& remoteIPAddress)
    412 {
    413     m_private->m_resourceResponse->setRemoteIPAddress(remoteIPAddress);
    414 }
    415 
    416 unsigned short WebURLResponse::remotePort() const
    417 {
    418     return m_private->m_resourceResponse->remotePort();
    419 }
    420 
    421 void WebURLResponse::setRemotePort(unsigned short remotePort)
    422 {
    423     m_private->m_resourceResponse->setRemotePort(remotePort);
    424 }
    425 
    426 WebURLResponse::ExtraData* WebURLResponse::extraData() const
    427 {
    428     RefPtr<ResourceResponse::ExtraData> data = m_private->m_resourceResponse->extraData();
    429     if (!data)
    430         return 0;
    431     return static_cast<ExtraDataContainer*>(data.get())->extraData();
    432 }
    433 
    434 void WebURLResponse::setExtraData(WebURLResponse::ExtraData* extraData)
    435 {
    436     m_private->m_resourceResponse->setExtraData(ExtraDataContainer::create(extraData));
    437 }
    438 
    439 void WebURLResponse::assign(WebURLResponsePrivate* p)
    440 {
    441     // Subclasses may call this directly so a self-assignment check is needed
    442     // here as well as in the public assign method.
    443     if (m_private == p)
    444         return;
    445     if (m_private)
    446         m_private->dispose();
    447     m_private = p;
    448 }
    449 
    450 } // namespace WebKit
    451