TaskScheduler: Replace the SchedulerServiceThread with a base::Thread.

base/task_scheduler/scheduler_worker_pool_impl.cc

Index: base/task_scheduler/scheduler_worker_pool_impl.cc
diff --git a/base/task_scheduler/scheduler_worker_pool_impl.cc b/base/task_scheduler/scheduler_worker_pool_impl.cc
index dc040301ca31af4868522b3983b112f293e0d28e..893c7de21438dbbf2adab9a3ffeb4985b8c76151 100644
--- a/base/task_scheduler/scheduler_worker_pool_impl.cc
+++ b/base/task_scheduler/scheduler_worker_pool_impl.cc
@@ -19,7 +19,6 @@
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/stringprintf.h"
-#include "base/task_scheduler/delayed_task_manager.h"
 #include "base/task_scheduler/task_tracker.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread_local.h"
@@ -65,7 +64,7 @@ class SchedulerParallelTaskRunner : public TaskRunner {
     // Post the task as part of a one-off single-task Sequence.
     return worker_pool_->PostTaskWithSequence(
         MakeUnique<Task>(from_here, closure, traits_, delay),
-        make_scoped_refptr(new Sequence), nullptr);
+        make_scoped_refptr(new Sequence), nullptr, delay);
   }
 
   bool RunsTasksOnCurrentThread() const override {
@@ -102,7 +101,7 @@ class SchedulerSequencedTaskRunner : public SequencedTaskRunner {
 
     // Post the task as part of |sequence_|.
     return worker_pool_->PostTaskWithSequence(std::move(task), sequence_,
-                                              nullptr);
+                                              nullptr, delay);
   }
 
   bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
@@ -187,7 +186,7 @@ class SchedulerWorkerPoolImpl::SchedulerSingleThreadTaskRunner :
 
     // Post the task to be executed by |worker_| as part of |sequence_|.
     return worker_pool_->PostTaskWithSequence(std::move(task), sequence_,
-                                              worker_);
+                                              worker_, delay);
   }
 
   bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
@@ -298,12 +297,11 @@ std::unique_ptr<SchedulerWorkerPoolImpl> SchedulerWorkerPoolImpl::Create(
     const SchedulerWorkerPoolParams& params,
     const ReEnqueueSequenceCallback& re_enqueue_sequence_callback,
     TaskTracker* task_tracker,
-    DelayedTaskManager* delayed_task_manager) {
+    scoped_refptr<TaskRunner> service_thread_task_runner) {
   std::unique_ptr<SchedulerWorkerPoolImpl> worker_pool(
-      new SchedulerWorkerPoolImpl(params.name(),
-                                  params.io_restriction(),
-                                  params.suggested_reclaim_time(),
-                                  task_tracker, delayed_task_manager));
+      new SchedulerWorkerPoolImpl(params.name(), params.io_restriction(),
+                                  params.suggested_reclaim_time(), task_tracker,
+                                  std::move(service_thread_task_runner)));
   if (worker_pool->Initialize(params.priority_hint(), params.max_threads(),
                               re_enqueue_sequence_callback)) {
     return worker_pool;
@@ -382,19 +380,24 @@ void SchedulerWorkerPoolImpl::ReEnqueueSequence(
 bool SchedulerWorkerPoolImpl::PostTaskWithSequence(
     std::unique_ptr<Task> task,
     scoped_refptr<Sequence> sequence,
-    SchedulerWorker* worker) {
+    SchedulerWorker* worker,
+    TimeDelta delay) {

[robliao, 2016/10/12 20:55:45]

I would be okay with storing the delay on the task now that we actually need it.
This would simplify the signature of PostTaskWithSequence. This has the benefit
of keeping all topical information like delay and delayed_run_time_ on the task,
removing the need for the DCHECK_EQ below.

Aside: Unsurprisingly, MessageLoop converts this delay into a TimeTicks later
on. Might be worthwhile to consider how we can pipe TimeTicks all the way
through.

[fdoray, 2016/10/13 13:51:29]

Done. Stored the delay with Task and added TODO.

   DCHECK(task);
   DCHECK(sequence);
   DCHECK(!worker || ContainsWorker(workers_, worker));
+  DCHECK_EQ(delay.is_zero(), task->delayed_run_time.is_null());
 
   if (!task_tracker_->WillPostTask(task.get()))
     return false;
 
-  if (task->delayed_run_time.is_null()) {
+  if (delay.is_zero()) {
     PostTaskWithSequenceNow(std::move(task), std::move(sequence), worker);
   } else {
-    delayed_task_manager_->AddDelayedTask(std::move(task), std::move(sequence),
-                                          worker, this);
+    service_thread_task_runner_->PostDelayedTask(
+        FROM_HERE, Bind(&SchedulerWorkerPoolImpl::PostTaskWithSequenceNow,
+                        Unretained(this), Passed(std::move(task)),
+                        std::move(sequence), worker),
+        delay);
   }
 
   return true;
@@ -410,7 +413,7 @@ void SchedulerWorkerPoolImpl::PostTaskWithSequenceNow(
 
   // Confirm that |task| is ready to run (its delayed run time is either null or
   // in the past).
-  DCHECK_LE(task->delayed_run_time, delayed_task_manager_->Now());
+  DCHECK_LE(task->delayed_run_time, TimeTicks::Now());
 
   // Because |worker| belongs to this worker pool, we know that the type
   // of its delegate is SchedulerWorkerDelegateImpl.
@@ -653,7 +656,7 @@ SchedulerWorkerPoolImpl::SchedulerWorkerPoolImpl(
     SchedulerWorkerPoolParams::IORestriction io_restriction,
     const TimeDelta& suggested_reclaim_time,
     TaskTracker* task_tracker,
-    DelayedTaskManager* delayed_task_manager)
+    scoped_refptr<TaskRunner> service_thread_task_runner)
     : name_(name.as_string()),
       io_restriction_(io_restriction),
       suggested_reclaim_time_(suggested_reclaim_time),
@@ -684,9 +687,9 @@ SchedulerWorkerPoolImpl::SchedulerWorkerPoolImpl(
           50,
           HistogramBase::kUmaTargetedHistogramFlag)),
       task_tracker_(task_tracker),
-      delayed_task_manager_(delayed_task_manager) {
+      service_thread_task_runner_(std::move(service_thread_task_runner)) {
   DCHECK(task_tracker_);
-  DCHECK(delayed_task_manager_);
+  DCHECK(service_thread_task_runner_);
 }
 
 bool SchedulerWorkerPoolImpl::Initialize(