Separate SBClientDownload.SignedOrWhitelistedDownload metric into two buckets,

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 "base/bind.h"
 #include "base/command_line.h"
@@ skipping 651 matching lines @@
       } else {
         PostFinishTask(UNKNOWN, REASON_ARCHIVE_WITHOUT_BINARIES);
         return;
       }
     }
 
     OnFileFeatureExtractionDone();
   }
 #endif  // defined(OS_MACOSX)
 
-  static void RecordCountOfSignedOrWhitelistedDownload() {
-    UMA_HISTOGRAM_COUNTS("SBClientDownload.SignedOrWhitelistedDownload", 1);
+  enum WhitelistType {
+    NO_WHITELIST_MATCH,
+    URL_WHITELIST,
+    SIGNATURE_WHITELIST,
+    WHITELIST_TYPE_MAX
+  };
+
+  static void RecordCountOfWhitelistedDownload(WhitelistType type) {
+    UMA_HISTOGRAM_ENUMERATION("SBClientDownload.WhitelistedDownload",
+                              type,
+                              WHITELIST_TYPE_MAX);
   }
 
   void CheckWhitelists() {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
     if (!database_manager_.get()) {
       PostFinishTask(UNKNOWN, REASON_SB_DISABLED);
       return;
     }
 
     const GURL& url = url_chain_.back();
     // TODO(asanka): This may acquire a lock on the SB DB on the IO thread.
     if (url.is_valid() && database_manager_->MatchDownloadWhitelistUrl(url)) {
       DVLOG(2) << url << " is on the download whitelist.";
-      RecordCountOfSignedOrWhitelistedDownload();
+      RecordCountOfWhitelistedDownload(URL_WHITELIST);
       // TODO(grt): Continue processing without uploading so that
       // ClientDownloadRequest callbacks can be run even for this type of safe
       // download.
       PostFinishTask(SAFE, REASON_WHITELISTED_URL);
       return;
     }
 
     if (signature_info_.trusted()) {
-      RecordCountOfSignedOrWhitelistedDownload();
       for (int i = 0; i < signature_info_.certificate_chain_size(); ++i) {
         if (CertificateChainIsWhitelisted(
                 signature_info_.certificate_chain(i))) {
+          RecordCountOfWhitelistedDownload(SIGNATURE_WHITELIST);
           // TODO(grt): Continue processing without uploading so that
           // ClientDownloadRequest callbacks can be run even for this type of
           // safe download.
           PostFinishTask(SAFE, REASON_TRUSTED_EXECUTABLE);
           return;
         }
       }
     }
 
+    RecordCountOfWhitelistedDownload(NO_WHITELIST_MATCH);

[mattm, 2016/03/21 20:57:19]

I think this is a little unclear. There are downloads which don't get to this
point in the process and thus don't get recorded in this histogram, so it should
define more precisely what it means in histograms.xml.

[Jialiu Lin, 2016/03/21 21:26:48]

metrics description updated.

+
     if (!pingback_enabled_) {
       PostFinishTask(UNKNOWN, REASON_PING_DISABLED);
       return;
     }
 
-  // The URLFetcher is owned by the UI thread, so post a message to
-  // start the pingback.
-  BrowserThread::PostTask(
-      BrowserThread::UI,
-      FROM_HERE,
-      base::Bind(&CheckClientDownloadRequest::GetTabRedirects, this));
+    // The URLFetcher is owned by the UI thread, so post a message to
+    // start the pingback.
+    BrowserThread::PostTask(
+        BrowserThread::UI,
+        FROM_HERE,
+        base::Bind(&CheckClientDownloadRequest::GetTabRedirects, this));
   }
 
   void GetTabRedirects() {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     if (!service_)
       return;
 
     if (!tab_url_.is_valid()) {
       SendRequest();
       return;
@@ skipping 511 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