Add support to URLRequest for deferring redirects....

net/url_request/url_request.h

 // Copyright (c) 2006-2009 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 <map>
 #include <string>
 #include <vector>
@@ skipping 117 matching lines @@
    public:
     virtual ~Delegate() {}
 
     // 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.
     //
     // 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 request is not canceled the redirect will be followed and the
-    // request's URL will be changed to the 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 default value for |*defer_redirect| is false, so that consumers do

[wtc, 2009/07/23 00:30:12]

I suggest rewriting this sentence as follows:

  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.

I also considered suggesting that this method returns
bool to indicate whether the redirect is deferred, but
I see that all the Delegate methods return void.  If
it's okay for a Delegate method to return non-void,
I think returning bool or an enum would be more clear.

[darin (slow to review), 2009/07/23 01:27:29]

Done.
I originally considered returning a bool, but I decided against it since it was
not so clear if returning false meant canceling the redirect or deferring the
redirect.  An enum would also make that clear, but an out parameter also makes
things more clear.

I'll think on the enum idea a bit more.

[wtc, 2009/07/23 02:37:48]

I agree.

+    // not need to set it if they are happy with the default behavior.
     virtual void OnReceivedRedirect(URLRequest* request,
-                                    const GURL& new_url) = 0;
+                                    const GURL& new_url,
+                                    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,
                                 net::AuthChallengeInfo* auth_info) {
       request->CancelAuth();
     }
@@ skipping 277 matching lines @@
   // The max_bytes parameter is the maximum number of bytes to read.
   //
   // The bytes_read parameter is an output parameter containing the
   // the number of bytes read.  A value of 0 indicates that there is no
   // more data available to read from the stream.
   //
   // If a read error occurs, Read returns false and the request->status
   // will be set to an error.
   bool Read(net::IOBuffer* buf, int max_bytes, int *bytes_read);
 
+  // This method may be called to follow a redirect that was deferred in
+  // response to an OnReceivedRedirect call.
+  void FollowDeferredRedirect();
+
   // One of the following two methods should be called in response to an
   // OnAuthRequired() callback (and only then).
   // SetAuth will reissue the request with the given credentials.
   // CancelAuth will give up and display the error page.
   void SetAuth(const std::wstring& username, const std::wstring& password);
   void CancelAuth();
 
   // This method can be called after the user selects a client certificate to
   // instruct this URLRequest to continue with the request with the
   // certificate.  Pass NULL if the user doesn't have a client certificate.
@@ skipping 38 matching lines @@
   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; }
 
   // Allow the URLRequestJob to redirect this request.  Returns net::OK if
   // successful, otherwise an error code is returned.
   int Redirect(const GURL& location, int http_status_code);
 
   // Called by URLRequestJob to allow interception when a redirect occurs.
-  void ReceivedRedirect(const GURL& location);
+  void ReceivedRedirect(const GURL& location, bool* defer_redirect);
 
   // Called by URLRequestJob to allow interception when the final response
   // occurs.
   void ResponseStarted();
 
   // Allow an interceptor's URLRequestJob to restart this request.
   // Should only be called if the original job has not started a resposne.
   void Restart();
 
  private:
@@ skipping 89 matching lines @@
 #define URLREQUEST_COUNT_DTOR() url_request_metrics.object_count--
 
 #else  // disable leak checking in release builds...
 
 #define URLREQUEST_COUNT_CTOR()
 #define URLREQUEST_COUNT_DTOR()
 
 #endif  // #ifndef NDEBUG
 
 #endif  // NET_URL_REQUEST_URL_REQUEST_H_