Refactor network_time_test_utils

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 21 matching lines @@
 const char kFetchFailedHistogram[] = "NetworkTimeTracker.UpdateTimeFetchFailed";
 const char kFetchValidHistogram[] = "NetworkTimeTracker.UpdateTimeFetchValid";
 const char kClockDivergencePositiveHistogram[] =
     "NetworkTimeTracker.ClockDivergence.Positive";
 const char kClockDivergenceNegativeHistogram[] =
     "NetworkTimeTracker.ClockDivergence.Negative";
 const char kWallClockBackwardsHistogram[] =
     "NetworkTimeTracker.WallClockRanBackwards";
 }  // namespace
 
-class NetworkTimeTrackerTest : public FieldTrialTest {
+class NetworkTimeTrackerTest : public ::testing::Test {
  public:
   ~NetworkTimeTrackerTest() override {}
 
   NetworkTimeTrackerTest()
       : io_thread_("IO thread"),
+        field_trial_test_(new FieldTrialTest()),
         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());
 
-    SetNetworkQueriesWithVariationsService(true, 0.0 /* query probability */);
+    field_trial_test_->SetNetworkQueriesWithVariationsService(
+        true, 0.0 /* query probability */,
+        FieldTrialTest::ENABLE_FETCHES_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 13 matching lines @@
     base::SimpleTestTickClock* new_tick_clock = new base::SimpleTestTickClock();
     new_tick_clock->SetNowTicks(tick_clock_->NowTicks());
     clock_ = new_clock;
     tick_clock_ = new_tick_clock;
     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())));
   }
 
