Replaced TestNowSource with SimpleTestTickClock.

components/scheduler/child/worker_scheduler_impl_unittest.cc

 // Copyright 2015 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 "components/scheduler/child/worker_scheduler_impl.h"
 
 #include "base/callback.h"
 #include "base/strings/stringprintf.h"
+#include "base/test/simple_test_tick_clock.h"
 #include "cc/test/ordered_simple_task_runner.h"
-#include "cc/test/test_now_source.h"
 #include "components/scheduler/child/nestable_task_runner_for_test.h"
 #include "components/scheduler/child/scheduler_message_loop_delegate.h"
 #include "components/scheduler/child/test_time_source.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::ElementsAreArray;
 
 namespace scheduler {
 
 namespace {
 void NopTask() {
 }
 
 int TimeTicksToIntMs(const base::TimeTicks& time) {
   return static_cast<int>((time - base::TimeTicks()).InMilliseconds());
 }
 
-void WakeUpTask(std::vector<std::string>* timeline, cc::TestNowSource* clock) {
+void WakeUpTask(std::vector<std::string>* timeline,
+                base::SimpleTestTickClock* clock) {
   if (timeline) {
-    timeline->push_back(base::StringPrintf("run WakeUpTask @ %d",
-                                           TimeTicksToIntMs(clock->Now())));
+    timeline->push_back(base::StringPrintf(
+        "run WakeUpTask @ %d", TimeTicksToIntMs(clock->NowTicks())));
   }
 }
 
 void RecordTimelineTask(std::vector<std::string>* timeline,
-                        cc::TestNowSource* clock) {
+                        base::SimpleTestTickClock* clock) {
   timeline->push_back(base::StringPrintf("run RecordTimelineTask @ %d",
-                                         TimeTicksToIntMs(clock->Now())));
+                                         TimeTicksToIntMs(clock->NowTicks())));
 }
 
 void AppendToVectorTestTask(std::vector<std::string>* vector,
                             std::string value) {
   vector->push_back(value);
 }
 
 void AppendToVectorIdleTestTask(std::vector<std::string>* vector,
                                 std::string value,
                                 base::TimeTicks deadline) {
   AppendToVectorTestTask(vector, value);
 }
 
 void TimelineIdleTestTask(std::vector<std::string>* timeline,
                           base::TimeTicks deadline) {
   timeline->push_back(base::StringPrintf("run TimelineIdleTestTask deadline %d",
                                          TimeTicksToIntMs(deadline)));
 }
 
 };  // namespace
 
 class WorkerSchedulerImplForTest : public WorkerSchedulerImpl {
  public:
   WorkerSchedulerImplForTest(
       scoped_refptr<NestableSingleThreadTaskRunner> main_task_runner,
-      scoped_refptr<cc::TestNowSource> clock_)
+      base::SimpleTestTickClock* clock_)
       : WorkerSchedulerImpl(main_task_runner),
         clock_(clock_),
         timeline_(nullptr) {}
 
   void RecordTimelineEvents(std::vector<std::string>* timeline) {
     timeline_ = timeline;
   }
 
  private:
   bool CanEnterLongIdlePeriod(
       base::TimeTicks now,
       base::TimeDelta* next_long_idle_period_delay_out) override {
     if (timeline_) {
       timeline_->push_back(base::StringPrintf("CanEnterLongIdlePeriod @ %d",
                                               TimeTicksToIntMs(now)));
     }
     return WorkerSchedulerImpl::CanEnterLongIdlePeriod(
         now, next_long_idle_period_delay_out);
   }
 
   void IsNotQuiescent() override {
     if (timeline_) {
-      timeline_->push_back(base::StringPrintf("IsNotQuiescent @ %d",
-                                              TimeTicksToIntMs(clock_->Now())));
+      timeline_->push_back(base::StringPrintf(
+          "IsNotQuiescent @ %d", TimeTicksToIntMs(clock_->NowTicks())));
     }
     WorkerSchedulerImpl::IsNotQuiescent();
   }
 
