Coalesce async touch move events until the ack back from render

content/browser/renderer_host/input/input_router_impl_unittest.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 <math.h>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 137 matching lines @@
     ack_handler_.reset(new MockInputAckHandler());
     base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
     command_line->AppendSwitch(switches::kValidateInputEventStream);
     input_router_.reset(new InputRouterImpl(process_.get(),
                                             client_.get(),
                                             ack_handler_.get(),
                                             MSG_ROUTING_NONE,
                                             config_));
     client_->set_input_router(input_router());
     ack_handler_->set_input_router(input_router());
+    sent_events_ids_.clear();
+    all_sent_events_ids_.clear();
   }
 
   void TearDown() override {
     // Process all pending tasks to avoid leaks.
     base::MessageLoop::current()->RunUntilIdle();
 
     input_router_.reset();
     client_.reset();
     process_.reset();
     browser_context_.reset();
@@ skipping 75 matching lines @@
         velocity_x, velocity_y, source_device));
   }
 
   void SetTouchTimestamp(base::TimeDelta timestamp) {
     touch_event_.SetTimestamp(timestamp);
   }
 
   void SendTouchEvent() {
     input_router_->SendTouchEvent(TouchEventWithLatencyInfo(touch_event_));
     touch_event_.ResetPoints();
+    SetLastEventID();
   }
 
   int PressTouchPoint(int x, int y) {
     return touch_event_.PressPoint(x, y);
   }
 
   void MoveTouchPoint(int index, int x, int y) {
     touch_event_.MovePoint(index, x, y);
   }
 
   void ReleaseTouchPoint(int index) {
     touch_event_.ReleasePoint(index);
   }
 
   void CancelTouchPoint(int index) {
     touch_event_.CancelPoint(index);
   }
 
   void SendInputEventACK(blink::WebInputEvent::Type type,
                          InputEventAckState ack_result) {
-    InputHostMsg_HandleInputEvent_ACK_Params ack;
-    ack.type = type;
-    ack.state = ack_result;
+    InputEventAck ack(type, ack_result);
+    if (WebInputEvent::isTouchEventType(type)) {
+      DCHECK(!sent_events_ids_.empty());
+      ack.unique_touch_event_id = sent_events_ids_.front();
+      sent_events_ids_.pop_front();
+    }
     input_router_->OnMessageReceived(InputHostMsg_HandleInputEvent_ACK(0, ack));
+    SetLastEventID();
   }
 
   InputRouterImpl* input_router() const {
     return input_router_.get();
   }
 
   bool TouchEventQueueEmpty() const {
     return input_router()->touch_event_queue_.empty();
   }
 
@@ skipping 22 matching lines @@
     input_router_->OnMessageReceived(
         InputHostMsg_SetTouchAction(0, touch_action));
   }
 
   size_t GetSentMessageCountAndResetSink() {
     size_t count = process_->sink().message_count();
     process_->sink().ClearMessages();
     return count;
   }
 
+  bool TouchEventCancelable() { return touch_event_.cancelable; }
+
+  void SetLastEventID() {
+    size_t count = process_->sink().message_count();

[jdduke (slow), 2015/05/12 16:07:11]

Hmm, this probably works fine, but I wonder if it's worth being more explicit
when we ack touches. What if we changed our touch forwarding to something like:

uint32 SendTouchEvent();

and then each caller of SendTouchEvent would just store the ID and then include
that in the ack? It's a bit more work for each test, but I feel like there may
be less surprises. Then we'd have a method like:

SendTouchEventAck(type, uint32 id, result);

Looks like there are 4 or 5 tests where you might need to do this, but I think
it's probably worth doing now.

Alternatively, we could cheat and modify the touch id to always be some
constant, say, kTestTouchId, before we send it, but that probably violates the
spirit of the test :).

[lanwei, 2015/05/13 21:01:53]

I think you are right, even though we have to add the additional event_id every
time when we ack events, but it is much clearer, which event it acks.

