Remove dependency on cc::TestNowSource from scheduler code

content/child/scheduler/scheduler_helper.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 "content/child/scheduler/scheduler_helper.h"
 
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "content/child/scheduler/nestable_single_thread_task_runner.h"
 #include "content/child/scheduler/prioritizing_task_queue_selector.h"
+#include "content/child/scheduler/time_source.h"
 
 namespace content {
 
 SchedulerHelper::SchedulerHelper(
     scoped_refptr<NestableSingleThreadTaskRunner> main_task_runner,
     SchedulerHelperDelegate* scheduler_helper_delegate,
     const char* tracing_category,
     const char* disabled_by_default_tracing_category,
     const char* idle_period_tracing_name,
     size_t total_task_queue_count,
@@ skipping 12 matching lines @@
           QueueId::CONTROL_TASK_AFTER_WAKEUP_QUEUE)),
       default_task_runner_(
           task_queue_manager_->TaskRunnerForQueue(QueueId::DEFAULT_TASK_QUEUE)),
       quiescence_monitored_task_queue_mask_(
           ((1ull << total_task_queue_count) - 1ull) &
           ~(1ull << QueueId::IDLE_TASK_QUEUE) &
           ~(1ull << QueueId::CONTROL_TASK_QUEUE) &
           ~(1ull << QueueId::CONTROL_TASK_AFTER_WAKEUP_QUEUE)),
       required_quiescence_duration_before_long_idle_period_(
           required_quiescence_duration_before_long_idle_period),
+      time_source_(new TimeSource),
       tracing_category_(tracing_category),
       disabled_by_default_tracing_category_(
           disabled_by_default_tracing_category),
       idle_period_tracing_name_(idle_period_tracing_name),
       weak_factory_(this) {
   DCHECK_GE(total_task_queue_count,
             static_cast<size_t>(QueueId::TASK_QUEUE_COUNT));
   weak_scheduler_ptr_ = weak_factory_.GetWeakPtr();
   end_idle_period_closure_.Reset(
       base::Bind(&SchedulerHelper::EndIdlePeriod, weak_scheduler_ptr_));
@@ skipping 252 matching lines @@
 }
 
 bool SchedulerHelper::CanExceedIdleDeadlineIfRequired() const {
   TRACE_EVENT0(tracing_category_, "CanExceedIdleDeadlineIfRequired");
   CheckOnValidThread();
   return idle_period_state_ ==
          IdlePeriodState::IN_LONG_IDLE_PERIOD_WITH_MAX_DEADLINE;
 }
 
 void SchedulerHelper::SetTimeSourceForTesting(
-    scoped_refptr<cc::TestNowSource> time_source) {
+    scoped_ptr<TimeSource> time_source) {
   CheckOnValidThread();
-  time_source_ = time_source;
-  task_queue_manager_->SetTimeSourceForTesting(time_source);
+  time_source_ = time_source.Pass();
 }
 
 void SchedulerHelper::SetWorkBatchSizeForTesting(size_t work_batch_size) {
   CheckOnValidThread();
   task_queue_manager_->SetWorkBatchSize(work_batch_size);
 }
 
+TaskQueueManager* SchedulerHelper::GetTaskQueueManagerForTesting() {
+  CheckOnValidThread();
+  return task_queue_manager_.get();
+}
+
 base::TimeTicks SchedulerHelper::Now() const {
-  return UNLIKELY(time_source_) ? time_source_->Now() : base::TimeTicks::Now();
+  return time_source_->Now();
 }
 
 SchedulerHelper::IdlePeriodState
 SchedulerHelper::SchedulerIdlePeriodState() const {
   return idle_period_state_;
 }
 
 PrioritizingTaskQueueSelector*
 SchedulerHelper::SchedulerTaskQueueSelector() const {
   return task_queue_selector_.get();
@@ skipping 60 matching lines @@
 }
 
 void SchedulerHelper::RemoveTaskObserver(
     base::MessageLoop::TaskObserver* task_observer) {
   CheckOnValidThread();
   if (task_queue_manager_)
     task_queue_manager_->RemoveTaskObserver(task_observer);
 }
 
 }  // namespace content