Add NetworkTimeTracker UMA histograms

components/network_time/network_time_tracker.cc

 // Copyright 2014 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/network_time/network_time_tracker.h"
 
 #include <stdint.h>
 #include <string>
 #include <utility>
 
 #include "base/feature_list.h"
 #include "base/i18n/time_formatting.h"
 #include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
+#include "base/metrics/histogram_macros.h"
+#include "base/metrics/sparse_histogram.h"
 #include "base/rand_util.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/tick_clock.h"
 #include "build/build_config.h"
 #include "components/client_update_protocol/ecdsa.h"
 #include "components/network_time/network_time_pref_names.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/pref_service.h"
@@ skipping 133 matching lines @@
   double probability;
   const std::string param = variations::GetVariationParamValueByFeature(
       kNetworkTimeServiceQuerying, kVariationsServiceRandomQueryProbability);
   if (!param.empty() && base::StringToDouble(param, &probability) &&
       probability >= 0.0 && probability <= 1.0) {
     return probability;
   }
   return kRandomQueryProbability;
 }
 
+void RecordFetchValidHistogram(bool valid) {
+  UMA_HISTOGRAM_BOOLEAN("NetworkTimeTracker.UpdateTimeFetchValid", valid);
+}
+
 }  // namespace
 
 // static
 void NetworkTimeTracker::RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterDictionaryPref(prefs::kNetworkTimeMapping,
                                    new base::DictionaryValue());
 }
 
 NetworkTimeTracker::NetworkTimeTracker(
     std::unique_ptr<base::Clock> clock,
@@ skipping 181 matching lines @@
   time_fetcher_->SaveResponseWithWriter(
       std::unique_ptr<net::URLFetcherResponseWriter>(
           new SizeLimitingStringWriter(max_response_size_)));
   DCHECK(getter_);
   time_fetcher_->SetRequestContext(getter_.get());
   // Not expecting any cookies, but just in case.
   time_fetcher_->SetLoadFlags(net::LOAD_BYPASS_CACHE | net::LOAD_DISABLE_CACHE |
                               net::LOAD_DO_NOT_SAVE_COOKIES |
                               net::LOAD_DO_NOT_SEND_COOKIES |
                               net::LOAD_DO_NOT_SEND_AUTH_DATA);
+
+  UMA_HISTOGRAM_BOOLEAN("NetworkTimeTracker.UpdateTimeFetchAttempted", true);
+
   time_fetcher_->Start();
   fetch_started_ = tick_clock_->NowTicks();
 
   timer_.Stop();  // Restarted in OnURLFetchComplete().
 }
 
 bool NetworkTimeTracker::UpdateTimeFromResponse() {
-  if (time_fetcher_->GetStatus().status() != net::URLRequestStatus::SUCCESS &&
+  if (time_fetcher_->GetStatus().status() != net::URLRequestStatus::SUCCESS ||
       time_fetcher_->GetResponseCode() != 200) {
     DVLOG(1) << "fetch failed, status=" << time_fetcher_->GetStatus().status()
              << ",code=" << time_fetcher_->GetResponseCode();
+    // The error code is negated because net errors are negative, but
+    // the corresponding histogram enum is positive.
+    UMA_HISTOGRAM_SPARSE_SLOWLY("NetworkTimeTracker.UpdateTimeFetchFailed",
+                                -time_fetcher_->GetStatus().error());
     return false;
   }
 
   std::string response_body;
   if (!time_fetcher_->GetResponseAsString(&response_body)) {
     DVLOG(1) << "failed to get response";
     return false;
   }
   DCHECK(query_signer_);
   if (!query_signer_->ValidateResponse(response_body,
                                        GetServerProof(time_fetcher_.get()))) {
     DVLOG(1) << "invalid signature";
+    RecordFetchValidHistogram(false);
     return false;
   }
   response_body = response_body.substr(5);  // Skips leading )]}'\n
   std::unique_ptr<base::Value> value = base::JSONReader::Read(response_body);
   if (!value) {
     DVLOG(1) << "bad JSON";
+    RecordFetchValidHistogram(false);
     return false;
   }
   const base::DictionaryValue* dict;
   if (!value->GetAsDictionary(&dict)) {
     DVLOG(1) << "not a dictionary";
+    RecordFetchValidHistogram(false);
     return false;
   }
   double current_time_millis;
   if (!dict->GetDouble("current_time_millis", &current_time_millis)) {
     DVLOG(1) << "no current_time_millis";
+    RecordFetchValidHistogram(false);
     return false;
   }
+
+  RecordFetchValidHistogram(true);
+
   // There is a "server_nonce" key here too, but it serves no purpose other than
   // to make the server's response unpredictable.
   base::Time current_time = base::Time::FromJsTime(current_time_millis);
   base::TimeDelta resolution =
       base::TimeDelta::FromMilliseconds(1) +
       base::TimeDelta::FromSeconds(kTimeServerMaxSkewSeconds);
   base::TimeDelta latency = tick_clock_->NowTicks() - fetch_started_;
   UpdateNetworkTime(current_time, resolution, latency, tick_clock_->NowTicks());
   return true;
 }
@@ skipping 35 matching lines @@
   base::Time network_time;
   if (!GetNetworkTime(&network_time, nullptr)) {
     return true;
   }
 
   // Otherwise, make the decision at random.
   return base::RandDouble() < RandomQueryProbability();
 }
 
 }  // namespace network_time