review.tizen.org Git - platform/framework/web/crosswalk-tizen.git/blob

   1 /*
   2  * Copyright (C) 2003, 2006 Apple Computer, Inc.  All rights reserved.
   3  * Copyright (C) 2006 Samuel Weinig <sam.weinig@gmail.com>
   4  * Copyright (C) 2009, 2012 Google Inc. All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  16  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  18  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  19  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  20  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  21  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  22  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  23  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  25  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26  */
  27
  28 #ifndef ResourceRequest_h
  29 #define ResourceRequest_h
  30
  31 #include "platform/HTTPNames.h"
  32 #include "platform/network/EncodedFormData.h"
  33 #include "platform/network/HTTPHeaderMap.h"
  34 #include "platform/network/HTTPParsers.h"
  35 #include "platform/network/ResourceLoadPriority.h"
  36 #include "platform/weborigin/KURL.h"
  37 #include "platform/weborigin/Referrer.h"
  38 #include "platform/weborigin/SecurityOrigin.h"
  39 #include "public/platform/WebAddressSpace.h"
  40 #include "public/platform/WebURLRequest.h"
  41 #include "wtf/RefCounted.h"
  42 #include <memory>
  43
  44 namespace blink {
  45
  46 enum class WebCachePolicy;
  47
  48 enum ResourceRequestBlockedReason {
  49   ResourceRequestBlockedReasonCSP,
  50   ResourceRequestBlockedReasonMixedContent,
  51   ResourceRequestBlockedReasonOrigin,
  52   ResourceRequestBlockedReasonInspector,
  53   ResourceRequestBlockedReasonSubresourceFilter,
  54   ResourceRequestBlockedReasonOther,
  55   ResourceRequestBlockedReasonNone
  56 };
  57
  58 enum InputToLoadPerfMetricReportPolicy {
  59   NoReport,    // Don't report metrics for this ResourceRequest.
  60   ReportLink,  // Report metrics for this request as initiated by a link click.
  61   ReportIntent,  // Report metrics for this request as initiated by an intent.
  62 };
  63
  64 struct CrossThreadResourceRequestData;
  65
  66 class PLATFORM_EXPORT ResourceRequest final {
  67   DISALLOW_NEW();
  68
  69  public:
  70   enum class RedirectStatus { FollowedRedirect, NoRedirect };
  71
  72   class ExtraData : public RefCounted<ExtraData> {
  73    public:
  74     virtual ~ExtraData() {}
  75   };
  76
  77   ResourceRequest();
  78   ResourceRequest(const String& urlString);
  79   ResourceRequest(const KURL&);
  80   explicit ResourceRequest(CrossThreadResourceRequestData*);
  81   ResourceRequest(const ResourceRequest&);
  82   ResourceRequest& operator=(const ResourceRequest&);
  83
  84   // Gets a copy of the data suitable for passing to another thread.
  85   std::unique_ptr<CrossThreadResourceRequestData> copyData() const;
  86
  87   bool isNull() const;
  88   bool isEmpty() const;
  89
  90   const KURL& url() const;
  91   void setURL(const KURL& url);
  92
  93 #if defined(USE_EFL)
  94   const KURL& unencryptedURL() const;
  95   void setUnencryptedURL(const KURL&);
  96
  97 #if defined(OS_TIZEN_TV_PRODUCT)
  98   bool isDecryptedFile() const;
  99   void setDecryptedFileFlag(const bool);
 100 #endif  // defined(OS_TIZEN_TV_PRODUCT)
 101 #endif  // defined(USE_EFL)
 102
 103   void removeCredentials();
 104
 105   WebCachePolicy getCachePolicy() const;
 106   void setCachePolicy(WebCachePolicy);
 107
 108   double timeoutInterval() const;  // May return 0 when using platform default.
 109   void setTimeoutInterval(double);
 110
 111   const KURL& firstPartyForCookies() const;
 112   void setFirstPartyForCookies(const KURL& firstPartyForCookies);
 113
 114   PassRefPtr<SecurityOrigin> requestorOrigin() const;
 115   void setRequestorOrigin(PassRefPtr<SecurityOrigin>);
 116
 117   const AtomicString& httpMethod() const;
 118   void setHTTPMethod(const AtomicString&);
 119
 120   const HTTPHeaderMap& httpHeaderFields() const;
 121   const AtomicString& httpHeaderField(const AtomicString& name) const;
 122   void setHTTPHeaderField(const AtomicString& name, const AtomicString& value);
 123   void addHTTPHeaderField(const AtomicString& name, const AtomicString& value);
 124   void addHTTPHeaderFields(const HTTPHeaderMap& headerFields);
 125   void clearHTTPHeaderField(const AtomicString& name);
 126
 127   const AtomicString& httpContentType() const {
 128     return httpHeaderField(HTTPNames::Content_Type);
 129   }
 130   void setHTTPContentType(const AtomicString& httpContentType) {
 131     setHTTPHeaderField(HTTPNames::Content_Type, httpContentType);
 132   }
 133
 134   bool didSetHTTPReferrer() const { return m_didSetHTTPReferrer; }
 135   const AtomicString& httpReferrer() const {
 136     return httpHeaderField(HTTPNames::Referer);
 137   }
 138   ReferrerPolicy getReferrerPolicy() const { return m_referrerPolicy; }
 139   void setHTTPReferrer(const Referrer&);
 140   void clearHTTPReferrer();
 141
 142   const AtomicString& httpOrigin() const {
 143     return httpHeaderField(HTTPNames::Origin);
 144   }
 145   const AtomicString& httpSuborigin() const {
 146     return httpHeaderField(HTTPNames::Suborigin);
 147   }
 148   // Note that these will also set and clear, respectively, the
 149   // Suborigin header, if appropriate.
 150   void setHTTPOrigin(const SecurityOrigin*);
 151   void clearHTTPOrigin();
 152
 153   void addHTTPOriginIfNeeded(const SecurityOrigin*);
 154   void addHTTPOriginIfNeeded(const String&);
 155
 156   const AtomicString& httpUserAgent() const {
 157     return httpHeaderField(HTTPNames::User_Agent);
 158   }
 159   void setHTTPUserAgent(const AtomicString& httpUserAgent) {
 160     setHTTPHeaderField(HTTPNames::User_Agent, httpUserAgent);
 161   }
 162   void clearHTTPUserAgent();
 163
 164   void setHTTPAccept(const AtomicString& httpAccept) {
 165     setHTTPHeaderField(HTTPNames::Accept, httpAccept);
 166   }
 167
 168   EncodedFormData* httpBody() const;
 169   void setHTTPBody(PassRefPtr<EncodedFormData>);
 170
 171   EncodedFormData* attachedCredential() const;
 172   void setAttachedCredential(PassRefPtr<EncodedFormData>);
 173
 174   bool allowStoredCredentials() const;
 175   void setAllowStoredCredentials(bool allowCredentials);
 176
 177   ResourceLoadPriority priority() const;
 178   void setPriority(ResourceLoadPriority, int intraPriorityValue = 0);
 179
 180   bool isConditional() const;
 181
 182   // Whether the associated ResourceHandleClient needs to be notified of
 183   // upload progress made for that resource.
 184   bool reportUploadProgress() const { return m_reportUploadProgress; }
 185   void setReportUploadProgress(bool reportUploadProgress) {
 186     m_reportUploadProgress = reportUploadProgress;
 187   }
 188
 189   // Whether actual headers being sent/received should be collected and reported
 190   // for the request.
 191   bool reportRawHeaders() const { return m_reportRawHeaders; }
 192   void setReportRawHeaders(bool reportRawHeaders) {
 193     m_reportRawHeaders = reportRawHeaders;
 194   }
 195
 196   // Allows the request to be matched up with its requestor.
 197   int requestorID() const { return m_requestorID; }
 198   void setRequestorID(int requestorID) { m_requestorID = requestorID; }
 199
 200   // The process id of the process from which this request originated. In
 201   // the case of out-of-process plugins, this allows to link back the
 202   // request to the plugin process (as it is processed through a render
 203   // view process).
 204   int requestorProcessID() const { return m_requestorProcessID; }
 205   void setRequestorProcessID(int requestorProcessID) {
 206     m_requestorProcessID = requestorProcessID;
 207   }
 208
 209   // Allows the request to be matched up with its app cache host.
 210   int appCacheHostID() const { return m_appCacheHostID; }
 211   void setAppCacheHostID(int id) { m_appCacheHostID = id; }
 212
 213   // True if request was user initiated.
 214   bool hasUserGesture() const { return m_hasUserGesture; }
 215   void setHasUserGesture(bool);
 216
 217   // True if request should be downloaded to file.
 218   bool downloadToFile() const { return m_downloadToFile; }
 219   void setDownloadToFile(bool downloadToFile) {
 220     m_downloadToFile = downloadToFile;
 221   }
 222
 223   // True if the requestor wants to receive a response body as
 224   // WebDataConsumerHandle.
 225   bool useStreamOnResponse() const { return m_useStreamOnResponse; }
 226   void setUseStreamOnResponse(bool useStreamOnResponse) {
 227     m_useStreamOnResponse = useStreamOnResponse;
 228   }
 229
 230   // Indicates which types of ServiceWorkers should skip handling this request.
 231   WebURLRequest::SkipServiceWorker skipServiceWorker() const {
 232     return m_skipServiceWorker;
 233   }
 234   void setSkipServiceWorker(
 235       WebURLRequest::SkipServiceWorker skipServiceWorker) {
 236     m_skipServiceWorker = skipServiceWorker;
 237   }
 238
 239   // True if corresponding AppCache group should be resetted.
 240   bool shouldResetAppCache() { return m_shouldResetAppCache; }
 241   void setShouldResetAppCache(bool shouldResetAppCache) {
 242     m_shouldResetAppCache = shouldResetAppCache;
 243   }
 244
 245   // Extra data associated with this request.
 246   ExtraData* getExtraData() const { return m_extraData.get(); }
 247   void setExtraData(PassRefPtr<ExtraData> extraData) {
 248     m_extraData = extraData;
 249   }
 250
 251   WebURLRequest::RequestContext requestContext() const {
 252     return m_requestContext;
 253   }
 254   void setRequestContext(WebURLRequest::RequestContext context) {
 255     m_requestContext = context;
 256   }
 257
 258   WebURLRequest::FrameType frameType() const { return m_frameType; }
 259   void setFrameType(WebURLRequest::FrameType frameType) {
 260     m_frameType = frameType;
 261   }
 262
 263   WebURLRequest::FetchRequestMode fetchRequestMode() const {
 264     return m_fetchRequestMode;
 265   }
 266   void setFetchRequestMode(WebURLRequest::FetchRequestMode mode) {
 267     m_fetchRequestMode = mode;
 268   }
 269
 270   WebURLRequest::FetchCredentialsMode fetchCredentialsMode() const {
 271     return m_fetchCredentialsMode;
 272   }
 273   void setFetchCredentialsMode(WebURLRequest::FetchCredentialsMode mode) {
 274     m_fetchCredentialsMode = mode;
 275   }
 276
 277   WebURLRequest::FetchRedirectMode fetchRedirectMode() const {
 278     return m_fetchRedirectMode;
 279   }
 280   void setFetchRedirectMode(WebURLRequest::FetchRedirectMode redirect) {
 281     m_fetchRedirectMode = redirect;
 282   }
 283
 284   WebURLRequest::LoFiState loFiState() const { return m_loFiState; }
 285   void setLoFiState(WebURLRequest::LoFiState loFiState) {
 286     m_loFiState = loFiState;
 287   }
 288
 289   bool cacheControlContainsNoCache() const;
 290   bool cacheControlContainsNoStore() const;
 291   bool hasCacheValidatorFields() const;
 292
 293   bool checkForBrowserSideNavigation() const {
 294     return m_checkForBrowserSideNavigation;
 295   }
 296   void setCheckForBrowserSideNavigation(bool check) {
 297     m_checkForBrowserSideNavigation = check;
 298   }
 299
 300   double uiStartTime() const { return m_uiStartTime; }
 301   void setUIStartTime(double uiStartTimeSeconds) {
 302     m_uiStartTime = uiStartTimeSeconds;
 303   }
 304
 305   // https://mikewest.github.io/cors-rfc1918/#external-request
 306   bool isExternalRequest() const { return m_isExternalRequest; }
 307   void setExternalRequestStateFromRequestorAddressSpace(WebAddressSpace);
 308
 309   InputToLoadPerfMetricReportPolicy inputPerfMetricReportPolicy() const {
 310     return m_inputPerfMetricReportPolicy;
 311   }
 312   void setInputPerfMetricReportPolicy(
 313       InputToLoadPerfMetricReportPolicy inputPerfMetricReportPolicy) {
 314     m_inputPerfMetricReportPolicy = inputPerfMetricReportPolicy;
 315   }
 316
 317   void setRedirectStatus(RedirectStatus status) { m_redirectStatus = status; }
 318   RedirectStatus redirectStatus() const { return m_redirectStatus; }
 319
 320   void setNavigationStartTime(double);
 321   double navigationStartTime() const { return m_navigationStart; }
 322
 323  private:
 324   void initialize(const KURL&);
 325
 326   const CacheControlHeader& cacheControlHeader() const;
 327
 328   bool needsHTTPOrigin() const;
 329
 330   KURL m_url;
 331 #if defined(USE_EFL)
 332   KURL m_unencryptedUrl;
 333 #if defined(OS_TIZEN_TV_PRODUCT)
 334   bool m_isDecryptedFile;
 335 #endif  // defined(OS_TIZEN_TV_PRODUCT)
 336 #endif  // defined(USE_EFL)
 337   WebCachePolicy m_cachePolicy;
 338   double m_timeoutInterval;  // 0 is a magic value for platform default on
 339                              // platforms that have one.
 340   KURL m_firstPartyForCookies;
 341   RefPtr<SecurityOrigin> m_requestorOrigin;
 342   AtomicString m_httpMethod;
 343   HTTPHeaderMap m_httpHeaderFields;
 344   RefPtr<EncodedFormData> m_httpBody;
 345   RefPtr<EncodedFormData> m_attachedCredential;
 346   bool m_allowStoredCredentials : 1;
 347   bool m_reportUploadProgress : 1;
 348   bool m_reportRawHeaders : 1;
 349   bool m_hasUserGesture : 1;
 350   bool m_downloadToFile : 1;
 351   bool m_useStreamOnResponse : 1;
 352   bool m_shouldResetAppCache : 1;
 353   WebURLRequest::SkipServiceWorker m_skipServiceWorker;
 354   ResourceLoadPriority m_priority;
 355   int m_intraPriorityValue;
 356   int m_requestorID;
 357   int m_requestorProcessID;
 358   int m_appCacheHostID;
 359   RefPtr<ExtraData> m_extraData;
 360   WebURLRequest::RequestContext m_requestContext;
 361   WebURLRequest::FrameType m_frameType;
 362   WebURLRequest::FetchRequestMode m_fetchRequestMode;
 363   WebURLRequest::FetchCredentialsMode m_fetchCredentialsMode;
 364   WebURLRequest::FetchRedirectMode m_fetchRedirectMode;
 365   WebURLRequest::LoFiState m_loFiState;
 366   ReferrerPolicy m_referrerPolicy;
 367   bool m_didSetHTTPReferrer;
 368   bool m_checkForBrowserSideNavigation;
 369   double m_uiStartTime;
 370   bool m_isExternalRequest;
 371   InputToLoadPerfMetricReportPolicy m_inputPerfMetricReportPolicy;
 372
 373   mutable CacheControlHeader m_cacheControlHeaderCache;
 374
 375   static double s_defaultTimeoutInterval;
 376
 377   RedirectStatus m_redirectStatus;
 378
 379   double m_navigationStart = 0;
 380 };
 381
 382 struct CrossThreadResourceRequestData {
 383   WTF_MAKE_NONCOPYABLE(CrossThreadResourceRequestData);
 384   USING_FAST_MALLOC(CrossThreadResourceRequestData);
 385
 386  public:
 387   CrossThreadResourceRequestData() {}
 388   KURL m_url;
 389 #if defined(USE_EFL)
 390   KURL m_unencryptedUrl;
 391 #if defined(OS_TIZEN_TV_PRODUCT)
 392   bool m_isDecryptedFile;
 393 #endif  // defined(OS_TIZEN_TV_PRODUCT)
 394 #endif  // defined(USE_EFL)
 395
 396   WebCachePolicy m_cachePolicy;
 397   double m_timeoutInterval;
 398   KURL m_firstPartyForCookies;
 399   RefPtr<SecurityOrigin> m_requestorOrigin;
 400
 401   String m_httpMethod;
 402   std::unique_ptr<CrossThreadHTTPHeaderMapData> m_httpHeaders;
 403   RefPtr<EncodedFormData> m_httpBody;
 404   RefPtr<EncodedFormData> m_attachedCredential;
 405   bool m_allowStoredCredentials;
 406   bool m_reportUploadProgress;
 407   bool m_hasUserGesture;
 408   bool m_downloadToFile;
 409   WebURLRequest::SkipServiceWorker m_skipServiceWorker;
 410   bool m_useStreamOnResponse;
 411   bool m_shouldResetAppCache;
 412   ResourceLoadPriority m_priority;
 413   int m_intraPriorityValue;
 414   int m_requestorID;
 415   int m_requestorProcessID;
 416   int m_appCacheHostID;
 417   WebURLRequest::RequestContext m_requestContext;
 418   WebURLRequest::FrameType m_frameType;
 419   WebURLRequest::FetchRequestMode m_fetchRequestMode;
 420   WebURLRequest::FetchCredentialsMode m_fetchCredentialsMode;
 421   WebURLRequest::FetchRedirectMode m_fetchRedirectMode;
 422   WebURLRequest::LoFiState m_loFiState;
 423   ReferrerPolicy m_referrerPolicy;
 424   bool m_didSetHTTPReferrer;
 425   bool m_checkForBrowserSideNavigation;
 426   double m_uiStartTime;
 427   bool m_isExternalRequest;
 428   InputToLoadPerfMetricReportPolicy m_inputPerfMetricReportPolicy;
 429   ResourceRequest::RedirectStatus m_redirectStatus;
 430 };
 431
 432 }  // namespace blink
 433
 434 #endif  // ResourceRequest_h