Attempt an on-demand time fetch when encountering a date invalid error

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 82 matching lines @@
 // be that badly wrong, but all the same it's included here to document the very
 // rough nature of the time service provided by this class.)
 const uint32_t kTimeServerMaxSkewSeconds = 10;
 
 const char kTimeServiceURL[] = "http://clients2.google.com/time/1/current";
 
 const char kVariationsServiceCheckTimeIntervalSeconds[] =
     "CheckTimeIntervalSeconds";
 const char kVariationsServiceRandomQueryProbability[] =
     "RandomQueryProbability";
-// This parameter must have the value "true" in order for
-// StartTimeFetch() to start time queries on demand.
-const char kVariationsServiceEnableFetchesOnDemand[] = "EnableFetchesOnDemand";
+
+// This parameter can have three values:
+//
+// - "background-only": Time queries will be issued in the background as
+//   needed (when the clock loses sync), but on-demand time queries will
+//   not be issued (i.e. StartTimeFetch() will not start time queries.)
+//
+// - "on-demand-only": Time queries will not be issued except when
+//   StartTimeFetch() is called.
+//
+// - "background-and-on-demand": Time queries will be issued both in the
+//   background as needed and also on-demand.
+const char kVariationsServiceFetchBehavior[] = "FetchBehavior";
 
 // This is an ECDSA prime256v1 named-curve key.
 const int kKeyVersion = 1;
 const uint8_t kKeyPubBytes[] = {
     0x30, 0x59, 0x30, 0x13, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02,
     0x01, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07, 0x03,
     0x42, 0x00, 0x04, 0xeb, 0xd8, 0xad, 0x0b, 0x8f, 0x75, 0xe8, 0x84, 0x36,
     0x23, 0x48, 0x14, 0x24, 0xd3, 0x93, 0x42, 0x25, 0x43, 0xc1, 0xde, 0x36,
     0x29, 0xc6, 0x95, 0xca, 0xeb, 0x28, 0x85, 0xff, 0x09, 0xdc, 0x08, 0xec,
     0x45, 0x74, 0x6e, 0x4b, 0xc3, 0xa5, 0xfd, 0x8a, 0x2f, 0x02, 0xa0, 0x4b,
@@ skipping 24 matching lines @@
     if (data().length() + num_bytes > limit_) {
       return net::ERR_FILE_TOO_BIG;
     }
     return net::URLFetcherStringWriter::Write(buffer, num_bytes, callback);
   }
 
  private:
   size_t limit_;
 };
 
+bool BackgroundQueriesEnabled() {
+  if (!base::FeatureList::IsEnabled(kNetworkTimeServiceQuerying)) {
+    return false;
+  }
+
+  const std::string param = variations::GetVariationParamValueByFeature(
+      kNetworkTimeServiceQuerying, kVariationsServiceFetchBehavior);
+  return param == "background-only" || param == "background-and-on-demand";
+}
+
+bool OnDemandQueriesEnabled() {
+  if (!base::FeatureList::IsEnabled(kNetworkTimeServiceQuerying)) {
+    return false;
+  }
+
+  const std::string param = variations::GetVariationParamValueByFeature(
+      kNetworkTimeServiceQuerying, kVariationsServiceFetchBehavior);
+  return param == "on-demand-only" || param == "background-and-on-demand";
+}
+
 base::TimeDelta CheckTimeInterval() {
   int64_t seconds;
   const std::string param = variations::GetVariationParamValueByFeature(
       kNetworkTimeServiceQuerying, kVariationsServiceCheckTimeIntervalSeconds);
   if (!param.empty() && base::StringToInt64(param, &seconds) && seconds > 0) {
     return base::TimeDelta::FromSeconds(seconds);
   }
   return base::TimeDelta::FromSeconds(kCheckTimeIntervalSeconds);
 }
 
