Use a TickClock instead of TimeTicks::Now() in Timer.

base/timer/timer_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 "base/timer/timer.h"
 
 #include <stddef.h>
 
 #include <memory>
 
+#include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
+#include "base/test/test_mock_time_task_runner.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
+#include "base/time/tick_clock.h"
 #include "build/build_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::TimeDelta;
 using base::SingleThreadTaskRunner;
 
 namespace {
 
 // The message loops on which each timer should be tested.
 const base::MessageLoop::Type testing_message_loops[] = {
   base::MessageLoop::TYPE_DEFAULT,
   base::MessageLoop::TYPE_IO,
 #if !defined(OS_IOS)  // iOS does not allow direct running of the UI loop.
   base::MessageLoop::TYPE_UI,
 #endif
 };
 
 const int kNumTestingMessageLoops = arraysize(testing_message_loops);
 
+class Receiver {
+ public:
+  Receiver() : count_(0) {}
+  void OnCalled() { count_++; }
+  bool WasCalled() { return count_ > 0; }
+  int TimesCalled() { return count_; }
+
+ private:
+  int count_;
+};
+
 class OneShotTimerTester {
  public:
   explicit OneShotTimerTester(bool* did_run, unsigned milliseconds = 10)
       : did_run_(did_run),
         delay_ms_(milliseconds),
         quit_message_loop_(true) {
   }
 
   void Start() {
     timer_.Start(FROM_HERE, TimeDelta::FromMilliseconds(delay_ms_), this,
@@ skipping 289 matching lines @@
   bool did_run = false;
   OneShotTimerTester f(&did_run);
   f.SetTaskRunner(task_runner);
   f.Start();
 
   EXPECT_FALSE(did_run);
   task_runner->RunUntilIdle();
   EXPECT_TRUE(did_run);
 }
 
+TEST(TimerTest, OneShotTimerWithTickClock) {
+  scoped_refptr<base::TestMockTimeTaskRunner> task_runner(
+      new base::TestMockTimeTaskRunner(base::Time::Now(),
+                                       base::TimeTicks::Now()));
+  std::unique_ptr<base::TickClock> tick_clock(task_runner->GetMockTickClock());
+  base::MessageLoop message_loop;
+  message_loop.SetTaskRunner(task_runner);
+  Receiver receiver;
+  base::OneShotTimer timer(tick_clock.get());
+  timer.Start(FROM_HERE, base::TimeDelta::FromSeconds(1),
+              base::Bind(&Receiver::OnCalled, base::Unretained(&receiver)));
+  task_runner->FastForwardBy(base::TimeDelta::FromSeconds(1));
+  EXPECT_TRUE(receiver.WasCalled());
+}
+
 TEST(TimerTest, RepeatingTimer) {
   for (int i = 0; i < kNumTestingMessageLoops; i++) {
     RunTest_RepeatingTimer(testing_message_loops[i],
                            TimeDelta::FromMilliseconds(10));
   }
 }
 
 TEST(TimerTest, RepeatingTimer_Cancel) {
   for (int i = 0; i < kNumTestingMessageLoops; i++) {
     RunTest_RepeatingTimer_Cancel(testing_message_loops[i],
                                   TimeDelta::FromMilliseconds(10));
   }
 }
 
 TEST(TimerTest, RepeatingTimerZeroDelay) {
   for (int i = 0; i < kNumTestingMessageLoops; i++) {
     RunTest_RepeatingTimer(testing_message_loops[i],
                            TimeDelta::FromMilliseconds(0));
   }
 }
 
 TEST(TimerTest, RepeatingTimerZeroDelay_Cancel) {
   for (int i = 0; i < kNumTestingMessageLoops; i++) {
     RunTest_RepeatingTimer_Cancel(testing_message_loops[i],
                                   TimeDelta::FromMilliseconds(0));
   }
 }
 
+TEST(TimerTest, RepeatingTimerWithTickClock) {
+  scoped_refptr<base::TestMockTimeTaskRunner> task_runner(
+      new base::TestMockTimeTaskRunner(base::Time::Now(),
+                                       base::TimeTicks::Now()));
+  std::unique_ptr<base::TickClock> tick_clock(task_runner->GetMockTickClock());
+  base::MessageLoop message_loop;
+  message_loop.SetTaskRunner(task_runner);
+  Receiver receiver;
+  const int expected_times_called = 10;
+  base::RepeatingTimer timer(tick_clock.get());
+  timer.Start(FROM_HERE, base::TimeDelta::FromSeconds(1),
+              base::Bind(&Receiver::OnCalled, base::Unretained(&receiver)));
+  task_runner->FastForwardBy(
+      base::TimeDelta::FromSeconds(expected_times_called));
+  timer.Stop();
+  EXPECT_EQ(expected_times_called, receiver.TimesCalled());
+}
+
 TEST(TimerTest, DelayTimer_NoCall) {
   for (int i = 0; i < kNumTestingMessageLoops; i++) {
     RunTest_DelayTimer_NoCall(testing_message_loops[i]);
   }
 }
 
 TEST(TimerTest, DelayTimer_OneCall) {
   for (int i = 0; i < kNumTestingMessageLoops; i++) {
     RunTest_DelayTimer_OneCall(testing_message_loops[i]);
   }
 }
 
 // It's flaky on the buildbot, http://crbug.com/25038.
 TEST(TimerTest, DISABLED_DelayTimer_Reset) {
   for (int i = 0; i < kNumTestingMessageLoops; i++) {
     RunTest_DelayTimer_Reset(testing_message_loops[i]);
   }
 }
 
 TEST(TimerTest, DelayTimer_Deleted) {
   for (int i = 0; i < kNumTestingMessageLoops; i++) {
     RunTest_DelayTimer_Deleted(testing_message_loops[i]);
   }
 }
 
+TEST(TimerTest, DelayTimerWithTickClock) {
+  scoped_refptr<base::TestMockTimeTaskRunner> task_runner(
+      new base::TestMockTimeTaskRunner(base::Time::Now(),
+                                       base::TimeTicks::Now()));
+  std::unique_ptr<base::TickClock> tick_clock(task_runner->GetMockTickClock());
+  base::MessageLoop message_loop;
+  message_loop.SetTaskRunner(task_runner);
+  Receiver receiver;
+  base::DelayTimer timer(FROM_HERE, base::TimeDelta::FromSeconds(1), &receiver,
+                         &Receiver::OnCalled, tick_clock.get());
+  task_runner->FastForwardBy(base::TimeDelta::FromMilliseconds(999));
+  EXPECT_FALSE(receiver.WasCalled());
+  timer.Reset();
+  task_runner->FastForwardBy(base::TimeDelta::FromMilliseconds(999));
+  EXPECT_FALSE(receiver.WasCalled());
+  timer.Reset();
+  task_runner->FastForwardBy(base::TimeDelta::FromSeconds(1));
+  EXPECT_TRUE(receiver.WasCalled());
+}
+
 TEST(TimerTest, MessageLoopShutdown) {
   // This test is designed to verify that shutdown of the
   // message loop does not cause crashes if there were pending
   // timers not yet fired.  It may only trigger exceptions
   // if debug heap checking is enabled.
   bool did_run = false;
   {
     OneShotTimerTester a(&did_run);
     OneShotTimerTester b(&did_run);
     OneShotTimerTester c(&did_run);
@@ skipping 123 matching lines @@
                 base::Bind(&SetCallbackHappened1));
     timer.Reset();
     // Since Reset happened before task ran, the user_task must not be cleared:
     ASSERT_FALSE(timer.user_task().is_null());
     base::RunLoop().Run();
     EXPECT_TRUE(g_callback_happened1);
   }
 }
 
 }  // namespace