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

net/url_request/url_request_unittest.cc

Index: net/url_request/url_request_unittest.cc
diff --git a/net/url_request/url_request_unittest.cc b/net/url_request/url_request_unittest.cc
index a66924ef862ff69e35c9fb1ec385d9ef7cd778a9..2a1de2c99a1bc3c7a781bc8f0ef23852529c2f77 100644
--- a/net/url_request/url_request_unittest.cc
+++ b/net/url_request/url_request_unittest.cc
@@ -104,10 +104,10 @@ const base::string16 kUser(ASCIIToUTF16("user"));
 
 // Tests load timing information in the case a fresh connection was used, with
 // no proxy.
-void TestLoadTimingNotReused(const net::LoadTimingInfo& load_timing_info,
+void TestLoadTimingNotReused(const LoadTimingInfo& load_timing_info,
                              int connect_timing_flags) {
   EXPECT_FALSE(load_timing_info.socket_reused);
-  EXPECT_NE(net::NetLog::Source::kInvalidId, load_timing_info.socket_log_id);
+  EXPECT_NE(NetLog::Source::kInvalidId, load_timing_info.socket_log_id);
 
   EXPECT_FALSE(load_timing_info.request_start_time.is_null());
   EXPECT_FALSE(load_timing_info.request_start.is_null());
@@ -127,10 +127,10 @@ void TestLoadTimingNotReused(const net::LoadTimingInfo& load_timing_info,
 
 // Same as above, but with proxy times.
 void TestLoadTimingNotReusedWithProxy(
-    const net::LoadTimingInfo& load_timing_info,
+    const LoadTimingInfo& load_timing_info,
     int connect_timing_flags) {
   EXPECT_FALSE(load_timing_info.socket_reused);
-  EXPECT_NE(net::NetLog::Source::kInvalidId, load_timing_info.socket_log_id);
+  EXPECT_NE(NetLog::Source::kInvalidId, load_timing_info.socket_log_id);
 
   EXPECT_FALSE(load_timing_info.request_start_time.is_null());
   EXPECT_FALSE(load_timing_info.request_start.is_null());
@@ -151,9 +151,9 @@ void TestLoadTimingNotReusedWithProxy(
 
 // Same as above, but with a reused socket and proxy times.
 void TestLoadTimingReusedWithProxy(
-    const net::LoadTimingInfo& load_timing_info) {
+    const LoadTimingInfo& load_timing_info) {
   EXPECT_TRUE(load_timing_info.socket_reused);
-  EXPECT_NE(net::NetLog::Source::kInvalidId, load_timing_info.socket_log_id);
+  EXPECT_NE(NetLog::Source::kInvalidId, load_timing_info.socket_log_id);
 
   EXPECT_FALSE(load_timing_info.request_start_time.is_null());
   EXPECT_FALSE(load_timing_info.request_start.is_null());
@@ -193,9 +193,9 @@ void FillBuffer(char* buffer, size_t len) {
 
 #if !defined(OS_IOS)
 void TestLoadTimingCacheHitNoNetwork(
-    const net::LoadTimingInfo& load_timing_info) {
+    const LoadTimingInfo& load_timing_info) {
   EXPECT_FALSE(load_timing_info.socket_reused);
-  EXPECT_EQ(net::NetLog::Source::kInvalidId, load_timing_info.socket_log_id);
+  EXPECT_EQ(NetLog::Source::kInvalidId, load_timing_info.socket_log_id);
 
   EXPECT_FALSE(load_timing_info.request_start_time.is_null());
   EXPECT_FALSE(load_timing_info.request_start.is_null());
@@ -212,9 +212,9 @@ void TestLoadTimingCacheHitNoNetwork(
 // Tests load timing in the case that there is no HTTP response.  This can be
 // used to test in the case of errors or non-HTTP requests.
 void TestLoadTimingNoHttpResponse(
-    const net::LoadTimingInfo& load_timing_info) {
+    const LoadTimingInfo& load_timing_info) {
   EXPECT_FALSE(load_timing_info.socket_reused);
-  EXPECT_EQ(net::NetLog::Source::kInvalidId, load_timing_info.socket_log_id);
+  EXPECT_EQ(NetLog::Source::kInvalidId, load_timing_info.socket_log_id);
 
   // Only the request times should be non-null.
   EXPECT_FALSE(load_timing_info.request_start_time.is_null());
@@ -305,7 +305,7 @@ class BlockingNetworkDelegate : public TestNetworkDelegate {
   };
 
   // Behavior during blocked stages.  During other stages, just
-  // returns net::OK or NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION.
+  // returns OK or NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION.
   enum BlockMode {
     SYNCHRONOUS,    // No callback, returns specified return values.
     AUTO_CALLBACK,  // |this| posts a task to run the callback using the
@@ -771,7 +771,7 @@ TEST_F(URLRequestTest, FileTestFullSpecifiedRange) {
     HttpRequestHeaders headers;
     headers.SetHeader(
         HttpRequestHeaders::kRange,
-        net::HttpByteRange::Bounded(
+        HttpByteRange::Bounded(
             first_byte_position, last_byte_position).GetHeaderValue());
     r.SetExtraRequestHeaders(headers);
     r.Start();
@@ -814,7 +814,7 @@ TEST_F(URLRequestTest, FileTestHalfSpecifiedRange) {
 
     HttpRequestHeaders headers;
     headers.SetHeader(HttpRequestHeaders::kRange,
-                      net::HttpByteRange::RightUnbounded(
+                      HttpByteRange::RightUnbounded(
                           first_byte_position).GetHeaderValue());
     r.SetExtraRequestHeaders(headers);
     r.Start();
@@ -869,7 +869,7 @@ TEST_F(URLRequestTest, AllowFileURLs) {
   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir.path(), &test_file));
   std::string test_data("monkey");
   base::WriteFile(test_file, test_data.data(), test_data.size());
-  GURL test_file_url = net::FilePathToFileURL(test_file);
+  GURL test_file_url = FilePathToFileURL(test_file);
 
   {
     TestDelegate d;
@@ -1873,7 +1873,7 @@ TEST_F(URLRequestTest, NetworkDelegateProxyError) {
   EXPECT_EQ(1, network_delegate.completed_requests());
 }
 
-// Make sure that net::NetworkDelegate::NotifyCompleted is called if
+// Make sure that NetworkDelegate::NotifyCompleted is called if
 // content is empty.
 TEST_F(URLRequestTest, RequestCompletionForEmptyResponse) {
   TestDelegate d;
@@ -2431,12 +2431,12 @@ class FixedDateNetworkDelegate : public TestNetworkDelegate {
       : fixed_date_(fixed_date) {}
   virtual ~FixedDateNetworkDelegate() {}
 
-  // net::NetworkDelegate implementation
+  // NetworkDelegate implementation
   virtual int OnHeadersReceived(
-      net::URLRequest* request,
-      const net::CompletionCallback& callback,
-      const net::HttpResponseHeaders* original_response_headers,
-      scoped_refptr<net::HttpResponseHeaders>* override_response_headers,
+      URLRequest* request,
+      const CompletionCallback& callback,
+      const HttpResponseHeaders* original_response_headers,
+      scoped_refptr<HttpResponseHeaders>* override_response_headers,
       GURL* allowed_unsafe_redirect_url) OVERRIDE;
 
  private:
@@ -2446,13 +2446,13 @@ class FixedDateNetworkDelegate : public TestNetworkDelegate {
 };
 
 int FixedDateNetworkDelegate::OnHeadersReceived(
-    net::URLRequest* request,
-    const net::CompletionCallback& callback,
-    const net::HttpResponseHeaders* original_response_headers,
-    scoped_refptr<net::HttpResponseHeaders>* override_response_headers,
+    URLRequest* request,
+    const CompletionCallback& callback,
+    const HttpResponseHeaders* original_response_headers,
+    scoped_refptr<HttpResponseHeaders>* override_response_headers,
     GURL* allowed_unsafe_redirect_url) {
-  net::HttpResponseHeaders* new_response_headers =
-      new net::HttpResponseHeaders(original_response_headers->raw_headers());
+  HttpResponseHeaders* new_response_headers =
+      new HttpResponseHeaders(original_response_headers->raw_headers());
 
   new_response_headers->RemoveHeader("Date");
   new_response_headers->AddHeader("Date: " + fixed_date_);
@@ -3124,7 +3124,7 @@ TEST_F(URLRequestTestHTTP, NetworkDelegateRedirectRequestOnHeadersReceived) {
     EXPECT_TRUE(
         network_delegate.last_observed_proxy().Equals(
             test_server_.host_port_pair()));
-    EXPECT_EQ(net::OK, r.status().error());
+    EXPECT_EQ(OK, r.status().error());
     EXPECT_EQ(redirect_url, r.url());
     EXPECT_EQ(original_url, r.original_url());
     EXPECT_EQ(2U, r.url_chain().size());
@@ -4123,7 +4123,7 @@ class AsyncLoggingUrlRequestDelegate : public TestDelegate {
 
   // URLRequest::Delegate implementation:
   void virtual OnReceivedRedirect(URLRequest* request,
-                                  const GURL& new_url,
+                                  const RedirectInfo& redirect_info,
                                   bool* defer_redirect) OVERRIDE {
     *defer_redirect = true;
     AsyncDelegateLogger::Run(
@@ -4133,7 +4133,7 @@ class AsyncLoggingUrlRequestDelegate : public TestDelegate {
         LOAD_STATE_WAITING_FOR_DELEGATE,
         base::Bind(
             &AsyncLoggingUrlRequestDelegate::OnReceivedRedirectLoggingComplete,
-            base::Unretained(this), request, new_url));
+            base::Unretained(this), request, redirect_info));
   }
 
   virtual void OnResponseStarted(URLRequest* request) OVERRIDE {
@@ -4161,9 +4161,9 @@ class AsyncLoggingUrlRequestDelegate : public TestDelegate {
 
  private:
   void OnReceivedRedirectLoggingComplete(URLRequest* request,
-                                         const GURL& new_url) {
+                                         const RedirectInfo& redirect_info) {
     bool defer_redirect = false;
-    TestDelegate::OnReceivedRedirect(request, new_url, &defer_redirect);
+    TestDelegate::OnReceivedRedirect(request, redirect_info, &defer_redirect);
     // FollowDeferredRedirect should not be called after cancellation.
     if (cancel_stage_ == CANCEL_ON_RECEIVED_REDIRECT)
       return;
@@ -4621,10 +4621,10 @@ const char kExtraHeader[] = "Allow-Snafu";
 const char kExtraValue[] = "fubar";
 
 class RedirectWithAdditionalHeadersDelegate : public TestDelegate {
-  virtual void OnReceivedRedirect(net::URLRequest* request,
-                                  const GURL& new_url,
+  virtual void OnReceivedRedirect(URLRequest* request,
+                                  const RedirectInfo& redirect_info,
                                   bool* defer_redirect) OVERRIDE {
-    TestDelegate::OnReceivedRedirect(request, new_url, defer_redirect);
+    TestDelegate::OnReceivedRedirect(request, redirect_info, defer_redirect);
     request->SetExtraRequestHeaderByName(kExtraHeader, kExtraValue, false);
   }
 };
@@ -4657,10 +4657,10 @@ namespace {
 const char kExtraHeaderToRemove[] = "To-Be-Removed";
 
 class RedirectWithHeaderRemovalDelegate : public TestDelegate {
-  virtual void OnReceivedRedirect(net::URLRequest* request,
-                          const GURL& new_url,
-                          bool* defer_redirect) OVERRIDE {
-    TestDelegate::OnReceivedRedirect(request, new_url, defer_redirect);
+  virtual void OnReceivedRedirect(URLRequest* request,
+                                  const RedirectInfo& redirect_info,
+                                  bool* defer_redirect) OVERRIDE {
+    TestDelegate::OnReceivedRedirect(request, redirect_info, defer_redirect);
     request->RemoveRequestHeaderByName(kExtraHeaderToRemove);
   }
 };
@@ -5388,7 +5388,7 @@ TEST_F(URLRequestTestHTTP, UnsafeRedirectToWhitelistedUnsafeURL) {
     EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status());
 
     EXPECT_EQ(2U, r.url_chain().size());
-    EXPECT_EQ(net::OK, r.status().error());
+    EXPECT_EQ(OK, r.status().error());
     EXPECT_EQ(unsafe_url, r.url());
     EXPECT_EQ("this-is-considered-an-unsafe-url", d.data_received());
   }
@@ -5441,7 +5441,7 @@ TEST_F(URLRequestTestHTTP, UnsafeRedirectWithDifferentReferenceFragment) {
 
     EXPECT_EQ(2U, r.url_chain().size());
     EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status());
-    EXPECT_EQ(net::OK, r.status().error());
+    EXPECT_EQ(OK, r.status().error());
     EXPECT_EQ(original_url, r.original_url());
     EXPECT_EQ(expected_url, r.url());
   }
@@ -5469,7 +5469,7 @@ TEST_F(URLRequestTestHTTP, RedirectWithReferenceFragmentAndUnrelatedUnsafeUrl) {
 
     EXPECT_EQ(2U, r.url_chain().size());
     EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status());
-    EXPECT_EQ(net::OK, r.status().error());
+    EXPECT_EQ(OK, r.status().error());
     EXPECT_EQ(original_url, r.original_url());
     EXPECT_EQ(expected_redirect_url, r.url());
   }
@@ -5496,7 +5496,7 @@ TEST_F(URLRequestTestHTTP, RedirectWithReferenceFragment) {
 
     EXPECT_EQ(2U, r.url_chain().size());
     EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status());
-    EXPECT_EQ(net::OK, r.status().error());
+    EXPECT_EQ(OK, r.status().error());
     EXPECT_EQ(original_url, r.original_url());
     EXPECT_EQ(redirect_url, r.url());
   }
@@ -5522,7 +5522,7 @@ TEST_F(URLRequestTestHTTP, RedirectJobWithReferenceFragment) {
   base::RunLoop().Run();
 
   EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status());
-  EXPECT_EQ(net::OK, r.status().error());
+  EXPECT_EQ(OK, r.status().error());
   EXPECT_EQ(original_url, r.original_url());
   EXPECT_EQ(redirect_url, r.url());
 }
@@ -6151,12 +6151,57 @@ TEST_F(URLRequestTestHTTP, Redirect302PreserveReferenceFragment) {
 
     EXPECT_EQ(2U, r.url_chain().size());
     EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status());
-    EXPECT_EQ(net::OK, r.status().error());
+    EXPECT_EQ(OK, r.status().error());
     EXPECT_EQ(original_url, r.original_url());
     EXPECT_EQ(expected_url, r.url());
   }
 }
 
+TEST_F(URLRequestTestHTTP, RedirectPreserveFirstPartyURL) {
+  ASSERT_TRUE(test_server_.Start());
+
+  GURL url(test_server_.GetURL("files/redirect302-to-echo"));
+  GURL first_party_url("http://example.com");
+
+  TestDelegate d;
+  {
+    URLRequest r(url, DEFAULT_PRIORITY, &d, &default_context_);
+    r.set_first_party_for_cookies(first_party_url);
+
+    r.Start();
+    base::RunLoop().Run();
+
+    EXPECT_EQ(2U, r.url_chain().size());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status());
+    EXPECT_EQ(OK, r.status().error());
+    EXPECT_EQ(first_party_url, r.first_party_for_cookies());
+  }
+}
+
+TEST_F(URLRequestTestHTTP, RedirectUpdateFirstPartyURL) {
+  ASSERT_TRUE(test_server_.Start());
+
+  GURL url(test_server_.GetURL("files/redirect302-to-echo"));
+  GURL original_first_party_url("http://example.com");
+  GURL expected_first_party_url(test_server_.GetURL("echo"));
+
+  TestDelegate d;
+  {
+    URLRequest r(url, DEFAULT_PRIORITY, &d, &default_context_);
+    r.set_first_party_for_cookies(original_first_party_url);
+    r.set_first_party_url_policy(
+        URLRequest::UPDATE_FIRST_PARTY_URL_ON_REDIRECT);
+
+    r.Start();
+    base::RunLoop().Run();
+
+    EXPECT_EQ(2U, r.url_chain().size());
+    EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status());
+    EXPECT_EQ(OK, r.status().error());
+    EXPECT_EQ(expected_first_party_url, r.first_party_for_cookies());
+  }
+}
+
 TEST_F(URLRequestTestHTTP, InterceptPost302RedirectGet) {
   ASSERT_TRUE(test_server_.Start());
 
@@ -6970,9 +7015,9 @@ TEST_F(HTTPSRequestTest, SSLSessionCacheShardTest) {
   params.http_server_properties = default_context_.http_server_properties();
   params.ssl_session_cache_shard = "alternate";
 
-  scoped_ptr<net::HttpCache> cache(new net::HttpCache(
-      new net::HttpNetworkSession(params),
-      net::HttpCache::DefaultBackend::InMemory(0)));
+  scoped_ptr<HttpCache> cache(new HttpCache(
+      new HttpNetworkSession(params),
+      HttpCache::DefaultBackend::InMemory(0)));
 
   default_context_.set_http_transaction_factory(cache.get());
 
@@ -7178,7 +7223,7 @@ TEST_F(HTTPSFallbackTest, SSLv3NoFallbackReset) {
 class HTTPSSessionTest : public testing::Test {
  public:
   HTTPSSessionTest() : default_context_(true) {
-    cert_verifier_.set_default_result(net::OK);
+    cert_verifier_.set_default_result(OK);
 
     default_context_.set_network_delegate(&default_network_delegate_);
     default_context_.set_cert_verifier(&cert_verifier_);
@@ -7206,7 +7251,7 @@ TEST_F(HTTPSSessionTest, DontResumeSessionsForInvalidCertificates) {
   SSLClientSocket::ClearSessionCache();
 
   // Simulate the certificate being expired and attempt a connection.
-  cert_verifier_.set_default_result(net::ERR_CERT_DATE_INVALID);
+  cert_verifier_.set_default_result(ERR_CERT_DATE_INVALID);
   {
     TestDelegate d;
     URLRequest r(test_server.GetURL("ssl-session-cache"),
@@ -7227,7 +7272,7 @@ TEST_F(HTTPSSessionTest, DontResumeSessionsForInvalidCertificates) {
 
   // Now change the certificate to be acceptable (so that the response is
   // loaded), and ensure that no session id is presented to the peer.
-  cert_verifier_.set_default_result(net::OK);
+  cert_verifier_.set_default_result(OK);
   {
     TestDelegate d;
     URLRequest r(test_server.GetURL("ssl-session-cache"),
@@ -7334,7 +7379,7 @@ class HTTPSOCSPTest : public HTTPSRequestTest {
     SetupContext(&context_);
     context_.Init();
 
-    scoped_refptr<net::X509Certificate> root_cert =
+    scoped_refptr<X509Certificate> root_cert =
         ImportCertFromFile(GetTestCertsDirectory(), "ocsp-test-root.pem");
     CHECK_NE(static_cast<X509Certificate*>(NULL), root_cert);
     test_root_.reset(new ScopedTestRoot(root_cert.get()));