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 4060 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 438 matching lines @@
   }
 }
 
 namespace {
 
 const char kExtraHeader[] = "Allow-Snafu";
 const char kExtraValue[] = "fubar";
 
 class RedirectWithAdditionalHeadersDelegate : public TestDelegate {
   virtual void OnReceivedRedirect(net::URLRequest* request,
-                                  const GURL& new_url,
+                                  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,

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

While you're here, mind getting rid of these net::'s?

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

Done.

-                          const GURL& new_url,
-                          bool* defer_redirect) OVERRIDE {
-    TestDelegate::OnReceivedRedirect(request, new_url, defer_redirect);
+                                  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 3478 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