Fix computation of runtime for throttled tasks

components/scheduler/base/task_queue_impl.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/base/task_queue_impl.h"
 
 #include "components/scheduler/base/task_queue_manager.h"
 #include "components/scheduler/base/task_queue_manager_delegate.h"
 #include "components/scheduler/base/time_domain.h"
 #include "components/scheduler/base/work_queue.h"
@@ skipping 168 matching lines @@
     TaskType task_type) {
   DCHECK_GT(delay, base::TimeDelta());
   if (base::PlatformThread::CurrentId() == thread_id_) {
     // Lock-free fast path for delayed tasks posted from the main thread.
     if (!main_thread_only().task_queue_manager)
       return false;
 
     EnqueueOrder sequence_number =
         main_thread_only().task_queue_manager->GetNextSequenceNumber();
 
-    base::TimeTicks now = main_thread_only().time_domain->Now();
+    base::TimeTicks time_domain_now = main_thread_only().time_domain->Now();
+    base::TimeTicks time_domain_delayed_run_time =
+        main_thread_only().time_domain->ComputeDelayedRunTime(time_domain_now,
+                                                              delay);
     PushOntoDelayedIncomingQueueFromMainThread(
-        Task(from_here, task, now + delay, sequence_number,
+        Task(from_here, task, time_domain_delayed_run_time, sequence_number,
              task_type != TaskType::NON_NESTABLE),
-        now);
+        time_domain_now);
   } else {
     // 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 to be false in future, we may need to revisit this.
     base::AutoLock lock(any_thread_lock_);
     if (!any_thread().task_queue_manager)
       return false;
 
     EnqueueOrder sequence_number =
         any_thread().task_queue_manager->GetNextSequenceNumber();
 
+    base::TimeTicks time_domain_now = any_thread().time_domain->Now();
+    base::TimeTicks time_domain_delayed_run_time =
+        any_thread().time_domain->ComputeDelayedRunTime(time_domain_now, delay);
     PushOntoDelayedIncomingQueueLocked(
-        Task(from_here, task, any_thread().time_domain->Now() + delay,
-             sequence_number, task_type != TaskType::NON_NESTABLE));
+        Task(from_here, task, time_domain_delayed_run_time, sequence_number,
+             task_type != TaskType::NON_NESTABLE));
   }
   return true;
 }
 
 void TaskQueueImpl::PushOntoDelayedIncomingQueueFromMainThread(
     Task&& pending_task,
     base::TimeTicks now) {
   main_thread_only().task_queue_manager->DidQueueTask(pending_task);
 
   // Schedule a later call to MoveReadyDelayedTasksToDelayedWorkQueue.
@@ skipping 454 matching lines @@
   state->SetBoolean("nestable", task.nestable);
   state->SetBoolean("is_high_res", task.is_high_res);
   state->SetDouble(
       "delayed_run_time",
       (task.delayed_run_time - base::TimeTicks()).InMicroseconds() / 1000.0L);
   state->EndDictionary();
 }
 
 }  // namespace internal
 }  // namespace scheduler