In previous implementation, if the server does the more than one server redirects, we only record t…

chrome/browser/safe_browsing/download_protection_service.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 "chrome/browser/safe_browsing/download_protection_service.h"
 
 #include <stddef.h>
 
 #include <memory>
 
@@ skipping 1047 matching lines @@
               .AsUTF8Unsafe());
     } else {
       request.set_file_basename(
         item_->GetTargetFilePath().BaseName().AsUTF8Unsafe());
     }
     request.set_download_type(type_);
 
     ReferrerChainData* referrer_chain_data =
       static_cast<ReferrerChainData*>(
           item_->GetUserData(kDownloadReferrerChainDataKey));
-    if (referrer_chain_data &&
-        !referrer_chain_data->GetReferrerChain()->empty()) {
-      request.mutable_referrer_chain()->Swap(
-          referrer_chain_data->GetReferrerChain());
+    if (referrer_chain_data) {
+      request.set_download_attribution_finch_enabled(true);
+      if (!referrer_chain_data->GetReferrerChain()->empty()) {
+        request.mutable_referrer_chain()->Swap(
+            referrer_chain_data->GetReferrerChain());
+      }
     }
 
     if (archive_is_valid_ != ArchiveValid::UNSET)
       request.set_archive_valid(archive_is_valid_ == ArchiveValid::VALID);
     request.mutable_signature()->CopyFrom(signature_info_);
     if (image_headers_)
       request.set_allocated_image_headers(image_headers_.release());
     if (archived_executable_)
       request.mutable_archived_binary()->Swap(&archived_binary_);
     if (!request.SerializeToString(&client_download_request_data_)) {
@@ skipping 211 matching lines @@
       const GURL& initiating_frame_url,
       content::WebContents* web_contents,
       const base::FilePath& default_file_path,
       const std::vector<base::FilePath::StringType>& alternate_extensions,
       Profile* profile,
       const CheckDownloadCallback& callback,
       DownloadProtectionService* service,
       scoped_refptr<SafeBrowsingDatabaseManager> database_manager)
       : requestor_url_(requestor_url),
         initiating_frame_url_(initiating_frame_url),
+        initiating_main_frame_url_(
+            web_contents ? web_contents->GetLastCommittedURL() : GURL()),
         tab_id_(SessionTabHelper::IdForTab(web_contents)),
         default_file_path_(default_file_path),
         alternate_extensions_(alternate_extensions),
         callback_(callback),
         service_(service),
         database_manager_(database_manager),
         start_time_(base::TimeTicks::Now()),
         supported_path_(
             GetSupportedFilePath(default_file_path, alternate_extensions)),
         weakptr_factory_(this) {
@@ skipping 113 matching lines @@
       DCHECK_EQ(base::FilePath::kExtensionSeparator, alternate_extension[0]);
       *(request.add_alternate_extensions()) =
           base::FilePath(alternate_extension).AsUTF8Unsafe();
     }
     if (supported_path_ != default_file_path_) {
       *(request.add_alternate_extensions()) =
           base::FilePath(default_file_path_.FinalExtension()).AsUTF8Unsafe();
     }
 
     service_->AddReferrerChainToPPAPIClientDownloadRequest(
-        initiating_frame_url_,
-        tab_id_,
-        has_user_gesture_,
-        &request);
+        initiating_frame_url_, initiating_main_frame_url_, tab_id_,
+        has_user_gesture_, &request);
 
     if (!request.SerializeToString(&client_download_request_data_)) {
       // More of an internal error than anything else. Note that the UNKNOWN
       // verdict gets interpreted as "allowed".
       Finish(RequestOutcome::REQUEST_MALFORMED, UNKNOWN);
       return;
     }
 
     service_->ppapi_download_request_callbacks_.Notify(&request);
     DVLOG(2) << "Sending a PPAPI download request for URL: " << request.url();
@@ skipping 103 matching lines @@
 
     return base::FilePath();
   }
 
   std::unique_ptr<net::URLFetcher> fetcher_;
   std::string client_download_request_data_;
 
   // URL of document that requested the PPAPI download.
   const GURL requestor_url_;
 
-  // URL of the frame that hosted the PPAPI plugin.
+  // URL of the frame that hosts the PPAPI plugin.
   const GURL initiating_frame_url_;
 
+  // URL of the tab that contains the initialting_frame.
+  const GURL initiating_main_frame_url_;
+
   // Tab id that associated with the PPAPI plugin, computed by
   // SessionTabHelper::IdForTab().
   int tab_id_;
 
   // If the user interacted with this PPAPI plugin to trigger the download.
   bool has_user_gesture_;
 
   // Default download path requested by the PPAPI plugin.
   const base::FilePath default_file_path_;
 
@@ skipping 323 matching lines @@
   UMA_HISTOGRAM_COUNTS_100(
       "SafeBrowsing.ReferrerURLChainSize.DownloadAttribution",
       referrer_chain->size());
   UMA_HISTOGRAM_ENUMERATION(
       "SafeBrowsing.ReferrerAttributionResult.DownloadAttribution", result,
       SafeBrowsingNavigationObserverManager::ATTRIBUTION_FAILURE_TYPE_MAX);
   return referrer_chain;
 }
 
 void DownloadProtectionService::AddReferrerChainToPPAPIClientDownloadRequest(
-  const GURL& initiating_frame_url,
-  int tab_id,
-  bool has_user_gesture,
-  ClientDownloadRequest* out_request) {
+    const GURL& initiating_frame_url,
+    const GURL& initiating_main_frame_url,
+    int tab_id,
+    bool has_user_gesture,
+    ClientDownloadRequest* out_request) {
   if (!base::FeatureList::IsEnabled(
       SafeBrowsingNavigationObserverManager::kDownloadAttribution) ||
       !navigation_observer_manager_) {
     return;
   }
 
   UMA_HISTOGRAM_BOOLEAN(
       "SafeBrowsing.ReferrerHasInvalidTabID.DownloadAttribution",
       tab_id == -1);
   SafeBrowsingNavigationObserverManager::AttributionResult result =
       navigation_observer_manager_->IdentifyReferrerChainForPPAPIDownload(
-          initiating_frame_url,
-          tab_id,
-          has_user_gesture,
-          kDownloadAttributionUserGestureLimit,
+          initiating_frame_url, initiating_main_frame_url, tab_id,
+          has_user_gesture, kDownloadAttributionUserGestureLimit,
           out_request->mutable_referrer_chain());
   UMA_HISTOGRAM_COUNTS_100(
       "SafeBrowsing.ReferrerURLChainSize.PPAPIDownloadAttribution",
       out_request->referrer_chain_size());
   UMA_HISTOGRAM_ENUMERATION(
       "SafeBrowsing.ReferrerAttributionResult.PPAPIDownloadAttribution", result,
       SafeBrowsingNavigationObserverManager::ATTRIBUTION_FAILURE_TYPE_MAX);
+  out_request->set_download_attribution_finch_enabled(true);
 }
 
 }  // namespace safe_browsing