Wireup SafeBrowsingNavigationObserverManager to help PPAPI download attribution

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 1212 matching lines @@
     TIMEDOUT,
     WHITELIST_HIT,
     REQUEST_MALFORMED,
     FETCH_FAILED,
     RESPONSE_MALFORMED,
     SUCCEEDED
   };
 
   PPAPIDownloadRequest(
       const GURL& requestor_url,
+      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),
+        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) {
     DCHECK(profile);
     is_extended_reporting_ = IsExtendedReportingEnabled(*profile->GetPrefs());
+
+    if (service->navigation_observer_manager()) {
+      has_user_gesture_ =
+          service->navigation_observer_manager()->HasUserGesture(web_contents);
+      if (has_user_gesture_) {
+        service->navigation_observer_manager()->OnUserGestureConsumed(
+            web_contents, base::Time::Now());
+      }
+    }
   }
 
   ~PPAPIDownloadRequest() override {
     if (fetcher_ && !callback_.is_null())
       Finish(RequestOutcome::REQUEST_DESTROYED, UNKNOWN);
   }
 
   // Start the process of checking the download request. The callback passed as
   // the |callback| parameter to the constructor will be invoked with the result
   // of the check at some point in the future.
@@ skipping 91 matching lines @@
         continue;
       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();
     }
 
-    // TODO(676691): We should add reliable download referrer chain for PPAPI
-    // downloads too.
+    service_->AddReferrerChainToPPAPIClientDownloadRequest(
+        initiating_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.
+  const GURL initiating_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_;
 
   // List of alternate extensions provided by the PPAPI plugin. Each extension
   // must begin with a leading extension separator.
   const std::vector<base::FilePath::StringType> alternate_extensions_;
 
   // Callback to invoke with the result of the PPAPI download request check.
   CheckDownloadCallback callback_;
 
@@ skipping 110 matching lines @@
       ClientDownloadRequest::WIN_EXECUTABLE;
   // TODO(nparker): Remove the CRX check here once can support
   // UNKNOWN types properly.  http://crbug.com/581044
   return (CheckClientDownloadRequest::IsSupportedDownload(
               item, target_path, &reason, &type) &&
           (ClientDownloadRequest::CHROME_EXTENSION != type));
 }
 
 void DownloadProtectionService::CheckPPAPIDownloadRequest(
     const GURL& requestor_url,
+    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) {
   DVLOG(1) << __func__ << " url:" << requestor_url
            << " default_file_path:" << default_file_path.value();
   std::unique_ptr<PPAPIDownloadRequest> request(new PPAPIDownloadRequest(
-      requestor_url, default_file_path, alternate_extensions, profile, callback,
-      this, database_manager_));
+      requestor_url, initiating_frame_url, web_contents, default_file_path,
+      alternate_extensions, profile, callback, this, database_manager_));
   PPAPIDownloadRequest* request_copy = request.get();
   auto insertion_result = ppapi_download_requests_.insert(
       std::make_pair(request_copy, std::move(request)));
   DCHECK(insertion_result.second);
   insertion_result.first->second->Start();
 }
 
 DownloadProtectionService::ClientDownloadRequestSubscription
 DownloadProtectionService::RegisterClientDownloadRequestCallback(
     const ClientDownloadRequestCallback& callback) {
@@ skipping 165 matching lines @@
       !navigation_observer_manager_) {
     return;
   }
 
   int download_tab_id = SessionTabHelper::IdForTab(web_contents);
   UMA_HISTOGRAM_BOOLEAN(
       "SafeBrowsing.ReferrerHasInvalidTabID.DownloadAttribution",
       download_tab_id == -1);
   std::vector<ReferrerChainEntry> attribution_chain;
   SafeBrowsingNavigationObserverManager::AttributionResult result =
-      navigation_observer_manager_->IdentifyReferrerChain(
+      navigation_observer_manager_->IdentifyReferrerChainForDownload(
           download_url,
           download_tab_id,
           kDownloadAttributionUserGestureLimit,
           &attribution_chain);
   UMA_HISTOGRAM_COUNTS_100(
       "SafeBrowsing.ReferrerURLChainSize.DownloadAttribution",
       attribution_chain.size());
   UMA_HISTOGRAM_ENUMERATION(
       "SafeBrowsing.ReferrerAttributionResult.DownloadAttribution", result,
       SafeBrowsingNavigationObserverManager::ATTRIBUTION_FAILURE_TYPE_MAX);
   for (auto entry : attribution_chain)
     out_request->add_referrer_chain()->Swap(&entry);
 }
 
+void DownloadProtectionService::AddReferrerChainToPPAPIClientDownloadRequest(
+  const GURL& initiating_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);
+  std::vector<ReferrerChainEntry> attribution_chain;
+  SafeBrowsingNavigationObserverManager::AttributionResult result =
+      navigation_observer_manager_->IdentifyReferrerChainForPPAPIDownload(
+          initiating_frame_url,
+          tab_id,
+          has_user_gesture,
+          kDownloadAttributionUserGestureLimit,
+          &attribution_chain);
+  UMA_HISTOGRAM_COUNTS_100(
+      "SafeBrowsing.ReferrerURLChainSize.PPAPIDownloadAttribution",
+      attribution_chain.size());
+  UMA_HISTOGRAM_ENUMERATION(
+      "SafeBrowsing.ReferrerAttributionResult.PPAPIDownloadAttribution", result,
+      SafeBrowsingNavigationObserverManager::ATTRIBUTION_FAILURE_TYPE_MAX);
+  for (auto entry : attribution_chain)
+    out_request->add_referrer_chain()->Swap(&entry);
+}
+
 }  // namespace safe_browsing