network_time_tracker: add temporary time protocol.

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 <memory>
 
+#include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/threading/thread_checker.h"
 #include "base/time/clock.h"
 #include "base/time/time.h"
+#include "base/timer/timer.h"
+#include "net/url_request/url_fetcher_delegate.h"
 
 class PrefRegistrySimple;
 class PrefService;
 
 namespace base {
 class TickClock;
-}
+}  // namespace base
+
+namespace client_update_protocol {
+class Ecdsa;
+}  // namespace client_udpate_protocol
+
+namespace net {
+class URLFetcher;
+class URLRequestContextGetter;
+}  // namespace net
 
 namespace network_time {
 
 // Clock resolution is platform dependent.
 #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 {
+class NetworkTimeTracker : public net::URLFetcherDelegate {
  public:
   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);
-  ~NetworkTimeTracker();
+                     PrefService* pref_service,
+                     net::URLRequestContextGetter* getter = nullptr);

[Ryan Sleevi, 2016/04/28 01:08:34]

URLRequestContextGetter is designed to be ref-counted and can be safely held on
to by clients, to ensure that they can actually get from the getter (if the
underlying URLRequestContext goes away, it behaves safely)

I believe you should be passing this as a
scoped_refptr<net::URLRequestContextGetter>, and storing as such.

[mab, 2016/04/28 02:29:04]

Good catch, thank you.  Done.

[mmenke, 2016/04/28 15:17:08]

Only certainly URLRequestContextGetters are safely shut down - it requires
coordination between the URLRequestContextGetter and the URLREquestContext's
owner for that to work.  Currently, only the Profile's URLRequestContextGetters
shutdown properly.  The system and proxy URLRequestContexts use another magic
path to shut down safely, so I suppose those should be fine, too.  Others can
only be used safely if you're destroyed before the URLRequestContext itself is.

Regardless, this code should definitely be hanging on to a reference, rather
than a raw pointer.

[mab, 2016/04/29 19:42:07]

Done.

+  ~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.
   //
   // 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;
 
   // 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);
 
  private:
+  friend class NetworkTimeTrackerTest;
+  FRIEND_TEST_ALL_PREFIXES(NetworkTimeTrackerTest, UpdateFromNetwork);
+  FRIEND_TEST_ALL_PREFIXES(NetworkTimeTrackerTest, NoNetworkQueryWhileSynced);
+  FRIEND_TEST_ALL_PREFIXES(NetworkTimeTrackerTest,
+                           UpdateFromNetworkBadSignature);
+
+  // If synchronization has been lost, sends a query to the secure time service.
+  // Upon response, execution resumes in |OnURLFetchComplete|.
+  void QueryTimeService();
+
+  // net::URLFetcherDelegate:
+  // Called to process responses from the secure time service.
+  void OnURLFetchComplete(const net::URLFetcher* source) override;
+
+  // State variables for internally-managed secure time service queries.
+  base::RepeatingTimer query_timer_;
+  net::URLRequestContextGetter* getter_;
+  std::unique_ptr<net::URLFetcher> time_fetcher_;
+  base::TimeTicks fetch_started_;
+  std::unique_ptr<client_update_protocol::Ecdsa> query_signer_;
+
   // The |Clock| and |TickClock| are used to sanity-check one another, allowing
   // the NetworkTimeTracker to notice e.g. suspend/resume events and clock
   // resets.
   std::unique_ptr<base::Clock> clock_;
   std::unique_ptr<base::TickClock> tick_clock_;
 
   PrefService* pref_service_;
 
   // Network time based on last call to UpdateNetworkTime().
   mutable base::Time network_time_at_last_measurement_;
@@ skipping 13 matching lines @@
   base::ThreadChecker thread_checker_;
 
   bool received_network_time_;
 
   DISALLOW_COPY_AND_ASSIGN(NetworkTimeTracker);
 };
 
 }  // namespace network_time
 
 #endif  // COMPONENTS_NETWORK_TIME_NETWORK_TIME_TRACKER_H_