When network time is unavailable, record the reason in UMA

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 <map>
 #include <memory>
 #include <string>
 #include <utility>
@@ skipping 15 matching lines @@
 #include "net/http/http_response_headers.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "net/test/embedded_test_server/http_response.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace network_time {
 
 namespace {
+const uint32_t kOneDayInSeconds = 86400;
 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 testing::Test {
  public:
   ~NetworkTimeTrackerTest() override {}
 
   NetworkTimeTrackerTest()
       : io_thread_("IO thread"),
         clock_(new base::SimpleTestClock),
         tick_clock_(new base::SimpleTestTickClock),
@@ skipping 177 matching lines @@
   TestingPrefServiceSimple pref_service_;
   std::unique_ptr<base::FieldTrialList> field_trial_list_;
   std::unique_ptr<NetworkTimeTracker> tracker_;
   std::unique_ptr<net::EmbeddedTestServer> test_server_;
   std::unique_ptr<base::test::ScopedFeatureList> scoped_feature_list_;
 };
 
 TEST_F(NetworkTimeTrackerTest, Uninitialized) {
   base::Time network_time;
   base::TimeDelta uncertainty;
-  EXPECT_FALSE(tracker_->GetNetworkTime(&network_time, &uncertainty));
+  EXPECT_EQ(NetworkTimeTracker::NETWORK_TIME_NO_SYNC,
+            tracker_->GetNetworkTime(&network_time, &uncertainty));
 }
 
 TEST_F(NetworkTimeTrackerTest, LongPostingDelay) {
   // The request arrives at the server, which records the time.  Advance the
   // clock to simulate the latency of sending the reply, which we'll say for
   // convenience is half the total latency.
   base::Time in_network_time = clock_->Now();
   AdvanceBoth(latency_ / 2);
 
   // Record the tick counter at the time the reply is received.  At this point,
   // we would post UpdateNetworkTime to be run on the browser thread.
   base::TimeTicks posting_time = tick_clock_->NowTicks();
 
   // Simulate that it look a long time (1888us) for the browser thread to get
   // around to executing the update.
   AdvanceBoth(base::TimeDelta::FromMicroseconds(1888));
   UpdateNetworkTime(in_network_time, resolution_, latency_, posting_time);
 
   base::Time out_network_time;
   base::TimeDelta uncertainty;
-  EXPECT_TRUE(tracker_->GetNetworkTime(&out_network_time,  &uncertainty));
+  EXPECT_EQ(NetworkTimeTracker::NETWORK_TIME_AVAILABLE,
+            tracker_->GetNetworkTime(&out_network_time, &uncertainty));
   EXPECT_EQ(resolution_ + latency_ + adjustment_, uncertainty);
   EXPECT_EQ(clock_->Now(), out_network_time);
 }
 
 TEST_F(NetworkTimeTrackerTest, LopsidedLatency) {
   // Simulate that the server received the request instantaneously, and that all
   // of the latency was in sending the reply.  (This contradicts the assumption
   // in the code.)
   base::Time in_network_time = clock_->Now();
   AdvanceBoth(latency_);
   UpdateNetworkTime(in_network_time, resolution_, latency_,
                     tick_clock_->NowTicks());
 
   // But, the answer is still within the uncertainty bounds!
   base::Time out_network_time;
   base::TimeDelta uncertainty;
-  EXPECT_TRUE(tracker_->GetNetworkTime(&out_network_time,  &uncertainty));
+  EXPECT_EQ(NetworkTimeTracker::NETWORK_TIME_AVAILABLE,
+            tracker_->GetNetworkTime(&out_network_time, &uncertainty));
   EXPECT_LT(out_network_time - uncertainty / 2, clock_->Now());
   EXPECT_GT(out_network_time + uncertainty / 2, clock_->Now());
 }
 
 TEST_F(NetworkTimeTrackerTest, ClockIsWack) {
   // Now let's assume the system clock is completely wrong.
   base::Time in_network_time = clock_->Now() - base::TimeDelta::FromDays(90);
   UpdateNetworkTime(in_network_time - latency_ / 2, resolution_, latency_,
                     tick_clock_->NowTicks());
 
   base::Time out_network_time;
-  EXPECT_TRUE(tracker_->GetNetworkTime(&out_network_time, nullptr));
+  EXPECT_EQ(NetworkTimeTracker::NETWORK_TIME_AVAILABLE,
+            tracker_->GetNetworkTime(&out_network_time, nullptr));
   EXPECT_EQ(in_network_time, out_network_time);
 }
 
 TEST_F(NetworkTimeTrackerTest, ClocksDivergeSlightly) {
   // The two clocks are allowed to diverge a little bit.
+  base::HistogramTester histograms;
+  histograms.ExpectTotalCount(kClockDivergencePositiveHistogram, 0);
+  histograms.ExpectTotalCount(kClockDivergenceNegativeHistogram, 0);
+  histograms.ExpectTotalCount(kWallClockBackwardsHistogram, 0);
   base::Time in_network_time = clock_->Now();
   UpdateNetworkTime(in_network_time - latency_ / 2, resolution_, latency_,
                     tick_clock_->NowTicks());
 
   base::TimeDelta small = base::TimeDelta::FromSeconds(30);
   tick_clock_->Advance(small);
   base::Time out_network_time;
   base::TimeDelta out_uncertainty;
-  EXPECT_TRUE(tracker_->GetNetworkTime(&out_network_time, &out_uncertainty));
+  EXPECT_EQ(NetworkTimeTracker::NETWORK_TIME_AVAILABLE,
+            tracker_->GetNetworkTime(&out_network_time, &out_uncertainty));
   EXPECT_EQ(in_network_time + small, out_network_time);
   // The clock divergence should show up in the uncertainty.
   EXPECT_EQ(resolution_ + latency_ + adjustment_ + small, out_uncertainty);
+  histograms.ExpectTotalCount(kClockDivergencePositiveHistogram, 0);
+  histograms.ExpectTotalCount(kClockDivergenceNegativeHistogram, 0);
+  histograms.ExpectTotalCount(kWallClockBackwardsHistogram, 0);
 }
 
 TEST_F(NetworkTimeTrackerTest, NetworkTimeUpdates) {
   // Verify that the the tracker receives and properly handles updates to the
   // network time.
   base::Time out_network_time;
   base::TimeDelta uncertainty;
 
   UpdateNetworkTime(clock_->Now() - latency_ / 2, resolution_, latency_,
                     tick_clock_->NowTicks());
-  EXPECT_TRUE(tracker_->GetNetworkTime(&out_network_time,  &uncertainty));
+  EXPECT_EQ(NetworkTimeTracker::NETWORK_TIME_AVAILABLE,
+            tracker_->GetNetworkTime(&out_network_time, &uncertainty));
   EXPECT_EQ(clock_->Now(), out_network_time);
   EXPECT_EQ(resolution_ + latency_ + adjustment_, uncertainty);
 
   // Fake a wait to make sure we keep tracking.
   AdvanceBoth(base::TimeDelta::FromSeconds(1));
-  EXPECT_TRUE(tracker_->GetNetworkTime(&out_network_time,  &uncertainty));
+  EXPECT_EQ(NetworkTimeTracker::NETWORK_TIME_AVAILABLE,
+            tracker_->GetNetworkTime(&out_network_time, &uncertainty));
   EXPECT_EQ(clock_->Now(), out_network_time);
   EXPECT_EQ(resolution_ + latency_ + adjustment_, uncertainty);
 
   // And one more time.
   UpdateNetworkTime(clock_->Now() - latency_ / 2, resolution_, latency_,
                     tick_clock_->NowTicks());
   AdvanceBoth(base::TimeDelta::FromSeconds(1));
-  EXPECT_TRUE(tracker_->GetNetworkTime(&out_network_time,  &uncertainty));
+  EXPECT_EQ(NetworkTimeTracker::NETWORK_TIME_AVAILABLE,
+            tracker_->GetNetworkTime(&out_network_time, &uncertainty));
   EXPECT_EQ(clock_->Now(), out_network_time);
   EXPECT_EQ(resolution_ + latency_ + adjustment_, uncertainty);
 }
 
 TEST_F(NetworkTimeTrackerTest, SpringForward) {
+  base::HistogramTester histograms;
+  histograms.ExpectTotalCount(kClockDivergencePositiveHistogram, 0);
+  histograms.ExpectTotalCount(kClockDivergenceNegativeHistogram, 0);
+  histograms.ExpectTotalCount(kWallClockBackwardsHistogram, 0);
   // Simulate the wall clock advancing faster than the tick clock.
   UpdateNetworkTime(clock_->Now(), resolution_, latency_,
                     tick_clock_->NowTicks());
   tick_clock_->Advance(base::TimeDelta::FromSeconds(1));
   clock_->Advance(base::TimeDelta::FromDays(1));
   base::Time out_network_time;
-  EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, nullptr));
+  EXPECT_EQ(NetworkTimeTracker::NETWORK_TIME_SYNC_LOST,
+            tracker_->GetNetworkTime(&out_network_time, nullptr));
+  histograms.ExpectTotalCount(kClockDivergencePositiveHistogram, 0);
+  histograms.ExpectTotalCount(kClockDivergenceNegativeHistogram, 1);
+  histograms.ExpectTotalCount(kWallClockBackwardsHistogram, 0);
+  // The recorded clock divergence should be 1 second - 1 day in seconds.
+  histograms.ExpectBucketCount(
+      kClockDivergenceNegativeHistogram,
+      base::TimeDelta::FromSeconds(kOneDayInSeconds - 1).InMilliseconds(), 1);
+}
+
+TEST_F(NetworkTimeTrackerTest, TickClockSpringsForward) {
+  base::HistogramTester histograms;
+  histograms.ExpectTotalCount(kClockDivergencePositiveHistogram, 0);
+  histograms.ExpectTotalCount(kClockDivergenceNegativeHistogram, 0);
+  histograms.ExpectTotalCount(kWallClockBackwardsHistogram, 0);
+  // Simulate the tick clock advancing faster than the wall clock.
+  UpdateNetworkTime(clock_->Now(), resolution_, latency_,
+                    tick_clock_->NowTicks());
+  tick_clock_->Advance(base::TimeDelta::FromDays(1));
+  clock_->Advance(base::TimeDelta::FromSeconds(1));
+  base::Time out_network_time;
+  EXPECT_EQ(NetworkTimeTracker::NETWORK_TIME_SYNC_LOST,
+            tracker_->GetNetworkTime(&out_network_time, nullptr));
+  histograms.ExpectTotalCount(kClockDivergencePositiveHistogram, 1);
+  histograms.ExpectTotalCount(kClockDivergenceNegativeHistogram, 0);
+  histograms.ExpectTotalCount(kWallClockBackwardsHistogram, 0);
+  // The recorded clock divergence should be 1 day - 1 second.
+  histograms.ExpectBucketCount(
+      kClockDivergencePositiveHistogram,
+      base::TimeDelta::FromSeconds(kOneDayInSeconds - 1).InMilliseconds(), 1);
 }
 
 TEST_F(NetworkTimeTrackerTest, FallBack) {
+  base::HistogramTester histograms;
+  histograms.ExpectTotalCount(kClockDivergencePositiveHistogram, 0);
+  histograms.ExpectTotalCount(kClockDivergenceNegativeHistogram, 0);
+  histograms.ExpectTotalCount(kWallClockBackwardsHistogram, 0);
   // Simulate the wall clock running backward.
   UpdateNetworkTime(clock_->Now(), resolution_, latency_,
                     tick_clock_->NowTicks());
   tick_clock_->Advance(base::TimeDelta::FromSeconds(1));
   clock_->Advance(base::TimeDelta::FromDays(-1));
   base::Time out_network_time;
-  EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, nullptr));
+  EXPECT_EQ(NetworkTimeTracker::NETWORK_TIME_SYNC_LOST,
+            tracker_->GetNetworkTime(&out_network_time, nullptr));
+  histograms.ExpectTotalCount(kClockDivergencePositiveHistogram, 0);
+  histograms.ExpectTotalCount(kClockDivergenceNegativeHistogram, 0);
+  histograms.ExpectTotalCount(kWallClockBackwardsHistogram, 1);
+  histograms.ExpectBucketCount(
+      kWallClockBackwardsHistogram,
+      base::TimeDelta::FromSeconds(kOneDayInSeconds - 1).InMilliseconds(), 1);
 }
 
 TEST_F(NetworkTimeTrackerTest, SuspendAndResume) {
   // Simulate the wall clock advancing while the tick clock stands still, as
   // would happen in a suspend+resume cycle.
   UpdateNetworkTime(clock_->Now(), resolution_, latency_,
                     tick_clock_->NowTicks());
   clock_->Advance(base::TimeDelta::FromHours(1));
   base::Time out_network_time;
-  EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, nullptr));
+  EXPECT_EQ(NetworkTimeTracker::NETWORK_TIME_SYNC_LOST,
+            tracker_->GetNetworkTime(&out_network_time, nullptr));
 }
 
 TEST_F(NetworkTimeTrackerTest, Serialize) {
   // Test that we can serialize and deserialize state and get consistent
   // results.
   base::Time in_network_time = clock_->Now() - base::TimeDelta::FromDays(90);
   UpdateNetworkTime(in_network_time - latency_ / 2, resolution_, latency_,
                     tick_clock_->NowTicks());
   base::Time out_network_time;
   base::TimeDelta out_uncertainty;
-  EXPECT_TRUE(tracker_->GetNetworkTime(&out_network_time, &out_uncertainty));
+  EXPECT_EQ(NetworkTimeTracker::NETWORK_TIME_AVAILABLE,
+            tracker_->GetNetworkTime(&out_network_time, &out_uncertainty));
   EXPECT_EQ(in_network_time, out_network_time);
   EXPECT_EQ(resolution_ + latency_ + adjustment_, out_uncertainty);
 
   // 6 days is just under the threshold for discarding data.
   base::TimeDelta delta = base::TimeDelta::FromDays(6);
   AdvanceBoth(delta);
   Reset();
-  EXPECT_TRUE(tracker_->GetNetworkTime(&out_network_time, &out_uncertainty));
+  EXPECT_EQ(NetworkTimeTracker::NETWORK_TIME_AVAILABLE,
+            tracker_->GetNetworkTime(&out_network_time, &out_uncertainty));
   EXPECT_EQ(in_network_time + delta, out_network_time);
   EXPECT_EQ(resolution_ + latency_ + adjustment_, out_uncertainty);
 }
 
 TEST_F(NetworkTimeTrackerTest, DeserializeOldFormat) {
   // Test that deserializing old data (which do not record the uncertainty and
   // tick clock) causes the serialized data to be ignored.
   base::Time in_network_time = clock_->Now() - base::TimeDelta::FromDays(90);
   UpdateNetworkTime(in_network_time - latency_ / 2, resolution_, latency_,
                     tick_clock_->NowTicks());
 
   base::Time out_network_time;
-  EXPECT_TRUE(tracker_->GetNetworkTime(&out_network_time, nullptr));
+  EXPECT_EQ(NetworkTimeTracker::NETWORK_TIME_AVAILABLE,
+            tracker_->GetNetworkTime(&out_network_time, nullptr));
   double local, network;
   const base::DictionaryValue* saved_prefs =
       pref_service_.GetDictionary(prefs::kNetworkTimeMapping);
   saved_prefs->GetDouble("local", &local);
   saved_prefs->GetDouble("network", &network);
   base::DictionaryValue prefs;
   prefs.SetDouble("local", local);
   prefs.SetDouble("network", network);
   pref_service_.Set(prefs::kNetworkTimeMapping, prefs);
   Reset();
-  EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, nullptr));
+  EXPECT_EQ(NetworkTimeTracker::NETWORK_TIME_NO_SYNC,
+            tracker_->GetNetworkTime(&out_network_time, nullptr));
 }
 
 TEST_F(NetworkTimeTrackerTest, SerializeWithLongDelay) {
   // Test that if the serialized data are more than a week old, they are
   // discarded.
   base::Time in_network_time = clock_->Now() - base::TimeDelta::FromDays(90);
   UpdateNetworkTime(in_network_time - latency_ / 2, resolution_, latency_,
                     tick_clock_->NowTicks());
   base::Time out_network_time;
-  EXPECT_TRUE(tracker_->GetNetworkTime(&out_network_time, nullptr));
+  EXPECT_EQ(NetworkTimeTracker::NETWORK_TIME_AVAILABLE,
+            tracker_->GetNetworkTime(&out_network_time, nullptr));
   AdvanceBoth(base::TimeDelta::FromDays(8));
   Reset();
-  EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, nullptr));
+  EXPECT_EQ(NetworkTimeTracker::NETWORK_TIME_NO_SYNC,
+            tracker_->GetNetworkTime(&out_network_time, nullptr));
 }
 
 TEST_F(NetworkTimeTrackerTest, SerializeWithTickClockAdvance) {
   // Test that serialized data are discarded if the wall clock and tick clock
   // have not advanced consistently since data were serialized.
   base::Time in_network_time = clock_->Now() - base::TimeDelta::FromDays(90);
   UpdateNetworkTime(in_network_time - latency_ / 2, resolution_, latency_,
                     tick_clock_->NowTicks());
   base::Time out_network_time;
-  EXPECT_TRUE(tracker_->GetNetworkTime(&out_network_time, nullptr));
+  EXPECT_EQ(NetworkTimeTracker::NETWORK_TIME_AVAILABLE,
+            tracker_->GetNetworkTime(&out_network_time, nullptr));
   tick_clock_->Advance(base::TimeDelta::FromDays(1));
   Reset();
-  EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, nullptr));
+  EXPECT_EQ(NetworkTimeTracker::NETWORK_TIME_SYNC_LOST,
+            tracker_->GetNetworkTime(&out_network_time, nullptr));
 }
 
 TEST_F(NetworkTimeTrackerTest, SerializeWithWallClockAdvance) {
   // Test that serialized data are discarded if the wall clock and tick clock
   // have not advanced consistently since data were serialized.
   base::Time in_network_time = clock_->Now() - base::TimeDelta::FromDays(90);
   UpdateNetworkTime(in_network_time - latency_ / 2, resolution_, latency_,
                     tick_clock_->NowTicks());
 
   base::Time out_network_time;
-  EXPECT_TRUE(tracker_->GetNetworkTime(&out_network_time, nullptr));
+  EXPECT_EQ(NetworkTimeTracker::NETWORK_TIME_AVAILABLE,
+            tracker_->GetNetworkTime(&out_network_time, nullptr));
   clock_->Advance(base::TimeDelta::FromDays(1));
   Reset();
-  EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, nullptr));
+  EXPECT_EQ(NetworkTimeTracker::NETWORK_TIME_SYNC_LOST,
+            tracker_->GetNetworkTime(&out_network_time, nullptr));
 }
 
 TEST_F(NetworkTimeTrackerTest, UpdateFromNetwork) {
   base::HistogramTester histograms;
   histograms.ExpectTotalCount(kFetchFailedHistogram, 0);
   histograms.ExpectTotalCount(kFetchValidHistogram, 0);
 
   base::Time out_network_time;
-  EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, nullptr));
+  EXPECT_EQ(NetworkTimeTracker::NETWORK_TIME_NO_SYNC,
+            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));
   EXPECT_TRUE(test_server_->Start());
   tracker_->SetTimeServerURLForTesting(test_server_->GetURL("/"));
   EXPECT_TRUE(tracker_->QueryTimeServiceForTesting());
   tracker_->WaitForFetchForTesting(123123123);
 
