Add a Clock and TickClock interface for mocking out time

sync/notifier/ack_tracker_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "sync/notifier/ack_tracker.h"
 
+#include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop.h"
+#include "base/tick_clock.h"
 #include "google/cacheinvalidation/include/types.h"
 #include "google/cacheinvalidation/types.pb.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace syncer {
 
 namespace {
 
-typedef AckTracker::NowCallback NowCallback;
+class FakeTickClock : public base::TickClock {
+ public:
+  FakeTickClock() {}
 
-class MockTimeProvider : public base::RefCountedThreadSafe<MockTimeProvider> {
- public:
-  MockTimeProvider() : fake_now_(base::TimeTicks::Now()) {}
+  virtual ~FakeTickClock() {}
 
   void LeapForward(int seconds) {
     ASSERT_GT(seconds, 0);
-    fake_now_ += base::TimeDelta::FromSeconds(seconds);
+    fake_now_ticks_ += base::TimeDelta::FromSeconds(seconds);
   }
 
   // After the next call to Now(), immediately leap forward by |seconds|.
   void DelayedLeapForward(int seconds) {
     ASSERT_GT(seconds, 0);
     delayed_leap_ = base::TimeDelta::FromSeconds(seconds);
   }
 
-  base::TimeTicks Now() {
-    base::TimeTicks fake_now = fake_now_;
+  virtual base::TimeTicks NowTicks() OVERRIDE {
+    base::TimeTicks fake_now_ticks = fake_now_ticks_;
     if (delayed_leap_ > base::TimeDelta()) {
-      fake_now_ += delayed_leap_;
+      fake_now_ticks_ += delayed_leap_;
       delayed_leap_ = base::TimeDelta();
     }
-    return fake_now;
+    return fake_now_ticks;
   }
 
  private:
-  friend class base::RefCountedThreadSafe<MockTimeProvider>;
-
-  ~MockTimeProvider() {}
-
-  base::TimeTicks fake_now_;
+  base::TimeTicks fake_now_ticks_;
   base::TimeDelta delayed_leap_;
 };
 
 class FakeBackoffEntry : public net::BackoffEntry {
  public:
-  FakeBackoffEntry(const Policy* const policy, const NowCallback& now_callback)
+  FakeBackoffEntry(const Policy* const policy, base::TickClock* tick_clock)
       : BackoffEntry(policy),
-        now_callback_(now_callback) {
+        tick_clock_(tick_clock) {

[jar (doing other things), 2012/12/17 20:29:21]

nit: I like the use of "tick_clock" here.  It helps clarify that this is more
kindred of TimeTicks() than of Time() (which historically has been a point of
confusion).  Perchance you should use a base of TickClock() as a class name
rather than Clock() in some of your other code.  

[akalin, 2012/12/17 22:38:31]

Yeah, I've made sure to have 'TickClock' in the name for anything that inherits
from TickClock.  If I run into places where TickClock is called for, I'll
probably name it 'tick_clock_' or similar.

   }
 
  protected:
   virtual base::TimeTicks ImplGetTimeNow() const OVERRIDE {
-    return now_callback_.Run();
+    return tick_clock_->NowTicks();
   }
 
  private:
-  NowCallback now_callback_;
+  base::TickClock* const tick_clock_;
 };
 
 class MockDelegate : public AckTracker::Delegate {
  public:
   MOCK_METHOD1(OnTimeout, void(const ObjectIdSet&));
 };
 
 scoped_ptr<net::BackoffEntry> CreateMockEntry(
-    const NowCallback& now_callback,
+    base::TickClock* tick_clock,
     const net::BackoffEntry::Policy* const policy) {
   return scoped_ptr<net::BackoffEntry>(new FakeBackoffEntry(
-      policy, now_callback));
+      policy, tick_clock));
 }
 
 }  // namespace
 
 class AckTrackerTest : public testing::Test {
  public:
   AckTrackerTest()
-      : time_provider_(new MockTimeProvider),
-        ack_tracker_(&delegate_),
+      : ack_tracker_(&fake_tick_clock_, &delegate_),
         kIdOne(ipc::invalidation::ObjectSource::TEST, "one"),
         kIdTwo(ipc::invalidation::ObjectSource::TEST, "two") {
-    ack_tracker_.SetNowCallbackForTest(
-        base::Bind(&MockTimeProvider::Now, time_provider_));
     ack_tracker_.SetCreateBackoffEntryCallbackForTest(
-        base::Bind(&CreateMockEntry,
-                   base::Bind(&MockTimeProvider::Now,
-                              time_provider_)));
+        base::Bind(&CreateMockEntry, &fake_tick_clock_));
   }
 
  protected:
   bool TriggerTimeoutNow() {
-    return ack_tracker_.TriggerTimeoutAtForTest(time_provider_->Now());
+    return ack_tracker_.TriggerTimeoutAtForTest(fake_tick_clock_.NowTicks());
   }
 
   base::TimeDelta GetTimerDelay() const {
     const base::Timer& timer = ack_tracker_.GetTimerForTest();
     if (!timer.IsRunning())
       ADD_FAILURE() << "Timer is not running!";
     return timer.GetCurrentDelay();
   }
 
-  scoped_refptr<MockTimeProvider> time_provider_;
+  FakeTickClock fake_tick_clock_;
   ::testing::StrictMock<MockDelegate> delegate_;
   AckTracker ack_tracker_;
 
   const invalidation::ObjectId kIdOne;
   const invalidation::ObjectId kIdTwo;
 
   // AckTracker uses base::Timer internally, which depends on the existence of a
   // MessageLoop.
   MessageLoop message_loop_;
 };
