Add experimental feature info to certificate reports

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 139 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 111 matching lines @@
   time_mapping.SetDouble(kPrefTime, time_at_last_measurement_.ToJsTime());
   time_mapping.SetDouble(kPrefTicks, static_cast<double>(
       ticks_at_last_measurement_.ToInternalValue()));
   time_mapping.SetDouble(kPrefUncertainty, static_cast<double>(
       network_time_uncertainty_.ToInternalValue()));
   time_mapping.SetDouble(kPrefNetworkTime,
       network_time_at_last_measurement_.ToJsTime());
   pref_service_->Set(prefs::kNetworkTimeMapping, time_mapping);
 }
 
+bool NetworkTimeTracker::AreTimeFetchesEnabled() const {
+  return base::FeatureList::IsEnabled(kNetworkTimeServiceQuerying);
+}
+
+NetworkTimeTracker::FetchBehavior NetworkTimeTracker::GetFetchBehavior() const {
+  const std::string param = variations::GetVariationParamValueByFeature(
+      kNetworkTimeServiceQuerying, kVariationsServiceFetchBehavior);
+  if (param == "background-only") {
+    return FETCHES_IN_BACKGROUND_ONLY;
+  } else if (param == "on-demand-only") {
+    return FETCHES_ON_DEMAND_ONLY;
+  } else if (param == "background-and-on-demand") {
+    return FETCHES_IN_BACKGROUND_AND_ON_DEMAND;
+  }
+  return FETCH_BEHAVIOR_UNKNOWN;
+}
+
 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;
@@ skipping 84 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());
-  if (!OnDemandQueriesEnabled()) {
+  FetchBehavior behavior = GetFetchBehavior();
+  if (behavior != FETCHES_ON_DEMAND_ONLY &&
+      behavior != FETCHES_IN_BACKGROUND_AND_ON_DEMAND) {
     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 139 matching lines @@
   // 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) {
   // Check if the user is opted in to background time fetches.
-  if (BackgroundQueriesEnabled()) {
+  FetchBehavior behavior = GetFetchBehavior();
+  if (behavior == FETCHES_IN_BACKGROUND_ONLY ||
+      behavior == FETCHES_IN_BACKGROUND_AND_ON_DEMAND) {
     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)) {
+  if (!AreTimeFetchesEnabled()) {
     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