Add support to URLRequest for deferring redirects....

net/url_request/url_request_job.cc

 // 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.
 
 #include "net/url_request/url_request_job.h"
 
 #include "base/message_loop.h"
 #include "base/string_util.h"
-#include "googleurl/src/gurl.h"
 #include "net/base/auth.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_job_metrics.h"
 #include "net/url_request/url_request_job_tracker.h"
 
 using base::Time;
 using base::TimeTicks;
 
 // Buffer size allocated when de-compressing data.
 // static
 const int URLRequestJob::kFilterBufSize = 32 * 1024;
 
 URLRequestJob::URLRequestJob(URLRequest* request)
     : request_(request),
       done_(false),
       filter_needs_more_output_space_(false),
       read_buffer_(NULL),
       read_buffer_len_(0),
       has_handled_response_(false),
       expected_content_size_(-1),
+      deferred_redirect_status_code_(-1),
       packet_timing_enabled_(false),
       filter_input_byte_count_(0),
       bytes_observed_in_packets_(0),
       max_packets_timed_(0),
       observed_packet_count_(0) {
   load_flags_ = request_->load_flags();
   is_profiling_ = request->enable_profiling();
   if (is_profiling()) {
     metrics_.reset(new URLRequestJobMetrics());
     metrics_->start_time_ = TimeTicks::Now();
@@ skipping 53 matching lines @@
   NOTREACHED();
 }
 
 void URLRequestJob::ContinueDespiteLastError() {
   // Implementations should know how to recover from errors they generate.
   // If this code was reached, we are trying to recover from an error that
   // we don't know how to recover from.
   NOTREACHED();
 }
 
+void URLRequestJob::FollowDeferredRedirect() {
+  DCHECK(deferred_redirect_status_code_ != -1);
+  // NOTE: deferred_redirect_url_ may be invalid, and attempting to redirect to
+  // such an URL will fail inside FollowRedirect.  The DCHECK above asserts
+  // that we called OnReceivedRedirect.
+
+  FollowRedirect(deferred_redirect_url_, deferred_redirect_status_code_);
+  deferred_redirect_url_ = GURL();
+  deferred_redirect_status_code_ = -1;
+}
+
 int64 URLRequestJob::GetByteReadCount() const {
   return filter_input_byte_count_;
 }
 
 bool URLRequestJob::GetURL(GURL* gurl) const {
   if (!request_)
     return false;
   *gurl = request_->url();
   return true;
 }
@@ skipping 199 matching lines @@
   request_->response_info_.response_time = Time::Now();
   GetResponseInfo(&request_->response_info_);
 
   // When notifying the delegate, the delegate can release the request
   // (and thus release 'this').  After calling to the delgate, we must
   // check the request pointer to see if it still exists, and return
   // immediately if it has been destroyed.  self_preservation ensures our
   // survival until we can get out of this method.
   scoped_refptr<URLRequestJob> self_preservation = this;
 
+  GURL new_location;
   int http_status_code;
-  GURL new_location;
   if (IsRedirectResponse(&new_location, &http_status_code)) {
     const GURL& url = request_->url();
 
     // Move the reference fragment of the old location to the new one if the
     // new one has none. This duplicates mozilla's behavior.
     if (url.is_valid() && url.has_ref() && !new_location.has_ref()) {
       GURL::Replacements replacements;
       // Reference the |ref| directly out of the original URL to avoid a
       // malloc.
       replacements.SetRef(url.spec().data(),
                           url.parsed_for_possibly_invalid_spec().ref);
       new_location = new_location.ReplaceComponents(replacements);
     }
 
-    // Toggle this flag to true so the consumer can access response headers.
-    // Then toggle it back if we choose to follow the redirect.
-    has_handled_response_ = true;
-    request_->ReceivedRedirect(new_location);
+    bool defer_redirect = false;
+    request_->ReceivedRedirect(new_location, &defer_redirect);
 
     // Ensure that the request wasn't detached or destroyed in ReceivedRedirect
     if (!request_ || !request_->delegate())
       return;
 
-    // If we were not cancelled, then follow the redirect.
+    // If we were not cancelled, then maybe follow the redirect.
     if (request_->status().is_success()) {
-      has_handled_response_ = false;
-      FollowRedirect(new_location, http_status_code);
+      if (defer_redirect) {
+        deferred_redirect_url_ = new_location;
+        deferred_redirect_status_code_ = http_status_code;
+      } else {
+        FollowRedirect(new_location, http_status_code);
+      }
       return;
     }
   } else if (NeedsAuth()) {
     scoped_refptr<net::AuthChallengeInfo> auth_info;
     GetAuthChallengeInfo(&auth_info);
     // Need to check for a NULL auth_info because the server may have failed
     // to send a challenge with the 401 response.
     if (auth_info) {
       request_->delegate()->OnAuthRequired(request_, auth_info);
       // Wait for SetAuth or CancelAuth to be called.
@@ skipping 136 matching lines @@
 void URLRequestJob::NotifyRestartRequired() {
   DCHECK(!has_handled_response_);
   if (GetStatus().status() != URLRequestStatus::CANCELED)
     request_->Restart();
 }
 
 bool URLRequestJob::FilterHasData() {
     return filter_.get() && filter_->stream_data_len();
 }
 
-void URLRequestJob::FollowRedirect(const GURL& location,
-                                   int http_status_code) {
-  g_url_request_job_tracker.OnJobRedirect(this, location, http_status_code);
-  Kill();
-  // Kill could have notified the Delegate and destroyed the request.
-  if (!request_)
-    return;
-
-  int rv = request_->Redirect(location, http_status_code);
-  if (rv != net::OK)
-    NotifyStartError(URLRequestStatus(URLRequestStatus::FAILED, rv));
-}
-
 void URLRequestJob::RecordBytesRead(int bytes_read) {
   if (is_profiling()) {
     ++(metrics_->number_of_read_IO_);
     metrics_->total_bytes_read_ += bytes_read;
   }
   filter_input_byte_count_ += bytes_read;
   UpdatePacketReadTimes();  // Facilitate stats recording if it is active.
   g_url_request_job_tracker.OnBytesRead(this, bytes_read);
 }
 
@@ skipping 170 matching lines @@
                                   packet_times_[4] - packet_times_[3],
                                   base::TimeDelta::FromMilliseconds(1),
                                   base::TimeDelta::FromSeconds(10), 100);
       return;
     }
     default:
       NOTREACHED();
       return;
   }
 }
+
+void URLRequestJob::FollowRedirect(const GURL& location, int http_status_code) {
+  g_url_request_job_tracker.OnJobRedirect(this, location, http_status_code);
+
+  int rv = request_->Redirect(location, http_status_code);
+  if (rv != net::OK)
+    NotifyDone(URLRequestStatus(URLRequestStatus::FAILED, rv));
+}