When network time is unavailable, record the reason in UMA

components/network_time/network_time_tracker.cc

Index: components/network_time/network_time_tracker.cc
diff --git a/components/network_time/network_time_tracker.cc b/components/network_time/network_time_tracker.cc
index 5ce5e24a42cc4b252e7c9af84a7eaf725f352498..e82ca3e7dfa5e47e8d5f154680ee81ead2662edd 100644
--- a/components/network_time/network_time_tracker.cc
+++ b/components/network_time/network_time_tracker.cc
@@ -306,12 +306,13 @@ base::TimeDelta NetworkTimeTracker::GetTimerDelayForTesting() const {
   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());
@@ -320,23 +321,38 @@ bool NetworkTimeTracker::GetNetworkTime(base::Time* network_time,
   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() {
@@ -469,10 +485,10 @@ bool NetworkTimeTracker::ShouldIssueTimeQuery() {
     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;
   }