Teach MainThreadEventQueue about touchmove throttling.

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/field_trial.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "content/common/input/event_with_latency_info.h"
 #include "content/common/input_messages.h"
 
 namespace content {
 
 namespace {
 
+// Time interval at which touchmove events will be skipped during rAF signal.
+const base::TimeDelta kAsyncTouchMoveInterval =
+    base::TimeDelta::FromMilliseconds(200);
+
 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;
     default:
       return false;
   }
 }
 
+bool IsAsyncTouchMove(const std::unique_ptr<EventWithDispatchType>& event) {
+  if (event->event().type() != blink::WebInputEvent::TouchMove)
+    return false;
+  const blink::WebTouchEvent& touch_event =
+      static_cast<const blink::WebTouchEvent&>(event->event());
+  return touch_event.movedBeyondSlopRegion && !event->originallyCancelable();
+}
+
 }  // namespace
 
 EventWithDispatchType::EventWithDispatchType(
     ui::WebScopedInputEvent event,
     const ui::LatencyInfo& latency,
-    InputEventDispatchType dispatch_type)
+    InputEventDispatchType dispatch_type,
+    bool originally_cancelable)
     : ScopedWebInputEventWithLatencyInfo(std::move(event), latency),
       dispatch_type_(dispatch_type),
       non_blocking_coalesced_count_(0),
       creation_timestamp_(base::TimeTicks::Now()),
-      last_coalesced_timestamp_(creation_timestamp_) {}
+      last_coalesced_timestamp_(creation_timestamp_),
+      originally_cancelable_(originally_cancelable) {}
 
 EventWithDispatchType::~EventWithDispatchType() {}
 
 void EventWithDispatchType::CoalesceWith(const EventWithDispatchType& other) {
   // If this event was blocking push the event id to the blocking
   // list before updating the dispatch_type of this event.
   if (dispatch_type_ == DISPATCH_TYPE_BLOCKING) {
     blocking_coalesced_event_ids_.push_back(
         ui::WebInputEventTraits::GetUniqueTouchEventId(event()));
   } else {
     non_blocking_coalesced_count_++;
   }
   ScopedWebInputEventWithLatencyInfo::CoalesceWith(other);
   dispatch_type_ = other.dispatch_type_;
   last_coalesced_timestamp_ = base::TimeTicks::Now();
+  originally_cancelable_ = other.originally_cancelable_;
 }
 
 MainThreadEventQueue::SharedState::SharedState()
     : sent_main_frame_request_(false) {}
 
 MainThreadEventQueue::SharedState::~SharedState() {}
 
 MainThreadEventQueue::MainThreadEventQueue(
     int routing_id,
     MainThreadEventQueueClient* client,
@@ skipping 43 matching lines @@
   DCHECK(original_dispatch_type == DISPATCH_TYPE_BLOCKING ||
          original_dispatch_type == DISPATCH_TYPE_NON_BLOCKING);
   DCHECK(ack_result == INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING ||
          ack_result == INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING_DUE_TO_FLING ||
          ack_result == INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 
   bool non_blocking = original_dispatch_type == DISPATCH_TYPE_NON_BLOCKING ||
                       ack_result == INPUT_EVENT_ACK_STATE_SET_NON_BLOCKING;
   bool is_wheel = event->type() == blink::WebInputEvent::MouseWheel;
   bool is_touch = blink::WebInputEvent::isTouchEventType(event->type());
+  bool originally_cancelable = false;
 
   if (is_touch) {
     blink::WebTouchEvent* touch_event =
         static_cast<blink::WebTouchEvent*>(event.get());
 
+    originally_cancelable =
+        touch_event->dispatchType == blink::WebInputEvent::Blocking;
+
     // Adjust the |dispatchType| on the event since the compositor
     // determined all event listeners are passive.
     if (non_blocking) {
       touch_event->dispatchType =
           blink::WebInputEvent::ListenersNonBlockingPassive;
     }
     if (touch_event->type() == blink::WebInputEvent::TouchStart)
       last_touch_start_forced_nonblocking_due_to_fling_ = false;
 
     if (enable_fling_passive_listener_flag_ &&
@@ skipping 20 matching lines @@
             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;
+  if (is_wheel) {
+    blink::WebMouseWheelEvent* wheel_event =
+        static_cast<blink::WebMouseWheelEvent*>(event.get());
+    originally_cancelable =
+        wheel_event->dispatchType == blink::WebInputEvent::Blocking;
+    if (non_blocking) {
+      // Adjust the |dispatchType| on the event since the compositor
+      // determined all event listeners are passive.
+      wheel_event->dispatchType =
+          blink::WebInputEvent::ListenersNonBlockingPassive;
+    }
   }
 
   InputEventDispatchType dispatch_type =
       non_blocking ? DISPATCH_TYPE_NON_BLOCKING : DISPATCH_TYPE_BLOCKING;
 
   std::unique_ptr<EventWithDispatchType> event_with_dispatch_type(
-      new EventWithDispatchType(std::move(event), latency, dispatch_type));
+      new EventWithDispatchType(std::move(event), latency, dispatch_type,
+                                originally_cancelable));
 
   QueueEvent(std::move(event_with_dispatch_type));
 
   // send an ack when we are non-blocking.
   return non_blocking;
 }
 
 void MainThreadEventQueue::DispatchInFlightEvent() {
   if (in_flight_event_) {
     // Report the coalesced count only for continuous events; otherwise
@@ skipping 76 matching lines @@
     for (const auto id : in_flight_event_->blockingCoalescedEventIds()) {
       client_->SendInputEventAck(routing_id_, type, ack_result, id);
       if (renderer_scheduler_) {
         renderer_scheduler_->DidHandleInputEventOnMainThread(
             in_flight_event_->event(), result);
       }
     }
   }
 }
 
-void MainThreadEventQueue::DispatchRafAlignedInput() {
+void MainThreadEventQueue::DispatchRafAlignedInput(base::TimeTicks frame_time) {
   if (IsRafAlignedInputDisabled())
     return;
 
   std::deque<std::unique_ptr<EventWithDispatchType>> events_to_process;
   {
     base::AutoLock lock(shared_state_lock_);
     shared_state_.sent_main_frame_request_ = false;
 
-    while(!shared_state_.events_.empty()) {
+    while (!shared_state_.events_.empty()) {
       if (!IsRafAlignedEvent(shared_state_.events_.front()->event()))
         break;
+
+      // Throttle touchmoves that are async.
+      if (handle_raf_aligned_touch_input_ &&
+          IsAsyncTouchMove(shared_state_.events_.front())) {
+        if (shared_state_.events_.size() == 1 &&
+            frame_time < shared_state_.last_async_touch_move_timestamp_ +
+                             kAsyncTouchMoveInterval) {
+          break;
+        }
+        shared_state_.last_async_touch_move_timestamp_ = frame_time;
+      }
       events_to_process.emplace_back(shared_state_.events_.Pop());
     }
   }
 
   while(!events_to_process.empty()) {
     in_flight_event_ = std::move(events_to_process.front());
     events_to_process.pop_front();
     DispatchInFlightEvent();
   }
   PossiblyScheduleMainFrame();
@@ skipping 67 matching lines @@
     case blink::WebInputEvent::MouseWheel:
       return handle_raf_aligned_mouse_input_;
     case blink::WebInputEvent::TouchMove:
       return handle_raf_aligned_touch_input_;
     default:
       return false;
   }
 }
 
 }  // namespace content