Remove the requirement to only rAF align non-blocking touch moves.

content/renderer/input/main_thread_event_queue.cc

 // Copyright 2016 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 "content/renderer/input/main_thread_event_queue.h"
 
 #include "base/metrics/histogram_macros.h"
 #include "content/common/input/event_with_latency_info.h"
 #include "content/common/input_messages.h"
 
 namespace content {
 
 namespace {
 
 const size_t kTenSeconds = 10 * 1000 * 1000;
 
 bool IsContinuousEvent(const std::unique_ptr<EventWithDispatchType>& event) {
   switch (event->event().type) {
     case blink::WebInputEvent::MouseMove:
     case blink::WebInputEvent::MouseWheel:
+    case blink::WebInputEvent::TouchMove:
       return true;
-    case blink::WebInputEvent::TouchMove:
-      // TouchMoves that are blocking end up blocking scroll. Do not treat
-      // them as continuous events otherwise we will end up waiting up to an
-      // additional frame.
-      return static_cast<const blink::WebTouchEvent&>(event->event())
-                 .dispatchType != blink::WebInputEvent::Blocking;
     default:
       return false;
   }
 }
 
 }  // namespace
 
 EventWithDispatchType::EventWithDispatchType(
     ui::ScopedWebInputEvent event,
     const ui::LatencyInfo& latency,
@@ skipping 80 matching lines @@
       // touch move should also be passive.
       if (ack_result == INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING_DUE_TO_FLING ||
           last_touch_start_forced_nonblocking_due_to_fling_) {
         touch_event->dispatchType =
             blink::WebInputEvent::ListenersForcedNonBlockingDueToFling;
         non_blocking = true;
         last_touch_start_forced_nonblocking_due_to_fling_ = true;
       }
     }
 
-    // If handling rAF aligned touch input ACK non-cancelable events right
-    // away.
-    if (!non_blocking && IsRafAlignedEvent(*touch_event))
-      non_blocking = true;
-
     if (enable_non_blocking_due_to_main_thread_responsiveness_flag_ &&
         touch_event->dispatchType == blink::WebInputEvent::Blocking) {
       bool passive_due_to_unresponsive_main =
           renderer_scheduler_->MainThreadSeemsUnresponsive();
       if (passive_due_to_unresponsive_main) {
         touch_event->dispatchType = blink::WebInputEvent::
             ListenersForcedNonBlockingDueToMainThreadResponsiveness;
         non_blocking = true;
       }
     }
+    // If the event is non-cancelable ACK it right away.
+    if (!non_blocking &&
+        touch_event->dispatchType != blink::WebInputEvent::Blocking)
+      non_blocking = true;
   }
+
   if (is_wheel && non_blocking) {
     // Adjust the |dispatchType| on the event since the compositor
     // determined all event listeners are passive.
     static_cast<blink::WebMouseWheelEvent*>(event.get())
         ->dispatchType = blink::WebInputEvent::ListenersNonBlockingPassive;
   }
 
   InputEventDispatchType dispatch_type =
       non_blocking ? DISPATCH_TYPE_NON_BLOCKING : DISPATCH_TYPE_BLOCKING;
 
@@ skipping 179 matching lines @@
   return !handle_raf_aligned_mouse_input_ && !handle_raf_aligned_touch_input_;
 }
 
 bool MainThreadEventQueue::IsRafAlignedEvent(
     const blink::WebInputEvent& event) {
   switch (event.type) {
     case blink::WebInputEvent::MouseMove:
     case blink::WebInputEvent::MouseWheel:
       return handle_raf_aligned_mouse_input_;
     case blink::WebInputEvent::TouchMove:
-      // TouchMoves that are blocking end up blocking scroll. Do not treat
-      // them as continuous events otherwise we will end up waiting up to an
-      // additional frame.
-      return static_cast<const blink::WebTouchEvent&>(event).dispatchType !=
-                 blink::WebInputEvent::Blocking &&
-             handle_raf_aligned_touch_input_;
+      return handle_raf_aligned_touch_input_;
     default:
       return false;
   }
 }
 
 }  // namespace content