Update histogram names to follow the usual PVer4 format: SafeBrowsing.V4*

components/safe_browsing_db/v4_get_hash_protocol_manager.cc

 // Copyright 2016 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 "components/safe_browsing_db/v4_get_hash_protocol_manager.h"
 
 #include <utility>
 
 #include "base/base64url.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/timer/timer.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/load_flags.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_status_code.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_request_context_getter.h"
 
 using base::Time;
 using base::TimeDelta;
 using content::BrowserThread;
 
 namespace {
 
 // Record a GetHash result.
 void RecordGetHashResult(safe_browsing::V4OperationResult result) {
   UMA_HISTOGRAM_ENUMERATION(
-      "SafeBrowsing.GetV4HashResult", result,
+      "SafeBrowsing.V4GetHash.Result", result,
       safe_browsing::V4OperationResult::OPERATION_RESULT_MAX);
 }
 
 // Enumerate parsing failures for histogramming purposes.  DO NOT CHANGE
 // THE ORDERING OF THESE VALUES.
 enum ParseResultType {
   // Error parsing the protocol buffer from a string.
   PARSE_FROM_STRING_ERROR = 0,
 
   // A match in the response had an unexpected THREAT_ENTRY_TYPE.
@@ skipping 19 matching lines @@
   // A match in the response had no information in the threat field.
   NO_THREAT_ERROR = 7,
 
   // Memory space for histograms is determined by the max.  ALWAYS
   // ADD NEW VALUES BEFORE THIS ONE.
   PARSE_RESULT_TYPE_MAX = 8,
 };
 
 // Record parsing errors of a GetHash result.
 void RecordParseGetHashResult(ParseResultType result_type) {
-  UMA_HISTOGRAM_ENUMERATION("SafeBrowsing.ParseV4HashResult", result_type,
+  UMA_HISTOGRAM_ENUMERATION("SafeBrowsing.V4GetHash.Parse.Result", result_type,
                             PARSE_RESULT_TYPE_MAX);
 }
 
 // Enumerate full hash cache hits/misses for histogramming purposes.
 // DO NOT CHANGE THE ORDERING OF THESE VALUES.
 enum V4FullHashCacheResultType {
   // Full hashes for which there is no cache hit.
   FULL_HASH_CACHE_MISS = 0,
 
   // Full hashes with a cache hit.
   FULL_HASH_CACHE_HIT = 1,
 
   // Full hashes with a negative cache hit.
   FULL_HASH_NEGATIVE_CACHE_HIT = 2,
 
   // Memory space for histograms is determined by the max. ALWAYS
   // ADD NEW VALUES BEFORE THIS ONE.
   FULL_HASH_CACHE_RESULT_MAX
 };
 
 // Record a full hash cache hit result.
 void RecordV4FullHashCacheResult(V4FullHashCacheResultType result_type) {
-  UMA_HISTOGRAM_ENUMERATION("SafeBrowsing.V4FullHashCacheResult", result_type,
-                            FULL_HASH_CACHE_RESULT_MAX);
+  UMA_HISTOGRAM_ENUMERATION("SafeBrowsing.V4GetHash.CacheHit.Result",
+                            result_type, FULL_HASH_CACHE_RESULT_MAX);
 }
 
 // Enumerate GetHash hits/misses for histogramming purposes. DO NOT CHANGE THE
 // ORDERING OF THESE VALUES.
 enum V4GetHashCheckResultType {
   // Successful responses which returned no full hashes.
   GET_HASH_CHECK_EMPTY = 0,
 
   // Successful responses for which one or more of the full hashes matched.
   GET_HASH_CHECK_HIT = 1,
 
   // Successful responses which weren't empty but have no matches.
   GET_HASH_CHECK_MISS = 2,
 
   // Memory space for histograms is determined by the max. ALWAYS
   // ADD NEW VALUES BEFORE THIS ONE.
   GET_HASH_CHECK_RESULT_MAX
 };
 
 // Record a GetHash hit result.
 void RecordV4GetHashCheckResult(V4GetHashCheckResultType result_type) {
-  UMA_HISTOGRAM_ENUMERATION("SafeBrowsing.V4GetHashCheckResult", result_type,
+  UMA_HISTOGRAM_ENUMERATION("SafeBrowsing.V4GetHash.Check.Result", result_type,
                             GET_HASH_CHECK_RESULT_MAX);
 }
 
 const char kPermission[] = "permission";
 const char kPhaPatternType[] = "pha_pattern_type";
 const char kMalwarePatternType[] = "malware_pattern_type";
 const char kSePatternType[] = "se_pattern_type";
 const char kLanding[] = "LANDING";
 const char kDistribution[] = "DISTRIBUTION";
 const char kSocialEngineeringAds[] = "SOCIAL_ENGINEERING_ADS";
 const char kSocialEngineeringLanding[] = "SOCIAL_ENGINEERING_LANDING";
 const char kPhishing[] = "PHISHING";
 
 }  // namespace
 
 namespace safe_browsing {
 
-const char kUmaV4HashResponseMetricName[] =
-    "SafeBrowsing.GetV4HashHttpResponseOrErrorCode";
-
 // The default V4GetHashProtocolManagerFactory.
 class V4GetHashProtocolManagerFactoryImpl
     : public V4GetHashProtocolManagerFactory {
  public:
   V4GetHashProtocolManagerFactoryImpl() {}
   ~V4GetHashProtocolManagerFactoryImpl() override {}
   std::unique_ptr<V4GetHashProtocolManager> CreateProtocolManager(
       net::URLRequestContextGetter* request_context_getter,
       const StoresToCheck& stores_to_check,
       const V4ProtocolConfig& config) override {
@@ skipping 542 matching lines @@
     const net::URLFetcher* source) {
   DCHECK(CalledOnValidThread());
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   PendingHashRequests::iterator it = pending_hash_requests_.find(source);
   DCHECK(it != pending_hash_requests_.end()) << "Request not found";
 
   int response_code = source->GetResponseCode();
   net::URLRequestStatus status = source->GetStatus();
   V4ProtocolManagerUtil::RecordHttpResponseOrErrorCode(
-      kUmaV4HashResponseMetricName, status, response_code);
+      "SafeBrowsing.V4GetHash.Network.Result", status, response_code);
 
   std::vector<FullHashInfo> full_hash_infos;
   Time negative_cache_expire;
   if (status.is_success() && response_code == net::HTTP_OK) {
     RecordGetHashResult(V4OperationResult::STATUS_200);
     ResetGetHashErrors();
     std::string data;
     source->GetResponseAsString(&data);
     if (!ParseHashResponse(data, &full_hash_infos, &negative_cache_expire)) {
       full_hash_infos.clear();
       RecordGetHashResult(V4OperationResult::PARSE_ERROR);
     }
   } else {
     HandleGetHashError(clock_->Now());
 
     DVLOG(1) << "SafeBrowsing GetEncodedFullHashes request for: "
              << source->GetURL() << " failed with error: " << status.error()
              << " and response code: " << response_code;
 
     if (status.status() == net::URLRequestStatus::FAILED) {
       RecordGetHashResult(V4OperationResult::NETWORK_ERROR);
     } else {
       RecordGetHashResult(V4OperationResult::HTTP_ERROR);
     }
   }
 
   const std::unique_ptr<FullHashCallbackInfo>& fhci = it->second;
-  UMA_HISTOGRAM_LONG_TIMES("SafeBrowsing.V4GetHashNetwork.Time",
+  UMA_HISTOGRAM_LONG_TIMES("SafeBrowsing.V4GetHash.Network.Time",
                            clock_->Now() - fhci->network_start_time);
   UpdateCache(fhci->prefixes_requested, full_hash_infos, negative_cache_expire);
   MergeResults(fhci->full_hash_to_store_and_hash_prefixes, full_hash_infos,
                &fhci->cached_full_hash_infos);
 
   fhci->callback.Run(fhci->cached_full_hash_infos);
 
   pending_hash_requests_.erase(it);
 }
 
 #ifndef DEBUG
 std::ostream& operator<<(std::ostream& os, const FullHashInfo& fhi) {
   os << "{full_hash: " << fhi.full_hash << "; list_id: " << fhi.list_id
      << "; positive_expiry: " << fhi.positive_expiry
      << "; metadata.api_permissions.size(): "
      << fhi.metadata.api_permissions.size() << "}";
   return os;
 }
 #endif
 
 }  // namespace safe_browsing