Add support for scout to 'ext' param when creating SafeBrowsing ping URLs.

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 159 matching lines @@
       SBStatsType dangerous_type)
       : sha256_hash_(item.GetHash()),
         url_chain_(item.GetUrlChain()),
         referrer_url_(item.GetReferrerUrl()),
         callback_(callback),
         ui_manager_(ui_manager),
         start_time_(base::TimeTicks::Now()),
         total_type_(total_type),
         dangerous_type_(dangerous_type) {
     Profile* profile = Profile::FromBrowserContext(item.GetBrowserContext());
-    is_extended_reporting_ =
-        profile && IsExtendedReportingEnabled(*profile->GetPrefs());
+    extended_reporting_level_ =
+        profile ? GetExtendedReportingLevel(*profile->GetPrefs())
+                : SBER_LEVEL_OFF;
   }
 
   virtual void StartCheck() = 0;
   virtual bool IsDangerous(SBThreatType threat_type) const = 0;
 
  protected:
   friend class base::RefCountedThreadSafe<DownloadSBClient>;
   ~DownloadSBClient() override {}
 
   void CheckDone(SBThreatType threat_type) {
@@ skipping 27 matching lines @@
     safe_browsing::HitReport hit_report;
     hit_report.malicious_url = url_chain_.back();
     hit_report.page_url = url_chain_.front();
     hit_report.referrer_url = referrer_url_;
     hit_report.is_subresource = true;
     hit_report.threat_type = threat_type;
     // TODO(nparker) Replace this with database_manager_->GetThreatSource();
     hit_report.threat_source = safe_browsing::ThreatSource::LOCAL_PVER3;
     // TODO(nparker) Populate hit_report.population_id once Pver4 is used here.
     hit_report.post_data = post_data;
-    hit_report.is_extended_reporting = is_extended_reporting_;
+    hit_report.extended_reporting_level = extended_reporting_level_;
     hit_report.is_metrics_reporting_active =
         ChromeMetricsServiceAccessor::IsMetricsAndCrashReportingEnabled();
 
     ui_manager_->MaybeReportSafeBrowsingHit(hit_report);
   }
 
   void UpdateDownloadCheckStats(SBStatsType stat_type) {
     UMA_HISTOGRAM_ENUMERATION("SB2.DownloadChecks",
                               stat_type,
                               DOWNLOAD_CHECKS_MAX);
   }
 
   std::string sha256_hash_;
   std::vector<GURL> url_chain_;
   GURL referrer_url_;
   DownloadProtectionService::CheckDownloadCallback callback_;
   scoped_refptr<SafeBrowsingUIManager> ui_manager_;
   base::TimeTicks start_time_;
 
  private:
   const SBStatsType total_type_;
   const SBStatsType dangerous_type_;
