Include all server redirects in referrer chain

chrome/browser/safe_browsing/safe_browsing_navigation_observer_browsertest.cc

 // Copyright 2016 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 "base/strings/stringprintf.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/download/download_prefs.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/safe_browsing/download_protection_service.h"
 #include "chrome/browser/safe_browsing/safe_browsing_navigation_observer.h"
@@ skipping 205 matching lines @@
                              const GURL& expected_destination_url,
                              bool expected_is_user_initiated,
                              bool expected_has_committed,
                              bool expected_has_server_redirect,
                              const NavigationEvent& actual_nav_event) {
     EXPECT_EQ(expected_source_url, actual_nav_event.source_url);
     EXPECT_EQ(expected_source_main_frame_url,
               actual_nav_event.source_main_frame_url);
     EXPECT_EQ(expected_original_request_url,
               actual_nav_event.original_request_url);
-    EXPECT_EQ(expected_destination_url, actual_nav_event.destination_url);
+    EXPECT_EQ(expected_destination_url, actual_nav_event.GetDestinationUrl());
     EXPECT_EQ(expected_is_user_initiated, actual_nav_event.is_user_initiated);
     EXPECT_EQ(expected_has_committed, actual_nav_event.has_committed);
     EXPECT_EQ(expected_has_server_redirect,
-              actual_nav_event.has_server_redirect);
+              !actual_nav_event.server_redirect_urls.empty());
   }
 
