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 ||
+       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) {
-    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;
+  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::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::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::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;
+    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;
-    }
+    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;
+
+    case blink::WebInputEvent::Undefined:
+      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 ||
       was_awaiting_touch_start_response !=
           AnyThread().awaiting_touch_start_response) {
     EnsureUrgentPolicyUpdatePostedOnMainThread(FROM_HERE);
   }
@@ skipping 419 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