| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #ifndef NET_URL_REQUEST_URL_REQUEST_H_ | |
| 6 #define NET_URL_REQUEST_URL_REQUEST_H_ | |
| 7 | |
| 8 #include <string> | |
| 9 #include <vector> | |
| 10 | |
| 11 #include "base/debug/leak_tracker.h" | |
| 12 #include "base/logging.h" | |
| 13 #include "base/memory/ref_counted.h" | |
| 14 #include "base/memory/scoped_ptr.h" | |
| 15 #include "base/strings/string16.h" | |
| 16 #include "base/supports_user_data.h" | |
| 17 #include "base/threading/non_thread_safe.h" | |
| 18 #include "base/time/time.h" | |
| 19 #include "net/base/auth.h" | |
| 20 #include "net/base/completion_callback.h" | |
| 21 #include "net/base/load_states.h" | |
| 22 #include "net/base/load_timing_info.h" | |
| 23 #include "net/base/net_export.h" | |
| 24 #include "net/base/net_log.h" | |
| 25 #include "net/base/network_delegate.h" | |
| 26 #include "net/base/request_priority.h" | |
| 27 #include "net/base/upload_progress.h" | |
| 28 #include "net/cookies/canonical_cookie.h" | |
| 29 #include "net/cookies/cookie_store.h" | |
| 30 #include "net/http/http_request_headers.h" | |
| 31 #include "net/http/http_response_info.h" | |
| 32 #include "net/url_request/url_request_status.h" | |
| 33 #include "url/gurl.h" | |
| 34 | |
| 35 namespace base { | |
| 36 class Value; | |
| 37 | |
| 38 namespace debug { | |
| 39 class StackTrace; | |
| 40 } // namespace debug | |
| 41 } // namespace base | |
| 42 | |
| 43 namespace net { | |
| 44 | |
| 45 class ChunkedUploadDataStream; | |
| 46 class CookieOptions; | |
| 47 class HostPortPair; | |
| 48 class IOBuffer; | |
| 49 struct LoadTimingInfo; | |
| 50 struct RedirectInfo; | |
| 51 class SSLCertRequestInfo; | |
| 52 class SSLInfo; | |
| 53 class UploadDataStream; | |
| 54 class URLRequestContext; | |
| 55 class URLRequestJob; | |
| 56 class X509Certificate; | |
| 57 | |
| 58 // This stores the values of the Set-Cookie headers received during the request. | |
| 59 // Each item in the vector corresponds to a Set-Cookie: line received, | |
| 60 // excluding the "Set-Cookie:" part. | |
| 61 typedef std::vector<std::string> ResponseCookies; | |
| 62 | |
| 63 //----------------------------------------------------------------------------- | |
| 64 // A class representing the asynchronous load of a data stream from an URL. | |
| 65 // | |
| 66 // The lifetime of an instance of this class is completely controlled by the | |
| 67 // consumer, and the instance is not required to live on the heap or be | |
| 68 // allocated in any special way. It is also valid to delete an URLRequest | |
| 69 // object during the handling of a callback to its delegate. Of course, once | |
| 70 // the URLRequest is deleted, no further callbacks to its delegate will occur. | |
| 71 // | |
| 72 // NOTE: All usage of all instances of this class should be on the same thread. | |
| 73 // | |
| 74 class NET_EXPORT URLRequest : NON_EXPORTED_BASE(public base::NonThreadSafe), | |
| 75 public base::SupportsUserData { | |
| 76 public: | |
| 77 // Callback function implemented by protocol handlers to create new jobs. | |
| 78 // The factory may return NULL to indicate an error, which will cause other | |
| 79 // factories to be queried. If no factory handles the request, then the | |
| 80 // default job will be used. | |
| 81 typedef URLRequestJob* (ProtocolFactory)(URLRequest* request, | |
| 82 NetworkDelegate* network_delegate, | |
| 83 const std::string& scheme); | |
| 84 | |
| 85 // Referrer policies (see set_referrer_policy): During server redirects, the | |
| 86 // referrer header might be cleared, if the protocol changes from HTTPS to | |
| 87 // HTTP. This is the default behavior of URLRequest, corresponding to | |
| 88 // CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE. Alternatively, the | |
| 89 // referrer policy can be set to strip the referrer down to an origin upon | |
| 90 // cross-origin navigation (ORIGIN_ONLY_ON_TRANSITION_CROSS_ORIGIN), or | |
| 91 // never change the referrer header (NEVER_CLEAR_REFERRER). Embedders will | |
| 92 // want to use these options when implementing referrer policy support | |
| 93 // (https://w3c.github.io/webappsec/specs/referrer-policy/). | |
| 94 // | |
| 95 // REDUCE_REFERRER_GRANULARITY_ON_TRANSITION_CROSS_ORIGIN is a slight variant | |
| 96 // on CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE: If the request | |
| 97 // downgrades from HTTPS to HTTP, the referrer will be cleared. If the request | |
| 98 // transitions cross-origin (but does not downgrade), the referrer's | |
| 99 // granularity will be reduced (currently stripped down to an origin rather | |
| 100 // than a full URL). Same-origin requests will send the full referrer. | |
| 101 enum ReferrerPolicy { | |
| 102 CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE, | |
| 103 REDUCE_REFERRER_GRANULARITY_ON_TRANSITION_CROSS_ORIGIN, | |
| 104 ORIGIN_ONLY_ON_TRANSITION_CROSS_ORIGIN, | |
| 105 NEVER_CLEAR_REFERRER, | |
| 106 }; | |
| 107 | |
| 108 // First-party URL redirect policy: During server redirects, the first-party | |
| 109 // URL for cookies normally doesn't change. However, if the request is a | |
| 110 // top-level first-party request, the first-party URL should be updated to the | |
| 111 // URL on every redirect. | |
| 112 enum FirstPartyURLPolicy { | |
| 113 NEVER_CHANGE_FIRST_PARTY_URL, | |
| 114 UPDATE_FIRST_PARTY_URL_ON_REDIRECT, | |
| 115 }; | |
| 116 | |
| 117 // The delegate's methods are called from the message loop of the thread | |
| 118 // on which the request's Start() method is called. See above for the | |
| 119 // ordering of callbacks. | |
| 120 // | |
| 121 // The callbacks will be called in the following order: | |
| 122 // Start() | |
| 123 // - OnCertificateRequested* (zero or more calls, if the SSL server and/or | |
| 124 // SSL proxy requests a client certificate for authentication) | |
| 125 // - OnSSLCertificateError* (zero or one call, if the SSL server's | |
| 126 // certificate has an error) | |
| 127 // - OnReceivedRedirect* (zero or more calls, for the number of redirects) | |
| 128 // - OnAuthRequired* (zero or more calls, for the number of | |
| 129 // authentication failures) | |
| 130 // - OnResponseStarted | |
| 131 // Read() initiated by delegate | |
| 132 // - OnReadCompleted* (zero or more calls until all data is read) | |
| 133 // | |
| 134 // Read() must be called at least once. Read() returns true when it completed | |
| 135 // immediately, and false if an IO is pending or if there is an error. When | |
| 136 // Read() returns false, the caller can check the Request's status() to see | |
| 137 // if an error occurred, or if the IO is just pending. When Read() returns | |
| 138 // true with zero bytes read, it indicates the end of the response. | |
| 139 // | |
| 140 class NET_EXPORT Delegate { | |
| 141 public: | |
| 142 // Called upon receiving a redirect. The delegate may call the request's | |
| 143 // Cancel method to prevent the redirect from being followed. Since there | |
| 144 // may be multiple chained redirects, there may also be more than one | |
| 145 // redirect call. | |
| 146 // | |
| 147 // When this function is called, the request will still contain the | |
| 148 // original URL, the destination of the redirect is provided in 'new_url'. | |
| 149 // If the delegate does not cancel the request and |*defer_redirect| is | |
| 150 // false, then the redirect will be followed, and the request's URL will be | |
| 151 // changed to the new URL. Otherwise if the delegate does not cancel the | |
| 152 // request and |*defer_redirect| is true, then the redirect will be | |
| 153 // followed once FollowDeferredRedirect is called on the URLRequest. | |
| 154 // | |
| 155 // The caller must set |*defer_redirect| to false, so that delegates do not | |
| 156 // need to set it if they are happy with the default behavior of not | |
| 157 // deferring redirect. | |
| 158 virtual void OnReceivedRedirect(URLRequest* request, | |
| 159 const RedirectInfo& redirect_info, | |
| 160 bool* defer_redirect); | |
| 161 | |
| 162 // Called when we receive an authentication failure. The delegate should | |
| 163 // call request->SetAuth() with the user's credentials once it obtains them, | |
| 164 // or request->CancelAuth() to cancel the login and display the error page. | |
| 165 // When it does so, the request will be reissued, restarting the sequence | |
| 166 // of On* callbacks. | |
| 167 virtual void OnAuthRequired(URLRequest* request, | |
| 168 AuthChallengeInfo* auth_info); | |
| 169 | |
| 170 // Called when we receive an SSL CertificateRequest message for client | |
| 171 // authentication. The delegate should call | |
| 172 // request->ContinueWithCertificate() with the client certificate the user | |
| 173 // selected, or request->ContinueWithCertificate(NULL) to continue the SSL | |
| 174 // handshake without a client certificate. | |
| 175 virtual void OnCertificateRequested( | |
| 176 URLRequest* request, | |
| 177 SSLCertRequestInfo* cert_request_info); | |
| 178 | |
| 179 // Called when using SSL and the server responds with a certificate with | |
| 180 // an error, for example, whose common name does not match the common name | |
| 181 // we were expecting for that host. The delegate should either do the | |
| 182 // safe thing and Cancel() the request or decide to proceed by calling | |
| 183 // ContinueDespiteLastError(). cert_error is a ERR_* error code | |
| 184 // indicating what's wrong with the certificate. | |
| 185 // If |fatal| is true then the host in question demands a higher level | |
| 186 // of security (due e.g. to HTTP Strict Transport Security, user | |
| 187 // preference, or built-in policy). In this case, errors must not be | |
| 188 // bypassable by the user. | |
| 189 virtual void OnSSLCertificateError(URLRequest* request, | |
| 190 const SSLInfo& ssl_info, | |
| 191 bool fatal); | |
| 192 | |
| 193 // Called to notify that the request must use the network to complete the | |
| 194 // request and is about to do so. This is called at most once per | |
| 195 // URLRequest, and by default does not defer. If deferred, call | |
| 196 // ResumeNetworkStart() to continue or Cancel() to cancel. | |
| 197 virtual void OnBeforeNetworkStart(URLRequest* request, bool* defer); | |
| 198 | |
| 199 // After calling Start(), the delegate will receive an OnResponseStarted | |
| 200 // callback when the request has completed. If an error occurred, the | |
| 201 // request->status() will be set. On success, all redirects have been | |
| 202 // followed and the final response is beginning to arrive. At this point, | |
| 203 // meta data about the response is available, including for example HTTP | |
| 204 // response headers if this is a request for a HTTP resource. | |
| 205 virtual void OnResponseStarted(URLRequest* request) = 0; | |
| 206 | |
| 207 // Called when the a Read of the response body is completed after an | |
| 208 // IO_PENDING status from a Read() call. | |
| 209 // The data read is filled into the buffer which the caller passed | |
| 210 // to Read() previously. | |
| 211 // | |
| 212 // If an error occurred, request->status() will contain the error, | |
| 213 // and bytes read will be -1. | |
| 214 virtual void OnReadCompleted(URLRequest* request, int bytes_read) = 0; | |
| 215 | |
| 216 protected: | |
| 217 virtual ~Delegate() {} | |
| 218 }; | |
| 219 | |
| 220 // If destroyed after Start() has been called but while IO is pending, | |
| 221 // then the request will be effectively canceled and the delegate | |
| 222 // will not have any more of its methods called. | |
| 223 ~URLRequest() override; | |
| 224 | |
| 225 // Changes the default cookie policy from allowing all cookies to blocking all | |
| 226 // cookies. Embedders that want to implement a more flexible policy should | |
| 227 // change the default to blocking all cookies, and provide a NetworkDelegate | |
| 228 // with the URLRequestContext that maintains the CookieStore. | |
| 229 // The cookie policy default has to be set before the first URLRequest is | |
| 230 // started. Once it was set to block all cookies, it cannot be changed back. | |
| 231 static void SetDefaultCookiePolicyToBlock(); | |
| 232 | |
| 233 // Returns true if the scheme can be handled by URLRequest. False otherwise. | |
| 234 static bool IsHandledProtocol(const std::string& scheme); | |
| 235 | |
| 236 // Returns true if the url can be handled by URLRequest. False otherwise. | |
| 237 // The function returns true for invalid urls because URLRequest knows how | |
| 238 // to handle those. | |
| 239 // NOTE: This will also return true for URLs that are handled by | |
| 240 // ProtocolFactories that only work for requests that are scoped to a | |
| 241 // Profile. | |
| 242 static bool IsHandledURL(const GURL& url); | |
| 243 | |
| 244 // The original url is the url used to initialize the request, and it may | |
| 245 // differ from the url if the request was redirected. | |
| 246 const GURL& original_url() const { return url_chain_.front(); } | |
| 247 // The chain of urls traversed by this request. If the request had no | |
| 248 // redirects, this vector will contain one element. | |
| 249 const std::vector<GURL>& url_chain() const { return url_chain_; } | |
| 250 const GURL& url() const { return url_chain_.back(); } | |
| 251 | |
| 252 // The URL that should be consulted for the third-party cookie blocking | |
| 253 // policy. | |
| 254 // | |
| 255 // WARNING: This URL must only be used for the third-party cookie blocking | |
| 256 // policy. It MUST NEVER be used for any kind of SECURITY check. | |
| 257 // | |
| 258 // For example, if a top-level navigation is redirected, the | |
| 259 // first-party for cookies will be the URL of the first URL in the | |
| 260 // redirect chain throughout the whole redirect. If it was used for | |
| 261 // a security check, an attacker might try to get around this check | |
| 262 // by starting from some page that redirects to the | |
| 263 // host-to-be-attacked. | |
| 264 const GURL& first_party_for_cookies() const { | |
| 265 return first_party_for_cookies_; | |
| 266 } | |
| 267 // This method may only be called before Start(). | |
| 268 void set_first_party_for_cookies(const GURL& first_party_for_cookies); | |
| 269 | |
| 270 // The first-party URL policy to apply when updating the first party URL | |
| 271 // during redirects. The first-party URL policy may only be changed before | |
| 272 // Start() is called. | |
| 273 FirstPartyURLPolicy first_party_url_policy() const { | |
| 274 return first_party_url_policy_; | |
| 275 } | |
| 276 void set_first_party_url_policy(FirstPartyURLPolicy first_party_url_policy); | |
| 277 | |
| 278 // The request method, as an uppercase string. "GET" is the default value. | |
| 279 // The request method may only be changed before Start() is called and | |
| 280 // should only be assigned an uppercase value. | |
| 281 const std::string& method() const { return method_; } | |
| 282 void set_method(const std::string& method); | |
| 283 | |
| 284 // The referrer URL for the request. This header may actually be suppressed | |
| 285 // from the underlying network request for security reasons (e.g., a HTTPS | |
| 286 // URL will not be sent as the referrer for a HTTP request). The referrer | |
| 287 // may only be changed before Start() is called. | |
| 288 const std::string& referrer() const { return referrer_; } | |
| 289 // Referrer is sanitized to remove URL fragment, user name and password. | |
| 290 void SetReferrer(const std::string& referrer); | |
| 291 | |
| 292 // The referrer policy to apply when updating the referrer during redirects. | |
| 293 // The referrer policy may only be changed before Start() is called. | |
| 294 ReferrerPolicy referrer_policy() const { return referrer_policy_; } | |
| 295 void set_referrer_policy(ReferrerPolicy referrer_policy); | |
| 296 | |
| 297 // Sets the delegate of the request. This value may be changed at any time, | |
| 298 // and it is permissible for it to be null. | |
| 299 void set_delegate(Delegate* delegate); | |
| 300 | |
| 301 // Indicates that the request body should be sent using chunked transfer | |
| 302 // encoding. This method may only be called before Start() is called. | |
| 303 void EnableChunkedUpload(); | |
| 304 | |
| 305 // Appends the given bytes to the request's upload data to be sent | |
| 306 // immediately via chunked transfer encoding. When all data has been sent, | |
| 307 // call MarkEndOfChunks() to indicate the end of upload data. | |
| 308 // | |
| 309 // This method may be called only after calling EnableChunkedUpload(). | |
| 310 void AppendChunkToUpload(const char* bytes, | |
| 311 int bytes_len, | |
| 312 bool is_last_chunk); | |
| 313 | |
| 314 // Sets the upload data. | |
| 315 void set_upload(scoped_ptr<UploadDataStream> upload); | |
| 316 | |
| 317 // Gets the upload data. | |
| 318 const UploadDataStream* get_upload() const; | |
| 319 | |
| 320 // Returns true if the request has a non-empty message body to upload. | |
| 321 bool has_upload() const; | |
| 322 | |
| 323 // Set or remove a extra request header. These methods may only be called | |
| 324 // before Start() is called, or between receiving a redirect and trying to | |
| 325 // follow it. | |
| 326 void SetExtraRequestHeaderByName(const std::string& name, | |
| 327 const std::string& value, bool overwrite); | |
| 328 void RemoveRequestHeaderByName(const std::string& name); | |
| 329 | |
| 330 // Sets all extra request headers. Any extra request headers set by other | |
| 331 // methods are overwritten by this method. This method may only be called | |
| 332 // before Start() is called. It is an error to call it later. | |
| 333 void SetExtraRequestHeaders(const HttpRequestHeaders& headers); | |
| 334 | |
| 335 const HttpRequestHeaders& extra_request_headers() const { | |
| 336 return extra_request_headers_; | |
| 337 } | |
| 338 | |
| 339 // Gets the full request headers sent to the server. | |
| 340 // | |
| 341 // Return true and overwrites headers if it can get the request headers; | |
| 342 // otherwise, returns false and does not modify headers. (Always returns | |
| 343 // false for request types that don't have headers, like file requests.) | |
| 344 // | |
| 345 // This is guaranteed to succeed if: | |
| 346 // | |
| 347 // 1. A redirect or auth callback is currently running. Once it ends, the | |
| 348 // headers may become unavailable as a new request with the new address | |
| 349 // or credentials is made. | |
| 350 // | |
| 351 // 2. The OnResponseStarted callback is currently running or has run. | |
| 352 bool GetFullRequestHeaders(HttpRequestHeaders* headers) const; | |
| 353 | |
| 354 // Gets the total amount of data received from network after SSL decoding and | |
| 355 // proxy handling. | |
| 356 int64 GetTotalReceivedBytes() const; | |
| 357 | |
| 358 // Returns the current load state for the request. The returned value's | |
| 359 // |param| field is an optional parameter describing details related to the | |
| 360 // load state. Not all load states have a parameter. | |
| 361 LoadStateWithParam GetLoadState() const; | |
| 362 | |
| 363 // Returns a partial representation of the request's state as a value, for | |
| 364 // debugging. Caller takes ownership of returned value. | |
| 365 base::Value* GetStateAsValue() const; | |
| 366 | |
| 367 // Logs information about the what external object currently blocking the | |
| 368 // request. LogUnblocked must be called before resuming the request. This | |
| 369 // can be called multiple times in a row either with or without calling | |
| 370 // LogUnblocked between calls. |blocked_by| must not be NULL or have length | |
| 371 // 0. | |
| 372 void LogBlockedBy(const char* blocked_by); | |
| 373 | |
| 374 // Just like LogBlockedBy, but also makes GetLoadState return source as the | |
| 375 // |param| in the value returned by GetLoadState. Calling LogUnblocked or | |
| 376 // LogBlockedBy will clear the load param. |blocked_by| must not be NULL or | |
| 377 // have length 0. | |
| 378 void LogAndReportBlockedBy(const char* blocked_by); | |
| 379 | |
| 380 // Logs that the request is no longer blocked by the last caller to | |
| 381 // LogBlockedBy. | |
| 382 void LogUnblocked(); | |
| 383 | |
| 384 // Returns the current upload progress in bytes. When the upload data is | |
| 385 // chunked, size is set to zero, but position will not be. | |
| 386 UploadProgress GetUploadProgress() const; | |
| 387 | |
| 388 // Get response header(s) by name. This method may only be called | |
| 389 // once the delegate's OnResponseStarted method has been called. Headers | |
| 390 // that appear more than once in the response are coalesced, with values | |
| 391 // separated by commas (per RFC 2616). This will not work with cookies since | |
| 392 // comma can be used in cookie values. | |
| 393 void GetResponseHeaderByName(const std::string& name, std::string* value); | |
| 394 | |
| 395 // The time when |this| was constructed. | |
| 396 base::TimeTicks creation_time() const { return creation_time_; } | |
| 397 | |
| 398 // The time at which the returned response was requested. For cached | |
| 399 // responses, this is the last time the cache entry was validated. | |
| 400 const base::Time& request_time() const { | |
| 401 return response_info_.request_time; | |
| 402 } | |
| 403 | |
| 404 // The time at which the returned response was generated. For cached | |
| 405 // responses, this is the last time the cache entry was validated. | |
| 406 const base::Time& response_time() const { | |
| 407 return response_info_.response_time; | |
| 408 } | |
| 409 | |
| 410 // Indicate if this response was fetched from disk cache. | |
| 411 bool was_cached() const { return response_info_.was_cached; } | |
| 412 | |
| 413 // Returns true if the URLRequest was delivered through a proxy. | |
| 414 bool was_fetched_via_proxy() const { | |
| 415 return response_info_.was_fetched_via_proxy; | |
| 416 } | |
| 417 | |
| 418 // Returns true if the URLRequest was delivered over SPDY. | |
| 419 bool was_fetched_via_spdy() const { | |
| 420 return response_info_.was_fetched_via_spdy; | |
| 421 } | |
| 422 | |
| 423 // Returns the host and port that the content was fetched from. See | |
| 424 // http_response_info.h for caveats relating to cached content. | |
| 425 HostPortPair GetSocketAddress() const; | |
| 426 | |
| 427 // Get all response headers, as a HttpResponseHeaders object. See comments | |
| 428 // in HttpResponseHeaders class as to the format of the data. | |
| 429 HttpResponseHeaders* response_headers() const; | |
| 430 | |
| 431 // Get the SSL connection info. | |
| 432 const SSLInfo& ssl_info() const { | |
| 433 return response_info_.ssl_info; | |
| 434 } | |
| 435 | |
| 436 // Gets timing information related to the request. Events that have not yet | |
| 437 // occurred are left uninitialized. After a second request starts, due to | |
| 438 // a redirect or authentication, values will be reset. | |
| 439 // | |
| 440 // LoadTimingInfo only contains ConnectTiming information and socket IDs for | |
| 441 // non-cached HTTP responses. | |
| 442 void GetLoadTimingInfo(LoadTimingInfo* load_timing_info) const; | |
| 443 | |
| 444 // Returns the cookie values included in the response, if the request is one | |
| 445 // that can have cookies. Returns true if the request is a cookie-bearing | |
| 446 // type, false otherwise. This method may only be called once the | |
| 447 // delegate's OnResponseStarted method has been called. | |
| 448 bool GetResponseCookies(ResponseCookies* cookies); | |
| 449 | |
| 450 // Get the mime type. This method may only be called once the delegate's | |
| 451 // OnResponseStarted method has been called. | |
| 452 void GetMimeType(std::string* mime_type) const; | |
| 453 | |
| 454 // Get the charset (character encoding). This method may only be called once | |
| 455 // the delegate's OnResponseStarted method has been called. | |
| 456 void GetCharset(std::string* charset) const; | |
| 457 | |
| 458 // Returns the HTTP response code (e.g., 200, 404, and so on). This method | |
| 459 // may only be called once the delegate's OnResponseStarted method has been | |
| 460 // called. For non-HTTP requests, this method returns -1. | |
| 461 int GetResponseCode() const; | |
| 462 | |
| 463 // Get the HTTP response info in its entirety. | |
| 464 const HttpResponseInfo& response_info() const { return response_info_; } | |
| 465 | |
| 466 // Access the LOAD_* flags modifying this request (see load_flags.h). | |
| 467 int load_flags() const { return load_flags_; } | |
| 468 | |
| 469 // The new flags may change the IGNORE_LIMITS flag only when called | |
| 470 // before Start() is called, it must only set the flag, and if set, | |
| 471 // the priority of this request must already be MAXIMUM_PRIORITY. | |
| 472 void SetLoadFlags(int flags); | |
| 473 | |
| 474 // Returns true if the request is "pending" (i.e., if Start() has been called, | |
| 475 // and the response has not yet been called). | |
| 476 bool is_pending() const { return is_pending_; } | |
| 477 | |
| 478 // Returns true if the request is in the process of redirecting to a new | |
| 479 // URL but has not yet initiated the new request. | |
| 480 bool is_redirecting() const { return is_redirecting_; } | |
| 481 | |
| 482 // Returns the error status of the request. | |
| 483 const URLRequestStatus& status() const { return status_; } | |
| 484 | |
| 485 // Returns a globally unique identifier for this request. | |
| 486 uint64 identifier() const { return identifier_; } | |
| 487 | |
| 488 // This method is called to start the request. The delegate will receive | |
| 489 // a OnResponseStarted callback when the request is started. | |
| 490 void Start(); | |
| 491 | |
| 492 // This method may be called at any time after Start() has been called to | |
| 493 // cancel the request. This method may be called many times, and it has | |
| 494 // no effect once the response has completed. It is guaranteed that no | |
| 495 // methods of the delegate will be called after the request has been | |
| 496 // cancelled, except that this may call the delegate's OnReadCompleted() | |
| 497 // during the call to Cancel itself. | |
| 498 void Cancel(); | |
| 499 | |
| 500 // Cancels the request and sets the error to |error| (see net_error_list.h | |
| 501 // for values). | |
| 502 void CancelWithError(int error); | |
| 503 | |
| 504 // Cancels the request and sets the error to |error| (see net_error_list.h | |
| 505 // for values) and attaches |ssl_info| as the SSLInfo for that request. This | |
| 506 // is useful to attach a certificate and certificate error to a canceled | |
| 507 // request. | |
| 508 void CancelWithSSLError(int error, const SSLInfo& ssl_info); | |
| 509 | |
| 510 // Read initiates an asynchronous read from the response, and must only | |
| 511 // be called after the OnResponseStarted callback is received with a | |
| 512 // successful status. | |
| 513 // If data is available, Read will return true, and the data and length will | |
| 514 // be returned immediately. If data is not available, Read returns false, | |
| 515 // and an asynchronous Read is initiated. The Read is finished when | |
| 516 // the caller receives the OnReadComplete callback. Unless the request was | |
| 517 // cancelled, OnReadComplete will always be called, even if the read failed. | |
| 518 // | |
| 519 // The buf parameter is a buffer to receive the data. If the operation | |
| 520 // completes asynchronously, the implementation will reference the buffer | |
| 521 // until OnReadComplete is called. The buffer must be at least max_bytes in | |
| 522 // length. | |
| 523 // | |
| 524 // The max_bytes parameter is the maximum number of bytes to read. | |
| 525 // | |
| 526 // The bytes_read parameter is an output parameter containing the | |
| 527 // the number of bytes read. A value of 0 indicates that there is no | |
| 528 // more data available to read from the stream. | |
| 529 // | |
| 530 // If a read error occurs, Read returns false and the request->status | |
| 531 // will be set to an error. | |
| 532 bool Read(IOBuffer* buf, int max_bytes, int* bytes_read); | |
| 533 | |
| 534 // If this request is being cached by the HTTP cache, stop subsequent caching. | |
| 535 // Note that this method has no effect on other (simultaneous or not) requests | |
| 536 // for the same resource. The typical example is a request that results in | |
| 537 // the data being stored to disk (downloaded instead of rendered) so we don't | |
| 538 // want to store it twice. | |
| 539 void StopCaching(); | |
| 540 | |
| 541 // This method may be called to follow a redirect that was deferred in | |
| 542 // response to an OnReceivedRedirect call. | |
| 543 void FollowDeferredRedirect(); | |
| 544 | |
| 545 // This method must be called to resume network communications that were | |
| 546 // deferred in response to an OnBeforeNetworkStart call. | |
| 547 void ResumeNetworkStart(); | |
| 548 | |
| 549 // One of the following two methods should be called in response to an | |
| 550 // OnAuthRequired() callback (and only then). | |
| 551 // SetAuth will reissue the request with the given credentials. | |
| 552 // CancelAuth will give up and display the error page. | |
| 553 void SetAuth(const AuthCredentials& credentials); | |
| 554 void CancelAuth(); | |
| 555 | |
| 556 // This method can be called after the user selects a client certificate to | |
| 557 // instruct this URLRequest to continue with the request with the | |
| 558 // certificate. Pass NULL if the user doesn't have a client certificate. | |
| 559 void ContinueWithCertificate(X509Certificate* client_cert); | |
| 560 | |
| 561 // This method can be called after some error notifications to instruct this | |
| 562 // URLRequest to ignore the current error and continue with the request. To | |
| 563 // cancel the request instead, call Cancel(). | |
| 564 void ContinueDespiteLastError(); | |
| 565 | |
| 566 // Used to specify the context (cookie store, cache) for this request. | |
| 567 const URLRequestContext* context() const; | |
| 568 | |
| 569 const BoundNetLog& net_log() const { return net_log_; } | |
| 570 | |
| 571 // Returns the expected content size if available | |
| 572 int64 GetExpectedContentSize() const; | |
| 573 | |
| 574 // Returns the priority level for this request. | |
| 575 RequestPriority priority() const { return priority_; } | |
| 576 | |
| 577 // Sets the priority level for this request and any related | |
| 578 // jobs. Must not change the priority to anything other than | |
| 579 // MAXIMUM_PRIORITY if the IGNORE_LIMITS load flag is set. | |
| 580 void SetPriority(RequestPriority priority); | |
| 581 | |
| 582 // Returns true iff this request would be internally redirected to HTTPS | |
| 583 // due to HSTS. If so, |redirect_url| is rewritten to the new HTTPS URL. | |
| 584 bool GetHSTSRedirect(GURL* redirect_url) const; | |
| 585 | |
| 586 // TODO(willchan): Undo this. Only temporarily public. | |
| 587 bool has_delegate() const { return delegate_ != NULL; } | |
| 588 | |
| 589 // NOTE(willchan): This is just temporary for debugging | |
| 590 // http://crbug.com/90971. | |
| 591 // Allows to setting debug info into the URLRequest. | |
| 592 void set_stack_trace(const base::debug::StackTrace& stack_trace); | |
| 593 const base::debug::StackTrace* stack_trace() const; | |
| 594 | |
| 595 void set_received_response_content_length(int64 received_content_length) { | |
| 596 received_response_content_length_ = received_content_length; | |
| 597 } | |
| 598 int64 received_response_content_length() const { | |
| 599 return received_response_content_length_; | |
| 600 } | |
| 601 | |
| 602 // Available at NetworkDelegate::NotifyHeadersReceived() time, which is before | |
| 603 // the more general response_info() is available, even though it is a subset. | |
| 604 const HostPortPair& proxy_server() const { | |
| 605 return proxy_server_; | |
| 606 } | |
| 607 | |
| 608 protected: | |
| 609 // Allow the URLRequestJob class to control the is_pending() flag. | |
| 610 void set_is_pending(bool value) { is_pending_ = value; } | |
| 611 | |
| 612 // Allow the URLRequestJob class to set our status too | |
| 613 void set_status(const URLRequestStatus& value) { status_ = value; } | |
| 614 | |
| 615 CookieStore* cookie_store() const { return cookie_store_.get(); } | |
| 616 | |
| 617 // Allow the URLRequestJob to redirect this request. Returns OK if | |
| 618 // successful, otherwise an error code is returned. | |
| 619 int Redirect(const RedirectInfo& redirect_info); | |
| 620 | |
| 621 // Called by URLRequestJob to allow interception when a redirect occurs. | |
| 622 void NotifyReceivedRedirect(const RedirectInfo& redirect_info, | |
| 623 bool* defer_redirect); | |
| 624 | |
| 625 // Called by URLRequestHttpJob (note, only HTTP(S) jobs will call this) to | |
| 626 // allow deferral of network initialization. | |
| 627 void NotifyBeforeNetworkStart(bool* defer); | |
| 628 | |
| 629 // Allow an interceptor's URLRequestJob to restart this request. | |
| 630 // Should only be called if the original job has not started a response. | |
| 631 void Restart(); | |
| 632 | |
| 633 private: | |
| 634 friend class URLRequestJob; | |
| 635 friend class URLRequestContext; | |
| 636 | |
| 637 // URLRequests are always created by calling URLRequestContext::CreateRequest. | |
| 638 // | |
| 639 // If no cookie store or network delegate are passed in, will use the ones | |
| 640 // from the URLRequestContext. | |
| 641 URLRequest(const GURL& url, | |
| 642 RequestPriority priority, | |
| 643 Delegate* delegate, | |
| 644 const URLRequestContext* context, | |
| 645 CookieStore* cookie_store, | |
| 646 NetworkDelegate* network_delegate); | |
| 647 | |
| 648 // Resumes or blocks a request paused by the NetworkDelegate::OnBeforeRequest | |
| 649 // handler. If |blocked| is true, the request is blocked and an error page is | |
| 650 // returned indicating so. This should only be called after Start is called | |
| 651 // and OnBeforeRequest returns true (signalling that the request should be | |
| 652 // paused). | |
| 653 void BeforeRequestComplete(int error); | |
| 654 | |
| 655 void StartJob(URLRequestJob* job); | |
| 656 | |
| 657 // Restarting involves replacing the current job with a new one such as what | |
| 658 // happens when following a HTTP redirect. | |
| 659 void RestartWithJob(URLRequestJob* job); | |
| 660 void PrepareToRestart(); | |
| 661 | |
| 662 // Detaches the job from this request in preparation for this object going | |
| 663 // away or the job being replaced. The job will not call us back when it has | |
| 664 // been orphaned. | |
| 665 void OrphanJob(); | |
| 666 | |
| 667 // Cancels the request and set the error and ssl info for this request to the | |
| 668 // passed values. | |
| 669 void DoCancel(int error, const SSLInfo& ssl_info); | |
| 670 | |
| 671 // Called by the URLRequestJob when the headers are received, before any other | |
| 672 // method, to allow caching of load timing information. | |
| 673 void OnHeadersComplete(); | |
| 674 | |
| 675 // Notifies the network delegate that the request has been completed. | |
| 676 // This does not imply a successful completion. Also a canceled request is | |
| 677 // considered completed. | |
| 678 void NotifyRequestCompleted(); | |
| 679 | |
| 680 // Called by URLRequestJob to allow interception when the final response | |
| 681 // occurs. | |
| 682 void NotifyResponseStarted(); | |
| 683 | |
| 684 // These functions delegate to |delegate_| and may only be used if | |
| 685 // |delegate_| is not NULL. See URLRequest::Delegate for the meaning | |
| 686 // of these functions. | |
| 687 void NotifyAuthRequired(AuthChallengeInfo* auth_info); | |
| 688 void NotifyAuthRequiredComplete(NetworkDelegate::AuthRequiredResponse result); | |
| 689 void NotifyCertificateRequested(SSLCertRequestInfo* cert_request_info); | |
| 690 void NotifySSLCertificateError(const SSLInfo& ssl_info, bool fatal); | |
| 691 void NotifyReadCompleted(int bytes_read); | |
| 692 | |
| 693 // These functions delegate to |network_delegate_| if it is not NULL. | |
| 694 // If |network_delegate_| is NULL, cookies can be used unless | |
| 695 // SetDefaultCookiePolicyToBlock() has been called. | |
| 696 bool CanGetCookies(const CookieList& cookie_list) const; | |
| 697 bool CanSetCookie(const std::string& cookie_line, | |
| 698 CookieOptions* options) const; | |
| 699 bool CanEnablePrivacyMode() const; | |
| 700 | |
| 701 // Called just before calling a delegate that may block a request. | |
| 702 void OnCallToDelegate(); | |
| 703 // Called when the delegate lets a request continue. Also called on | |
| 704 // cancellation. | |
| 705 void OnCallToDelegateComplete(); | |
| 706 | |
| 707 // Contextual information used for this request. Cannot be NULL. This contains | |
| 708 // most of the dependencies which are shared between requests (disk cache, | |
| 709 // cookie store, socket pool, etc.) | |
| 710 const URLRequestContext* context_; | |
| 711 | |
| 712 NetworkDelegate* network_delegate_; | |
| 713 | |
| 714 // Tracks the time spent in various load states throughout this request. | |
| 715 BoundNetLog net_log_; | |
| 716 | |
| 717 scoped_refptr<URLRequestJob> job_; | |
| 718 scoped_ptr<UploadDataStream> upload_data_stream_; | |
| 719 // TODO(mmenke): Make whether or not an upload is chunked transparent to the | |
| 720 // URLRequest. | |
| 721 ChunkedUploadDataStream* upload_chunked_data_stream_; | |
| 722 | |
| 723 std::vector<GURL> url_chain_; | |
| 724 GURL first_party_for_cookies_; | |
| 725 GURL delegate_redirect_url_; | |
| 726 std::string method_; // "GET", "POST", etc. Should be all uppercase. | |
| 727 std::string referrer_; | |
| 728 ReferrerPolicy referrer_policy_; | |
| 729 FirstPartyURLPolicy first_party_url_policy_; | |
| 730 HttpRequestHeaders extra_request_headers_; | |
| 731 int load_flags_; // Flags indicating the request type for the load; | |
| 732 // expected values are LOAD_* enums above. | |
| 733 | |
| 734 // Never access methods of the |delegate_| directly. Always use the | |
| 735 // Notify... methods for this. | |
| 736 Delegate* delegate_; | |
| 737 | |
| 738 // Current error status of the job. When no error has been encountered, this | |
| 739 // will be SUCCESS. If multiple errors have been encountered, this will be | |
| 740 // the first non-SUCCESS status seen. | |
| 741 URLRequestStatus status_; | |
| 742 | |
| 743 // The HTTP response info, lazily initialized. | |
| 744 HttpResponseInfo response_info_; | |
| 745 | |
| 746 // Tells us whether the job is outstanding. This is true from the time | |
| 747 // Start() is called to the time we dispatch RequestComplete and indicates | |
| 748 // whether the job is active. | |
| 749 bool is_pending_; | |
| 750 | |
| 751 // Indicates if the request is in the process of redirecting to a new | |
| 752 // location. It is true from the time the headers complete until a | |
| 753 // new request begins. | |
| 754 bool is_redirecting_; | |
| 755 | |
| 756 // Number of times we're willing to redirect. Used to guard against | |
| 757 // infinite redirects. | |
| 758 int redirect_limit_; | |
| 759 | |
| 760 // Cached value for use after we've orphaned the job handling the | |
| 761 // first transaction in a request involving redirects. | |
| 762 UploadProgress final_upload_progress_; | |
| 763 | |
| 764 // The priority level for this request. Objects like | |
| 765 // ClientSocketPool use this to determine which URLRequest to | |
| 766 // allocate sockets to first. | |
| 767 RequestPriority priority_; | |
| 768 | |
| 769 // TODO(battre): The only consumer of the identifier_ is currently the | |
| 770 // web request API. We need to match identifiers of requests between the | |
| 771 // web request API and the web navigation API. As the URLRequest does not | |
| 772 // exist when the web navigation API is triggered, the tracking probably | |
| 773 // needs to be done outside of the URLRequest anyway. Therefore, this | |
| 774 // identifier should be deleted here. http://crbug.com/89321 | |
| 775 // A globally unique identifier for this request. | |
| 776 const uint64 identifier_; | |
| 777 | |
| 778 // True if this request is currently calling a delegate, or is blocked waiting | |
| 779 // for the URL request or network delegate to resume it. | |
| 780 bool calling_delegate_; | |
| 781 | |
| 782 // An optional parameter that provides additional information about what | |
| 783 // |this| is currently being blocked by. | |
| 784 std::string blocked_by_; | |
| 785 bool use_blocked_by_as_load_param_; | |
| 786 | |
| 787 base::debug::LeakTracker<URLRequest> leak_tracker_; | |
| 788 | |
| 789 // Callback passed to the network delegate to notify us when a blocked request | |
| 790 // is ready to be resumed or canceled. | |
| 791 CompletionCallback before_request_callback_; | |
| 792 | |
| 793 // Safe-guard to ensure that we do not send multiple "I am completed" | |
| 794 // messages to network delegate. | |
| 795 // TODO(battre): Remove this. http://crbug.com/89049 | |
| 796 bool has_notified_completion_; | |
| 797 | |
| 798 // Authentication data used by the NetworkDelegate for this request, | |
| 799 // if one is present. |auth_credentials_| may be filled in when calling | |
| 800 // |NotifyAuthRequired| on the NetworkDelegate. |auth_info_| holds | |
| 801 // the authentication challenge being handled by |NotifyAuthRequired|. | |
| 802 AuthCredentials auth_credentials_; | |
| 803 scoped_refptr<AuthChallengeInfo> auth_info_; | |
| 804 | |
| 805 int64 received_response_content_length_; | |
| 806 | |
| 807 base::TimeTicks creation_time_; | |
| 808 | |
| 809 // Timing information for the most recent request. Its start times are | |
| 810 // populated during Start(), and the rest are populated in OnResponseReceived. | |
| 811 LoadTimingInfo load_timing_info_; | |
| 812 | |
| 813 scoped_ptr<const base::debug::StackTrace> stack_trace_; | |
| 814 | |
| 815 // Keeps track of whether or not OnBeforeNetworkStart has been called yet. | |
| 816 bool notified_before_network_start_; | |
| 817 | |
| 818 // The cookie store to be used for this request. | |
| 819 scoped_refptr<CookieStore> cookie_store_; | |
| 820 | |
| 821 // The proxy server used for this request, if any. | |
| 822 HostPortPair proxy_server_; | |
| 823 | |
| 824 DISALLOW_COPY_AND_ASSIGN(URLRequest); | |
| 825 }; | |
| 826 | |
| 827 } // namespace net | |
| 828 | |
| 829 #endif // NET_URL_REQUEST_URL_REQUEST_H_ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 992733002:
Remove //net (except for Android test stuff) and sdch (Closed)
Base URL: git@github.com:domokit/mojo.git@master