src/third_party/WebKit/Source/platform/network/ResourceRequest.cpp

   1 /*
   2  * Copyright (C) 2003, 2006 Apple Computer, Inc.  All rights reserved.
   3  * Copyright (C) 2009, 2012 Google Inc. All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  17  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  18  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  19  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  20  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  21  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  22  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  24  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  */
  26
  27 #include "config.h"
  28 #include "platform/network/ResourceRequest.h"
  29
  30 namespace WebCore {
  31
  32 double ResourceRequest::s_defaultTimeoutInterval = INT_MAX;
  33
  34 PassOwnPtr<ResourceRequest> ResourceRequest::adopt(PassOwnPtr<CrossThreadResourceRequestData> data)
  35 {
  36     OwnPtr<ResourceRequest> request = adoptPtr(new ResourceRequest());
  37     request->setURL(data->m_url);
  38     request->setCachePolicy(data->m_cachePolicy);
  39     request->setTimeoutInterval(data->m_timeoutInterval);
  40     request->setFirstPartyForCookies(data->m_firstPartyForCookies);
  41     request->setHTTPMethod(AtomicString(data->m_httpMethod));
  42     request->setPriority(data->m_priority);
  43
  44     request->m_httpHeaderFields.adopt(data->m_httpHeaders.release());
  45
  46     request->setHTTPBody(data->m_httpBody);
  47     request->setAllowCookies(data->m_allowCookies);
  48     request->setReportUploadProgress(data->m_reportUploadProgress);
  49     request->setHasUserGesture(data->m_hasUserGesture);
  50     request->setDownloadToFile(data->m_downloadToFile);
  51     request->setRequestorID(data->m_requestorID);
  52     request->setRequestorProcessID(data->m_requestorProcessID);
  53     request->setAppCacheHostID(data->m_appCacheHostID);
  54     request->setTargetType(data->m_targetType);
  55     request->m_referrerPolicy = data->m_referrerPolicy;
  56     return request.release();
  57 }
  58
  59 PassOwnPtr<CrossThreadResourceRequestData> ResourceRequest::copyData() const
  60 {
  61     OwnPtr<CrossThreadResourceRequestData> data = adoptPtr(new CrossThreadResourceRequestData());
  62     data->m_url = url().copy();
  63     data->m_cachePolicy = cachePolicy();
  64     data->m_timeoutInterval = timeoutInterval();
  65     data->m_firstPartyForCookies = firstPartyForCookies().copy();
  66     data->m_httpMethod = httpMethod().string().isolatedCopy();
  67     data->m_httpHeaders = httpHeaderFields().copyData();
  68     data->m_priority = priority();
  69
  70     if (m_httpBody)
  71         data->m_httpBody = m_httpBody->deepCopy();
  72     data->m_allowCookies = m_allowCookies;
  73     data->m_reportUploadProgress = m_reportUploadProgress;
  74     data->m_hasUserGesture = m_hasUserGesture;
  75     data->m_downloadToFile = m_downloadToFile;
  76     data->m_requestorID = m_requestorID;
  77     data->m_requestorProcessID = m_requestorProcessID;
  78     data->m_appCacheHostID = m_appCacheHostID;
  79     data->m_targetType = m_targetType;
  80     data->m_referrerPolicy = m_referrerPolicy;
  81     return data.release();
  82 }
  83
  84 bool ResourceRequest::isEmpty() const
  85 {
  86     return m_url.isEmpty();
  87 }
  88
  89 bool ResourceRequest::isNull() const
  90 {
  91     return m_url.isNull();
  92 }
  93
  94 const KURL& ResourceRequest::url() const
  95 {
  96     return m_url;
  97 }
  98
  99 void ResourceRequest::setURL(const KURL& url)
 100 {
 101     m_url = url;
 102 }
 103
 104 void ResourceRequest::removeCredentials()
 105 {
 106     if (m_url.user().isEmpty() && m_url.pass().isEmpty())
 107         return;
 108
 109     m_url.setUser(String());
 110     m_url.setPass(String());
 111 }
 112
 113 ResourceRequestCachePolicy ResourceRequest::cachePolicy() const
 114 {
 115     return m_cachePolicy;
 116 }
 117
 118 void ResourceRequest::setCachePolicy(ResourceRequestCachePolicy cachePolicy)
 119 {
 120     m_cachePolicy = cachePolicy;
 121 }
 122
 123 double ResourceRequest::timeoutInterval() const
 124 {
 125     return m_timeoutInterval;
 126 }
 127
 128 void ResourceRequest::setTimeoutInterval(double timeoutInterval)
 129 {
 130     m_timeoutInterval = timeoutInterval;
 131 }
 132
 133 const KURL& ResourceRequest::firstPartyForCookies() const
 134 {
 135     return m_firstPartyForCookies;
 136 }
 137
 138 void ResourceRequest::setFirstPartyForCookies(const KURL& firstPartyForCookies)
 139 {
 140     m_firstPartyForCookies = firstPartyForCookies;
 141 }
 142
 143 const AtomicString& ResourceRequest::httpMethod() const
 144 {
 145     return m_httpMethod;
 146 }
 147
 148 void ResourceRequest::setHTTPMethod(const AtomicString& httpMethod)
 149 {
 150     m_httpMethod = httpMethod;
 151 }
 152
 153 const HTTPHeaderMap& ResourceRequest::httpHeaderFields() const
 154 {
 155     return m_httpHeaderFields;
 156 }
 157
 158 const AtomicString& ResourceRequest::httpHeaderField(const AtomicString& name) const
 159 {
 160     return m_httpHeaderFields.get(name);
 161 }
 162
 163 const AtomicString& ResourceRequest::httpHeaderField(const char* name) const
 164 {
 165     return m_httpHeaderFields.get(name);
 166 }
 167
 168 void ResourceRequest::setHTTPHeaderField(const AtomicString& name, const AtomicString& value)
 169 {
 170     m_httpHeaderFields.set(name, value);
 171 }
 172
 173 void ResourceRequest::setHTTPHeaderField(const char* name, const AtomicString& value)
 174 {
 175     setHTTPHeaderField(AtomicString(name), value);
 176 }
 177
 178 void ResourceRequest::clearHTTPAuthorization()
 179 {
 180     m_httpHeaderFields.remove("Authorization");
 181 }
 182
 183 void ResourceRequest::clearHTTPContentType()
 184 {
 185     m_httpHeaderFields.remove("Content-Type");
 186 }
 187
 188 void ResourceRequest::clearHTTPReferrer()
 189 {
 190     m_httpHeaderFields.remove("Referer");
 191     m_referrerPolicy = ReferrerPolicyDefault;
 192 }
 193
 194 void ResourceRequest::clearHTTPOrigin()
 195 {
 196     m_httpHeaderFields.remove("Origin");
 197 }
 198
 199 void ResourceRequest::clearHTTPUserAgent()
 200 {
 201     m_httpHeaderFields.remove("User-Agent");
 202 }
 203
 204 void ResourceRequest::clearHTTPAccept()
 205 {
 206     m_httpHeaderFields.remove("Accept");
 207 }
 208
 209 FormData* ResourceRequest::httpBody() const
 210 {
 211     return m_httpBody.get();
 212 }
 213
 214 void ResourceRequest::setHTTPBody(PassRefPtr<FormData> httpBody)
 215 {
 216     m_httpBody = httpBody;
 217 }
 218
 219 bool ResourceRequest::allowCookies() const
 220 {
 221     return m_allowCookies;
 222 }
 223
 224 void ResourceRequest::setAllowCookies(bool allowCookies)
 225 {
 226     m_allowCookies = allowCookies;
 227 }
 228
 229 ResourceLoadPriority ResourceRequest::priority() const
 230 {
 231     return m_priority;
 232 }
 233
 234 void ResourceRequest::setPriority(ResourceLoadPriority priority)
 235 {
 236     m_priority = priority;
 237 }
 238
 239 void ResourceRequest::addHTTPHeaderField(const AtomicString& name, const AtomicString& value)
 240 {
 241     HTTPHeaderMap::AddResult result = m_httpHeaderFields.add(name, value);
 242     if (!result.isNewEntry)
 243         result.storedValue->value = result.storedValue->value + ',' + value;
 244 }
 245
 246 void ResourceRequest::addHTTPHeaderFields(const HTTPHeaderMap& headerFields)
 247 {
 248     HTTPHeaderMap::const_iterator end = headerFields.end();
 249     for (HTTPHeaderMap::const_iterator it = headerFields.begin(); it != end; ++it)
 250         addHTTPHeaderField(it->key, it->value);
 251 }
 252
 253 void ResourceRequest::clearHTTPHeaderField(const AtomicString& name)
 254 {
 255     m_httpHeaderFields.remove(name);
 256 }
 257
 258 bool equalIgnoringHeaderFields(const ResourceRequest& a, const ResourceRequest& b)
 259 {
 260     if (a.url() != b.url())
 261         return false;
 262
 263     if (a.cachePolicy() != b.cachePolicy())
 264         return false;
 265
 266     if (a.timeoutInterval() != b.timeoutInterval())
 267         return false;
 268
 269     if (a.firstPartyForCookies() != b.firstPartyForCookies())
 270         return false;
 271
 272     if (a.httpMethod() != b.httpMethod())
 273         return false;
 274
 275     if (a.allowCookies() != b.allowCookies())
 276         return false;
 277
 278     if (a.priority() != b.priority())
 279         return false;
 280
 281     if (a.referrerPolicy() != b.referrerPolicy())
 282         return false;
 283
 284     FormData* formDataA = a.httpBody();
 285     FormData* formDataB = b.httpBody();
 286
 287     if (!formDataA)
 288         return !formDataB;
 289     if (!formDataB)
 290         return !formDataA;
 291
 292     if (*formDataA != *formDataB)
 293         return false;
 294
 295     return true;
 296 }
 297
 298 bool ResourceRequest::compare(const ResourceRequest& a, const ResourceRequest& b)
 299 {
 300     if (!equalIgnoringHeaderFields(a, b))
 301         return false;
 302
 303     if (a.httpHeaderFields() != b.httpHeaderFields())
 304         return false;
 305
 306     return true;
 307 }
 308
 309 bool ResourceRequest::isConditional() const
 310 {
 311     return (m_httpHeaderFields.contains("If-Match")
 312         || m_httpHeaderFields.contains("If-Modified-Since")
 313         || m_httpHeaderFields.contains("If-None-Match")
 314         || m_httpHeaderFields.contains("If-Range")
 315         || m_httpHeaderFields.contains("If-Unmodified-Since")
 316         || m_httpHeaderFields.contains("Cache-Control"));
 317 }
 318
 319 double ResourceRequest::defaultTimeoutInterval()
 320 {
 321     return s_defaultTimeoutInterval;
 322 }
 323
 324 void ResourceRequest::setDefaultTimeoutInterval(double timeoutInterval)
 325 {
 326     s_defaultTimeoutInterval = timeoutInterval;
 327 }
 328
 329 void ResourceRequest::initialize(const KURL& url, ResourceRequestCachePolicy cachePolicy)
 330 {
 331     m_url = url;
 332     m_cachePolicy = cachePolicy;
 333     m_timeoutInterval = s_defaultTimeoutInterval;
 334     m_httpMethod = "GET";
 335     m_allowCookies = true;
 336     m_reportUploadProgress = false;
 337     m_reportLoadTiming = false;
 338     m_reportRawHeaders = false;
 339     m_hasUserGesture = false;
 340     m_downloadToFile = false;
 341     m_priority = ResourceLoadPriorityLow;
 342     m_requestorID = 0;
 343     m_requestorProcessID = 0;
 344     m_appCacheHostID = 0;
 345     m_targetType = TargetIsUnspecified;
 346     m_referrerPolicy = ReferrerPolicyDefault;
 347 }
 348
 349 // This is used by the loader to control the number of issued parallel load requests.
 350 unsigned initializeMaximumHTTPConnectionCountPerHost()
 351 {
 352     // The chromium network stack already handles limiting the number of
 353     // parallel requests per host, so there's no need to do it here.  Therefore,
 354     // this is set to a high value that should never be hit in practice.
 355     return 10000;
 356 }
 357
 358 }