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 270 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 87 matching lines @@
     *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, kVariationsServiceFetchBehavior);
-  if (param == "background-only") {
+  if (!AreTimeFetchesEnabled() ||
+      GetFetchBehavior() == FETCHES_IN_BACKGROUND_ONLY) {
     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) {
-  // Check if the user is opted in to background time fetches.
-  const std::string param = variations::GetVariationParamValueByFeature(
-      kNetworkTimeServiceQuerying, kVariationsServiceFetchBehavior);
-  if (base::FeatureList::IsEnabled(kNetworkTimeServiceQuerying) &&
-      param != "on-demand-only") {
+  if (AreTimeFetchesEnabled() && GetFetchBehavior() != FETCHES_ON_DEMAND_ONLY) {
     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