Replaced TestNowSource with SimpleTestTickClock.

cc/test/ordered_simple_task_runner_unittest.cc

 // Copyright 2014 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 <string>
 
 #include "base/cancelable_callback.h"
 #include "base/format_macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/stringprintf.h"
@@ skipping 38 matching lines @@
   TestOrderablePendingTask a2 = a;
   EXPECT_EQ(a, a2);
   EXPECT_LT(a2, b);
   EXPECT_LT(b, c);
   EXPECT_LT(a2, c);
 }
 
 class OrderedSimpleTaskRunnerTest : public testing::Test {
  public:
   OrderedSimpleTaskRunnerTest()
-      : now_src_(TestNowSource::Create(base::TimeTicks())) {
-    task_runner_ = new OrderedSimpleTaskRunner(now_src_, true);
-  }
+      : now_src_(new base::SimpleTestTickClock()),
+        task_runner_(new OrderedSimpleTaskRunner(now_src_.get(), true)) {}
   ~OrderedSimpleTaskRunnerTest() override {}
 
  protected:
   std::string executed_tasks_;
-  scoped_refptr<TestNowSource> now_src_;
+  scoped_ptr<base::SimpleTestTickClock> now_src_;
   scoped_refptr<OrderedSimpleTaskRunner> task_runner_;
 
   void PostTask(int task_num, base::TimeDelta delay) {
     base::Closure test_task = base::Bind(&OrderedSimpleTaskRunnerTest::Task,
                                          base::Unretained(this),
                                          task_num);
     task_runner_->PostDelayedTask(FROM_HERE, test_task, delay);
   }
 
   void PostTaskWhichPostsInstantTask(int task_num, base::TimeDelta delay) {
@@ skipping 30 matching lines @@
                    task_num,
                    delay);
     task_runner_->PostDelayedTask(FROM_HERE, test_task, delay);
   }
 
  private:
   void Task(int task_num) {
     if (!executed_tasks_.empty())
       executed_tasks_ += " ";
     executed_tasks_ +=
-        base::StringPrintf("%d(%" PRId64 "ms)",
-                           task_num,
-                           now_src_->Now().ToInternalValue() /
+        base::StringPrintf("%d(%" PRId64 "ms)", task_num,
+                           now_src_->NowTicks().ToInternalValue() /

[Sami, 2015/06/08 13:59:02]

This could just be .InMilliseconds()

[Ankur Verma, 2015/06/09 07:53:47]

Same argument as before about explicitly constituting a TimeDelta and converting
to milliseconds.

[Sami, 2015/06/09 10:16:02]

Yep, let's do the same conversion that I mentioned above here.

[Ankur Verma, 2015/06/09 13:53:43]

Done.

                                base::Time::kMicrosecondsPerMillisecond);
   }
 
   void TaskWhichPostsInstantTask(int task_num) {
     Task(task_num);
     PostTask(-task_num, base::TimeDelta());
   }
 
   void TaskWhichPostsDelayedTask(int task_num, base::TimeDelta delay) {
     Task(task_num);
@@ skipping 139 matching lines @@
   task_runner_->SetAutoAdvanceNowToPendingTasks(false);
   PostTask(1, base::TimeDelta());
   PostTask(2, base::TimeDelta::FromMilliseconds(15));
   PostTask(3, base::TimeDelta());
   PostTask(4, base::TimeDelta::FromMilliseconds(8));
 
   RUN_AND_CHECK_RESULT(EXPECT_TRUE, RunPendingTasks(), "1(0ms) 3(0ms)");
   RUN_AND_CHECK_RESULT(EXPECT_TRUE, RunPendingTasks(), "");
   EXPECT_EQ(task_runner_->DelayToNextTaskTime(),
             base::TimeDelta::FromMilliseconds(8));
-  now_src_->SetNow(base::TimeTicks::FromInternalValue(5000));
+  now_src_->Advance(base::TimeDelta::FromInternalValue(5000));
   EXPECT_EQ(task_runner_->DelayToNextTaskTime(),
             base::TimeDelta::FromMilliseconds(3));
-  now_src_->SetNow(base::TimeTicks::FromInternalValue(25000));
+  now_src_->Advance(base::TimeDelta::FromInternalValue(20000));
   EXPECT_EQ(task_runner_->DelayToNextTaskTime(), base::TimeDelta());
   RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunPendingTasks(), "4(25ms) 2(25ms)");
   RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunPendingTasks(), "");
 }
 
 TEST_F(OrderedSimpleTaskRunnerTest, RunUntilIdle) {
   PostTaskWhichPostsInstantTask(1, base::TimeDelta());
   RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunUntilIdle(), "1(0ms) -1(0ms)");
   RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunUntilIdle(), "");
 }
 
 TEST_F(OrderedSimpleTaskRunnerTest, RunUntilTimeAutoNow) {
   PostTaskWhichPostsInstantTask(1, base::TimeDelta());
   PostTaskWhichPostsInstantTask(2, base::TimeDelta::FromMilliseconds(2));
   PostTaskWhichPostsInstantTask(3, base::TimeDelta::FromMilliseconds(3));
 
   task_runner_->SetAutoAdvanceNowToPendingTasks(true);
 
   base::TimeTicks run_at = base::TimeTicks();
 
   run_at += base::TimeDelta::FromMilliseconds(2);
   RUN_AND_CHECK_RESULT(
       EXPECT_TRUE, RunUntilTime(run_at), "1(0ms) -1(0ms) 2(2ms) -2(2ms)");
-  EXPECT_EQ(run_at, now_src_->Now());
+  EXPECT_EQ(run_at, now_src_->NowTicks());
 
   run_at += base::TimeDelta::FromMilliseconds(1);
   RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunUntilTime(run_at), "3(3ms) -3(3ms)");
