Adds UMA histogram metrics for SafeBrowsing PVer4 methods.

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 75 matching lines @@
 static const int kSbTimerStartIntervalSecMax = 300;
 
 // The maximum time, in seconds, to wait for a response to an update request.
 static const int kSbMaxUpdateWaitSec = 30;
 
 // Maximum back off multiplier.
 static const size_t kSbMaxBackOff = 8;
 
 const char kGetHashUmaResponseMetricName[] = "SB2.GetHashResponseOrErrorCode";
 const char kGetChunkUmaResponseMetricName[] = "SB2.GetChunkResponseOrErrorCode";
+const char kUmaV4ResponseMetricName[] =
+    "SafeBrowsing.GetV4HashHttpResponseOrErrorCode";
 
 // The V4 URL prefix where browser fetches hashes from the V4 server.
 const char kSbV4UrlPrefix[] = "https://safebrowsing.googleapis.com/v4";
 
 // The default SBProtocolManagerFactory.
 class SBProtocolManagerFactoryImpl : public SBProtocolManagerFactory {
  public:
   SBProtocolManagerFactoryImpl() {}
   ~SBProtocolManagerFactoryImpl() override {}
   SafeBrowsingProtocolManager* CreateProtocolManager(
@@ skipping 103 matching lines @@
                                                       ResultType result_type) {
   if (is_download) {
     UMA_HISTOGRAM_ENUMERATION("SB2.GetHashResultDownload", result_type,
                               GET_HASH_RESULT_MAX);
   } else {
     UMA_HISTOGRAM_ENUMERATION("SB2.GetHashResult", result_type,
                               GET_HASH_RESULT_MAX);
   }
 }
 
+// static
+void SafeBrowsingProtocolManager::RecordGetV4HashResult(
+    ResultType result_type) {
+  UMA_HISTOGRAM_ENUMERATION("SafeBrowsing.GetV4HashResult", result_type,
+                            GET_HASH_RESULT_MAX);
+}
+
 void SafeBrowsingProtocolManager::RecordHttpResponseOrErrorCode(
     const char* metric_name,
     const net::URLRequestStatus& status,
     int response_code) {
   UMA_HISTOGRAM_SPARSE_SLOWLY(
       metric_name, status.is_success() ? response_code : status.error());
 }
 
 bool SafeBrowsingProtocolManager::IsUpdateScheduled() const {
   return update_timer_.IsRunning();
@@ skipping 137 matching lines @@
     const std::vector<SBPrefix>& prefixes,
     const std::vector<PlatformType>& platforms,
     ThreatType threat_type,
     FullHashCallback callback) {
   DCHECK(CalledOnValidThread());
   // We need to wait the minimum waiting duration, and if we are in 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 (Time::Now() <= next_gethash_v4_time_) {
-    // TODO(kcarattini): Add UMA recording.
+    if (gethash_v4_error_count_) {
+      RecordGetV4HashResult(GET_HASH_BACKOFF_ERROR);
+    } else {
+      RecordGetV4HashResult(GET_HASH_MIN_WAIT_DURATION_ERROR);
+    }
     std::vector<SBFullHashResult> full_hashes;
     callback.Run(full_hashes, base::TimeDelta());
     return;
   }
 
   std::string req_base64 = GetV4HashRequest(prefixes, platforms, threat_type);
   GURL gethash_url = GetV4HashUrl(req_base64);
 
   net::URLFetcher* fetcher =
       net::URLFetcher::Create(url_fetcher_id_++, gethash_url,
@@ skipping 83 matching lines @@
     }
 
     // Invoke the callback with full_hashes, even if there was a parse error or
     // an error response code (in which case full_hashes will be empty). The
     // caller can't be blocked indefinitely.
     details.callback.Run(full_hashes, cache_lifetime);
 
     hash_requests_.erase(it);
   } else if (v4_it != v4_hash_requests_.end()) {
     // V4 FindFullHashes response.
+    // TODO(kcarattini): Consider pulling all the V4 handling out into a
+    // separate V4ProtocolManager class.
+    RecordHttpResponseOrErrorCode(kUmaV4ResponseMetricName, status,
+                                  response_code);
     const FullHashDetails& details = v4_it->second;
     std::vector<SBFullHashResult> full_hashes;
     base::TimeDelta negative_cache_duration;
     if (status.is_success() && response_code == net::HTTP_OK) {
-      // TODO(kcarattini): Add UMA reporting.
+      RecordGetV4HashResult(GET_HASH_STATUS_200);
       ResetGetHashV4Errors();
       std::string data;
       source->GetResponseAsString(&data);
       if (!ParseV4HashResponse(data, &full_hashes, &negative_cache_duration)) {
         full_hashes.clear();
-        // TODO(kcarattini): Add UMA reporting.
+        RecordGetV4HashResult(GET_HASH_PARSE_ERROR);
       }
     } else {
       HandleGetHashV4Error(Time::Now());
-      // TODO(kcarattini): Add UMA reporting.
+
       DVLOG(1) << "SafeBrowsing GetEncodedFullHashes request for: " <<
           source->GetURL() << " failed with error: " << status.error() <<
           " and response code: " << response_code;
+
+      if (status.status() == net::URLRequestStatus::FAILED) {
+        RecordGetV4HashResult(GET_HASH_NETWORK_ERROR);
+      } else {
+        RecordGetV4HashResult(GET_HASH_HTTP_ERROR);
+      }
     }
 
     // Invoke the callback with full_hashes, even if there was a parse error or
     // an error response code (in which case full_hashes will be empty). The
     // caller can't be blocked indefinitely.
     details.callback.Run(full_hashes, negative_cache_duration);
 
     v4_hash_requests_.erase(v4_it);
   } else {
     // Update or chunk response.
@@ skipping 503 matching lines @@
 SafeBrowsingProtocolManager::FullHashDetails::FullHashDetails(
     FullHashCallback callback,
     bool is_download)
     : callback(callback), is_download(is_download) {}
 
 SafeBrowsingProtocolManager::FullHashDetails::~FullHashDetails() {}
 
 SafeBrowsingProtocolManagerDelegate::~SafeBrowsingProtocolManagerDelegate() {}
 
 }  // namespace safe_browsing