scheduler: Add main thread gesture as a detected use case

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/logging.h"
 #include "base/memory/ptr_util.h"
@@ skipping 122 matching lines @@
       expensive_task_blocking_allowed(true),
       in_idle_period_for_testing(false) {}
 
 RendererSchedulerImpl::MainThreadOnly::~MainThreadOnly() {}
 
 RendererSchedulerImpl::AnyThread::AnyThread()
     : awaiting_touch_start_response(false),
       in_idle_period(false),
       begin_main_frame_on_critical_path(false),
       last_gesture_was_compositor_driven(false),
+      default_gesture_prevented(true),
       have_seen_touchstart(false) {}
 
 RendererSchedulerImpl::AnyThread::~AnyThread() {}
 
 RendererSchedulerImpl::CompositorThreadOnly::CompositorThreadOnly()
     : last_input_type(blink::WebInputEvent::Undefined) {}
 
 RendererSchedulerImpl::CompositorThreadOnly::~CompositorThreadOnly() {}
 
 void RendererSchedulerImpl::Shutdown() {
@@ skipping 333 matching lines @@
 
   if (type) {
     switch (type) {
       case blink::WebInputEvent::TouchStart:
         AnyThread().awaiting_touch_start_response = true;
         // This is just a fail-safe to reset the state of
         // |last_gesture_was_compositor_driven| to the default. We don't know
         // yet where the gesture will run.
         AnyThread().last_gesture_was_compositor_driven = false;
         AnyThread().have_seen_touchstart = true;
+        // Assume the default gesture is prevented until we see evidence
+        // otherwise.
+        AnyThread().default_gesture_prevented = 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 ==
                 blink::WebInputEvent::TouchMove) {
           AnyThread().awaiting_touch_start_response = false;
         }
         break;
 
       case blink::WebInputEvent::GesturePinchUpdate:
       case blink::WebInputEvent::GestureScrollUpdate:
         // If we see events for an established gesture, we can lock it to the
         // appropriate thread as the gesture can no longer be cancelled.
         AnyThread().last_gesture_was_compositor_driven =
             input_event_state == InputEventState::EVENT_CONSUMED_BY_COMPOSITOR;
         AnyThread().awaiting_touch_start_response = false;
+        AnyThread().default_gesture_prevented = false;
         break;
 
       case blink::WebInputEvent::GestureFlingCancel:
         AnyThread().fling_compositor_escalation_deadline = base::TimeTicks();
         break;
 
       case blink::WebInputEvent::GestureTapDown:
       case blink::WebInputEvent::GestureShowPress:
       case blink::WebInputEvent::GestureScrollEnd:
         // With no observable effect, these meta events do not indicate a
@@ skipping 34 matching lines @@
   if (helper_.IsShutdown())
     return false;
 
   MaybeUpdatePolicy();
   // The touchstart, synchronized gesture and main-thread gesture use cases
   // 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 ||
+         use_case == UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING ||
          use_case == UseCase::SYNCHRONIZED_GESTURE;
 }
 
 bool RendererSchedulerImpl::ShouldYieldForHighPriorityWork() {
   helper_.CheckOnValidThread();
   if (helper_.IsShutdown())
     return false;
 
   MaybeUpdatePolicy();
   // 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::COMPOSITOR_GESTURE:
     case UseCase::NONE:
       return MainThreadOnly().touchstart_expected_soon;
 
     case UseCase::MAIN_THREAD_GESTURE:
+    case UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING:
     case UseCase::SYNCHRONIZED_GESTURE:
       return compositor_task_runner_->HasPendingImmediateWork() ||
              MainThreadOnly().touchstart_expected_soon;
 
     case UseCase::TOUCHSTART:
       return true;
 
     case UseCase::LOADING:
       return false;
 
@@ skipping 130 matching lines @@
       new_policy.compositor_queue_policy.priority =
           main_thread_compositing_is_fast ? TaskQueue::HIGH_PRIORITY
                                           : TaskQueue::NORMAL_PRIORITY;
       if (touchstart_expected_soon) {
         expensive_task_policy = ExpensiveTaskPolicy::BLOCK;
       } else {
         expensive_task_policy = ExpensiveTaskPolicy::THROTTLE;
       }
       break;
 
-    case UseCase::MAIN_THREAD_GESTURE:
-      // In main thread gestures we don't have perfect knowledge about which
-      // things we should be prioritizing, so we don't attempt to block
-      // expensive tasks because we don't know whether they were integral to the
-      // page's functionality or not.
+    case UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING:
+      // In main thread input handling scenarios we don't have perfect knowledge
+      // about which things we should be prioritizing, so we don't attempt to
+      // block expensive tasks because we don't know whether they were integral
+      // to the page's functionality or not.
       new_policy.compositor_queue_policy.priority =
           main_thread_compositing_is_fast ? TaskQueue::HIGH_PRIORITY
                                           : TaskQueue::NORMAL_PRIORITY;
       break;
 
+    case UseCase::MAIN_THREAD_GESTURE:
+      // A main thread gesture is for example a scroll gesture which is handled
+      // by the main thread. Since we know the established gesture type, we can
+      // be a little more aggressive about prioritizing compositing and input
+      // handling over other tasks.
+      new_policy.compositor_queue_policy.priority = TaskQueue::HIGH_PRIORITY;
+      if (touchstart_expected_soon) {
+        expensive_task_policy = ExpensiveTaskPolicy::BLOCK;
+      } else {
+        expensive_task_policy = ExpensiveTaskPolicy::THROTTLE;
+      }
+      break;
+
     case UseCase::TOUCHSTART:
       new_policy.compositor_queue_policy.priority = TaskQueue::HIGH_PRIORITY;
       new_policy.loading_queue_policy.is_enabled = false;
       new_policy.timer_queue_policy.is_enabled = false;
       // NOTE this is a nop due to the above.
       expensive_task_policy = ExpensiveTaskPolicy::BLOCK;
       break;
 
     case UseCase::NONE:
       // It's only safe to block tasks that if we are expecting a compositor
@@ skipping 142 matching lines @@
   *expected_use_case_duration =
       AnyThread().user_model.TimeLeftInUserGesture(now);
   if (*expected_use_case_duration > base::TimeDelta()) {
     // Has a gesture 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 a gesture has been established.  Based on how the gesture is handled
-    // we need to choose between one of three use cases:
+    // we need to choose between one of four use cases:
     // 1. COMPOSITOR_GESTURE where the gesture is processed only on the
     //    compositor thread.
     // 2. MAIN_THREAD_GESTURE where the gesture is processed only on the main
     //    thread.
-    // 3. SYNCHRONIZED_GESTURE where the gesture is processed on both threads.
+    // 3. MAIN_THREAD_CUSTOM_INPUT_HANDLING where the main thread processes a
+    //    stream of input events and has prevented a default gesture from being
+    //    started.
+    // 4. SYNCHRONIZED_GESTURE where the gesture is processed on both threads.
     // TODO(skyostil): Consider removing in_idle_period_ and
     // HadAnIdlePeriodRecently() unless we need them here.
     if (AnyThread().last_gesture_was_compositor_driven) {
       if (AnyThread().begin_main_frame_on_critical_path) {
         return UseCase::SYNCHRONIZED_GESTURE;
       } else {
         return UseCase::COMPOSITOR_GESTURE;
       }
     }
-    return UseCase::MAIN_THREAD_GESTURE;
+    if (AnyThread().default_gesture_prevented) {
+      return UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING;
+    } else {
+      return UseCase::MAIN_THREAD_GESTURE;
+    }
   }
 
   // TODO(alexclarke): return UseCase::LOADING if signals suggest the system is
   // in the initial 1s of RAIL loading.
   return UseCase::NONE;
 }
 
 base::TimeDelta RendererSchedulerImpl::EstimateLongestJankFreeTaskDuration()
     const {
   switch (MainThreadOnly().current_use_case) {
     case UseCase::TOUCHSTART:
     case UseCase::COMPOSITOR_GESTURE:
     case UseCase::LOADING:
     case UseCase::NONE:
       return base::TimeDelta::FromMilliseconds(kRailsResponseTimeMillis);
 
+    case UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING:
     case UseCase::MAIN_THREAD_GESTURE:
     case UseCase::SYNCHRONIZED_GESTURE:
       return MainThreadOnly().idle_time_estimator.GetExpectedIdleDuration(
           MainThreadOnly().compositor_frame_interval);
 
     default:
       NOTREACHED();
       return base::TimeDelta::FromMilliseconds(kRailsResponseTimeMillis);
   }
 }
@@ skipping 133 matching lines @@
                     MainThreadOnly().navigation_task_expected_count);
   state->SetDouble("last_idle_period_end_time",
                    (AnyThread().last_idle_period_end_time - base::TimeTicks())
                        .InMillisecondsF());
   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->SetBoolean("last_gesture_was_compositor_driven",
                     AnyThread().last_gesture_was_compositor_driven);
+  state->SetBoolean("default_gesture_prevented",
+                    AnyThread().default_gesture_prevented);
   state->SetDouble("expected_loading_task_duration",
                    MainThreadOnly()
                        .loading_task_cost_estimator.expected_task_duration()
                        .InMillisecondsF());
   state->SetDouble("expected_timer_task_duration",
                    MainThreadOnly()
                        .timer_task_cost_estimator.expected_task_duration()
                        .InMillisecondsF());
   // TODO(skyostil): Can we somehow trace how accurate these estimates were?
   state->SetDouble(
@@ skipping 175 matching lines @@
     }
     MainThreadOnly().have_reported_blocking_intervention_since_navigation =
         true;
     BroadcastConsoleWarning(
         "Deferred long-running timer task(s) to improve scrolling smoothness. "
         "See crbug.com/574343.");
   }
 }
 
 }  // namespace scheduler