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