-  EXPECT_EQ(run_at, now_src_->Now());
+  EXPECT_EQ(run_at, now_src_->NowTicks());
 
   run_at += base::TimeDelta::FromMilliseconds(1);
   RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunUntilTime(run_at), "");
-  EXPECT_EQ(run_at, now_src_->Now());
+  EXPECT_EQ(run_at, now_src_->NowTicks());
 }
 
 TEST_F(OrderedSimpleTaskRunnerTest, RunUntilTimeManualNow) {
   PostTaskWhichPostsInstantTask(1, base::TimeDelta());
   PostTaskWhichPostsInstantTask(2, base::TimeDelta::FromMilliseconds(2));
   PostTaskWhichPostsInstantTask(3, base::TimeDelta::FromMilliseconds(3));
 
   task_runner_->SetAutoAdvanceNowToPendingTasks(false);
 
   base::TimeTicks run_at = base::TimeTicks();
 
   run_at += base::TimeDelta::FromMilliseconds(2);
   RUN_AND_CHECK_RESULT(
       EXPECT_TRUE, RunUntilTime(run_at), "1(2ms) 2(2ms) -1(2ms) -2(2ms)");
-  EXPECT_EQ(run_at, now_src_->Now());
+  EXPECT_EQ(run_at, now_src_->NowTicks());
 
   run_at += base::TimeDelta::FromMilliseconds(1);
   RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunUntilTime(run_at), "3(3ms) -3(3ms)");
-  EXPECT_EQ(run_at, now_src_->Now());
+  EXPECT_EQ(run_at, now_src_->NowTicks());
 
   run_at += base::TimeDelta::FromMilliseconds(1);
   RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunUntilTime(run_at), "");
