Add support to URLRequest for deferring redirects....

net/url_request/url_request_job.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_JOB_H_
 #define NET_URL_REQUEST_URL_REQUEST_JOB_H_
 
 #include <string>
 #include <vector>
 
 #include "base/ref_counted.h"
 #include "base/scoped_ptr.h"
 #include "base/time.h"
+#include "googleurl/src/gurl.h"
 #include "net/base/filter.h"
 #include "net/base/load_states.h"
 
 namespace net {
 class AuthChallengeInfo;
 class HttpResponseInfo;
 class IOBuffer;
 class UploadData;
 class X509Certificate;
 }
 
-class GURL;
 class URLRequest;
 class URLRequestStatus;
 class URLRequestJobMetrics;
 
 // The URLRequestJob is using RefCounterThreadSafe because some sub classes
 // can be destroyed on multiple threads. This is the case of the
 // UrlRequestFileJob.
 class URLRequestJob : public base::RefCountedThreadSafe<URLRequestJob>,
                       public FilterContext {
  public:
@@ skipping 139 matching lines @@
                        const std::wstring& password);
 
   // Display the error page without asking for credentials again.
   virtual void CancelAuth();
 
   virtual void ContinueWithCertificate(net::X509Certificate* client_cert);
 
   // Continue processing the request ignoring the last error.
   virtual void ContinueDespiteLastError();
 
+  void FollowDeferredRedirect();
+
   // Returns true if the Job is done producing response data and has called
   // NotifyDone on the request.
   bool is_done() const { return done_; }
 
   // Returns true if the job is doing performance profiling
   bool is_profiling() const { return is_profiling_; }
 
   // Retrieve the performance measurement of the job. The data is encapsulated
   // with a URLRequestJobMetrics object. The caller owns this object from now
   // on.
@@ skipping 101 matching lines @@
 
  private:
   // Size of filter input buffers used by this class.
   static const int kFilterBufSize;
 
   // When data filtering is enabled, this function is used to read data
   // for the filter.  Returns true if raw data was read.  Returns false if
   // an error occurred (or we are waiting for IO to complete).
   bool ReadRawDataForFilter(int *bytes_read);
 
-  // Called in response to a redirect that was not canceled to follow the
-  // redirect. The current job will be replaced with a new job loading the
-  // given redirect destination.
-  void FollowRedirect(const GURL& location, int http_status_code);
-
   // Updates the profiling info and notifies observers that bytes_read bytes
   // have been read.
   void RecordBytesRead(int bytes_read);
 
   // Called to query whether there is data available in the filter to be read
   // out.
   bool FilterHasData();
 
   // Record packet arrival times for possible use in histograms.
   void UpdatePacketReadTimes();
 
+  // Called in response to a redirect that was not canceled to follow the
+  // redirect. The current job will be replaced with a new job loading the
+  // given redirect destination.
+  void FollowRedirect(const GURL& location, int http_status_code);

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

Nit: move this method back to its original location in this
header and in the .cc file to minimize the diffs.

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

Done.

+
   // Indicates that the job is done producing data, either it has completed
   // all the data or an error has been encountered. Set exclusively by
   // NotifyDone so that it is kept in sync with the request.
   bool done_;
 
   // Cache the load flags from request_ because it might go away.
   int load_flags_;
 
   // The data stream filter which is enabled on demand.
   scoped_ptr<Filter> filter_;
 
   // If the filter filled its output buffer, then there is a change that it
   // still has internal data to emit, and this flag is set.
   bool filter_needs_more_output_space_;
 
   // When we filter data, we receive data into the filter buffers.  After
   // processing the filtered data, we return the data in the caller's buffer.
   // While the async IO is in progress, we save the user buffer here, and
   // when the IO completes, we fill this in.
   net::IOBuffer *read_buffer_;
   int read_buffer_len_;
 
   // Used by HandleResponseIfNecessary to track whether we've sent the
   // OnResponseStarted callback and potentially redirect callbacks as well.
   bool has_handled_response_;
 
   // Expected content size
   int64 expected_content_size_;
 
+  // Set when a redirect is deferred.
+  GURL deferred_redirect_url_;
+  int deferred_redirect_status_code_;
+
   //----------------------------------------------------------------------------
   // Data used for statistics gathering in some instances.  This data is only
   // used for histograms etc., and is not required.  It is optionally gathered
   // based on the settings of several control variables.
 
   // Enable recording of packet arrival times for histogramming.
   bool packet_timing_enabled_;
 
   // TODO(jar): improve the quality of the gathered info by gathering most times
   // at a lower point in the network stack, assuring we have actual packet
@@ skipping 26 matching lines @@
   base::Time final_packet_time_;
 
   // The count of the number of packets, some of which may not have been timed.
   // We're ignoring overflow, as 1430 x 2^31 is a LOT of bytes.
   int observed_packet_count_;
 
   DISALLOW_COPY_AND_ASSIGN(URLRequestJob);
 };
 
 #endif  // NET_URL_REQUEST_URL_REQUEST_JOB_H_