Add experimental feature info to certificate reports

components/network_time/network_time_tracker_unittest.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 <memory>
 #include <string>
 #include <utility>
 
@@ skipping 39 matching lines @@
         clock_(new base::SimpleTestClock),
         tick_clock_(new base::SimpleTestTickClock),
         test_server_(new net::EmbeddedTestServer) {
     base::Thread::Options thread_options;
     thread_options.message_loop_type = base::MessageLoop::TYPE_IO;
     EXPECT_TRUE(io_thread_.StartWithOptions(thread_options));
     NetworkTimeTracker::RegisterPrefs(pref_service_.registry());
 
     field_trial_test_->SetNetworkQueriesWithVariationsService(
         true, 0.0 /* query probability */,
-        FieldTrialTest::FETCHES_IN_BACKGROUND_AND_ON_DEMAND);
+        NetworkTimeTracker::FETCHES_IN_BACKGROUND_AND_ON_DEMAND);
 
     tracker_.reset(new NetworkTimeTracker(
         std::unique_ptr<base::Clock>(clock_),
         std::unique_ptr<base::TickClock>(tick_clock_), &pref_service_,
         new net::TestURLRequestContextGetter(io_thread_.task_runner())));
 
     // Do this to be sure that |is_null| returns false.
     clock_->Advance(base::TimeDelta::FromDays(111));
     tick_clock_->Advance(base::TimeDelta::FromDays(222));
 
@@ skipping 477 matching lines @@
 
   // No query should be started so long as NetworkTimeTracker is synced.
   base::RunLoop run_loop;
   EXPECT_FALSE(tracker_->StartTimeFetch(run_loop.QuitClosure()));
 }
 
 // Tests that StartTimeFetch() returns false if the field trial
 // is not configured to allow on-demand time fetches.
 TEST_F(NetworkTimeTrackerTest, StartTimeFetchWithoutVariationsParam) {
   field_trial_test_->SetNetworkQueriesWithVariationsService(
-      true, 0.0, FieldTrialTest::FETCHES_IN_BACKGROUND_ONLY);
+      true, 0.0, NetworkTimeTracker::FETCHES_IN_BACKGROUND_ONLY);
   test_server_->RegisterRequestHandler(base::Bind(&GoodTimeResponseHandler));
   EXPECT_TRUE(test_server_->Start());
   tracker_->SetTimeServerURLForTesting(test_server_->GetURL("/"));
 
   base::Time out_network_time;
   EXPECT_EQ(NetworkTimeTracker::NETWORK_TIME_NO_SYNC_ATTEMPT,
             tracker_->GetNetworkTime(&out_network_time, nullptr));
 
   base::RunLoop run_loop;
   EXPECT_FALSE(tracker_->StartTimeFetch(run_loop.QuitClosure()));
 }
 
 TEST_F(NetworkTimeTrackerTest, NoNetworkQueryWhileSynced) {
   test_server_->RegisterRequestHandler(base::Bind(&GoodTimeResponseHandler));
   EXPECT_TRUE(test_server_->Start());
   tracker_->SetTimeServerURLForTesting(test_server_->GetURL("/"));
 
   field_trial_test_->SetNetworkQueriesWithVariationsService(
-      true, 0.0, FieldTrialTest::FETCHES_IN_BACKGROUND_AND_ON_DEMAND);
+      true, 0.0, NetworkTimeTracker::FETCHES_IN_BACKGROUND_AND_ON_DEMAND);
   base::Time in_network_time = clock_->Now();
   UpdateNetworkTime(in_network_time, resolution_, latency_,
                     tick_clock_->NowTicks());
 
   // No query should be started so long as NetworkTimeTracker is synced, but the
   // next check should happen soon.
   EXPECT_FALSE(tracker_->QueryTimeServiceForTesting());
   EXPECT_EQ(base::TimeDelta::FromMinutes(6),
             tracker_->GetTimerDelayForTesting());
 
   field_trial_test_->SetNetworkQueriesWithVariationsService(
-      true, 1.0, FieldTrialTest::FETCHES_IN_BACKGROUND_AND_ON_DEMAND);
+      true, 1.0, NetworkTimeTracker::FETCHES_IN_BACKGROUND_AND_ON_DEMAND);
   EXPECT_TRUE(tracker_->QueryTimeServiceForTesting());
   tracker_->WaitForFetchForTesting(123123123);
   EXPECT_EQ(base::TimeDelta::FromMinutes(60),
             tracker_->GetTimerDelayForTesting());
 }
 
 TEST_F(NetworkTimeTrackerTest, NoNetworkQueryWhileFeatureDisabled) {
   // Disable network time queries and check that a query is not sent.
   field_trial_test_->SetNetworkQueriesWithVariationsService(
-      false, 0.0, FieldTrialTest::FETCHES_IN_BACKGROUND_AND_ON_DEMAND);
+      false, 0.0, NetworkTimeTracker::FETCHES_IN_BACKGROUND_AND_ON_DEMAND);
   EXPECT_FALSE(tracker_->QueryTimeServiceForTesting());
   // The timer is not started when the feature is disabled.
   EXPECT_EQ(base::TimeDelta::FromMinutes(0),
             tracker_->GetTimerDelayForTesting());
 
   // Enable time queries and check that a query is sent.
   field_trial_test_->SetNetworkQueriesWithVariationsService(
-      true, 0.0, FieldTrialTest::FETCHES_IN_BACKGROUND_AND_ON_DEMAND);
+      true, 0.0, NetworkTimeTracker::FETCHES_IN_BACKGROUND_AND_ON_DEMAND);
   EXPECT_TRUE(tracker_->QueryTimeServiceForTesting());
   tracker_->WaitForFetchForTesting(123123123);
 }
 
 TEST_F(NetworkTimeTrackerTest, UpdateFromNetworkBadSignature) {
   base::HistogramTester histograms;
   histograms.ExpectTotalCount(kFetchFailedHistogram, 0);
   histograms.ExpectTotalCount(kFetchValidHistogram, 0);
 
   test_server_->RegisterRequestHandler(
@@ skipping 189 matching lines @@
   EXPECT_EQ(NetworkTimeTracker::NETWORK_TIME_SUBSEQUENT_SYNC_PENDING,
             tracker_->GetNetworkTime(&out_network_time, nullptr));
   histograms.ExpectTotalCount(kFetchFailedHistogram, 0);
   histograms.ExpectTotalCount(kFetchValidHistogram, 1);
   histograms.ExpectBucketCount(kFetchValidHistogram, false, 1);
 
   tracker_->WaitForFetchForTesting(123123123);
 }
 
 }  // namespace network_time