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.
5 #ifndef NET_URL_REQUEST_URL_REQUEST_H_
6 #define NET_URL_REQUEST_URL_REQUEST_H_
11 #include "base/debug/leak_tracker.h"
12 #include "base/logging.h"
13 #include "base/memory/ref_counted.h"
14 #include "base/strings/string16.h"
15 #include "base/supports_user_data.h"
16 #include "base/threading/non_thread_safe.h"
17 #include "base/time/time.h"
18 #include "net/base/auth.h"
19 #include "net/base/completion_callback.h"
20 #include "net/base/load_states.h"
21 #include "net/base/load_timing_info.h"
22 #include "net/base/net_export.h"
23 #include "net/base/net_log.h"
24 #include "net/base/network_delegate.h"
25 #include "net/base/request_priority.h"
26 #include "net/base/upload_progress.h"
27 #include "net/cookies/canonical_cookie.h"
28 #include "net/http/http_request_headers.h"
29 #include "net/http/http_response_info.h"
30 #include "net/url_request/url_request_status.h"
33 // Temporary layering violation to allow existing users of a deprecated
35 class ChildProcessSecurityPolicyTest;
36 class TestAutomationProvider;
37 class URLRequestAutomationJob;
47 // Temporary layering violation to allow existing users of a deprecated
50 class AppCacheInterceptor;
51 class AppCacheRequestHandlerTest;
52 class AppCacheURLRequestJobTest;
55 // Temporary layering violation to allow existing users of a deprecated
58 class ResourceDispatcherHostTest;
61 // Temporary layering violation to allow existing users of a deprecated
64 class FileSystemDirURLRequestJobTest;
65 class FileSystemURLRequestJobTest;
66 class FileWriterDelegateTest;
69 // Temporary layering violation to allow existing users of a deprecated
71 namespace webkit_blob {
72 class BlobURLRequestJobTest;
80 struct LoadTimingInfo;
81 class SSLCertRequestInfo;
83 class UploadDataStream;
84 class URLRequestContext;
86 class X509Certificate;
88 // This stores the values of the Set-Cookie headers received during the request.
89 // Each item in the vector corresponds to a Set-Cookie: line received,
90 // excluding the "Set-Cookie:" part.
91 typedef std::vector<std::string> ResponseCookies;
93 //-----------------------------------------------------------------------------
94 // A class representing the asynchronous load of a data stream from an URL.
96 // The lifetime of an instance of this class is completely controlled by the
97 // consumer, and the instance is not required to live on the heap or be
98 // allocated in any special way. It is also valid to delete an URLRequest
99 // object during the handling of a callback to its delegate. Of course, once
100 // the URLRequest is deleted, no further callbacks to its delegate will occur.
102 // NOTE: All usage of all instances of this class should be on the same thread.
104 class NET_EXPORT URLRequest : NON_EXPORTED_BASE(public base::NonThreadSafe),
105 public base::SupportsUserData {
107 // Callback function implemented by protocol handlers to create new jobs.
108 // The factory may return NULL to indicate an error, which will cause other
109 // factories to be queried. If no factory handles the request, then the
110 // default job will be used.
111 typedef URLRequestJob* (ProtocolFactory)(URLRequest* request,
112 NetworkDelegate* network_delegate,
113 const std::string& scheme);
115 // HTTP request/response header IDs (via some preprocessor fun) for use with
116 // SetRequestHeaderById and GetResponseHeaderById.
118 #define HTTP_ATOM(x) HTTP_ ## x,
119 #include "net/http/http_atom_list.h"
123 // Referrer policies (see set_referrer_policy): During server redirects, the
124 // referrer header might be cleared, if the protocol changes from HTTPS to
125 // HTTP. This is the default behavior of URLRequest, corresponding to
126 // CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE. Alternatively, the
127 // referrer policy can be set to never change the referrer header. This
128 // behavior corresponds to NEVER_CLEAR_REFERRER. Embedders will want to use
129 // NEVER_CLEAR_REFERRER when implementing the meta-referrer support
130 // (http://wiki.whatwg.org/wiki/Meta_referrer) and sending requests with a
131 // non-default referrer policy. Only the default referrer policy requires
132 // the referrer to be cleared on transitions from HTTPS to HTTP.
133 enum ReferrerPolicy {
134 CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE,
135 NEVER_CLEAR_REFERRER,
138 // Used with SetDelegateInfo to indicate how the string should be used.
139 // DELEGATE_INFO_DEBUG_ONLY indicates it should only be used when logged to
140 // NetLog, while DELEGATE_INFO_DISPLAY_TO_USER indicates it should also be
141 // returned by calls to GetLoadState for display to the user.
142 enum DelegateInfoUsage {
143 DELEGATE_INFO_DEBUG_ONLY,
144 DELEGATE_INFO_DISPLAY_TO_USER,
147 // This class handles network interception. Use with
148 // (Un)RegisterRequestInterceptor.
149 class NET_EXPORT Interceptor {
151 virtual ~Interceptor() {}
153 // Called for every request made. Should return a new job to handle the
154 // request if it should be intercepted, or NULL to allow the request to
155 // be handled in the normal manner.
156 virtual URLRequestJob* MaybeIntercept(
157 URLRequest* request, NetworkDelegate* network_delegate) = 0;
159 // Called after having received a redirect response, but prior to the
160 // the request delegate being informed of the redirect. Can return a new
161 // job to replace the existing job if it should be intercepted, or NULL
162 // to allow the normal handling to continue. If a new job is provided,
163 // the delegate never sees the original redirect response, instead the
164 // response produced by the intercept job will be returned.
165 virtual URLRequestJob* MaybeInterceptRedirect(
167 NetworkDelegate* network_delegate,
168 const GURL& location);
170 // Called after having received a final response, but prior to the
171 // the request delegate being informed of the response. This is also
172 // called when there is no server response at all to allow interception
173 // on dns or network errors. Can return a new job to replace the existing
174 // job if it should be intercepted, or NULL to allow the normal handling to
175 // continue. If a new job is provided, the delegate never sees the original
176 // response, instead the response produced by the intercept job will be
178 virtual URLRequestJob* MaybeInterceptResponse(
179 URLRequest* request, NetworkDelegate* network_delegate);
182 // Deprecated interfaces in net::URLRequest. They have been moved to
183 // URLRequest's private section to prevent new uses. Existing uses are
184 // explicitly friended here and should be removed over time.
185 class NET_EXPORT Deprecated {
187 // TODO(willchan): Kill off these friend declarations.
188 friend class ::ChildProcessSecurityPolicyTest;
189 friend class ::TestAutomationProvider;
190 friend class ::URLRequestAutomationJob;
191 friend class TestInterceptor;
192 friend class URLRequestFilter;
193 friend class appcache::AppCacheInterceptor;
194 friend class appcache::AppCacheRequestHandlerTest;
195 friend class appcache::AppCacheURLRequestJobTest;
196 friend class content::ResourceDispatcherHostTest;
197 friend class fileapi::FileSystemDirURLRequestJobTest;
198 friend class fileapi::FileSystemURLRequestJobTest;
199 friend class fileapi::FileWriterDelegateTest;
200 friend class webkit_blob::BlobURLRequestJobTest;
202 // Use URLRequestJobFactory::ProtocolHandler instead.
203 static ProtocolFactory* RegisterProtocolFactory(const std::string& scheme,
204 ProtocolFactory* factory);
206 // TODO(pauljensen): Remove this when AppCacheInterceptor is a
207 // ProtocolHandler, see crbug.com/161547.
208 static void RegisterRequestInterceptor(Interceptor* interceptor);
209 static void UnregisterRequestInterceptor(Interceptor* interceptor);
211 DISALLOW_IMPLICIT_CONSTRUCTORS(Deprecated);
214 // The delegate's methods are called from the message loop of the thread
215 // on which the request's Start() method is called. See above for the
216 // ordering of callbacks.
218 // The callbacks will be called in the following order:
220 // - OnCertificateRequested* (zero or more calls, if the SSL server and/or
221 // SSL proxy requests a client certificate for authentication)
222 // - OnSSLCertificateError* (zero or one call, if the SSL server's
223 // certificate has an error)
224 // - OnReceivedRedirect* (zero or more calls, for the number of redirects)
225 // - OnAuthRequired* (zero or more calls, for the number of
226 // authentication failures)
227 // - OnResponseStarted
228 // Read() initiated by delegate
229 // - OnReadCompleted* (zero or more calls until all data is read)
231 // Read() must be called at least once. Read() returns true when it completed
232 // immediately, and false if an IO is pending or if there is an error. When
233 // Read() returns false, the caller can check the Request's status() to see
234 // if an error occurred, or if the IO is just pending. When Read() returns
235 // true with zero bytes read, it indicates the end of the response.
237 class NET_EXPORT Delegate {
239 // Called upon a server-initiated redirect. The delegate may call the
240 // request's Cancel method to prevent the redirect from being followed.
241 // Since there may be multiple chained redirects, there may also be more
242 // than one redirect call.
244 // When this function is called, the request will still contain the
245 // original URL, the destination of the redirect is provided in 'new_url'.
246 // If the delegate does not cancel the request and |*defer_redirect| is
247 // false, then the redirect will be followed, and the request's URL will be
248 // changed to the new URL. Otherwise if the delegate does not cancel the
249 // request and |*defer_redirect| is true, then the redirect will be
250 // followed once FollowDeferredRedirect is called on the URLRequest.
252 // The caller must set |*defer_redirect| to false, so that delegates do not
253 // need to set it if they are happy with the default behavior of not
254 // deferring redirect.
255 virtual void OnReceivedRedirect(URLRequest* request,
257 bool* defer_redirect);
259 // Called when we receive an authentication failure. The delegate should
260 // call request->SetAuth() with the user's credentials once it obtains them,
261 // or request->CancelAuth() to cancel the login and display the error page.
262 // When it does so, the request will be reissued, restarting the sequence
264 virtual void OnAuthRequired(URLRequest* request,
265 AuthChallengeInfo* auth_info);
267 // Called when we receive an SSL CertificateRequest message for client
268 // authentication. The delegate should call
269 // request->ContinueWithCertificate() with the client certificate the user
270 // selected, or request->ContinueWithCertificate(NULL) to continue the SSL
271 // handshake without a client certificate.
272 virtual void OnCertificateRequested(
274 SSLCertRequestInfo* cert_request_info);
276 // Called when using SSL and the server responds with a certificate with
277 // an error, for example, whose common name does not match the common name
278 // we were expecting for that host. The delegate should either do the
279 // safe thing and Cancel() the request or decide to proceed by calling
280 // ContinueDespiteLastError(). cert_error is a ERR_* error code
281 // indicating what's wrong with the certificate.
282 // If |fatal| is true then the host in question demands a higher level
283 // of security (due e.g. to HTTP Strict Transport Security, user
284 // preference, or built-in policy). In this case, errors must not be
285 // bypassable by the user.
286 virtual void OnSSLCertificateError(URLRequest* request,
287 const SSLInfo& ssl_info,
290 // After calling Start(), the delegate will receive an OnResponseStarted
291 // callback when the request has completed. If an error occurred, the
292 // request->status() will be set. On success, all redirects have been
293 // followed and the final response is beginning to arrive. At this point,
294 // meta data about the response is available, including for example HTTP
295 // response headers if this is a request for a HTTP resource.
296 virtual void OnResponseStarted(URLRequest* request) = 0;
298 // Called when the a Read of the response body is completed after an
299 // IO_PENDING status from a Read() call.
300 // The data read is filled into the buffer which the caller passed
301 // to Read() previously.
303 // If an error occurred, request->status() will contain the error,
304 // and bytes read will be -1.
305 virtual void OnReadCompleted(URLRequest* request, int bytes_read) = 0;
308 virtual ~Delegate() {}
311 URLRequest(const GURL& url,
312 RequestPriority priority,
314 const URLRequestContext* context);
316 // If destroyed after Start() has been called but while IO is pending,
317 // then the request will be effectively canceled and the delegate
318 // will not have any more of its methods called.
319 virtual ~URLRequest();
321 // Changes the default cookie policy from allowing all cookies to blocking all
322 // cookies. Embedders that want to implement a more flexible policy should
323 // change the default to blocking all cookies, and provide a NetworkDelegate
324 // with the URLRequestContext that maintains the CookieStore.
325 // The cookie policy default has to be set before the first URLRequest is
326 // started. Once it was set to block all cookies, it cannot be changed back.
327 static void SetDefaultCookiePolicyToBlock();
329 // Returns true if the scheme can be handled by URLRequest. False otherwise.
330 static bool IsHandledProtocol(const std::string& scheme);
332 // Returns true if the url can be handled by URLRequest. False otherwise.
333 // The function returns true for invalid urls because URLRequest knows how
335 // NOTE: This will also return true for URLs that are handled by
336 // ProtocolFactories that only work for requests that are scoped to a
338 static bool IsHandledURL(const GURL& url);
340 // The original url is the url used to initialize the request, and it may
341 // differ from the url if the request was redirected.
342 const GURL& original_url() const { return url_chain_.front(); }
343 // The chain of urls traversed by this request. If the request had no
344 // redirects, this vector will contain one element.
345 const std::vector<GURL>& url_chain() const { return url_chain_; }
346 const GURL& url() const { return url_chain_.back(); }
348 // The URL that should be consulted for the third-party cookie blocking
351 // WARNING: This URL must only be used for the third-party cookie blocking
352 // policy. It MUST NEVER be used for any kind of SECURITY check.
354 // For example, if a top-level navigation is redirected, the
355 // first-party for cookies will be the URL of the first URL in the
356 // redirect chain throughout the whole redirect. If it was used for
357 // a security check, an attacker might try to get around this check
358 // by starting from some page that redirects to the
359 // host-to-be-attacked.
360 const GURL& first_party_for_cookies() const {
361 return first_party_for_cookies_;
363 // This method may be called before Start() or FollowDeferredRedirect() is
365 void set_first_party_for_cookies(const GURL& first_party_for_cookies);
367 // The request method, as an uppercase string. "GET" is the default value.
368 // The request method may only be changed before Start() is called and
369 // should only be assigned an uppercase value.
370 const std::string& method() const { return method_; }
371 void set_method(const std::string& method);
373 // Determines the new method of the request afer following a redirect.
374 // |method| is the method used to arrive at the redirect,
375 // |http_status_code| is the status code associated with the redirect.
376 static std::string ComputeMethodForRedirect(const std::string& method,
377 int http_status_code);
379 // The referrer URL for the request. This header may actually be suppressed
380 // from the underlying network request for security reasons (e.g., a HTTPS
381 // URL will not be sent as the referrer for a HTTP request). The referrer
382 // may only be changed before Start() is called.
383 const std::string& referrer() const { return referrer_; }
384 // Referrer is sanitized to remove URL fragment, user name and password.
385 void SetReferrer(const std::string& referrer);
387 // The referrer policy to apply when updating the referrer during redirects.
388 // The referrer policy may only be changed before Start() is called.
389 void set_referrer_policy(ReferrerPolicy referrer_policy);
391 // Sets the delegate of the request. This value may be changed at any time,
392 // and it is permissible for it to be null.
393 void set_delegate(Delegate* delegate);
395 // Indicates that the request body should be sent using chunked transfer
396 // encoding. This method may only be called before Start() is called.
397 void EnableChunkedUpload();
399 // Appends the given bytes to the request's upload data to be sent
400 // immediately via chunked transfer encoding. When all data has been sent,
401 // call MarkEndOfChunks() to indicate the end of upload data.
403 // This method may be called only after calling EnableChunkedUpload().
404 void AppendChunkToUpload(const char* bytes,
408 // Sets the upload data.
409 void set_upload(scoped_ptr<UploadDataStream> upload);
411 // Gets the upload data.
412 const UploadDataStream* get_upload() const;
414 // Returns true if the request has a non-empty message body to upload.
415 bool has_upload() const;
417 // Set an extra request header by ID or name, or remove one by name. These
418 // methods may only be called before Start() is called, or before a new
419 // redirect in the request chain.
420 void SetExtraRequestHeaderById(int header_id, const std::string& value,
422 void SetExtraRequestHeaderByName(const std::string& name,
423 const std::string& value, bool overwrite);
424 void RemoveRequestHeaderByName(const std::string& name);
426 // Sets all extra request headers. Any extra request headers set by other
427 // methods are overwritten by this method. This method may only be called
428 // before Start() is called. It is an error to call it later.
429 void SetExtraRequestHeaders(const HttpRequestHeaders& headers);
431 const HttpRequestHeaders& extra_request_headers() const {
432 return extra_request_headers_;
435 // Gets the full request headers sent to the server.
437 // Return true and overwrites headers if it can get the request headers;
438 // otherwise, returns false and does not modify headers. (Always returns
439 // false for request types that don't have headers, like file requests.)
441 // This is guaranteed to succeed if:
443 // 1. A redirect or auth callback is currently running. Once it ends, the
444 // headers may become unavailable as a new request with the new address
445 // or credentials is made.
447 // 2. The OnResponseStarted callback is currently running or has run.
448 bool GetFullRequestHeaders(HttpRequestHeaders* headers) const;
450 // Returns the current load state for the request. |param| is an optional
451 // parameter describing details related to the load state. Not all load states
453 LoadStateWithParam GetLoadState() const;
455 // Returns a partial representation of the request's state as a value, for
456 // debugging. Caller takes ownership of returned value.
457 base::Value* GetStateAsValue() const;
459 // Logs information about the delegate currently blocking the request.
460 // The delegate info must be cleared by sending NULL before resuming a
461 // request. |delegate_info| will be copied as needed. |delegate_info_usage|
462 // is used to indicate whether the value should be returned in the param field
463 // of GetLoadState. |delegate_info_usage_| is ignored when |delegate_info| is
465 void SetDelegateInfo(const char* delegate_info,
466 DelegateInfoUsage delegate_info_usage);
468 // Returns the current upload progress in bytes. When the upload data is
469 // chunked, size is set to zero, but position will not be.
470 UploadProgress GetUploadProgress() const;
472 // Get response header(s) by ID or name. These methods may only be called
473 // once the delegate's OnResponseStarted method has been called. Headers
474 // that appear more than once in the response are coalesced, with values
475 // separated by commas (per RFC 2616). This will not work with cookies since
476 // comma can be used in cookie values.
477 // TODO(darin): add API to enumerate response headers.
478 void GetResponseHeaderById(int header_id, std::string* value);
479 void GetResponseHeaderByName(const std::string& name, std::string* value);
481 // Get all response headers, \n-delimited and \n\0-terminated. This includes
482 // the response status line. Restrictions on GetResponseHeaders apply.
483 void GetAllResponseHeaders(std::string* headers);
485 // The time when |this| was constructed.
486 base::TimeTicks creation_time() const { return creation_time_; }
488 // The time at which the returned response was requested. For cached
489 // responses, this is the last time the cache entry was validated.
490 const base::Time& request_time() const {
491 return response_info_.request_time;
494 // The time at which the returned response was generated. For cached
495 // responses, this is the last time the cache entry was validated.
496 const base::Time& response_time() const {
497 return response_info_.response_time;
500 // Indicate if this response was fetched from disk cache.
501 bool was_cached() const { return response_info_.was_cached; }
503 // Returns true if the URLRequest was delivered through a proxy.
504 bool was_fetched_via_proxy() const {
505 return response_info_.was_fetched_via_proxy;
508 // Returns the host and port that the content was fetched from. See
509 // http_response_info.h for caveats relating to cached content.
510 HostPortPair GetSocketAddress() const;
512 // Get all response headers, as a HttpResponseHeaders object. See comments
513 // in HttpResponseHeaders class as to the format of the data.
514 HttpResponseHeaders* response_headers() const;
516 // Get the SSL connection info.
517 const SSLInfo& ssl_info() const {
518 return response_info_.ssl_info;
521 // Gets timing information related to the request. Events that have not yet
522 // occurred are left uninitialized. After a second request starts, due to
523 // a redirect or authentication, values will be reset.
525 // LoadTimingInfo only contains ConnectTiming information and socket IDs for
526 // non-cached HTTP responses.
527 void GetLoadTimingInfo(LoadTimingInfo* load_timing_info) const;
529 // Returns the cookie values included in the response, if the request is one
530 // that can have cookies. Returns true if the request is a cookie-bearing
531 // type, false otherwise. This method may only be called once the
532 // delegate's OnResponseStarted method has been called.
533 bool GetResponseCookies(ResponseCookies* cookies);
535 // Get the mime type. This method may only be called once the delegate's
536 // OnResponseStarted method has been called.
537 void GetMimeType(std::string* mime_type);
539 // Get the charset (character encoding). This method may only be called once
540 // the delegate's OnResponseStarted method has been called.
541 void GetCharset(std::string* charset);
543 // Returns the HTTP response code (e.g., 200, 404, and so on). This method
544 // may only be called once the delegate's OnResponseStarted method has been
545 // called. For non-HTTP requests, this method returns -1.
546 int GetResponseCode() const;
548 // Get the HTTP response info in its entirety.
549 const HttpResponseInfo& response_info() const { return response_info_; }
551 // Access the LOAD_* flags modifying this request (see load_flags.h).
552 int load_flags() const { return load_flags_; }
553 void set_load_flags(int flags) { load_flags_ = flags; }
555 // Returns true if the request is "pending" (i.e., if Start() has been called,
556 // and the response has not yet been called).
557 bool is_pending() const { return is_pending_; }
559 // Returns true if the request is in the process of redirecting to a new
560 // URL but has not yet initiated the new request.
561 bool is_redirecting() const { return is_redirecting_; }
563 // Returns the error status of the request.
564 const URLRequestStatus& status() const { return status_; }
566 // Returns a globally unique identifier for this request.
567 uint64 identifier() const { return identifier_; }
569 // This method is called to start the request. The delegate will receive
570 // a OnResponseStarted callback when the request is started.
573 // This method may be called at any time after Start() has been called to
574 // cancel the request. This method may be called many times, and it has
575 // no effect once the response has completed. It is guaranteed that no
576 // methods of the delegate will be called after the request has been
577 // cancelled, except that this may call the delegate's OnReadCompleted()
578 // during the call to Cancel itself.
581 // Cancels the request and sets the error to |error| (see net_error_list.h
583 void CancelWithError(int error);
585 // Cancels the request and sets the error to |error| (see net_error_list.h
586 // for values) and attaches |ssl_info| as the SSLInfo for that request. This
587 // is useful to attach a certificate and certificate error to a canceled
589 void CancelWithSSLError(int error, const SSLInfo& ssl_info);
591 // Read initiates an asynchronous read from the response, and must only
592 // be called after the OnResponseStarted callback is received with a
593 // successful status.
594 // If data is available, Read will return true, and the data and length will
595 // be returned immediately. If data is not available, Read returns false,
596 // and an asynchronous Read is initiated. The Read is finished when
597 // the caller receives the OnReadComplete callback. Unless the request was
598 // cancelled, OnReadComplete will always be called, even if the read failed.
600 // The buf parameter is a buffer to receive the data. If the operation
601 // completes asynchronously, the implementation will reference the buffer
602 // until OnReadComplete is called. The buffer must be at least max_bytes in
605 // The max_bytes parameter is the maximum number of bytes to read.
607 // The bytes_read parameter is an output parameter containing the
608 // the number of bytes read. A value of 0 indicates that there is no
609 // more data available to read from the stream.
611 // If a read error occurs, Read returns false and the request->status
612 // will be set to an error.
613 bool Read(IOBuffer* buf, int max_bytes, int* bytes_read);
615 // If this request is being cached by the HTTP cache, stop subsequent caching.
616 // Note that this method has no effect on other (simultaneous or not) requests
617 // for the same resource. The typical example is a request that results in
618 // the data being stored to disk (downloaded instead of rendered) so we don't
619 // want to store it twice.
622 // This method may be called to follow a redirect that was deferred in
623 // response to an OnReceivedRedirect call.
624 void FollowDeferredRedirect();
626 // One of the following two methods should be called in response to an
627 // OnAuthRequired() callback (and only then).
628 // SetAuth will reissue the request with the given credentials.
629 // CancelAuth will give up and display the error page.
630 void SetAuth(const AuthCredentials& credentials);
633 // This method can be called after the user selects a client certificate to
634 // instruct this URLRequest to continue with the request with the
635 // certificate. Pass NULL if the user doesn't have a client certificate.
636 void ContinueWithCertificate(X509Certificate* client_cert);
638 // This method can be called after some error notifications to instruct this
639 // URLRequest to ignore the current error and continue with the request. To
640 // cancel the request instead, call Cancel().
641 void ContinueDespiteLastError();
643 // Used to specify the context (cookie store, cache) for this request.
644 const URLRequestContext* context() const;
646 const BoundNetLog& net_log() const { return net_log_; }
648 // Returns the expected content size if available
649 int64 GetExpectedContentSize() const;
651 // Returns the priority level for this request.
652 RequestPriority priority() const { return priority_; }
654 // Sets the priority level for this request and any related jobs.
655 void SetPriority(RequestPriority priority);
657 // Returns true iff this request would be internally redirected to HTTPS
658 // due to HSTS. If so, |redirect_url| is rewritten to the new HTTPS URL.
659 bool GetHSTSRedirect(GURL* redirect_url) const;
661 // TODO(willchan): Undo this. Only temporarily public.
662 bool has_delegate() const { return delegate_ != NULL; }
664 // NOTE(willchan): This is just temporary for debugging
665 // http://crbug.com/90971.
666 // Allows to setting debug info into the URLRequest.
667 void set_stack_trace(const base::debug::StackTrace& stack_trace);
668 const base::debug::StackTrace* stack_trace() const;
670 void set_received_response_content_length(int64 received_content_length) {
671 received_response_content_length_ = received_content_length;
673 int64 received_response_content_length() {
674 return received_response_content_length_;
678 // Allow the URLRequestJob class to control the is_pending() flag.
679 void set_is_pending(bool value) { is_pending_ = value; }
681 // Allow the URLRequestJob class to set our status too
682 void set_status(const URLRequestStatus& value) { status_ = value; }
684 // Allow the URLRequestJob to redirect this request. Returns OK if
685 // successful, otherwise an error code is returned.
686 int Redirect(const GURL& location, int http_status_code);
688 // Called by URLRequestJob to allow interception when a redirect occurs.
689 void NotifyReceivedRedirect(const GURL& location, bool* defer_redirect);
691 // Allow an interceptor's URLRequestJob to restart this request.
692 // Should only be called if the original job has not started a response.
696 friend class URLRequestJob;
698 // Registers a new protocol handler for the given scheme. If the scheme is
699 // already handled, this will overwrite the given factory. To delete the
700 // protocol factory, use NULL for the factory BUT this WILL NOT put back
701 // any previously registered protocol factory. It will have returned
702 // the previously registered factory (or NULL if none is registered) when
703 // the scheme was first registered so that the caller can manually put it
706 // The scheme must be all-lowercase ASCII. See the ProtocolFactory
707 // declaration for its requirements.
709 // The registered protocol factory may return NULL, which will cause the
710 // regular "built-in" protocol factory to be used.
712 static ProtocolFactory* RegisterProtocolFactory(const std::string& scheme,
713 ProtocolFactory* factory);
715 // Registers or unregisters a network interception class.
716 static void RegisterRequestInterceptor(Interceptor* interceptor);
717 static void UnregisterRequestInterceptor(Interceptor* interceptor);
719 // Resumes or blocks a request paused by the NetworkDelegate::OnBeforeRequest
720 // handler. If |blocked| is true, the request is blocked and an error page is
721 // returned indicating so. This should only be called after Start is called
722 // and OnBeforeRequest returns true (signalling that the request should be
724 void BeforeRequestComplete(int error);
726 void StartJob(URLRequestJob* job);
728 // Restarting involves replacing the current job with a new one such as what
729 // happens when following a HTTP redirect.
730 void RestartWithJob(URLRequestJob* job);
731 void PrepareToRestart();
733 // Detaches the job from this request in preparation for this object going
734 // away or the job being replaced. The job will not call us back when it has
738 // Cancels the request and set the error and ssl info for this request to the
740 void DoCancel(int error, const SSLInfo& ssl_info);
742 // Called by the URLRequestJob when the headers are received, before any other
743 // method, to allow caching of load timing information.
744 void OnHeadersComplete();
746 // Notifies the network delegate that the request has been completed.
747 // This does not imply a successful completion. Also a canceled request is
748 // considered completed.
749 void NotifyRequestCompleted();
751 // Called by URLRequestJob to allow interception when the final response
753 void NotifyResponseStarted();
755 // These functions delegate to |delegate_| and may only be used if
756 // |delegate_| is not NULL. See URLRequest::Delegate for the meaning
757 // of these functions.
758 void NotifyAuthRequired(AuthChallengeInfo* auth_info);
759 void NotifyAuthRequiredComplete(NetworkDelegate::AuthRequiredResponse result);
760 void NotifyCertificateRequested(SSLCertRequestInfo* cert_request_info);
761 void NotifySSLCertificateError(const SSLInfo& ssl_info, bool fatal);
762 void NotifyReadCompleted(int bytes_read);
764 // These functions delegate to |network_delegate_| if it is not NULL.
765 // If |network_delegate_| is NULL, cookies can be used unless
766 // SetDefaultCookiePolicyToBlock() has been called.
767 bool CanGetCookies(const CookieList& cookie_list) const;
768 bool CanSetCookie(const std::string& cookie_line,
769 CookieOptions* options) const;
770 bool CanEnablePrivacyMode() const;
772 // Called just before calling a delegate that may block a request.
773 void OnCallToDelegate();
774 // Called when the delegate lets a request continue. Also called on
776 void OnCallToDelegateComplete();
778 // Contextual information used for this request. Cannot be NULL. This contains
779 // most of the dependencies which are shared between requests (disk cache,
780 // cookie store, socket pool, etc.)
781 const URLRequestContext* context_;
783 NetworkDelegate* network_delegate_;
785 // Tracks the time spent in various load states throughout this request.
786 BoundNetLog net_log_;
788 scoped_refptr<URLRequestJob> job_;
789 scoped_ptr<UploadDataStream> upload_data_stream_;
790 std::vector<GURL> url_chain_;
791 GURL first_party_for_cookies_;
792 GURL delegate_redirect_url_;
793 std::string method_; // "GET", "POST", etc. Should be all uppercase.
794 std::string referrer_;
795 ReferrerPolicy referrer_policy_;
796 HttpRequestHeaders extra_request_headers_;
797 int load_flags_; // Flags indicating the request type for the load;
798 // expected values are LOAD_* enums above.
800 // Never access methods of the |delegate_| directly. Always use the
801 // Notify... methods for this.
804 // Current error status of the job. When no error has been encountered, this
805 // will be SUCCESS. If multiple errors have been encountered, this will be
806 // the first non-SUCCESS status seen.
807 URLRequestStatus status_;
809 // The HTTP response info, lazily initialized.
810 HttpResponseInfo response_info_;
812 // Tells us whether the job is outstanding. This is true from the time
813 // Start() is called to the time we dispatch RequestComplete and indicates
814 // whether the job is active.
817 // Indicates if the request is in the process of redirecting to a new
818 // location. It is true from the time the headers complete until a
819 // new request begins.
820 bool is_redirecting_;
822 // Number of times we're willing to redirect. Used to guard against
823 // infinite redirects.
826 // Cached value for use after we've orphaned the job handling the
827 // first transaction in a request involving redirects.
828 UploadProgress final_upload_progress_;
830 // The priority level for this request. Objects like ClientSocketPool use
831 // this to determine which URLRequest to allocate sockets to first.
832 RequestPriority priority_;
834 // TODO(battre): The only consumer of the identifier_ is currently the
835 // web request API. We need to match identifiers of requests between the
836 // web request API and the web navigation API. As the URLRequest does not
837 // exist when the web navigation API is triggered, the tracking probably
838 // needs to be done outside of the URLRequest anyway. Therefore, this
839 // identifier should be deleted here. http://crbug.com/89321
840 // A globally unique identifier for this request.
841 const uint64 identifier_;
843 // True if this request is currently calling a delegate, or is blocked waiting
844 // for the URL request or network delegate to resume it.
845 bool calling_delegate_;
847 // An optional parameter that provides additional information about the
848 // delegate |this| is currently blocked on.
849 std::string delegate_info_;
850 DelegateInfoUsage delegate_info_usage_;
852 base::debug::LeakTracker<URLRequest> leak_tracker_;
854 // Callback passed to the network delegate to notify us when a blocked request
855 // is ready to be resumed or canceled.
856 CompletionCallback before_request_callback_;
858 // Safe-guard to ensure that we do not send multiple "I am completed"
859 // messages to network delegate.
860 // TODO(battre): Remove this. http://crbug.com/89049
861 bool has_notified_completion_;
863 // Authentication data used by the NetworkDelegate for this request,
864 // if one is present. |auth_credentials_| may be filled in when calling
865 // |NotifyAuthRequired| on the NetworkDelegate. |auth_info_| holds
866 // the authentication challenge being handled by |NotifyAuthRequired|.
867 AuthCredentials auth_credentials_;
868 scoped_refptr<AuthChallengeInfo> auth_info_;
870 int64 received_response_content_length_;
872 base::TimeTicks creation_time_;
874 // Timing information for the most recent request. Its start times are
875 // populated during Start(), and the rest are populated in OnResponseReceived.
876 LoadTimingInfo load_timing_info_;
878 scoped_ptr<const base::debug::StackTrace> stack_trace_;
880 DISALLOW_COPY_AND_ASSIGN(URLRequest);
885 #endif // NET_URL_REQUEST_URL_REQUEST_H_