content: Add RendererScheduler.

content/renderer/scheduler/single_thread_idle_task_runner.cc

Index: content/renderer/scheduler/single_thread_idle_task_runner.cc
diff --git a/content/renderer/scheduler/single_thread_idle_task_runner.cc b/content/renderer/scheduler/single_thread_idle_task_runner.cc
new file mode 100644
index 0000000000000000000000000000000000000000..67cad7cf7c8de64a1126de300b15cec8dd6de8cd
--- /dev/null
+++ b/content/renderer/scheduler/single_thread_idle_task_runner.cc
@@ -0,0 +1,41 @@
+// 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/single_thread_idle_task_runner.h"
+
+#include "base/location.h"
+
+namespace content {
+
+IdleTaskDeadlineSupplier::~IdleTaskDeadlineSupplier() {
+}
+
+SingleThreadIdleTaskRunner::SingleThreadIdleTaskRunner(
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner,
+    base::WeakPtr<IdleTaskDeadlineSupplier> deadline_supplier)
+    : task_runner_(task_runner), deadline_supplier_(deadline_supplier) {
+}
+
+SingleThreadIdleTaskRunner::~SingleThreadIdleTaskRunner() {
+}
+
+bool SingleThreadIdleTaskRunner::RunsTasksOnCurrentThread() const {
+  return task_runner_->RunsTasksOnCurrentThread();
+}
+
+void SingleThreadIdleTaskRunner::PostIdleTask(
+    const tracked_objects::Location& from_here,
+    const IdleTask& idle_task) {
+  task_runner_->PostTask(
+      from_here,
+      base::Bind(&SingleThreadIdleTaskRunner::RunTask, this, idle_task));
+}
+
+void SingleThreadIdleTaskRunner::RunTask(IdleTask idle_task) {
+  if (deadline_supplier_) {

[no sievers, 2014/10/30 23:40:51]

Do we really want to cancel the task when the deadline supplier goes away?
Or should it not happen that a task is run when that was the case and we
DCHECK() instead?

[rmcilroy, 2014/11/03 19:02:53]

Yes we should probably DCHECK - done.

[no sievers, 2014/11/03 22:19:01]

Actually based on other comments it seems like RendererSchedulerImpl (the
deadline supplier) might go away, while another thread is still holding a ref to
this task runner. So no DCHECK() then? What about the task? Run it without a
deadline, or drop it?

[rmcilroy, 2014/11/04 02:22:19]

The RendererSchedulerImpl could go away while another thread is holding a ref to
this task runner - we need to make PostIdleTask able to deal with
RendererSchedulerImpl having gone away, however RunTask should never be called
if RendererSchedulerImpl has gone away, so it should be fine to DCHECK here.

+    idle_task.Run(deadline_supplier_->CurrentIdleTaskDeadline());
+  }
+}
+
+}  // namespace content