Fix recursion in handling touch input events acks.

content/browser/renderer_host/input/passthrough_touch_event_queue_unittest.cc

 // Copyright 2017 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/passthrough_touch_event_queue.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <utility>
@@ skipping 46 matching lines @@
 
   void TearDown() override { queue_.reset(); }
 
   // TouchEventQueueClient
   void SendTouchEventImmediately(
       const TouchEventWithLatencyInfo& event) override {
     sent_events_.push_back(event.event);
     sent_events_ids_.push_back(event.event.unique_touch_event_id);
     if (sync_ack_result_) {
       auto sync_ack_result = std::move(sync_ack_result_);
-      SendTouchEventAck(*sync_ack_result);
+      SendTouchEventAckWithID(*sync_ack_result,
+                              event.event.unique_touch_event_id);
     }
   }
 
   void OnTouchEventAck(const TouchEventWithLatencyInfo& event,
                        InputEventAckState ack_result) override {
     ++acked_event_count_;
-    last_acked_event_ = event.event;
-    last_acked_event_state_ = ack_result;
     if (followup_touch_event_) {
       std::unique_ptr<WebTouchEvent> followup_touch_event =
           std::move(followup_touch_event_);
       SendTouchEvent(*followup_touch_event);
     }
     if (followup_gesture_event_) {
       std::unique_ptr<WebGestureEvent> followup_gesture_event =
           std::move(followup_gesture_event_);
       queue_->OnGestureScrollEvent(GestureEventWithLatencyInfo(
           *followup_gesture_event, ui::LatencyInfo()));
     }
+    last_acked_event_ = event.event;
+    last_acked_event_state_ = ack_result;
   }
 
   void OnFilteringTouchEvent(const blink::WebTouchEvent& touch_event) override {
   }
 
  protected:
   void SetUpForTouchMoveSlopTesting(double slop_length_dips) {
     slop_length_dips_ = slop_length_dips;
   }
 
@@ skipping 652 matching lines @@
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   SetSyncAckResult(INPUT_EVENT_ACK_STATE_CONSUMED);
   CancelTouchPoint(0);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 }
 
+// Tests that touch-events acks are in order even with synchronous acks.
+TEST_F(PassthroughTouchEventQueueTest, SynchronousAcksInOrder) {
+  // TouchStart
+  PressTouchPoint(1, 1);
+  EXPECT_EQ(1U, queued_event_count());
+  EXPECT_EQ(1U, GetAndResetSentEventCount());
+  EXPECT_EQ(0U, GetAndResetAckedEventCount());
+
+  // TouchMove
+  MoveTouchPoint(0, 2, 3);
+  EXPECT_EQ(2U, queued_event_count());
+  EXPECT_EQ(1U, GetAndResetSentEventCount());
+  EXPECT_EQ(0U, GetAndResetAckedEventCount());
+
+  // Ack the TouchMove
+  SendTouchEventAckLast(INPUT_EVENT_ACK_STATE_CONSUMED);
+  EXPECT_EQ(2U, queued_event_count());
+  EXPECT_EQ(0U, GetAndResetSentEventCount());
+  EXPECT_EQ(0U, GetAndResetAckedEventCount());
+
+  // Create a touch event that will be queued synchronously by a touch ack.
+  WebTouchEvent followup_event(
+      WebInputEvent::kTouchMove, WebInputEvent::kNoModifiers,
+      ui::EventTimeStampToSeconds(ui::EventTimeForNow()));
+  followup_event.touches_length = 1;
+  followup_event.touches[0].id = 0;
+  followup_event.unique_touch_event_id = 100;
+  followup_event.touches[0].state = WebTouchPoint::kStateMoved;
+  SetFollowupEvent(followup_event);
+  SetSyncAckResult(INPUT_EVENT_ACK_STATE_CONSUMED);
+
+  // Ack the touch start, should release the |follow_up| event (and its ack).
+  SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
+
+  EXPECT_EQ(0U, queued_event_count());
+  EXPECT_EQ(1U, GetAndResetSentEventCount());
+  EXPECT_EQ(3U, GetAndResetAckedEventCount());
+  EXPECT_EQ(100U, acked_event().unique_touch_event_id);
+}
+
 // Tests that followup events triggered by an immediate ack from
 // TouchEventQueue::QueueEvent() are properly handled.
 TEST_F(PassthroughTouchEventQueueTest, ImmediateAckWithFollowupEvents) {
   // Create a touch event that will be queued synchronously by a touch ack.
   WebTouchEvent followup_event(
       WebInputEvent::kTouchStart, WebInputEvent::kNoModifiers,
       ui::EventTimeStampToSeconds(ui::EventTimeForNow()));
   followup_event.touches_length = 1;
   followup_event.touches[0].id = 1;
   followup_event.touches[0].state = WebTouchPoint::kStatePressed;
   SetFollowupEvent(followup_event);
 
   // Now, enqueue a stationary touch that will not be forwarded.  This should be
   // immediately ack'ed with "NO_CONSUMER_EXISTS".  The followup event should
   // then be enqueued and immediately sent to the renderer.
   WebTouchEvent stationary_event(
       WebInputEvent::kTouchMove, WebInputEvent::kNoModifiers,
       ui::EventTimeStampToSeconds(ui::EventTimeForNow()));
-  ;
   stationary_event.touches_length = 1;
   stationary_event.touches[0].id = 1;
   stationary_event.touches[0].state = WebTouchPoint::kStateStationary;
   SendTouchEvent(stationary_event);
 
   EXPECT_EQ(1U, queued_event_count());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   EXPECT_EQ(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS, acked_event_state());
   EXPECT_EQ(WebInputEvent::kTouchMove, acked_event().GetType());
@@ skipping 937 matching lines @@
   EXPECT_EQ(WebInputEvent::kTouchMove, sent_event().GetType());
   EXPECT_FALSE(sent_event().touch_start_or_first_touch_move);
 
   ReleaseTouchPoint(0);
   SendTouchEventAck(INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(WebInputEvent::kTouchEnd, sent_event().GetType());
   EXPECT_FALSE(sent_event().touch_start_or_first_touch_move);
 }
 
 }  // namespace content