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();
+
+  // Move the reference fragment of the old location to the new one if the
+  // new one has none. This duplicates mozilla's behavior.
+  GURL new_location = location;
+  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;
+
+  redirect_info.status_code = http_status_code;
+
+  // The request method may change, depending on the status code.
+  redirect_info.method = URLRequest::ComputeMethodForRedirect(
+      request_->method(), http_status_code);
+
+  redirect_info.url = new_location;

[mmenke, 2014/07/17 16:55:09]

Could avoid this copy by getting rid of new_location.  Could also avoid an extra
copy in the copy fragment case by only copying location  directly to
redirect_info.url when not copying the fragment.

In the scheme of things, getting rid of those copies really doesn't matter, but
if we're going to have comments about just how we're avoiding an extra copy from
ref, seems like we may as well minimize copies in other cases, too....

[davidben, 2014/07/17 22:03:55]

Done.

+
+  // Update the first-party URL if appropriate.
+  if (request_->first_party_url_policy() ==
+          URLRequest::UPDATE_FIRST_PARTY_URL_ON_REDIRECT) {

[mmenke, 2014/07/17 16:55:09]

Sure there are integration tests for this (At least I *HOPE* there are), but now
that it's in net/, should have net/ tests for this as well.

[davidben, 2014/07/17 22:03:55]

Done.

+    redirect_info.first_party_for_cookies = new_location;
+  } else {
+    redirect_info.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() &&
+      !new_location.SchemeIsSecure()) {
+    redirect_info.referrer.clear();
+  } else {
+    redirect_info.referrer = request_->referrer();
+  }
+
+  return redirect_info;
+}
+
 }  // namespace net