When network time is unavailable, record the reason in UMA

components/network_time/network_time_tracker.h

 // 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.
 
 #ifndef COMPONENTS_NETWORK_TIME_NETWORK_TIME_TRACKER_H_
 #define COMPONENTS_NETWORK_TIME_NETWORK_TIME_TRACKER_H_
 
 #include <stdint.h>
 #include <memory>
 
@@ skipping 30 matching lines @@
 #if defined(OS_WIN)
 const int64_t kTicksResolutionMs = base::Time::kMinLowResolutionThresholdMs;
 #else
 const int64_t kTicksResolutionMs = 1;  // Assume 1ms for non-windows platforms.
 #endif
 
 // A class that receives network time updates and can provide the network time
 // for a corresponding local time. This class is not thread safe.
 class NetworkTimeTracker : public net::URLFetcherDelegate {
  public:
+  // Describes the result of a GetNetworkTime() call, describing whether
+  // network time was available and if not, why not.
+  enum NetworkTimeResult {
+    // Network time is available.
+    NETWORK_TIME_AVAILABLE,
+    // A time has been retrieved from the network in the past, but
+    // network time is no longer available because the tracker fell out
+    // of sync due to, for example, a suspend/resume.
+    NETWORK_TIME_SYNC_LOST,
+    // Network time is unavailable because the tracker has not yet
+    // retrieved a time from the network.
+    NETWORK_TIME_NO_SYNC,
+  };
+
   static void RegisterPrefs(PrefRegistrySimple* registry);
 
   // Constructor.  Arguments may be stubbed out for tests.  |getter|, if not
   // null, will cause automatic queries to a time server.  Otherwise, time is
   // available only if |UpdateNetworkTime| is called.
   NetworkTimeTracker(std::unique_ptr<base::Clock> clock,
                      std::unique_ptr<base::TickClock> tick_clock,
                      PrefService* pref_service,
                      scoped_refptr<net::URLRequestContextGetter> getter);
   ~NetworkTimeTracker() override;
 
-  // Sets |network_time| to an estimate of the true time.  Returns true if time
-  // is available, and false otherwise.  If |uncertainty| is non-NULL, it will
-  // be set to an estimate of the error range.
+  // Sets |network_time| to an estimate of the true time.  Returns
+  // NETWORK_TIME_AVAILABLE if time is available. If |uncertainty| is
+  // non-NULL, it will be set to an estimate of the error range.
+  //
+  // If network time is unavailable, this method returns
+  // NETWORK_TIME_SYNC_LOST or NETWORK_TIME_NO_SYNC to indicate the
+  // reason.
   //
   // Network time may be available on startup if deserialized from a pref.
   // Failing that, a call to |UpdateNetworkTime| is required to make time
   // available to callers of |GetNetworkTime|.  Subsequently, network time may
   // become unavailable if |NetworkTimeTracker| has reason to believe it is no
   // longer accurate.  Consumers should even be prepared to handle the case
   // where calls to |GetNetworkTime| never once succeeds.
-  bool GetNetworkTime(base::Time* network_time,
-                      base::TimeDelta* uncertainty) const;
+  NetworkTimeResult GetNetworkTime(base::Time* network_time,
+                                   base::TimeDelta* uncertainty) const;
 
   // Calculates corresponding time ticks according to the given parameters.
   // The provided |network_time| is precise at the given |resolution| and
   // represent the time between now and up to |latency| + (now - |post_time|)
   // ago.
   void UpdateNetworkTime(base::Time network_time,
                          base::TimeDelta resolution,
                          base::TimeDelta latency,
                          base::TimeTicks post_time);
 
@@ skipping 68 matching lines @@
   base::TimeDelta network_time_uncertainty_;
 
   base::ThreadChecker thread_checker_;
 
   DISALLOW_COPY_AND_ASSIGN(NetworkTimeTracker);
 };
 
 }  // namespace network_time
 
 #endif  // COMPONENTS_NETWORK_TIME_NETWORK_TIME_TRACKER_H_