content: Add RendererScheduler.

content/renderer/scheduler/renderer_scheduler.cc

+// 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"
+#include "ui/gfx/frame_time.h"
+
+namespace content {
+
+RendererScheduler::RendererScheduler()
+    : renderer_scheduler_selector_(new RendererSchedulerSelector()),
+      task_queue_manager_(kTaskQueueCount,
+                          base::MessageLoopProxy::current(),
+                          renderer_scheduler_selector_.get()),
+      control_task_runner_(
+          task_queue_manager_.TaskRunnerForQueue(kControlTaskQueue)) {
+  renderer_scheduler_selector_->SetQueuePriority(
+      kControlTaskQueue, RendererSchedulerSelector::kControlPriority);
+  renderer_scheduler_selector_->DisableQueue(kIdleTaskQueue);
+  task_queue_manager_.SetAutoPump(kIdleTaskQueue, false);
+}
+
+RendererScheduler::~RendererScheduler() {
+}
+
+scoped_refptr<base::SingleThreadTaskRunner>
+RendererScheduler::DefaultTaskRunner() {
+  return task_queue_manager_.TaskRunnerForQueue(kDefaultTaskQueue);
+}
+
+scoped_refptr<base::SingleThreadTaskRunner>
+RendererScheduler::CompositorTaskRunner() {
+  return task_queue_manager_.TaskRunnerForQueue(kCompositorTaskQueue);
+}
+
+scoped_refptr<base::SingleThreadTaskRunner>
+RendererScheduler::IdleTaskRunner() {
+  return task_queue_manager_.TaskRunnerForQueue(kIdleTaskQueue);
+}
+
+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 (gfx::FrameTime::Now() < estimated_next_frame_begin_) {
+    StartIdlePeriod();
+  }
+}
+
+void RendererScheduler::DidReceiveInputEvent() {
+  base::AutoLock lock(incoming_signals_lock_);
+  if (last_input_time_.is_null()) {
+    // Update scheduler policy if should start a new compositor policy mode.
+    base::subtle::NoBarrier_Store(&policy_may_need_update_, 1);
+    control_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&RendererScheduler::UpdatePolicy, base::Unretained(this)));
+  }
+  last_input_time_ = base::TimeTicks::Now();
+}
+
+bool RendererScheduler::ShouldYieldForHighPriorityWork() {
+  main_thread_checker_.CalledOnValidThread();
+  return SchedulerPolicy() == kCompositorPriorityPolicy &&
+         task_queue_manager_.PollQueue(kCompositorTaskQueue);

[alexclarke, 2014/10/22 15:59:42]

I think this should be:
         !task_queue_manager_.IsQueueEmpty(kCompositorTaskQueue);

[rmcilroy, 2014/10/23 14:54:49]

Hadn't synced Sami's new changes yet - done now.

+}
+
+base::TimeTicks RendererScheduler::CurrentFrameDeadlineForIdleTasks() const {
+  main_thread_checker_.CalledOnValidThread();
+  return estimated_next_frame_begin_;
+}
+
+RendererScheduler::Policy RendererScheduler::SchedulerPolicy() {
+  main_thread_checker_.CalledOnValidThread();
+  if (base::subtle::NoBarrier_Load(&policy_may_need_update_)) {
+    UpdatePolicy();
+  }
+  return current_policy_;
+}
+
+void RendererScheduler::UpdatePolicy() {
+  main_thread_checker_.CalledOnValidThread();
+  base::AutoLock lock(incoming_signals_lock_);
+
+  Policy new_policy = kNormalPriorityPolicy;
+  if (!last_input_time_.is_null()) {
+    base::TimeDelta compositor_priority_time =
+        base::TimeDelta::FromMilliseconds(kCompositorPriorityAfterTouchMillis);
+    base::TimeDelta remaining_compositor_priority_time =
+        base::TimeTicks::Now() - (last_input_time_ + compositor_priority_time);
+    if (remaining_compositor_priority_time > base::TimeDelta()) {
+      new_policy = kCompositorPriorityPolicy;
+      control_task_runner_->PostDelayedTask(
+          FROM_HERE,
+          base::Bind(&RendererScheduler::UpdatePolicy, base::Unretained(this)),
+          remaining_compositor_priority_time);
+    } else {
+      // Null out last_input_time_ to ensure DidReceiveInputEvent will post an
+      // UpdatePolicy task when it's next called.
+      last_input_time_ = base::TimeTicks();
+    }
+  }
+
+  if (new_policy != current_policy_) {
+    return;

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

Shouldn't we clear the dirty flag here too?

[rmcilroy, 2014/10/23 14:54:49]

Yes good point - moved this to the top of the function (since the dirty flag is
write-protected by the incoming_signals_lock).

+  }
+
+  switch (new_policy) {
+    case kCompositorPriorityPolicy:
+      renderer_scheduler_selector_->SetQueuePriority(
+          kCompositorTaskQueue, RendererSchedulerSelector::kHighPriority);
+      break;
+    case kNormalPriorityPolicy:
+      renderer_scheduler_selector_->SetQueuePriority(
+          kCompositorTaskQueue, RendererSchedulerSelector::kNormalPriority);
+      break;
+  }
+  current_policy_ = new_policy;
+  base::subtle::NoBarrier_Store(&policy_may_need_update_, 0);

[Sami, 2014/10/22 14:49:24]

Thinking out loud: these can be barrier-less safely because they aren't guarding
any critical data; it doesn't matter if the policy is wrong for a few iterations
of the message loop. Right? Of course, the situation where it does matter when
we're going from normal to compositor priority and have critical work to do.

[rmcilroy, 2014/10/23 14:54:49]

Yes, they aren't guarding anything, and actually write access is protected by
the incoming_signals_lock_ mutex.  The lock operations are already a barrier,
however there is no implicit barrier for the SchedulerPolicy() function, so it
could possibly miss a switch to compositor priority. I've 
 updated to Acquire/Release which should ensure we are always as up-to-date as
possible, but I'm not sure if the cost of the memory barriers will hurt us.

+}
+
+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