-  scoped_refptr<cc::TestNowSource> clock_;
+  base::SimpleTestTickClock* clock_;
   std::vector<std::string>* timeline_;  // NOT OWNED
 };
 
 class WorkerSchedulerImplTest : public testing::Test {
  public:
   WorkerSchedulerImplTest()
-      : clock_(cc::TestNowSource::Create(5000)),
-        mock_task_runner_(new cc::OrderedSimpleTaskRunner(clock_, true)),
-        nestable_task_runner_(
-            NestableTaskRunnerForTest::Create(mock_task_runner_)),
-        scheduler_(
-            new WorkerSchedulerImplForTest(nestable_task_runner_, clock_)),
-        timeline_(nullptr) {
+      : clock_(new base::SimpleTestTickClock()), timeline_(nullptr) {
+    clock_->Advance(base::TimeDelta::FromInternalValue(5000));

[Sami, 2015/05/29 14:00:58]

Ditto about the starting time value.

[Ankur Verma, 2015/06/03 14:56:10]

Have'nt changed starting values yet as per mithro's explaination.

+    mock_task_runner_ = new cc::OrderedSimpleTaskRunner(clock_, true);
+    nestable_task_runner_ =
+        NestableTaskRunnerForTest::Create(mock_task_runner_);
+    scheduler_ = make_scoped_ptr(
+        new WorkerSchedulerImplForTest(nestable_task_runner_, clock_));
     scheduler_->GetSchedulerHelperForTesting()->SetTimeSourceForTesting(
         make_scoped_ptr(new TestTimeSource(clock_)));
     scheduler_->GetSchedulerHelperForTesting()
         ->GetTaskQueueManagerForTesting()
         ->SetTimeSourceForTesting(make_scoped_ptr(new TestTimeSource(clock_)));
   }
 
   ~WorkerSchedulerImplTest() override {}
 
   void TearDown() override {
     // Check that all tests stop posting tasks.
     while (mock_task_runner_->RunUntilIdle()) {
     }
   }
 
   void Init() {
     scheduler_->Init();
     default_task_runner_ = scheduler_->DefaultTaskRunner();
     idle_task_runner_ = scheduler_->IdleTaskRunner();
     timeline_ = nullptr;
   }
 
   void RecordTimelineEvents(std::vector<std::string>* timeline) {
     timeline_ = timeline;
     scheduler_->RecordTimelineEvents(timeline);
   }
 
   void RunUntilIdle() {
     if (timeline_) {
-      timeline_->push_back(base::StringPrintf("RunUntilIdle begin @ %d",
-                                              TimeTicksToIntMs(clock_->Now())));
+      timeline_->push_back(base::StringPrintf(
+          "RunUntilIdle begin @ %d", TimeTicksToIntMs(clock_->NowTicks())));
     }
     mock_task_runner_->RunUntilIdle();
     if (timeline_) {
-      timeline_->push_back(base::StringPrintf("RunUntilIdle end @ %d",
-                                              TimeTicksToIntMs(clock_->Now())));
+      timeline_->push_back(base::StringPrintf(
+          "RunUntilIdle end @ %d", TimeTicksToIntMs(clock_->NowTicks())));
     }
   }
 
   void InitAndPostDelayedWakeupTask() {
     Init();
     // WorkerSchedulerImpl::Init causes a delayed task to be posted on the
     // after wakeup control runner.  We need a task to wake the system up
     // AFTER the delay for this has expired.
     default_task_runner_->PostDelayedTask(
         FROM_HERE, base::Bind(&WakeUpTask, base::Unretained(timeline_),
-                              base::Unretained(clock_.get())),
+                              base::Unretained(clock_)),
         base::TimeDelta::FromMilliseconds(100));
   }
 
   // Helper for posting several tasks of specific types. |task_descriptor| is a
   // string with space delimited task identifiers. The first letter of each
   // task identifier specifies the task type:
   // - 'D': Default task
   // - 'I': Idle task
   void PostTestTasks(std::vector<std::string>* run_order,
                      const std::string& task_descriptor) {
@@ skipping 16 matching lines @@
       }
     }
   }
 
   static base::TimeDelta maximum_idle_period_duration() {
     return base::TimeDelta::FromMilliseconds(
         IdleHelper::kMaximumIdlePeriodMillis);
   }
 
  protected:
-  scoped_refptr<cc::TestNowSource> clock_;
+  base::SimpleTestTickClock* clock_;

[Sami, 2015/05/29 14:00:58]

Ditto about scoped_ptr.

[Ankur Verma, 2015/06/03 14:56:10]

Done.

   // Only one of mock_task_runner_ or message_loop_ will be set.
   scoped_refptr<cc::OrderedSimpleTaskRunner> mock_task_runner_;
 
   scoped_refptr<NestableSingleThreadTaskRunner> nestable_task_runner_;
   scoped_ptr<WorkerSchedulerImplForTest> scheduler_;
   scoped_refptr<base::SingleThreadTaskRunner> default_task_runner_;
   scoped_refptr<SingleThreadIdleTaskRunner> idle_task_runner_;
   std::vector<std::string>* timeline_;  // NOT OWNED
 
   DISALLOW_COPY_AND_ASSIGN(WorkerSchedulerImplTest);
