Make blink platform time consistent with the timer virtual time

components/scheduler/base/task_queue_manager.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 "components/scheduler/base/task_queue_manager.h"
 
 #include <queue>
 #include <set>
 
 #include "base/bind.h"
@@ skipping 153 matching lines @@
     newly_updatable_.pop_back();
   }
 }
 
 void TaskQueueManager::UpdateWorkQueues(
     bool should_trigger_wakeup,
     const internal::TaskQueueImpl::Task* previous_task) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   TRACE_EVENT0(disabled_by_default_tracing_category_,
                "TaskQueueManager::UpdateWorkQueues");
-  internal::LazyNow lazy_now(tick_clock());
+  internal::LazyNow lazy_now(delegate().get());
 
   // Move any ready delayed tasks into the incomming queues.
   WakeupReadyDelayedQueues(&lazy_now);
 
   MoveNewlyUpdatableQueuesIntoUpdatableQueueSet();
 
   auto iter = updatable_queue_set_.begin();
   while (iter != updatable_queue_set_.end()) {
     internal::TaskQueueImpl* queue = *iter++;
     // NOTE Update work queue may erase itself from |updatable_queue_set_|.
     // This is fine, erasing an element won't invalidate any interator, as long
     // as the iterator isn't the element being delated.
     if (queue->work_queue().empty())
       queue->UpdateWorkQueue(&lazy_now, should_trigger_wakeup, previous_task);
   }
 }
 
 void TaskQueueManager::ScheduleDelayedWorkTask(
     scoped_refptr<internal::TaskQueueImpl> queue,
     base::TimeTicks delayed_run_time) {
-  internal::LazyNow lazy_now(tick_clock());
+  internal::LazyNow lazy_now(delegate().get());
   ScheduleDelayedWork(queue.get(), delayed_run_time, &lazy_now);
 }
 
 void TaskQueueManager::ScheduleDelayedWork(internal::TaskQueueImpl* queue,
                                            base::TimeTicks delayed_run_time,
                                            internal::LazyNow* lazy_now) {
   if (!delegate_->BelongsToCurrentThread()) {
     // NOTE posting a delayed task from a different thread is not expected to be
     // common. This pathway is less optimal than perhaps it could be because
     // it causes two main thread tasks to be run.  Should this assumption prove
@@ skipping 187 matching lines @@
   DCHECK(main_thread_checker_.CalledOnValidThread());
   task_observers_.RemoveObserver(task_observer);
 }
 
 bool TaskQueueManager::GetAndClearSystemIsQuiescentBit() {
   bool task_was_run = task_was_run_on_quiescence_monitored_queue_;
   task_was_run_on_quiescence_monitored_queue_ = false;
   return !task_was_run;
 }
 
-base::TickClock* TaskQueueManager::tick_clock() const {
-  return delegate_.get();
+const scoped_refptr<TaskQueueManagerDelegate>& TaskQueueManager::delegate()
+    const {
+  return delegate_;
 }
 
 int TaskQueueManager::GetNextSequenceNumber() {
   return task_sequence_num_.GetNext();
 }
 
 scoped_refptr<base::trace_event::ConvertableToTraceFormat>
 TaskQueueManager::AsValueWithSelectorResult(
     bool should_run,
     internal::TaskQueueImpl* selected_queue) const {
@@ skipping 18 matching lines @@
 }
 
 void TaskQueueManager::OnTaskQueueEnabled(internal::TaskQueueImpl* queue) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   // Only schedule DoWork if there's something to do.
   if (!queue->work_queue().empty())
     MaybePostDoWorkOnMainRunner();
 }
 
 }  // namespace scheduler