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

net/url_request/url_request.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.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
@@ skipping 12 matching lines @@
 #include "net/base/load_flags.h"
 #include "net/base/load_timing_info.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 #include "net/base/network_change_notifier.h"
 #include "net/base/network_delegate.h"
 #include "net/base/upload_data_stream.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_util.h"
 #include "net/ssl/ssl_cert_request_info.h"
+#include "net/url_request/redirect_info.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_error_job.h"
 #include "net/url_request/url_request_job.h"
 #include "net/url_request/url_request_job_manager.h"
 #include "net/url_request/url_request_netlog_params.h"
 #include "net/url_request/url_request_redirect_job.h"
 
 using base::Time;
 using std::string;
 
@@ skipping 119 matching lines @@
 
 URLRequestJob* URLRequest::Interceptor::MaybeInterceptResponse(
     URLRequest* request, NetworkDelegate* network_delegate) {
   return NULL;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // URLRequest::Delegate
 
 void URLRequest::Delegate::OnReceivedRedirect(URLRequest* request,
-                                              const GURL& new_url,
+                                              const RedirectInfo& redirect_info,
                                               bool* defer_redirect) {
 }
 
 void URLRequest::Delegate::OnAuthRequired(URLRequest* request,
                                           AuthChallengeInfo* auth_info) {
   request->CancelAuth();
 }
 
 void URLRequest::Delegate::OnCertificateRequested(
     URLRequest* request,
@@ skipping 69 matching lines @@
                       RequestPriority priority,
                       Delegate* delegate,
                       const URLRequestContext* context,
                       CookieStore* cookie_store) {
   context_ = context;
   network_delegate_ = context->network_delegate();
   net_log_ = BoundNetLog::Make(context->net_log(), NetLog::SOURCE_URL_REQUEST);
   url_chain_.push_back(url);
   method_ = "GET";
   referrer_policy_ = CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE;
+  first_party_url_policy_ = NEVER_CHANGE_FIRST_PARTY_URL;
   load_flags_ = LOAD_NORMAL;
   delegate_ = delegate;
   is_pending_ = false;
   is_redirecting_ = false;
   redirect_limit_ = kMaxRedirects;
   priority_ = priority;
   calling_delegate_ = false;
   use_blocked_by_as_load_param_ =false;
   before_request_callback_ = base::Bind(&URLRequest::BeforeRequestComplete,
                                         base::Unretained(this));
@@ skipping 284 matching lines @@
   if (!url.is_valid()) {
     // We handle error cases.
     return true;
   }
 
   return IsHandledProtocol(url.scheme());
 }
 
 void URLRequest::set_first_party_for_cookies(
     const GURL& first_party_for_cookies) {
+  DCHECK(!is_pending_);
   first_party_for_cookies_ = first_party_for_cookies;
 }
 
+void URLRequest::set_first_party_url_policy(
+    FirstPartyURLPolicy first_party_url_policy) {
+  DCHECK(!is_pending_);
+  first_party_url_policy_ = first_party_url_policy;
+}
+
 void URLRequest::set_method(const std::string& method) {
   DCHECK(!is_pending_);
   method_ = method;
 }
 
 // static
 std::string URLRequest::ComputeMethodForRedirect(
     const std::string& method,
     int http_status_code) {
   // For 303 redirects, all request methods except HEAD are converted to GET,
@@ skipping 236 matching lines @@
   if (rv && *bytes_read <= 0 && status_.is_success())
     NotifyRequestCompleted();
   return rv;
 }
 
 void URLRequest::StopCaching() {
   DCHECK(job_.get());
   job_->StopCaching();
 }
 
-void URLRequest::NotifyReceivedRedirect(const GURL& location,
+void URLRequest::NotifyReceivedRedirect(const RedirectInfo& redirect_info,
                                         bool* defer_redirect) {
   is_redirecting_ = true;
 
+  // TODO(davidben): Pass the full RedirectInfo down to MaybeInterceptRedirect?
   URLRequestJob* job =
       URLRequestJobManager::GetInstance()->MaybeInterceptRedirect(
-          this, network_delegate_, location);
+          this, network_delegate_, redirect_info.new_url);
   if (job) {
     RestartWithJob(job);
   } else if (delegate_) {
     OnCallToDelegate();
-    delegate_->OnReceivedRedirect(this, location, defer_redirect);
+    delegate_->OnReceivedRedirect(this, redirect_info, defer_redirect);
     // |this| may be have been destroyed here.
   }
 }
 
 void URLRequest::NotifyBeforeNetworkStart(bool* defer) {
   if (delegate_ && !notified_before_network_start_) {
     OnCallToDelegate();
     delegate_->OnBeforeNetworkStart(this, defer);
     if (!*defer)
       OnCallToDelegateComplete();
@@ skipping 102 matching lines @@
   // - OrphanJob is called on JobRestart, in this case the URLRequestJob cannot
   //   be receiving any headers at that time.
   // - OrphanJob is called in ~URLRequest, in this case
   //   NetworkDelegate::NotifyURLRequestDestroyed notifies the NetworkDelegate
   //   that the callback becomes invalid.
   job_->Kill();
   job_->DetachRequest();  // ensures that the job will not call us again
   job_ = NULL;
 }
 
-int URLRequest::Redirect(const GURL& location, int http_status_code) {
+int URLRequest::Redirect(const RedirectInfo& redirect_info) {
   // Matches call in NotifyReceivedRedirect.
   OnCallToDelegateComplete();
   if (net_log_.IsLogging()) {
     net_log_.AddEvent(
         NetLog::TYPE_URL_REQUEST_REDIRECTED,
-        NetLog::StringCallback("location", &location.possibly_invalid_spec()));
+        NetLog::StringCallback("location",
+                               &redirect_info.new_url.possibly_invalid_spec()));
   }
 
+  // TODO(davidben): Pass the full RedirectInfo to the NetworkDelegate.
   if (network_delegate_)
-    network_delegate_->NotifyBeforeRedirect(this, location);
+    network_delegate_->NotifyBeforeRedirect(this, redirect_info.new_url);
 
   if (redirect_limit_ <= 0) {
     DVLOG(1) << "disallowing redirect: exceeds limit";
     return ERR_TOO_MANY_REDIRECTS;
   }
 
-  if (!location.is_valid())
+  if (!redirect_info.new_url.is_valid())
     return ERR_INVALID_URL;
 
-  if (!job_->IsSafeRedirect(location)) {
+  if (!job_->IsSafeRedirect(redirect_info.new_url)) {
     DVLOG(1) << "disallowing redirect: unsafe protocol";
     return ERR_UNSAFE_REDIRECT;
   }
 
   if (!final_upload_progress_.position())
     final_upload_progress_ = job_->GetUploadProgress();
   PrepareToRestart();
 
-  std::string new_method(ComputeMethodForRedirect(method_, http_status_code));
-  if (new_method != method_) {
+  if (redirect_info.new_method != method_) {
+    // TODO(davidben): This logic still needs to be replicated at the consumers.
     if (method_ == "POST") {
       // If being switched from POST, must remove headers that were specific to
       // the POST and don't have meaning in other methods. For example the
       // inclusion of a multipart Content-Type header in GET can cause problems
       // with some servers:
       // http://code.google.com/p/chromium/issues/detail?id=843
       StripPostSpecificHeaders(&extra_request_headers_);
     }
     upload_data_stream_.reset();
-    method_.swap(new_method);
+    method_ = redirect_info.new_method;
   }
 
-  // Suppress the referrer if we're redirecting out of https.
-  if (referrer_policy_ ==
-          CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE &&
-      GURL(referrer_).SchemeIsSecure() && !location.SchemeIsSecure()) {
-    referrer_.clear();
-  }
+  referrer_ = redirect_info.new_referrer;
+  first_party_for_cookies_ = redirect_info.new_first_party_for_cookies;
 
-  url_chain_.push_back(location);
+  url_chain_.push_back(redirect_info.new_url);
   --redirect_limit_;
 
   Start();
   return OK;
 }
 
 const URLRequestContext* URLRequest::context() const {
   return context_;
 }
 
@@ skipping 212 matching lines @@
       new base::debug::StackTrace(NULL, 0);
   *stack_trace_copy = stack_trace;
   stack_trace_.reset(stack_trace_copy);
 }
 
 const base::debug::StackTrace* URLRequest::stack_trace() const {
   return stack_trace_.get();
 }
 
 }  // namespace net