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

base/task_scheduler/delayed_task_manager.cc

Index: base/task_scheduler/delayed_task_manager.cc
diff --git a/base/task_scheduler/delayed_task_manager.cc b/base/task_scheduler/delayed_task_manager.cc
deleted file mode 100644
index d648b9d4628fab6324b9e8474daffa607692f0d8..0000000000000000000000000000000000000000
--- a/base/task_scheduler/delayed_task_manager.cc
+++ /dev/null
@@ -1,153 +0,0 @@
-// 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/delayed_task_manager.h"
-
-#include <utility>
-
-#include "base/logging.h"
-#include "base/task_scheduler/scheduler_worker_pool.h"
-
-namespace base {
-namespace internal {
-
-struct DelayedTaskManager::DelayedTask {
-  DelayedTask(std::unique_ptr<Task> task,
-              scoped_refptr<Sequence> sequence,
-              SchedulerWorker* worker,
-              SchedulerWorkerPool* worker_pool,
-              uint64_t index)
-      : task(std::move(task)),
-        sequence(std::move(sequence)),
-        worker(worker),
-        worker_pool(worker_pool),
-        index(index) {}
-
-  DelayedTask(DelayedTask&& other) = default;
-
-  ~DelayedTask() = default;
-
-  DelayedTask& operator=(DelayedTask&& other) = default;
-
-  // |task| will be posted to |worker_pool| with |sequence| and |worker|
-  // when it becomes ripe for execution.
-  std::unique_ptr<Task> task;
-  scoped_refptr<Sequence> sequence;
-  SchedulerWorker* worker;
-  SchedulerWorkerPool* worker_pool;
-
-  // Ensures that tasks that have the same |delayed_run_time| are sorted
-  // according to the order in which they were added to the DelayedTaskManager.
-  uint64_t index;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(DelayedTask);
-};
-
-DelayedTaskManager::DelayedTaskManager(
-    const Closure& on_delayed_run_time_updated)
-    : on_delayed_run_time_updated_(on_delayed_run_time_updated) {
-  DCHECK(!on_delayed_run_time_updated_.is_null());
-}
-
-DelayedTaskManager::~DelayedTaskManager() = default;
-
-void DelayedTaskManager::AddDelayedTask(std::unique_ptr<Task> task,

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

An alternative implementation would be to route the service thread here and keep
the Delayed Task Manager. That way the SchedulerWorkerPools only have to know
about their own threads.

This has the benefit of keeping all of the policy about delayed tasks here (and
makes it an easy place to calculate metrics over the delayed tasks.

Thoughts?

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

Instead of passing a TaskRunner to SchedulerWorkerPools, we could pass an opaque
Callback that posts a delayed task to the service thread TaskRunner?

But SchedulerWorkerPools will have to know about the service thread TaskRunner
anyways to support FileDescriptorWatcher::WatchReadable/Writable [1].

I'm hesitant to keep DelayedTaskManager (153 + 88 LOC, extra lock, extra
priority queue) just to have all the policy about delayed tasks in one place. I
think we should delete it for now and restore it later if necessary (e.g. if we
introduce a new metric or a new policy about delayed tasks).

[1] FileDescriptorWatcher relies on a MessageLoopForIO pointer stored in TLS (I
intend to replace this with a TaskRunner pointer).

[robliao, 2016/10/13 17:03:39]

We wouldn't keep around everything in the DelayedTaskManager. It would simply
forward tasks to the service thread task runner. The locks and queue goes away.
We would simply use the abstraction we have a little longer until we determine
it's no longer necessary.

I suspect that its probably we would like to gather data about the sorts of
delayed tasks going through the system, so we would need a central gathering
point somewhere.

-                                        scoped_refptr<Sequence> sequence,
-                                        SchedulerWorker* worker,
-                                        SchedulerWorkerPool* worker_pool) {
-  DCHECK(task);
-  DCHECK(sequence);
-  DCHECK(worker_pool);
-
-  const TimeTicks new_task_delayed_run_time = task->delayed_run_time;
-  TimeTicks current_delayed_run_time;
-
-  {
-    AutoSchedulerLock auto_lock(lock_);
-
-    if (!delayed_tasks_.empty())
-      current_delayed_run_time = delayed_tasks_.top().task->delayed_run_time;
-
-    delayed_tasks_.emplace(std::move(task), std::move(sequence), worker,
-                           worker_pool, ++delayed_task_index_);
-  }
-
-  if (current_delayed_run_time.is_null() ||
-      new_task_delayed_run_time < current_delayed_run_time) {
-    on_delayed_run_time_updated_.Run();
-  }
-}
-
-void DelayedTaskManager::PostReadyTasks() {
-  const TimeTicks now = Now();
-
-  // Move delayed tasks that are ready for execution into |ready_tasks|. Don't
-  // post them right away to avoid imposing an unecessary lock dependency on
-  // PostTaskNowHelper.
-  std::vector<DelayedTask> ready_tasks;
-
-  {
-    AutoSchedulerLock auto_lock(lock_);
-    while (!delayed_tasks_.empty() &&
-           delayed_tasks_.top().task->delayed_run_time <= now) {
-      // The const_cast for std::move is okay since we're immediately popping
-      // the task from |delayed_tasks_|. See DelayedTaskComparator::operator()
-      // for minor debug-check implications.
-      ready_tasks.push_back(
-          std::move(const_cast<DelayedTask&>(delayed_tasks_.top())));
-      delayed_tasks_.pop();
-    }
-  }
-
-  // Post delayed tasks that are ready for execution.
-  for (auto& delayed_task : ready_tasks) {
-    delayed_task.worker_pool->PostTaskWithSequenceNow(
-        std::move(delayed_task.task), std::move(delayed_task.sequence),
-        delayed_task.worker);
-  }
-}
-
-TimeTicks DelayedTaskManager::GetDelayedRunTime() const {
-  AutoSchedulerLock auto_lock(lock_);
-
-  if (delayed_tasks_.empty())
-    return TimeTicks();
-
-  return delayed_tasks_.top().task->delayed_run_time;
-}
-
-// In std::priority_queue, the largest element is on top. Therefore, this
-// comparator returns true if the delayed run time of |right| is earlier than
-// the delayed run time of |left|.
-bool DelayedTaskManager::DelayedTaskComparator::operator()(
-    const DelayedTask& left,
-    const DelayedTask& right) const {
-#ifndef NDEBUG
-  // Due to STL consistency checks in Windows and const_cast'ing right before
-  // popping the DelayedTask, a null task can be passed to this comparator in
-  // Debug builds. To satisfy these consistency checks, this comparator
-  // considers null tasks to be the larger than anything.
-  DCHECK(left.task || right.task);
-  if (!left.task)
-    return false;
-  if (!right.task)
-    return true;
-#else
-  DCHECK(left.task);
-  DCHECK(right.task);
-#endif  // NDEBUG
-  if (left.task->delayed_run_time > right.task->delayed_run_time)
-    return true;
-  if (left.task->delayed_run_time < right.task->delayed_run_time)
-    return false;
-  return left.index > right.index;
-}
-
-TimeTicks DelayedTaskManager::Now() const {
-  return TimeTicks::Now();
-}
-
-}  // namespace internal
-}  // namespace base