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 10 matching lines @@
 using ui::LatencyInfo;
 
 namespace content {
 namespace {
 
 // Time interval at which touchmove events will be forwarded to the client while
 // scrolling is active and possible.
 const double kAsyncTouchMoveIntervalSec = .2;
 
 // A sanity check on touches received to ensure that touch movement outside
-// the platform slop region will cause scrolling, as indicated by the event's
-// |causesScrollingIfUncanceled| bit.
+// the platform slop region will cause scrolling.
 const double kMaxConceivablePlatformSlopRegionLengthDipsSquared = 60. * 60.;
 
 TouchEventWithLatencyInfo ObtainCancelEventForTouchEvent(
     const TouchEventWithLatencyInfo& event_to_cancel) {
   TouchEventWithLatencyInfo event = event_to_cancel;
   WebTouchEventTraits::ResetTypeAndTouchStates(
       WebInputEvent::TouchCancel,
       // TODO(rbyers): Shouldn't we use a fresh timestamp?
       event.event.timeStampSeconds,
       &event.event);
@@ skipping 410 matching lines @@
 
 TouchEventQueue::~TouchEventQueue() {
   if (!touch_queue_.empty())
     STLDeleteElements(&touch_queue_);
 }
 
 void TouchEventQueue::QueueEvent(const TouchEventWithLatencyInfo& event) {
   TRACE_EVENT0("input", "TouchEventQueue::QueueEvent");
 
   // 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_) {
+  // processing the event until the dispatch has finished. The touch queue is
+  // non-empty in this case.
+  if (touch_queue_.empty()) {
     // 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,
                                filter_result == ACK_WITH_NO_CONSUMER_EXISTS
                                    ? INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS
                                    : INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
       return;
     }
 
     // There is no touch event in the queue. Forward it to the renderer
     // immediately.
     touch_queue_.push_back(new CoalescedWebTouchEvent(event, false));
     ForwardNextEventToRenderer();
     return;
   }
 
   // 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");
+
+  TouchEventWithLatencyInfo touch;
+  touch.event.type = WebInputEvent::TouchScrollStarted;
+  touch.event.uniqueTouchEventId = 0;
+
+  if (touch_queue_.empty()) {
+    touch_queue_.push_back(new CoalescedWebTouchEvent(touch, false));
+    ForwardNextEventToRenderer();
+  } else {
+    // Leave the head of the queue untouched since it is an in-flight event.
+    auto it = touch_queue_.begin();
+    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 208 matching lines @@
 void TouchEventQueue::FlushQueue() {
   DCHECK(!dispatching_touch_ack_);
   DCHECK(!dispatching_touch_);
   pending_async_touchmove_.reset();
   drop_remaining_touches_in_sequence_ = true;
   while (!touch_queue_.empty())
     PopTouchEventToClient(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
 }
 
 void TouchEventQueue::PopTouchEventToClient(InputEventAckState ack_result) {
-  AckTouchEventToClient(ack_result, PopTouchEvent(), nullptr);
+  AckTouchEventToClient(ack_result, nullptr);
 }
 
 void TouchEventQueue::PopTouchEventToClient(
     InputEventAckState ack_result,
     const LatencyInfo& renderer_latency_info) {
-  AckTouchEventToClient(ack_result, PopTouchEvent(), &renderer_latency_info);
+  AckTouchEventToClient(ack_result, &renderer_latency_info);
 }
 
 void TouchEventQueue::AckTouchEventToClient(
     InputEventAckState ack_result,
-    scoped_ptr<CoalescedWebTouchEvent> acked_event,
     const ui::LatencyInfo* optional_latency_info) {
+  DCHECK(!dispatching_touch_ack_);
+  DCHECK(!touch_queue_.empty());
+  scoped_ptr<CoalescedWebTouchEvent> acked_event(touch_queue_.front());
   DCHECK(acked_event);
-  DCHECK(!dispatching_touch_ack_);
+
   UpdateTouchConsumerStates(acked_event->coalesced_event().event, ack_result);
 
   // 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());
+  // Skip ack for TouchScrollStarted since it was synthesized within the queue.
+  if (acked_event->coalesced_event().event.type !=
+      WebInputEvent::TouchScrollStarted)

[tdresser, 2016/04/01 19:03:20]

Multiline bodies require {}

[mustaq, 2016/04/01 21:49:52]

Done.

+    acked_event->DispatchAckToClient(ack_result, optional_latency_info,
+                                     client_);
+
   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_);
     for (unsigned int i = 0; i < last_sent_touchevent_->touchesLength; ++i) {
       const WebTouchPoint& last_touch_point =
           last_sent_touchevent_->touches[i];
       // Touches with same id may not have same index in Touches array.
       for (unsigned int j = 0; j < touch->event.touchesLength; ++j) {
         const WebTouchPoint& current_touchmove_point = touch->event.touches[j];
         if (current_touchmove_point.id != last_touch_point.id)
           continue;
 
         if (!HasPointChanged(last_touch_point, current_touchmove_point))
           touch->event.touches[j].state = WebTouchPoint::StateStationary;
 
         break;
       }
     }
   }
 
-  if (last_sent_touchevent_)
-    *last_sent_touchevent_ = touch->event;
-  else
-    last_sent_touchevent_.reset(new WebTouchEvent(touch->event));
+  if (touch->event.type != WebInputEvent::TouchScrollStarted) {
+    if (last_sent_touchevent_)
+      *last_sent_touchevent_ = touch->event;
+    else
+      last_sent_touchevent_.reset(new WebTouchEvent(touch->event));
+  }
 
   base::AutoReset<bool> dispatching_touch(&dispatching_touch_, true);
 
   client_->SendTouchEventImmediately(*touch);
 
   // A synchronous ack will reset |dispatching_touch_|, in which case the touch
   // timeout should not be started and the count also should not be increased.
   if (dispatching_touch_) {
     if (touch->event.type == WebInputEvent::TouchMove &&
         !touch->event.cancelable) {
       // When we send out a uncancelable touch move, we increase the count and
       // we do not process input event ack any more, we will just ack to client
       // and wait for the ack from render. Also we will remove it from the front
       // of the queue.
       ack_pending_async_touchmove_ids_.push_back(
           touch->event.uniqueTouchEventId);
       dispatching_touch_ = false;
       PopTouchEventToClient(INPUT_EVENT_ACK_STATE_IGNORED);
       TryForwardNextEventToRenderer();
       return;
     }
 
     if (timeout_handler_)
       timeout_handler_->StartIfNecessary(*touch);
   }
 }
 
 TouchEventQueue::PreFilterResult
 TouchEventQueue::FilterBeforeForwarding(const WebTouchEvent& event) {
+  if (event.type == WebInputEvent::TouchScrollStarted)
+    return FORWARD_TO_RENDERER;
+
   if (WebTouchEventTraits::IsTouchSequenceStart(event)) {
     has_handler_for_current_sequence_ = false;
     send_touch_events_async_ = false;
     pending_async_touchmove_.reset();
     last_sent_touchevent_.reset();
 
     touch_sequence_start_position_ = gfx::PointF(event.touches[0].position);
     drop_remaining_touches_in_sequence_ = false;
     if (!has_handlers_) {
       drop_remaining_touches_in_sequence_ = true;
@@ skipping 62 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