-  void VerifyReferrerChainEntry(const GURL& expected_url,
-                                ReferrerChainEntry::URLType expected_type,
-                                const std::string& expected_ip_address,
-                                const GURL& expected_referrer_url,
-                                const GURL& expected_referrer_main_frame_url,
-                                bool expected_is_retargeting,
-                                ReferrerChainEntry* actual_entry) {
+  void VerifyReferrerChainEntry(
+      const GURL& expected_url,
+      const GURL& expected_main_frame_url,
+      ReferrerChainEntry::URLType expected_type,
+      const std::string& expected_ip_address,
+      const GURL& expected_referrer_url,
+      const GURL& expected_referrer_main_frame_url,
+      bool expected_is_retargeting,
+      const std::vector<GURL>& expected_server_redirects,
+      ReferrerChainEntry* actual_entry) {
     EXPECT_EQ(expected_url.spec(), actual_entry->url());
+    if (expected_main_frame_url.is_valid()) {

[Nathan Parker, 2017/01/27 22:53:37]

nit: some of these if()'s start with the populated case, and some start with the
unpopulated case.  It might be easier to read if the first branch was always the
empty/invalid case.

[Jialiu Lin, 2017/01/27 23:25:06]

You're right. Let me rotate them.

+      // main_frame_url only set if it is different from url.
+      EXPECT_EQ(expected_main_frame_url.spec(), actual_entry->main_frame_url());
+      EXPECT_NE(expected_main_frame_url.spec(), actual_entry->url());
+    } else {
+      EXPECT_FALSE(actual_entry->has_main_frame_url());
+    }
     EXPECT_EQ(expected_type, actual_entry->type());
     if (expected_ip_address.empty()) {
       ASSERT_EQ(0, actual_entry->ip_addresses_size());
     } else {
       ASSERT_EQ(1, actual_entry->ip_addresses_size());
       EXPECT_EQ(expected_ip_address, actual_entry->ip_addresses(0));
     }
     EXPECT_EQ(expected_referrer_url.spec(), actual_entry->referrer_url());
-    EXPECT_EQ(expected_referrer_main_frame_url.spec(),
-              actual_entry->referrer_main_frame_url());
+    if (expected_referrer_main_frame_url.is_valid()) {
+      // referrer_main_frame_url only set if it is different from referrer_url.
+      EXPECT_EQ(expected_referrer_main_frame_url.spec(),
+                actual_entry->referrer_main_frame_url());
+      EXPECT_NE(expected_referrer_main_frame_url.spec(),
+                actual_entry->referrer_url());
+    } else {
+      EXPECT_FALSE(actual_entry->has_referrer_main_frame_url());
+    }
     EXPECT_EQ(expected_is_retargeting, actual_entry->is_retargeting());
+    if (expected_server_redirects.empty()) {
+      EXPECT_EQ(0, actual_entry->server_redirect_chain_size());
+    } else {
+      ASSERT_EQ(static_cast<int>(expected_server_redirects.size()),
+                actual_entry->server_redirect_chain_size());
+      for (int i = 0; i<actual_entry->server_redirect_chain_size(); i++) {

[Nathan Parker, 2017/01/27 22:53:38]

nit: spaces around <

[Jialiu Lin, 2017/01/27 23:25:06]

Done.

+        EXPECT_EQ(expected_server_redirects[i].spec(),
+                  actual_entry->server_redirect_chain(i).url());
+      }
+    }
   }
 
   // Identify referrer chain of a DownloadItem and populate |referrer_chain|.
   void IdentifyReferrerChainForDownload(
       DownloadItem* download,
       ReferrerChain* referrer_chain) {
     int download_tab_id =
         SessionTabHelper::IdForTab(download->GetWebContents());
     // IdentifyReferrerChain should return SUCCESS(1), SUCCESS_LANDING_PAGE(2),
     // or SUCCESS_LANDING_REFERRER(3) in all these tests.
     EXPECT_LE(observer_manager_->IdentifyReferrerChainForDownload(
                   download->GetURL(), download_tab_id,
                   2,  // kDownloadAttributionUserGestureLimit
                   referrer_chain),
               SafeBrowsingNavigationObserverManager::SUCCESS_LANDING_REFERRER);
   }
 
   // Identify referrer chain of a PPAPI download and populate |referrer_chain|.
   void IdentifyReferrerChainForPPAPIDownload(
       const GURL& initiating_frame_url,
       content::WebContents* web_contents,
       ReferrerChain* referrer_chain) {
     int tab_id = SessionTabHelper::IdForTab(web_contents);
     bool has_user_gesture = observer_manager_->HasUserGesture(web_contents);
     observer_manager_->OnUserGestureConsumed(web_contents, base::Time::Now());
     EXPECT_LE(observer_manager_->IdentifyReferrerChainForPPAPIDownload(
                   initiating_frame_url,
+                  web_contents->GetLastCommittedURL(),
                   tab_id,
                   has_user_gesture,
                   2,  // kDownloadAttributionUserGestureLimit)
                   referrer_chain),
               SafeBrowsingNavigationObserverManager::SUCCESS_LANDING_REFERRER);
   }
 
   void VerifyHostToIpMap() {
     // Since all testing pages have the same host, there is only one entry in
     // host_to_ip_map_.
@@ skipping 56 matching lines @@
                         true,          // is_user_initiated,
                         false,         // has_committed
                         false,         // has_server_redirect
                         nav_map->at(download_url).at(0));
   VerifyHostToIpMap();
 
   ReferrerChain referrer_chain;
   IdentifyReferrerChainForDownload(GetDownload(), &referrer_chain);
   ASSERT_EQ(1U, referrer_chain.size());
   VerifyReferrerChainEntry(download_url,                      // url
+                           GURL(),                            // main_frame_url
                            ReferrerChainEntry::DOWNLOAD_URL,  // type
                            test_server_ip,                    // ip_address
                            GURL(),                            // referrer_url
                            GURL(),  // referrer_main_frame_url
                            false,   // is_retargeting
+                           std::vector<GURL>(),  // server redirects
                            referrer_chain[0].get());
 }
 // Click on a link and start download on the same page.
 IN_PROC_BROWSER_TEST_F(SBNavigationObserverBrowserTest, DirectDownload) {
   GURL initial_url = embedded_test_server()->GetURL(kSingleFrameTestURL);
   ClickTestLink("direct_download", 1, initial_url);
   GURL download_url = embedded_test_server()->GetURL(kDownloadItemURL);
   std::string test_server_ip(embedded_test_server()->host_port_pair().host());
   auto nav_map = navigation_map();
   ASSERT_TRUE(nav_map);
@@ skipping 15 matching lines @@
                         true,          // is_user_initiated,
                         false,         // has_committed
                         false,         // has_server_redirect
                         nav_map->at(download_url).at(0));
   VerifyHostToIpMap();
 
   ReferrerChain referrer_chain;
   IdentifyReferrerChainForDownload(GetDownload(), &referrer_chain);
   ASSERT_EQ(2U, referrer_chain.size());
   VerifyReferrerChainEntry(download_url,                      // url
+                           GURL(),                            // main_frame_url

[Nathan Parker, 2017/01/27 22:53:37]

(I don't know how to validate if these are correct)

[Jialiu Lin, 2017/01/27 23:25:06]

I don't think it is impossible to have a invalid main_frame_url as a parent of a
valid subframe url. If this happens in some weird corner cases, the
main_frame_url in the actual proto should not be set. 

                            ReferrerChainEntry::DOWNLOAD_URL,  // type
                            test_server_ip,                    // ip_address
                            initial_url,                       // referrer_url
-                           initial_url,  // referrer_main_frame_url
-                           false,        // is_retargeting
+                           GURL(),               // referrer_main_frame_url
+                           false,                // is_retargeting
+                           std::vector<GURL>(),  // server redirects
                            referrer_chain[0].get());
   VerifyReferrerChainEntry(initial_url,                       // url
+                           GURL(),                            // main_frame_url
                            ReferrerChainEntry::LANDING_PAGE,  // type
                            test_server_ip,                    // ip_address
                            GURL(),                            // referrer_url
                            GURL(),  // referrer_main_frame_url
                            false,   // is_retargeting
+                           std::vector<GURL>(),  // server redirects
                            referrer_chain[1].get());
 }
 
 // Click on a link with rel="noreferrer" attribute, and start download on the
 // same page.
 IN_PROC_BROWSER_TEST_F(SBNavigationObserverBrowserTest,
                        DirectDownloadNoReferrer) {
   GURL initial_url = embedded_test_server()->GetURL(kSingleFrameTestURL);
   ClickTestLink("direct_download_noreferrer", 1, initial_url);
   GURL download_url = embedded_test_server()->GetURL(kDownloadItemURL);
@@ skipping 18 matching lines @@
                         true,          // is_user_initiated,
                         false,         // has_committed
                         false,         // has_server_redirect
                         nav_map->at(download_url).at(0));
   VerifyHostToIpMap();
 
   ReferrerChain referrer_chain;
   IdentifyReferrerChainForDownload(GetDownload(), &referrer_chain);
   ASSERT_EQ(2U, referrer_chain.size());
   VerifyReferrerChainEntry(download_url,                      // url
+                           GURL(),                            // main_frame_url
                            ReferrerChainEntry::DOWNLOAD_URL,  // type
                            test_server_ip,                    // ip_address
                            initial_url,                       // referrer_url
-                           initial_url,  // referrer_main_frame_url
-                           false,        // is_retargeting
+                           GURL(),  // referrer_main_frame_url
+                           false,   // is_retargeting
+                           std::vector<GURL>(),  // server redirects
                            referrer_chain[0].get());
   VerifyReferrerChainEntry(initial_url,                       // url
+                           GURL(),                            // main_frame_url
                            ReferrerChainEntry::LANDING_PAGE,  // type
                            test_server_ip,                    // ip_address
                            GURL(),                            // referrer_url
                            GURL(),  // referrer_main_frame_url
                            false,   // is_retargeting
+                           std::vector<GURL>(),  // server redirects
                            referrer_chain[1].get());
 }
 
 // Click on a link with rel="noreferrer" attribute, and start download in a
 // new tab using target=_blank.
 IN_PROC_BROWSER_TEST_F(SBNavigationObserverBrowserTest,
                        DirectDownloadNoReferrerTargetBlank) {
   GURL initial_url = embedded_test_server()->GetURL(kSingleFrameTestURL);
   ClickTestLink("direct_download_noreferrer_target_blank", 1, initial_url);
   GURL download_url = embedded_test_server()->GetURL(kDownloadItemURL);
@@ skipping 32 matching lines @@
                         false,         // is_user_initiated,
                         false,         // has_committed
                         false,         // has_server_redirect
                         nav_map->at(download_url).at(1));
   VerifyHostToIpMap();
 
   ReferrerChain referrer_chain;
   IdentifyReferrerChainForDownload(GetDownload(), &referrer_chain);
   ASSERT_EQ(2U, referrer_chain.size());
   VerifyReferrerChainEntry(download_url,                      // url
+                           GURL(),                            // main_frame_url
                            ReferrerChainEntry::DOWNLOAD_URL,  // type
                            test_server_ip,                    // ip_address
                            initial_url,                       // referrer_url
-                           initial_url,  // referrer_main_frame_url
-                           true,         // is_retargeting
+                           GURL(),  // referrer_main_frame_url
+                           true,    // is_retargeting
+                           std::vector<GURL>(),  // server redirects
                            referrer_chain[0].get());
   VerifyReferrerChainEntry(initial_url,                       // url
+                           GURL(),                            // main_frame_url
                            ReferrerChainEntry::LANDING_PAGE,  // type
                            test_server_ip,                    // ip_address
                            GURL(),                            // referrer_url
                            GURL(),  // referrer_main_frame_url
                            false,   // is_retargeting
+                           std::vector<GURL>(),  // server redirects
                            referrer_chain[1].get());
 }
 
 // Click on a link which navigates to a page then redirects to a download using
 // META HTTP-EQUIV="refresh". All transitions happen in the same tab.
 IN_PROC_BROWSER_TEST_F(SBNavigationObserverBrowserTest,
                        SingleMetaRefreshRedirect) {
   GURL initial_url = embedded_test_server()->GetURL(kSingleFrameTestURL);
   ClickTestLink("single_meta_refresh_redirect", 2, initial_url);
   GURL redirect_url = embedded_test_server()->GetURL(kRedirectURL);
@@ skipping 30 matching lines @@
                         false,         // is_user_initiated,
                         false,         // has_committed
                         false,         // has_server_redirect
                         nav_map->at(download_url).at(0));
   VerifyHostToIpMap();
 
   ReferrerChain referrer_chain;
   IdentifyReferrerChainForDownload(GetDownload(), &referrer_chain);
   ASSERT_EQ(3U, referrer_chain.size());
   VerifyReferrerChainEntry(download_url,                      // url
+                           GURL(),                            // main_frame_url
                            ReferrerChainEntry::DOWNLOAD_URL,  // type
                            test_server_ip,                    // ip_address
                            redirect_url,                      // referrer_url
-                           redirect_url,  // referrer_main_frame_url
-                           false,         // is_retargeting
+                           GURL(),  // referrer_main_frame_url
+                           false,   // is_retargeting
+                           std::vector<GURL>(),  // server redirects
                            referrer_chain[0].get());
   VerifyReferrerChainEntry(redirect_url,                         // url
+                           GURL(),  // main_frame_url
                            ReferrerChainEntry::CLIENT_REDIRECT,  // type
                            test_server_ip,                       // ip_address
                            initial_url,                          // referrer_url
-                           initial_url,  // referrer_main_frame_url
-                           false,        // is_retargeting
+                           GURL(),  // referrer_main_frame_url
+                           false,   // is_retargeting
+                           std::vector<GURL>(),  // server redirects
                            referrer_chain[1].get());
   VerifyReferrerChainEntry(initial_url,                       // url
+                           GURL(),                            // main_frame_url
                            ReferrerChainEntry::LANDING_PAGE,  // type
                            test_server_ip,                    // ip_address
                            GURL(),                            // referrer_url
                            GURL(),  // referrer_main_frame_url
                            false,   // is_retargeting
+                           std::vector<GURL>(),  // server redirects
                            referrer_chain[2].get());
 }
 
 // Click on a link which navigates to a page then redirects to a download using
 // META HTTP-EQUIV="refresh". First navigation happens in target blank.
 IN_PROC_BROWSER_TEST_F(SBNavigationObserverBrowserTest,
                        SingleMetaRefreshRedirectTargetBlank) {
   GURL initial_url = embedded_test_server()->GetURL(kSingleFrameTestURL);
   ClickTestLink("single_meta_refresh_redirect_target_blank", 2, initial_url);
   GURL redirect_url = embedded_test_server()->GetURL(kRedirectURL);
@@ skipping 39 matching lines @@
                         false,         // is_user_initiated,
                         false,         // has_committed
                         false,         // has_server_redirect
                         nav_map->at(download_url).at(0));
   VerifyHostToIpMap();
 
   ReferrerChain referrer_chain;
   IdentifyReferrerChainForDownload(GetDownload(), &referrer_chain);
   ASSERT_EQ(3U, referrer_chain.size());
   VerifyReferrerChainEntry(download_url,                      // url
+                           GURL(),                            // main_frame_url
                            ReferrerChainEntry::DOWNLOAD_URL,  // type
                            test_server_ip,                    // ip_address
                            redirect_url,                      // referrer_url
-                           redirect_url,  // referrer_main_frame_url
-                           false,         // is_retargeting
+                           GURL(),  // referrer_main_frame_url
+                           false,   // is_retargeting
+                           std::vector<GURL>(),  // server redirects
                            referrer_chain[0].get());
   VerifyReferrerChainEntry(redirect_url,                         // url
+                           GURL(),  // main_frame_url
                            ReferrerChainEntry::CLIENT_REDIRECT,  // type
                            test_server_ip,                       // ip_address
                            initial_url,                          // referrer_url
-                           initial_url,  // referrer_main_frame_url
-                           true,         // is_retargeting
+                           GURL(),  // referrer_main_frame_url
+                           true,    // is_retargeting
+                           std::vector<GURL>(),  // server redirects
                            referrer_chain[1].get());
   VerifyReferrerChainEntry(initial_url,                       // url
+                           GURL(),                            // main_frame_url
                            ReferrerChainEntry::LANDING_PAGE,  // type
                            test_server_ip,                    // ip_address
                            GURL(),                            // referrer_url
                            GURL(),  // referrer_main_frame_url
                            false,   // is_retargeting
+                           std::vector<GURL>(),  // server redirects
                            referrer_chain[2].get());
 }
 
 // Click on a link which redirects twice before reaching download using
 // META HTTP-EQUIV="refresh". All transitions happen in the same tab.
 IN_PROC_BROWSER_TEST_F(SBNavigationObserverBrowserTest,
                        MultiMetaRefreshRedirects) {
   GURL initial_url = embedded_test_server()->GetURL(kSingleFrameTestURL);
   ClickTestLink("multiple_meta_refresh_redirects", 3, initial_url);
   GURL first_redirect_url = embedded_test_server()->GetURL(
@@ skipping 40 matching lines @@
                         false,                // is_user_initiated,
                         false,                // has_committed
                         false,                // has_server_redirect
                         nav_map->at(download_url).at(0));
   VerifyHostToIpMap();
 
   ReferrerChain referrer_chain;
   IdentifyReferrerChainForDownload(GetDownload(), &referrer_chain);
   ASSERT_EQ(4U, referrer_chain.size());
   VerifyReferrerChainEntry(download_url,                      // url
+                           GURL(),                            // main_frame_url
                            ReferrerChainEntry::DOWNLOAD_URL,  // type
                            test_server_ip,                    // ip_address
                            second_redirect_url,               // referrer_url
-                           second_redirect_url,  // referrer_main_frame_url
-                           false,                // is_retargeting
+                           GURL(),  // referrer_main_frame_url
+                           false,   // is_retargeting
+                           std::vector<GURL>(),  // server redirects
                            referrer_chain[0].get());
   VerifyReferrerChainEntry(second_redirect_url,                  // url
+                           GURL(),  // main_frame_url
                            ReferrerChainEntry::CLIENT_REDIRECT,  // type
                            test_server_ip,                       // ip_address
                            first_redirect_url,                   // referrer_url
-                           first_redirect_url,  // referrer_main_frame_url
-                           false,               // is_retargeting
+                           GURL(),   // referrer_main_frame_url
+                           false,    // is_retargeting
+                           std::vector<GURL>(),  // server redirects
                            referrer_chain[1].get());
   VerifyReferrerChainEntry(first_redirect_url,                   // url
+                           GURL(),  // main_frame_url
                            ReferrerChainEntry::CLIENT_REDIRECT,  // type
                            test_server_ip,                       // ip_address
                            initial_url,                          // referrer_url
-                           initial_url,  // referrer_main_frame_url
-                           false,        // is_retargeting
+                           GURL(),  // referrer_main_frame_url
+                           false,   // is_retargeting
+                           std::vector<GURL>(),  // server redirects
                            referrer_chain[2].get());
   VerifyReferrerChainEntry(initial_url,                       // url
+                           GURL(),                            // main_frame_url
                            ReferrerChainEntry::LANDING_PAGE,  // type
                            test_server_ip,                    // ip_address
                            GURL(),                            // referrer_url
                            GURL(),  // referrer_main_frame_url
                            false,   // is_retargeting
+                           std::vector<GURL>(),  // server redirects
                            referrer_chain[3].get());
 }
 
 // Click on a link which redirects to download using window.location.
 // All transitions happen in the same tab.
 IN_PROC_BROWSER_TEST_F(SBNavigationObserverBrowserTest,
                        WindowLocationRedirect) {
   GURL initial_url = embedded_test_server()->GetURL(kSingleFrameTestURL);
   ClickTestLink("window_location_redirection", 1, initial_url);
   GURL download_url = embedded_test_server()->GetURL(kDownloadItemURL);
@@ skipping 17 matching lines @@
                         download_url,  // destination_url
                         true,          // is_user_initiated,
                         false,         // has_committed
                         false,         // has_server_redirect
                         nav_map->at(download_url).at(0));
 
   ReferrerChain referrer_chain;
   IdentifyReferrerChainForDownload(GetDownload(), &referrer_chain);
   ASSERT_EQ(2U, referrer_chain.size());
   VerifyReferrerChainEntry(download_url,                      // url
+                           GURL(),                            // main_frame_url
                            ReferrerChainEntry::DOWNLOAD_URL,  // type
                            test_server_ip,                    // ip_address
                            initial_url,                       // referrer_url
-                           initial_url,  // referrer_main_frame_url
-                           false,        // is_retargeting
+                           GURL(),  // referrer_main_frame_url
+                           false,   // is_retargeting
+                           std::vector<GURL>(),  // server redirects
                            referrer_chain[0].get());
   VerifyReferrerChainEntry(initial_url,                       // url
+                           GURL(),                            // main_frame_url
                            ReferrerChainEntry::LANDING_PAGE,  // type
                            test_server_ip,                    // ip_address
                            GURL(),                            // referrer_url
                            GURL(),  // referrer_main_frame_url
                            false,   // is_retargeting
+                           std::vector<GURL>(),  // server redirects
                            referrer_chain[1].get());
 }
 
 // Click on a link which redirects twice until it reaches download using a
 // mixture of meta refresh and window.location. All transitions happen in the
 // same tab.
 IN_PROC_BROWSER_TEST_F(SBNavigationObserverBrowserTest, MixRedirects) {
   GURL initial_url = embedded_test_server()->GetURL(kSingleFrameTestURL);
   ClickTestLink("mix_redirects", 2, initial_url);
   GURL redirect_url = embedded_test_server()->GetURL(kRedirectURL);
@@ skipping 28 matching lines @@
                         false,         // is_user_initiated,
                         false,         // has_committed
                         false,         // has_server_redirect
                         nav_map->at(download_url).at(0));
   VerifyHostToIpMap();
 
   ReferrerChain referrer_chain;
   IdentifyReferrerChainForDownload(GetDownload(), &referrer_chain);
   ASSERT_EQ(3U, referrer_chain.size());
   VerifyReferrerChainEntry(download_url,                      // url
+                           GURL(),                            // main_frame_url
                            ReferrerChainEntry::DOWNLOAD_URL,  // type
                            test_server_ip,                    // ip_address
                            redirect_url,                      // referrer_url
-                           redirect_url,  // referrer_main_frame_url
-                           false,         // is_retargeting
+                           GURL(),  // referrer_main_frame_url
+                           false,   // is_retargeting
+                           std::vector<GURL>(),  // server redirects
                            referrer_chain[0].get());
   VerifyReferrerChainEntry(redirect_url,                         // url
+                           GURL(),  // main_frame_url
                            ReferrerChainEntry::CLIENT_REDIRECT,  // type
                            test_server_ip,                       // ip_address
                            initial_url,                          // referrer_url
-                           initial_url,  // referrer_main_frame_url
-                           false,        // is_retargeting
+                           GURL(),  // referrer_main_frame_url
+                           false,   // is_retargeting
+                           std::vector<GURL>(),  // server redirects
                            referrer_chain[1].get());
   VerifyReferrerChainEntry(initial_url,                       // url
+                           GURL(),                            // main_frame_url
                            ReferrerChainEntry::LANDING_PAGE,  // type
                            test_server_ip,                    // ip_address
                            GURL(),                            // referrer_url
                            GURL(),  // referrer_main_frame_url
                            false,   // is_retargeting
+                           std::vector<GURL>(),  // server redirects
                            referrer_chain[2].get());
 }
 
 // Use javascript to open download in a new tab.
 IN_PROC_BROWSER_TEST_F(SBNavigationObserverBrowserTest, NewTabDownload) {
   GURL initial_url = embedded_test_server()->GetURL(kSingleFrameTestURL);
   ClickTestLink("new_tab_download", 2, initial_url);
   GURL download_url = embedded_test_server()->GetURL(kDownloadItemURL);
   GURL blank_url = GURL(url::kAboutBlankURL);
   std::string test_server_ip(embedded_test_server()->host_port_pair().host());
@@ skipping 41 matching lines @@
                         false,         // has_server_redirect
                         nav_map->at(download_url).at(0));
   EXPECT_EQ(nav_map->at(download_url).at(0).source_tab_id,
             nav_map->at(download_url).at(0).target_tab_id);
   VerifyHostToIpMap();
 
   ReferrerChain referrer_chain;
   IdentifyReferrerChainForDownload(GetDownload(), &referrer_chain);
   ASSERT_EQ(3U, referrer_chain.size());
   VerifyReferrerChainEntry(download_url,                      // url
+                           GURL(),                            // main_frame_url
                            ReferrerChainEntry::DOWNLOAD_URL,  // type
                            test_server_ip,                    // ip_address
                            blank_url,                         // referrer_url
-                           blank_url,  // referrer_main_frame_url
-                           false,      // is_retargeting
+                           GURL(),  // referrer_main_frame_url
+                           false,   // is_retargeting
+                           std::vector<GURL>(),  // server redirects
                            referrer_chain[0].get());
   VerifyReferrerChainEntry(blank_url,                            // url
+                           GURL(),  // main_frame_url
                            ReferrerChainEntry::CLIENT_REDIRECT,  // type
                            "",                                   // ip_address
                            initial_url,                          // referrer_url
-                           initial_url,  // referrer_main_frame_url
-                           true,         // is_retargeting
+                           GURL(),  // referrer_main_frame_url
+                           true,    // is_retargeting
+                           std::vector<GURL>(),  // server redirects
                            referrer_chain[1].get());
   VerifyReferrerChainEntry(initial_url,                       // url
+                           GURL(),                            // main_frame_url
                            ReferrerChainEntry::LANDING_PAGE,  // type
                            test_server_ip,                    // ip_address
                            GURL(),                            // referrer_url
                            GURL(),  // referrer_main_frame_url
                            false,   // is_retargeting
+                           std::vector<GURL>(),  // server redirects
                            referrer_chain[2].get());
 }
 
 // Use javascript to open download in a new tab and download has a data url.
 IN_PROC_BROWSER_TEST_F(SBNavigationObserverBrowserTest,
                        NewTabDownloadWithDataURL) {
   GURL initial_url = embedded_test_server()->GetURL(kSingleFrameTestURL);
   ClickTestLink("new_tab_download_with_data_url", 2, initial_url);
   GURL download_url = GURL(kDownloadDataURL);
   GURL blank_url = GURL(url::kAboutBlankURL);
@@ skipping 43 matching lines @@
                         false,         // has_server_redirect
                         nav_map->at(download_url).at(0));
   EXPECT_TRUE(nav_map->at(download_url).at(0).source_tab_id ==
               nav_map->at(download_url).at(0).target_tab_id);
   VerifyHostToIpMap();
 
   ReferrerChain referrer_chain;
   IdentifyReferrerChainForDownload(GetDownload(), &referrer_chain);
   ASSERT_EQ(3U, referrer_chain.size());
   VerifyReferrerChainEntry(download_url,                      // url
+                           GURL(),                            // main_frame_url
                            ReferrerChainEntry::DOWNLOAD_URL,  // type
                            "",                                // ip_address
                            blank_url,                         // referrer_url
-                           blank_url,  // referrer_main_frame_url
-                           false,      // is_retargeting
+                           GURL(),  // referrer_main_frame_url
+                           false,   // is_retargeting
+                           std::vector<GURL>(),  // server redirects
                            referrer_chain[0].get());
   VerifyReferrerChainEntry(blank_url,                            // url
+                           GURL(),  // main_frame_url
                            ReferrerChainEntry::CLIENT_REDIRECT,  // type
                            "",                                   // ip_address
                            initial_url,                          // referrer_url
-                           initial_url,  // referrer_main_frame_url
-                           true,         // is_retargeting
+                           GURL(),  // referrer_main_frame_url
+                           true,    // is_retargeting
+                           std::vector<GURL>(),  // server redirects
                            referrer_chain[1].get());
   VerifyReferrerChainEntry(initial_url,                       // url
+                           GURL(),                            // main_frame_url
                            ReferrerChainEntry::LANDING_PAGE,  // type
                            test_server_ip,                    // ip_address
                            GURL(),                            // referrer_url
                            GURL(),  // referrer_main_frame_url
                            false,   // is_retargeting
+                           std::vector<GURL>(),  // server redirects
                            referrer_chain[2].get());
 }
 
 // TODO(jialiul): Need to figure out why this test is failing on Windows and
 // flaky on other platforms.
 #define MAYBE_DownloadViaHTML5FileApi DISABLED_DownloadViaHTML5FileApi
 // Download via html5 file API.
 IN_PROC_BROWSER_TEST_F(SBNavigationObserverBrowserTest,
                        MAYBE_DownloadViaHTML5FileApi) {
   GURL initial_url = embedded_test_server()->GetURL(kSingleFrameTestURL);
@@ skipping 23 matching lines @@
                         true,          // is_user_initiated,
                         false,         // has_committed
                         false,         // has_server_redirect
                         nav_map->at(download_url).at(0));
   VerifyHostToIpMap();
 
   ReferrerChain referrer_chain;
   IdentifyReferrerChainForDownload(GetDownload(), &referrer_chain);
   ASSERT_EQ(2U, referrer_chain.size());
   VerifyReferrerChainEntry(download_url,                      // url
+                           GURL(),                            // main_frame_url
                            ReferrerChainEntry::DOWNLOAD_URL,  // type
                            "",                                // ip_address
                            initial_url,                       // referrer_url
-                           initial_url,  // referrer_main_frame_url
-                           false,        // is_retargeting
+                           GURL(),  // referrer_main_frame_url
+                           false,   // is_retargeting
+                           std::vector<GURL>(),  // server redirects
                            referrer_chain[0].get());
   VerifyReferrerChainEntry(initial_url,                       // url
+                           GURL(),                            // main_frame_url
                            ReferrerChainEntry::LANDING_PAGE,  // type
                            test_server_ip,                    // ip_address
                            GURL(),                            // referrer_url
                            GURL(),  // referrer_main_frame_url
                            false,   // is_retargeting
+                           std::vector<GURL>(),  // server redirects
                            referrer_chain[1].get());
 }
 
 // Click a link in a subframe and start download.
 IN_PROC_BROWSER_TEST_F(SBNavigationObserverBrowserTest,
                        SubFrameDirectDownload) {
   GURL initial_url = embedded_test_server()->GetURL(kSingleFrameTestURL);
   ClickTestLink("sub_frame_download_attribution", 1, initial_url);
   std::string test_name =
       base::StringPrintf("%s', '%s", "iframe1", "iframe_direct_download");
@@ skipping 52 matching lines @@
                         true,                  // is_user_initiated,
                         false,                 // has_committed
                         false,                 // has_server_redirect
                         nav_map->at(download_url).at(0));
   VerifyHostToIpMap();
 
   ReferrerChain referrer_chain;
   IdentifyReferrerChainForDownload(GetDownload(), &referrer_chain);
   ASSERT_EQ(4U, referrer_chain.size());
   VerifyReferrerChainEntry(download_url,                      // url
+                           GURL(),                            // main_frame_url
                            ReferrerChainEntry::DOWNLOAD_URL,  // type
                            test_server_ip,                    // ip_address
                            iframe_url,                        // referrer_url
                            multi_frame_test_url,  // referrer_main_frame_url
                            false,                 // is_retargeting
+                           std::vector<GURL>(),   // server redirects
                            referrer_chain[0].get());
   VerifyReferrerChainEntry(iframe_url,                        // url
+                           multi_frame_test_url,              // main_frame_url
                            ReferrerChainEntry::LANDING_PAGE,  // type
                            test_server_ip,                    // ip_address
                            GURL(),                            // referrer_url
                            multi_frame_test_url,  // referrer_main_frame_url
                            false,                 // is_retargeting
+                           std::vector<GURL>(),   // server redirects
                            referrer_chain[1].get());
   VerifyReferrerChainEntry(multi_frame_test_url,                 // url
+                           GURL(),  // main_frame_url
                            ReferrerChainEntry::CLIENT_REDIRECT,  // type
                            test_server_ip,                       // ip_address
                            initial_url,  // referrer_url
-                           initial_url,  // referrer_main_frame_url
-                           false,                 // is_retargeting
+                           GURL(),  // referrer_main_frame_url
+                           false,   // is_retargeting
+                           std::vector<GURL>(),  // server redirects
                            referrer_chain[2].get());
   VerifyReferrerChainEntry(initial_url,                           // url
+                           GURL(),  // main_frame_url
                            ReferrerChainEntry::LANDING_REFERRER,  // type
                            test_server_ip,                        // ip_address
                            GURL(),  // referrer_url
                            GURL(),  // referrer_main_frame_url
-                           false,                 // is_retargeting
+                           false,   // is_retargeting
+                           std::vector<GURL>(),  // server redirects
                            referrer_chain[3].get());
 }
 
 // Click a link in a subframe and open download in a new tab.
 IN_PROC_BROWSER_TEST_F(SBNavigationObserverBrowserTest,
                        SubFrameNewTabDownload) {
   GURL initial_url = embedded_test_server()->GetURL(kSingleFrameTestURL);
   ClickTestLink("sub_frame_download_attribution", 1, initial_url);
   std::string test_name =
       base::StringPrintf("%s', '%s", "iframe2", "iframe_new_tab_download");
@@ skipping 70 matching lines @@
                         false,         // is_user_initiated,
                         false,         // has_committed
                         false,         // has_server_redirect
                         nav_map->at(download_url).at(0));
   VerifyHostToIpMap();
 
   ReferrerChain referrer_chain;
   IdentifyReferrerChainForDownload(GetDownload(), &referrer_chain);
   EXPECT_EQ(5U, referrer_chain.size());
   VerifyReferrerChainEntry(download_url,                      // url
+                           GURL(),                            // main_frame_url
                            ReferrerChainEntry::DOWNLOAD_URL,  // type
                            test_server_ip,                    // ip_address
                            blank_url,                         // referrer_url
-                           blank_url,  // referrer_main_frame_url
-                           false,      // is_retargeting
+                           GURL(),  // referrer_main_frame_url
+                           false,   // is_retargeting
+                           std::vector<GURL>(),  // server redirects
                            referrer_chain[0].get());
   VerifyReferrerChainEntry(blank_url,                            // url
+                           GURL(),                            // main_frame_url
                            ReferrerChainEntry::CLIENT_REDIRECT,  // type
                            "",                                   // ip_address
                            iframe_retargeting_url,               // referrer_url
                            multi_frame_test_url,  // referrer_main_frame_url
                            true,                  // is_retargeting
+                           std::vector<GURL>(),   // server redirects
                            referrer_chain[1].get());
   VerifyReferrerChainEntry(iframe_retargeting_url,            // url
+                           multi_frame_test_url,              // main_frame_url
                            ReferrerChainEntry::LANDING_PAGE,  // type
                            test_server_ip,                    // ip_address
                            GURL(),                            // referrer_url
                            multi_frame_test_url,  // referrer_main_frame_url
                            false,                 // is_retargeting
+                          std::vector<GURL>(),    // server redirects
                            referrer_chain[2].get());
   VerifyReferrerChainEntry(multi_frame_test_url,                 // url
+                           GURL(),  // main_frame_url
                            ReferrerChainEntry::CLIENT_REDIRECT,  // type
                            test_server_ip,                       // ip_address
                            initial_url,  // referrer_url
-                           initial_url,  // referrer_main_frame_url
-                           false,                 // is_retargeting
+                           GURL(),  // referrer_main_frame_url
+                           false,   // is_retargeting
+                           std::vector<GURL>(),  // server redirects
                            referrer_chain[3].get());
   VerifyReferrerChainEntry(initial_url,                           // url
+                           GURL(),  // main_frame_url
                            ReferrerChainEntry::LANDING_REFERRER,  // type
                            test_server_ip,                        // ip_address
                            GURL(),  // referrer_url
                            GURL(),  // referrer_main_frame_url
-                           false,                 // is_retargeting
+                           false,   // is_retargeting
+                           std::vector<GURL>(),  // server redirects
                            referrer_chain[4].get());
 }
 
 // Click a link which redirects to the landing page, and then click on the
 // landing page to trigger download.
 IN_PROC_BROWSER_TEST_F(SBNavigationObserverBrowserTest, CompleteReferrerChain) {
   GURL initial_url = embedded_test_server()->GetURL(kSingleFrameTestURL);
   ClickTestLink("complete_referrer_chain", 2, initial_url);
   GURL redirect_url = embedded_test_server()->GetURL(kRedirectToLandingURL);
   GURL landing_url = embedded_test_server()->GetURL(kLandingURL);
@@ skipping 38 matching lines @@
                         true,          // is_user_initiated,
                         false,         // has_committed
                         false,         // has_server_redirect
                         nav_map->at(download_url).at(0));
   VerifyHostToIpMap();
 
   ReferrerChain referrer_chain;
   IdentifyReferrerChainForDownload(GetDownload(), &referrer_chain);
   EXPECT_EQ(4U, referrer_chain.size());
   VerifyReferrerChainEntry(download_url,                      // url
+                           GURL(),                            // main_frame_url
                            ReferrerChainEntry::DOWNLOAD_URL,  // type
                            test_server_ip,                    // ip_address
                            landing_url,                       // referrer_url
-                           landing_url,  // referrer_main_frame_url
-                           false,        // is_retargeting
+                           GURL(),  // referrer_main_frame_url
+                           false,   // is_retargeting
+                           std::vector<GURL>(),  // server redirects
                            referrer_chain[0].get());
   VerifyReferrerChainEntry(landing_url,                       // url
+                           GURL(),                            // main_frame_url
                            ReferrerChainEntry::LANDING_PAGE,  // type
                            test_server_ip,                    // ip_address
                            redirect_url,                      // referrer_url
-                           redirect_url,  // referrer_main_frame_url
-                           false,         // is_retargeting
+                           GURL(),  // referrer_main_frame_url
+                           false,   // is_retargeting
+                           std::vector<GURL>(),  // server redirects
                            referrer_chain[1].get());
   VerifyReferrerChainEntry(redirect_url,                         // url
+                           GURL(),                            // main_frame_url
                            ReferrerChainEntry::CLIENT_REDIRECT,  // type
                            test_server_ip,                       // ip_address
                            initial_url,                          // referrer_url
-                           initial_url,  // referrer_main_frame_url
-                           false,        // is_retargeting
+                           GURL(),  // referrer_main_frame_url
+                           false,   // is_retargeting
+                           std::vector<GURL>(),  // server redirects
                            referrer_chain[2].get());
   VerifyReferrerChainEntry(
       initial_url,                           // url
+      GURL(),                                // main_frame_url
       ReferrerChainEntry::LANDING_REFERRER,  // type
       test_server_ip,                        // ip_address
       GURL(),  // referrer_url is empty since this beyonds 2 clicks.
       GURL(),  // referrer_main_frame_url is empty for the same reason.
       false,   // is_retargeting
+      std::vector<GURL>(),  // server redirects
       referrer_chain[3].get());
 }
 
 // Click three links before reaching download.
 IN_PROC_BROWSER_TEST_F(SBNavigationObserverBrowserTest,
                        ReferrerAttributionWithinTwoUserGestures) {
   GURL initial_url = embedded_test_server()->GetURL(kSingleFrameTestURL);
   ClickTestLink("attribution_within_two_user_gestures", 1, initial_url);
   GURL page_before_landing_referrer_url =
       embedded_test_server()->GetURL(kPageBeforeLandingReferrerURL);
@@ skipping 53 matching lines @@
                         true,          // is_user_initiated,
                         false,         // has_committed
                         false,         // has_server_redirect
                         nav_map->at(download_url).at(0));
   VerifyHostToIpMap();
 
   ReferrerChain referrer_chain;
   IdentifyReferrerChainForDownload(GetDownload(), &referrer_chain);
   EXPECT_EQ(3U, referrer_chain.size());
   VerifyReferrerChainEntry(download_url,                      // url
+                           GURL(),                            // main_frame_url
                            ReferrerChainEntry::DOWNLOAD_URL,  // type
                            test_server_ip,                    // ip_address
                            landing_url,                       // referrer_url
-                           landing_url,  // referrer_main_frame_url
-                           false,        // is_retargeting
+                           GURL(),  // referrer_main_frame_url
+                           false,   // is_retargeting
+                           std::vector<GURL>(),  // server redirects
                            referrer_chain[0].get());
   VerifyReferrerChainEntry(landing_url,                       // url
+                           GURL(),                            // main_frame_url
                            ReferrerChainEntry::LANDING_PAGE,  // type
                            test_server_ip,                    // ip_address
                            landing_referrer_url,              // referrer_url
-                           landing_referrer_url,  // referrer_main_frame_url
-                           false,                 // is_retargeting
+                           GURL(),  // referrer_main_frame_url
+                           false,   // is_retargeting
+                           std::vector<GURL>(),  // server redirects
                            referrer_chain[1].get());
   VerifyReferrerChainEntry(
       landing_referrer_url,                  // url
+      GURL(),                                // main_frame_url
       ReferrerChainEntry::LANDING_REFERRER,  // type
       test_server_ip,                        // ip_address
       GURL(),  // referrer_url is empty since this beyonds 2 clicks.
       GURL(),  // referrer_main_frame_url is empty for the same reason.
       false,   // is_retargeting
+      std::vector<GURL>(),  // server redirects
       referrer_chain[2].get());
   // page_before_landing_referrer_url is not in referrer chain.
 }
 
 // Click a link which redirects to a PPAPI landing page.
 IN_PROC_BROWSER_TEST_F(SBNavigationObserverBrowserTest,
                        PPAPIDownloadWithUserGestureOnHostingFrame) {
   GURL initial_url = embedded_test_server()->GetURL(kSingleFrameTestURL);
   ClickTestLink("complete_referrer_chain", 2, initial_url);
   GURL redirect_url = embedded_test_server()->GetURL(kRedirectToLandingURL);
@@ skipping 34 matching lines @@
                         nav_map->at(landing_url).at(0));
   VerifyHostToIpMap();
 
   ReferrerChain referrer_chain;
   IdentifyReferrerChainForPPAPIDownload(
       landing_url,
       browser()->tab_strip_model()->GetActiveWebContents(),
       &referrer_chain);
   EXPECT_EQ(3U, referrer_chain.size());
   VerifyReferrerChainEntry(landing_url,                       // url
+                           GURL(),                            // main_frame_url
                            ReferrerChainEntry::LANDING_PAGE,  // type
                            test_server_ip,                    // ip_address
                            redirect_url,                      // referrer_url
-                           redirect_url,  // referrer_main_frame_url
-                           false,         // is_retargeting
+                           GURL(),  // referrer_main_frame_url
+                           false,   // is_retargeting
+                           std::vector<GURL>(),  // server redirects
                            referrer_chain[0].get());
   VerifyReferrerChainEntry(redirect_url,                         // url
+                           GURL(),                            // main_frame_url
                            ReferrerChainEntry::CLIENT_REDIRECT,  // type
                            test_server_ip,                       // ip_address
                            initial_url,                          // referrer_url
-                           initial_url,  // referrer_main_frame_url
-                           false,        // is_retargeting
+                           GURL(),  // referrer_main_frame_url
+                           false,   // is_retargeting
+                           std::vector<GURL>(),  // server redirects
                            referrer_chain[1].get());
   VerifyReferrerChainEntry(
       initial_url,                           // url
+      GURL(),                                // main_frame_url
       ReferrerChainEntry::LANDING_REFERRER,  // type
       test_server_ip,                        // ip_address
       GURL(),  // referrer_url is empty since this beyonds 2 clicks.
       GURL(),  // referrer_main_frame_url is empty for the same reason.
       false,   // is_retargeting
+      std::vector<GURL>(),  // server redirects
       referrer_chain[2].get());
 }
 
 // Click a link which redirects to a page that triggers PPAPI download without
 // user gesture (a.k.a not a landing page).
 IN_PROC_BROWSER_TEST_F(SBNavigationObserverBrowserTest,
                        PPAPIDownloadWithoutUserGestureOnHostingFrame) {
   GURL landing_url = embedded_test_server()->GetURL(kSingleFrameTestURL);
   ClickTestLink("complete_referrer_chain", 2, landing_url);
   GURL redirect_url = embedded_test_server()->GetURL(kRedirectToLandingURL);
@@ skipping 32 matching lines @@
                         nav_map->at(hosting_url).at(0));
   VerifyHostToIpMap();
 
   ReferrerChain referrer_chain;
   IdentifyReferrerChainForPPAPIDownload(
       hosting_url,
       browser()->tab_strip_model()->GetActiveWebContents(),
       &referrer_chain);
   EXPECT_EQ(3U, referrer_chain.size());
   VerifyReferrerChainEntry(hosting_url,                       // url
+                           GURL(),                            // main_frame_url
                            ReferrerChainEntry::CLIENT_REDIRECT,  // type
                            test_server_ip,                    // ip_address
                            redirect_url,                      // referrer_url
-                           redirect_url,  // referrer_main_frame_url
-                           false,         // is_retargeting
+                           GURL(),  // referrer_main_frame_url
+                           false,   // is_retargeting
+                           std::vector<GURL>(),  // server redirects
                            referrer_chain[0].get());
   VerifyReferrerChainEntry(redirect_url,                         // url
+                           GURL(),  // main_frame_url
                            ReferrerChainEntry::CLIENT_REDIRECT,  // type
                            test_server_ip,                       // ip_address
                            landing_url,                          // referrer_url
-                           landing_url,  // referrer_main_frame_url
-                           false,        // is_retargeting
+                           GURL(),  // referrer_main_frame_url
+                           false,   // is_retargeting
+                           std::vector<GURL>(),  // server redirects
                            referrer_chain[1].get());
   VerifyReferrerChainEntry(landing_url,                       // url
+                           GURL(),                            // main_frame_url
                            ReferrerChainEntry::LANDING_PAGE,  // type
                            test_server_ip,                    // ip_address
                            GURL(),  // no more referrer before landing_url
                            GURL(),
                            false,   // is_retargeting
+                           std::vector<GURL>(),  // server redirects
                            referrer_chain[2].get());
 }
 
 // Server-side redirect.
 IN_PROC_BROWSER_TEST_F(SBNavigationObserverBrowserTest, ServerRedirect) {
   GURL initial_url = embedded_test_server()->GetURL(kSingleFrameTestURL);
   GURL download_url = embedded_test_server()->GetURL(kDownloadItemURL);
   GURL request_url =
       embedded_test_server()->GetURL("/server-redirect?" + download_url.spec());
   ui_test_utils::NavigateToURL(browser(), request_url);
@@ skipping 17 matching lines @@
                         download_url,  // destination_url
                         true,          // is_user_initiated,
                         false,         // has_committed
                         true,          // has_server_redirect
                         nav_map->at(download_url).at(0));
 
   ReferrerChain referrer_chain;
   IdentifyReferrerChainForDownload(GetDownload(), &referrer_chain);
   ASSERT_EQ(1U, referrer_chain.size());
   VerifyReferrerChainEntry(download_url,                      // url
+                           GURL(),                            // main_frame_url
                            ReferrerChainEntry::DOWNLOAD_URL,  // type
                            test_server_ip,                    // ip_address
                            GURL(),                            // referrer_url
                            GURL(),  // referrer_main_frame_url
                            false,   // is_retargeting
+                           {request_url, download_url},  // server redirects
                            referrer_chain[0].get());
 }
 
