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

net/url_request/url_request_unittest.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 "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <shlobj.h>
 #endif
@@ skipping 86 matching lines @@
 namespace net {
 
 namespace {
 
 const base::string16 kChrome(ASCIIToUTF16("chrome"));
 const base::string16 kSecret(ASCIIToUTF16("secret"));
 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());
 
   EXPECT_LE(load_timing_info.request_start,
             load_timing_info.connect_timing.connect_start);
   ExpectConnectTimingHasTimes(load_timing_info.connect_timing,
                               connect_timing_flags);
   EXPECT_LE(load_timing_info.connect_timing.connect_end,
             load_timing_info.send_start);
   EXPECT_LE(load_timing_info.send_start, load_timing_info.send_end);
   EXPECT_LE(load_timing_info.send_end, load_timing_info.receive_headers_end);
 
   EXPECT_TRUE(load_timing_info.proxy_resolve_start.is_null());
   EXPECT_TRUE(load_timing_info.proxy_resolve_end.is_null());
 }
 
 // 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());
 
   EXPECT_LE(load_timing_info.request_start,
             load_timing_info.proxy_resolve_start);
   EXPECT_LE(load_timing_info.proxy_resolve_start,
             load_timing_info.proxy_resolve_end);
   EXPECT_LE(load_timing_info.proxy_resolve_end,
             load_timing_info.connect_timing.connect_start);
   ExpectConnectTimingHasTimes(load_timing_info.connect_timing,
                               connect_timing_flags);
   EXPECT_LE(load_timing_info.connect_timing.connect_end,
             load_timing_info.send_start);
   EXPECT_LE(load_timing_info.send_start, load_timing_info.send_end);
   EXPECT_LE(load_timing_info.send_end, load_timing_info.receive_headers_end);
 }
 
 // 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());
 
   ExpectConnectTimingHasNoTimes(load_timing_info.connect_timing);
 
   EXPECT_LE(load_timing_info.request_start,
             load_timing_info.proxy_resolve_start);
   EXPECT_LE(load_timing_info.proxy_resolve_start,
             load_timing_info.proxy_resolve_end);
@@ skipping 19 matching lines @@
 
   for (size_t i = 0; i < len; i++) {
     buffer[i] = static_cast<char>(rand());
     if (!buffer[i])
       buffer[i] = 'g';
   }
 }
 
 #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());
 
   ExpectConnectTimingHasNoTimes(load_timing_info.connect_timing);
   EXPECT_LE(load_timing_info.request_start, load_timing_info.send_start);
   EXPECT_LE(load_timing_info.send_start, load_timing_info.send_end);
   EXPECT_LE(load_timing_info.send_end, load_timing_info.receive_headers_end);
 
   EXPECT_TRUE(load_timing_info.proxy_resolve_start.is_null());
   EXPECT_TRUE(load_timing_info.proxy_resolve_end.is_null());
 }
 
 // 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());
   EXPECT_FALSE(load_timing_info.request_start.is_null());
 
   ExpectConnectTimingHasNoTimes(load_timing_info.connect_timing);
 
   EXPECT_TRUE(load_timing_info.proxy_resolve_start.is_null());
   EXPECT_TRUE(load_timing_info.proxy_resolve_end.is_null());
   EXPECT_TRUE(load_timing_info.send_start.is_null());
@@ skipping 70 matching lines @@
   // Stages in which the delegate can block.
   enum Stage {
     NOT_BLOCKED = 0,
     ON_BEFORE_URL_REQUEST = 1 << 0,
     ON_BEFORE_SEND_HEADERS = 1 << 1,
     ON_HEADERS_RECEIVED = 1 << 2,
     ON_AUTH_REQUIRED = 1 << 3
   };
 
   // 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
                     // specified return codes.
     USER_CALLBACK,  // User takes care of doing a callback.  |retval_| and
                     // |auth_retval_| are ignored. In every blocking stage the
                     // message loop is quit.
   };
 
   // Creates a delegate which does not block at all.