@@ skipping 75 matching lines @@
 
 TEST_F(WorkerSchedulerImplTest, TestIdleDeadlineWithPendingDelayedTask) {
   std::vector<std::string> timeline;
   RecordTimelineEvents(&timeline);
   InitAndPostDelayedWakeupTask();
 
   timeline.push_back("Post delayed and idle tasks");
   // Post a delayed task timed to occur mid way during the long idle period.
   default_task_runner_->PostDelayedTask(
       FROM_HERE, base::Bind(&RecordTimelineTask, base::Unretained(&timeline),
-                            base::Unretained(clock_.get())),
+                            base::Unretained(clock_)),
       base::TimeDelta::FromMilliseconds(420));
   idle_task_runner_->PostIdleTask(FROM_HERE,
                                   base::Bind(&TimelineIdleTestTask, &timeline));
 
   RunUntilIdle();
 
   std::string expected_timeline[] = {
       "CanEnterLongIdlePeriod @ 5",
       "Post delayed and idle tasks",
       "IsNotQuiescent @ 105",
       "CanEnterLongIdlePeriod @ 405",
       "run TimelineIdleTestTask deadline 425",  // Note the short 20ms deadline.
       "CanEnterLongIdlePeriod @ 425",
       "run RecordTimelineTask @ 425"};
 
   EXPECT_THAT(timeline, ElementsAreArray(expected_timeline));
 }
 
 TEST_F(WorkerSchedulerImplTest,
        TestIdleDeadlineWithPendingDelayedTaskFarInTheFuture) {
   std::vector<std::string> timeline;
   RecordTimelineEvents(&timeline);
   InitAndPostDelayedWakeupTask();
 
   timeline.push_back("Post delayed and idle tasks");
   // Post a delayed task timed to occur well after the long idle period.
   default_task_runner_->PostDelayedTask(
       FROM_HERE, base::Bind(&RecordTimelineTask, base::Unretained(&timeline),
-                            base::Unretained(clock_.get())),
+                            base::Unretained(clock_)),
       base::TimeDelta::FromMilliseconds(1000));
   idle_task_runner_->PostIdleTask(FROM_HERE,
                                   base::Bind(&TimelineIdleTestTask, &timeline));
 
   RunUntilIdle();
 
   std::string expected_timeline[] = {
       "CanEnterLongIdlePeriod @ 5",
       "Post delayed and idle tasks",
       "IsNotQuiescent @ 105",
@@ skipping 48 matching lines @@
 
   std::vector<std::string> timeline;
   RecordTimelineEvents(&timeline);
 
   // The scheduler should not run the initiate_next_long_idle_period task if
   // there are no idle tasks and no other task woke up the scheduler, thus
   // the idle period deadline shouldn't update at the end of the current long
   // idle period.
   base::TimeTicks idle_period_deadline =
       scheduler_->CurrentIdleTaskDeadlineForTesting();
-  clock_->AdvanceNow(maximum_idle_period_duration());
+  clock_->Advance(maximum_idle_period_duration());
   RunUntilIdle();
 
   base::TimeTicks new_idle_period_deadline =
       scheduler_->CurrentIdleTaskDeadlineForTesting();
   EXPECT_EQ(idle_period_deadline, new_idle_period_deadline);
 
   // Posting a after-wakeup idle task also shouldn't wake the scheduler or
   // initiate the next long idle period.
   timeline.push_back("PostIdleTaskAfterWakeup");
   idle_task_runner_->PostIdleTaskAfterWakeup(
       FROM_HERE, base::Bind(&TimelineIdleTestTask, &timeline));
   RunUntilIdle();
   new_idle_period_deadline = scheduler_->CurrentIdleTaskDeadlineForTesting();
 
   // Running a normal task should initiate a new long idle period after waiting
   // 300ms for quiescence.
   timeline.push_back("Post RecordTimelineTask");
   default_task_runner_->PostTask(
       FROM_HERE, base::Bind(&RecordTimelineTask, base::Unretained(&timeline),
-                            base::Unretained(clock_.get())));
+                            base::Unretained(clock_)));
   RunUntilIdle();
 
   std::string expected_timeline[] = {
       "RunUntilIdle begin @ 55",
       "RunUntilIdle end @ 55",
       "PostIdleTaskAfterWakeup",
       "RunUntilIdle begin @ 55",  // NOTE idle task doesn't run till later.
       "RunUntilIdle end @ 55",
       "Post RecordTimelineTask",
       "RunUntilIdle begin @ 55",
       "run RecordTimelineTask @ 55",
       "IsNotQuiescent @ 55",  // NOTE we have to wait for quiescence.
       "CanEnterLongIdlePeriod @ 355",
       "run TimelineIdleTestTask deadline 405",
       "CanEnterLongIdlePeriod @ 405",
       "RunUntilIdle end @ 455"};
 
   EXPECT_THAT(timeline, ElementsAreArray(expected_timeline));
 }
 
 }  // namespace scheduler