third_party/WebKit/Source/platform/exported/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 "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/WebSecurityOrigin.h"
  39 #include "public/platform/WebURL.h"
  40
  41 namespace blink {
  42
  43 namespace {
  44
  45 class ExtraDataContainer : public ResourceRequest::ExtraData {
  46 public:
  47     static PassRefPtr<ExtraDataContainer> create(WebURLRequest::ExtraData* extraData) { return adoptRef(new ExtraDataContainer(extraData)); }
  48
  49     ~ExtraDataContainer() override {}
  50
  51     WebURLRequest::ExtraData* extraData() const { return m_extraData.get(); }
  52
  53 private:
  54     explicit ExtraDataContainer(WebURLRequest::ExtraData* extraData)
  55         : m_extraData(adoptPtr(extraData))
  56     {
  57     }
  58
  59     OwnPtr<WebURLRequest::ExtraData> m_extraData;
  60 };
  61
  62 } // namespace
  63
  64 // The standard implementation of WebURLRequestPrivate, which maintains
  65 // ownership of a ResourceRequest instance.
  66 class WebURLRequestPrivateImpl : public WebURLRequestPrivate {
  67 public:
  68     WebURLRequestPrivateImpl()
  69     {
  70         m_resourceRequest = &m_resourceRequestAllocation;
  71     }
  72
  73     WebURLRequestPrivateImpl(const WebURLRequestPrivate* p)
  74         : m_resourceRequestAllocation(*p->m_resourceRequest)
  75     {
  76         m_resourceRequest = &m_resourceRequestAllocation;
  77     }
  78
  79     virtual void dispose() { delete this; }
  80
  81 private:
  82     virtual ~WebURLRequestPrivateImpl() { }
  83
  84     ResourceRequest m_resourceRequestAllocation;
  85 };
  86
  87 void WebURLRequest::initialize()
  88 {
  89     assign(new WebURLRequestPrivateImpl());
  90 }
  91
  92 void WebURLRequest::reset()
  93 {
  94     assign(0);
  95 }
  96
  97 void WebURLRequest::assign(const WebURLRequest& r)
  98 {
  99     if (&r != this)
 100         assign(r.m_private ? new WebURLRequestPrivateImpl(r.m_private) : 0);
 101 }
 102
 103 bool WebURLRequest::isNull() const
 104 {
 105     return !m_private || m_private->m_resourceRequest->isNull();
 106 }
 107
 108 WebURL WebURLRequest::url() const
 109 {
 110     return m_private->m_resourceRequest->url();
 111 }
 112
 113 void WebURLRequest::setURL(const WebURL& url)
 114 {
 115     m_private->m_resourceRequest->setURL(url);
 116 }
 117
 118 WebURL WebURLRequest::firstPartyForCookies() const
 119 {
 120     return m_private->m_resourceRequest->firstPartyForCookies();
 121 }
 122
 123 void WebURLRequest::setFirstPartyForCookies(const WebURL& firstPartyForCookies)
 124 {
 125     m_private->m_resourceRequest->setFirstPartyForCookies(firstPartyForCookies);
 126 }
 127
 128 WebSecurityOrigin WebURLRequest::requestorOrigin() const
 129 {
 130     return m_private->m_resourceRequest->requestorOrigin();
 131 }
 132
 133 void WebURLRequest::setRequestorOrigin(const WebSecurityOrigin& requestorOrigin)
 134 {
 135     m_private->m_resourceRequest->setRequestorOrigin(requestorOrigin);
 136 }
 137
 138 bool WebURLRequest::allowStoredCredentials() const
 139 {
 140     return m_private->m_resourceRequest->allowStoredCredentials();
 141 }
 142
 143 void WebURLRequest::setAllowStoredCredentials(bool allowStoredCredentials)
 144 {
 145     m_private->m_resourceRequest->setAllowStoredCredentials(allowStoredCredentials);
 146 }
 147
 148 WebURLRequest::CachePolicy WebURLRequest::cachePolicy() const
 149 {
 150     return static_cast<WebURLRequest::CachePolicy>(
 151         m_private->m_resourceRequest->cachePolicy());
 152 }
 153
 154 void WebURLRequest::setCachePolicy(CachePolicy cachePolicy)
 155 {
 156     m_private->m_resourceRequest->setCachePolicy(
 157         static_cast<ResourceRequestCachePolicy>(cachePolicy));
 158 }
 159
 160 WebString WebURLRequest::httpMethod() const
 161 {
 162     return m_private->m_resourceRequest->httpMethod();
 163 }
 164
 165 void WebURLRequest::setHTTPMethod(const WebString& httpMethod)
 166 {
 167     m_private->m_resourceRequest->setHTTPMethod(httpMethod);
 168 }
 169
 170 WebString WebURLRequest::httpHeaderField(const WebString& name) const
 171 {
 172     return m_private->m_resourceRequest->httpHeaderField(name);
 173 }
 174
 175 void WebURLRequest::setHTTPHeaderField(const WebString& name, const WebString& value)
 176 {
 177     RELEASE_ASSERT(!equalIgnoringCase(name, "referer"));
 178     m_private->m_resourceRequest->setHTTPHeaderField(name, value);
 179 }
 180
 181 void WebURLRequest::setHTTPReferrer(const WebString& referrer, WebReferrerPolicy referrerPolicy)
 182 {
 183     m_private->m_resourceRequest->setHTTPReferrer(Referrer(referrer, static_cast<ReferrerPolicy>(referrerPolicy)));
 184 }
 185
 186 void WebURLRequest::addHTTPHeaderField(const WebString& name, const WebString& value)
 187 {
 188     m_private->m_resourceRequest->addHTTPHeaderField(name, value);
 189 }
 190
 191 void WebURLRequest::clearHTTPHeaderField(const WebString& name)
 192 {
 193     m_private->m_resourceRequest->clearHTTPHeaderField(name);
 194 }
 195
 196 void WebURLRequest::visitHTTPHeaderFields(WebHTTPHeaderVisitor* visitor) const
 197 {
 198     const HTTPHeaderMap& map = m_private->m_resourceRequest->httpHeaderFields();
 199     for (HTTPHeaderMap::const_iterator it = map.begin(); it != map.end(); ++it)
 200         visitor->visitHeader(it->key, it->value);
 201 }
 202
 203 WebHTTPBody WebURLRequest::httpBody() const
 204 {
 205     return WebHTTPBody(m_private->m_resourceRequest->httpBody());
 206 }
 207
 208 void WebURLRequest::setHTTPBody(const WebHTTPBody& httpBody)
 209 {
 210     m_private->m_resourceRequest->setHTTPBody(httpBody);
 211 }
 212
 213 bool WebURLRequest::reportUploadProgress() const
 214 {
 215     return m_private->m_resourceRequest->reportUploadProgress();
 216 }
 217
 218 void WebURLRequest::setReportUploadProgress(bool reportUploadProgress)
 219 {
 220     m_private->m_resourceRequest->setReportUploadProgress(reportUploadProgress);
 221 }
 222
 223 void WebURLRequest::setReportRawHeaders(bool reportRawHeaders)
 224 {
 225     m_private->m_resourceRequest->setReportRawHeaders(reportRawHeaders);
 226 }
 227
 228 bool WebURLRequest::reportRawHeaders() const
 229 {
 230     return m_private->m_resourceRequest->reportRawHeaders();
 231 }
 232
 233 WebURLRequest::RequestContext WebURLRequest::requestContext() const
 234 {
 235     return m_private->m_resourceRequest->requestContext();
 236 }
 237
 238 WebURLRequest::FrameType WebURLRequest::frameType() const
 239 {
 240     return m_private->m_resourceRequest->frameType();
 241 }
 242
 243 WebReferrerPolicy WebURLRequest::referrerPolicy() const
 244 {
 245     return static_cast<WebReferrerPolicy>(m_private->m_resourceRequest->referrerPolicy());
 246 }
 247
 248 void WebURLRequest::addHTTPOriginIfNeeded(const WebString& origin)
 249 {
 250     m_private->m_resourceRequest->addHTTPOriginIfNeeded(origin);
 251 }
 252
 253 bool WebURLRequest::hasUserGesture() const
 254 {
 255     return m_private->m_resourceRequest->hasUserGesture();
 256 }
 257
 258 void WebURLRequest::setHasUserGesture(bool hasUserGesture)
 259 {
 260     m_private->m_resourceRequest->setHasUserGesture(hasUserGesture);
 261 }
 262
 263 void WebURLRequest::setRequestContext(RequestContext requestContext)
 264 {
 265     m_private->m_resourceRequest->setRequestContext(requestContext);
 266 }
 267
 268 void WebURLRequest::setFrameType(FrameType frameType)
 269 {
 270     m_private->m_resourceRequest->setFrameType(frameType);
 271 }
 272
 273 int WebURLRequest::requestorID() const
 274 {
 275     return m_private->m_resourceRequest->requestorID();
 276 }
 277
 278 void WebURLRequest::setRequestorID(int requestorID)
 279 {
 280     m_private->m_resourceRequest->setRequestorID(requestorID);
 281 }
 282
 283 int WebURLRequest::requestorProcessID() const
 284 {
 285     return m_private->m_resourceRequest->requestorProcessID();
 286 }
 287
 288 void WebURLRequest::setRequestorProcessID(int requestorProcessID)
 289 {
 290     m_private->m_resourceRequest->setRequestorProcessID(requestorProcessID);
 291 }
 292
 293 int WebURLRequest::appCacheHostID() const
 294 {
 295     return m_private->m_resourceRequest->appCacheHostID();
 296 }
 297
 298 void WebURLRequest::setAppCacheHostID(int appCacheHostID)
 299 {
 300     m_private->m_resourceRequest->setAppCacheHostID(appCacheHostID);
 301 }
 302
 303 bool WebURLRequest::downloadToFile() const
 304 {
 305     return m_private->m_resourceRequest->downloadToFile();
 306 }
 307
 308 void WebURLRequest::setDownloadToFile(bool downloadToFile)
 309 {
 310     m_private->m_resourceRequest->setDownloadToFile(downloadToFile);
 311 }
 312
 313 bool WebURLRequest::useStreamOnResponse() const
 314 {
 315     return m_private->m_resourceRequest->useStreamOnResponse();
 316 }
 317
 318 void WebURLRequest::setUseStreamOnResponse(bool useStreamOnResponse)
 319 {
 320     m_private->m_resourceRequest->setUseStreamOnResponse(useStreamOnResponse);
 321 }
 322
 323 bool WebURLRequest::skipServiceWorker() const
 324 {
 325     return m_private->m_resourceRequest->skipServiceWorker();
 326 }
 327
 328 void WebURLRequest::setSkipServiceWorker(bool skipServiceWorker)
 329 {
 330     m_private->m_resourceRequest->setSkipServiceWorker(skipServiceWorker);
 331 }
 332
 333 bool WebURLRequest::shouldResetAppCache() const
 334 {
 335     return m_private->m_resourceRequest->shouldResetAppCache();
 336 }
 337
 338 void WebURLRequest::setShouldResetAppCache(bool setShouldResetAppCache)
 339 {
 340     m_private->m_resourceRequest->setShouldResetAppCache(setShouldResetAppCache);
 341 }
 342
 343 WebURLRequest::FetchRequestMode WebURLRequest::fetchRequestMode() const
 344 {
 345     return m_private->m_resourceRequest->fetchRequestMode();
 346 }
 347
 348 void WebURLRequest::setFetchRequestMode(WebURLRequest::FetchRequestMode mode)
 349 {
 350     return m_private->m_resourceRequest->setFetchRequestMode(mode);
 351 }
 352
 353 WebURLRequest::FetchCredentialsMode WebURLRequest::fetchCredentialsMode() const
 354 {
 355     return m_private->m_resourceRequest->fetchCredentialsMode();
 356 }
 357
 358 void WebURLRequest::setFetchCredentialsMode(WebURLRequest::FetchCredentialsMode mode)
 359 {
 360     return m_private->m_resourceRequest->setFetchCredentialsMode(mode);
 361 }
 362
 363 WebURLRequest::FetchRedirectMode WebURLRequest::fetchRedirectMode() const
 364 {
 365     return m_private->m_resourceRequest->fetchRedirectMode();
 366 }
 367
 368 void WebURLRequest::setFetchRedirectMode(WebURLRequest::FetchRedirectMode redirect)
 369 {
 370     return m_private->m_resourceRequest->setFetchRedirectMode(redirect);
 371 }
 372
 373 WebURLRequest::ExtraData* WebURLRequest::extraData() const
 374 {
 375     RefPtr<ResourceRequest::ExtraData> data = m_private->m_resourceRequest->extraData();
 376     if (!data)
 377         return 0;
 378     return static_cast<ExtraDataContainer*>(data.get())->extraData();
 379 }
 380
 381 void WebURLRequest::setExtraData(WebURLRequest::ExtraData* extraData)
 382 {
 383     m_private->m_resourceRequest->setExtraData(ExtraDataContainer::create(extraData));
 384 }
 385
 386 ResourceRequest& WebURLRequest::toMutableResourceRequest()
 387 {
 388     ASSERT(m_private);
 389     ASSERT(m_private->m_resourceRequest);
 390
 391     return *m_private->m_resourceRequest;
 392 }
 393
 394 WebURLRequest::Priority WebURLRequest::priority() const
 395 {
 396     return static_cast<WebURLRequest::Priority>(
 397         m_private->m_resourceRequest->priority());
 398 }
 399
 400 void WebURLRequest::setPriority(WebURLRequest::Priority priority)
 401 {
 402     m_private->m_resourceRequest->setPriority(
 403         static_cast<ResourceLoadPriority>(priority));
 404 }
 405
 406 bool WebURLRequest::checkForBrowserSideNavigation() const
 407 {
 408     return m_private->m_resourceRequest->checkForBrowserSideNavigation();
 409 }
 410
 411 void WebURLRequest::setCheckForBrowserSideNavigation(bool check)
 412 {
 413     m_private->m_resourceRequest->setCheckForBrowserSideNavigation(check);
 414 }
 415
 416 double WebURLRequest::uiStartTime() const
 417 {
 418     return m_private->m_resourceRequest->uiStartTime();
 419 }
 420
 421 void WebURLRequest::setUiStartTime(double time)
 422 {
 423     m_private->m_resourceRequest->setUIStartTime(time);
 424 }
 425
 426 bool WebURLRequest::originatesFromReservedIPRange() const
 427 {
 428     return m_private->m_resourceRequest->originatesFromReservedIPRange();
 429 }
 430
 431 void WebURLRequest::setOriginatesFromReservedIPRange(bool value)
 432 {
 433     m_private->m_resourceRequest->setOriginatesFromReservedIPRange(value);
 434 }
 435
 436 WebURLRequest::InputToLoadPerfMetricReportPolicy WebURLRequest::inputPerfMetricReportPolicy() const
 437 {
 438     return static_cast<WebURLRequest::InputToLoadPerfMetricReportPolicy>(
 439         m_private->m_resourceRequest->inputPerfMetricReportPolicy());
 440 }
 441
 442 void WebURLRequest::setInputPerfMetricReportPolicy(
 443     WebURLRequest::InputToLoadPerfMetricReportPolicy policy)
 444 {
 445     m_private->m_resourceRequest->setInputPerfMetricReportPolicy(
 446         static_cast<blink::InputToLoadPerfMetricReportPolicy>(policy));
 447 }
 448
 449 const ResourceRequest& WebURLRequest::toResourceRequest() const
 450 {
 451     ASSERT(m_private);
 452     ASSERT(m_private->m_resourceRequest);
 453
 454     return *m_private->m_resourceRequest;
 455 }
 456
 457 void WebURLRequest::assign(WebURLRequestPrivate* p)
 458 {
 459     // Subclasses may call this directly so a self-assignment check is needed
 460     // here as well as in the public assign method.
 461     if (m_private == p)
 462         return;
 463     if (m_private)
 464         m_private->dispose();
 465     m_private = p;
 466 }
 467
 468 } // namespace blink