content: Add RendererScheduler.

content/renderer/scheduler/renderer_scheduler.cc

Index: content/renderer/scheduler/renderer_scheduler.cc
diff --git a/content/renderer/scheduler/renderer_scheduler.cc b/content/renderer/scheduler/renderer_scheduler.cc
new file mode 100644
index 0000000000000000000000000000000000000000..e72d6ba620aaf0482831baae079fc70f72f367b0
--- /dev/null
+++ b/content/renderer/scheduler/renderer_scheduler.cc
@@ -0,0 +1,116 @@
+// 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/renderer_scheduler.h"
+
+#include "base/bind.h"
+#include "base/command_line.h"
+#include "base/message_loop/message_loop_proxy.h"
+#include "content/public/common/content_switches.h"
+#include "content/renderer/scheduler/renderer_scheduler_impl.h"
+
+namespace content {
+
+namespace {
+
+class NullIdleTaskRunner : public SingleThreadIdleTaskRunner {

[alexclarke, 2014/10/24 15:56:29]

Shouldn't the null scheduler be in it's own file?

[rmcilroy, 2014/10/27 16:25:00]

I didn't think it was worth it, but OK, done.

+ public:
+  NullIdleTaskRunner(scoped_refptr<base::SingleThreadTaskRunner> task_runner);
+  void PostIdleTask(const tracked_objects::Location& from_here,
+                    const IdleTask& idle_task) override;
+
+ protected:
+  virtual ~NullIdleTaskRunner();
+};
+
+class NullRendererScheduler : public RendererScheduler {
+ public:
+  NullRendererScheduler();
+  virtual ~NullRendererScheduler();
+
+  scoped_refptr<base::SingleThreadTaskRunner> DefaultTaskRunner() override;
+  scoped_refptr<base::SingleThreadTaskRunner> CompositorTaskRunner() override;
+  scoped_refptr<SingleThreadIdleTaskRunner> IdleTaskRunner() override;
+
+  void WillBeginFrame(const cc::BeginFrameArgs& args) override;
+  void DidCommitFrameToCompositor() override;
+  void DidReceiveInputEvent() override;
+  bool ShouldYieldForHighPriorityWork() override;
+
+ private:
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
+  scoped_refptr<SingleThreadIdleTaskRunner> idle_task_runner_;
+
+  DISALLOW_COPY_AND_ASSIGN(NullRendererScheduler);
+};
+
+NullIdleTaskRunner::NullIdleTaskRunner(
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner)
+    : SingleThreadIdleTaskRunner(task_runner,
+                                 base::WeakPtr<IdleTaskDeadlineSupplier>()) {
+}
+
+NullIdleTaskRunner::~NullIdleTaskRunner() {
+}
+
+void NullIdleTaskRunner::PostIdleTask(
+    const tracked_objects::Location& from_here,
+    const IdleTask& idle_task) {
+}
+
+NullRendererScheduler::NullRendererScheduler()
+    : task_runner_(base::MessageLoopProxy::current()),
+      idle_task_runner_(new NullIdleTaskRunner(task_runner_)) {
+}
+
+NullRendererScheduler::~NullRendererScheduler() {
+}
+
+scoped_refptr<base::SingleThreadTaskRunner>
+NullRendererScheduler::DefaultTaskRunner() {
+  return task_runner_;
+}
+
+scoped_refptr<base::SingleThreadTaskRunner>
+NullRendererScheduler::CompositorTaskRunner() {
+  return task_runner_;
+}
+
+scoped_refptr<SingleThreadIdleTaskRunner>
+NullRendererScheduler::IdleTaskRunner() {
+  return idle_task_runner_;
+}
+
+void NullRendererScheduler::WillBeginFrame(const cc::BeginFrameArgs& args) {
+}
+
+void NullRendererScheduler::DidCommitFrameToCompositor() {
+}
+
+void NullRendererScheduler::DidReceiveInputEvent() {
+}
+
+bool NullRendererScheduler::ShouldYieldForHighPriorityWork() {
+  return false;
+}
+
+}  // namespace
+
+RendererScheduler::RendererScheduler() {
+}
+
+RendererScheduler::~RendererScheduler() {
+}
+
+// static
+scoped_ptr<RendererScheduler> RendererScheduler::Create() {
+  CommandLine* command_line = CommandLine::ForCurrentProcess();
+  if (command_line->HasSwitch(switches::kDisableBlinkScheduler)) {
+    return make_scoped_ptr(new NullRendererScheduler());
+  } else {
+    return make_scoped_ptr(new RendererSchedulerImpl());
+  }
+}
+
+}  // namespace content