Optimize for TouchStart responsiveness

components/scheduler/renderer/renderer_scheduler_impl.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 "components/scheduler/renderer/renderer_scheduler_impl.h"
 
 #include "base/bind.h"
 #include "base/debug/stack_trace.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "cc/output/begin_frame_args.h"
 #include "components/scheduler/child/scheduler_task_runner_delegate.h"
 #include "components/scheduler/child/task_queue_impl.h"
 #include "components/scheduler/child/task_queue_selector.h"
 
 namespace scheduler {
 namespace {
-const int kTimerTaskEstimationSampleCount = 4 * 60;
-const double kTimerTaskEstimationPercentile = 80;
+const int kLoadingTaskEstimationSampleCount = 200;
+const double kLoadingTaskEstimationPercentile = 90;
+const int kTimerTaskEstimationSampleCount = 200;
+const double kTimerTaskEstimationPercentile = 90;
 const int kShortIdlePeriodDurationSampleCount = 10;
 const double kShortIdlePeriodDurationPercentile = 20;
 }
 
 RendererSchedulerImpl::RendererSchedulerImpl(
     scoped_refptr<SchedulerTaskRunnerDelegate> main_task_runner)
     : helper_(main_task_runner,
               "renderer.scheduler",
               TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
               TRACE_DISABLED_BY_DEFAULT("renderer.scheduler.debug")),
@@ skipping 17 matching lines @@
           base::Bind(&RendererSchedulerImpl::UpdatePolicy,
                      base::Unretained(this)),
           helper_.ControlTaskRunner()),
       policy_may_need_update_(&any_thread_lock_),
       weak_factory_(this) {
   update_policy_closure_ = base::Bind(&RendererSchedulerImpl::UpdatePolicy,
                                       weak_factory_.GetWeakPtr());
   end_renderer_hidden_idle_period_closure_.Reset(base::Bind(
       &RendererSchedulerImpl::EndIdlePeriod, weak_factory_.GetWeakPtr()));
 
+  loading_task_runner_->AddTaskObserver(
+      &MainThreadOnly().loading_task_cost_estimator);
+
   timer_task_runner_->AddTaskObserver(
-      &MainThreadOnly().timer_task_cost_estimator_);
+      &MainThreadOnly().timer_task_cost_estimator);
 
   TRACE_EVENT_OBJECT_CREATED_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "RendererScheduler",
       this);
+
+  // Make sure that we don't initially assume there is no idle time.
+  MainThreadOnly().short_idle_period_duration.InsertSample(
+      cc::BeginFrameArgs::DefaultInterval());
 }
 
 RendererSchedulerImpl::~RendererSchedulerImpl() {
   TRACE_EVENT_OBJECT_DELETED_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "RendererScheduler",
       this);
   timer_task_runner_->RemoveTaskObserver(
-      &MainThreadOnly().timer_task_cost_estimator_);
+      &MainThreadOnly().timer_task_cost_estimator);
   // Ensure the renderer scheduler was shut down explicitly, because otherwise
   // we could end up having stale pointers to the Blink heap which has been
   // terminated by this point.
-  DCHECK(MainThreadOnly().was_shutdown_);
+  DCHECK(MainThreadOnly().was_shutdown);
 }
 
+RendererSchedulerImpl::Policy::Policy()
+    : compositor_queue_priority(TaskQueue::NORMAL_PRIORITY),
+      loading_queue_priority(TaskQueue::NORMAL_PRIORITY),
+      timer_queue_priority(TaskQueue::NORMAL_PRIORITY) {}
+
 RendererSchedulerImpl::MainThreadOnly::MainThreadOnly()
-    : timer_task_cost_estimator_(kTimerTaskEstimationSampleCount,
-                                 kTimerTaskEstimationPercentile),
-      short_idle_period_duration_(kShortIdlePeriodDurationSampleCount),
-      current_policy_(Policy::NORMAL),
-      timer_queue_suspend_count_(0),
-      renderer_hidden_(false),
-      was_shutdown_(false) {}
+    : loading_task_cost_estimator(kLoadingTaskEstimationSampleCount,
+                                  kLoadingTaskEstimationPercentile),
+      timer_task_cost_estimator(kTimerTaskEstimationSampleCount,
+                                kTimerTaskEstimationPercentile),
+      short_idle_period_duration(kShortIdlePeriodDurationSampleCount),
+      current_use_case(UseCase::NONE),
+      timer_queue_suspend_count(0),
+      renderer_hidden(false),
+      was_shutdown(false),
+      loading_tasks_seem_expensive(false),
+      timer_tasks_seem_expensive(false),
+      touchstart_expected_soon(false) {}
 
 RendererSchedulerImpl::MainThreadOnly::~MainThreadOnly() {}
 
 RendererSchedulerImpl::AnyThread::AnyThread()
