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 double kAsyncTouchMoveIntervalSec = .2;

[aelias_OOO_until_Jul13, 2017/02/24 20:19:51]

const base::TimeDelta kAsyncTouchMoveInterval =
base::TimeDelta::FromMilliseconds(200);

[dtapuska, 2017/02/24 20:43:15]

Done.

+
 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) {}
+    : sent_main_frame_request_(false), last_async_touch_move_timestamp_(0) {}
 
 MainThreadEventQueue::SharedState::~SharedState() {}
 
 MainThreadEventQueue::MainThreadEventQueue(
     int routing_id,
     MainThreadEventQueueClient* client,
     const scoped_refptr<base::SingleThreadTaskRunner>& main_task_runner,
     blink::scheduler::RendererScheduler* renderer_scheduler)
     : routing_id_(routing_id),
       client_(client),
@@ skipping 39 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(double frame_time_sec) {
   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()) {
-      if (!IsRafAlignedEvent(shared_state_.events_.front()->event()))
-        break;
-      events_to_process.emplace_back(shared_state_.events_.Pop());
+    // Throttle touchmoves that are async.
+    if (handle_raf_aligned_touch_input_ && shared_state_.events_.size() == 1 &&

[aelias_OOO_until_Jul13, 2017/02/24 20:19:50]

Could you explain the reasoning why this is only needed when size is 1?

[dtapuska, 2017/02/24 20:23:35]

Because it you have anything other than one then something else needs to run.
The coalescing happens on insertion so it should always be 1 if nothing else
needs to run.

[aelias_OOO_until_Jul13, 2017/02/24 21:01:14]

OK.  Well, this control flow seems like it could be less hairy, the duplication
of the emplace_back() line has a bad code smell in particular.

How about the following instead.  It's mostly equivalent to what you wrote
except that async touchmoves at the end of a multi-element queue are treated the
same as async touchmoves in an originally size-1 queue, which seems appropriate.

while (!shared_state_.events_.empty()) {
  if (!IsRafAlignedEvent(shared_state_.events_.front()->event()))
    break;
  if (IsAsyncTouchMove(shared_state_.events_.front()) &&
handle_raf_aligned_touch_input_) {
    if (shared_state_.events_.size() == 1 && frame_time_sec <
shared_state_.last_async_touch_move_timestamp_ + kAsyncTouchMoveIntervalSec)
      break;
    shared_state_.last_async_touch_move_timestamp_ = frame_time_sec;
  } 

  events_to_process.emplace_back(shared_state_.events_.Pop());
}

[dtapuska, 2017/02/24 21:29:41]

Done.

+        IsAsyncTouchMove(shared_state_.events_.front())) {
+      if (frame_time_sec >= shared_state_.last_async_touch_move_timestamp_ +
+                                kAsyncTouchMoveIntervalSec) {
+        shared_state_.last_async_touch_move_timestamp_ = frame_time_sec;
+        events_to_process.emplace_back(shared_state_.events_.Pop());
+      }
+    } else {
+      while (!shared_state_.events_.empty()) {
+        if (!IsRafAlignedEvent(shared_state_.events_.front()->event()))
+          break;
+        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 66 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