@@ skipping 445 matching lines @@
   std::string partial_buffer_string(buffer.get() + first_byte_position,
                                     buffer.get() + last_byte_position + 1);
 
   TestDelegate d;
   {
     URLRequest r(temp_url, DEFAULT_PRIORITY, &d, &default_context_);
 
     HttpRequestHeaders headers;
     headers.SetHeader(
         HttpRequestHeaders::kRange,
-        net::HttpByteRange::Bounded(
+        HttpByteRange::Bounded(
             first_byte_position, last_byte_position).GetHeaderValue());
     r.SetExtraRequestHeaders(headers);
     r.Start();
     EXPECT_TRUE(r.is_pending());
 
     base::RunLoop().Run();
     EXPECT_TRUE(!r.is_pending());
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_EQ(static_cast<int>(content_length), d.bytes_received());
@@ skipping 22 matching lines @@
   const size_t content_length = last_byte_position - first_byte_position + 1;
   std::string partial_buffer_string(buffer.get() + first_byte_position,
                                     buffer.get() + last_byte_position + 1);
 
   TestDelegate d;
   {
     URLRequest r(temp_url, DEFAULT_PRIORITY, &d, &default_context_);
 
     HttpRequestHeaders headers;
     headers.SetHeader(HttpRequestHeaders::kRange,
-                      net::HttpByteRange::RightUnbounded(
+                      HttpByteRange::RightUnbounded(
                           first_byte_position).GetHeaderValue());
     r.SetExtraRequestHeaders(headers);
     r.Start();
     EXPECT_TRUE(r.is_pending());
 
     base::RunLoop().Run();
     EXPECT_TRUE(!r.is_pending());
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_EQ(static_cast<int>(content_length), d.bytes_received());
@@ skipping 34 matching lines @@
   EXPECT_TRUE(base::DeleteFile(temp_path, false));
 }
 
 TEST_F(URLRequestTest, AllowFileURLs) {
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   base::FilePath test_file;
   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;
     TestNetworkDelegate network_delegate;
     network_delegate.set_can_access_files(true);
     default_context_.set_network_delegate(&network_delegate);
     URLRequest r(test_file_url, DEFAULT_PRIORITY, &d, &default_context_);
     r.Start();
     base::RunLoop().Run();
     EXPECT_FALSE(d.request_failed());
@@ skipping 983 matching lines @@
   // The proxy server is not set before failure.
   EXPECT_TRUE(req.proxy_server().IsEmpty());
   EXPECT_EQ(URLRequestStatus::FAILED, req.status().status());
   EXPECT_EQ(ERR_PROXY_CONNECTION_FAILED, req.status().error());
 
   EXPECT_EQ(1, network_delegate.error_count());
   EXPECT_EQ(ERR_PROXY_CONNECTION_FAILED, network_delegate.last_error());
   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;
   URLRequest req(GURL("data:,"), DEFAULT_PRIORITY, &d, &default_context_);
   req.Start();
   base::RunLoop().Run();
   EXPECT_EQ("", d.data_received());
   EXPECT_EQ(1, default_network_delegate_.completed_requests());
 }
 
@@ skipping 537 matching lines @@
 }
 
 // FixedDateNetworkDelegate swaps out the server's HTTP Date response header
 // value for the |fixed_date| argument given to the constructor.
 class FixedDateNetworkDelegate : public TestNetworkDelegate {
  public:
   explicit FixedDateNetworkDelegate(const std::string& fixed_date)
       : 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:
   std::string fixed_date_;
 
   DISALLOW_COPY_AND_ASSIGN(FixedDateNetworkDelegate);
 };
 
 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_);
 
   *override_response_headers = new_response_headers;
   return TestNetworkDelegate::OnHeadersReceived(request,
                                                 callback,
                                                 original_response_headers,
                                                 override_response_headers,
                                                 allowed_unsafe_redirect_url);
@@ skipping 606 matching lines @@
     r.Start();
     base::RunLoop().Run();
 
     EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status());
     EXPECT_TRUE(r.proxy_server().Equals(test_server_.host_port_pair()));
     EXPECT_EQ(
         2, network_delegate.observed_before_proxy_headers_sent_callbacks());
     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());
     EXPECT_EQ(2, network_delegate.created_requests());
     EXPECT_EQ(0, network_delegate.destroyed_requests());
   }
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 }
 
 // Tests that the network delegate can synchronously complete OnAuthRequired
