components/network_time/network_time_tracker.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "components/network_time/network_time_tracker.h"
   6
   7 #include "base/basictypes.h"
   8 #include "base/i18n/time_formatting.h"
   9 #include "base/logging.h"
  10 #include "base/prefs/pref_registry_simple.h"
  11 #include "base/prefs/pref_service.h"
  12 #include "base/strings/utf_string_conversions.h"
  13 #include "base/time/tick_clock.h"
  14 #include "components/network_time/network_time_pref_names.h"
  15
  16 namespace network_time {
  17
  18 namespace {
  19
  20 // Clock resolution is platform dependent.
  21 #if defined(OS_WIN)
  22 const int64 kTicksResolutionMs = base::Time::kMinLowResolutionThresholdMs;
  23 #else
  24 const int64 kTicksResolutionMs = 1;  // Assume 1ms for non-windows platforms.
  25 #endif
  26
  27 // Number of time measurements performed in a given network time calculation.
  28 const int kNumTimeMeasurements = 5;
  29
  30 }  // namespace
  31
  32 // static
  33 void NetworkTimeTracker::RegisterPrefs(PrefRegistrySimple* registry) {
  34   registry->RegisterDictionaryPref(prefs::kNetworkTimeMapping,
  35                                    new base::DictionaryValue());
  36 }
  37
  38 NetworkTimeTracker::NetworkTimeTracker(scoped_ptr<base::TickClock> tick_clock,
  39                                        PrefService* pref_service)
  40     : tick_clock_(tick_clock.Pass()),
  41       pref_service_(pref_service),
  42       received_network_time_(false) {
  43   const base::DictionaryValue* time_mapping =
  44       pref_service_->GetDictionary(prefs::kNetworkTimeMapping);
  45   double local_time_js = 0;
  46   double network_time_js = 0;
  47   if (time_mapping->GetDouble("local", &local_time_js) &&
  48       time_mapping->GetDouble("network", &network_time_js)) {
  49     base::Time local_time_saved = base::Time::FromJsTime(local_time_js);
  50     base::Time local_time_now = base::Time::Now();
  51     if (local_time_saved > local_time_now ||
  52         local_time_now - local_time_saved > base::TimeDelta::FromDays(7)) {
  53       // Drop saved mapping if clock skew has changed or the data is too old.
  54       pref_service_->ClearPref(prefs::kNetworkTimeMapping);
  55     } else {
  56       network_time_ = base::Time::FromJsTime(network_time_js) +
  57           (local_time_now - local_time_saved);
  58       network_time_ticks_ = base::TimeTicks::Now();
  59     }
  60   }
  61 }
  62
  63 NetworkTimeTracker::~NetworkTimeTracker() {
  64   DCHECK(thread_checker_.CalledOnValidThread());
  65 }
  66
  67 void NetworkTimeTracker::UpdateNetworkTime(base::Time network_time,
  68                                            base::TimeDelta resolution,
  69                                            base::TimeDelta latency,
  70                                            base::TimeTicks post_time) {
  71   DCHECK(thread_checker_.CalledOnValidThread());
  72   DVLOG(1) << "Network time updating to "
  73            << base::UTF16ToUTF8(
  74                   base::TimeFormatFriendlyDateAndTime(network_time));
  75   // Update network time on every request to limit dependency on ticks lag.
  76   // TODO(mad): Find a heuristic to avoid augmenting the
  77   // network_time_uncertainty_ too much by a particularly long latency.
  78   // Maybe only update when the the new time either improves in accuracy or
  79   // drifts too far from |network_time_|.
  80   network_time_ = network_time;
  81
  82   // Calculate the delay since the network time was received.
  83   base::TimeTicks now = tick_clock_->NowTicks();
  84   base::TimeDelta task_delay = now - post_time;
  85   // Estimate that the time was set midway through the latency time.
  86   network_time_ticks_ = now - task_delay - latency / 2;
  87
  88   // Can't assume a better time than the resolution of the given time
  89   // and 5 ticks measurements are involved, each with their own uncertainty.
  90   // 1 & 2 are the ones used to compute the latency, 3 is the Now() from when
  91   // this task was posted, 4 is the Now() above and 5 will be the Now() used in
  92   // GetNetworkTime().
  93   network_time_uncertainty_ =
  94       resolution + latency + kNumTimeMeasurements *
  95       base::TimeDelta::FromMilliseconds(kTicksResolutionMs);
  96
  97   received_network_time_ = true;
  98
  99   base::Time network_time_now;
 100   if (GetNetworkTime(base::TimeTicks::Now(), &network_time_now, NULL)) {
 101     // Update time mapping if tracker received time update from server, i.e.
 102     // mapping is accurate.
 103     base::Time local_now = base::Time::Now();
 104     base::DictionaryValue time_mapping;
 105     time_mapping.SetDouble("local", local_now.ToJsTime());
 106     time_mapping.SetDouble("network", network_time_now.ToJsTime());
 107     pref_service_->Set(prefs::kNetworkTimeMapping, time_mapping);
 108   }
 109 }
 110
 111 bool NetworkTimeTracker::GetNetworkTime(base::TimeTicks time_ticks,
 112                                         base::Time* network_time,
 113                                         base::TimeDelta* uncertainty) const {
 114   DCHECK(thread_checker_.CalledOnValidThread());
 115   DCHECK(network_time);
 116   if (network_time_.is_null())
 117     return false;
 118   DCHECK(!network_time_ticks_.is_null());
 119   *network_time = network_time_ + (time_ticks - network_time_ticks_);
 120   if (uncertainty)
 121     *uncertainty = network_time_uncertainty_;
 122   return true;
 123 }
 124
 125 }  // namespace network_time