-    : pending_main_thread_input_event_count_(0),
-      awaiting_touch_start_response_(false),
-      in_idle_period_(false),
-      begin_main_frame_on_critical_path_(false),
-      timer_tasks_seem_expensive_(false) {}
+    : awaiting_touch_start_response(false),
+      in_idle_period(false),
+      begin_main_frame_on_critical_path(false) {}
 
 RendererSchedulerImpl::CompositorThreadOnly::CompositorThreadOnly()
-    : last_input_type_(blink::WebInputEvent::Undefined) {
-}
+    : last_input_type(blink::WebInputEvent::Undefined) {}
 
 RendererSchedulerImpl::CompositorThreadOnly::~CompositorThreadOnly() {
 }
 
 void RendererSchedulerImpl::Shutdown() {
   helper_.Shutdown();
-  MainThreadOnly().was_shutdown_ = true;
+  MainThreadOnly().was_shutdown = true;
 }
 
 scoped_refptr<TaskQueue> RendererSchedulerImpl::DefaultTaskRunner() {
   return helper_.DefaultTaskRunner();
 }
 
 scoped_refptr<base::SingleThreadTaskRunner>
 RendererSchedulerImpl::CompositorTaskRunner() {
   helper_.CheckOnValidThread();
   return compositor_task_runner_;
@@ skipping 30 matching lines @@
 }
 
 void RendererSchedulerImpl::WillBeginFrame(const cc::BeginFrameArgs& args) {
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                "RendererSchedulerImpl::WillBeginFrame", "args", args.AsValue());
   helper_.CheckOnValidThread();
   if (helper_.IsShutdown())
     return;
 
   EndIdlePeriod();
-  MainThreadOnly().estimated_next_frame_begin_ =
-      args.frame_time + args.interval;
+  MainThreadOnly().estimated_next_frame_begin = args.frame_time + args.interval;
   {
     base::AutoLock lock(any_thread_lock_);
-    AnyThread().begin_main_frame_on_critical_path_ = args.on_critical_path;
+    AnyThread().begin_main_frame_on_critical_path = args.on_critical_path;
   }
 }
 
 void RendererSchedulerImpl::DidCommitFrameToCompositor() {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                "RendererSchedulerImpl::DidCommitFrameToCompositor");
   helper_.CheckOnValidThread();
   if (helper_.IsShutdown())
     return;
 
   base::TimeTicks now(helper_.Now());
-  if (now < MainThreadOnly().estimated_next_frame_begin_) {
+  if (now < MainThreadOnly().estimated_next_frame_begin) {
     // TODO(rmcilroy): Consider reducing the idle period based on the runtime of
     // the next pending delayed tasks (as currently done in for long idle times)
     idle_helper_.StartIdlePeriod(
         IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, now,
-        MainThreadOnly().estimated_next_frame_begin_);
-    MainThreadOnly().short_idle_period_duration_.InsertSample(
-        MainThreadOnly().estimated_next_frame_begin_ - now);
-    MainThreadOnly().expected_short_idle_period_duration_ =
-        MainThreadOnly().short_idle_period_duration_.Percentile(
-            kShortIdlePeriodDurationPercentile);
+        MainThreadOnly().estimated_next_frame_begin);
+    MainThreadOnly().short_idle_period_duration.InsertSample(
+        MainThreadOnly().estimated_next_frame_begin - now);
+  } else {
+    // There was no idle time :(
+    MainThreadOnly().short_idle_period_duration.InsertSample(base::TimeDelta());
   }
+
+  MainThreadOnly().expected_short_idle_period_duration =
+      MainThreadOnly().short_idle_period_duration.Percentile(
+          kShortIdlePeriodDurationPercentile);
 }
 
 void RendererSchedulerImpl::BeginFrameNotExpectedSoon() {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                "RendererSchedulerImpl::BeginFrameNotExpectedSoon");
   helper_.CheckOnValidThread();
   if (helper_.IsShutdown())
     return;
 
   idle_helper_.EnableLongIdlePeriod();
 }
 
 void RendererSchedulerImpl::OnRendererHidden() {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                "RendererSchedulerImpl::OnRendererHidden");
   helper_.CheckOnValidThread();
-  if (helper_.IsShutdown() || MainThreadOnly().renderer_hidden_)
+  if (helper_.IsShutdown() || MainThreadOnly().renderer_hidden)
     return;
 
   idle_helper_.EnableLongIdlePeriod();
 
   // Ensure that we stop running idle tasks after a few seconds of being hidden.
   end_renderer_hidden_idle_period_closure_.Cancel();
   base::TimeDelta end_idle_when_hidden_delay =
       base::TimeDelta::FromMilliseconds(kEndIdleWhenHiddenDelayMillis);
   control_task_runner_->PostDelayedTask(
       FROM_HERE, end_renderer_hidden_idle_period_closure_.callback(),
       end_idle_when_hidden_delay);
-  MainThreadOnly().renderer_hidden_ = true;
+  MainThreadOnly().renderer_hidden = true;
 
   TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "RendererScheduler",
       this, AsValue(helper_.Now()));
 }
 
 void RendererSchedulerImpl::OnRendererVisible() {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                "RendererSchedulerImpl::OnRendererVisible");
   helper_.CheckOnValidThread();
