Merge r21417 to 172....

net/url_request/url_request_job.cc

 // Copyright (c) 2006-2008 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),
-      filter_input_byte_count_(0) {
+      filter_input_byte_count_(0) ,
+      deferred_redirect_status_code_(-1) {
   load_flags_ = request_->load_flags();
   is_profiling_ = request->enable_profiling();
   if (is_profiling()) {
     metrics_.reset(new URLRequestJobMetrics());
     metrics_->start_time_ = TimeTicks::Now();
   }
   g_url_request_job_tracker.AddNewJob(this);
 }
 
 URLRequestJob::~URLRequestJob() {
@@ skipping 42 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 58 matching lines @@
   if (!filter_->stream_data_len() && !is_done()) {
     net::IOBuffer* stream_buffer = filter_->stream_buffer();
     int stream_buffer_size = filter_->stream_buffer_size();
     rv = ReadRawData(stream_buffer, stream_buffer_size, bytes_read);
     if (rv && *bytes_read > 0)
       RecordBytesRead(*bytes_read);
   }
   return rv;
 }
 
+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));
+}
+
 void URLRequestJob::FilteredDataRead(int bytes_read) {
   DCHECK(filter_.get());  // don't add data if there is no filter
   filter_->FlushStreamBuffer(bytes_read);
 }
 
 bool URLRequestJob::ReadFilteredData(int *bytes_read) {
   DCHECK(filter_.get());  // don't add data if there is no filter
   DCHECK(read_buffer_ != NULL);  // we need to have a buffer to fill
   DCHECK(read_buffer_len_ > 0);  // sanity check
   DCHECK(read_buffer_len_ < 1000000);  // sanity check
@@ skipping 127 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_->delegate()->OnReceivedRedirect(request_, new_location);
+    bool defer_redirect = false;
+    request_->ReceivedRedirect(new_location, &defer_redirect);
 
     // Ensure that the request wasn't destroyed in OnReceivedRedirect
     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 131 matching lines @@
   if (!done_) {
     NotifyDone(URLRequestStatus(URLRequestStatus::CANCELED,
                                 net::ERR_ABORTED));
   }
 }
 
 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;
   g_url_request_job_tracker.OnBytesRead(this, bytes_read);
 }
 
 const URLRequestStatus URLRequestJob::GetStatus() {
   if (request_)
     return request_->status();
   // If the request is gone, we must be cancelled.
   return URLRequestStatus(URLRequestStatus::CANCELED,
                           net::ERR_ABORTED);
 }
 
 void URLRequestJob::SetStatus(const URLRequestStatus &status) {
   if (request_)
     request_->set_status(status);
 }