Clean up DownloadAttribution Finch experiments

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 183 matching lines @@
         database_manager_(database_manager),
         download_item_observer_(this) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     DCHECK(item_);
     DCHECK(service_);
     download_item_observer_.Add(item_);
     Profile* profile = Profile::FromBrowserContext(item_->GetBrowserContext());
     extended_reporting_level_ =
         profile ? GetExtendedReportingLevel(*profile->GetPrefs())
                 : SBER_LEVEL_OFF;
-    download_attribution_enabled_ = service_->navigation_observer_manager() &&
-        base::FeatureList::IsEnabled(
-            SafeBrowsingNavigationObserverManager::kDownloadAttribution);
   }
 
   // Implements DownloadItem::Observer.
   void OnDownloadDestroyed(content::DownloadItem* download) override {
    download_item_observer_.Remove(item_);
     item_ = nullptr;
   }
 
   void StartCheck() {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
@@ skipping 32 matching lines @@
   void CheckDone(SBThreatType threat_type) {
     DownloadProtectionService::DownloadCheckResult result =
         IsDangerous(threat_type) ?
         DownloadProtectionService::DANGEROUS :
         DownloadProtectionService::SAFE;
     UpdateDownloadCheckStats(total_type_);
     if (threat_type != SB_THREAT_TYPE_SAFE) {
       UpdateDownloadCheckStats(dangerous_type_);
       BrowserThread::PostTask(
           BrowserThread::UI, FROM_HERE,
-          base::BindOnce(&DownloadUrlSBClient::ReportMalware, this,
-                         threat_type));
-    } else if (download_attribution_enabled_) {
-        // Identify download referrer chain, which will be used in
-        // ClientDownloadRequest.
-        BrowserThread::PostTask(
-            BrowserThread::UI, FROM_HERE,
-            base::BindOnce(&DownloadUrlSBClient::IdentifyReferrerChain, this));
+          base::Bind(&DownloadUrlSBClient::ReportMalware, this, threat_type));
+    } else {
+      // Identify download referrer chain, which will be used in
+      // ClientDownloadRequest.
+      BrowserThread::PostTask(
+          BrowserThread::UI, FROM_HERE,
+          base::Bind(&DownloadUrlSBClient::IdentifyReferrerChain, this));
     }
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                             base::BindOnce(callback_, result));
   }
 
   void ReportMalware(SBThreatType threat_type) {
     std::string post_data;
     if (!sha256_hash_.empty()) {
       post_data += base::HexEncode(sha256_hash_.data(),
                                    sha256_hash_.size()) + "\n";
@@ skipping 39 matching lines @@
   // The DownloadItem we are checking. Must be accessed only on UI thread.
   content::DownloadItem* item_;
   // Copies of data from |item_| for access on other threads.
   std::string sha256_hash_;
   std::vector<GURL> url_chain_;
   GURL referrer_url_;
   DownloadProtectionService* service_;
   DownloadProtectionService::CheckDownloadCallback callback_;
   scoped_refptr<SafeBrowsingUIManager> ui_manager_;
   base::TimeTicks start_time_;
-  bool download_attribution_enabled_;
   const SBStatsType total_type_;
   const SBStatsType dangerous_type_;
   ExtendedReportingLevel extended_reporting_level_;
   scoped_refptr<SafeBrowsingDatabaseManager> database_manager_;
   ScopedObserver<content::DownloadItem,
                  content::DownloadItem::Observer> download_item_observer_;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadUrlSBClient);
 };
 
@@ skipping 699 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) {
-      request.set_download_attribution_finch_enabled(true);
-      if (!referrer_chain_data->GetReferrerChain()->empty()) {
-        request.mutable_referrer_chain()->Swap(
-            referrer_chain_data->GetReferrerChain());
-      }
+    if (referrer_chain_data &&
+        !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 597 matching lines @@
 
   bool is_extended_reporting_;
 
   base::WeakPtrFactory<PPAPIDownloadRequest> weakptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(PPAPIDownloadRequest);
 };
 
 DownloadProtectionService::DownloadProtectionService(
     SafeBrowsingService* sb_service)
-    : request_context_getter_(sb_service ? sb_service->url_request_context()
+    : navigation_observer_manager_(nullptr),
+      request_context_getter_(sb_service ? sb_service->url_request_context()
                                          : nullptr),
       enabled_(false),
       binary_feature_extractor_(new BinaryFeatureExtractor()),
       download_request_timeout_ms_(kDownloadRequestTimeoutMs),
       feedback_service_(
           new DownloadFeedbackService(request_context_getter_.get(),
                                       BrowserThread::GetBlockingPool())),
       whitelist_sample_rate_(kWhitelistDownloadSampleRate) {
   if (sb_service) {
     ui_manager_ = sb_service->ui_manager();
@@ skipping 262 matching lines @@
   std::string api_key = google_apis::GetAPIKey();
   if (!api_key.empty())
     url = url.Resolve("?key=" + net::EscapeQueryParamValue(api_key, true));
 
   return url;
 }
 
 std::unique_ptr<ReferrerChain> DownloadProtectionService::IdentifyReferrerChain(
     const GURL& download_url,
     content::WebContents* web_contents) {
+  // If navigation_observer_manager_ is null, return immediately. This could
+  // happen in tests.
+  if (!navigation_observer_manager_)
+    return nullptr;
+
   std::unique_ptr<ReferrerChain> referrer_chain =
       base::MakeUnique<ReferrerChain>();
   int download_tab_id = SessionTabHelper::IdForTab(web_contents);
   UMA_HISTOGRAM_BOOLEAN(
       "SafeBrowsing.ReferrerHasInvalidTabID.DownloadAttribution",
       download_tab_id == -1);
   // We look for the referrer chain that leads to the download url first.
   SafeBrowsingNavigationObserverManager::AttributionResult result =
       navigation_observer_manager_->IdentifyReferrerChainByEventURL(
           download_url, download_tab_id, kDownloadAttributionUserGestureLimit,
@@ skipping 18 matching lines @@
       SafeBrowsingNavigationObserverManager::ATTRIBUTION_FAILURE_TYPE_MAX);
   return referrer_chain;
 }
 
 void DownloadProtectionService::AddReferrerChainToPPAPIClientDownloadRequest(
     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_) {
+  if (!navigation_observer_manager_)
     return;
-  }
 
   UMA_HISTOGRAM_BOOLEAN(
       "SafeBrowsing.ReferrerHasInvalidTabID.DownloadAttribution",
       tab_id == -1);
   SafeBrowsingNavigationObserverManager::AttributionResult result =
       navigation_observer_manager_->IdentifyReferrerChainByHostingPage(
           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