Ignore TouchCancel ack dispositions

content/browser/renderer_host/input/touch_event_queue_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 "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "content/browser/renderer_host/input/synthetic_web_input_event_builders.h"
 #include "content/browser/renderer_host/input/touch_event_queue.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 23 matching lines @@
 
   virtual void TearDown() OVERRIDE {
     queue_.reset();
   }
 
   // TouchEventQueueClient
   virtual void SendTouchEventImmediately(
       const TouchEventWithLatencyInfo& event) OVERRIDE {
     ++sent_event_count_;
     last_sent_event_ = event.event;
+    if (sync_ack_result_)
+      SendTouchEventACK(*sync_ack_result_.Pass());
   }
 
   virtual 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_) {
       scoped_ptr<WebTouchEvent> followup_touch_event =
@@ skipping 32 matching lines @@
   }
 
   void SetFollowupEvent(const WebTouchEvent& event) {
     followup_touch_event_.reset(new WebTouchEvent(event));
   }
 
   void SetFollowupEvent(const WebGestureEvent& event) {
     followup_gesture_event_.reset(new WebGestureEvent(event));
   }
 
+  void SetSyncAckResult(InputEventAckState sync_ack_result) {
+    sync_ack_result_.reset(new InputEventAckState(sync_ack_result));
+  }
+
   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);
+  }
+
   size_t GetAndResetAckedEventCount() {
     size_t count = acked_event_count_;
     acked_event_count_ = 0;
     return count;
   }
 
   size_t GetAndResetSentEventCount() {
     size_t count = sent_event_count_;
     sent_event_count_ = 0;
     return count;
@@ skipping 34 matching lines @@
  private:
   scoped_ptr<TouchEventQueue> queue_;
   size_t sent_event_count_;
   size_t acked_event_count_;
   WebTouchEvent last_sent_event_;
   WebTouchEvent last_acked_event_;
   InputEventAckState last_acked_event_state_;
   SyntheticWebTouchEvent touch_event_;
   scoped_ptr<WebTouchEvent> followup_touch_event_;
   scoped_ptr<WebGestureEvent> followup_gesture_event_;
+  scoped_ptr<InputEventAckState> sync_ack_result_;

[tdresser, 2013/11/21 13:54:31]

Why bother with a pointer here, when |InputEventAckState| is just an enum?

[jdduke (slow), 2013/11/21 16:55:29]

scoped_ptr is as close as we have to an "optional<T>" type.  I suppose I could
just use the UNKNOWN type, but I prefer to be explicit about whether or not it
has been specified (and I'm not really worried about a heap alloc here).

[tdresser, 2013/11/21 17:02:48]

Right, sounds good.

 };
 
 
 // Tests that touch-events are queued properly.
 TEST_F(TouchEventQueueTest, Basic) {
   PressTouchPoint(1, 1);
   SendTouchEvent();
   EXPECT_EQ(1U, queued_event_count());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
 
@@ skipping 441 matching lines @@
   EXPECT_EQ(2U, queued_event_count());
 
   // Receive an ACK for the touch-move followup event. This should cause the
   // subsequent touch move event be sent to the renderer.
   SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(1U, queued_event_count());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 }
 
+// Tests that touch-event's can be synchronously ack'ed.

[tdresser, 2013/11/21 13:54:31]

s/event's/events

[jdduke (slow), 2013/11/21 16:55:29]

Done.

+TEST_F(TouchEventQueueTest, SynchronousAcks) {
+  // TouchStart
+  SetSyncAckResult(INPUT_EVENT_ACK_STATE_CONSUMED);
+  PressTouchPoint(1, 1);
+  SendTouchEvent();
+  EXPECT_EQ(0U, queued_event_count());
+  EXPECT_EQ(1U, GetAndResetSentEventCount());
+  EXPECT_EQ(1U, GetAndResetAckedEventCount());
+
+  // TouchMove
+  SetSyncAckResult(INPUT_EVENT_ACK_STATE_CONSUMED);
+  PressTouchPoint(1, 1);
+  MoveTouchPoint(0, 2, 2);
+  SendTouchEvent();
+  EXPECT_EQ(0U, queued_event_count());
+  EXPECT_EQ(1U, GetAndResetSentEventCount());
+  EXPECT_EQ(1U, GetAndResetAckedEventCount());
+
+  // TouchEnd
+  SetSyncAckResult(INPUT_EVENT_ACK_STATE_CONSUMED);
+  PressTouchPoint(1, 1);
+  ReleaseTouchPoint(0);
+  SendTouchEvent();
+  EXPECT_EQ(0U, queued_event_count());
+  EXPECT_EQ(1U, GetAndResetSentEventCount());
+  EXPECT_EQ(1U, GetAndResetAckedEventCount());
+
+  // TouchCancel (first inserting a TouchStart so the TouchCancel will be sent)
+  PressTouchPoint(1, 1);
+  SendTouchEvent();
+  SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
+  EXPECT_EQ(0U, queued_event_count());
+  EXPECT_EQ(1U, GetAndResetSentEventCount());
+  EXPECT_EQ(1U, GetAndResetAckedEventCount());
+
+  SetSyncAckResult(INPUT_EVENT_ACK_STATE_CONSUMED);
+  PressTouchPoint(1, 1);
+  CancelTouchPoint(0);
+  SendTouchEvent();
+  EXPECT_EQ(0U, queued_event_count());
+  EXPECT_EQ(1U, GetAndResetSentEventCount());
+  EXPECT_EQ(1U, GetAndResetAckedEventCount());
+}
+
 // Tests that followup events triggered by an immediate ack from
 // TouchEventQueue::QueueEvent() are properly handled.
 TEST_F(TouchEventQueueTest, ImmediateAckWithFollowupEvents) {
   // Create a touch event that will be queued synchronously by a touch ack.
   WebTouchEvent followup_event;
   followup_event.type = WebInputEvent::TouchStart;
   followup_event.touchesLength = 1;
   followup_event.touches[0].id = 1;
   followup_event.touches[0].state = WebTouchPoint::StatePressed;
   SetFollowupEvent(followup_event);
@@ skipping 141 matching lines @@
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   ReleaseTouchPoint(0);
   SendTouchEvent();
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 }
 
 }  // namespace content