Add token field to ClientSafeBrowsingReportReqeust

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 64 matching lines @@
 static const int64_t kDownloadRequestTimeoutMs = 7000;
 // We sample 1% of whitelisted downloads to still send out download pings.
 static const double kWhitelistDownloadSampleRate = 0.01;
 }  // namespace
 
 namespace safe_browsing {
 
 const char DownloadProtectionService::kDownloadRequestUrl[] =
     "https://sb-ssl.google.com/safebrowsing/clientreport/download";
 
+const void* const DownloadProtectionService::kDownloadPingTokenKey
+    = &kDownloadPingTokenKey;
+
 namespace {
 void RecordFileExtensionType(const base::FilePath& file) {
   UMA_HISTOGRAM_SPARSE_SLOWLY(
       "SBClientDownload.DownloadExtensions",
       FileTypePolicies::GetInstance()->UmaValueForFile(file));
 }
 
 void RecordArchivedArchiveFileExtensionType(const base::FilePath& file) {
   UMA_HISTOGRAM_SPARSE_SLOWLY(
       "SBClientDownload.ArchivedArchiveExtensions",
@@ skipping 349 matching lines @@
     if (source->GetStatus().is_success()) {
       UMA_HISTOGRAM_SPARSE_SLOWLY(
           "SBClientDownload.DownloadRequestResponseCode",
           source->GetResponseCode());
     }
     UMA_HISTOGRAM_SPARSE_SLOWLY(
         "SBClientDownload.DownloadRequestNetError",
         -source->GetStatus().error());
     DownloadCheckResultReason reason = REASON_SERVER_PING_FAILED;
     DownloadCheckResult result = UNKNOWN;
+    std::string token;
     if (source->GetStatus().is_success() &&
         net::HTTP_OK == source->GetResponseCode()) {
       ClientDownloadResponse response;
       std::string data;
       bool got_data = source->GetResponseAsString(&data);
       DCHECK(got_data);
       if (!response.ParseFromString(data)) {
         reason = REASON_INVALID_RESPONSE_PROTO;
         result = UNKNOWN;
       } else if (response.verdict() == ClientDownloadResponse::SAFE) {
         reason = REASON_DOWNLOAD_SAFE;
         result = SAFE;
       } else if (service_ && !service_->IsSupportedDownload(
           *item_, item_->GetTargetFilePath())) {
         // The client of the download protection service assumes that we don't
         // support this download so we cannot return any other verdict than
         // UNKNOWN even if the server says it's dangerous to download this file.
         // Note: if service_ is NULL we already cancelled the request and
         // returned UNKNOWN.
         reason = REASON_DOWNLOAD_NOT_SUPPORTED;
         result = UNKNOWN;
       } else if (response.verdict() == ClientDownloadResponse::DANGEROUS) {
         reason = REASON_DOWNLOAD_DANGEROUS;
         result = DANGEROUS;
+        token = response.token();
       } else if (response.verdict() == ClientDownloadResponse::UNCOMMON) {
         reason = REASON_DOWNLOAD_UNCOMMON;
         result = UNCOMMON;
+        token = response.token();
       } else if (response.verdict() == ClientDownloadResponse::DANGEROUS_HOST) {
         reason = REASON_DOWNLOAD_DANGEROUS_HOST;
         result = DANGEROUS_HOST;
+        token = response.token();
       } else if (
           response.verdict() == ClientDownloadResponse::POTENTIALLY_UNWANTED) {
         reason = REASON_DOWNLOAD_POTENTIALLY_UNWANTED;
         result = POTENTIALLY_UNWANTED;
+        token = response.token();
       } else {
         LOG(DFATAL) << "Unknown download response verdict: "
                     << response.verdict();
         reason = REASON_INVALID_RESPONSE_VERDICT;
         result = UNKNOWN;
       }
+      if (!token.empty())
+        SetDownloadPingToken(item_, token);
+
       DownloadFeedbackService::MaybeStorePingsForDownload(
           result, item_, client_download_request_data_, data);
     }
     // We don't need the fetcher anymore.
     fetcher_.reset();
     UMA_HISTOGRAM_TIMES("SBClientDownload.DownloadRequestDuration",
                         base::TimeTicks::Now() - start_time_);
     UMA_HISTOGRAM_TIMES("SBClientDownload.DownloadRequestNetworkDuration",
                         base::TimeTicks::Now() - request_start_time_);
 
@@ skipping 1059 matching lines @@
       learn_more_url, "ctx",
       base::IntToString(static_cast<int>(item.GetDangerType())));
   navigator->OpenURL(
       content::OpenURLParams(learn_more_url,
                              content::Referrer(),
                              NEW_FOREGROUND_TAB,
                              ui::PAGE_TRANSITION_LINK,
                              false));
 }
 
+void DownloadProtectionService::SetDownloadPingToken(
+    content::DownloadItem* item, const std::string& token) {
+  if (item)
+    item->SetUserData(kDownloadPingTokenKey, new DownloadPingToken(token));
+}
+
+std::string DownloadProtectionService::GetDownloadPingToken(
+    const content::DownloadItem* item) {
+  base::SupportsUserData::Data* token_data =
+      item->GetUserData(kDownloadPingTokenKey);
+  if (token_data)
+    return static_cast<DownloadPingToken*>(token_data)->token_string();
+  else
+    return std::string();
+}
+
 namespace {
 // Escapes a certificate attribute so that it can be used in a whitelist
 // entry.  Currently, we only escape slashes, since they are used as a
 // separator between attributes.
 std::string EscapeCertAttribute(const std::string& attribute) {
   std::string escaped;
   for (size_t i = 0; i < attribute.size(); ++i) {
     if (attribute[i] == '%') {
       escaped.append("%25");
     } else if (attribute[i] == '/') {
@@ skipping 66 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