OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 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 "sync/notifier/ack_tracker.h" | 5 #include "sync/notifier/ack_tracker.h" |
6 | 6 |
| 7 #include "base/compiler_specific.h" |
7 #include "base/memory/ref_counted.h" | 8 #include "base/memory/ref_counted.h" |
8 #include "base/message_loop.h" | 9 #include "base/message_loop.h" |
| 10 #include "base/time/tick_clock.h" |
9 #include "google/cacheinvalidation/include/types.h" | 11 #include "google/cacheinvalidation/include/types.h" |
10 #include "google/cacheinvalidation/types.pb.h" | 12 #include "google/cacheinvalidation/types.pb.h" |
11 #include "testing/gmock/include/gmock/gmock.h" | 13 #include "testing/gmock/include/gmock/gmock.h" |
12 #include "testing/gtest/include/gtest/gtest.h" | 14 #include "testing/gtest/include/gtest/gtest.h" |
13 | 15 |
14 namespace syncer { | 16 namespace syncer { |
15 | 17 |
16 namespace { | 18 namespace { |
17 | 19 |
18 typedef AckTracker::NowCallback NowCallback; | 20 class FakeTickClock : public base::TickClock { |
| 21 public: |
| 22 FakeTickClock() {} |
19 | 23 |
20 class MockTimeProvider : public base::RefCountedThreadSafe<MockTimeProvider> { | 24 virtual ~FakeTickClock() {} |
21 public: | |
22 MockTimeProvider() : fake_now_(base::TimeTicks::Now()) {} | |
23 | 25 |
24 void LeapForward(int seconds) { | 26 void LeapForward(int seconds) { |
25 ASSERT_GT(seconds, 0); | 27 ASSERT_GT(seconds, 0); |
26 fake_now_ += base::TimeDelta::FromSeconds(seconds); | 28 fake_now_ticks_ += base::TimeDelta::FromSeconds(seconds); |
27 } | 29 } |
28 | 30 |
29 // After the next call to Now(), immediately leap forward by |seconds|. | 31 // After the next call to Now(), immediately leap forward by |seconds|. |
30 void DelayedLeapForward(int seconds) { | 32 void DelayedLeapForward(int seconds) { |
31 ASSERT_GT(seconds, 0); | 33 ASSERT_GT(seconds, 0); |
32 delayed_leap_ = base::TimeDelta::FromSeconds(seconds); | 34 delayed_leap_ = base::TimeDelta::FromSeconds(seconds); |
33 } | 35 } |
34 | 36 |
35 base::TimeTicks Now() { | 37 virtual base::TimeTicks NowTicks() OVERRIDE { |
36 base::TimeTicks fake_now = fake_now_; | 38 base::TimeTicks fake_now_ticks = fake_now_ticks_; |
37 if (delayed_leap_ > base::TimeDelta()) { | 39 if (delayed_leap_ > base::TimeDelta()) { |
38 fake_now_ += delayed_leap_; | 40 fake_now_ticks_ += delayed_leap_; |
39 delayed_leap_ = base::TimeDelta(); | 41 delayed_leap_ = base::TimeDelta(); |
40 } | 42 } |
41 return fake_now; | 43 return fake_now_ticks; |
42 } | 44 } |
43 | 45 |
44 private: | 46 private: |
45 friend class base::RefCountedThreadSafe<MockTimeProvider>; | 47 base::TimeTicks fake_now_ticks_; |
46 | |
47 ~MockTimeProvider() {} | |
48 | |
49 base::TimeTicks fake_now_; | |
50 base::TimeDelta delayed_leap_; | 48 base::TimeDelta delayed_leap_; |
51 }; | 49 }; |
52 | 50 |
53 class FakeBackoffEntry : public net::BackoffEntry { | 51 class FakeBackoffEntry : public net::BackoffEntry { |
54 public: | 52 public: |
55 FakeBackoffEntry(const Policy* const policy, const NowCallback& now_callback) | 53 FakeBackoffEntry(const Policy* const policy, base::TickClock* tick_clock) |
56 : BackoffEntry(policy), | 54 : BackoffEntry(policy), |
57 now_callback_(now_callback) { | 55 tick_clock_(tick_clock) { |
58 } | 56 } |
59 | 57 |
60 protected: | 58 protected: |
61 virtual base::TimeTicks ImplGetTimeNow() const OVERRIDE { | 59 virtual base::TimeTicks ImplGetTimeNow() const OVERRIDE { |
62 return now_callback_.Run(); | 60 return tick_clock_->NowTicks(); |
63 } | 61 } |
64 | 62 |
65 private: | 63 private: |
66 NowCallback now_callback_; | 64 base::TickClock* const tick_clock_; |
67 }; | 65 }; |
68 | 66 |
69 class MockDelegate : public AckTracker::Delegate { | 67 class MockDelegate : public AckTracker::Delegate { |
70 public: | 68 public: |
71 MOCK_METHOD1(OnTimeout, void(const ObjectIdSet&)); | 69 MOCK_METHOD1(OnTimeout, void(const ObjectIdSet&)); |
72 }; | 70 }; |
73 | 71 |
74 scoped_ptr<net::BackoffEntry> CreateMockEntry( | 72 scoped_ptr<net::BackoffEntry> CreateMockEntry( |
75 const NowCallback& now_callback, | 73 base::TickClock* tick_clock, |
76 const net::BackoffEntry::Policy* const policy) { | 74 const net::BackoffEntry::Policy* const policy) { |
77 return scoped_ptr<net::BackoffEntry>(new FakeBackoffEntry( | 75 return scoped_ptr<net::BackoffEntry>(new FakeBackoffEntry( |
78 policy, now_callback)); | 76 policy, tick_clock)); |
79 } | 77 } |
80 | 78 |
81 } // namespace | 79 } // namespace |
82 | 80 |
83 class AckTrackerTest : public testing::Test { | 81 class AckTrackerTest : public testing::Test { |
84 public: | 82 public: |
85 AckTrackerTest() | 83 AckTrackerTest() |
86 : time_provider_(new MockTimeProvider), | 84 : ack_tracker_(&fake_tick_clock_, &delegate_), |
87 ack_tracker_(&delegate_), | |
88 kIdOne(ipc::invalidation::ObjectSource::TEST, "one"), | 85 kIdOne(ipc::invalidation::ObjectSource::TEST, "one"), |
89 kIdTwo(ipc::invalidation::ObjectSource::TEST, "two") { | 86 kIdTwo(ipc::invalidation::ObjectSource::TEST, "two") { |
90 ack_tracker_.SetNowCallbackForTest( | |
91 base::Bind(&MockTimeProvider::Now, time_provider_)); | |
92 ack_tracker_.SetCreateBackoffEntryCallbackForTest( | 87 ack_tracker_.SetCreateBackoffEntryCallbackForTest( |
93 base::Bind(&CreateMockEntry, | 88 base::Bind(&CreateMockEntry, &fake_tick_clock_)); |
94 base::Bind(&MockTimeProvider::Now, | |
95 time_provider_))); | |
96 } | 89 } |
97 | 90 |
98 protected: | 91 protected: |
99 bool TriggerTimeoutNow() { | 92 bool TriggerTimeoutNow() { |
100 return ack_tracker_.TriggerTimeoutAtForTest(time_provider_->Now()); | 93 return ack_tracker_.TriggerTimeoutAtForTest(fake_tick_clock_.NowTicks()); |
101 } | 94 } |
102 | 95 |
103 base::TimeDelta GetTimerDelay() const { | 96 base::TimeDelta GetTimerDelay() const { |
104 const base::Timer& timer = ack_tracker_.GetTimerForTest(); | 97 const base::Timer& timer = ack_tracker_.GetTimerForTest(); |
105 if (!timer.IsRunning()) | 98 if (!timer.IsRunning()) |
106 ADD_FAILURE() << "Timer is not running!"; | 99 ADD_FAILURE() << "Timer is not running!"; |
107 return timer.GetCurrentDelay(); | 100 return timer.GetCurrentDelay(); |
108 } | 101 } |
109 | 102 |
110 scoped_refptr<MockTimeProvider> time_provider_; | 103 FakeTickClock fake_tick_clock_; |
111 ::testing::StrictMock<MockDelegate> delegate_; | 104 ::testing::StrictMock<MockDelegate> delegate_; |
112 AckTracker ack_tracker_; | 105 AckTracker ack_tracker_; |
113 | 106 |
114 const invalidation::ObjectId kIdOne; | 107 const invalidation::ObjectId kIdOne; |
115 const invalidation::ObjectId kIdTwo; | 108 const invalidation::ObjectId kIdTwo; |
116 | 109 |
117 // AckTracker uses base::Timer internally, which depends on the existence of a | 110 // AckTracker uses base::Timer internally, which depends on the existence of a |
118 // MessageLoop. | 111 // MessageLoop. |
119 MessageLoop message_loop_; | 112 MessageLoop message_loop_; |
120 }; | 113 }; |
(...skipping 72 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
193 // exponentially until it hits the cap. | 186 // exponentially until it hits the cap. |
194 TEST_F(AckTrackerTest, SimpleTimeout) { | 187 TEST_F(AckTrackerTest, SimpleTimeout) { |
195 ObjectIdSet ids; | 188 ObjectIdSet ids; |
196 ids.insert(kIdOne); | 189 ids.insert(kIdOne); |
197 | 190 |
198 EXPECT_TRUE(ack_tracker_.IsQueueEmptyForTest()); | 191 EXPECT_TRUE(ack_tracker_.IsQueueEmptyForTest()); |
199 ack_tracker_.Track(ids); | 192 ack_tracker_.Track(ids); |
200 EXPECT_FALSE(ack_tracker_.IsQueueEmptyForTest()); | 193 EXPECT_FALSE(ack_tracker_.IsQueueEmptyForTest()); |
201 | 194 |
202 EXPECT_EQ(base::TimeDelta::FromSeconds(60), GetTimerDelay()); | 195 EXPECT_EQ(base::TimeDelta::FromSeconds(60), GetTimerDelay()); |
203 time_provider_->LeapForward(60); | 196 fake_tick_clock_.LeapForward(60); |
204 EXPECT_CALL(delegate_, OnTimeout(ids)); | 197 EXPECT_CALL(delegate_, OnTimeout(ids)); |
205 EXPECT_TRUE(TriggerTimeoutNow()); | 198 EXPECT_TRUE(TriggerTimeoutNow()); |
206 | 199 |
207 EXPECT_EQ(base::TimeDelta::FromSeconds(120), GetTimerDelay()); | 200 EXPECT_EQ(base::TimeDelta::FromSeconds(120), GetTimerDelay()); |
208 time_provider_->LeapForward(120); | 201 fake_tick_clock_.LeapForward(120); |
209 EXPECT_CALL(delegate_, OnTimeout(ids)); | 202 EXPECT_CALL(delegate_, OnTimeout(ids)); |
210 EXPECT_TRUE(TriggerTimeoutNow()); | 203 EXPECT_TRUE(TriggerTimeoutNow()); |
211 | 204 |
212 EXPECT_EQ(base::TimeDelta::FromSeconds(240), GetTimerDelay()); | 205 EXPECT_EQ(base::TimeDelta::FromSeconds(240), GetTimerDelay()); |
213 time_provider_->LeapForward(240); | 206 fake_tick_clock_.LeapForward(240); |
214 EXPECT_CALL(delegate_, OnTimeout(ids)); | 207 EXPECT_CALL(delegate_, OnTimeout(ids)); |
215 EXPECT_TRUE(TriggerTimeoutNow()); | 208 EXPECT_TRUE(TriggerTimeoutNow()); |
216 | 209 |
217 EXPECT_EQ(base::TimeDelta::FromSeconds(480), GetTimerDelay()); | 210 EXPECT_EQ(base::TimeDelta::FromSeconds(480), GetTimerDelay()); |
218 time_provider_->LeapForward(480); | 211 fake_tick_clock_.LeapForward(480); |
219 EXPECT_CALL(delegate_, OnTimeout(ids)); | 212 EXPECT_CALL(delegate_, OnTimeout(ids)); |
220 EXPECT_TRUE(TriggerTimeoutNow()); | 213 EXPECT_TRUE(TriggerTimeoutNow()); |
221 | 214 |
222 EXPECT_EQ(base::TimeDelta::FromSeconds(600), GetTimerDelay()); | 215 EXPECT_EQ(base::TimeDelta::FromSeconds(600), GetTimerDelay()); |
223 time_provider_->LeapForward(600); | 216 fake_tick_clock_.LeapForward(600); |
224 EXPECT_CALL(delegate_, OnTimeout(ids)); | 217 EXPECT_CALL(delegate_, OnTimeout(ids)); |
225 EXPECT_TRUE(TriggerTimeoutNow()); | 218 EXPECT_TRUE(TriggerTimeoutNow()); |
226 | 219 |
227 EXPECT_EQ(base::TimeDelta::FromSeconds(600), GetTimerDelay()); | 220 EXPECT_EQ(base::TimeDelta::FromSeconds(600), GetTimerDelay()); |
228 time_provider_->LeapForward(600); | 221 fake_tick_clock_.LeapForward(600); |
229 EXPECT_CALL(delegate_, OnTimeout(ids)); | 222 EXPECT_CALL(delegate_, OnTimeout(ids)); |
230 EXPECT_TRUE(TriggerTimeoutNow()); | 223 EXPECT_TRUE(TriggerTimeoutNow()); |
231 | 224 |
232 EXPECT_FALSE(ack_tracker_.IsQueueEmptyForTest()); | 225 EXPECT_FALSE(ack_tracker_.IsQueueEmptyForTest()); |
233 ack_tracker_.Ack(ids); | 226 ack_tracker_.Ack(ids); |
234 EXPECT_TRUE(ack_tracker_.IsQueueEmptyForTest()); | 227 EXPECT_TRUE(ack_tracker_.IsQueueEmptyForTest()); |
235 | 228 |
236 // The backoff time should be reset after an Ack/Track cycle. | 229 // The backoff time should be reset after an Ack/Track cycle. |
237 ack_tracker_.Track(ids); | 230 ack_tracker_.Track(ids); |
238 EXPECT_FALSE(ack_tracker_.IsQueueEmptyForTest()); | 231 EXPECT_FALSE(ack_tracker_.IsQueueEmptyForTest()); |
239 | 232 |
240 EXPECT_EQ(base::TimeDelta::FromSeconds(60), GetTimerDelay()); | 233 EXPECT_EQ(base::TimeDelta::FromSeconds(60), GetTimerDelay()); |
241 time_provider_->LeapForward(60); | 234 fake_tick_clock_.LeapForward(60); |
242 EXPECT_CALL(delegate_, OnTimeout(ids)); | 235 EXPECT_CALL(delegate_, OnTimeout(ids)); |
243 EXPECT_TRUE(TriggerTimeoutNow()); | 236 EXPECT_TRUE(TriggerTimeoutNow()); |
244 | 237 |
245 EXPECT_FALSE(ack_tracker_.IsQueueEmptyForTest()); | 238 EXPECT_FALSE(ack_tracker_.IsQueueEmptyForTest()); |
246 ack_tracker_.Ack(ids); | 239 ack_tracker_.Ack(ids); |
247 EXPECT_TRUE(ack_tracker_.IsQueueEmptyForTest()); | 240 EXPECT_TRUE(ack_tracker_.IsQueueEmptyForTest()); |
248 } | 241 } |
249 | 242 |
250 // Tests that a sequence of Track() calls that results in interleaving | 243 // Tests that a sequence of Track() calls that results in interleaving |
251 // timeouts occurs as expected. | 244 // timeouts occurs as expected. |
252 TEST_F(AckTrackerTest, InterleavedTimeout) { | 245 TEST_F(AckTrackerTest, InterleavedTimeout) { |
253 ObjectIdSet ids_one; | 246 ObjectIdSet ids_one; |
254 ids_one.insert(kIdOne); | 247 ids_one.insert(kIdOne); |
255 ObjectIdSet ids_two; | 248 ObjectIdSet ids_two; |
256 ids_two.insert(kIdTwo); | 249 ids_two.insert(kIdTwo); |
257 | 250 |
258 EXPECT_TRUE(ack_tracker_.IsQueueEmptyForTest()); | 251 EXPECT_TRUE(ack_tracker_.IsQueueEmptyForTest()); |
259 ack_tracker_.Track(ids_one); | 252 ack_tracker_.Track(ids_one); |
260 EXPECT_FALSE(ack_tracker_.IsQueueEmptyForTest()); | 253 EXPECT_FALSE(ack_tracker_.IsQueueEmptyForTest()); |
261 | 254 |
262 time_provider_->LeapForward(30); | 255 fake_tick_clock_.LeapForward(30); |
263 ack_tracker_.Track(ids_two); | 256 ack_tracker_.Track(ids_two); |
264 EXPECT_FALSE(ack_tracker_.IsQueueEmptyForTest()); | 257 EXPECT_FALSE(ack_tracker_.IsQueueEmptyForTest()); |
265 | 258 |
266 EXPECT_EQ(base::TimeDelta::FromSeconds(60), GetTimerDelay()); | 259 EXPECT_EQ(base::TimeDelta::FromSeconds(60), GetTimerDelay()); |
267 time_provider_->LeapForward(30); | 260 fake_tick_clock_.LeapForward(30); |
268 EXPECT_CALL(delegate_, OnTimeout(ids_one)); | 261 EXPECT_CALL(delegate_, OnTimeout(ids_one)); |
269 EXPECT_TRUE(TriggerTimeoutNow()); | 262 EXPECT_TRUE(TriggerTimeoutNow()); |
270 | 263 |
271 EXPECT_EQ(base::TimeDelta::FromSeconds(30), GetTimerDelay()); | 264 EXPECT_EQ(base::TimeDelta::FromSeconds(30), GetTimerDelay()); |
272 time_provider_->LeapForward(30); | 265 fake_tick_clock_.LeapForward(30); |
273 EXPECT_CALL(delegate_, OnTimeout(ids_two)); | 266 EXPECT_CALL(delegate_, OnTimeout(ids_two)); |
274 EXPECT_TRUE(TriggerTimeoutNow()); | 267 EXPECT_TRUE(TriggerTimeoutNow()); |
275 | 268 |
276 EXPECT_EQ(base::TimeDelta::FromSeconds(90), GetTimerDelay()); | 269 EXPECT_EQ(base::TimeDelta::FromSeconds(90), GetTimerDelay()); |
277 time_provider_->LeapForward(90); | 270 fake_tick_clock_.LeapForward(90); |
278 EXPECT_CALL(delegate_, OnTimeout(ids_one)); | 271 EXPECT_CALL(delegate_, OnTimeout(ids_one)); |
279 EXPECT_TRUE(TriggerTimeoutNow()); | 272 EXPECT_TRUE(TriggerTimeoutNow()); |
280 | 273 |
281 EXPECT_EQ(base::TimeDelta::FromSeconds(30), GetTimerDelay()); | 274 EXPECT_EQ(base::TimeDelta::FromSeconds(30), GetTimerDelay()); |
282 time_provider_->LeapForward(30); | 275 fake_tick_clock_.LeapForward(30); |
283 EXPECT_CALL(delegate_, OnTimeout(ids_two)); | 276 EXPECT_CALL(delegate_, OnTimeout(ids_two)); |
284 EXPECT_TRUE(TriggerTimeoutNow()); | 277 EXPECT_TRUE(TriggerTimeoutNow()); |
285 | 278 |
286 ack_tracker_.Ack(ids_one); | 279 ack_tracker_.Ack(ids_one); |
287 ack_tracker_.Ack(ids_two); | 280 ack_tracker_.Ack(ids_two); |
288 EXPECT_TRUE(ack_tracker_.IsQueueEmptyForTest()); | 281 EXPECT_TRUE(ack_tracker_.IsQueueEmptyForTest()); |
289 } | 282 } |
290 | 283 |
291 // Tests that registering a new object ID properly shortens the timeout when | 284 // Tests that registering a new object ID properly shortens the timeout when |
292 // needed. | 285 // needed. |
293 TEST_F(AckTrackerTest, ShortenTimeout) { | 286 TEST_F(AckTrackerTest, ShortenTimeout) { |
294 ObjectIdSet ids_one; | 287 ObjectIdSet ids_one; |
295 ids_one.insert(kIdOne); | 288 ids_one.insert(kIdOne); |
296 ObjectIdSet ids_two; | 289 ObjectIdSet ids_two; |
297 ids_two.insert(kIdTwo); | 290 ids_two.insert(kIdTwo); |
298 | 291 |
299 EXPECT_TRUE(ack_tracker_.IsQueueEmptyForTest()); | 292 EXPECT_TRUE(ack_tracker_.IsQueueEmptyForTest()); |
300 ack_tracker_.Track(ids_one); | 293 ack_tracker_.Track(ids_one); |
301 EXPECT_FALSE(ack_tracker_.IsQueueEmptyForTest()); | 294 EXPECT_FALSE(ack_tracker_.IsQueueEmptyForTest()); |
302 | 295 |
303 EXPECT_EQ(base::TimeDelta::FromSeconds(60), GetTimerDelay()); | 296 EXPECT_EQ(base::TimeDelta::FromSeconds(60), GetTimerDelay()); |
304 time_provider_->LeapForward(60); | 297 fake_tick_clock_.LeapForward(60); |
305 EXPECT_CALL(delegate_, OnTimeout(ids_one)); | 298 EXPECT_CALL(delegate_, OnTimeout(ids_one)); |
306 EXPECT_TRUE(TriggerTimeoutNow()); | 299 EXPECT_TRUE(TriggerTimeoutNow()); |
307 | 300 |
308 // Without this next register, the next timeout should occur in 120 seconds | 301 // Without this next register, the next timeout should occur in 120 seconds |
309 // from the last timeout event. | 302 // from the last timeout event. |
310 EXPECT_EQ(base::TimeDelta::FromSeconds(120), GetTimerDelay()); | 303 EXPECT_EQ(base::TimeDelta::FromSeconds(120), GetTimerDelay()); |
311 time_provider_->LeapForward(30); | 304 fake_tick_clock_.LeapForward(30); |
312 ack_tracker_.Track(ids_two); | 305 ack_tracker_.Track(ids_two); |
313 EXPECT_FALSE(ack_tracker_.IsQueueEmptyForTest()); | 306 EXPECT_FALSE(ack_tracker_.IsQueueEmptyForTest()); |
314 | 307 |
315 // Now that we've registered another entry though, we should receive a timeout | 308 // Now that we've registered another entry though, we should receive a timeout |
316 // in 60 seconds. | 309 // in 60 seconds. |
317 EXPECT_EQ(base::TimeDelta::FromSeconds(60), GetTimerDelay()); | 310 EXPECT_EQ(base::TimeDelta::FromSeconds(60), GetTimerDelay()); |
318 time_provider_->LeapForward(60); | 311 fake_tick_clock_.LeapForward(60); |
319 EXPECT_CALL(delegate_, OnTimeout(ids_two)); | 312 EXPECT_CALL(delegate_, OnTimeout(ids_two)); |
320 EXPECT_TRUE(TriggerTimeoutNow()); | 313 EXPECT_TRUE(TriggerTimeoutNow()); |
321 | 314 |
322 // Verify that the original timeout for kIdOne still occurs as expected. | 315 // Verify that the original timeout for kIdOne still occurs as expected. |
323 EXPECT_EQ(base::TimeDelta::FromSeconds(30), GetTimerDelay()); | 316 EXPECT_EQ(base::TimeDelta::FromSeconds(30), GetTimerDelay()); |
324 time_provider_->LeapForward(30); | 317 fake_tick_clock_.LeapForward(30); |
325 EXPECT_CALL(delegate_, OnTimeout(ids_one)); | 318 EXPECT_CALL(delegate_, OnTimeout(ids_one)); |
326 EXPECT_TRUE(TriggerTimeoutNow()); | 319 EXPECT_TRUE(TriggerTimeoutNow()); |
327 | 320 |
328 ack_tracker_.Ack(ids_one); | 321 ack_tracker_.Ack(ids_one); |
329 ack_tracker_.Ack(ids_two); | 322 ack_tracker_.Ack(ids_two); |
330 EXPECT_TRUE(ack_tracker_.IsQueueEmptyForTest()); | 323 EXPECT_TRUE(ack_tracker_.IsQueueEmptyForTest()); |
331 } | 324 } |
332 | 325 |
333 // Tests that a delay between inserting a new object ID registration and start | 326 // Tests that a delay between inserting a new object ID registration and start |
334 // the timer that is greater than the initial timeout period (60 seconds) does | 327 // the timer that is greater than the initial timeout period (60 seconds) does |
335 // not break things. This could happen on a heavily loaded system, for instance. | 328 // not break things. This could happen on a heavily loaded system, for instance. |
336 TEST_F(AckTrackerTest, ImmediateTimeout) { | 329 TEST_F(AckTrackerTest, ImmediateTimeout) { |
337 ObjectIdSet ids; | 330 ObjectIdSet ids; |
338 ids.insert(kIdOne); | 331 ids.insert(kIdOne); |
339 | 332 |
340 time_provider_->DelayedLeapForward(90); | 333 fake_tick_clock_.DelayedLeapForward(90); |
341 EXPECT_TRUE(ack_tracker_.IsQueueEmptyForTest()); | 334 EXPECT_TRUE(ack_tracker_.IsQueueEmptyForTest()); |
342 ack_tracker_.Track(ids); | 335 ack_tracker_.Track(ids); |
343 EXPECT_FALSE(ack_tracker_.IsQueueEmptyForTest()); | 336 EXPECT_FALSE(ack_tracker_.IsQueueEmptyForTest()); |
344 | 337 |
345 EXPECT_EQ(base::TimeDelta::FromSeconds(0), GetTimerDelay()); | 338 EXPECT_EQ(base::TimeDelta::FromSeconds(0), GetTimerDelay()); |
346 EXPECT_CALL(delegate_, OnTimeout(ids)); | 339 EXPECT_CALL(delegate_, OnTimeout(ids)); |
347 message_loop_.RunUntilIdle(); | 340 message_loop_.RunUntilIdle(); |
348 | 341 |
349 // The next timeout should still be scheduled normally. | 342 // The next timeout should still be scheduled normally. |
350 EXPECT_EQ(base::TimeDelta::FromSeconds(120), GetTimerDelay()); | 343 EXPECT_EQ(base::TimeDelta::FromSeconds(120), GetTimerDelay()); |
351 time_provider_->LeapForward(120); | 344 fake_tick_clock_.LeapForward(120); |
352 EXPECT_CALL(delegate_, OnTimeout(ids)); | 345 EXPECT_CALL(delegate_, OnTimeout(ids)); |
353 EXPECT_TRUE(TriggerTimeoutNow()); | 346 EXPECT_TRUE(TriggerTimeoutNow()); |
354 | 347 |
355 ack_tracker_.Ack(ids); | 348 ack_tracker_.Ack(ids); |
356 EXPECT_TRUE(ack_tracker_.IsQueueEmptyForTest()); | 349 EXPECT_TRUE(ack_tracker_.IsQueueEmptyForTest()); |
357 } | 350 } |
358 | 351 |
359 } // namespace syncer | 352 } // namespace syncer |
OLD | NEW |