content: Add RendererScheduler.

content/renderer/scheduler/single_thread_idle_task_runner.h

+// 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.
+
+#ifndef CONTENT_RENDERER_SCHEDULER_SINGLE_THREAD_IDLE_TASK_RUNNER_H_
+#define CONTENT_RENDERER_SCHEDULER_SINGLE_THREAD_IDLE_TASK_RUNNER_H_
+
+#include "base/bind.h"
+#include "base/callback.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/weak_ptr.h"
+#include "base/single_thread_task_runner.h"
+#include "base/time/time.h"
+
+namespace content {
+
+class IdleTaskDeadlineSupplier;
+
+// A SingleThreadIdleTaskRunner is a task runner for running idle tasks. Idle
+// tasks have an unbound argument which is bound to a deadline
+// (in base::TimeTicks) when they are run. The idle task is expected to
+// complete by this deadline.
+class SingleThreadIdleTaskRunner
+    : public base::RefCountedThreadSafe<SingleThreadIdleTaskRunner> {
+ public:
+  typedef base::Callback<void(base::TimeTicks)> IdleTask;
+
+  SingleThreadIdleTaskRunner(
+      scoped_refptr<base::SingleThreadTaskRunner> task_runner,
+      base::WeakPtr<IdleTaskDeadlineSupplier> deadline_supplier);
+
+  virtual void PostIdleTask(const tracked_objects::Location& from_here,
+                            const IdleTask& idle_task);
+
+  bool RunsTasksOnCurrentThread() const;
+
+ protected:
+  virtual ~SingleThreadIdleTaskRunner();
+
+ private:
+  friend class base::RefCountedThreadSafe<SingleThreadIdleTaskRunner>;
+
+  void RunTask(IdleTask idle_task);
+
+  scoped_refptr<base::TaskRunner> task_runner_;
+  base::WeakPtr<IdleTaskDeadlineSupplier> deadline_supplier_;
+};
+
+class IdleTaskDeadlineSupplier {

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

Can this be a CancelableCallback?

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

I don't thinks so.  We need to be able to pass the task an actual deadline which
it should work until (e.g., the V8 GC idle task will use this deadline to
estimate how much marking it can do before the deadline), not just be able to
cancel it.

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

I meant just to avoid needing the interface class.
The callback itself is of type Callback<base::TimeTicks()> and returns the
current deadline.
It's just cancelable (from RendererSchedulerImpl) to handle the scheduler impl
going away.

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

Ahh I see what you mean, good idea.  Done, but using a non cancelable callback
with a weakref 'this' parameter since this will implicitly cancel the callback
if the weakptr becomes invalid (see
https://code.google.com/p/chromium/codesearch#chromium/src/base/bind_internal...).

+ public:
+  // Returns the deadline by which an idle task should finish by.
+  virtual base::TimeTicks CurrentIdleTaskDeadline() const = 0;
+
+ protected:
+  virtual ~IdleTaskDeadlineSupplier();
+};
+
+}  // namespace content
+
+#endif  // CONTENT_RENDERER_SCHEDULER_SINGLE_THREAD_IDLE_TASK_RUNNER_H_