Notify Blink about start of gesture scroll through a queued event.

content/browser/renderer_host/input/touch_event_queue.cc

 // Copyright 2013 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/browser/renderer_host/input/touch_event_queue.h"
 
 #include <utility>
 
 #include "base/auto_reset.h"
 #include "base/macros.h"
@@ skipping 441 matching lines @@
   }
 }
 
 TouchEventQueue::~TouchEventQueue() {
   if (!touch_queue_.empty())
     STLDeleteElements(&touch_queue_);
 }
 
 void TouchEventQueue::QueueEvent(const TouchEventWithLatencyInfo& event) {
   TRACE_EVENT0("input", "TouchEventQueue::QueueEvent");
+  LOG(ERROR) << "======= mDebug " << __FUNCTION__
+             << " t=" << WebInputEventTraits::GetName(event.event.type)
+             << " |q|=" << touch_queue_.size();
 
   // If the queueing of |event| was triggered by an ack dispatch, defer
   // processing the event until the dispatch has finished.
   if (touch_queue_.empty() && !dispatching_touch_ack_) {
     // Optimization of the case without touch handlers.  Removing this path
     // yields identical results, but this avoids unnecessary allocations.
     PreFilterResult filter_result = FilterBeforeForwarding(event.event);
     if (filter_result != FORWARD_TO_RENDERER) {
       client_->OnFilteringTouchEvent(event.event);
       client_->OnTouchEventAck(event,
@@ skipping 13 matching lines @@
   // If the last queued touch-event was a touch-move, and the current event is
   // also a touch-move, then the events can be coalesced into a single event.
   if (touch_queue_.size() > 1) {
     CoalescedWebTouchEvent* last_event = touch_queue_.back();
     if (last_event->CoalesceEventIfPossible(event))
       return;
   }
   touch_queue_.push_back(new CoalescedWebTouchEvent(event, false));
 }
 
+void TouchEventQueue::PrependTouchScrollNotification() {
+  TRACE_EVENT0("input", "TouchEventQueue::PrependTouchScrollNotification");
+  LOG(ERROR) << "======= mDebug " << __FUNCTION__
+             << " |q|=" << touch_queue_.size();
+
+  TouchEventWithLatencyInfo touch;
+  touch.event.type = WebInputEvent::TouchScrollStarted;
+  touch.event.uniqueTouchEventId = 12345;
+  touch.event.touchesLength = 0;
+
+  // Skip the head of the queue to avoid messing up with in-flight event's ack.
+  auto it = touch_queue_.begin();
+  if (it != touch_queue_.end())
+      ++it;
+  touch_queue_.insert(it, new CoalescedWebTouchEvent(touch, false));
+}
+
+
 void TouchEventQueue::ProcessTouchAck(InputEventAckState ack_result,
                                       const LatencyInfo& latency_info,
                                       const uint32_t unique_touch_event_id) {
   TRACE_EVENT0("input", "TouchEventQueue::ProcessTouchAck");
 
   // We receive an ack for async touchmove from render.
   if (!ack_pending_async_touchmove_ids_.empty() &&
       ack_pending_async_touchmove_ids_.front() == unique_touch_event_id) {
     // Remove the first touchmove from the ack_pending_async_touchmove queue.
     ack_pending_async_touchmove_ids_.pop_front();
@@ skipping 234 matching lines @@
 
   // Note that acking the touch-event may result in multiple gestures being sent
   // to the renderer, or touch-events being queued.
   base::AutoReset<bool> dispatching_touch_ack(&dispatching_touch_ack_, true);
   acked_event->DispatchAckToClient(ack_result, optional_latency_info, client_);
 }
 
 scoped_ptr<CoalescedWebTouchEvent> TouchEventQueue::PopTouchEvent() {
   DCHECK(!touch_queue_.empty());
   scoped_ptr<CoalescedWebTouchEvent> event(touch_queue_.front());
+  LOG(ERROR) << "======= mDebug " << __FUNCTION__
+             << " t=" << WebInputEventTraits::GetName(
+                             event->coalesced_event().event.type)
+             << " |q|=" << touch_queue_.size();
   touch_queue_.pop_front();
   return event;
 }
 
 void TouchEventQueue::SendTouchEventImmediately(
     TouchEventWithLatencyInfo* touch) {
   // For touchmove events, compare touch points position from current event
   // to last sent event and update touch points state.
   if (touch->event.type == WebInputEvent::TouchMove) {
     CHECK(last_sent_touchevent_);
@@ skipping 65 matching lines @@
     return ACK_WITH_NO_CONSUMER_EXISTS;
 
   if (touchmove_slop_suppressor_->FilterEvent(event))
     return ACK_WITH_NOT_CONSUMED;
 
   if (drop_remaining_touches_in_sequence_ &&
       event.type != WebInputEvent::TouchCancel) {
     return ACK_WITH_NO_CONSUMER_EXISTS;
   }
 
+  if (event.type == WebInputEvent::TouchScrollStarted)
+    return FORWARD_TO_RENDERER;

[tdresser, 2016/03/16 14:56:31]

Are we returning before this for some TouchScrollStarted events?

[mustaq, 2016/03/16 15:15:40]

That's a possibility of course, but not in the case I am looking at now. See
below.

+
   if (event.type == WebInputEvent::TouchStart) {
     return (has_handlers_ || has_handler_for_current_sequence_)
                ? FORWARD_TO_RENDERER
                : ACK_WITH_NO_CONSUMER_EXISTS;
   }
 
   if (has_handler_for_current_sequence_) {
     // Only forward a touch if it has a non-stationary pointer that is active
     // in the current touch sequence.
     for (size_t i = 0; i < event.touchesLength; ++i) {
       const WebTouchPoint& point = event.touches[i];
       if (point.state == WebTouchPoint::StateStationary)
         continue;
 
       // |last_sent_touchevent_| will be non-null as long as there is an
       // active touch sequence being forwarded to the renderer.
       if (!last_sent_touchevent_)
         continue;
 
       for (size_t j = 0; j < last_sent_touchevent_->touchesLength; ++j) {
         if (point.id != last_sent_touchevent_->touches[j].id)
           continue;
 
         if (event.type != WebInputEvent::TouchMove)
           return FORWARD_TO_RENDERER;

[mustaq, 2016/03/16 15:15:40]

Here is a possible problem: for touchmoves as well as touchends, the filter
normally returns FORWARD_TO_RENDERER from within this loop. But after firing
TouchScrollStarted event, the filter doesn't return from within the loop,
instead returns ACK_WITH_NO_CONSUMER_EXISTS.

[tdresser, 2016/03/16 15:39:15]

Yeah, that's causing the behavior you're seeing.

What's causing the TouchMove's not to trigger HasPointChanged? We might want to
check if the last_sent_touch_event_->type is different from the event.type, and
FORWARD_TO_RENDERER if that's the case.

[mustaq, 2016/03/16 15:44:11]

Got the culprit: when sent_touch_event_ is the new event, the point.id
comparison above fails, so the loop doesn't effectively execute.

 
         // All pointers in TouchMove events may have state as StateMoved,
         // even though none of the pointers have not changed in real.
         // Forward these events when at least one pointer has changed.
         if (HasPointChanged(last_sent_touchevent_->touches[j], point))
           return FORWARD_TO_RENDERER;
 
         // This is a TouchMove event for which we have yet to find a
         // non-stationary pointer. Continue checking the next pointers
         // in the |event|.
@@ skipping 12 matching lines @@
     if (ack_result == INPUT_EVENT_ACK_STATE_CONSUMED)
       send_touch_events_async_ = false;
     has_handler_for_current_sequence_ |=
         ack_result != INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS;
   } else if (WebTouchEventTraits::IsTouchSequenceEnd(event)) {
     has_handler_for_current_sequence_ = false;
   }
 }
 
 }  // namespace content