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..5b3872321abcee60e2785ac280a473d09c96541e
--- /dev/null
+++ b/content/renderer/scheduler/renderer_scheduler.cc
@@ -0,0 +1,103 @@
+// 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/message_loop/message_loop_proxy.h"
+#include "cc/output/begin_frame_args.h"
+#include "content/renderer/scheduler/renderer_scheduler_selector.h"
+
+namespace content {
+
+RendererScheduler::RendererScheduler()
+    : renderer_scheduler_selector_(new RendererSchedulerSelector()),
+      task_queue_manager_(kTaskAndControlQueueCount,
+                          base::MessageLoopProxy::current(),
+                          renderer_scheduler_selector_.get()),
+      control_task_runner_(
+        task_queue_manager_.TaskRunnerForQueue(kControlQueue)) {

[Sami, 2014/10/20 13:31:08]

Is this intended with git cl format? Looks a bit weird.

[rmcilroy, 2014/10/21 17:21:27]

Done.

+  renderer_scheduler_selector_->SetQueuePriority(
+      kControlQueue, RendererSchedulerSelector::kControlPriority);;

[Sami, 2014/10/20 13:31:08]

nit: extra ;

[rmcilroy, 2014/10/21 17:21:27]

Done.

+  renderer_scheduler_selector_->DisableQueue(kIdleTaskQueue);
+  task_queue_manager_.SetAutoPump(kIdleTaskQueue, false);
+}
+
+RendererScheduler::~RendererScheduler() {
+}
+
+scoped_refptr<base::SingleThreadTaskRunner>
+RendererScheduler::TaskRunnerForQueue(QueueId queue) {
+  return task_queue_manager_.TaskRunnerForQueue(queue);
+}
+
+void RendererScheduler::WillBeginFrame(const cc::BeginFrameArgs& args) {
+  main_thread_checker_.CalledOnValidThread();
+  EndIdlePeriod();
+  estimated_next_frame_begin_ = args.frame_time + args.interval;
+}
+
+void RendererScheduler::DidCommitFrameToCompositor() {
+  main_thread_checker_.CalledOnValidThread();
+  if (base::TimeTicks::Now() < estimated_next_frame_begin_) {

[Sami, 2014/10/20 13:31:08]

Please use gfx::FrameTime::Now() when comparing BeginFrame time stamps.

[rmcilroy, 2014/10/21 17:21:27]

Done.

+    StartIdlePeriod();
+  }
+}
+
+void RendererScheduler::DidReceiveInputEvent() {
+  control_task_runner_->PostTask(

[Sami, 2014/10/20 13:31:08]

I guess Alex already brought this up but somehow we need to make this affect the
output of ShouldYieldForHighPriorityWork immediately so that DOM timers can
yield right away without going back to the message loop.

It would be good if we can avoid posting a new task for every input event we
get.

[rmcilroy, 2014/10/21 17:21:27]

Done. Using policy_may_need_update_ bit to ensure policy update is immediate for
ShouldYieldForHighPriorityWork and only posting a new task if last_input_time_
is null.

+      FROM_HERE,
+      base::Bind(&RendererScheduler::EnterSchedulerPolicy,
+                 base::Unretained(this),
+                 kCompositorPriorityPolicy));
+}
+
+bool RendererScheduler::ShouldYieldForHighPriorityWork() {
+  return (SchedulerPolicy() == kCompositorPriorityPolicy) &&

[petrcermak, 2014/10/20 17:43:35]

nit - is there any reason for the brackets?

[rmcilroy, 2014/10/21 17:21:27]

Nope, removed.

+      task_queue_manager_.PollQueue(kCompositorTaskQueue);
+}
+
+base::TimeTicks RendererScheduler::CurrentFrameDeadlineForIdleTasks() const {
+  main_thread_checker_.CalledOnValidThread();
+  return estimated_next_frame_begin_;
+}
+
+RendererScheduler::Policy RendererScheduler::SchedulerPolicy() const {
+  return static_cast<Policy>(base::subtle::Acquire_Load(&current_policy_));
+}
+
+void RendererScheduler::EnterSchedulerPolicy(Policy policy) {

[alexclarke, 2014/10/20 12:48:35]

With an eye to the future where we may have a loading priority policy, I think
it would make sense to write a function that based on various signals decides
what policy the scheduler should be in and calls EnterSchedulerPolicy
accordingly.

It needs to obey the flag I added too, which disables the scheduler.

[rmcilroy, 2014/10/21 17:21:27]

Agreed - I've updated this to be simply UpdatePolicy which modifies the policy
based on the signals, WDYT?
Done.

+  main_thread_checker_.CalledOnValidThread();
+  if (SchedulerPolicy() != policy) {
+    switch(policy) {
+      case kCompositorPriorityPolicy:
+        renderer_scheduler_selector_->SetQueuePriority(
+            kCompositorTaskQueue, RendererSchedulerSelector::kHighPriority);
+        control_task_runner_->PostDelayedTask(
+            FROM_HERE,
+            base::Bind(&RendererScheduler::EnterSchedulerPolicy,

[Sami, 2014/10/20 13:31:08]

This is nice way to get back to normal mode.

[rmcilroy, 2014/10/21 17:21:27]

Acknowledged.

+                       base::Unretained(this),
+                       kNormalPriorityPolicy),
+            kCompositoryPriorityAfterTouchTime);
+        break;
+      case kNormalPriorityPolicy:
+        renderer_scheduler_selector_->SetQueuePriority(
+            kCompositorTaskQueue, RendererSchedulerSelector::kNormalPriority);
+        break;
+    }
+    base::subtle::Release_Store(&current_policy_, policy);
+  }
+}
+
+void RendererScheduler::StartIdlePeriod() {
+  renderer_scheduler_selector_->EnableQueue(
+      kIdleTaskQueue, RendererSchedulerSelector::kBestEffortPriority);
+  task_queue_manager_.PumpQueue(kIdleTaskQueue);
+}
+
+void RendererScheduler::EndIdlePeriod() {
+  renderer_scheduler_selector_->DisableQueue(kIdleTaskQueue);
+}
+
+}  // namespace content