-  EXPECT_EQ(run_at, now_src_->Now());
+  EXPECT_EQ(run_at, now_src_->NowTicks());
 }
 
 TEST_F(OrderedSimpleTaskRunnerTest, RunForPeriod) {
   PostTaskWhichPostsInstantTask(1, base::TimeDelta());
   PostTaskWhichPostsInstantTask(2, base::TimeDelta::FromMilliseconds(2));
   PostTaskWhichPostsInstantTask(3, base::TimeDelta::FromMilliseconds(3));
 
   RUN_AND_CHECK_RESULT(EXPECT_TRUE,
                        RunForPeriod(base::TimeDelta::FromMilliseconds(2)),
                        "1(0ms) -1(0ms) 2(2ms) -2(2ms)");
   EXPECT_EQ(base::TimeTicks() + base::TimeDelta::FromMilliseconds(2),
-            now_src_->Now());
+            now_src_->NowTicks());
 
   RUN_AND_CHECK_RESULT(EXPECT_FALSE,
                        RunForPeriod(base::TimeDelta::FromMilliseconds(1)),
                        "3(3ms) -3(3ms)");
   EXPECT_EQ(base::TimeTicks() + base::TimeDelta::FromMilliseconds(3),
-            now_src_->Now());
+            now_src_->NowTicks());
 
   RUN_AND_CHECK_RESULT(
       EXPECT_FALSE, RunForPeriod(base::TimeDelta::FromMilliseconds(1)), "");
   EXPECT_EQ(base::TimeTicks() + base::TimeDelta::FromMilliseconds(4),
-            now_src_->Now());
+            now_src_->NowTicks());
 }
 
 TEST_F(OrderedSimpleTaskRunnerTest, RunTasksWhileWithCallback) {
   base::Callback<bool(void)> return_true = base::Bind(&ReturnTrue);
   base::Callback<bool(void)> return_false = base::Bind(&ReturnFalse);
 
   PostTask(1, base::TimeDelta());
 
   RUN_AND_CHECK_RESULT(EXPECT_TRUE, RunTasksWhile(return_false), "");
   RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunTasksWhile(return_true), "1(0ms)");
 }
 
 TEST_F(OrderedSimpleTaskRunnerTest, EmptyTaskList) {
   RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunPendingTasks(), "");
   RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunUntilIdle(), "");
 
-  ASSERT_EQ(base::TimeTicks(), now_src_->Now());
+  ASSERT_EQ(base::TimeTicks(), now_src_->NowTicks());
 
   RUN_AND_CHECK_RESULT(
       EXPECT_FALSE, RunUntilTime(base::TimeTicks::FromInternalValue(100)), "");
-  EXPECT_EQ(base::TimeTicks::FromInternalValue(100), now_src_->Now());
+  EXPECT_EQ(base::TimeTicks::FromInternalValue(100), now_src_->NowTicks());
 
   RUN_AND_CHECK_RESULT(
       EXPECT_FALSE, RunForPeriod(base::TimeDelta::FromInternalValue(100)), "");
-  EXPECT_EQ(base::TimeTicks::FromInternalValue(200), now_src_->Now());
+  EXPECT_EQ(base::TimeTicks::FromInternalValue(200), now_src_->NowTicks());
 
   base::Callback<bool(void)> return_true = base::Bind(&ReturnTrue);
   RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunTasksWhile(return_true), "");
 }
 
 TEST_F(OrderedSimpleTaskRunnerTest, RunPendingTasksTimeout) {
   PostTask(1, base::TimeDelta());
   PostTask(2, base::TimeDelta());
   PostTask(3, base::TimeDelta());
   PostTask(4, base::TimeDelta());
@@ skipping 25 matching lines @@
 
 TEST_F(OrderedSimpleTaskRunnerTest, RunUntilTimeout) {
   base::TimeTicks run_to = base::TimeTicks() + base::TimeDelta::FromSeconds(1);
 
   PostTask(1, base::TimeDelta::FromMilliseconds(1));
   PostTask(2, base::TimeDelta::FromMilliseconds(2));
   PostTask(3, base::TimeDelta::FromMilliseconds(3));
   PostTask(4, base::TimeDelta::FromMilliseconds(4));
   PostTask(5, base::TimeDelta::FromMilliseconds(5));
 
-  EXPECT_EQ(base::TimeTicks(), now_src_->Now());
+  EXPECT_EQ(base::TimeTicks(), now_src_->NowTicks());
   task_runner_->SetRunTaskLimit(3);
   RUN_AND_CHECK_RESULT(
       EXPECT_TRUE, RunUntilTime(run_to), "1(1ms) 2(2ms) 3(3ms)");
   EXPECT_EQ(base::TimeTicks() + base::TimeDelta::FromMilliseconds(3),
-            now_src_->Now());
+            now_src_->NowTicks());
 
   task_runner_->SetRunTaskLimit(0);
   RUN_AND_CHECK_RESULT(EXPECT_TRUE, RunUntilTime(run_to), "");
 
   task_runner_->SetRunTaskLimit(100);
   RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunUntilTime(run_to), "4(4ms) 5(5ms)");
-  EXPECT_EQ(run_to, now_src_->Now());
+  EXPECT_EQ(run_to, now_src_->NowTicks());
 }
 
 }  // namespace cc