@@ skipping 72 matching lines @@
 // exponentially until it hits the cap.
 TEST_F(AckTrackerTest, SimpleTimeout) {
   ObjectIdSet ids;
   ids.insert(kIdOne);
 
   EXPECT_TRUE(ack_tracker_.IsQueueEmptyForTest());
   ack_tracker_.Track(ids);
   EXPECT_FALSE(ack_tracker_.IsQueueEmptyForTest());
 
   EXPECT_EQ(base::TimeDelta::FromSeconds(60), GetTimerDelay());
-  time_provider_->LeapForward(60);
+  fake_tick_clock_.LeapForward(60);
   EXPECT_CALL(delegate_, OnTimeout(ids));
   EXPECT_TRUE(TriggerTimeoutNow());
 
   EXPECT_EQ(base::TimeDelta::FromSeconds(120), GetTimerDelay());
-  time_provider_->LeapForward(120);
+  fake_tick_clock_.LeapForward(120);
   EXPECT_CALL(delegate_, OnTimeout(ids));
   EXPECT_TRUE(TriggerTimeoutNow());
 
   EXPECT_EQ(base::TimeDelta::FromSeconds(240), GetTimerDelay());
-  time_provider_->LeapForward(240);
+  fake_tick_clock_.LeapForward(240);
   EXPECT_CALL(delegate_, OnTimeout(ids));
   EXPECT_TRUE(TriggerTimeoutNow());
 
   EXPECT_EQ(base::TimeDelta::FromSeconds(480), GetTimerDelay());
-  time_provider_->LeapForward(480);
+  fake_tick_clock_.LeapForward(480);
   EXPECT_CALL(delegate_, OnTimeout(ids));
   EXPECT_TRUE(TriggerTimeoutNow());
 
   EXPECT_EQ(base::TimeDelta::FromSeconds(600), GetTimerDelay());
-  time_provider_->LeapForward(600);
+  fake_tick_clock_.LeapForward(600);
   EXPECT_CALL(delegate_, OnTimeout(ids));
   EXPECT_TRUE(TriggerTimeoutNow());
 
   EXPECT_EQ(base::TimeDelta::FromSeconds(600), GetTimerDelay());
-  time_provider_->LeapForward(600);
+  fake_tick_clock_.LeapForward(600);
   EXPECT_CALL(delegate_, OnTimeout(ids));
   EXPECT_TRUE(TriggerTimeoutNow());
 
   EXPECT_FALSE(ack_tracker_.IsQueueEmptyForTest());
   ack_tracker_.Ack(ids);
   EXPECT_TRUE(ack_tracker_.IsQueueEmptyForTest());
 
   // The backoff time should be reset after an Ack/Track cycle.
   ack_tracker_.Track(ids);
   EXPECT_FALSE(ack_tracker_.IsQueueEmptyForTest());
 
   EXPECT_EQ(base::TimeDelta::FromSeconds(60), GetTimerDelay());
-  time_provider_->LeapForward(60);
+  fake_tick_clock_.LeapForward(60);
   EXPECT_CALL(delegate_, OnTimeout(ids));
   EXPECT_TRUE(TriggerTimeoutNow());
 
   EXPECT_FALSE(ack_tracker_.IsQueueEmptyForTest());
   ack_tracker_.Ack(ids);
   EXPECT_TRUE(ack_tracker_.IsQueueEmptyForTest());
 }
 
 // Tests that a sequence of Track() calls that results in interleaving
 // timeouts occurs as expected.
 TEST_F(AckTrackerTest, InterleavedTimeout) {
   ObjectIdSet ids_one;
   ids_one.insert(kIdOne);
   ObjectIdSet ids_two;
   ids_two.insert(kIdTwo);
 
   EXPECT_TRUE(ack_tracker_.IsQueueEmptyForTest());
   ack_tracker_.Track(ids_one);
   EXPECT_FALSE(ack_tracker_.IsQueueEmptyForTest());
 
-  time_provider_->LeapForward(30);
+  fake_tick_clock_.LeapForward(30);
   ack_tracker_.Track(ids_two);
   EXPECT_FALSE(ack_tracker_.IsQueueEmptyForTest());
 
   EXPECT_EQ(base::TimeDelta::FromSeconds(60), GetTimerDelay());
-  time_provider_->LeapForward(30);
+  fake_tick_clock_.LeapForward(30);
   EXPECT_CALL(delegate_, OnTimeout(ids_one));
   EXPECT_TRUE(TriggerTimeoutNow());
 
   EXPECT_EQ(base::TimeDelta::FromSeconds(30), GetTimerDelay());
-  time_provider_->LeapForward(30);
+  fake_tick_clock_.LeapForward(30);
   EXPECT_CALL(delegate_, OnTimeout(ids_two));
   EXPECT_TRUE(TriggerTimeoutNow());
 
   EXPECT_EQ(base::TimeDelta::FromSeconds(90), GetTimerDelay());
-  time_provider_->LeapForward(90);
+  fake_tick_clock_.LeapForward(90);
   EXPECT_CALL(delegate_, OnTimeout(ids_one));
   EXPECT_TRUE(TriggerTimeoutNow());
 
   EXPECT_EQ(base::TimeDelta::FromSeconds(30), GetTimerDelay());
-  time_provider_->LeapForward(30);
+  fake_tick_clock_.LeapForward(30);
   EXPECT_CALL(delegate_, OnTimeout(ids_two));
   EXPECT_TRUE(TriggerTimeoutNow());
 
   ack_tracker_.Ack(ids_one);
   ack_tracker_.Ack(ids_two);
   EXPECT_TRUE(ack_tracker_.IsQueueEmptyForTest());
 }
 
 // Tests that registering a new object ID properly shortens the timeout when
 // needed.
 TEST_F(AckTrackerTest, ShortenTimeout) {
   ObjectIdSet ids_one;
   ids_one.insert(kIdOne);
   ObjectIdSet ids_two;
   ids_two.insert(kIdTwo);
 
   EXPECT_TRUE(ack_tracker_.IsQueueEmptyForTest());
   ack_tracker_.Track(ids_one);
   EXPECT_FALSE(ack_tracker_.IsQueueEmptyForTest());
 
   EXPECT_EQ(base::TimeDelta::FromSeconds(60), GetTimerDelay());
-  time_provider_->LeapForward(60);
+  fake_tick_clock_.LeapForward(60);
   EXPECT_CALL(delegate_, OnTimeout(ids_one));
   EXPECT_TRUE(TriggerTimeoutNow());
 
   // Without this next register, the next timeout should occur in 120 seconds
   // from the last timeout event.
   EXPECT_EQ(base::TimeDelta::FromSeconds(120), GetTimerDelay());
-  time_provider_->LeapForward(30);
+  fake_tick_clock_.LeapForward(30);
   ack_tracker_.Track(ids_two);
   EXPECT_FALSE(ack_tracker_.IsQueueEmptyForTest());
 
   // Now that we've registered another entry though, we should receive a timeout
   // in 60 seconds.
   EXPECT_EQ(base::TimeDelta::FromSeconds(60), GetTimerDelay());
-  time_provider_->LeapForward(60);
+  fake_tick_clock_.LeapForward(60);
   EXPECT_CALL(delegate_, OnTimeout(ids_two));
   EXPECT_TRUE(TriggerTimeoutNow());
 
   // Verify that the original timeout for kIdOne still occurs as expected.
   EXPECT_EQ(base::TimeDelta::FromSeconds(30), GetTimerDelay());
-  time_provider_->LeapForward(30);
+  fake_tick_clock_.LeapForward(30);
   EXPECT_CALL(delegate_, OnTimeout(ids_one));
   EXPECT_TRUE(TriggerTimeoutNow());
 
   ack_tracker_.Ack(ids_one);
   ack_tracker_.Ack(ids_two);
   EXPECT_TRUE(ack_tracker_.IsQueueEmptyForTest());
 }
 
 // Tests that a delay between inserting a new object ID registration and start
 // the timer that is greater than the initial timeout period (60 seconds) does
 // not break things. This could happen on a heavily loaded system, for instance.
 TEST_F(AckTrackerTest, ImmediateTimeout) {
   ObjectIdSet ids;
   ids.insert(kIdOne);
 
-  time_provider_->DelayedLeapForward(90);
+  fake_tick_clock_.DelayedLeapForward(90);
   EXPECT_TRUE(ack_tracker_.IsQueueEmptyForTest());
   ack_tracker_.Track(ids);
   EXPECT_FALSE(ack_tracker_.IsQueueEmptyForTest());
 
   EXPECT_EQ(base::TimeDelta::FromSeconds(0), GetTimerDelay());
   EXPECT_CALL(delegate_, OnTimeout(ids));
   message_loop_.RunUntilIdle();
 
   // The next timeout should still be scheduled normally.
   EXPECT_EQ(base::TimeDelta::FromSeconds(120), GetTimerDelay());
-  time_provider_->LeapForward(120);
+  fake_tick_clock_.LeapForward(120);
   EXPECT_CALL(delegate_, OnTimeout(ids));
   EXPECT_TRUE(TriggerTimeoutNow());
 
   ack_tracker_.Ack(ids);
   EXPECT_TRUE(ack_tracker_.IsQueueEmptyForTest());
 }
 
 }  // namespace syncer