content: Add task queue manager

content/renderer/scheduler/task_queue_manager.cc

Index: content/renderer/scheduler/task_queue_manager.cc
diff --git a/content/renderer/scheduler/task_queue_manager.cc b/content/renderer/scheduler/task_queue_manager.cc
new file mode 100644
index 0000000000000000000000000000000000000000..66384c404ac66117c7ce25148c4e1694f7cc127d
--- /dev/null
+++ b/content/renderer/scheduler/task_queue_manager.cc
@@ -0,0 +1,175 @@
+// 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 "content/renderer/scheduler/task_queue_manager.h"
+
+#include "base/bind.h"
+#include "base/debug/trace_event.h"
+#include "content/renderer/scheduler/task_queue_scheduler_default.h"
+
+namespace content {
+
+TaskQueueManager::TaskRunner::TaskRunner(TaskQueueManager* task_queue_manager,
+                                         QueueId queue)
+    : task_queue_manager_(task_queue_manager), queue_(queue) {
+}
+
+TaskQueueManager::TaskRunner::~TaskRunner() {
+}
+
+bool TaskQueueManager::TaskRunner::RunsTasksOnCurrentThread() const {
+  return task_queue_manager_->RunsTasksOnCurrentThread();
+}
+
+bool TaskQueueManager::TaskRunner::PostDelayedTask(
+    const tracked_objects::Location& from_here,
+    const base::Closure& task,
+    base::TimeDelta delay) {
+  return task_queue_manager_->PostDelayedTask(queue_, from_here, task, delay);
+}
+
+bool TaskQueueManager::TaskRunner::PostNonNestableDelayedTask(
+    const tracked_objects::Location& from_here,
+    const base::Closure& task,
+    base::TimeDelta delay) {
+  return task_queue_manager_->PostNonNestableDelayedTask(
+      queue_, from_here, task, delay);
+}
+
+TaskQueueManager::TaskQueue::TaskQueue(QueueId id) : id(id) {
+}
+
+TaskQueueManager::TaskQueue::~TaskQueue() {
+}
+
+TaskQueueManager::TaskQueueManager(
+    scoped_refptr<base::SingleThreadTaskRunner> main_task_runner)
+    : main_task_runner_(main_task_runner), weak_factory_(this) {
+  DCHECK(main_task_runner->RunsTasksOnCurrentThread());
+  for (size_t i = 0; i < kTaskQueueCount; i++) {
+    QueueId id = static_cast<QueueId>(i);
+    scoped_ptr<TaskQueue> queue(new TaskQueue(id));
+    queue->task_runner = make_scoped_refptr(new TaskRunner(this, id));
+    queues_.push_back(queue.release());
+  }
+  SetScheduler(make_scoped_ptr(new TaskQueueSchedulerDefault()));
+}
+
+TaskQueueManager::~TaskQueueManager() {
+}
+
+void TaskQueueManager::SetScheduler(scoped_ptr<TaskQueueScheduler> scheduler) {
+  scheduler_ = scheduler.Pass();
+  std::vector<const base::TaskQueue*> work_queues;
+  for (size_t i = 0; i < queues_.size(); i++)
+    work_queues.push_back(&queues_[i]->work_queue);
+  scheduler_->SetWorkQueues(work_queues);
+}
+
+scoped_refptr<base::SingleThreadTaskRunner>
+TaskQueueManager::TaskRunnerForQueue(QueueId queue) {
+  DCHECK_LT(queue, queues_.size());
+  return queues_[queue]->task_runner;
+}
+
+bool TaskQueueManager::ReloadWorkQueue(QueueId queue) {
+  main_thread_checker_.CalledOnValidThread();
+  DCHECK_LT(queue, queues_.size());
+  DCHECK(queues_[queue]->work_queue.empty());
+  base::AutoLock lock(queues_[queue]->incoming_queue_lock);
+  queues_[queue]->work_queue.Swap(&queues_[queue]->incoming_queue);
+  return queues_[queue]->work_queue.empty();
+}
+
+void TaskQueueManager::EnqueueTask(QueueId queue,
+                                   base::PendingTask pending_task) {
+  DCHECK_LT(queue, queues_.size());
+  {
+    base::AutoLock lock(queues_[queue]->incoming_queue_lock);
+    queues_[queue]->incoming_queue.push(pending_task);
+  }
+  scheduler_->DidQueueTask(queue);
+  ScheduleWork();
+}
+
+void TaskQueueManager::ScheduleWork() {
+  main_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&TaskQueueManager::DoWork, weak_factory_.GetWeakPtr()));
+}
+
+bool TaskQueueManager::ReloadWorkQueues() {
+  bool has_work = false;
+  for (auto& queue : queues_) {
+    if (!queue->work_queue.empty()) {
+      has_work = true;
+      continue;
+    }
+    if (scheduler_->ShouldReloadWorkQueue(queue->id))
+      has_work |= ReloadWorkQueue(queue->id);
+  }
+  return has_work;
+}
+
+void TaskQueueManager::DoWork() {
+  main_thread_checker_.CalledOnValidThread();
+
+  // FIXME: Can this ever happen?

[alexclarke, 2014/10/13 10:06:22]

Right now I suspect no, but if you where to post DoWork as a delayed task (to
facilitate idle work) and then as a regular task (because the compositor
finished early) it might happen.

[Sami, 2014/10/13 18:16:21]

Right, let's figure out how idle tasks fit into all of this...

+  if (!ReloadWorkQueues())
+    return;
+
+  QueueId queue;
+  if (!scheduler_->ChooseWorkQueueToService(&queue))
+    return;
+  RunTaskFromWorkQueue(queue);
+}
+
+void TaskQueueManager::RunTaskFromWorkQueue(QueueId queue) {
+  main_thread_checker_.CalledOnValidThread();
+  DCHECK_LT(queue, queues_.size());
+  DCHECK(!queues_[queue]->work_queue.empty());
+  base::PendingTask pending_task = queues_[queue]->work_queue.front();
+  queues_[queue]->work_queue.pop();
+  task_annotator_.RunTask(
+      "TaskQueueManager::PostTask", "TaskQueueManager::DoWork", pending_task);
+}
+
+bool TaskQueueManager::RunsTasksOnCurrentThread() const {
+  return main_task_runner_->RunsTasksOnCurrentThread();
+}
+
+bool TaskQueueManager::PostDelayedTask(
+    QueueId queue,
+    const tracked_objects::Location& from_here,
+    const base::Closure& task,
+    base::TimeDelta delay) {
+  int sequence_num = task_sequence_num_.GetNext();
+
+  base::PendingTask pending_task(from_here, task);
+  pending_task.sequence_num = sequence_num;
+
+  task_annotator_.DidQueueTask("TaskQueueManager::PostTask", pending_task);
+  if (delay > base::TimeDelta()) {
+    return main_task_runner_->PostDelayedTask(
+        from_here,
+        base::Bind(&TaskQueueManager::EnqueueTask,
+                   weak_factory_.GetWeakPtr(),
+                   queue,
+                   pending_task),
+        delay);
+  }
+  EnqueueTask(queue, pending_task);
+  return true;
+}
+
+bool TaskQueueManager::PostNonNestableDelayedTask(
+    QueueId queue,
+    const tracked_objects::Location& from_here,
+    const base::Closure& task,
+    base::TimeDelta delay) {
+  // Defer non-nestable work to the main task runner.
+  return main_task_runner_->PostNonNestableDelayedTask(from_here, task, delay);
+}
+
+}  // namespace content