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

net/url_request/url_request_job.cc

 // 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.
 
 #include "net/url_request/url_request_job.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/message_loop/message_loop.h"
 #include "base/power_monitor/power_monitor.h"
@@ skipping 15 matching lines @@
                              NetworkDelegate* network_delegate)
     : request_(request),
       done_(false),
       prefilter_bytes_read_(0),
       postfilter_bytes_read_(0),
       filter_input_byte_count_(0),
       filter_needs_more_output_space_(false),
       filtered_read_buffer_len_(0),
       has_handled_response_(false),
       expected_content_size_(-1),
-      deferred_redirect_status_code_(-1),
       network_delegate_(network_delegate),
       weak_factory_(this) {
   base::PowerMonitor* power_monitor = base::PowerMonitor::Get();
   if (power_monitor)
     power_monitor->AddObserver(this);
 }
 
 void URLRequestJob::SetUpload(UploadDataStream* upload) {
 }
 
@@ skipping 149 matching lines @@
 }
 
 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);
+  DCHECK_NE(-1, deferred_redirect_info_.status_code);
 
-  // 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.
+  // NOTE: deferred_redirect_info_ may be invalid, and attempting to follow it
+  // will fail inside FollowRedirect.  The DCHECK above asserts that we called
+  // OnReceivedRedirect.
 
   // It is also possible that FollowRedirect will drop the last reference to
   // this job, so we need to reset our members before calling it.
 
-  GURL redirect_url = deferred_redirect_url_;
-  int redirect_status_code = deferred_redirect_status_code_;
-
-  deferred_redirect_url_ = GURL();
-  deferred_redirect_status_code_ = -1;
-
-  FollowRedirect(redirect_url, redirect_status_code);
+  RedirectInfo redirect_info = deferred_redirect_info_;
+  deferred_redirect_info_ = RedirectInfo();
+  FollowRedirect(redirect_info);
 }
 
 void URLRequestJob::ResumeNetworkStart() {
   // This should only be called for HTTP Jobs, and implemented in the derived
   // class.
   NOTREACHED();
 }
 
 bool URLRequestJob::GetMimeType(std::string* mime_type) const {
   return false;
@@ skipping 96 matching lines @@
   if (request_)
     request_->OnHeadersComplete();
 
   GURL new_location;
   int http_status_code;
   if (IsRedirectResponse(&new_location, &http_status_code)) {
     // Redirect response bodies are not read. Notify the transaction
     // so it does not treat being stopped as an error.
     DoneReadingRedirectResponse();
 
-    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() &&
-        CopyFragmentOnRedirect(new_location)) {
-      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);
-    }
+    RedirectInfo redirect_info =
+        ComputeRedirectInfo(new_location, http_status_code);
 
     bool defer_redirect = false;
-    request_->NotifyReceivedRedirect(new_location, &defer_redirect);
+    request_->NotifyReceivedRedirect(redirect_info, &defer_redirect);
 
     // Ensure that the request wasn't detached or destroyed in
     // NotifyReceivedRedirect
     if (!request_ || !request_->has_delegate())
       return;
 
     // If we were not cancelled, then maybe follow the redirect.
     if (request_->status().is_success()) {
       if (defer_redirect) {
-        deferred_redirect_url_ = new_location;
-        deferred_redirect_status_code_ = http_status_code;
+        deferred_redirect_info_ = redirect_info;
       } else {
-        FollowRedirect(new_location, http_status_code);
+        FollowRedirect(redirect_info);
       }
       return;
     }
   } else if (NeedsAuth()) {
     scoped_refptr<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.get()) {
       request_->NotifyAuthRequired(auth_info.get());
@@ skipping 342 matching lines @@
 
   if (!request_->status().is_io_pending()) {
     // If the read completes synchronously, either success or failure,
     // invoke the OnRawReadComplete callback so we can account for the
     // completed read.
     OnRawReadComplete(*bytes_read);
   }
   return rv;
 }
 
-void URLRequestJob::FollowRedirect(const GURL& location, int http_status_code) {
-  int rv = request_->Redirect(location, http_status_code);
+void URLRequestJob::FollowRedirect(const RedirectInfo& redirect_info) {
+  int rv = request_->Redirect(redirect_info);
   if (rv != OK)
     NotifyDone(URLRequestStatus(URLRequestStatus::FAILED, rv));
 }
 
 void URLRequestJob::OnRawReadComplete(int bytes_read) {
   DCHECK(raw_read_buffer_.get());
   // If |filter_| is non-NULL, bytes will be logged after it is applied instead.
   if (!filter_.get() && request() && request()->net_log().IsLoggingBytes() &&
       bytes_read > 0) {
     request()->net_log().AddByteTransferEvent(
@@ skipping 22 matching lines @@
     network_delegate_->NotifyRawBytesRead(*request_, bytes_read);
 }
 
 bool URLRequestJob::FilterHasData() {
     return filter_.get() && filter_->stream_data_len();
 }
 
 void URLRequestJob::UpdatePacketReadTimes() {
 }
 
+RedirectInfo URLRequestJob::ComputeRedirectInfo(const GURL& location,
+                                                int http_status_code) {
+  const GURL& url = request_->url();
+
+  RedirectInfo redirect_info;
+
+  redirect_info.status_code = http_status_code;
+
+  // The request method may change, depending on the status code.
+  redirect_info.new_method = URLRequest::ComputeMethodForRedirect(
+      request_->method(), http_status_code);
+
+  // 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() && !location.has_ref() &&
+      CopyFragmentOnRedirect(location)) {
+    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);
+    redirect_info.new_url = location.ReplaceComponents(replacements);
+  } else {
+    redirect_info.new_url = location;
+  }
+
+  // Update the first-party URL if appropriate.
+  if (request_->first_party_url_policy() ==
+          URLRequest::UPDATE_FIRST_PARTY_URL_ON_REDIRECT) {
+    redirect_info.new_first_party_for_cookies = redirect_info.new_url;
+  } else {
+    redirect_info.new_first_party_for_cookies =
+        request_->first_party_for_cookies();
+  }
+
+  // Suppress the referrer if we're redirecting out of https.
+  if (request_->referrer_policy() ==
+          URLRequest::CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE &&
+      GURL(request_->referrer()).SchemeIsSecure() &&
+      !redirect_info.new_url.SchemeIsSecure()) {
+    redirect_info.new_referrer.clear();
+  } else {
+    redirect_info.new_referrer = request_->referrer();
+  }
+
+  return redirect_info;
+}
+
 }  // namespace net