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> | |
9 | 8 |
10 #include "base/compiler_specific.h" | 9 #include "base/compiler_specific.h" |
11 #include "base/feature_list.h" | |
12 #include "base/strings/stringprintf.h" | |
13 #include "base/test/simple_test_clock.h" | 10 #include "base/test/simple_test_clock.h" |
14 #include "base/test/simple_test_tick_clock.h" | 11 #include "base/test/simple_test_tick_clock.h" |
15 #include "components/client_update_protocol/ecdsa.h" | |
16 #include "components/network_time/network_time_pref_names.h" | 12 #include "components/network_time/network_time_pref_names.h" |
17 #include "components/prefs/testing_pref_service.h" | 13 #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" | |
23 #include "testing/gtest/include/gtest/gtest.h" | 14 #include "testing/gtest/include/gtest/gtest.h" |
24 | 15 |
25 namespace network_time { | 16 namespace network_time { |
26 | 17 |
27 class NetworkTimeTrackerTest : public testing::Test { | 18 class NetworkTimeTrackerTest : public testing::Test { |
28 public: | 19 public: |
29 ~NetworkTimeTrackerTest() override {} | 20 ~NetworkTimeTrackerTest() override {} |
30 | 21 |
31 NetworkTimeTrackerTest() | 22 void SetUp() override { |
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)); | |
39 NetworkTimeTracker::RegisterPrefs(pref_service_.registry()); | 23 NetworkTimeTracker::RegisterPrefs(pref_service_.registry()); |
40 | 24 |
| 25 clock_ = new base::SimpleTestClock(); |
| 26 tick_clock_ = new base::SimpleTestTickClock(); |
| 27 // Do this to be sure that |is_null| returns false. |
| 28 clock_->Advance(base::TimeDelta::FromDays(111)); |
| 29 tick_clock_->Advance(base::TimeDelta::FromDays(222)); |
| 30 |
41 tracker_.reset(new NetworkTimeTracker( | 31 tracker_.reset(new NetworkTimeTracker( |
42 std::unique_ptr<base::Clock>(clock_), | 32 std::unique_ptr<base::Clock>(clock_), |
43 std::unique_ptr<base::TickClock>(tick_clock_), &pref_service_, | 33 std::unique_ptr<base::TickClock>(tick_clock_), &pref_service_)); |
44 new net::TestURLRequestContextGetter(io_thread_.task_runner()))); | |
45 | |
46 // Do this to be sure that |is_null| returns false. | |
47 clock_->Advance(base::TimeDelta::FromDays(111)); | |
48 tick_clock_->Advance(base::TimeDelta::FromDays(222)); | |
49 | 34 |
50 // Can not be smaller than 15, it's the NowFromSystemTime() resolution. | 35 // Can not be smaller than 15, it's the NowFromSystemTime() resolution. |
51 resolution_ = base::TimeDelta::FromMilliseconds(17); | 36 resolution_ = base::TimeDelta::FromMilliseconds(17); |
52 latency_ = base::TimeDelta::FromMilliseconds(50); | 37 latency_ = base::TimeDelta::FromMilliseconds(50); |
53 adjustment_ = 7 * base::TimeDelta::FromMilliseconds(kTicksResolutionMs); | 38 adjustment_ = 7 * base::TimeDelta::FromMilliseconds(kTicksResolutionMs); |
54 | |
55 SetNetworkQueriesWithFinch(true); | |
56 } | 39 } |
57 | 40 |
58 void TearDown() override { io_thread_.Stop(); } | |
59 | |
60 // Replaces |tracker_| with a new object, while preserving the | 41 // Replaces |tracker_| with a new object, while preserving the |
61 // testing clocks. | 42 // testing clocks. |
62 void Reset() { | 43 void Reset() { |
63 base::SimpleTestClock* new_clock = new base::SimpleTestClock(); | 44 base::SimpleTestClock* new_clock = new base::SimpleTestClock(); |
64 new_clock->SetNow(clock_->Now()); | 45 new_clock->SetNow(clock_->Now()); |
65 base::SimpleTestTickClock* new_tick_clock = new base::SimpleTestTickClock(); | 46 base::SimpleTestTickClock* new_tick_clock = new base::SimpleTestTickClock(); |
66 new_tick_clock->SetNowTicks(tick_clock_->NowTicks()); | 47 new_tick_clock->SetNowTicks(tick_clock_->NowTicks()); |
67 clock_ = new_clock; | 48 clock_ = new_clock; |
68 tick_clock_= new_tick_clock; | 49 tick_clock_= new_tick_clock; |
69 tracker_.reset(new NetworkTimeTracker( | 50 tracker_.reset(new NetworkTimeTracker( |
70 std::unique_ptr<base::Clock>(clock_), | 51 std::unique_ptr<base::Clock>(clock_), |
71 std::unique_ptr<base::TickClock>(tick_clock_), &pref_service_, | 52 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("", "")); | |
143 } | 53 } |
144 | 54 |
145 // Updates the notifier's time with the specified parameters. | 55 // Updates the notifier's time with the specified parameters. |
146 void UpdateNetworkTime(const base::Time& network_time, | 56 void UpdateNetworkTime(const base::Time& network_time, |
147 const base::TimeDelta& resolution, | 57 const base::TimeDelta& resolution, |
148 const base::TimeDelta& latency, | 58 const base::TimeDelta& latency, |
149 const base::TimeTicks& post_time) { | 59 const base::TimeTicks& post_time) { |
150 tracker_->UpdateNetworkTime( | 60 tracker_->UpdateNetworkTime( |
151 network_time, resolution, latency, post_time); | 61 network_time, resolution, latency, post_time); |
152 } | 62 } |
153 | 63 |
154 // Advances both the system clock and the tick clock. This should be used for | 64 // Advances both the system clock and the tick clock. This should be used for |
155 // the normal passage of time, i.e. when neither clock is doing anything odd. | 65 // the normal passage of time, i.e. when neither clock is doing anything odd. |
156 void AdvanceBoth(const base::TimeDelta& delta) { | 66 void AdvanceBoth(const base::TimeDelta& delta) { |
157 tick_clock_->Advance(delta); | 67 tick_clock_->Advance(delta); |
158 clock_->Advance(delta); | 68 clock_->Advance(delta); |
159 } | 69 } |
160 | 70 |
161 protected: | 71 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_; | |
173 base::TimeDelta resolution_; | 72 base::TimeDelta resolution_; |
174 base::TimeDelta latency_; | 73 base::TimeDelta latency_; |
175 base::TimeDelta adjustment_; | 74 base::TimeDelta adjustment_; |
176 base::SimpleTestClock* clock_; | 75 base::SimpleTestClock* clock_; |
177 base::SimpleTestTickClock* tick_clock_; | 76 base::SimpleTestTickClock* tick_clock_; |
178 TestingPrefServiceSimple pref_service_; | 77 TestingPrefServiceSimple pref_service_; |
179 std::unique_ptr<NetworkTimeTracker> tracker_; | 78 std::unique_ptr<NetworkTimeTracker> tracker_; |
180 std::unique_ptr<net::EmbeddedTestServer> test_server_; | |
181 }; | 79 }; |
182 | 80 |
183 TEST_F(NetworkTimeTrackerTest, Uninitialized) { | 81 TEST_F(NetworkTimeTrackerTest, Uninitialized) { |
184 base::Time network_time; | 82 base::Time network_time; |
185 base::TimeDelta uncertainty; | 83 base::TimeDelta uncertainty; |
186 EXPECT_FALSE(tracker_->GetNetworkTime(&network_time, &uncertainty)); | 84 EXPECT_FALSE(tracker_->GetNetworkTime(&network_time, &uncertainty)); |
187 } | 85 } |
188 | 86 |
189 TEST_F(NetworkTimeTrackerTest, LongPostingDelay) { | 87 TEST_F(NetworkTimeTrackerTest, LongPostingDelay) { |
190 // The request arrives at the server, which records the time. Advance the | 88 // 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... |
226 EXPECT_GT(out_network_time + uncertainty / 2, clock_->Now()); | 124 EXPECT_GT(out_network_time + uncertainty / 2, clock_->Now()); |
227 } | 125 } |
228 | 126 |
229 TEST_F(NetworkTimeTrackerTest, ClockIsWack) { | 127 TEST_F(NetworkTimeTrackerTest, ClockIsWack) { |
230 // Now let's assume the system clock is completely wrong. | 128 // Now let's assume the system clock is completely wrong. |
231 base::Time in_network_time = clock_->Now() - base::TimeDelta::FromDays(90); | 129 base::Time in_network_time = clock_->Now() - base::TimeDelta::FromDays(90); |
232 UpdateNetworkTime(in_network_time - latency_ / 2, resolution_, latency_, | 130 UpdateNetworkTime(in_network_time - latency_ / 2, resolution_, latency_, |
233 tick_clock_->NowTicks()); | 131 tick_clock_->NowTicks()); |
234 | 132 |
235 base::Time out_network_time; | 133 base::Time out_network_time; |
236 EXPECT_TRUE(tracker_->GetNetworkTime(&out_network_time, nullptr)); | 134 EXPECT_TRUE(tracker_->GetNetworkTime(&out_network_time, NULL)); |
237 EXPECT_EQ(in_network_time, out_network_time); | 135 EXPECT_EQ(in_network_time, out_network_time); |
238 } | 136 } |
239 | 137 |
240 TEST_F(NetworkTimeTrackerTest, ClocksDivergeSlightly) { | 138 TEST_F(NetworkTimeTrackerTest, ClocksDivergeSlightly) { |
241 // The two clocks are allowed to diverge a little bit. | 139 // The two clocks are allowed to diverge a little bit. |
242 base::Time in_network_time = clock_->Now(); | 140 base::Time in_network_time = clock_->Now(); |
243 UpdateNetworkTime(in_network_time - latency_ / 2, resolution_, latency_, | 141 UpdateNetworkTime(in_network_time - latency_ / 2, resolution_, latency_, |
244 tick_clock_->NowTicks()); | 142 tick_clock_->NowTicks()); |
245 | 143 |
246 base::TimeDelta small = base::TimeDelta::FromSeconds(30); | 144 base::TimeDelta small = base::TimeDelta::FromSeconds(30); |
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
280 EXPECT_EQ(resolution_ + latency_ + adjustment_, uncertainty); | 178 EXPECT_EQ(resolution_ + latency_ + adjustment_, uncertainty); |
281 } | 179 } |
282 | 180 |
283 TEST_F(NetworkTimeTrackerTest, SpringForward) { | 181 TEST_F(NetworkTimeTrackerTest, SpringForward) { |
284 // Simulate the wall clock advancing faster than the tick clock. | 182 // Simulate the wall clock advancing faster than the tick clock. |
285 UpdateNetworkTime(clock_->Now(), resolution_, latency_, | 183 UpdateNetworkTime(clock_->Now(), resolution_, latency_, |
286 tick_clock_->NowTicks()); | 184 tick_clock_->NowTicks()); |
287 tick_clock_->Advance(base::TimeDelta::FromSeconds(1)); | 185 tick_clock_->Advance(base::TimeDelta::FromSeconds(1)); |
288 clock_->Advance(base::TimeDelta::FromDays(1)); | 186 clock_->Advance(base::TimeDelta::FromDays(1)); |
289 base::Time out_network_time; | 187 base::Time out_network_time; |
290 EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, nullptr)); | 188 EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, NULL)); |
291 } | 189 } |
292 | 190 |
293 TEST_F(NetworkTimeTrackerTest, FallBack) { | 191 TEST_F(NetworkTimeTrackerTest, FallBack) { |
294 // Simulate the wall clock running backward. | 192 // Simulate the wall clock running backward. |
295 UpdateNetworkTime(clock_->Now(), resolution_, latency_, | 193 UpdateNetworkTime(clock_->Now(), resolution_, latency_, |
296 tick_clock_->NowTicks()); | 194 tick_clock_->NowTicks()); |
297 tick_clock_->Advance(base::TimeDelta::FromSeconds(1)); | 195 tick_clock_->Advance(base::TimeDelta::FromSeconds(1)); |
298 clock_->Advance(base::TimeDelta::FromDays(-1)); | 196 clock_->Advance(base::TimeDelta::FromDays(-1)); |
299 base::Time out_network_time; | 197 base::Time out_network_time; |
300 EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, nullptr)); | 198 EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, NULL)); |
301 } | 199 } |
302 | 200 |
303 TEST_F(NetworkTimeTrackerTest, SuspendAndResume) { | 201 TEST_F(NetworkTimeTrackerTest, SuspendAndResume) { |
304 // Simulate the wall clock advancing while the tick clock stands still, as | 202 // Simulate the wall clock advancing while the tick clock stands still, as |
305 // would happen in a suspend+resume cycle. | 203 // would happen in a suspend+resume cycle. |
306 UpdateNetworkTime(clock_->Now(), resolution_, latency_, | 204 UpdateNetworkTime(clock_->Now(), resolution_, latency_, |
307 tick_clock_->NowTicks()); | 205 tick_clock_->NowTicks()); |
308 clock_->Advance(base::TimeDelta::FromHours(1)); | 206 clock_->Advance(base::TimeDelta::FromHours(1)); |
309 base::Time out_network_time; | 207 base::Time out_network_time; |
310 EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, nullptr)); | 208 EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, NULL)); |
311 } | 209 } |
312 | 210 |
313 TEST_F(NetworkTimeTrackerTest, Serialize) { | 211 TEST_F(NetworkTimeTrackerTest, Serialize) { |
314 // Test that we can serialize and deserialize state and get consistent | 212 // Test that we can serialize and deserialize state and get consistent |
315 // results. | 213 // results. |
316 base::Time in_network_time = clock_->Now() - base::TimeDelta::FromDays(90); | 214 base::Time in_network_time = clock_->Now() - base::TimeDelta::FromDays(90); |
317 UpdateNetworkTime(in_network_time - latency_ / 2, resolution_, latency_, | 215 UpdateNetworkTime(in_network_time - latency_ / 2, resolution_, latency_, |
318 tick_clock_->NowTicks()); | 216 tick_clock_->NowTicks()); |
319 base::Time out_network_time; | 217 base::Time out_network_time; |
320 base::TimeDelta out_uncertainty; | 218 base::TimeDelta out_uncertainty; |
(...skipping 11 matching lines...) Expand all Loading... |
332 } | 230 } |
333 | 231 |
334 TEST_F(NetworkTimeTrackerTest, DeserializeOldFormat) { | 232 TEST_F(NetworkTimeTrackerTest, DeserializeOldFormat) { |
335 // Test that deserializing old data (which do not record the uncertainty and | 233 // Test that deserializing old data (which do not record the uncertainty and |
336 // tick clock) causes the serialized data to be ignored. | 234 // tick clock) causes the serialized data to be ignored. |
337 base::Time in_network_time = clock_->Now() - base::TimeDelta::FromDays(90); | 235 base::Time in_network_time = clock_->Now() - base::TimeDelta::FromDays(90); |
338 UpdateNetworkTime(in_network_time - latency_ / 2, resolution_, latency_, | 236 UpdateNetworkTime(in_network_time - latency_ / 2, resolution_, latency_, |
339 tick_clock_->NowTicks()); | 237 tick_clock_->NowTicks()); |
340 | 238 |
341 base::Time out_network_time; | 239 base::Time out_network_time; |
342 EXPECT_TRUE(tracker_->GetNetworkTime(&out_network_time, nullptr)); | 240 EXPECT_TRUE(tracker_->GetNetworkTime(&out_network_time, NULL)); |
343 double local, network; | 241 double local, network; |
344 const base::DictionaryValue* saved_prefs = | 242 const base::DictionaryValue* saved_prefs = |
345 pref_service_.GetDictionary(prefs::kNetworkTimeMapping); | 243 pref_service_.GetDictionary(prefs::kNetworkTimeMapping); |
346 saved_prefs->GetDouble("local", &local); | 244 saved_prefs->GetDouble("local", &local); |
347 saved_prefs->GetDouble("network", &network); | 245 saved_prefs->GetDouble("network", &network); |
348 base::DictionaryValue prefs; | 246 base::DictionaryValue prefs; |
349 prefs.SetDouble("local", local); | 247 prefs.SetDouble("local", local); |
350 prefs.SetDouble("network", network); | 248 prefs.SetDouble("network", network); |
351 pref_service_.Set(prefs::kNetworkTimeMapping, prefs); | 249 pref_service_.Set(prefs::kNetworkTimeMapping, prefs); |
352 Reset(); | 250 Reset(); |
353 EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, nullptr)); | 251 EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, NULL)); |
354 } | 252 } |
355 | 253 |
356 TEST_F(NetworkTimeTrackerTest, SerializeWithLongDelay) { | 254 TEST_F(NetworkTimeTrackerTest, SerializeWithLongDelay) { |
357 // Test that if the serialized data are more than a week old, they are | 255 // Test that if the serialized data are more than a week old, they are |
358 // discarded. | 256 // discarded. |
359 base::Time in_network_time = clock_->Now() - base::TimeDelta::FromDays(90); | 257 base::Time in_network_time = clock_->Now() - base::TimeDelta::FromDays(90); |
360 UpdateNetworkTime(in_network_time - latency_ / 2, resolution_, latency_, | 258 UpdateNetworkTime(in_network_time - latency_ / 2, resolution_, latency_, |
361 tick_clock_->NowTicks()); | 259 tick_clock_->NowTicks()); |
362 base::Time out_network_time; | 260 base::Time out_network_time; |
363 EXPECT_TRUE(tracker_->GetNetworkTime(&out_network_time, nullptr)); | 261 EXPECT_TRUE(tracker_->GetNetworkTime(&out_network_time, NULL)); |
364 AdvanceBoth(base::TimeDelta::FromDays(8)); | 262 AdvanceBoth(base::TimeDelta::FromDays(8)); |
365 Reset(); | 263 Reset(); |
366 EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, nullptr)); | 264 EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, NULL)); |
367 } | 265 } |
368 | 266 |
369 TEST_F(NetworkTimeTrackerTest, SerializeWithTickClockAdvance) { | 267 TEST_F(NetworkTimeTrackerTest, SerializeWithTickClockAdvance) { |
370 // Test that serialized data are discarded if the wall clock and tick clock | 268 // Test that serialized data are discarded if the wall clock and tick clock |
371 // have not advanced consistently since data were serialized. | 269 // have not advanced consistently since data were serialized. |
372 base::Time in_network_time = clock_->Now() - base::TimeDelta::FromDays(90); | 270 base::Time in_network_time = clock_->Now() - base::TimeDelta::FromDays(90); |
373 UpdateNetworkTime(in_network_time - latency_ / 2, resolution_, latency_, | 271 UpdateNetworkTime(in_network_time - latency_ / 2, resolution_, latency_, |
374 tick_clock_->NowTicks()); | 272 tick_clock_->NowTicks()); |
375 base::Time out_network_time; | 273 base::Time out_network_time; |
376 EXPECT_TRUE(tracker_->GetNetworkTime(&out_network_time, nullptr)); | 274 EXPECT_TRUE(tracker_->GetNetworkTime(&out_network_time, NULL)); |
377 tick_clock_->Advance(base::TimeDelta::FromDays(1)); | 275 tick_clock_->Advance(base::TimeDelta::FromDays(1)); |
378 Reset(); | 276 Reset(); |
379 EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, nullptr)); | 277 EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, NULL)); |
380 } | 278 } |
381 | 279 |
382 TEST_F(NetworkTimeTrackerTest, SerializeWithWallClockAdvance) { | 280 TEST_F(NetworkTimeTrackerTest, SerializeWithWallClockAdvance) { |
383 // Test that serialized data are discarded if the wall clock and tick clock | 281 // Test that serialized data are discarded if the wall clock and tick clock |
384 // have not advanced consistently since data were serialized. | 282 // have not advanced consistently since data were serialized. |
385 base::Time in_network_time = clock_->Now() - base::TimeDelta::FromDays(90); | 283 base::Time in_network_time = clock_->Now() - base::TimeDelta::FromDays(90); |
386 UpdateNetworkTime(in_network_time - latency_ / 2, resolution_, latency_, | 284 UpdateNetworkTime(in_network_time - latency_ / 2, resolution_, latency_, |
387 tick_clock_->NowTicks()); | 285 tick_clock_->NowTicks()); |
388 | 286 |
389 base::Time out_network_time; | 287 base::Time out_network_time; |
390 EXPECT_TRUE(tracker_->GetNetworkTime(&out_network_time, nullptr)); | 288 EXPECT_TRUE(tracker_->GetNetworkTime(&out_network_time, NULL)); |
391 clock_->Advance(base::TimeDelta::FromDays(1)); | 289 clock_->Advance(base::TimeDelta::FromDays(1)); |
392 Reset(); | 290 Reset(); |
393 EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, nullptr)); | 291 EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, NULL)); |
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)); | |
522 } | 292 } |
523 | 293 |
524 } // namespace network_time | 294 } // namespace network_time |
OLD | NEW |