Add UMA metric for GetHash parsing errors.

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/base64.h"
 #include "base/environment.h"
@@ skipping 57 matching lines @@
 base::TimeDelta GetNextUpdateIntervalFromFinch() {
   std::string num_str = variations::GetVariationParamValue(
       kSBUpdateFrequencyFinchExperiment, kSBUpdateFrequencyFinchParam);
   int finch_next_update_interval_minutes = 0;
   if (!base::StringToInt(num_str, &finch_next_update_interval_minutes)) {
     finch_next_update_interval_minutes = 0;  // Defaults to 0.
   }
   return base::TimeDelta::FromMinutes(finch_next_update_interval_minutes);
 }
 
+// Enumerate V4 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.
+  UNEXPECTED_THREAT_ENTRY_TYPE_ERROR = 1,
+
+  // A match in the response had an unexpected THREAT_TYPE.
+  UNEXPECTED_THREAT_TYPE_ERROR = 2,
+
+  // A match in the response had an unexpected PLATFORM_TYPE.
+  UNEXPECTED_PLATFORM_TYPE_ERROR = 3,
+
+  // A match in teh response contained no metadata where metadata was
+  // expected.
+  NO_METADATA_ERROR = 4,
+
+  // Memory space for histograms is determined by the max.  ALWAYS
+  // ADD NEW VALUES BEFORE THIS ONE.
+  PARSE_GET_HASH_RESULT_MAX = 5
+};
+
+// Record parsing errors of a GetHash result.
+void RecordParseGetHashResult(ParseResultType result_type) {
+  UMA_HISTOGRAM_ENUMERATION("SafeBrowsing.ParseV4HashResult", result_type,
+                            PARSE_GET_HASH_RESULT_MAX);
+}
+
 }  // namespace
 
 namespace safe_browsing {
 
 // Minimum time, in seconds, from start up before we must issue an update query.
 static const int kSbTimerStartIntervalSecMin = 60;
 
 // Maximum time, in seconds, from start up before we must issue an update query.
 static const int kSbTimerStartIntervalSecMax = 300;
 
@@ skipping 219 matching lines @@
   return req_base64;
 }
 
 bool SafeBrowsingProtocolManager::ParseV4HashResponse(
     const std::string& data,
     std::vector<SBFullHashResult>* full_hashes,
     base::TimeDelta* negative_cache_duration) {
   FindFullHashesResponse response;
 
   if (!response.ParseFromString(data)) {
-    // TODO(kcarattini): Add UMA.
+    RecordParseGetHashResult(PARSE_FROM_STRING_ERROR);
     return false;
   }
 
   if (response.has_negative_cache_duration()) {
     // Seconds resolution is good enough so we ignore the nanos field.
     *negative_cache_duration = base::TimeDelta::FromSeconds(
         response.negative_cache_duration().seconds());
   }
 
   if (response.has_minimum_wait_duration()) {
     // Seconds resolution is good enough so we ignore the nanos field.
     next_gethash_v4_time_ = Time::Now() + base::TimeDelta::FromSeconds(
         response.minimum_wait_duration().seconds());
   }
 
   // Loop over the threat matches and fill in full_hashes.
   for (const ThreatMatch& match : response.matches()) {
     // Make sure the platform and threat entry type match.
     if (!(match.has_threat_entry_type() &&
           match.threat_entry_type() == URL_EXPRESSION &&
           match.has_threat())) {
-      continue;
+      RecordParseGetHashResult(UNEXPECTED_THREAT_ENTRY_TYPE_ERROR);
+      return false;
     }
 
     // Fill in the full hash.
     SBFullHashResult result;
     result.hash = StringToSBFullHash(match.threat().hash());
 
     if (match.has_cache_duration()) {
       // Seconds resolution is good enough so we ignore the nanos field.
       result.cache_duration = base::TimeDelta::FromSeconds(
           match.cache_duration().seconds());
     }
 
     // Different threat types will handle the metadata differently.
-    if (match.has_threat_type() && match.threat_type() == API_ABUSE &&
-        match.has_platform_type() &&
-        match.platform_type() == CHROME_PLATFORM &&
-        match.has_threat_entry_metadata()) {
-      // For API Abuse, store a csv of the returned permissions.
-      for (const ThreatEntryMetadata::MetadataEntry& m :
-               match.threat_entry_metadata().entries()) {
-        if (m.key() == "permission") {
-          result.metadata += m.value() + ",";
+    if (match.has_threat_type() && match.threat_type() == API_ABUSE) {
+      if (match.has_platform_type() &&
+          match.platform_type() == CHROME_PLATFORM) {
+        if (match.has_threat_entry_metadata()) {
+          // For API Abuse, store a csv of the returned permissions.
+          for (const ThreatEntryMetadata::MetadataEntry& m :
+                   match.threat_entry_metadata().entries()) {
+            if (m.key() == "permission") {
+              result.metadata += m.value() + ",";
+            }
+          }
+        } else {
+          RecordParseGetHashResult(NO_METADATA_ERROR);
+          return false;
         }
+      } else {
+        RecordParseGetHashResult(UNEXPECTED_PLATFORM_TYPE_ERROR);
+        return false;
       }
     } else {
-      // TODO(kcarattini): Add UMA for unexpected threat type match.
+      RecordParseGetHashResult(UNEXPECTED_THREAT_TYPE_ERROR);
       return false;
     }
 
     full_hashes->push_back(result);
   }
   return true;
 }
 
 void SafeBrowsingProtocolManager::GetV4FullHashes(
     const std::vector<SBPrefix>& prefixes,
@@ skipping 658 matching lines @@
 SafeBrowsingProtocolManager::FullHashDetails::FullHashDetails(
     FullHashCallback callback,
     bool is_download)
     : callback(callback), is_download(is_download) {}
 
 SafeBrowsingProtocolManager::FullHashDetails::~FullHashDetails() {}
 
 SafeBrowsingProtocolManagerDelegate::~SafeBrowsingProtocolManagerDelegate() {}
 
 }  // namespace safe_browsing