Scheduler/child/TimeSource could be replaced with base/time/DefaultTickClock.

components/scheduler/child/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 "components/scheduler/child/scheduler_helper.h"
 
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "components/scheduler/child/nestable_single_thread_task_runner.h"
-#include "components/scheduler/child/time_source.h"
 
 namespace scheduler {
 
 SchedulerHelper::SchedulerHelper(
     scoped_refptr<NestableSingleThreadTaskRunner> main_task_runner,
     const char* tracing_category,
     const char* disabled_by_default_tracing_category,
     size_t total_task_queue_count)
     : task_queue_selector_(new PrioritizingTaskQueueSelector()),
       task_queue_manager_(
           new TaskQueueManager(total_task_queue_count,
                                main_task_runner,
                                task_queue_selector_.get(),
                                disabled_by_default_tracing_category)),
       quiescence_monitored_task_queue_mask_(
           ((1ull << total_task_queue_count) - 1ull) &
           ~(1ull << QueueId::CONTROL_TASK_QUEUE) &
           ~(1ull << QueueId::CONTROL_TASK_AFTER_WAKEUP_QUEUE)),
       control_task_runner_(
           task_queue_manager_->TaskRunnerForQueue(QueueId::CONTROL_TASK_QUEUE)),
       control_after_wakeup_task_runner_(task_queue_manager_->TaskRunnerForQueue(
           QueueId::CONTROL_TASK_AFTER_WAKEUP_QUEUE)),
       default_task_runner_(
           task_queue_manager_->TaskRunnerForQueue(QueueId::DEFAULT_TASK_QUEUE)),
-      time_source_(new TimeSource),
+      time_source_(new base::DefaultTickClock),
       tracing_category_(tracing_category),
       disabled_by_default_tracing_category_(
           disabled_by_default_tracing_category) {
   DCHECK_GE(total_task_queue_count,
             static_cast<size_t>(QueueId::TASK_QUEUE_COUNT));
   task_queue_selector_->SetQueuePriority(
       QueueId::CONTROL_TASK_QUEUE,
       PrioritizingTaskQueueSelector::CONTROL_PRIORITY);
   task_queue_manager_->SetWakeupPolicy(
       QueueId::CONTROL_TASK_QUEUE,
@@ skipping 36 matching lines @@
 SchedulerHelper::ControlTaskRunner() {
   return control_task_runner_;
 }
 
 scoped_refptr<base::SingleThreadTaskRunner>
 SchedulerHelper::ControlAfterWakeUpTaskRunner() {
   return control_after_wakeup_task_runner_;
 }
 
 void SchedulerHelper::SetTimeSourceForTesting(
-    scoped_ptr<TimeSource> time_source) {
+    scoped_ptr<base::DefaultTickClock> time_source) {
   CheckOnValidThread();
   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 time_source_->Now();
+  return time_source_->NowTicks();
 }
 
 scoped_refptr<base::SingleThreadTaskRunner> SchedulerHelper::TaskRunnerForQueue(
     size_t queue_index) const {
   CheckOnValidThread();
   return task_queue_manager_->TaskRunnerForQueue(queue_index);
 }
 
 base::TimeTicks SchedulerHelper::NextPendingDelayedTaskRunTime() const {
   CheckOnValidThread();
@@ skipping 91 matching lines @@
 }
 
 void SchedulerHelper::RemoveTaskObserver(
     base::MessageLoop::TaskObserver* task_observer) {
   CheckOnValidThread();
   if (task_queue_manager_)
     task_queue_manager_->RemoveTaskObserver(task_observer);
 }
 
 }  // namespace scheduler