When network time is unavailable, record the reason in UMA

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>
 
@@ skipping 288 matching lines @@
 void NetworkTimeTracker::WaitForFetchForTesting(uint32_t nonce) {
   query_signer_->OverrideNonceForTesting(kKeyVersion, nonce);
   base::RunLoop().Run();
 }
 
 base::TimeDelta NetworkTimeTracker::GetTimerDelayForTesting() const {
   DCHECK(timer_.IsRunning());
   return timer_.GetCurrentDelay();
 }
 
-bool NetworkTimeTracker::GetNetworkTime(base::Time* network_time,
-                                        base::TimeDelta* uncertainty) const {
+NetworkTimeTracker::NetworkTimeResult NetworkTimeTracker::GetNetworkTime(
+    base::Time* network_time,
+    base::TimeDelta* uncertainty) const {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(network_time);
   if (network_time_at_last_measurement_.is_null()) {
-    return false;
+    return NETWORK_TIME_NO_SYNC;
   }
   DCHECK(!ticks_at_last_measurement_.is_null());
   DCHECK(!time_at_last_measurement_.is_null());
   base::TimeDelta tick_delta =
       tick_clock_->NowTicks() - ticks_at_last_measurement_;
   base::TimeDelta time_delta = clock_->Now() - time_at_last_measurement_;
   if (time_delta.InMilliseconds() < 0) {  // Has wall clock run backward?
     DVLOG(1) << "Discarding network time due to wall clock running backward";
+    UMA_HISTOGRAM_CUSTOM_TIMES(
+        "NetworkTimeTracker.WallClockRanBackwards", time_delta.magnitude(),
+        base::TimeDelta::FromSeconds(0), base::TimeDelta::FromDays(30), 50);
     network_time_at_last_measurement_ = base::Time();
-    return false;
+    return NETWORK_TIME_SYNC_LOST;
   }
   // Now we know that both |tick_delta| and |time_delta| are positive.
-  base::TimeDelta divergence = (tick_delta - time_delta).magnitude();
-  if (divergence > base::TimeDelta::FromSeconds(kClockDivergenceSeconds)) {
+  base::TimeDelta divergence = tick_delta - time_delta;
+  if (divergence.magnitude() >
+      base::TimeDelta::FromSeconds(kClockDivergenceSeconds)) {
     // Most likely either the machine has suspended, or the wall clock has been
     // reset.
     DVLOG(1) << "Discarding network time due to clocks diverging";
+    if (divergence.InMilliseconds() < 0) {
+      UMA_HISTOGRAM_CUSTOM_TIMES(
+          "NetworkTimeTracker.ClockDivergence.Negative", divergence.magnitude(),
+          base::TimeDelta::FromSeconds(kClockDivergenceSeconds),

[Steven Holte, 2016/08/29 22:22:59]

You may want to be a bit careful here, since even if you change
kClockDiveregenceSeconds later you should not change it here, so that buckets do
not change and you would have incompatible data from old and new clients.

[estark, 2016/08/29 22:37:05]

Ah, thanks. I think I'll just change this hard-code the constant value 60, with
a comment. I anticipate that we might want to raise the value of
|kClockDivergenceSeconds| so that way we'll have room to do that.

+          base::TimeDelta::FromDays(30), 50);
+    } else {
+      UMA_HISTOGRAM_CUSTOM_TIMES(
+          "NetworkTimeTracker.ClockDivergence.Positive", divergence.magnitude(),
+          base::TimeDelta::FromSeconds(kClockDivergenceSeconds),
+          base::TimeDelta::FromDays(30), 50);
+    }
     network_time_at_last_measurement_ = base::Time();
-    return false;
+    return NETWORK_TIME_SYNC_LOST;
   }
   *network_time = network_time_at_last_measurement_ + tick_delta;
   if (uncertainty) {
     *uncertainty = network_time_uncertainty_ + divergence;
   }
-  return true;
+  return NETWORK_TIME_AVAILABLE;
 }
 
 void NetworkTimeTracker::CheckTime() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // If NetworkTimeTracker is waking up after a backoff, this will reset the
   // timer to its default faster frequency.
   QueueCheckTime(CheckTimeInterval());
 
   if (!ShouldIssueTimeQuery()) {
@@ skipping 112 matching lines @@
 void NetworkTimeTracker::QueueCheckTime(base::TimeDelta delay) {
   timer_.Start(FROM_HERE, delay, this, &NetworkTimeTracker::CheckTime);
 }
 
 bool NetworkTimeTracker::ShouldIssueTimeQuery() {
   // Do not query the time service if not enabled via Variations Service.
   if (!base::FeatureList::IsEnabled(kNetworkTimeServiceQuerying)) {
     return false;
   }
 
-  // If GetNetworkTime() returns false, synchronization has been lost
-  // and a query is needed.
+  // If GetNetworkTime() does not return NETWORK_TIME_AVAILABLE,
+  // synchronization has been lost and a query is needed.
   base::Time network_time;
-  if (!GetNetworkTime(&network_time, nullptr)) {
+  if (GetNetworkTime(&network_time, nullptr) != NETWORK_TIME_AVAILABLE) {
     return true;
   }
 
   // Otherwise, make the decision at random.
   return base::RandDouble() < RandomQueryProbability();
 }
 
 }  // namespace network_time