scheduler: Reset gesture state at start of a mouse drag

third_party/WebKit/Source/platform/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 "platform/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 450 matching lines @@
 
 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 &&
+  if ((web_input_event.type == blink::WebInputEvent::MouseDown ||

[alex clarke (OOO till 29th), 2016/08/22 11:30:09]

Are we going to start blocking expensive tasks if the user clicks on something? 
Which ever way is decided, please add a test to lock in the behavior.

[Sami, 2016/08/22 13:25:14]

Right, we wouldn't want to do blocking based on a click. I've added a test.
Basically a mouse click now means main thread input handling, which can
prioritize compositing but won't block anything.

+       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
   // interaction needing a smooth framerate. NOTE isMouseEventType returns false
   // for mouse wheel events, hence we regard them as user input.
   // Ignore keyboard events because it doesn't really make sense to enter
   // compositor priority for them.
   if (blink::WebInputEvent::isMouseEventType(web_input_event.type) ||
       blink::WebInputEvent::isKeyboardEventType(web_input_event.type)) {
@@ skipping 39 matching lines @@
   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) {
+  if (type != blink::WebInputEvent::Undefined) {

[alex clarke (OOO till 29th), 2016/08/22 11:30:09]

Perhaps handle this as a case in the switch?

[Sami, 2016/08/22 13:25:15]

Good idea -- makes more sense that way.

     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.
@@ skipping 27 matching lines @@
         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;
 
+      case blink::WebInputEvent::MouseDown:
+        // Reset tracking state at the start of a new mouse drag gesture.
+        AnyThread().last_gesture_was_compositor_driven = false;
+        AnyThread().default_gesture_prevented = true;
+        break;
+
+      case blink::WebInputEvent::MouseMove:
+        // Consider mouse movement with the left button held down (see
+        // ShouldPrioritizeInputEvent) similarly to a touch gesture.
+        AnyThread().last_gesture_was_compositor_driven =
+            input_event_state == InputEventState::EVENT_CONSUMED_BY_COMPOSITOR;
+        AnyThread().awaiting_touch_start_response = false;
+        break;
+
       default:
         AnyThread().awaiting_touch_start_response = false;
         break;
     }
   }
 
   // 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 ||
@@ skipping 423 matching lines @@
     // Yes a gesture has been established.  Based on how the gesture is handled
     // 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. 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;
       }
     }
     if (AnyThread().default_gesture_prevented) {
       return UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING;
     } else {
@@ skipping 240 matching lines @@
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                "RendererSchedulerImpl::OnNavigationStarted");
   base::AutoLock lock(any_thread_lock_);
   AnyThread().rails_loading_priority_deadline =
       helper_.scheduler_tqm_delegate()->NowTicks() +
       base::TimeDelta::FromMilliseconds(
           kRailsInitialLoadingPrioritizationMillis);
   ResetForNavigationLocked();
 }
 
-bool RendererSchedulerImpl::HadAnIdlePeriodRecently(base::TimeTicks now) const {
-  return (now - AnyThread().last_idle_period_end_time) <=
-         base::TimeDelta::FromMilliseconds(
-             kIdlePeriodStarvationThresholdMillis);
-}
-
 void RendererSchedulerImpl::SuspendTimerQueueWhenBackgrounded() {
   DCHECK(MainThreadOnly().renderer_backgrounded);
   if (MainThreadOnly().timer_queue_suspended_when_backgrounded)
     return;
 
   MainThreadOnly().timer_queue_suspended_when_backgrounded = true;
   ForceUpdatePolicy();
 }
 
 void RendererSchedulerImpl::ResumeTimerQueueWhenForegrounded() {
@@ skipping 188 matching lines @@
     case v8::PERFORMANCE_LOAD:
       return "load";
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
 }  // namespace scheduler
 }  // namespace blink