+    for (size_t i = 0; i < count; ++i) {
+      const WebInputEvent* input_event =
+          GetInputEventFromMessage(*process_->sink().GetMessageAt(i));
+      uint32 id = WebInputEventTraits::GetUniqueTouchEventId(*input_event);
+      if (id != 0 &&
+          all_sent_events_ids_.find(id) == all_sent_events_ids_.end()) {
+        sent_events_ids_.push_back(id);
+        all_sent_events_ids_.insert(id);
+      }
+    }
+  }
+
   static void RunTasksAndWait(base::TimeDelta delay) {
     base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE, base::MessageLoop::QuitClosure(), delay);
     base::MessageLoop::current()->Run();
   }
 
   InputRouterImpl::Config config_;
   scoped_ptr<MockRenderProcessHost> process_;
   scoped_ptr<MockInputRouterClient> client_;
   scoped_ptr<MockInputAckHandler> ack_handler_;
   scoped_ptr<InputRouterImpl> input_router_;
 
  private:
   base::MessageLoopForUI message_loop_;
   SyntheticWebTouchEvent touch_event_;
 
   scoped_ptr<TestBrowserContext> browser_context_;
+  std::deque<uint32> sent_events_ids_;
+  std::set<uint32> all_sent_events_ids_;
 };
 
 TEST_F(InputRouterImplTest, CoalescesRangeSelection) {
   input_router_->SendInput(scoped_ptr<IPC::Message>(
       new InputMsg_SelectRange(0, gfx::Point(1, 2), gfx::Point(3, 4))));
   ExpectIPCMessageWithArg2<InputMsg_SelectRange>(
       process_->sink().GetMessageAt(0),
       gfx::Point(1, 2),
       gfx::Point(3, 4));
   EXPECT_EQ(1u, GetSentMessageCountAndResetSink());
@@ skipping 604 matching lines @@
                   InputMsg_HandleInputEvent::ID));
   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 
   // Check that the correct unhandled wheel event was received.
   EXPECT_EQ(ack_handler_->acked_wheel_event().deltaY, -5);
 }
 
 TEST_F(InputRouterImplTest, TouchTypesIgnoringAck) {
   OnHasTouchEventHandlers(true);
   // Only acks for TouchCancel should always be ignored.
-  ASSERT_FALSE(WebInputEventTraits::IgnoresAckDisposition(
+  ASSERT_TRUE(WebInputEventTraits::WillReceiveAckFromRenderer(
       GetEventWithType(WebInputEvent::TouchStart)));
-  ASSERT_FALSE(WebInputEventTraits::IgnoresAckDisposition(
+  ASSERT_TRUE(WebInputEventTraits::WillReceiveAckFromRenderer(
       GetEventWithType(WebInputEvent::TouchMove)));
-  ASSERT_FALSE(WebInputEventTraits::IgnoresAckDisposition(
+  ASSERT_TRUE(WebInputEventTraits::WillReceiveAckFromRenderer(
       GetEventWithType(WebInputEvent::TouchEnd)));
 
   // Precede the TouchCancel with an appropriate TouchStart;
   PressTouchPoint(1, 1);
   SendTouchEvent();
   SendInputEventACK(WebInputEvent::TouchStart, INPUT_EVENT_ACK_STATE_CONSUMED);
   ASSERT_EQ(1U, GetSentMessageCountAndResetSink());
   ASSERT_EQ(1U, ack_handler_->GetAndResetAckCount());
   ASSERT_EQ(0, client_->in_flight_event_count());
 
@@ skipping 37 matching lines @@
       WebInputEvent::GestureTapDown,
       WebInputEvent::GestureTapCancel,
       WebInputEvent::GestureScrollBegin,
       WebInputEvent::GestureScrollUpdate,
       WebInputEvent::GesturePinchBegin,
       WebInputEvent::GesturePinchUpdate,
       WebInputEvent::GesturePinchEnd,
       WebInputEvent::GestureScrollEnd};
   for (size_t i = 0; i < arraysize(eventTypes); ++i) {
     WebInputEvent::Type type = eventTypes[i];
-    if (!WebInputEventTraits::IgnoresAckDisposition(GetEventWithType(type))) {
+    if (WebInputEventTraits::WillReceiveAckFromRenderer(
+            GetEventWithType(type))) {
       SimulateGestureEvent(type, blink::WebGestureDeviceTouchscreen);
       EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
       EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
       EXPECT_EQ(1, client_->in_flight_event_count());
       EXPECT_TRUE(HasPendingEvents());
 
       SendInputEventACK(type, INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
       EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
       EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
       EXPECT_EQ(0, client_->in_flight_event_count());
       EXPECT_FALSE(HasPendingEvents());
       continue;
     }
 
     SimulateGestureEvent(type, blink::WebGestureDeviceTouchscreen);
     EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
     EXPECT_EQ(1U, ack_handler_->GetAndResetAckCount());
     EXPECT_EQ(0, client_->in_flight_event_count());
     EXPECT_FALSE(HasPendingEvents());
   }
 }
 
 TEST_F(InputRouterImplTest, MouseTypesIgnoringAck) {
   int start_type = static_cast<int>(WebInputEvent::MouseDown);
   int end_type = static_cast<int>(WebInputEvent::ContextMenu);
   ASSERT_LT(start_type, end_type);
   for (int i = start_type; i <= end_type; ++i) {
     WebInputEvent::Type type = static_cast<WebInputEvent::Type>(i);
     int expected_in_flight_event_count =
-        WebInputEventTraits::IgnoresAckDisposition(GetEventWithType(type)) ? 0
-                                                                           : 1;
+        !WebInputEventTraits::WillReceiveAckFromRenderer(GetEventWithType(type))
+            ? 0
+            : 1;
 
     // Note: Mouse event acks are never forwarded to the ack handler, so the key
     // result here is that ignored ack types don't affect the in-flight count.
     SimulateMouseEvent(type, 0, 0);
     EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
     EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
     EXPECT_EQ(expected_in_flight_event_count, client_->in_flight_event_count());
     if (expected_in_flight_event_count) {
       SendInputEventACK(type, INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
       EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
       EXPECT_EQ(0U, ack_handler_->GetAndResetAckCount());
       EXPECT_EQ(0, client_->in_flight_event_count());
     }
   }
 }
 
 // Guard against breaking changes to the list of ignored event ack types in
-// |WebInputEventTraits::IgnoresAckDisposition|.
+// |WebInputEventTraits::WillReceiveAckFromRenderer|.
 TEST_F(InputRouterImplTest, RequiredEventAckTypes) {
   const WebInputEvent::Type kRequiredEventAckTypes[] = {
     WebInputEvent::MouseMove,
     WebInputEvent::MouseWheel,
     WebInputEvent::RawKeyDown,
     WebInputEvent::KeyDown,
     WebInputEvent::KeyUp,
     WebInputEvent::Char,
     WebInputEvent::GestureScrollUpdate,
     WebInputEvent::GestureFlingStart,
     WebInputEvent::GestureFlingCancel,
     WebInputEvent::GesturePinchUpdate,
     WebInputEvent::TouchStart,
     WebInputEvent::TouchMove
   };
   for (size_t i = 0; i < arraysize(kRequiredEventAckTypes); ++i) {
     const WebInputEvent::Type required_ack_type = kRequiredEventAckTypes[i];
-    EXPECT_FALSE(WebInputEventTraits::IgnoresAckDisposition(
+    ASSERT_TRUE(WebInputEventTraits::WillReceiveAckFromRenderer(
         GetEventWithType(required_ack_type)));
   }
 }
 
 // Test that GestureShowPress, GestureTapDown and GestureTapCancel events don't
 // wait for ACKs.
 TEST_F(InputRouterImplTest, GestureTypesIgnoringAckInterleaved) {
   // Interleave a few events that do and do not ignore acks, ensuring that
   // ack-ignoring events aren't dispatched until all prior events which observe
   // their ack disposition have been dispatched.
@@ skipping 397 matching lines @@
   SimulateGestureEvent(WebInputEvent::GestureTapDown,
                        blink::WebGestureDeviceTouchscreen);
   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 
   // The GestureTapUnconfirmed is converted into a tap, as the touch action is
   // none.
   SimulateGestureEvent(WebInputEvent::GestureTapUnconfirmed,
                        blink::WebGestureDeviceTouchscreen);
   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
   // This test will become invalid if GestureTap stops requiring an ack.
-  ASSERT_FALSE(WebInputEventTraits::IgnoresAckDisposition(
+  ASSERT_TRUE(WebInputEventTraits::WillReceiveAckFromRenderer(
       GetEventWithType(WebInputEvent::GestureTap)));
   EXPECT_EQ(2, client_->in_flight_event_count());
   SendInputEventACK(WebInputEvent::GestureTap,
                     INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(1, client_->in_flight_event_count());
 
   // This tap gesture is dropped, since the GestureTapUnconfirmed was turned
   // into a tap.
   SimulateGestureEvent(WebInputEvent::GestureTap,
                        blink::WebGestureDeviceTouchscreen);
   EXPECT_EQ(0U, GetSentMessageCountAndResetSink());
 
   SendInputEventACK(WebInputEvent::TouchEnd, INPUT_EVENT_ACK_STATE_CONSUMED);
   SendInputEventACK(WebInputEvent::TouchStart,
                     INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
 
   // Second Tap.
   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
   SimulateGestureEvent(WebInputEvent::GestureTapDown,
                        blink::WebGestureDeviceTouchscreen);
   EXPECT_EQ(1U, GetSentMessageCountAndResetSink());
 
   // Although the touch-action is now auto, the double tap still won't be
   // dispatched, because the first tap occured when the touch-action was none.
   SimulateGestureEvent(WebInputEvent::GestureDoubleTap,
                        blink::WebGestureDeviceTouchscreen);
   // This test will become invalid if GestureDoubleTap stops requiring an ack.
-  ASSERT_FALSE(WebInputEventTraits::IgnoresAckDisposition(
+  ASSERT_TRUE(WebInputEventTraits::WillReceiveAckFromRenderer(
       GetEventWithType(WebInputEvent::GestureDoubleTap)));
   EXPECT_EQ(1, client_->in_flight_event_count());
   SendInputEventACK(WebInputEvent::GestureTap, INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(0, client_->in_flight_event_count());
 }
 
 // Test that the router will call the client's |DidFlush| after all events have
 // been dispatched following a call to |Flush|.
 TEST_F(InputRouterImplTest, InputFlush) {
   EXPECT_FALSE(HasPendingEvents());
@@ skipping 177 matching lines @@
             client_overscroll.latest_overscroll_delta);
   EXPECT_EQ(overscroll.current_fling_velocity,
             client_overscroll.current_fling_velocity);
 
   DidOverscrollParams wheel_overscroll;
   wheel_overscroll.accumulated_overscroll = gfx::Vector2dF(7, -7);
   wheel_overscroll.latest_overscroll_delta = gfx::Vector2dF(3, 0);
   wheel_overscroll.current_fling_velocity = gfx::Vector2dF(1, 0);
 
   SimulateWheelEvent(3, 0, 0, false);
-  InputHostMsg_HandleInputEvent_ACK_Params ack;
-  ack.type = WebInputEvent::MouseWheel;
-  ack.state = INPUT_EVENT_ACK_STATE_NOT_CONSUMED;
+  InputEventAck ack(WebInputEvent::MouseWheel,
+                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   ack.overscroll.reset(new DidOverscrollParams(wheel_overscroll));
   input_router_->OnMessageReceived(InputHostMsg_HandleInputEvent_ACK(0, ack));
 
   client_overscroll = client_->GetAndResetOverscroll();
   EXPECT_EQ(wheel_overscroll.accumulated_overscroll,
             client_overscroll.accumulated_overscroll);
   EXPECT_EQ(wheel_overscroll.latest_overscroll_delta,
             client_overscroll.latest_overscroll_delta);
   EXPECT_EQ(wheel_overscroll.current_fling_velocity,
             client_overscroll.current_fling_velocity);
 }
 
 }  // namespace content