scheduler: Detect when a main thread touch stream turns into a compositor gesture

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 386 matching lines @@
 }
 
 void RendererSchedulerImpl::EndIdlePeriodForTesting(
     const base::Closure& callback,
     base::TimeTicks time_remaining) {
   MainThreadOnly().in_idle_period_for_testing = false;
   EndIdlePeriod();
   callback.Run();
 }
 
+bool RendererSchedulerImpl::PolicyNeedsUpdateForTesting() {
+  return policy_may_need_update_.IsSet();
+}
+
 // static
 bool RendererSchedulerImpl::ShouldPrioritizeInputEvent(
     const blink::WebInputEvent& web_input_event) {
   // We regard MouseMove events with the left mouse button down as a signal
   // that the user is doing something requiring a smooth frame rate.
   if (web_input_event.type == blink::WebInputEvent::MouseMove &&
       (web_input_event.modifiers & blink::WebInputEvent::LeftButtonDown)) {
     return true;
   }
   // Ignore all other mouse events because they probably don't signal user
@@ skipping 34 matching lines @@
   base::AutoLock lock(any_thread_lock_);
   base::TimeTicks now = helper_.scheduler_tqm_delegate()->NowTicks();
 
   // 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);
+  base::TimeDelta unused_policy_duration;
+  UseCase previous_use_case =
+      ComputeCurrentUseCase(now, &unused_policy_duration);
   bool was_awaiting_touch_start_response =
       AnyThread().awaiting_touch_start_response;
 
   AnyThread().user_model.DidStartProcessingInputEvent(type, now);
 
   if (input_event_state == InputEventState::EVENT_CONSUMED_BY_COMPOSITOR)
     AnyThread().user_model.DidFinishProcessingInputEvent(now);
 
   if (type) {
     switch (type) {
@@ skipping 14 matching lines @@
         // 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;
         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
         // meaningful touchstart response and should not impact task priority.
         break;
 
       default:
         AnyThread().awaiting_touch_start_response = false;
         break;
     }
   }
 
-  // Avoid unnecessary policy updates, while a gesture is already in progress.
-  if (!gesture_already_in_progress ||
+  // Avoid unnecessary policy updates if the use case did not change.
+  UseCase use_case = ComputeCurrentUseCase(now, &unused_policy_duration);
+
+  if (use_case != previous_use_case ||
       was_awaiting_touch_start_response !=
           AnyThread().awaiting_touch_start_response) {
     EnsureUrgentPolicyUpdatePostedOnMainThread(FROM_HERE);
   }
   CompositorThreadOnly().last_input_type = type;
 }
 
 void RendererSchedulerImpl::DidHandleInputEventOnMainThread(
     const blink::WebInputEvent& web_input_event) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
@@ skipping 262 matching lines @@
   }
 
   // Tracing is done before the early out check, because it's quite possible we
   // 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"),
+                 "touchstart_expected_soon",
+                 MainThreadOnly().touchstart_expected_soon);
+  TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
+                 "expensive_task_policy", expensive_task_policy);
+  TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                  "RendererScheduler.loading_tasks_seem_expensive",
                  MainThreadOnly().loading_tasks_seem_expensive);
   TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                  "RendererScheduler.timer_tasks_seem_expensive",
                  MainThreadOnly().timer_tasks_seem_expensive);
 
   // TODO(alexclarke): Can we get rid of force update now?
   if (update_type == UpdateType::MAY_EARLY_OUT_IF_POLICY_UNCHANGED &&
       new_policy == MainThreadOnly().current_policy) {
     return;
@@ skipping 43 matching lines @@
       new_task_queue_policy.time_domain_type) {
     if (new_task_queue_policy.time_domain_type == TimeDomainType::THROTTLED) {
       throttling_helper_->IncreaseThrottleRefCount(task_queue);
     } else if (old_task_queue_policy.time_domain_type ==
                TimeDomainType::THROTTLED) {
       throttling_helper_->DecreaseThrottleRefCount(task_queue);
     }
   }
 }
 
-bool RendererSchedulerImpl::InputSignalsSuggestGestureInProgress(
-    base::TimeTicks now) const {
-  base::TimeDelta unused_policy_duration;
-  switch (ComputeCurrentUseCase(now, &unused_policy_duration)) {
-    case UseCase::COMPOSITOR_GESTURE:
-    case UseCase::MAIN_THREAD_GESTURE:
-    case UseCase::SYNCHRONIZED_GESTURE:
-    case UseCase::TOUCHSTART:
-      return true;
-
-    default:
-      break;
-  }
-  return false;
-}
-
 RendererSchedulerImpl::UseCase RendererSchedulerImpl::ComputeCurrentUseCase(
     base::TimeTicks now,
     base::TimeDelta* expected_use_case_duration) const {
   any_thread_lock_.AssertAcquired();
   // Special case for flings. This is needed because we don't get notification
   // of a fling ending (although we do for cancellation).
   if (AnyThread().fling_compositor_escalation_deadline > now &&
       !AnyThread().awaiting_touch_start_response) {
     *expected_use_case_duration =
         AnyThread().fling_compositor_escalation_deadline - now;
@@ skipping 378 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