Remove dependency on cc::TestNowSource from scheduler code

content/child/scheduler/task_queue_manager_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 "content/child/scheduler/task_queue_manager.h"
 
 #include "base/threading/thread.h"
 #include "cc/test/ordered_simple_task_runner.h"
 #include "cc/test/test_now_source.h"
 #include "content/child/scheduler/nestable_task_runner_for_test.h"
 #include "content/child/scheduler/scheduler_message_loop_delegate.h"
 #include "content/child/scheduler/task_queue_selector.h"
+#include "content/test/test_time_source.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using testing::ElementsAre;
 using testing::_;
 
 namespace content {
 namespace {
 
 class SelectorForTest : public TaskQueueSelector {
  public:
@@ skipping 93 matching lines @@
   };
 
   void Initialize(size_t num_queues, SelectorType type) {
     now_src_ = cc::TestNowSource::Create(1000);
     test_task_runner_ =
         make_scoped_refptr(new cc::OrderedSimpleTaskRunner(now_src_, false));
     selector_ = make_scoped_ptr(createSelectorForTest(type));
     manager_ = make_scoped_ptr(new TaskQueueManager(
         num_queues, NestableTaskRunnerForTest::Create(test_task_runner_.get()),
         selector_.get(), "test.scheduler"));
-    manager_->SetTimeSourceForTesting(now_src_);
+    manager_->SetTimeSourceForTesting(
+        make_scoped_ptr(new TestTimeSource(now_src_)));
 
     EXPECT_EQ(num_queues, selector_->work_queues().size());
   }
 
   void InitializeWithRealMessageLoop(size_t num_queues, SelectorType type) {
     message_loop_.reset(new base::MessageLoop());
     selector_ = make_scoped_ptr(createSelectorForTest(type));
     manager_ = make_scoped_ptr(new TaskQueueManager(
         num_queues, SchedulerMessageLoopDelegate::Create(message_loop_.get()),
         selector_.get(), "test.scheduler"));
@@ skipping 79 matching lines @@
   EXPECT_THAT(run_order, ElementsAre(1, 3, 5, 2, 4, 6));
 }
 
 void NopTask() {
 }
 
 TEST_F(TaskQueueManagerTest, NowNotCalledWhenThereAreNoDelayedTasks) {
   Initialize(3u, SelectorType::Explicit);
 
   scoped_refptr<cc::TestNowSource> now_src = cc::TestNowSource::Create(1000);
-  manager_->SetTimeSourceForTesting(now_src);
+  manager_->SetTimeSourceForTesting(
+      make_scoped_ptr(new TestTimeSource(now_src)));
 
   scoped_refptr<base::SingleThreadTaskRunner> runners[3] = {
       manager_->TaskRunnerForQueue(0),
       manager_->TaskRunnerForQueue(1),
       manager_->TaskRunnerForQueue(2)};
 
   selector_->AppendQueueToService(0);
   selector_->AppendQueueToService(1);
   selector_->AppendQueueToService(2);
   selector_->AppendQueueToService(0);
@@ skipping 743 matching lines @@
   scoped_refptr<base::SingleThreadTaskRunner> runner =
       manager_->TaskRunnerForQueue(0);
   EXPECT_TRUE(runner->RunsTasksOnCurrentThread());
   manager_.reset();
   EXPECT_TRUE(runner->RunsTasksOnCurrentThread());
 }
 
 TEST_F(TaskQueueManagerTest, NextPendingDelayedTaskRunTime) {
   scoped_refptr<cc::TestNowSource> clock(cc::TestNowSource::Create());
   Initialize(2u, SelectorType::Explicit);
-  manager_->SetTimeSourceForTesting(clock);
+  manager_->SetTimeSourceForTesting(make_scoped_ptr(new TestTimeSource(clock)));
 
   scoped_refptr<base::SingleThreadTaskRunner> runners[2] = {
       manager_->TaskRunnerForQueue(0), manager_->TaskRunnerForQueue(1)};
 
   // With no delayed tasks.
   EXPECT_TRUE(manager_->NextPendingDelayedTaskRunTime().is_null());
 
   // With a non-delayed task.
   runners[0]->PostTask(FROM_HERE, base::Bind(&NopTask));
   EXPECT_TRUE(manager_->NextPendingDelayedTaskRunTime().is_null());
@@ skipping 93 matching lines @@
 TEST_F(TaskQueueManagerTest, GetAndClearTaskWasRunBitmap_ManyQueues) {
   Initialize(64u, SelectorType::Automatic);
 
   manager_->TaskRunnerForQueue(63)->PostTask(FROM_HERE, base::Bind(&NopTask));
   test_task_runner_->RunUntilIdle();
   EXPECT_EQ(1ull << 63, manager_->GetAndClearTaskWasRunOnQueueBitmap());
 }
 
 }  // namespace
 }  // namespace content