-  EXPECT_TRUE(tracker_->GetNetworkTime(&out_network_time, nullptr));
+  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);
@@ skipping 42 matching lines @@
   histograms.ExpectTotalCount(kFetchValidHistogram, 0);
 
   test_server_->RegisterRequestHandler(
       base::Bind(&NetworkTimeTrackerTest::BadSignatureResponseHandler));
   EXPECT_TRUE(test_server_->Start());
   tracker_->SetTimeServerURLForTesting(test_server_->GetURL("/"));
   EXPECT_TRUE(tracker_->QueryTimeServiceForTesting());
   tracker_->WaitForFetchForTesting(123123123);
 
   base::Time out_network_time;
-  EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, nullptr));
+  EXPECT_EQ(NetworkTimeTracker::NETWORK_TIME_NO_SYNC,
+            tracker_->GetNetworkTime(&out_network_time, nullptr));
   EXPECT_EQ(base::TimeDelta::FromMinutes(120),
             tracker_->GetTimerDelayForTesting());
 
   histograms.ExpectTotalCount(kFetchFailedHistogram, 0);
   histograms.ExpectTotalCount(kFetchValidHistogram, 1);
   histograms.ExpectBucketCount(kFetchValidHistogram, false, 1);
 }
 
 static const uint8_t kDevKeyPubBytes[] = {
     0x30, 0x59, 0x30, 0x13, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02,
@@ skipping 13 matching lines @@
   test_server_->RegisterRequestHandler(
       base::Bind(&NetworkTimeTrackerTest::BadDataResponseHandler));
   EXPECT_TRUE(test_server_->Start());
   base::StringPiece key = {reinterpret_cast<const char*>(kDevKeyPubBytes),
                            sizeof(kDevKeyPubBytes)};
   tracker_->SetPublicKeyForTesting(key);
   tracker_->SetTimeServerURLForTesting(test_server_->GetURL("/"));
   EXPECT_TRUE(tracker_->QueryTimeServiceForTesting());
   tracker_->WaitForFetchForTesting(123123123);
   base::Time out_network_time;
-  EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, nullptr));
+  EXPECT_EQ(NetworkTimeTracker::NETWORK_TIME_NO_SYNC,
+            tracker_->GetNetworkTime(&out_network_time, nullptr));
   EXPECT_EQ(base::TimeDelta::FromMinutes(120),
             tracker_->GetTimerDelayForTesting());
 
   histograms.ExpectTotalCount(kFetchFailedHistogram, 0);
   histograms.ExpectTotalCount(kFetchValidHistogram, 1);
   histograms.ExpectBucketCount(kFetchValidHistogram, false, 1);
 }
 
 TEST_F(NetworkTimeTrackerTest, UpdateFromNetworkServerError) {
   base::HistogramTester histograms;
   histograms.ExpectTotalCount(kFetchFailedHistogram, 0);
   histograms.ExpectTotalCount(kFetchValidHistogram, 0);
 
   test_server_->RegisterRequestHandler(
       base::Bind(&NetworkTimeTrackerTest::ServerErrorResponseHandler));
   EXPECT_TRUE(test_server_->Start());
   tracker_->SetTimeServerURLForTesting(test_server_->GetURL("/"));
   EXPECT_TRUE(tracker_->QueryTimeServiceForTesting());
   tracker_->WaitForFetchForTesting(123123123);
 
   base::Time out_network_time;
-  EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, nullptr));
+  EXPECT_EQ(NetworkTimeTracker::NETWORK_TIME_NO_SYNC,
+            tracker_->GetNetworkTime(&out_network_time, nullptr));
   // Should see backoff in the error case.
   EXPECT_EQ(base::TimeDelta::FromMinutes(120),
             tracker_->GetTimerDelayForTesting());
 
   histograms.ExpectTotalCount(kFetchFailedHistogram, 1);
   // There was no network error, so the histogram is recorded as
   // net::OK, indicating that the connection succeeded but there was a
   // non-200 HTTP status code.
   histograms.ExpectBucketCount(kFetchFailedHistogram, net::OK, 1);
   histograms.ExpectTotalCount(kFetchValidHistogram, 0);
 }
 
 TEST_F(NetworkTimeTrackerTest, UpdateFromNetworkNetworkError) {
   base::HistogramTester histograms;
   histograms.ExpectTotalCount(kFetchFailedHistogram, 0);
   histograms.ExpectTotalCount(kFetchValidHistogram, 0);
 
   test_server_->RegisterRequestHandler(
       base::Bind(&NetworkTimeTrackerTest::NetworkErrorResponseHandler));
   EXPECT_TRUE(test_server_->Start());
   tracker_->SetTimeServerURLForTesting(test_server_->GetURL("/"));
   EXPECT_TRUE(tracker_->QueryTimeServiceForTesting());
   tracker_->WaitForFetchForTesting(123123123);
 
   base::Time out_network_time;
-  EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, nullptr));
+  EXPECT_EQ(NetworkTimeTracker::NETWORK_TIME_NO_SYNC,
+            tracker_->GetNetworkTime(&out_network_time, nullptr));
   // Should see backoff in the error case.
   EXPECT_EQ(base::TimeDelta::FromMinutes(120),
             tracker_->GetTimerDelayForTesting());
 
   histograms.ExpectTotalCount(kFetchFailedHistogram, 1);
   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));
   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_FALSE(tracker_->GetNetworkTime(&out_network_time, nullptr));
+  EXPECT_EQ(NetworkTimeTracker::NETWORK_TIME_NO_SYNC,
+            tracker_->GetNetworkTime(&out_network_time, nullptr));
 
   histograms.ExpectTotalCount(kFetchFailedHistogram, 1);
   histograms.ExpectTotalCount(kFetchValidHistogram, 0);
 
   tracker_->SetMaxResponseSizeForTesting(1024);
   EXPECT_TRUE(tracker_->QueryTimeServiceForTesting());
   tracker_->WaitForFetchForTesting(123123123);
-  EXPECT_TRUE(tracker_->GetNetworkTime(&out_network_time, nullptr));
+  EXPECT_EQ(NetworkTimeTracker::NETWORK_TIME_AVAILABLE,
+            tracker_->GetNetworkTime(&out_network_time, nullptr));
 
   histograms.ExpectTotalCount(kFetchFailedHistogram, 1);
   histograms.ExpectTotalCount(kFetchValidHistogram, 1);
   histograms.ExpectBucketCount(kFetchValidHistogram, true, 1);
 }
 
 }  // namespace network_time