OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "components/network_time/network_time_tracker.h" | 5 #include "components/network_time/network_time_tracker.h" |
6 | 6 |
7 #include <memory> | 7 #include <memory> |
| 8 #include <utility> |
8 | 9 |
9 #include "base/compiler_specific.h" | 10 #include "base/compiler_specific.h" |
| 11 #include "base/feature_list.h" |
| 12 #include "base/strings/stringprintf.h" |
10 #include "base/test/simple_test_clock.h" | 13 #include "base/test/simple_test_clock.h" |
11 #include "base/test/simple_test_tick_clock.h" | 14 #include "base/test/simple_test_tick_clock.h" |
| 15 #include "components/client_update_protocol/ecdsa.h" |
12 #include "components/network_time/network_time_pref_names.h" | 16 #include "components/network_time/network_time_pref_names.h" |
13 #include "components/prefs/testing_pref_service.h" | 17 #include "components/prefs/testing_pref_service.h" |
| 18 #include "net/http/http_response_headers.h" |
| 19 #include "net/test/embedded_test_server/embedded_test_server.h" |
| 20 #include "net/test/embedded_test_server/http_response.h" |
| 21 #include "net/url_request/url_fetcher.h" |
| 22 #include "net/url_request/url_request_test_util.h" |
14 #include "testing/gtest/include/gtest/gtest.h" | 23 #include "testing/gtest/include/gtest/gtest.h" |
15 | 24 |
16 namespace network_time { | 25 namespace network_time { |
17 | 26 |
18 class NetworkTimeTrackerTest : public testing::Test { | 27 class NetworkTimeTrackerTest : public testing::Test { |
19 public: | 28 public: |
20 ~NetworkTimeTrackerTest() override {} | 29 ~NetworkTimeTrackerTest() override {} |
21 | 30 |
22 void SetUp() override { | 31 NetworkTimeTrackerTest() |
| 32 : io_thread_("IO thread"), |
| 33 clock_(new base::SimpleTestClock), |
| 34 tick_clock_(new base::SimpleTestTickClock), |
| 35 test_server_(new net::EmbeddedTestServer) { |
| 36 base::Thread::Options thread_options; |
| 37 thread_options.message_loop_type = base::MessageLoop::TYPE_IO; |
| 38 EXPECT_TRUE(io_thread_.StartWithOptions(thread_options)); |
23 NetworkTimeTracker::RegisterPrefs(pref_service_.registry()); | 39 NetworkTimeTracker::RegisterPrefs(pref_service_.registry()); |
24 | 40 |
25 clock_ = new base::SimpleTestClock(); | 41 tracker_.reset(new NetworkTimeTracker( |
26 tick_clock_ = new base::SimpleTestTickClock(); | 42 std::unique_ptr<base::Clock>(clock_), |
| 43 std::unique_ptr<base::TickClock>(tick_clock_), &pref_service_, |
| 44 new net::TestURLRequestContextGetter(io_thread_.task_runner()))); |
| 45 |
27 // Do this to be sure that |is_null| returns false. | 46 // Do this to be sure that |is_null| returns false. |
28 clock_->Advance(base::TimeDelta::FromDays(111)); | 47 clock_->Advance(base::TimeDelta::FromDays(111)); |
29 tick_clock_->Advance(base::TimeDelta::FromDays(222)); | 48 tick_clock_->Advance(base::TimeDelta::FromDays(222)); |
30 | 49 |
31 tracker_.reset(new NetworkTimeTracker( | |
32 std::unique_ptr<base::Clock>(clock_), | |
33 std::unique_ptr<base::TickClock>(tick_clock_), &pref_service_)); | |
34 | |
35 // Can not be smaller than 15, it's the NowFromSystemTime() resolution. | 50 // Can not be smaller than 15, it's the NowFromSystemTime() resolution. |
36 resolution_ = base::TimeDelta::FromMilliseconds(17); | 51 resolution_ = base::TimeDelta::FromMilliseconds(17); |
37 latency_ = base::TimeDelta::FromMilliseconds(50); | 52 latency_ = base::TimeDelta::FromMilliseconds(50); |
38 adjustment_ = 7 * base::TimeDelta::FromMilliseconds(kTicksResolutionMs); | 53 adjustment_ = 7 * base::TimeDelta::FromMilliseconds(kTicksResolutionMs); |
| 54 |
| 55 SetNetworkQueriesWithFinch(true); |
39 } | 56 } |
40 | 57 |
| 58 void TearDown() override { io_thread_.Stop(); } |
| 59 |
41 // Replaces |tracker_| with a new object, while preserving the | 60 // Replaces |tracker_| with a new object, while preserving the |
42 // testing clocks. | 61 // testing clocks. |
43 void Reset() { | 62 void Reset() { |
44 base::SimpleTestClock* new_clock = new base::SimpleTestClock(); | 63 base::SimpleTestClock* new_clock = new base::SimpleTestClock(); |
45 new_clock->SetNow(clock_->Now()); | 64 new_clock->SetNow(clock_->Now()); |
46 base::SimpleTestTickClock* new_tick_clock = new base::SimpleTestTickClock(); | 65 base::SimpleTestTickClock* new_tick_clock = new base::SimpleTestTickClock(); |
47 new_tick_clock->SetNowTicks(tick_clock_->NowTicks()); | 66 new_tick_clock->SetNowTicks(tick_clock_->NowTicks()); |
48 clock_ = new_clock; | 67 clock_ = new_clock; |
49 tick_clock_= new_tick_clock; | 68 tick_clock_ = new_tick_clock; |
50 tracker_.reset(new NetworkTimeTracker( | 69 tracker_.reset(new NetworkTimeTracker( |
51 std::unique_ptr<base::Clock>(clock_), | 70 std::unique_ptr<base::Clock>(clock_), |
52 std::unique_ptr<base::TickClock>(tick_clock_), &pref_service_)); | 71 std::unique_ptr<base::TickClock>(tick_clock_), &pref_service_, |
| 72 new net::TestURLRequestContextGetter(io_thread_.task_runner()))); |
| 73 } |
| 74 |
| 75 // Returns a valid time response. Update as follows: |
| 76 // |
| 77 // curl http://clients2.google.com/time/1/current?cup2key=1:123123123 |
| 78 // |
| 79 // where 1 is the key version and 123123123 is the nonce. Copy the nonce, the |
| 80 // response, and the x-cup-server-proof header into the test. |
| 81 static std::unique_ptr<net::test_server::HttpResponse> |
| 82 GoodTimeResponseHandler(const net::test_server::HttpRequest& request) { |
| 83 net::test_server::BasicHttpResponse* response = |
| 84 new net::test_server::BasicHttpResponse(); |
| 85 response->set_code(net::HTTP_OK); |
| 86 response->set_content( |
| 87 ")]}'\n" |
| 88 "{\"current_time_millis\":1461621971825,\"server_nonce\":-6." |
| 89 "006853099049523E85}"); |
| 90 response->AddCustomHeader( |
| 91 "x-cup-server-proof", |
| 92 "304402202e0f24db1ea69f1bbe81da4108f381fcf7a2781c53cf7663cb47083cb5fe8e" |
| 93 "fd" |
| 94 "022009d2b67c0deceaaf849f7c529be96701ed5f15d5efcaf401a94e0801accc9832:" |
| 95 "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"); |
| 96 return std::unique_ptr<net::test_server::HttpResponse>(response); |
| 97 } |
| 98 |
| 99 // Good signature over invalid data, though made with a non-production key. |
| 100 static std::unique_ptr<net::test_server::HttpResponse> BadDataResponseHandler( |
| 101 const net::test_server::HttpRequest& request) { |
| 102 net::test_server::BasicHttpResponse* response = |
| 103 new net::test_server::BasicHttpResponse(); |
| 104 response->set_code(net::HTTP_OK); |
| 105 response->set_content( |
| 106 ")]}'\n" |
| 107 "{\"current_time_millis\":NaN,\"server_nonce\":9.420921002039447E182}"); |
| 108 response->AddCustomHeader( |
| 109 "x-cup-server-proof", |
| 110 "3046022100a07aa437b24f1f6bb7ff6f6d1e004dd4bcb717c93e21d6bae5ef8d6d984c" |
| 111 "86a7022100e423419ff49fae37b421ef6cdeab348b45c63b236ab365f36f4cd3b4d4d6" |
| 112 "d852:" |
| 113 "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b85" |
| 114 "5"); |
| 115 return std::unique_ptr<net::test_server::HttpResponse>(response); |
| 116 } |
| 117 |
| 118 static std::unique_ptr<net::test_server::HttpResponse> |
| 119 BadSignatureResponseHandler(const net::test_server::HttpRequest& request) { |
| 120 net::test_server::BasicHttpResponse* response = |
| 121 new net::test_server::BasicHttpResponse(); |
| 122 response->set_code(net::HTTP_OK); |
| 123 response->set_content( |
| 124 ")]}'\n" |
| 125 "{\"current_time_millis\":1461621971825,\"server_nonce\":-6." |
| 126 "006853099049523E85}"); |
| 127 response->AddCustomHeader("x-cup-server-proof", "dead:beef"); |
| 128 return std::unique_ptr<net::test_server::HttpResponse>(response); |
| 129 } |
| 130 |
| 131 static std::unique_ptr<net::test_server::HttpResponse> |
| 132 ServerErrorResponseHandler(const net::test_server::HttpRequest& request) { |
| 133 net::test_server::BasicHttpResponse* response = |
| 134 new net::test_server::BasicHttpResponse(); |
| 135 response->set_code(net::HTTP_INTERNAL_SERVER_ERROR); |
| 136 return std::unique_ptr<net::test_server::HttpResponse>(response); |
| 137 } |
| 138 |
| 139 static std::unique_ptr<net::test_server::HttpResponse> |
| 140 NetworkErrorResponseHandler(const net::test_server::HttpRequest& request) { |
| 141 return std::unique_ptr<net::test_server::HttpResponse>( |
| 142 new net::test_server::RawHttpResponse("", "")); |
53 } | 143 } |
54 | 144 |
55 // Updates the notifier's time with the specified parameters. | 145 // Updates the notifier's time with the specified parameters. |
56 void UpdateNetworkTime(const base::Time& network_time, | 146 void UpdateNetworkTime(const base::Time& network_time, |
57 const base::TimeDelta& resolution, | 147 const base::TimeDelta& resolution, |
58 const base::TimeDelta& latency, | 148 const base::TimeDelta& latency, |
59 const base::TimeTicks& post_time) { | 149 const base::TimeTicks& post_time) { |
60 tracker_->UpdateNetworkTime( | 150 tracker_->UpdateNetworkTime( |
61 network_time, resolution, latency, post_time); | 151 network_time, resolution, latency, post_time); |
62 } | 152 } |
63 | 153 |
64 // Advances both the system clock and the tick clock. This should be used for | 154 // Advances both the system clock and the tick clock. This should be used for |
65 // the normal passage of time, i.e. when neither clock is doing anything odd. | 155 // the normal passage of time, i.e. when neither clock is doing anything odd. |
66 void AdvanceBoth(const base::TimeDelta& delta) { | 156 void AdvanceBoth(const base::TimeDelta& delta) { |
67 tick_clock_->Advance(delta); | 157 tick_clock_->Advance(delta); |
68 clock_->Advance(delta); | 158 clock_->Advance(delta); |
69 } | 159 } |
70 | 160 |
71 protected: | 161 protected: |
| 162 void SetNetworkQueriesWithFinch(bool enable) { |
| 163 base::FeatureList::ClearInstanceForTesting(); |
| 164 std::unique_ptr<base::FeatureList> feature_list(new base::FeatureList); |
| 165 if (enable) { |
| 166 feature_list->InitializeFromCommandLine("NetworkTimeServiceQuerying", ""); |
| 167 } |
| 168 base::FeatureList::SetInstance(std::move(feature_list)); |
| 169 } |
| 170 |
| 171 base::Thread io_thread_; |
| 172 base::MessageLoop message_loop_; |
72 base::TimeDelta resolution_; | 173 base::TimeDelta resolution_; |
73 base::TimeDelta latency_; | 174 base::TimeDelta latency_; |
74 base::TimeDelta adjustment_; | 175 base::TimeDelta adjustment_; |
75 base::SimpleTestClock* clock_; | 176 base::SimpleTestClock* clock_; |
76 base::SimpleTestTickClock* tick_clock_; | 177 base::SimpleTestTickClock* tick_clock_; |
77 TestingPrefServiceSimple pref_service_; | 178 TestingPrefServiceSimple pref_service_; |
78 std::unique_ptr<NetworkTimeTracker> tracker_; | 179 std::unique_ptr<NetworkTimeTracker> tracker_; |
| 180 std::unique_ptr<net::EmbeddedTestServer> test_server_; |
79 }; | 181 }; |
80 | 182 |
81 TEST_F(NetworkTimeTrackerTest, Uninitialized) { | 183 TEST_F(NetworkTimeTrackerTest, Uninitialized) { |
82 base::Time network_time; | 184 base::Time network_time; |
83 base::TimeDelta uncertainty; | 185 base::TimeDelta uncertainty; |
84 EXPECT_FALSE(tracker_->GetNetworkTime(&network_time, &uncertainty)); | 186 EXPECT_FALSE(tracker_->GetNetworkTime(&network_time, &uncertainty)); |
85 } | 187 } |
86 | 188 |
87 TEST_F(NetworkTimeTrackerTest, LongPostingDelay) { | 189 TEST_F(NetworkTimeTrackerTest, LongPostingDelay) { |
88 // The request arrives at the server, which records the time. Advance the | 190 // The request arrives at the server, which records the time. Advance the |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
124 EXPECT_GT(out_network_time + uncertainty / 2, clock_->Now()); | 226 EXPECT_GT(out_network_time + uncertainty / 2, clock_->Now()); |
125 } | 227 } |
126 | 228 |
127 TEST_F(NetworkTimeTrackerTest, ClockIsWack) { | 229 TEST_F(NetworkTimeTrackerTest, ClockIsWack) { |
128 // Now let's assume the system clock is completely wrong. | 230 // Now let's assume the system clock is completely wrong. |
129 base::Time in_network_time = clock_->Now() - base::TimeDelta::FromDays(90); | 231 base::Time in_network_time = clock_->Now() - base::TimeDelta::FromDays(90); |
130 UpdateNetworkTime(in_network_time - latency_ / 2, resolution_, latency_, | 232 UpdateNetworkTime(in_network_time - latency_ / 2, resolution_, latency_, |
131 tick_clock_->NowTicks()); | 233 tick_clock_->NowTicks()); |
132 | 234 |
133 base::Time out_network_time; | 235 base::Time out_network_time; |
134 EXPECT_TRUE(tracker_->GetNetworkTime(&out_network_time, NULL)); | 236 EXPECT_TRUE(tracker_->GetNetworkTime(&out_network_time, nullptr)); |
135 EXPECT_EQ(in_network_time, out_network_time); | 237 EXPECT_EQ(in_network_time, out_network_time); |
136 } | 238 } |
137 | 239 |
138 TEST_F(NetworkTimeTrackerTest, ClocksDivergeSlightly) { | 240 TEST_F(NetworkTimeTrackerTest, ClocksDivergeSlightly) { |
139 // The two clocks are allowed to diverge a little bit. | 241 // The two clocks are allowed to diverge a little bit. |
140 base::Time in_network_time = clock_->Now(); | 242 base::Time in_network_time = clock_->Now(); |
141 UpdateNetworkTime(in_network_time - latency_ / 2, resolution_, latency_, | 243 UpdateNetworkTime(in_network_time - latency_ / 2, resolution_, latency_, |
142 tick_clock_->NowTicks()); | 244 tick_clock_->NowTicks()); |
143 | 245 |
144 base::TimeDelta small = base::TimeDelta::FromSeconds(30); | 246 base::TimeDelta small = base::TimeDelta::FromSeconds(30); |
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
178 EXPECT_EQ(resolution_ + latency_ + adjustment_, uncertainty); | 280 EXPECT_EQ(resolution_ + latency_ + adjustment_, uncertainty); |
179 } | 281 } |
180 | 282 |
181 TEST_F(NetworkTimeTrackerTest, SpringForward) { | 283 TEST_F(NetworkTimeTrackerTest, SpringForward) { |
182 // Simulate the wall clock advancing faster than the tick clock. | 284 // Simulate the wall clock advancing faster than the tick clock. |
183 UpdateNetworkTime(clock_->Now(), resolution_, latency_, | 285 UpdateNetworkTime(clock_->Now(), resolution_, latency_, |
184 tick_clock_->NowTicks()); | 286 tick_clock_->NowTicks()); |
185 tick_clock_->Advance(base::TimeDelta::FromSeconds(1)); | 287 tick_clock_->Advance(base::TimeDelta::FromSeconds(1)); |
186 clock_->Advance(base::TimeDelta::FromDays(1)); | 288 clock_->Advance(base::TimeDelta::FromDays(1)); |
187 base::Time out_network_time; | 289 base::Time out_network_time; |
188 EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, NULL)); | 290 EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, nullptr)); |
189 } | 291 } |
190 | 292 |
191 TEST_F(NetworkTimeTrackerTest, FallBack) { | 293 TEST_F(NetworkTimeTrackerTest, FallBack) { |
192 // Simulate the wall clock running backward. | 294 // Simulate the wall clock running backward. |
193 UpdateNetworkTime(clock_->Now(), resolution_, latency_, | 295 UpdateNetworkTime(clock_->Now(), resolution_, latency_, |
194 tick_clock_->NowTicks()); | 296 tick_clock_->NowTicks()); |
195 tick_clock_->Advance(base::TimeDelta::FromSeconds(1)); | 297 tick_clock_->Advance(base::TimeDelta::FromSeconds(1)); |
196 clock_->Advance(base::TimeDelta::FromDays(-1)); | 298 clock_->Advance(base::TimeDelta::FromDays(-1)); |
197 base::Time out_network_time; | 299 base::Time out_network_time; |
198 EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, NULL)); | 300 EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, nullptr)); |
199 } | 301 } |
200 | 302 |
201 TEST_F(NetworkTimeTrackerTest, SuspendAndResume) { | 303 TEST_F(NetworkTimeTrackerTest, SuspendAndResume) { |
202 // Simulate the wall clock advancing while the tick clock stands still, as | 304 // Simulate the wall clock advancing while the tick clock stands still, as |
203 // would happen in a suspend+resume cycle. | 305 // would happen in a suspend+resume cycle. |
204 UpdateNetworkTime(clock_->Now(), resolution_, latency_, | 306 UpdateNetworkTime(clock_->Now(), resolution_, latency_, |
205 tick_clock_->NowTicks()); | 307 tick_clock_->NowTicks()); |
206 clock_->Advance(base::TimeDelta::FromHours(1)); | 308 clock_->Advance(base::TimeDelta::FromHours(1)); |
207 base::Time out_network_time; | 309 base::Time out_network_time; |
208 EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, NULL)); | 310 EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, nullptr)); |
209 } | 311 } |
210 | 312 |
211 TEST_F(NetworkTimeTrackerTest, Serialize) { | 313 TEST_F(NetworkTimeTrackerTest, Serialize) { |
212 // Test that we can serialize and deserialize state and get consistent | 314 // Test that we can serialize and deserialize state and get consistent |
213 // results. | 315 // results. |
214 base::Time in_network_time = clock_->Now() - base::TimeDelta::FromDays(90); | 316 base::Time in_network_time = clock_->Now() - base::TimeDelta::FromDays(90); |
215 UpdateNetworkTime(in_network_time - latency_ / 2, resolution_, latency_, | 317 UpdateNetworkTime(in_network_time - latency_ / 2, resolution_, latency_, |
216 tick_clock_->NowTicks()); | 318 tick_clock_->NowTicks()); |
217 base::Time out_network_time; | 319 base::Time out_network_time; |
218 base::TimeDelta out_uncertainty; | 320 base::TimeDelta out_uncertainty; |
(...skipping 11 matching lines...) Expand all Loading... |
230 } | 332 } |
231 | 333 |
232 TEST_F(NetworkTimeTrackerTest, DeserializeOldFormat) { | 334 TEST_F(NetworkTimeTrackerTest, DeserializeOldFormat) { |
233 // Test that deserializing old data (which do not record the uncertainty and | 335 // Test that deserializing old data (which do not record the uncertainty and |
234 // tick clock) causes the serialized data to be ignored. | 336 // tick clock) causes the serialized data to be ignored. |
235 base::Time in_network_time = clock_->Now() - base::TimeDelta::FromDays(90); | 337 base::Time in_network_time = clock_->Now() - base::TimeDelta::FromDays(90); |
236 UpdateNetworkTime(in_network_time - latency_ / 2, resolution_, latency_, | 338 UpdateNetworkTime(in_network_time - latency_ / 2, resolution_, latency_, |
237 tick_clock_->NowTicks()); | 339 tick_clock_->NowTicks()); |
238 | 340 |
239 base::Time out_network_time; | 341 base::Time out_network_time; |
240 EXPECT_TRUE(tracker_->GetNetworkTime(&out_network_time, NULL)); | 342 EXPECT_TRUE(tracker_->GetNetworkTime(&out_network_time, nullptr)); |
241 double local, network; | 343 double local, network; |
242 const base::DictionaryValue* saved_prefs = | 344 const base::DictionaryValue* saved_prefs = |
243 pref_service_.GetDictionary(prefs::kNetworkTimeMapping); | 345 pref_service_.GetDictionary(prefs::kNetworkTimeMapping); |
244 saved_prefs->GetDouble("local", &local); | 346 saved_prefs->GetDouble("local", &local); |
245 saved_prefs->GetDouble("network", &network); | 347 saved_prefs->GetDouble("network", &network); |
246 base::DictionaryValue prefs; | 348 base::DictionaryValue prefs; |
247 prefs.SetDouble("local", local); | 349 prefs.SetDouble("local", local); |
248 prefs.SetDouble("network", network); | 350 prefs.SetDouble("network", network); |
249 pref_service_.Set(prefs::kNetworkTimeMapping, prefs); | 351 pref_service_.Set(prefs::kNetworkTimeMapping, prefs); |
250 Reset(); | 352 Reset(); |
251 EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, NULL)); | 353 EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, nullptr)); |
252 } | 354 } |
253 | 355 |
254 TEST_F(NetworkTimeTrackerTest, SerializeWithLongDelay) { | 356 TEST_F(NetworkTimeTrackerTest, SerializeWithLongDelay) { |
255 // Test that if the serialized data are more than a week old, they are | 357 // Test that if the serialized data are more than a week old, they are |
256 // discarded. | 358 // discarded. |
257 base::Time in_network_time = clock_->Now() - base::TimeDelta::FromDays(90); | 359 base::Time in_network_time = clock_->Now() - base::TimeDelta::FromDays(90); |
258 UpdateNetworkTime(in_network_time - latency_ / 2, resolution_, latency_, | 360 UpdateNetworkTime(in_network_time - latency_ / 2, resolution_, latency_, |
259 tick_clock_->NowTicks()); | 361 tick_clock_->NowTicks()); |
260 base::Time out_network_time; | 362 base::Time out_network_time; |
261 EXPECT_TRUE(tracker_->GetNetworkTime(&out_network_time, NULL)); | 363 EXPECT_TRUE(tracker_->GetNetworkTime(&out_network_time, nullptr)); |
262 AdvanceBoth(base::TimeDelta::FromDays(8)); | 364 AdvanceBoth(base::TimeDelta::FromDays(8)); |
263 Reset(); | 365 Reset(); |
264 EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, NULL)); | 366 EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, nullptr)); |
265 } | 367 } |
266 | 368 |
267 TEST_F(NetworkTimeTrackerTest, SerializeWithTickClockAdvance) { | 369 TEST_F(NetworkTimeTrackerTest, SerializeWithTickClockAdvance) { |
268 // Test that serialized data are discarded if the wall clock and tick clock | 370 // Test that serialized data are discarded if the wall clock and tick clock |
269 // have not advanced consistently since data were serialized. | 371 // have not advanced consistently since data were serialized. |
270 base::Time in_network_time = clock_->Now() - base::TimeDelta::FromDays(90); | 372 base::Time in_network_time = clock_->Now() - base::TimeDelta::FromDays(90); |
271 UpdateNetworkTime(in_network_time - latency_ / 2, resolution_, latency_, | 373 UpdateNetworkTime(in_network_time - latency_ / 2, resolution_, latency_, |
272 tick_clock_->NowTicks()); | 374 tick_clock_->NowTicks()); |
273 base::Time out_network_time; | 375 base::Time out_network_time; |
274 EXPECT_TRUE(tracker_->GetNetworkTime(&out_network_time, NULL)); | 376 EXPECT_TRUE(tracker_->GetNetworkTime(&out_network_time, nullptr)); |
275 tick_clock_->Advance(base::TimeDelta::FromDays(1)); | 377 tick_clock_->Advance(base::TimeDelta::FromDays(1)); |
276 Reset(); | 378 Reset(); |
277 EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, NULL)); | 379 EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, nullptr)); |
278 } | 380 } |
279 | 381 |
280 TEST_F(NetworkTimeTrackerTest, SerializeWithWallClockAdvance) { | 382 TEST_F(NetworkTimeTrackerTest, SerializeWithWallClockAdvance) { |
281 // Test that serialized data are discarded if the wall clock and tick clock | 383 // Test that serialized data are discarded if the wall clock and tick clock |
282 // have not advanced consistently since data were serialized. | 384 // have not advanced consistently since data were serialized. |
283 base::Time in_network_time = clock_->Now() - base::TimeDelta::FromDays(90); | 385 base::Time in_network_time = clock_->Now() - base::TimeDelta::FromDays(90); |
284 UpdateNetworkTime(in_network_time - latency_ / 2, resolution_, latency_, | 386 UpdateNetworkTime(in_network_time - latency_ / 2, resolution_, latency_, |
285 tick_clock_->NowTicks()); | 387 tick_clock_->NowTicks()); |
286 | 388 |
287 base::Time out_network_time; | 389 base::Time out_network_time; |
288 EXPECT_TRUE(tracker_->GetNetworkTime(&out_network_time, NULL)); | 390 EXPECT_TRUE(tracker_->GetNetworkTime(&out_network_time, nullptr)); |
289 clock_->Advance(base::TimeDelta::FromDays(1)); | 391 clock_->Advance(base::TimeDelta::FromDays(1)); |
290 Reset(); | 392 Reset(); |
291 EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, NULL)); | 393 EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, nullptr)); |
| 394 } |
| 395 |
| 396 TEST_F(NetworkTimeTrackerTest, UpdateFromNetwork) { |
| 397 base::Time out_network_time; |
| 398 EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, nullptr)); |
| 399 |
| 400 test_server_->RegisterRequestHandler( |
| 401 base::Bind(&NetworkTimeTrackerTest::GoodTimeResponseHandler)); |
| 402 EXPECT_TRUE(test_server_->Start()); |
| 403 tracker_->SetTimeServerURLForTesting(test_server_->GetURL("/")); |
| 404 EXPECT_TRUE(tracker_->QueryTimeServiceForTesting()); |
| 405 tracker_->WaitForFetchForTesting(123123123); |
| 406 |
| 407 EXPECT_TRUE(tracker_->GetNetworkTime(&out_network_time, nullptr)); |
| 408 EXPECT_EQ(base::Time::UnixEpoch() + |
| 409 base::TimeDelta::FromMilliseconds(1461621971825), |
| 410 out_network_time); |
| 411 // Should see no backoff in the success case. |
| 412 EXPECT_EQ(base::TimeDelta::FromMinutes(60), |
| 413 tracker_->GetTimerDelayForTesting()); |
| 414 } |
| 415 |
| 416 TEST_F(NetworkTimeTrackerTest, NoNetworkQueryWhileSynced) { |
| 417 base::Time in_network_time = clock_->Now(); |
| 418 UpdateNetworkTime(in_network_time, resolution_, latency_, |
| 419 tick_clock_->NowTicks()); |
| 420 EXPECT_FALSE( |
| 421 tracker_->QueryTimeServiceForTesting()); // No query should be started. |
| 422 } |
| 423 |
| 424 TEST_F(NetworkTimeTrackerTest, NoNetworkQueryWhileFeatureDisabled) { |
| 425 // Disable network time queries and check that a query is not sent. |
| 426 SetNetworkQueriesWithFinch(false); |
| 427 EXPECT_FALSE(tracker_->QueryTimeServiceForTesting()); |
| 428 |
| 429 // Enable time queries and check that a query is sent. |
| 430 SetNetworkQueriesWithFinch(true); |
| 431 EXPECT_TRUE(tracker_->QueryTimeServiceForTesting()); |
| 432 tracker_->WaitForFetchForTesting(123123123); |
| 433 } |
| 434 |
| 435 TEST_F(NetworkTimeTrackerTest, UpdateFromNetworkBadSignature) { |
| 436 test_server_->RegisterRequestHandler( |
| 437 base::Bind(&NetworkTimeTrackerTest::BadSignatureResponseHandler)); |
| 438 EXPECT_TRUE(test_server_->Start()); |
| 439 tracker_->SetTimeServerURLForTesting(test_server_->GetURL("/")); |
| 440 EXPECT_TRUE(tracker_->QueryTimeServiceForTesting()); |
| 441 tracker_->WaitForFetchForTesting(123123123); |
| 442 |
| 443 base::Time out_network_time; |
| 444 EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, nullptr)); |
| 445 EXPECT_EQ(base::TimeDelta::FromMinutes(120), |
| 446 tracker_->GetTimerDelayForTesting()); |
| 447 } |
| 448 |
| 449 static const uint8_t kDevKeyPubBytes[] = { |
| 450 0x30, 0x59, 0x30, 0x13, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02, |
| 451 0x01, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07, 0x03, |
| 452 0x42, 0x00, 0x04, 0xe0, 0x6b, 0x0d, 0x76, 0x75, 0xa3, 0x99, 0x7d, 0x7c, |
| 453 0x1b, 0xd6, 0x3c, 0x73, 0xbb, 0x4b, 0xfe, 0x0a, 0xe7, 0x2f, 0x61, 0x3d, |
| 454 0x77, 0x0a, 0xaa, 0x14, 0xd8, 0x5a, 0xbf, 0x14, 0x60, 0xec, 0xf6, 0x32, |
| 455 0x77, 0xb5, 0xa7, 0xe6, 0x35, 0xa5, 0x61, 0xaf, 0xdc, 0xdf, 0x91, 0xce, |
| 456 0x45, 0x34, 0x5f, 0x36, 0x85, 0x2f, 0xb9, 0x53, 0x00, 0x5d, 0x86, 0xe7, |
| 457 0x04, 0x16, 0xe2, 0x3d, 0x21, 0x76, 0x2b}; |
| 458 |
| 459 TEST_F(NetworkTimeTrackerTest, UpdateFromNetworkBadData) { |
| 460 test_server_->RegisterRequestHandler( |
| 461 base::Bind(&NetworkTimeTrackerTest::BadDataResponseHandler)); |
| 462 EXPECT_TRUE(test_server_->Start()); |
| 463 base::StringPiece key = {reinterpret_cast<const char*>(kDevKeyPubBytes), |
| 464 sizeof(kDevKeyPubBytes)}; |
| 465 tracker_->SetPublicKeyForTesting(key); |
| 466 tracker_->SetTimeServerURLForTesting(test_server_->GetURL("/")); |
| 467 EXPECT_TRUE(tracker_->QueryTimeServiceForTesting()); |
| 468 tracker_->WaitForFetchForTesting(123123123); |
| 469 base::Time out_network_time; |
| 470 EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, nullptr)); |
| 471 EXPECT_EQ(base::TimeDelta::FromMinutes(120), |
| 472 tracker_->GetTimerDelayForTesting()); |
| 473 } |
| 474 |
| 475 TEST_F(NetworkTimeTrackerTest, UpdateFromNetworkServerError) { |
| 476 test_server_->RegisterRequestHandler( |
| 477 base::Bind(&NetworkTimeTrackerTest::ServerErrorResponseHandler)); |
| 478 EXPECT_TRUE(test_server_->Start()); |
| 479 tracker_->SetTimeServerURLForTesting(test_server_->GetURL("/")); |
| 480 EXPECT_TRUE(tracker_->QueryTimeServiceForTesting()); |
| 481 tracker_->WaitForFetchForTesting(123123123); |
| 482 |
| 483 base::Time out_network_time; |
| 484 EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, nullptr)); |
| 485 // Should see backoff in the error case. |
| 486 EXPECT_EQ(base::TimeDelta::FromMinutes(120), |
| 487 tracker_->GetTimerDelayForTesting()); |
| 488 } |
| 489 |
| 490 TEST_F(NetworkTimeTrackerTest, UpdateFromNetworNetworkError) { |
| 491 test_server_->RegisterRequestHandler( |
| 492 base::Bind(&NetworkTimeTrackerTest::NetworkErrorResponseHandler)); |
| 493 EXPECT_TRUE(test_server_->Start()); |
| 494 tracker_->SetTimeServerURLForTesting(test_server_->GetURL("/")); |
| 495 EXPECT_TRUE(tracker_->QueryTimeServiceForTesting()); |
| 496 tracker_->WaitForFetchForTesting(123123123); |
| 497 |
| 498 base::Time out_network_time; |
| 499 EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, nullptr)); |
| 500 // Should see backoff in the error case. |
| 501 EXPECT_EQ(base::TimeDelta::FromMinutes(120), |
| 502 tracker_->GetTimerDelayForTesting()); |
| 503 } |
| 504 |
| 505 TEST_F(NetworkTimeTrackerTest, UpdateFromNetworkLargeResponse) { |
| 506 test_server_->RegisterRequestHandler( |
| 507 base::Bind(&NetworkTimeTrackerTest::GoodTimeResponseHandler)); |
| 508 EXPECT_TRUE(test_server_->Start()); |
| 509 tracker_->SetTimeServerURLForTesting(test_server_->GetURL("/")); |
| 510 |
| 511 base::Time out_network_time; |
| 512 |
| 513 tracker_->SetMaxResponseSizeForTesting(3); |
| 514 EXPECT_TRUE(tracker_->QueryTimeServiceForTesting()); |
| 515 tracker_->WaitForFetchForTesting(123123123); |
| 516 EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, nullptr)); |
| 517 |
| 518 tracker_->SetMaxResponseSizeForTesting(1024); |
| 519 EXPECT_TRUE(tracker_->QueryTimeServiceForTesting()); |
| 520 tracker_->WaitForFetchForTesting(123123123); |
| 521 EXPECT_TRUE(tracker_->GetNetworkTime(&out_network_time, nullptr)); |
292 } | 522 } |
293 | 523 |
294 } // namespace network_time | 524 } // namespace network_time |
OLD | NEW |