TaskScheduler: TimeDelta instead of TimeTicks in Task's constructor.

base/task_scheduler/scheduler_thread_pool_impl.cc

 // Copyright 2016 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 "base/task_scheduler/scheduler_thread_pool_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 23 matching lines @@
   SchedulerParallelTaskRunner(const TaskTraits& traits,
                               SchedulerThreadPool* thread_pool)
       : traits_(traits), thread_pool_(thread_pool) {}
 
   // TaskRunner:
   bool PostDelayedTask(const tracked_objects::Location& from_here,
                        const Closure& closure,
                        TimeDelta delay) override {
     // Post the task as part of a one-off single-task Sequence.
     return thread_pool_->PostTaskWithSequence(
-        WrapUnique(
-            new Task(from_here, closure, traits_,
-                     delay.is_zero() ? TimeTicks() : TimeTicks::Now() + delay)),
+        WrapUnique(new Task(from_here, closure, traits_, delay)),
         make_scoped_refptr(new Sequence));
   }
 
   bool RunsTasksOnCurrentThread() const override {
     return tls_current_thread_pool.Get().Get() == thread_pool_;
   }
 
  private:
   ~SchedulerParallelTaskRunner() override = default;
 
@@ skipping 12 matching lines @@
   SchedulerSequencedTaskRunner(const TaskTraits& traits,
                                SchedulerThreadPool* thread_pool)
       : traits_(traits), thread_pool_(thread_pool) {}
 
   // SequencedTaskRunner:
   bool PostDelayedTask(const tracked_objects::Location& from_here,
                        const Closure& closure,
                        TimeDelta delay) override {
     // Post the task as part of |sequence|.
     return thread_pool_->PostTaskWithSequence(
-        WrapUnique(
-            new Task(from_here, closure, traits_,
-                     delay.is_zero() ? TimeTicks() : TimeTicks::Now() + delay)),
-        sequence_);
+        WrapUnique(new Task(from_here, closure, traits_, delay)), sequence_);
   }
 
   bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
                                   const Closure& closure,
                                   base::TimeDelta delay) override {
     // Tasks are never nested within the task scheduler.
     return PostDelayedTask(from_here, closure, delay);
   }
 
   bool RunsTasksOnCurrentThread() const override {
@@ skipping 256 matching lines @@
   AutoSchedulerLock auto_lock(idle_worker_threads_stack_lock_);
   idle_worker_threads_stack_.Push(worker_thread);
   DCHECK_LE(idle_worker_threads_stack_.Size(), worker_threads_.size());
 
   if (idle_worker_threads_stack_.Size() == worker_threads_.size())
     idle_worker_threads_stack_cv_for_testing_->Broadcast();
 }
 
 }  // namespace internal
 }  // namespace base