+// 2 consecutive server-side redirects.
+IN_PROC_BROWSER_TEST_F(SBNavigationObserverBrowserTest, TwoServerRedirects) {
+  GURL initial_url = embedded_test_server()->GetURL(kSingleFrameTestURL);
+  GURL destination_url = embedded_test_server()->GetURL(kDownloadItemURL);
+  GURL redirect_url =
+      embedded_test_server()->GetURL("/server-redirect?" +
+                                     destination_url.spec());
+  GURL request_url =
+      embedded_test_server()->GetURL("/server-redirect?" +
+                                     redirect_url.spec());
+  ui_test_utils::NavigateToURL(browser(), request_url);
+  std::string test_server_ip(embedded_test_server()->host_port_pair().host());
+  auto nav_map = navigation_map();
+  ASSERT_TRUE(nav_map);
+  ASSERT_EQ(2U, nav_map->size());
+  ASSERT_EQ(1U, nav_map->at(destination_url).size());
+  ASSERT_EQ(1U, nav_map->at(initial_url).size());
+  VerifyNavigationEvent(GURL(),       // source_url
+                        GURL(),       // source_main_frame_url
+                        initial_url,  // original_request_url
+                        initial_url,  // destination_url
+                        true,         // is_user_initiated,
+                        true,         // has_committed
+                        false,        // has_server_redirect
+                        nav_map->at(initial_url).at(0));
+  VerifyNavigationEvent(GURL(),           // source_url
+                        GURL(),           // source_main_frame_url
+                        request_url,      // original_request_url
+                        destination_url,  // destination_url
+                        true,             // is_user_initiated,
+                        false,            // has_committed
+                        true,             // has_server_redirect
+                        nav_map->at(destination_url).at(0));
+  const auto redirect_vector =
+      nav_map->at(destination_url).at(0).server_redirect_urls;
+  ASSERT_EQ(2U, redirect_vector.size());
+  EXPECT_EQ(redirect_url, redirect_vector.at(0));
+  EXPECT_EQ(destination_url, redirect_vector.at(1));
+
+  ReferrerChain referrer_chain;
+  IdentifyReferrerChainForDownload(GetDownload(), &referrer_chain);
+  ASSERT_EQ(1U, referrer_chain.size());
+  VerifyReferrerChainEntry(destination_url,                   // url
+                           GURL(),                            // main_frame_url
+                           ReferrerChainEntry::DOWNLOAD_URL,  // type
+                           test_server_ip,                    // ip_address
+                           GURL(),                            // referrer_url
+                           GURL(),  // referrer_main_frame_url
+                           false,   // is_retargeting
+                           {request_url, redirect_url, destination_url},
+                           referrer_chain[0].get());
+}
+
 // Retargeting immediately followed by server-side redirect.
 IN_PROC_BROWSER_TEST_F(SBNavigationObserverBrowserTest,
                        RetargetingAndServerRedirect) {
   GURL initial_url = embedded_test_server()->GetURL(kSingleFrameTestURL);
   GURL download_url = embedded_test_server()->GetURL(kDownloadItemURL);
   GURL request_url =
       embedded_test_server()->GetURL("/server-redirect?" + download_url.spec());
   ClickTestLink("new_tab_download_with_server_redirect", 1, initial_url);
   std::string test_server_ip(embedded_test_server()->host_port_pair().host());
   auto nav_map = navigation_map();
@@ skipping 24 matching lines @@
                         download_url,  // destination_url
                         false,          // is_user_initiated,
                         false,         // has_committed
                         true,          // has_server_redirect
                         nav_map->at(download_url).at(0));
 
   ReferrerChain referrer_chain;
   IdentifyReferrerChainForDownload(GetDownload(), &referrer_chain);
   ASSERT_EQ(2U, referrer_chain.size());
   VerifyReferrerChainEntry(download_url,                      // url
+                           GURL(),                            // main_frame_url
                            ReferrerChainEntry::DOWNLOAD_URL,  // type
                            test_server_ip,                    // ip_address
                            initial_url,                       // referrer_url
-                           initial_url,  // referrer_main_frame_url
-                           true,         // is_retargeting
+                           GURL(),  // referrer_main_frame_url
+                           true,    // is_retargeting
+                           {request_url, download_url},  // server redirects
                            referrer_chain[0].get());
   VerifyReferrerChainEntry(initial_url,                       // url
+                           GURL(),                            // main_frame_url
                            ReferrerChainEntry::LANDING_PAGE,  // type
                            test_server_ip,                    // ip_address
                            GURL(),                            // referrer_url
                            GURL(),  // referrer_main_frame_url
                            false,   // is_retargeting
+                           std::vector<GURL>(),  // server redirects
                            referrer_chain[1].get());
 }
 
 // host_to_ip_map_ size should increase by one after a new navigation.
 IN_PROC_BROWSER_TEST_F(SBNavigationObserverBrowserTest, AddIPMapping) {
   GURL initial_url = embedded_test_server()->GetURL(kSingleFrameTestURL);
   auto ip_map = host_to_ip_map();
   std::string test_server_host(embedded_test_server()->base_url().host());
   ip_map->clear();
   ip_map->insert(
@@ skipping 19 matching lines @@
           yesterday, embedded_test_server()->host_port_pair().host()));
   ASSERT_EQ(1U, ip_map->at(test_server_host).size());
   ClickTestLink("direct_download", 1, initial_url);
   EXPECT_EQ(1U, ip_map->at(test_server_host).size());
   EXPECT_EQ(embedded_test_server()->host_port_pair().host(),
             ip_map->at(test_server_host).back().ip);
   EXPECT_NE(yesterday, ip_map->at(test_server_host).front().timestamp);
 }
 
 }  // namespace safe_browsing