-  if (helper_.IsShutdown() || !MainThreadOnly().renderer_hidden_)
+  if (helper_.IsShutdown() || !MainThreadOnly().renderer_hidden)
     return;
 
   end_renderer_hidden_idle_period_closure_.Cancel();
-  MainThreadOnly().renderer_hidden_ = false;
+  MainThreadOnly().renderer_hidden = false;
   EndIdlePeriod();
 
   TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "RendererScheduler",
       this, AsValue(helper_.Now()));
 }
 
 void RendererSchedulerImpl::EndIdlePeriod() {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                "RendererSchedulerImpl::EndIdlePeriod");
@@ skipping 39 matching lines @@
   UpdateForInputEventOnCompositorThread(
       blink::WebInputEvent::Undefined,
       InputEventState::EVENT_CONSUMED_BY_COMPOSITOR);
 }
 
 void RendererSchedulerImpl::UpdateForInputEventOnCompositorThread(
     blink::WebInputEvent::Type type,
     InputEventState input_event_state) {
   base::AutoLock lock(any_thread_lock_);
   base::TimeTicks now = helper_.Now();
-  bool was_in_compositor_priority = InputSignalsSuggestCompositorPriority(now);
+
+  // TODO(alexclarke): Move WebInputEventTraits where we can access it from here
+  // and record the name rather than the integer representation.
+  TRACE_EVENT2(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
+               "RendererSchedulerImpl::UpdateForInputEventOnCompositorThread",
+               "type", static_cast<int>(type), "input_event_state",
+               InputEventStateToString(input_event_state));
+
+  bool gesture_already_in_progress = InputSignalsSuggestGestureInProgress(now);
   bool was_awaiting_touch_start_response =
-      AnyThread().awaiting_touch_start_response_;
+      AnyThread().awaiting_touch_start_response;
+
+  AnyThread().user_model.DidHandleInputEventOnCompositorThread(
+      type, input_event_state, now);
 
   if (type) {
     switch (type) {
       case blink::WebInputEvent::TouchStart:
-        AnyThread().awaiting_touch_start_response_ = true;
+        AnyThread().awaiting_touch_start_response = true;
         break;
 
       case blink::WebInputEvent::TouchMove:
         // Observation of consecutive touchmoves is a strong signal that the
         // page is consuming the touch sequence, in which case touchstart
         // response prioritization is no longer necessary. Otherwise, the
         // initial touchmove should preserve the touchstart response pending
         // state.
-        if (AnyThread().awaiting_touch_start_response_ &&
-            CompositorThreadOnly().last_input_type_ ==
+        if (AnyThread().awaiting_touch_start_response &&
+            CompositorThreadOnly().last_input_type ==
                 blink::WebInputEvent::TouchMove) {
-          AnyThread().awaiting_touch_start_response_ = false;
+          AnyThread().awaiting_touch_start_response = false;
         }
         break;
 
       case blink::WebInputEvent::Undefined:
       case blink::WebInputEvent::GestureTapDown:
       case blink::WebInputEvent::GestureShowPress:
       case blink::WebInputEvent::GestureFlingCancel:
       case blink::WebInputEvent::GestureScrollEnd:
         // With no observable effect, these meta events do not indicate a
         // meaningful touchstart response and should not impact task priority.
         break;
 
       default:
-        AnyThread().awaiting_touch_start_response_ = false;
+        AnyThread().awaiting_touch_start_response = false;
         break;
     }
   }
 
-  // Avoid unnecessary policy updates, while in compositor priority.
-  if (!was_in_compositor_priority ||
+  // Avoid unnecessary policy updates, while a gesture is already in progress.
+  if (!gesture_already_in_progress ||
       was_awaiting_touch_start_response !=
-          AnyThread().awaiting_touch_start_response_) {
+          AnyThread().awaiting_touch_start_response) {
     EnsureUrgentPolicyUpdatePostedOnMainThread(FROM_HERE);
   }
-  AnyThread().last_input_signal_time_ = now;
-  CompositorThreadOnly().last_input_type_ = type;
-
-  if (input_event_state == InputEventState::EVENT_FORWARDED_TO_MAIN_THREAD)
-    AnyThread().pending_main_thread_input_event_count_++;
+  CompositorThreadOnly().last_input_type = type;
 }
 
 void RendererSchedulerImpl::DidHandleInputEventOnMainThread(
     const blink::WebInputEvent& web_input_event) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                "RendererSchedulerImpl::DidHandleInputEventOnMainThread");
   helper_.CheckOnValidThread();
   if (ShouldPrioritizeInputEvent(web_input_event)) {
     base::AutoLock lock(any_thread_lock_);
-    AnyThread().last_input_signal_time_ = helper_.Now();
-    if (AnyThread().pending_main_thread_input_event_count_ > 0)
-      AnyThread().pending_main_thread_input_event_count_--;
+    AnyThread().user_model.DidHandleInputEventOnMainThread(helper_.Now());
   }
 }
 
 bool RendererSchedulerImpl::IsHighPriorityWorkAnticipated() {
   helper_.CheckOnValidThread();
   if (helper_.IsShutdown())
     return false;
 
   MaybeUpdatePolicy();
-  // The touchstart and compositor policies indicate a strong likelihood of
-  // high-priority work in the near future.
-  return MainThreadOnly().current_policy_ == Policy::COMPOSITOR_PRIORITY ||
-         MainThreadOnly().current_policy_ ==
-             Policy::COMPOSITOR_CRITICAL_PATH_PRIORITY ||
-         MainThreadOnly().current_policy_ == Policy::TOUCHSTART_PRIORITY;
+  // The touchstart and main-thread scrolling states indicate a strong
+  // likelihood of high-priority work in the near future.
+  UseCase use_case = MainThreadOnly().current_use_case;
+  return MainThreadOnly().touchstart_expected_soon ||
+         use_case == UseCase::TOUCHSTART ||
+         use_case == UseCase::MAIN_THREAD_GESTURE;
 }
 
 bool RendererSchedulerImpl::ShouldYieldForHighPriorityWork() {
   helper_.CheckOnValidThread();
   if (helper_.IsShutdown())
     return false;
 
   MaybeUpdatePolicy();
-  // We only yield if we are in the compositor priority and there is compositor
-  // work outstanding, or if we are in the touchstart response priority.
-  // Note: even though the control queue is higher priority we don't yield for
-  // it since these tasks are not user-provided work and they are only intended
-  // to run before the next task, not interrupt the tasks.
-  switch (MainThreadOnly().current_policy_) {
-    case Policy::NORMAL:
-      return false;
+  // We only yield if there's a urgent task to be run now, or we are expecting
+  // one soon (touch start).
+  // Note: even though the control queue has the highest priority we don't yield
+  // for it since these tasks are not user-provided work and they are only
+  // intended to run before the next task, not interrupt the tasks.
+  switch (MainThreadOnly().current_use_case) {
+    case UseCase::NONE:
+      return MainThreadOnly().touchstart_expected_soon;
 
-    case Policy::COMPOSITOR_PRIORITY:
-      return !compositor_task_runner_->IsQueueEmpty();
+    case UseCase::COMPOSITOR_GESTURE:
+      return MainThreadOnly().touchstart_expected_soon;
 
-    case Policy::COMPOSITOR_CRITICAL_PATH_PRIORITY:
-      return !compositor_task_runner_->IsQueueEmpty();
+    case UseCase::MAIN_THREAD_GESTURE:
+      return !compositor_task_runner_->IsQueueEmpty() ||
+             MainThreadOnly().touchstart_expected_soon;
 
-    case Policy::TOUCHSTART_PRIORITY:
+    case UseCase::TOUCHSTART:
       return true;
 
-    case Policy::LOADING_PRIORITY:
+    case UseCase::LOADING:
       return false;
 
     default:
       NOTREACHED();
       return false;
   }
 }
 
 base::TimeTicks RendererSchedulerImpl::CurrentIdleTaskDeadlineForTesting()
     const {
@@ skipping 30 matching lines @@
 
 void RendererSchedulerImpl::UpdatePolicyLocked(UpdateType update_type) {
   helper_.CheckOnValidThread();
   any_thread_lock_.AssertAcquired();
   if (helper_.IsShutdown())
     return;
 
   base::TimeTicks now = helper_.Now();
   policy_may_need_update_.SetWhileLocked(false);
 
-  AnyThread().timer_tasks_seem_expensive_ =
-      MainThreadOnly().expected_short_idle_period_duration_ >
-          base::TimeDelta() &&
-      MainThreadOnly().timer_task_cost_estimator_.expected_task_duration() >
-          MainThreadOnly().expected_short_idle_period_duration_;
+  base::TimeDelta expected_use_case_duration;
+  UseCase use_case = ComputeCurrentUseCase(now, &expected_use_case_duration);
+  MainThreadOnly().current_use_case = use_case;
 
-  base::TimeDelta new_policy_duration;
-  Policy new_policy = ComputeNewPolicy(now, &new_policy_duration);
+  // TODO(alexclarke): We should wire up a signal from blink to let us know if
+  // there are any touch handlers registerd or not, and only call
+  // TouchStartExpectedSoon if there is at least one.
+  base::TimeDelta scroll_expected_flag_valid_for_duration;
+  bool touchstart_expected_soon = AnyThread().user_model.TouchStartExpectedSoon(
+      use_case, now, &scroll_expected_flag_valid_for_duration);
+  MainThreadOnly().touchstart_expected_soon = touchstart_expected_soon;
+
+  bool loading_tasks_seem_expensive =
+      MainThreadOnly().loading_task_cost_estimator.expected_task_duration() >
+      MainThreadOnly().expected_short_idle_period_duration;
+  MainThreadOnly().loading_tasks_seem_expensive = loading_tasks_seem_expensive;
+
+  bool timer_tasks_seem_expensive =
+      MainThreadOnly().timer_task_cost_estimator.expected_task_duration() >
+      MainThreadOnly().expected_short_idle_period_duration;
+  MainThreadOnly().timer_tasks_seem_expensive = timer_tasks_seem_expensive;
+
+  // The |new_policy_duration| is the minimum of |expected_use_case_duration|
+  // and |scroll_expected_flag_valid_for_duration| unless one is zero in which
+  // case we choose the other.
+  base::TimeDelta new_policy_duration = expected_use_case_duration;
+  if (new_policy_duration == base::TimeDelta() ||
+      (scroll_expected_flag_valid_for_duration > base::TimeDelta() &&
+       new_policy_duration > scroll_expected_flag_valid_for_duration)) {
+    new_policy_duration = scroll_expected_flag_valid_for_duration;
+  }
+
   if (new_policy_duration > base::TimeDelta()) {
-    MainThreadOnly().current_policy_expiration_time_ =
-        now + new_policy_duration;
+    MainThreadOnly().current_policy_expiration_time = now + new_policy_duration;
     delayed_update_policy_runner_.SetDeadline(FROM_HERE, new_policy_duration,
                                               now);
   } else {
-    MainThreadOnly().current_policy_expiration_time_ = base::TimeTicks();
+    MainThreadOnly().current_policy_expiration_time = base::TimeTicks();
   }
 
-  if (update_type == UpdateType::MAY_EARLY_OUT_IF_POLICY_UNCHANGED &&
-      new_policy == MainThreadOnly().current_policy_)
-    return;
+  Policy new_policy;
+  bool block_expensive_tasks = false;
+  switch (use_case) {
+    case UseCase::COMPOSITOR_GESTURE:
+      if (touchstart_expected_soon)
+        block_expensive_tasks = true;
+      else
+        new_policy.loading_queue_priority = TaskQueue::HIGH_PRIORITY;
+      break;
 
-  TaskQueue::QueuePriority compositor_queue_priority =
-      TaskQueue::NORMAL_PRIORITY;
-  TaskQueue::QueuePriority loading_queue_priority = TaskQueue::NORMAL_PRIORITY;
-  TaskQueue::QueuePriority timer_queue_priority =
-      MainThreadOnly().timer_queue_suspend_count_ != 0
-          ? TaskQueue::DISABLED_PRIORITY
-          : TaskQueue::NORMAL_PRIORITY;
+    case UseCase::MAIN_THREAD_GESTURE:
+      new_policy.compositor_queue_priority = TaskQueue::HIGH_PRIORITY;
+      block_expensive_tasks = true;
+      break;
 
-  switch (new_policy) {
-    case Policy::COMPOSITOR_PRIORITY:
-      compositor_queue_priority = TaskQueue::HIGH_PRIORITY;
+    case UseCase::TOUCHSTART:
+      new_policy.compositor_queue_priority = TaskQueue::HIGH_PRIORITY;
+      new_policy.loading_queue_priority = TaskQueue::DISABLED_PRIORITY;
+      new_policy.timer_queue_priority = TaskQueue::DISABLED_PRIORITY;
       break;
-    case Policy::COMPOSITOR_CRITICAL_PATH_PRIORITY:
-      compositor_queue_priority = TaskQueue::HIGH_PRIORITY;
-      loading_queue_priority = TaskQueue::DISABLED_PRIORITY;
-      timer_queue_priority = TaskQueue::DISABLED_PRIORITY;
+
+    case UseCase::NONE:
+      if (touchstart_expected_soon)
+        block_expensive_tasks = true;
+      else
+        new_policy.loading_queue_priority = TaskQueue::HIGH_PRIORITY;
       break;
-    case Policy::TOUCHSTART_PRIORITY:
-      compositor_queue_priority = TaskQueue::HIGH_PRIORITY;
-      loading_queue_priority = TaskQueue::DISABLED_PRIORITY;
-      timer_queue_priority = TaskQueue::DISABLED_PRIORITY;
-      break;
-    case Policy::NORMAL:
-      break;
-    case Policy::LOADING_PRIORITY:
-      // We prioritize loading tasks by deprioritizing compositing and timers.
-      compositor_queue_priority = TaskQueue::BEST_EFFORT_PRIORITY;
-      timer_queue_priority = TaskQueue::BEST_EFFORT_PRIORITY;
-      // TODO(alexclarke): See if we can safely mark the loading task queue as
-      // high priority.
+
+    case UseCase::LOADING:
+      new_policy.loading_queue_priority = TaskQueue::HIGH_PRIORITY;
       break;
     default:
       NOTREACHED();
   }
 
-  compositor_task_runner_->SetQueuePriority(compositor_queue_priority);
-  loading_task_runner_->SetQueuePriority(loading_queue_priority);
-  timer_task_runner_->SetQueuePriority(timer_queue_priority);
+  if (block_expensive_tasks && loading_tasks_seem_expensive)
+    new_policy.loading_queue_priority = TaskQueue::DISABLED_PRIORITY;
 
-  DCHECK(compositor_task_runner_->IsQueueEnabled());
-  if (new_policy != Policy::TOUCHSTART_PRIORITY &&
-      new_policy != Policy::COMPOSITOR_CRITICAL_PATH_PRIORITY) {
-    DCHECK(loading_task_runner_->IsQueueEnabled());
-  }
-  MainThreadOnly().current_policy_ = new_policy;
+  if ((block_expensive_tasks && timer_tasks_seem_expensive) ||
+      MainThreadOnly().timer_queue_suspend_count != 0)
+    new_policy.timer_queue_priority = TaskQueue::DISABLED_PRIORITY;
 
+  // Tracing is done before the early out check, because it's quite possible we

[Sami, 2015/08/27 15:15:59]

Should we only do this if the use case or the policy changes? Otherwise I think
this can become a little too spammy.

[alex clarke (OOO till 29th), 2015/09/03 10:34:25]

I actually think it was way too hard to figure out what state the scheduler was
in before if you started recording after the policy was set.  This does spam
more, but it's still several orders of magnitude less than the task queue
manager logging.

WDYT?

+  // will otherwise miss this information in traces.
   TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "RendererScheduler",
       this, AsValueLocked(now));
+  TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "use_case",
+                 use_case);
   TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
-                 "RendererScheduler.policy", MainThreadOnly().current_policy_);
+                 "RendererScheduler.loading_tasks_seem_expensive",
+                 MainThreadOnly().loading_tasks_seem_expensive);
   TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                  "RendererScheduler.timer_tasks_seem_expensive",
