content: Add RendererScheduler.

content/renderer/scheduler/renderer_scheduler_impl.cc

Index: content/renderer/scheduler/renderer_scheduler_impl.cc
diff --git a/content/renderer/scheduler/renderer_scheduler_impl.cc b/content/renderer/scheduler/renderer_scheduler_impl.cc
new file mode 100644
index 0000000000000000000000000000000000000000..4f116af0ed8653745b2512cb1f3e915e9194c0b5
--- /dev/null
+++ b/content/renderer/scheduler/renderer_scheduler_impl.cc
@@ -0,0 +1,182 @@
+// 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_impl.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_task_queue_selector.h"
+#include "ui/gfx/frame_time.h"
+
+namespace content {
+
+RendererSchedulerImpl::RendererSchedulerImpl()
+    : RendererSchedulerImpl(base::MessageLoopProxy::current()) {
+}
+
+RendererSchedulerImpl::RendererSchedulerImpl(
+    scoped_refptr<base::SingleThreadTaskRunner> main_task_runner)
+    : renderer_task_queue_selector_(new RendererTaskQueueSelector()),
+      task_queue_manager_(
+          new TaskQueueManager(TASK_QUEUE_COUNT,
+                               main_task_runner,
+                               renderer_task_queue_selector_.get())),
+      control_task_runner_(
+          task_queue_manager_->TaskRunnerForQueue(CONTROL_TASK_QUEUE)),
+      default_task_runner_(
+          task_queue_manager_->TaskRunnerForQueue(DEFAULT_TASK_QUEUE)),
+      compositor_task_runner_(
+          task_queue_manager_->TaskRunnerForQueue(COMPOSITOR_TASK_QUEUE)),
+      current_policy_(NORMAL_PRIORITY_POLICY),
+      policy_may_need_update_(0),
+      weak_factory_(this) {
+  weak_renderer_scheduler_ptr_ = weak_factory_.GetWeakPtr();
+  idle_task_runner_ = make_scoped_refptr(new SingleThreadIdleTaskRunner(
+      task_queue_manager_->TaskRunnerForQueue(IDLE_TASK_QUEUE),
+      weak_factory_.GetWeakPtr()));
+  renderer_task_queue_selector_->SetQueuePriority(
+      CONTROL_TASK_QUEUE, RendererTaskQueueSelector::CONTROL_PRIORITY);
+  renderer_task_queue_selector_->DisableQueue(IDLE_TASK_QUEUE);
+  task_queue_manager_->SetAutoPump(IDLE_TASK_QUEUE, false);
+}
+
+RendererSchedulerImpl::~RendererSchedulerImpl() {
+}
+
+void RendererSchedulerImpl::Shutdown() {
+  task_queue_manager_.reset();
+}
+
+scoped_refptr<base::SingleThreadTaskRunner>
+RendererSchedulerImpl::DefaultTaskRunner() {

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

What about these task runner getter methods being called from another thread
while we are shutting down on the main thread?

[alex clarke (OOO till 29th), 2014/11/03 17:39:34]

If a task gets posted during shut down, then it will go onto the queue but will
never get executed.

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

This should be fine - the task_runners are ref_counted so will stay alive even
as we are shutting down, and internally contain a weak pointer to the
TaskQueueManager (see task_queue_manager.cc), which is checked during posting,
so if we have shutdown the task_runner will just drop the posted tasks.

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

But these getters should call main_thread_checker_.CalledOnValidThread().

You can't access |this| from another thread because |this| might get deleted
while you are calling into it which will crash.
Everybody needs to acquire a reference to the task runners from the main thread
and then hold on to it.

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

Yes, these getters should call main_thread_checker_ - the clients all do
currently get the task runners on the main thread and hold onto it, I had just
forgotton to add the checks here.  Added
main_thread_checker_.CalledOnValidThread() (and also in Shutdown which should
also only be called from the main thread).

+  return default_task_runner_;
+}
+
+scoped_refptr<base::SingleThreadTaskRunner>
+RendererSchedulerImpl::CompositorTaskRunner() {
+  return compositor_task_runner_;
+}
+
+scoped_refptr<SingleThreadIdleTaskRunner>
+RendererSchedulerImpl::IdleTaskRunner() {
+  return idle_task_runner_;
+}
+
+void RendererSchedulerImpl::WillBeginFrame(const cc::BeginFrameArgs& args) {
+  main_thread_checker_.CalledOnValidThread();
+  if (!task_queue_manager_)

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

Do we really expect this after shutdown? Should it be DCHECK()? Same for other
calls below.

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

Unfortunately we can still get called by the compositor while Blink is shutting
down because it doesn't seem to be guaranteed that the compositor thread is dead
by the point Blink shuts down, so I don't think we can just DCHECK() here.
http://crbug.com/415758 describes an issue due to this.

+    return;
+
+  EndIdlePeriod();
+  estimated_next_frame_begin_ = args.frame_time + args.interval;
+}
+
+void RendererSchedulerImpl::DidCommitFrameToCompositor() {
+  main_thread_checker_.CalledOnValidThread();
+  if (!task_queue_manager_)
+    return;
+
+  if (Now() < estimated_next_frame_begin_) {
+    StartIdlePeriod();
+  }
+}
+
+void RendererSchedulerImpl::DidReceiveInputEvent() {
+  if (!task_queue_manager_)

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

This is accessing task_queue_manager_ without a mutex.
But more importantly how will we make sure that this doesn't get called from the
IO thread when the scheduler is about to or has already shut down?

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

Very good point.  I've removed the check entirely because we never actually
access the task_queue_manager_ from this function, and if we have shutdown then
the control_task_runner_ will just silently drop the UpdatePolicy task we post
here.

+    return;
+  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::Release_Store(&policy_may_need_update_, 1);
+    PostUpdatePolicyOnControlRunner(base::TimeDelta());
+  }
+  last_input_time_ = Now();
+}
+
+bool RendererSchedulerImpl::ShouldYieldForHighPriorityWork() {
+  main_thread_checker_.CalledOnValidThread();
+  if (!task_queue_manager_)
+    return false;
+
+  return SchedulerPolicy() == COMPOSITOR_PRIORITY_POLICY &&
+         !task_queue_manager_->IsQueueEmpty(COMPOSITOR_TASK_QUEUE);
+}
+
+base::TimeTicks RendererSchedulerImpl::CurrentIdleTaskDeadline() const {
+  main_thread_checker_.CalledOnValidThread();
+  return estimated_next_frame_begin_;
+}
+
+RendererSchedulerImpl::Policy RendererSchedulerImpl::SchedulerPolicy() {
+  main_thread_checker_.CalledOnValidThread();
+  if (base::subtle::Acquire_Load(&policy_may_need_update_)) {
+    UpdatePolicy();

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

Why do we need to do this here? We know that if it needed an update we already
scheduled a task to update it.
Also, you could use base::CancellationFlag to hide the 'subtle' stuff here. But
am wondering why we need it at all.

[alex clarke (OOO till 29th), 2014/11/03 17:39:33]

The motivation for this is to let ShouldYieldForHighPriorityWork() return true
as fast as possible in the following scenario:

The scheduler is in NORMAL_PRIORITY_POLICY and while the Blink platform timers
are executing, the user touches the screen.   In that situation we want
ShouldYieldForHighPriorityWork (which is polled by the blink platform timer
loop) to return true, hence we update the policy here if the
policy_may_need_update_ dirty flag is set.

The use of subtle is an optimization to try and avoid locking because this
function can get called a lot.

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

We need this due to the ShouldYieldForHighPriorityWork() - this is called by
long running tasks to check whether they should yield. We want a policy change
to cause this to return 'true' as soon as possible if we need to move to
compositor priority.  The UpdatePolicy task can only be run once the current
task has completed, so we wouldn't be able to signal to the long-running task to
yield if we didn't use this flag to enable short-circuiting.  I've added a test
(TestShouldYield) to check for this.

base::CancellationFlag almost works, however we need to be able to set it from
multiple threads (with a lock) and read it from one thread (CancellationFlag is
the opposite).  I created a PolicyNeedsUpdateFlag class which encapsulates the
behavior we need - WDYT?

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

Shouldn't it also yield then for any control task in general?
Could we just do this:

bool RendererSchedulerImpl::ShouldYieldForHighPriorityWork() {
...
   return !task_queue_manager_->IsQueueEmpty(CONTROL_TASK_QUEUE)
       || (SchedulerPolicy() == COMPOSITOR_PRIORITY_POLICY &&
           !task_queue_manager_->IsQueueEmpty(COMPOSITOR_TASK_QUEUE));
 }
 

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

As discussed offline, this doesn't quite give us what we want because: in the
future we might end up posting a low-prio policy update on the control task
queue which we don't want to force tasks to yield for; and IsQueueEmpty requires
locking if the queue is empty so we don't want to do it in the normal case.

+  }
+  return current_policy_;
+}
+
+void RendererSchedulerImpl::PostUpdatePolicyOnControlRunner(
+    base::TimeDelta delay) {
+  base::Closure closure = base::Bind(&RendererSchedulerImpl::UpdatePolicy,
+                                     weak_renderer_scheduler_ptr_);
+  control_task_runner_->PostDelayedTask(FROM_HERE, closure, delay);
+}
+
+void RendererSchedulerImpl::UpdatePolicy() {
+  main_thread_checker_.CalledOnValidThread();
+  if (!task_queue_manager_)
+    return;
+
+  base::AutoLock lock(incoming_signals_lock_);
+  base::subtle::Release_Store(&policy_may_need_update_, 0);
+
+  Policy new_policy = NORMAL_PRIORITY_POLICY;
+  if (!last_input_time_.is_null()) {
+    base::TimeDelta compositor_priority_duration =

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

nit: indent

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

I'm not sure what's wrongly indented here?

+        base::TimeDelta::FromMilliseconds(kCompositorPriorityAfterTouchMillis);
+    base::TimeDelta remaining_compositor_priority_duration =
+        last_input_time_ + compositor_priority_duration - Now();
+    if (remaining_compositor_priority_duration > base::TimeDelta()) {

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

nit: can you write instead:

base::TimeTicks priority_end(last_input_time_ + compositor_priority_duration);
base::TimeTicks now(Now());
if (priority_end > now) {
  new_policy = ...
  Post(priority_end - now);
}

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

Done.

+      PostUpdatePolicyOnControlRunner(remaining_compositor_priority_duration);
+      new_policy = COMPOSITOR_PRIORITY_POLICY;
+    } 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;
+  }
+
+  switch (new_policy) {
+    case COMPOSITOR_PRIORITY_POLICY:
+      renderer_task_queue_selector_->SetQueuePriority(
+          COMPOSITOR_TASK_QUEUE, RendererTaskQueueSelector::HIGH_PRIORITY);
+      break;
+    case NORMAL_PRIORITY_POLICY:
+      renderer_task_queue_selector_->SetQueuePriority(
+          COMPOSITOR_TASK_QUEUE, RendererTaskQueueSelector::NORMAL_PRIORITY);
+      break;
+  }
+  current_policy_ = new_policy;
+}
+
+void RendererSchedulerImpl::StartIdlePeriod() {
+  renderer_task_queue_selector_->EnableQueue(
+      IDLE_TASK_QUEUE, RendererTaskQueueSelector::BEST_EFFORT_PRIORITY);
+  task_queue_manager_->PumpQueue(IDLE_TASK_QUEUE);
+}
+
+void RendererSchedulerImpl::EndIdlePeriod() {
+  renderer_task_queue_selector_->DisableQueue(IDLE_TASK_QUEUE);
+}
+
+base::TimeTicks RendererSchedulerImpl::Now() const {
+  return gfx::FrameTime::Now();
+}
+
+}  // namespace content