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

chrome/browser/safe_browsing/protocol_manager.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/protocol_manager.h"
 
 #include <utility>
 
 #include "base/environment.h"
 #include "base/logging.h"
@@ skipping 182 matching lines @@
 
 SafeBrowsingProtocolManager::~SafeBrowsingProtocolManager() {}
 
 // We can only have one update or chunk request outstanding, but there may be
 // multiple GetHash requests pending since we don't want to serialize them and
 // slow down the user.
 void SafeBrowsingProtocolManager::GetFullHash(
     const std::vector<SBPrefix>& prefixes,
     FullHashCallback callback,
     bool is_download,
-    bool is_extended_reporting) {
+    ExtendedReportingLevel reporting_level) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   // If we are in GetHash backoff, we need to check if we're past the next
   // allowed time. If we are, we can proceed with the request. If not, we are
   // required to return empty results (i.e. treat the page as safe).
   if (gethash_error_count_ && Time::Now() <= next_gethash_time_) {
     RecordGetHashResult(is_download, GET_HASH_BACKOFF_ERROR);
     std::vector<SBFullHashResult> full_hashes;
     callback.Run(full_hashes, base::TimeDelta());
     return;
   }
-  GURL gethash_url = GetHashUrl(is_extended_reporting);
+  GURL gethash_url = GetHashUrl(reporting_level);
   std::unique_ptr<net::URLFetcher> fetcher_ptr = net::URLFetcher::Create(
       url_fetcher_id_++, gethash_url, net::URLFetcher::POST, this);
   net::URLFetcher* fetcher = fetcher_ptr.get();
   data_use_measurement::DataUseUserData::AttachToFetcher(
       fetcher, data_use_measurement::DataUseUserData::SAFE_BROWSING);
   hash_requests_[fetcher] = {std::move(fetcher_ptr),
                              FullHashDetails(callback, is_download)};
 
   const std::string get_hash = FormatGetHash(prefixes);
 
@@ skipping 391 matching lines @@
       request_.get(), data_use_measurement::DataUseUserData::SAFE_BROWSING);
   request_->SetLoadFlags(net::LOAD_DISABLE_CACHE);
   request_->SetRequestContext(request_context_getter_.get());
   chunk_request_start_ = base::Time::Now();
   request_->Start();
 }
 
 void SafeBrowsingProtocolManager::OnGetChunksComplete(
     const std::vector<SBListChunkRanges>& lists,
     bool database_error,
-    bool is_extended_reporting) {
+    ExtendedReportingLevel extended_reporting_level) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   DCHECK_EQ(request_type_, UPDATE_REQUEST);
   DCHECK(update_list_data_.empty());
   if (database_error) {
     // The update was not successful, but don't back off.
     UpdateFinished(false, false);
     return;
   }
 
   // Format our stored chunks:
@@ skipping 18 matching lines @@
   }
   if (!found_malware) {
     update_list_data_.append(FormatList(SBListChunkRanges(kMalwareList)));
   }
 
   // Large requests are (probably) a sign of database corruption.
   // Record stats to inform decisions about whether to automate
   // deletion of such databases.  http://crbug.com/120219
   UMA_HISTOGRAM_COUNTS("SB2.UpdateRequestSize", update_list_data_.size());
 
-  GURL update_url = UpdateUrl(is_extended_reporting);
+  GURL update_url = UpdateUrl(extended_reporting_level);
   request_ = net::URLFetcher::Create(url_fetcher_id_++, update_url,
                                      net::URLFetcher::POST, this);
   data_use_measurement::DataUseUserData::AttachToFetcher(
       request_.get(), data_use_measurement::DataUseUserData::SAFE_BROWSING);
   request_->SetLoadFlags(net::LOAD_DISABLE_CACHE);
   request_->SetRequestContext(request_context_getter_.get());
   request_->SetUploadData("text/plain", update_list_data_);
   request_->Start();
 
   // Begin the update request timeout.
@@ skipping 53 matching lines @@
         (static_cast<int>(backup_update_reason_) * 2) + update_success);
     RecordUpdateResult(update_result);
   }
   backup_update_reason_ = BACKUP_UPDATE_REASON_MAX;
   request_type_ = NO_REQUEST;
   update_list_data_.clear();
   delegate_->UpdateFinished(success);
   ScheduleNextUpdate(back_off);
 }
 
-GURL SafeBrowsingProtocolManager::UpdateUrl(bool is_extended_reporting) const {
+GURL SafeBrowsingProtocolManager::UpdateUrl(
+    ExtendedReportingLevel reporting_level) const {
   std::string url = SafeBrowsingProtocolManagerHelper::ComposeUrl(
       url_prefix_, "downloads", client_name_, version_, additional_query_,
-      is_extended_reporting);
+      reporting_level);
   return GURL(url);
 }
 
 GURL SafeBrowsingProtocolManager::BackupUpdateUrl(
     BackupUpdateReason backup_update_reason) const {
   DCHECK(backup_update_reason >= 0 &&
          backup_update_reason < BACKUP_UPDATE_REASON_MAX);
   DCHECK(!backup_url_prefixes_[backup_update_reason].empty());
   std::string url = SafeBrowsingProtocolManagerHelper::ComposeUrl(
       backup_url_prefixes_[backup_update_reason], "downloads", client_name_,
       version_, additional_query_);
   return GURL(url);
 }
 
-GURL SafeBrowsingProtocolManager::GetHashUrl(bool is_extended_reporting) const {
+GURL SafeBrowsingProtocolManager::GetHashUrl(
+    ExtendedReportingLevel reporting_level) const {
   std::string url = SafeBrowsingProtocolManagerHelper::ComposeUrl(
       url_prefix_, "gethash", client_name_, version_, additional_query_,
-      is_extended_reporting);
+      reporting_level);
   return GURL(url);
 }
 
 GURL SafeBrowsingProtocolManager::NextChunkUrl(const std::string& url) const {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   std::string next_url;
   if (!base::StartsWith(url, "http://", base::CompareCase::INSENSITIVE_ASCII) &&
       !base::StartsWith(url, "https://",
                         base::CompareCase::INSENSITIVE_ASCII)) {
     // Use https if we updated via https, otherwise http (useful for testing).
@@ skipping 26 matching lines @@
     : callback(callback), is_download(is_download) {}
 
 SafeBrowsingProtocolManager::FullHashDetails::FullHashDetails(
     const FullHashDetails& other) = default;
 
 SafeBrowsingProtocolManager::FullHashDetails::~FullHashDetails() {}
 
 SafeBrowsingProtocolManagerDelegate::~SafeBrowsingProtocolManagerDelegate() {}
 
 }  // namespace safe_browsing