@@ skipping 115 matching lines @@
       network_time_uncertainty_.ToInternalValue()));
   time_mapping.SetDouble(kPrefNetworkTime,
       network_time_at_last_measurement_.ToJsTime());
   pref_service_->Set(prefs::kNetworkTimeMapping, time_mapping);
 }
 
 void NetworkTimeTracker::SetTimeServerURLForTesting(const GURL& url) {
   server_url_ = url;
 }
 
+GURL NetworkTimeTracker::GetTimeServerURLForTesting() const {
+  return server_url_;
+}
+
 void NetworkTimeTracker::SetMaxResponseSizeForTesting(size_t limit) {
   max_response_size_ = limit;
 }
 
 void NetworkTimeTracker::SetPublicKeyForTesting(const base::StringPiece& key) {
   query_signer_ = client_update_protocol::Ecdsa::Create(kKeyVersion, key);
 }
 
 bool NetworkTimeTracker::QueryTimeServiceForTesting() {
   CheckTime();
   return time_fetcher_ != nullptr;
 }
 
 void NetworkTimeTracker::WaitForFetchForTesting(uint32_t nonce) {
   query_signer_->OverrideNonceForTesting(kKeyVersion, nonce);
   base::RunLoop run_loop;
   fetch_completion_callbacks_.push_back(run_loop.QuitClosure());
   run_loop.Run();
 }
 
+void NetworkTimeTracker::OverrideNonceForTesting(uint32_t nonce) {
+  query_signer_->OverrideNonceForTesting(kKeyVersion, nonce);
+}
+
 base::TimeDelta NetworkTimeTracker::GetTimerDelayForTesting() const {
   DCHECK(timer_.IsRunning());
   return timer_.GetCurrentDelay();
 }
 
 NetworkTimeTracker::NetworkTimeResult NetworkTimeTracker::GetNetworkTime(
     base::Time* network_time,
     base::TimeDelta* uncertainty) const {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(network_time);
@@ skipping 52 matching lines @@
   }
   *network_time = network_time_at_last_measurement_ + tick_delta;
   if (uncertainty) {
     *uncertainty = network_time_uncertainty_ + divergence;
   }
   return NETWORK_TIME_AVAILABLE;
 }
 
 bool NetworkTimeTracker::StartTimeFetch(const base::Closure& closure) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  // Check if the user is opted in to on-demand time fetches.
-  const std::string param = variations::GetVariationParamValueByFeature(
-      kNetworkTimeServiceQuerying, kVariationsServiceEnableFetchesOnDemand);
-  if (param != "true") {
+  if (!OnDemandQueriesEnabled()) {
     return false;
   }
 
   // Enqueue the callback before calling CheckTime(), so that if
   // CheckTime() completes synchronously, the callback gets called.
   fetch_completion_callbacks_.push_back(closure);
 
   // If a time query is already in progress, do not start another one.
   if (time_fetcher_) {
     return true;
@@ skipping 138 matching lines @@
   // because a callback could call StartTimeFetch() to enqueue another
   // callback.
   std::vector<base::Closure> callbacks = fetch_completion_callbacks_;
   fetch_completion_callbacks_.clear();
   for (const auto& callback : callbacks) {
     callback.Run();
   }
 }
 
 void NetworkTimeTracker::QueueCheckTime(base::TimeDelta delay) {
-  timer_.Start(FROM_HERE, delay, this, &NetworkTimeTracker::CheckTime);
+  // Check if the user is opted in to background time fetches.
+  if (BackgroundQueriesEnabled()) {
+    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() does not return NETWORK_TIME_AVAILABLE,
   // synchronization has been lost and a query is needed.
   base::Time network_time;
   if (GetNetworkTime(&network_time, nullptr) != NETWORK_TIME_AVAILABLE) {
     return true;
   }
 
   // Otherwise, make the decision at random.
   return base::RandDouble() < RandomQueryProbability();
 }
 
 }  // namespace network_time