-  bool is_extended_reporting_;
+  ExtendedReportingLevel extended_reporting_level_;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadSBClient);
 };
 
 class DownloadUrlSBClient : public DownloadSBClient {
  public:
   DownloadUrlSBClient(
       const content::DownloadItem& item,
       const DownloadProtectionService::CheckDownloadCallback& callback,
       const scoped_refptr<SafeBrowsingUIManager>& ui_manager,
@@ skipping 57 matching lines @@
         callback_(callback),
         service_(service),
         binary_feature_extractor_(binary_feature_extractor),
         database_manager_(database_manager),
         pingback_enabled_(service_->enabled()),
         finished_(false),
         type_(ClientDownloadRequest::WIN_EXECUTABLE),
         start_time_(base::TimeTicks::Now()),
         skipped_url_whitelist_(false),
         skipped_certificate_whitelist_(false),
-        is_extended_reporting_(false),
+        extended_reporting_level_(SBER_LEVEL_OFF),
         is_incognito_(false),
         weakptr_factory_(this) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     item_->AddObserver(this);
   }
 
   bool ShouldSampleUnsupportedFile(const base::FilePath& filename) {
     // If this extension is specifically marked as SAMPLED_PING (as are
     // all "unknown" extensions), we may want to sample it. Sampling it means
     // we'll send a "light ping" with private info removed, and we won't
     // use the verdict.
     const FileTypePolicies* policies = FileTypePolicies::GetInstance();
-    return service_ && is_extended_reporting_ && !is_incognito_ &&
+    return service_ && extended_reporting_level_ != SBER_LEVEL_OFF &&
+           !is_incognito_ &&
            base::RandDouble() < policies->SampledPingProbability() &&
            policies->PingSettingForFile(filename) ==
                DownloadFileType::SAMPLED_PING;
   }
 
   void Start() {
     DVLOG(2) << "Starting SafeBrowsing download check for: "
              << item_->DebugString(true);
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     if (item_->GetBrowserContext()) {
       Profile* profile =
           Profile::FromBrowserContext(item_->GetBrowserContext());
-      is_extended_reporting_ =
-          profile && IsExtendedReportingEnabled(*profile->GetPrefs());
+      extended_reporting_level_ =
+          profile ? GetExtendedReportingLevel(*profile->GetPrefs())
+                  : SBER_LEVEL_OFF;
       is_incognito_ = item_->GetBrowserContext()->IsOffTheRecord();
     }
 
     DownloadCheckResultReason reason = REASON_MAX;
     if (!IsSupportedDownload(
         *item_, item_->GetTargetFilePath(), &reason, &type_)) {
       switch (reason) {
         case REASON_EMPTY_URL_CHAIN:
         case REASON_INVALID_URL:
         case REASON_LOCAL_FILE:
@@ skipping 425 matching lines @@
       }
     }
 
     OnFileFeatureExtractionDone();
   }
 #endif  // defined(OS_MACOSX)
 
   bool ShouldSampleWhitelistedDownload() {
     // We currently sample 1% whitelisted downloads from users who opted
     // in extended reporting and are not in incognito mode.
-    return service_ && is_extended_reporting_ && !is_incognito_ &&
-        base::RandDouble() < service_->whitelist_sample_rate();
+    return service_ && extended_reporting_level_ != SBER_LEVEL_OFF &&
+           !is_incognito_ &&
+           base::RandDouble() < service_->whitelist_sample_rate();
   }
 
   void CheckWhitelists() {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
     if (!database_manager_.get()) {
       PostFinishTask(UNKNOWN, REASON_SB_DISABLED);
       return;
     }
 
@@ skipping 122 matching lines @@
 
   void SendRequest() {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
     // This is our last chance to check whether the request has been canceled
     // before sending it.
     if (!service_)
       return;
 
     ClientDownloadRequest request;
-    auto population = is_extended_reporting_
-        ? ChromeUserPopulation::EXTENDED_REPORTING
-        : ChromeUserPopulation::SAFE_BROWSING;
+    auto population = extended_reporting_level_ != SBER_LEVEL_OFF

[Jialiu Lin, 2016/11/17 18:47:23]

You might want to add ChromeUserPopulation::SCOUT_REPORTING to 
c/c/safe_browsing/csd.proto. And ping awoz@ to change its corresponding proto in
google3. 
otherwise, it seems unnecessary to change this bool to ExtendedReportingLevel
enum. 

[lpz, 2016/11/17 19:46:05]

Agreed, back to a bool. I think adding another population can happen as a
followup.

+                          ? ChromeUserPopulation::EXTENDED_REPORTING
+                          : ChromeUserPopulation::SAFE_BROWSING;
     request.mutable_population()->set_user_population(population);
 
     request.set_url(SanitizeUrl(item_->GetUrlChain().back()));
     request.mutable_digests()->set_sha256(item_->GetHash());
     request.set_length(item_->GetReceivedBytes());
     request.set_skipped_url_whitelist(skipped_url_whitelist_);
     request.set_skipped_certificate_whitelist(skipped_certificate_whitelist_);
     for (size_t i = 0; i < item_->GetUrlChain().size(); ++i) {
       ClientDownloadRequest::Resource* resource = request.add_resources();
       resource->set_url(SanitizeUrl(item_->GetUrlChain()[i]));
@@ skipping 214 matching lines @@
 #endif
   bool finished_;
   ClientDownloadRequest::DownloadType type_;
   std::string client_download_request_data_;
   base::CancelableTaskTracker request_tracker_;  // For HistoryService lookup.
   base::TimeTicks start_time_;  // Used for stats.
   base::TimeTicks timeout_start_time_;
   base::TimeTicks request_start_time_;
   bool skipped_url_whitelist_;
   bool skipped_certificate_whitelist_;
-  bool is_extended_reporting_;
+  ExtendedReportingLevel extended_reporting_level_;
   bool is_incognito_;
   base::WeakPtrFactory<CheckClientDownloadRequest> weakptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(CheckClientDownloadRequest);
 };
 
 // A request for checking whether a PPAPI initiated download is safe.
 //
 // These are considered different from DownloadManager mediated downloads
 // because:
@@ skipping 35 matching lines @@
         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());
+    extended_reporting_level_ = GetExtendedReportingLevel(*profile->GetPrefs());
   }
 
   ~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 67 matching lines @@
     // Not on whitelist, so we are going to check with the SafeBrowsing
     // backend.
     SendRequest();
   }
 
   void SendRequest() {
     DVLOG(2) << __func__;
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
     ClientDownloadRequest request;
-    auto population = is_extended_reporting_
-        ? ChromeUserPopulation::EXTENDED_REPORTING
-        : ChromeUserPopulation::SAFE_BROWSING;
+    auto population = extended_reporting_level_ != SBER_LEVEL_OFF

[Jialiu Lin, 2016/11/17 18:47:23]

Similar to above.

[lpz, 2016/11/17 19:46:05]

Done.

+                          ? ChromeUserPopulation::EXTENDED_REPORTING
+                          : ChromeUserPopulation::SAFE_BROWSING;
     request.mutable_population()->set_user_population(population);
     request.set_download_type(ClientDownloadRequest::PPAPI_SAVE_REQUEST);
     ClientDownloadRequest::Resource* resource = request.add_resources();
     resource->set_type(ClientDownloadRequest::PPAPI_DOCUMENT);
     resource->set_url(requestor_url_.spec());
     request.set_url(requestor_url_.spec());
     request.set_file_basename(supported_path_.BaseName().AsUTF8Unsafe());
     request.set_length(0);
     request.mutable_digests()->set_md5(std::string());
     for (const auto& alternate_extension : alternate_extensions_) {
@@ skipping 146 matching lines @@
   // Time request was started.
   const base::TimeTicks start_time_;
 
   // A download path that is supported by SafeBrowsing. This is determined by
   // invoking GetSupportedFilePath(). If non-empty,
   // IsCheckedBinaryFile(supported_path_) is always true. This
   // path is therefore used as the download target when sending the SafeBrowsing
   // ping.
   const base::FilePath supported_path_;
 
-  bool is_extended_reporting_;
+  ExtendedReportingLevel extended_reporting_level_;
 
   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()
                                          : nullptr),
@@ skipping 263 matching lines @@
 GURL DownloadProtectionService::GetDownloadRequestUrl() {
   GURL url(kDownloadRequestUrl);
   std::string api_key = google_apis::GetAPIKey();
   if (!api_key.empty())
     url = url.Resolve("?key=" + net::EscapeQueryParamValue(api_key, true));
 
   return url;
 }
 
 }  // namespace safe_browsing