@@ skipping 978 matching lines @@
       set_cancel_in_received_redirect(true);
     else if (cancel_stage == CANCEL_ON_RESPONSE_STARTED)
       set_cancel_in_response_started(true);
     else if (cancel_stage == CANCEL_ON_READ_COMPLETED)
       set_cancel_in_received_data(true);
   }
   virtual ~AsyncLoggingUrlRequestDelegate() {}
 
   // 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(
         request,
         LOAD_STATE_WAITING_FOR_DELEGATE,
         LOAD_STATE_WAITING_FOR_DELEGATE,
         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 {
     AsyncDelegateLogger::Run(
       request,
       LOAD_STATE_WAITING_FOR_DELEGATE,
       LOAD_STATE_WAITING_FOR_DELEGATE,
       LOAD_STATE_WAITING_FOR_DELEGATE,
       base::Bind(
           &AsyncLoggingUrlRequestDelegate::OnResponseStartedLoggingComplete,
           base::Unretained(this), request));
   }
 
   virtual void OnReadCompleted(URLRequest* request,
                                int bytes_read) OVERRIDE {
     AsyncDelegateLogger::Run(
         request,
         LOAD_STATE_IDLE,
         LOAD_STATE_IDLE,
         LOAD_STATE_IDLE,
         base::Bind(
             &AsyncLoggingUrlRequestDelegate::AfterReadCompletedLoggingComplete,
             base::Unretained(this), request, bytes_read));
   }
 
  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;
     if (!defer_redirect)
       request->FollowDeferredRedirect();
   }
 
   void OnResponseStartedLoggingComplete(URLRequest* request) {
     // The parent class continues the request.
     TestDelegate::OnResponseStarted(request);
@@ skipping 437 matching lines @@
         entries, log_position + 1, NetLog::TYPE_URL_REQUEST_DELEGATE));
   }
 }
 
 namespace {
 
 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);
   }
 };
 
 }  // namespace
 
 TEST_F(URLRequestTestHTTP, RedirectWithAdditionalHeadersTest) {
   ASSERT_TRUE(test_server_.Start());
 
   GURL destination_url = test_server_.GetURL(
@@ skipping 12 matching lines @@
   EXPECT_FALSE(req.is_pending());
   EXPECT_FALSE(req.is_redirecting());
   EXPECT_EQ(kExtraValue, d.data_received());
 }
 
 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);
   }
 };
 
 }  // namespace
 
 TEST_F(URLRequestTestHTTP, RedirectWithHeaderRemovalTest) {
   ASSERT_TRUE(test_server_.Start());
 
   GURL destination_url = test_server_.GetURL(
@@ skipping 707 matching lines @@
                  DEFAULT_PRIORITY,
                  &d,
                  &default_context_);
 
     r.Start();
     base::RunLoop().Run();
 
     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());
   }
 }
 
 // Tests that a redirect to a different unsafe URL is blocked, even after adding
 // some other URL to the whitelist.
 TEST_F(URLRequestTestHTTP, UnsafeRedirectToDifferentUnsafeURL) {
   ASSERT_TRUE(test_server_.Start());
 
@@ skipping 32 matching lines @@
 
   TestDelegate d;
   {
     URLRequest r(original_url, DEFAULT_PRIORITY, &d, &default_context_);
 
     r.Start();
     base::RunLoop().Run();
 
     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());
   }
 }
 
 // When a delegate has specified a safe redirect URL, but it does not match the
 // redirect target, then do not prevent the reference fragment from being added.
 TEST_F(URLRequestTestHTTP, RedirectWithReferenceFragmentAndUnrelatedUnsafeUrl) {
   ASSERT_TRUE(test_server_.Start());
 
   GURL original_url(test_server_.GetURL("original#expected-fragment"));
   GURL unsafe_url("data:text/html,this-url-does-not-match-redirect-url");
   GURL redirect_url(test_server_.GetURL("target"));
   GURL expected_redirect_url(test_server_.GetURL("target#expected-fragment"));
 
   default_network_delegate_.set_redirect_on_headers_received_url(redirect_url);
   default_network_delegate_.set_allowed_unsafe_redirect_url(unsafe_url);
 
   TestDelegate d;
   {
     URLRequest r(original_url, DEFAULT_PRIORITY, &d, &default_context_);
 
     r.Start();
     base::RunLoop().Run();
 
     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());
   }
 }
 
 // When a delegate has specified a safe redirect URL, assume that the redirect
 // URL should not be changed. In particular, the reference fragment should not
 // be modified.
 TEST_F(URLRequestTestHTTP, RedirectWithReferenceFragment) {
   ASSERT_TRUE(test_server_.Start());
 
   GURL original_url(test_server_.GetURL("original#should-not-be-appended"));
   GURL redirect_url("data:text/html,expect-no-reference-fragment");
 
   default_network_delegate_.set_redirect_on_headers_received_url(redirect_url);
   default_network_delegate_.set_allowed_unsafe_redirect_url(redirect_url);
 
   TestDelegate d;
   {
     URLRequest r(original_url, DEFAULT_PRIORITY, &d, &default_context_);
 
     r.Start();
     base::RunLoop().Run();
 
     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());
   }
 }
 
 // When a URLRequestRedirectJob is created, the redirection must be followed and
 // the reference fragment of the target URL must not be modified.
 TEST_F(URLRequestTestHTTP, RedirectJobWithReferenceFragment) {
   ASSERT_TRUE(test_server_.Start());
 
   GURL original_url(test_server_.GetURL("original#should-not-be-appended"));
   GURL redirect_url(test_server_.GetURL("echo"));
 
   TestDelegate d;
   URLRequest r(original_url, DEFAULT_PRIORITY, &d, &default_context_);
 
   URLRequestRedirectJob* job = new URLRequestRedirectJob(
       &r, &default_network_delegate_, redirect_url,
       URLRequestRedirectJob::REDIRECT_302_FOUND, "Very Good Reason");
   AddTestInterceptor()->set_main_intercept_job(job);
 
   r.Start();
   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());
 }
 
 TEST_F(URLRequestTestHTTP, NoUserPassInReferrer) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
   URLRequest req(test_server_.GetURL("echoheader?Referer"),
                  DEFAULT_PRIORITY,
@@ skipping 608 matching lines @@
 
   TestDelegate d;
   {
     URLRequest r(original_url, DEFAULT_PRIORITY, &d, &default_context_);
 
     r.Start();
     base::RunLoop().Run();
 
     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());
 
   const char kData[] = "hello world";
 
   TestDelegate d;
   URLRequest req(test_server_.GetURL("empty.html"),
                  DEFAULT_PRIORITY,
                  &d,
                  &default_context_);
@@ skipping 793 matching lines @@
   params.cert_verifier = default_context_.cert_verifier();
   params.transport_security_state = default_context_.transport_security_state();
   params.proxy_service = default_context_.proxy_service();
   params.ssl_config_service = default_context_.ssl_config_service();
   params.http_auth_handler_factory =
       default_context_.http_auth_handler_factory();
   params.network_delegate = &default_network_delegate_;
   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());
 
   {
     TestDelegate d;
     URLRequest r(test_server.GetURL("ssl-session-cache"),
                  DEFAULT_PRIORITY,
                  &d,
                  &default_context_);
 
@@ skipping 193 matching lines @@
       SpawnedTestServer::SSLOptions::TLS_INTOLERANCE_RESET;
 
   ASSERT_NO_FATAL_FAILURE(DoFallbackTest(ssl_options));
   ExpectFailure(ERR_CONNECTION_RESET);
 }
 #endif  // !OS_ANDROID
 
 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_);
     default_context_.Init();
   }
   virtual ~HTTPSSessionTest() {}
 
  protected:
   MockCertVerifier cert_verifier_;
   TestNetworkDelegate default_network_delegate_;  // Must outlive URLRequest.
   TestURLRequestContext default_context_;
 };
 
 // Tests that session resumption is not attempted if an invalid certificate
 // is presented.
 TEST_F(HTTPSSessionTest, DontResumeSessionsForInvalidCertificates) {
   SpawnedTestServer::SSLOptions ssl_options;
   ssl_options.record_resume = true;
   SpawnedTestServer test_server(
       SpawnedTestServer::TYPE_HTTPS,
       ssl_options,
       base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
   ASSERT_TRUE(test_server.Start());
 
   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"),
                  DEFAULT_PRIORITY,
                  &d,
                  &default_context_);
 
     r.Start();
     EXPECT_TRUE(r.is_pending());
 
     base::RunLoop().Run();
 
     EXPECT_EQ(1, d.response_started_count());
   }
 
   reinterpret_cast<HttpCache*>(default_context_.http_transaction_factory())->
     CloseAllConnections();
 
   // 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"),
                  DEFAULT_PRIORITY,
                  &d,
                  &default_context_);
 
     r.Start();
     EXPECT_TRUE(r.is_pending());
 
@@ skipping 86 matching lines @@
         ev_test_policy_(
             new ScopedTestEVPolicy(EVRootCAMetadata::GetInstance(),
                                    kOCSPTestCertFingerprint,
                                    kOCSPTestCertPolicy)) {
   }
 
   virtual void SetUp() OVERRIDE {
     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()));
 
 #if defined(USE_NSS) || defined(OS_IOS)
     SetURLRequestContextForNSSHttpIO(&context_);
     EnsureNSSHttpIOInit();
 #endif
   }
 
@@ skipping 796 matching lines @@
 
     EXPECT_FALSE(r.is_pending());
     EXPECT_EQ(1, d->response_started_count());
     EXPECT_FALSE(d->received_data_before_response());
     EXPECT_EQ(d->bytes_received(), static_cast<int>(file_size));
   }
 }
 #endif  // !defined(DISABLE_FTP_SUPPORT)
 
 }  // namespace net