Plumb redirect info out of net, through content, and into child processes.

net/url_request/url_request.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef NET_URL_REQUEST_URL_REQUEST_H_
 #define NET_URL_REQUEST_URL_REQUEST_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 33 matching lines @@
 namespace content {
 class AppCacheInterceptor;
 }
 
 namespace net {
 
 class CookieOptions;
 class HostPortPair;
 class IOBuffer;
 struct LoadTimingInfo;
+struct RedirectInfo;
 class SSLCertRequestInfo;
 class SSLInfo;
 class UploadDataStream;
 class URLRequestContext;
 class URLRequestJob;
 class X509Certificate;
 
 // This stores the values of the Set-Cookie headers received during the request.
 // Each item in the vector corresponds to a Set-Cookie: line received,
 // excluding the "Set-Cookie:" part.
@@ skipping 37 matching lines @@
   // behavior corresponds to NEVER_CLEAR_REFERRER. Embedders will want to use
   // NEVER_CLEAR_REFERRER when implementing the meta-referrer support
   // (http://wiki.whatwg.org/wiki/Meta_referrer) and sending requests with a
   // non-default referrer policy. Only the default referrer policy requires
   // the referrer to be cleared on transitions from HTTPS to HTTP.
   enum ReferrerPolicy {
     CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE,
     NEVER_CLEAR_REFERRER,
   };
 
+  // First-party URL redirect policy: During server redirects, the first-party
+  // URL for cookies normally doesn't change. However, if the request is a
+  // top-level first-party request, the first-party URL should be updated to the
+  // URL on every redirect.
+  enum FirstPartyURLPolicy {
+    NEVER_CHANGE_FIRST_PARTY_URL,
+    UPDATE_FIRST_PARTY_URL_ON_REDIRECT,
+  };
+
   // This class handles network interception.  Use with
   // (Un)RegisterRequestInterceptor.
   class NET_EXPORT Interceptor {
    public:
     virtual ~Interceptor() {}
 
     // Called for every request made.  Should return a new job to handle the
     // request if it should be intercepted, or NULL to allow the request to
     // be handled in the normal manner.
     virtual URLRequestJob* MaybeIntercept(
@@ skipping 57 matching lines @@
   //    - OnReadCompleted* (zero or more calls until all data is read)
   //
   // Read() must be called at least once. Read() returns true when it completed
   // immediately, and false if an IO is pending or if there is an error.  When
   // Read() returns false, the caller can check the Request's status() to see
   // if an error occurred, or if the IO is just pending.  When Read() returns
   // true with zero bytes read, it indicates the end of the response.
   //
   class NET_EXPORT Delegate {
    public:
-    // Called upon a server-initiated redirect.  The delegate may call the
-    // request's Cancel method to prevent the redirect from being followed.
-    // Since there may be multiple chained redirects, there may also be more
-    // than one redirect call.
+    // Called upon receiving a redirect.  The delegate may call the request's
+    // Cancel method to prevent the redirect from being followed.  Since there
+    // may be multiple chained redirects, there may also be more than one
+    // redirect call.
     //
     // When this function is called, the request will still contain the
     // original URL, the destination of the redirect is provided in 'new_url'.
     // If the delegate does not cancel the request and |*defer_redirect| is
     // false, then the redirect will be followed, and the request's URL will be
     // changed to the new URL.  Otherwise if the delegate does not cancel the
     // request and |*defer_redirect| is true, then the redirect will be
     // followed once FollowDeferredRedirect is called on the URLRequest.
     //
     // The caller must set |*defer_redirect| to false, so that delegates do not
     // need to set it if they are happy with the default behavior of not
     // deferring redirect.
     virtual void OnReceivedRedirect(URLRequest* request,
-                                    const GURL& new_url,
+                                    const RedirectInfo& redirect_info,
                                     bool* defer_redirect);
 
     // Called when we receive an authentication failure.  The delegate should
     // call request->SetAuth() with the user's credentials once it obtains them,
     // or request->CancelAuth() to cancel the login and display the error page.
     // When it does so, the request will be reissued, restarting the sequence
     // of On* callbacks.
     virtual void OnAuthRequired(URLRequest* request,
                                 AuthChallengeInfo* auth_info);
 
@@ skipping 101 matching lines @@
   //
   //          For example, if a top-level navigation is redirected, the
   //          first-party for cookies will be the URL of the first URL in the
   //          redirect chain throughout the whole redirect. If it was used for
   //          a security check, an attacker might try to get around this check
   //          by starting from some page that redirects to the
   //          host-to-be-attacked.
   const GURL& first_party_for_cookies() const {
     return first_party_for_cookies_;
   }
-  // This method may be called before Start() or FollowDeferredRedirect() is
-  // called.
+  // This method may only be called before Start().
   void set_first_party_for_cookies(const GURL& first_party_for_cookies);
 
+  // The first-party URL policy to apply when updating the first party URL
+  // during redirects. The first-party URL policy may only be changed before
+  // Start() is called.
+  FirstPartyURLPolicy first_party_url_policy() const {
+    return first_party_url_policy_;
+  }
+  void set_first_party_url_policy(FirstPartyURLPolicy first_party_url_policy);
+
   // The request method, as an uppercase string.  "GET" is the default value.
   // The request method may only be changed before Start() is called and
   // should only be assigned an uppercase value.
   const std::string& method() const { return method_; }
   void set_method(const std::string& method);
 
   // Determines the new method of the request afer following a redirect.
   // |method| is the method used to arrive at the redirect,
   // |http_status_code| is the status code associated with the redirect.
   static std::string ComputeMethodForRedirect(const std::string& method,
                                               int http_status_code);
 
   // The referrer URL for the request.  This header may actually be suppressed
   // from the underlying network request for security reasons (e.g., a HTTPS
   // URL will not be sent as the referrer for a HTTP request).  The referrer
   // may only be changed before Start() is called.
   const std::string& referrer() const { return referrer_; }
   // Referrer is sanitized to remove URL fragment, user name and password.
   void SetReferrer(const std::string& referrer);
 
   // The referrer policy to apply when updating the referrer during redirects.
   // The referrer policy may only be changed before Start() is called.
+  ReferrerPolicy referrer_policy() const { return referrer_policy_; }
   void set_referrer_policy(ReferrerPolicy referrer_policy);
 
   // Sets the delegate of the request.  This value may be changed at any time,
   // and it is permissible for it to be null.
   void set_delegate(Delegate* delegate);
 
   // Indicates that the request body should be sent using chunked transfer
   // encoding. This method may only be called before Start() is called.
   void EnableChunkedUpload();
 
@@ skipping 312 matching lines @@
   // Allow the URLRequestJob class to control the is_pending() flag.
   void set_is_pending(bool value) { is_pending_ = value; }
 
   // Allow the URLRequestJob class to set our status too
   void set_status(const URLRequestStatus& value) { status_ = value; }
 
   CookieStore* cookie_store() const { return cookie_store_; }
 
   // Allow the URLRequestJob to redirect this request.  Returns OK if
   // successful, otherwise an error code is returned.
-  int Redirect(const GURL& location, int http_status_code);
+  int Redirect(const RedirectInfo& redirect_info);
 
   // Called by URLRequestJob to allow interception when a redirect occurs.
-  void NotifyReceivedRedirect(const GURL& location, bool* defer_redirect);
+  void NotifyReceivedRedirect(const RedirectInfo& redirect_info,
+                              bool* defer_redirect);
 
   // Called by URLRequestHttpJob (note, only HTTP(S) jobs will call this) to
   // allow deferral of network initialization.
   void NotifyBeforeNetworkStart(bool* defer);
 
   // Allow an interceptor's URLRequestJob to restart this request.
   // Should only be called if the original job has not started a response.
   void Restart();
 
  private:
@@ skipping 82 matching lines @@
   BoundNetLog net_log_;
 
   scoped_refptr<URLRequestJob> job_;
   scoped_ptr<UploadDataStream> upload_data_stream_;
   std::vector<GURL> url_chain_;
   GURL first_party_for_cookies_;
   GURL delegate_redirect_url_;
   std::string method_;  // "GET", "POST", etc. Should be all uppercase.
   std::string referrer_;
   ReferrerPolicy referrer_policy_;
+  FirstPartyURLPolicy first_party_url_policy_;
   HttpRequestHeaders extra_request_headers_;
   int load_flags_;  // Flags indicating the request type for the load;
                     // expected values are LOAD_* enums above.
 
   // Never access methods of the |delegate_| directly. Always use the
   // Notify... methods for this.
   Delegate* delegate_;
 
   // Current error status of the job. When no error has been encountered, this
   // will be SUCCESS. If multiple errors have been encountered, this will be
@@ skipping 80 matching lines @@
 
   // The proxy server used for this request, if any.
   HostPortPair proxy_server_;
 
   DISALLOW_COPY_AND_ASSIGN(URLRequest);
 };
 
 }  // namespace net
 
 #endif  // NET_URL_REQUEST_URL_REQUEST_H_