-                 AnyThread().timer_tasks_seem_expensive_);
+                 MainThreadOnly().timer_tasks_seem_expensive);
+
+  if (update_type == UpdateType::MAY_EARLY_OUT_IF_POLICY_UNCHANGED &&
+      new_policy == MainThreadOnly().current_policy) {
+    return;
+  }
+
+  compositor_task_runner_->SetQueuePriority(
+      new_policy.compositor_queue_priority);
+  loading_task_runner_->SetQueuePriority(new_policy.loading_queue_priority);
+  timer_task_runner_->SetQueuePriority(new_policy.timer_queue_priority);
+
+  DCHECK(compositor_task_runner_->IsQueueEnabled());
+  MainThreadOnly().current_policy = new_policy;
 }
 
-bool RendererSchedulerImpl::InputSignalsSuggestCompositorPriority(
+bool RendererSchedulerImpl::InputSignalsSuggestGestureInProgress(
     base::TimeTicks now) const {
   base::TimeDelta unused_policy_duration;
-  switch (ComputeNewPolicy(now, &unused_policy_duration)) {
-    case Policy::TOUCHSTART_PRIORITY:
-    case Policy::COMPOSITOR_PRIORITY:
-    case Policy::COMPOSITOR_CRITICAL_PATH_PRIORITY:
+  switch (ComputeCurrentUseCase(now, &unused_policy_duration)) {
+    case UseCase::COMPOSITOR_GESTURE:
+    case UseCase::MAIN_THREAD_GESTURE:
+    case UseCase::TOUCHSTART:
       return true;
 
     default:
       break;
   }
   return false;
 }
 
-RendererSchedulerImpl::Policy RendererSchedulerImpl::ComputeNewPolicy(
+RendererSchedulerImpl::UseCase RendererSchedulerImpl::ComputeCurrentUseCase(
     base::TimeTicks now,
-    base::TimeDelta* new_policy_duration) const {
+    base::TimeDelta* expected_use_case_duration) const {
   any_thread_lock_.AssertAcquired();
   // Above all else we want to be responsive to user input.
-  *new_policy_duration = TimeLeftInInputEscalatedPolicy(now);
-  if (*new_policy_duration > base::TimeDelta()) {
-    if (AnyThread().awaiting_touch_start_response_)
-      return Policy::TOUCHSTART_PRIORITY;
-    // If BeginMainFrame is on the critical path, we want to try and prevent
-    // timers and loading tasks from running if we think they might be
-    // expensive.
+  *expected_use_case_duration =
+      AnyThread().user_model.TimeLeftInInputEscalatedPolicy(now);
+  if (*expected_use_case_duration > base::TimeDelta()) {
+    // Has scrolling been fully established?
+    if (AnyThread().awaiting_touch_start_response) {
+      // No, so arrange for compositor tasks to be run at the highest priority.
+      return UseCase::TOUCHSTART;
+    }
+    // Yes scrolling has been established.  If BeginMainFrame is on the critical
+    // path, compositor tasks need to be prioritized, otherwise now might be a
+    // good time to run potentially expensive work.
     // TODO(skyostil): Consider removing in_idle_period_ and
     // HadAnIdlePeriodRecently() unless we need them here.
-    if (AnyThread().timer_tasks_seem_expensive_ &&
-        AnyThread().begin_main_frame_on_critical_path_) {
-      return Policy::COMPOSITOR_CRITICAL_PATH_PRIORITY;
+    if (AnyThread().begin_main_frame_on_critical_path) {
+      return UseCase::MAIN_THREAD_GESTURE;
+    } else {
+      return UseCase::COMPOSITOR_GESTURE;
     }
-    return Policy::COMPOSITOR_PRIORITY;
   }
 
-  if (AnyThread().rails_loading_priority_deadline_ > now) {
-    *new_policy_duration = AnyThread().rails_loading_priority_deadline_ - now;
-    return Policy::LOADING_PRIORITY;
+  if (AnyThread().rails_loading_priority_deadline > now) {
+    *expected_use_case_duration =
+        AnyThread().rails_loading_priority_deadline - now;
+    return UseCase::LOADING;
   }
 
-  return Policy::NORMAL;
-}
-
-base::TimeDelta RendererSchedulerImpl::TimeLeftInInputEscalatedPolicy(
-    base::TimeTicks now) const {
-  any_thread_lock_.AssertAcquired();
-
-  base::TimeDelta escalated_priority_duration =
-      base::TimeDelta::FromMilliseconds(kPriorityEscalationAfterInputMillis);
-
-  // If the input event is still pending, go into input prioritized policy
-  // and check again later.
-  if (AnyThread().pending_main_thread_input_event_count_ > 0)
-    return escalated_priority_duration;
-  if (AnyThread().last_input_signal_time_.is_null() ||
-      AnyThread().last_input_signal_time_ + escalated_priority_duration < now) {
-    return base::TimeDelta();
-  }
-  return AnyThread().last_input_signal_time_ + escalated_priority_duration -
-         now;
+  return UseCase::NONE;
 }
 
 bool RendererSchedulerImpl::CanEnterLongIdlePeriod(
     base::TimeTicks now,
     base::TimeDelta* next_long_idle_period_delay_out) {
   helper_.CheckOnValidThread();
 
   MaybeUpdatePolicy();
-  if (MainThreadOnly().current_policy_ == Policy::TOUCHSTART_PRIORITY) {
+  if (MainThreadOnly().current_use_case == UseCase::TOUCHSTART) {
     // Don't start a long idle task in touch start priority, try again when
     // the policy is scheduled to end.
     *next_long_idle_period_delay_out =
-        MainThreadOnly().current_policy_expiration_time_ - now;
+        MainThreadOnly().current_policy_expiration_time - now;
     return false;
   }
   return true;
 }
 
 SchedulerHelper* RendererSchedulerImpl::GetSchedulerHelperForTesting() {
   return &helper_;
 }
 
 void RendererSchedulerImpl::SuspendTimerQueue() {
-  MainThreadOnly().timer_queue_suspend_count_++;
+  MainThreadOnly().timer_queue_suspend_count++;
   ForceUpdatePolicy();
   DCHECK(!timer_task_runner_->IsQueueEnabled());
 }
 
 void RendererSchedulerImpl::ResumeTimerQueue() {
-  MainThreadOnly().timer_queue_suspend_count_--;
-  DCHECK_GE(MainThreadOnly().timer_queue_suspend_count_, 0);
+  MainThreadOnly().timer_queue_suspend_count--;
+  DCHECK_GE(MainThreadOnly().timer_queue_suspend_count, 0);
   ForceUpdatePolicy();
 }
 
-// static
-const char* RendererSchedulerImpl::PolicyToString(Policy policy) {
-  switch (policy) {
-    case Policy::NORMAL:
-      return "normal";
-    case Policy::COMPOSITOR_PRIORITY:
-      return "compositor";
-    case Policy::COMPOSITOR_CRITICAL_PATH_PRIORITY:
-      return "compositor_critical_path";
-    case Policy::TOUCHSTART_PRIORITY:
-      return "touchstart";
-    case Policy::LOADING_PRIORITY:
-      return "loading";
-    default:
-      NOTREACHED();
-      return nullptr;
-  }
-}
-
 scoped_refptr<base::trace_event::ConvertableToTraceFormat>
 RendererSchedulerImpl::AsValue(base::TimeTicks optional_now) const {
   base::AutoLock lock(any_thread_lock_);
   return AsValueLocked(optional_now);
 }
 
 scoped_refptr<base::trace_event::ConvertableToTraceFormat>
 RendererSchedulerImpl::AsValueLocked(base::TimeTicks optional_now) const {
   helper_.CheckOnValidThread();
   any_thread_lock_.AssertAcquired();
 
   if (optional_now.is_null())
     optional_now = helper_.Now();
   scoped_refptr<base::trace_event::TracedValue> state =
       new base::trace_event::TracedValue();
 
-  state->SetString("current_policy",
-                   PolicyToString(MainThreadOnly().current_policy_));
+  state->SetString("current_use_case",
+                   UseCaseToString(MainThreadOnly().current_use_case));
+  state->SetBoolean("loading_tasks_seem_expensive",
+                    MainThreadOnly().loading_tasks_seem_expensive);
+  state->SetBoolean("timer_tasks_seem_expensive",
+                    MainThreadOnly().timer_tasks_seem_expensive);
+  state->SetBoolean("touchstart_expected_soon",
+                    MainThreadOnly().touchstart_expected_soon);
   state->SetString("idle_period_state",
                    IdleHelper::IdlePeriodStateToString(
                        idle_helper_.SchedulerIdlePeriodState()));
-  state->SetBoolean("renderer_hidden", MainThreadOnly().renderer_hidden_);
+  state->SetBoolean("renderer_hidden", MainThreadOnly().renderer_hidden);
   state->SetDouble("now", (optional_now - base::TimeTicks()).InMillisecondsF());
-  state->SetDouble("last_input_signal_time",
-                   (AnyThread().last_input_signal_time_ - base::TimeTicks())
+  state->SetDouble(
+      "rails_loading_priority_deadline",
+      (AnyThread().rails_loading_priority_deadline - base::TimeTicks())
+          .InMillisecondsF());
+  state->SetDouble("last_idle_period_end_time",
+                   (AnyThread().last_idle_period_end_time - base::TimeTicks())
                        .InMillisecondsF());
-  state->SetDouble("rails_loading_priority_deadline",
-                   (AnyThread().rails_loading_priority_deadline_ -
-                    base::TimeTicks()).InMillisecondsF());
-  state->SetDouble("last_idle_period_end_time",
-                   (AnyThread().last_idle_period_end_time_ - base::TimeTicks())
+  state->SetBoolean("awaiting_touch_start_response",
+                    AnyThread().awaiting_touch_start_response);
+  state->SetBoolean("begin_main_frame_on_critical_path",
+                    AnyThread().begin_main_frame_on_critical_path);
+  state->SetDouble("expected_loading_task_duration",
+                   MainThreadOnly()
+                       .loading_task_cost_estimator.expected_task_duration()
                        .InMillisecondsF());
-  state->SetInteger("pending_main_thread_input_event_count",
-                    AnyThread().pending_main_thread_input_event_count_);
-  state->SetBoolean("awaiting_touch_start_response",
-                    AnyThread().awaiting_touch_start_response_);
-  state->SetBoolean("begin_main_frame_on_critical_path",
-                    AnyThread().begin_main_frame_on_critical_path_);
   state->SetDouble("expected_timer_task_duration",
                    MainThreadOnly()
-                       .timer_task_cost_estimator_.expected_task_duration()
+                       .timer_task_cost_estimator.expected_task_duration()
                        .InMillisecondsF());
   // TODO(skyostil): Can we somehow trace how accurate these estimates were?
   state->SetDouble(
       "expected_short_idle_period_duration",
-      MainThreadOnly().expected_short_idle_period_duration_.InMillisecondsF());
-  state->SetBoolean("timer_tasks_seem_expensive",
-                    AnyThread().timer_tasks_seem_expensive_);
-  state->SetDouble("estimated_next_frame_begin",
-                   (MainThreadOnly().estimated_next_frame_begin_ -
-                    base::TimeTicks()).InMillisecondsF());
-  state->SetBoolean("in_idle_period", AnyThread().in_idle_period_);
+      MainThreadOnly().expected_short_idle_period_duration.InMillisecondsF());
+  state->SetDouble(
+      "estimated_next_frame_begin",
+      (MainThreadOnly().estimated_next_frame_begin - base::TimeTicks())
+          .InMillisecondsF());
+  state->SetBoolean("in_idle_period", AnyThread().in_idle_period);
+  AnyThread().user_model.AsValueInto(state.get());
 
   return state;
 }
 
 void RendererSchedulerImpl::OnIdlePeriodStarted() {
   base::AutoLock lock(any_thread_lock_);
-  AnyThread().in_idle_period_ = true;
+  AnyThread().in_idle_period = true;
   UpdatePolicyLocked(UpdateType::MAY_EARLY_OUT_IF_POLICY_UNCHANGED);
 }
 
 void RendererSchedulerImpl::OnIdlePeriodEnded() {
   base::AutoLock lock(any_thread_lock_);
-  AnyThread().last_idle_period_end_time_ = helper_.Now();
-  AnyThread().in_idle_period_ = false;
+  AnyThread().last_idle_period_end_time = helper_.Now();
+  AnyThread().in_idle_period = false;
   UpdatePolicyLocked(UpdateType::MAY_EARLY_OUT_IF_POLICY_UNCHANGED);
 }
 
 void RendererSchedulerImpl::OnPageLoadStarted() {
   base::AutoLock lock(any_thread_lock_);
-  AnyThread().rails_loading_priority_deadline_ =
+  AnyThread().rails_loading_priority_deadline =
       helper_.Now() + base::TimeDelta::FromMilliseconds(
                           kRailsInitialLoadingPrioritizationMillis);
   UpdatePolicyLocked(UpdateType::MAY_EARLY_OUT_IF_POLICY_UNCHANGED);
 }
 
 bool RendererSchedulerImpl::HadAnIdlePeriodRecently(base::TimeTicks now) const {
-  return (now - AnyThread().last_idle_period_end_time_) <=
+  return (now - AnyThread().last_idle_period_end_time) <=
          base::TimeDelta::FromMilliseconds(
              kIdlePeriodStarvationThresholdMillis);
 }
 
 }  // namespace scheduler