-  // Returns a valid time response.  Update as follows:
-  //
-  // curl http://clients2.google.com/time/1/current?cup2key=1:123123123
-  //
-  // where 1 is the key version and 123123123 is the nonce.  Copy the nonce, the
-  // response, and the x-cup-server-proof header into the test.
-  static std::unique_ptr<net::test_server::HttpResponse>
-  GoodTimeResponseHandler(const net::test_server::HttpRequest& request) {
-    net::test_server::BasicHttpResponse* response =
-        new net::test_server::BasicHttpResponse();
-    response->set_code(net::HTTP_OK);
-    response->set_content(
-        ")]}'\n"
-        "{\"current_time_millis\":1461621971825,\"server_nonce\":-6."
-        "006853099049523E85}");
-    response->AddCustomHeader(
-        "x-cup-server-proof",
-        "304402202e0f24db1ea69f1bbe81da4108f381fcf7a2781c53cf7663cb47083cb5fe8e"
-        "fd"
-        "022009d2b67c0deceaaf849f7c529be96701ed5f15d5efcaf401a94e0801accc9832:"
-        "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855");
-    return std::unique_ptr<net::test_server::HttpResponse>(response);
-  }
-
   // Good signature over invalid data, though made with a non-production key.
   static std::unique_ptr<net::test_server::HttpResponse> BadDataResponseHandler(
       const net::test_server::HttpRequest& request) {
     net::test_server::BasicHttpResponse* response =
         new net::test_server::BasicHttpResponse();
     response->set_code(net::HTTP_OK);
     response->set_content(
         ")]}'\n"
         "{\"current_time_millis\":NaN,\"server_nonce\":9.420921002039447E182}");
     response->AddCustomHeader(
@@ skipping 44 matching lines @@
 
   // Advances both the system clock and the tick clock.  This should be used for
   // the normal passage of time, i.e. when neither clock is doing anything odd.
   void AdvanceBoth(const base::TimeDelta& delta) {
     tick_clock_->Advance(delta);
     clock_->Advance(delta);
   }
 
  protected:
   base::Thread io_thread_;
+  std::unique_ptr<FieldTrialTest> field_trial_test_;
   base::MessageLoop message_loop_;
   base::TimeDelta resolution_;
   base::TimeDelta latency_;
   base::TimeDelta adjustment_;
   base::SimpleTestClock* clock_;
   base::SimpleTestTickClock* tick_clock_;
   TestingPrefServiceSimple pref_service_;
   std::unique_ptr<NetworkTimeTracker> tracker_;
   std::unique_ptr<net::EmbeddedTestServer> test_server_;
 };
@@ skipping 287 matching lines @@
   histograms.ExpectTotalCount(kFetchFailedHistogram, 0);
   histograms.ExpectTotalCount(kFetchValidHistogram, 0);
 
   base::Time out_network_time;
   EXPECT_EQ(NetworkTimeTracker::NETWORK_TIME_NO_SYNC_ATTEMPT,
             tracker_->GetNetworkTime(&out_network_time, nullptr));
   // First query should happen soon.
   EXPECT_EQ(base::TimeDelta::FromMinutes(0),
             tracker_->GetTimerDelayForTesting());
 
-  test_server_->RegisterRequestHandler(
-      base::Bind(&NetworkTimeTrackerTest::GoodTimeResponseHandler));
+  test_server_->RegisterRequestHandler(base::Bind(&GoodTimeResponseHandler));
   EXPECT_TRUE(test_server_->Start());
   tracker_->SetTimeServerURLForTesting(test_server_->GetURL("/"));
   EXPECT_TRUE(tracker_->QueryTimeServiceForTesting());
   tracker_->WaitForFetchForTesting(123123123);
 
   EXPECT_EQ(NetworkTimeTracker::NETWORK_TIME_AVAILABLE,
             tracker_->GetNetworkTime(&out_network_time, nullptr));
   EXPECT_EQ(base::Time::UnixEpoch() +
                 base::TimeDelta::FromMilliseconds(1461621971825),
             out_network_time);
   // Should see no backoff in the success case.
   EXPECT_EQ(base::TimeDelta::FromMinutes(60),
             tracker_->GetTimerDelayForTesting());
 
   histograms.ExpectTotalCount(kFetchFailedHistogram, 0);
   histograms.ExpectTotalCount(kFetchValidHistogram, 1);
   histograms.ExpectBucketCount(kFetchValidHistogram, true, 1);
 }
 
 TEST_F(NetworkTimeTrackerTest, NoNetworkQueryWhileSynced) {
-  test_server_->RegisterRequestHandler(
-      base::Bind(&NetworkTimeTrackerTest::GoodTimeResponseHandler));
+  test_server_->RegisterRequestHandler(base::Bind(&GoodTimeResponseHandler));
   EXPECT_TRUE(test_server_->Start());
   tracker_->SetTimeServerURLForTesting(test_server_->GetURL("/"));
 
-  SetNetworkQueriesWithVariationsService(true, 0.0);
+  field_trial_test_->SetNetworkQueriesWithVariationsService(
+      true, 0.0, FieldTrialTest::ENABLE_FETCHES_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());
 
-  SetNetworkQueriesWithVariationsService(true, 1.0);
+  field_trial_test_->SetNetworkQueriesWithVariationsService(
+      true, 1.0, FieldTrialTest::ENABLE_FETCHES_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.
-  SetNetworkQueriesWithVariationsService(false, 0.0);
+  field_trial_test_->SetNetworkQueriesWithVariationsService(
+      false, 0.0, FieldTrialTest::ENABLE_FETCHES_ON_DEMAND);
   EXPECT_FALSE(tracker_->QueryTimeServiceForTesting());
   EXPECT_EQ(base::TimeDelta::FromMinutes(6),
             tracker_->GetTimerDelayForTesting());
 
   // Enable time queries and check that a query is sent.
-  SetNetworkQueriesWithVariationsService(true, 0.0);
+  field_trial_test_->SetNetworkQueriesWithVariationsService(
+      true, 0.0, FieldTrialTest::ENABLE_FETCHES_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 99 matching lines @@
   histograms.ExpectBucketCount(kFetchFailedHistogram, -net::ERR_EMPTY_RESPONSE,
                                1);
   histograms.ExpectTotalCount(kFetchValidHistogram, 0);
 }
 
 TEST_F(NetworkTimeTrackerTest, UpdateFromNetworkLargeResponse) {
   base::HistogramTester histograms;
   histograms.ExpectTotalCount(kFetchFailedHistogram, 0);
   histograms.ExpectTotalCount(kFetchValidHistogram, 0);
 
-  test_server_->RegisterRequestHandler(
-      base::Bind(&NetworkTimeTrackerTest::GoodTimeResponseHandler));
+  test_server_->RegisterRequestHandler(base::Bind(&GoodTimeResponseHandler));
   EXPECT_TRUE(test_server_->Start());
   tracker_->SetTimeServerURLForTesting(test_server_->GetURL("/"));
 
   base::Time out_network_time;
 
   tracker_->SetMaxResponseSizeForTesting(3);
   EXPECT_TRUE(tracker_->QueryTimeServiceForTesting());
   tracker_->WaitForFetchForTesting(123123123);
   EXPECT_EQ(NetworkTimeTracker::NETWORK_TIME_NO_SUCCESSFUL_SYNC,
             tracker_->GetNetworkTime(&out_network_time, nullptr));
@@ skipping 62 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