Eager Gesture Recognizer (WIP)

ui/events/gestures/gesture_event_queue_unittest.cc

Index: ui/events/gestures/gesture_event_queue_unittest.cc
diff --git a/ui/events/gestures/gesture_event_queue_unittest.cc b/ui/events/gestures/gesture_event_queue_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..ea82e24529d8e88c341fc36f913ebb9bf5ba6fa0
--- /dev/null
+++ b/ui/events/gestures/gesture_event_queue_unittest.cc
@@ -0,0 +1,454 @@
+// 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 "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/events/event.h"
+#include "ui/events/gestures/gesture_event_queue.h"
+#include "ui/events/gestures/test/eager_gesture_recognition_test_base.h"
+#include "ui/events/gestures/touch_point_state.h"
+
+using testing::ElementsAre;
+
+namespace ui {
+namespace test {
+
+namespace {
+
+// Used to condense definitions of ScopedVectors of TouchPointStates.
+class TPStates : public std::vector<TouchPointState*> {
+ public:
+  TPStates(int n, ...) {
+    va_list ap;
+    va_start(ap, n);
+
+    TouchPointState* tps;
+    for (int i = 0; i < n; ++i) {
+      tps = va_arg(ap, TouchPointState*);
+      push_back(tps);
+    }
+    va_end(ap);
+  }
+
+  TPStates(int touch_id,
+           bool has_press,
+           bool has_release,
+           int move_count,
+           int timer_count) {
+    push_back(new TouchPointState(
+        touch_id, has_press, has_release, move_count, timer_count));
+  }
+};
+
+class MockGestureEventQueueDelegate: public GestureEventQueueDelegate {
+ public:
+  MockGestureEventQueueDelegate() {}
+  virtual ~MockGestureEventQueueDelegate() {}
+  std::vector<EventType> GetAndResetDispatchedEvents() {
+    std::vector<EventType> tmp;
+    dispatched_events_.swap(tmp);
+    return tmp;
+
+  }
+  virtual void DispatchGestureEvent(GestureEvent* event) OVERRIDE {
+    dispatched_events_.push_back(event->type());
+  }
+
+ private:
+  std::vector<EventType> dispatched_events_;
+};
+
+class TestGestureEventQueue : public GestureEventQueue{
+ public:
+  TestGestureEventQueue(MockGestureEventQueueDelegate* delegate)
+      : GestureEventQueue(delegate)
+      , mock_delegate_(delegate) {
+  }
+
+  std::vector<EventType> GetAndResetDispatchedEvents() {
+    return mock_delegate_->GetAndResetDispatchedEvents();
+  }
+
+  std::list<size_t> SequenceSizes() {
+    std::list<size_t> sizes;
+    for (std::list<Sequence*>::iterator it = sequences_.begin();
+       it != sequences_.end();
+         ++it) {
+      sizes.push_back((*it)->size());
+    }
+    return sizes;
+  }
+
+  void QueueForTest(
+      GestureEvent* event,
+      std::vector<TouchPointState*>& touch_point_states) {
+    QueueGestureEvent(event, touch_point_states);
+  }
+
+ private:
+  MockGestureEventQueueDelegate* mock_delegate_;
+  DISALLOW_COPY_AND_ASSIGN(TestGestureEventQueue);
+};
+
+class GestureEventQueueTest : public EagerGestureRecognitionTestBase {
+ public:
+  GestureEventQueueTest() {}
+  virtual void SetUp() {
+    EagerGestureRecognitionTestBase::SetUp();
+    delegate_.reset(new MockGestureEventQueueDelegate());
+    geq_.reset(new TestGestureEventQueue(delegate_.get()));
+  }
+
+  virtual void TearDown() {
+    geq_.reset();
+    EagerGestureRecognitionTestBase::TearDown();
+  }
+
+  TestGestureEventQueue& geq() { return *geq_.get(); }
+
+ private:
+  scoped_ptr<TestGestureEventQueue> geq_;
+  scoped_ptr<MockGestureEventQueueDelegate> delegate_;
+  DISALLOW_COPY_AND_ASSIGN(GestureEventQueueTest);
+};
+
+}  // namespace
+
+// Ensure that GESTURE_BEGIN creates a new sequence in the queue. We ensure
+// no events are acked, to simplify the test.
+TEST_F(GestureEventQueueTest, QueueGestureEvent) {
+  EXPECT_THAT(geq().SequenceSizes(), ElementsAre());
+
+  // QueueForTest takes ownership of the elements of the TPStates object, and
+  // empties it, so we can't reuse these objects.
+  TPStates never_send_1(0, false, false, 100, 0);
+  geq().QueueForTest(Gesture(ET_GESTURE_BEGIN), never_send_1);
+  EXPECT_THAT(geq().SequenceSizes(), ElementsAre(1));
+
+  TPStates never_send_2(0, false, false, 100, 0);
+  geq().QueueForTest(Gesture(ET_GESTURE_TAP_DOWN), never_send_2);
+  EXPECT_THAT(geq().SequenceSizes(), ElementsAre(2));
+
+  TPStates never_send_3(0, false, false, 100, 0);
+  geq().QueueForTest(Gesture(ET_GESTURE_BEGIN), never_send_3);
+  EXPECT_THAT(geq().SequenceSizes(), ElementsAre(2, 1));
+
+  TPStates never_send_4(0, false, false, 100, 0);
+  geq().QueueForTest(Gesture(ET_GESTURE_TAP_DOWN), never_send_4);
+  EXPECT_THAT(geq().SequenceSizes(), ElementsAre(2, 2));
+
+  TPStates never_send_5(0, false, false, 100, 0);
+  geq().QueueForTest(Gesture(ET_GESTURE_BEGIN), never_send_5);
+  EXPECT_THAT(geq().SequenceSizes(), ElementsAre(2, 2, 1));
+}
+
+TEST_F(GestureEventQueueTest, OnTouchEventAckNotConsumed) {
+  EXPECT_THAT(geq().SequenceSizes(), ElementsAre());
+
+  TPStates depends_on_nothing(0, false, false, 0, 0);
+  geq().QueueForTest(Gesture(ET_GESTURE_BEGIN),
+                     depends_on_nothing);
+  EXPECT_THAT(geq().SequenceSizes(), ElementsAre(0));
+  EXPECT_THAT(geq().GetAndResetDispatchedEvents(),
+              ElementsAre(ET_GESTURE_BEGIN));
+
+  TPStates depends_on_press_1(0, true, false, 0, 0);
+  geq().QueueForTest(Gesture(ET_GESTURE_TAP_DOWN),
+                     depends_on_press_1);
+  EXPECT_THAT(geq().SequenceSizes(), ElementsAre(1));
+  EXPECT_THAT(geq().GetAndResetDispatchedEvents(), ElementsAre());
+
+  TPStates depends_on_press_2(0, true, false, 0, 0);
+  geq().QueueForTest(Gesture(ET_GESTURE_SCROLL_BEGIN),
+                     depends_on_press_2);
+  EXPECT_THAT(geq().SequenceSizes(), ElementsAre(2));
+  EXPECT_THAT(geq().GetAndResetDispatchedEvents(), ElementsAre());
+
+  TPStates depends_on_1_move(0, true, false, 1, 0);
+  geq().QueueForTest(Gesture(ET_GESTURE_SCROLL_UPDATE),
+                     depends_on_1_move);
+  EXPECT_THAT(geq().SequenceSizes(), ElementsAre(3));
+  EXPECT_THAT(geq().GetAndResetDispatchedEvents(), ElementsAre());
+
+  TPStates depends_on_2_moves(0, true, false, 2, 0);
+  geq().QueueForTest(Gesture(ET_GESTURE_SCROLL_UPDATE),
+                     depends_on_2_moves);
+  EXPECT_THAT(geq().SequenceSizes(), ElementsAre(4));
+  EXPECT_THAT(geq().GetAndResetDispatchedEvents(), ElementsAre());
+
+  TPStates depends_on_press_3(0, true, false, 0, 0);
+  geq().QueueForTest(Gesture(ET_GESTURE_BEGIN),
+                     depends_on_press_3);
+  EXPECT_THAT(geq().SequenceSizes(), ElementsAre(4, 1));
+  EXPECT_THAT(geq().GetAndResetDispatchedEvents(), ElementsAre());
+
+  // Ack TAP_DOWN and SCROLL_BEGIN.
+  geq().OnTouchEventAck(Press(0), ui::ER_UNHANDLED);
+  EXPECT_THAT(geq().SequenceSizes(), ElementsAre(2, 1));
+  EXPECT_THAT(geq().GetAndResetDispatchedEvents(),
+              ElementsAre(ET_GESTURE_TAP_DOWN, ET_GESTURE_SCROLL_BEGIN));
+
+  // Ack SCROLL_UPDATE.
+  geq().OnTouchEventAck(Move(0), ui::ER_UNHANDLED);
+  EXPECT_THAT(geq().SequenceSizes(), ElementsAre(1, 1));
+  EXPECT_THAT(geq().GetAndResetDispatchedEvents(),
+              ElementsAre(ET_GESTURE_SCROLL_UPDATE));
+
+  // Ack SCROLL_UPDATE, which is the end of this sequence. We could dispatch the
+  // next GESTURE_BEGIN at this point, but at this point it isn't clear if we
+  // want to dispatch it before the press receives an ack.
+  geq().OnTouchEventAck(Move(0), ui::ER_UNHANDLED);
+  EXPECT_THAT(geq().SequenceSizes(), ElementsAre(0, 1));
+  EXPECT_THAT(geq().GetAndResetDispatchedEvents(),
+              ElementsAre(ET_GESTURE_SCROLL_UPDATE));
+}
+
+TEST_F(GestureEventQueueTest, OnTouchEventAckConsumed) {
+  TPStates depends_on_nothing(0, false, false, 0, 0);
+  geq().QueueForTest(Gesture(ET_GESTURE_BEGIN),
+                     depends_on_nothing);
+  EXPECT_THAT(geq().SequenceSizes(), ElementsAre(0));
+  EXPECT_THAT(geq().GetAndResetDispatchedEvents(),
+              ElementsAre(ET_GESTURE_BEGIN));
+
+  TPStates depends_on_press(0, true, false, 0, 0);
+  geq().QueueForTest(Gesture(ET_GESTURE_TAP_DOWN),
+                     depends_on_press);
+  EXPECT_THAT(geq().SequenceSizes(), ElementsAre(1));
+  EXPECT_THAT(geq().GetAndResetDispatchedEvents(), ElementsAre());
+
+  TPStates depends_on_press_and_move(0, true, false, 1, 0);
+  geq().QueueForTest(Gesture(ET_GESTURE_TAP),
+                     depends_on_press_and_move);
+  EXPECT_THAT(geq().SequenceSizes(), ElementsAre(2));
+  EXPECT_THAT(geq().GetAndResetDispatchedEvents(), ElementsAre());
+
+  TPStates depends_on_move(0, false, false, 1, 0);
+  geq().QueueForTest(Gesture(ET_GESTURE_SCROLL_UPDATE),
+                     depends_on_move);
+  EXPECT_THAT(geq().SequenceSizes(), ElementsAre(3));
+  EXPECT_THAT(geq().GetAndResetDispatchedEvents(), ElementsAre());
+
+  // Consume press event.
+  geq().OnTouchEventAck(Press(0), ui::ER_CONSUMED);
+  EXPECT_THAT(geq().SequenceSizes(), ElementsAre(1));
+  EXPECT_THAT(geq().GetAndResetDispatchedEvents(), ElementsAre());
+
+  // Ack move event.
+  geq().OnTouchEventAck(Move(0), ui::ER_UNHANDLED);
+  EXPECT_THAT(geq().SequenceSizes(), ElementsAre(0));
+  EXPECT_THAT(geq().GetAndResetDispatchedEvents(),
+              ElementsAre(ET_GESTURE_SCROLL_UPDATE));
+}
+
+TEST_F(GestureEventQueueTest, SimpleMultiFingerTest) {
+  TPStates depends_on_nothing(1, false, false, 0, 0);
+  geq().QueueForTest(Gesture(ET_GESTURE_BEGIN), depends_on_nothing);
+  EXPECT_THAT(geq().SequenceSizes(), ElementsAre(0));
+  EXPECT_THAT(geq().GetAndResetDispatchedEvents(),
+              ElementsAre(ET_GESTURE_BEGIN));
+
+  TPStates depends_on_press(1, true, false, 0, 0);
+  geq().QueueForTest(Gesture(ET_GESTURE_TAP_DOWN), depends_on_press);
+  EXPECT_THAT(geq().SequenceSizes(), ElementsAre(1));
+  EXPECT_THAT(geq().GetAndResetDispatchedEvents(), ElementsAre());
+
+  TPStates depends_on_press_2(2, true, false, 0, 0);
+  geq().QueueForTest(Gesture(ET_GESTURE_TAP), depends_on_press_2);
+  EXPECT_THAT(geq().SequenceSizes(), ElementsAre(2));
+  EXPECT_THAT(geq().GetAndResetDispatchedEvents(), ElementsAre());
+
+  // Ack touch 1 press.
+  geq().OnTouchEventAck(Press(1), ui::ER_UNHANDLED);
+  EXPECT_THAT(geq().SequenceSizes(), ElementsAre(1));
+  EXPECT_THAT(geq().GetAndResetDispatchedEvents(),
+              ElementsAre(ET_GESTURE_TAP_DOWN));
+
+  // Ack touch 2 press.
+  geq().OnTouchEventAck(Press(2), ui::ER_UNHANDLED);
+  EXPECT_THAT(geq().SequenceSizes(), ElementsAre(0));
+  EXPECT_THAT(geq().GetAndResetDispatchedEvents(),
+              ElementsAre(ET_GESTURE_TAP));
+}
+
+TEST_F(GestureEventQueueTest, StaysInOrder) {
+  TPStates depends_on_nothing(1, false, false, 0, 0);
+  geq().QueueForTest(Gesture(ET_GESTURE_BEGIN), depends_on_nothing);
+  EXPECT_THAT(geq().SequenceSizes(), ElementsAre(0));
+  EXPECT_THAT(geq().GetAndResetDispatchedEvents(),
+              ElementsAre(ET_GESTURE_BEGIN));
+
+  TPStates depends_on_press(1, true, false, 0, 0);
+  geq().QueueForTest(Gesture(ET_GESTURE_TAP_DOWN), depends_on_press);
+  EXPECT_THAT(geq().SequenceSizes(), ElementsAre(1));
+  EXPECT_THAT(geq().GetAndResetDispatchedEvents(), ElementsAre());
+
+  TPStates depends_on_press_2(2, true, false, 0, 0);
+  geq().QueueForTest(Gesture(ET_GESTURE_TAP), depends_on_press_2);
+  EXPECT_THAT(geq().SequenceSizes(), ElementsAre(2));
+  EXPECT_THAT(geq().GetAndResetDispatchedEvents(), ElementsAre());
+
+  // Ack touch 2 press.
+  geq().OnTouchEventAck(Press(2), ui::ER_UNHANDLED);
+  EXPECT_THAT(geq().SequenceSizes(), ElementsAre(2));
+  EXPECT_THAT(geq().GetAndResetDispatchedEvents(),
+              ElementsAre());
+
+  // Ack touch 1 press.
+  geq().OnTouchEventAck(Press(1), ui::ER_UNHANDLED);
+  EXPECT_THAT(geq().SequenceSizes(), ElementsAre(0));
+  EXPECT_THAT(geq().GetAndResetDispatchedEvents(),
+              ElementsAre(ET_GESTURE_TAP_DOWN, ET_GESTURE_TAP));
+
+}
+
+TEST_F(GestureEventQueueTest, DependsTwoFingers) {
+  TPStates depends_on_nothing(1, false, false, 0, 0);
+  geq().QueueForTest(Gesture(ET_GESTURE_BEGIN),
+                     depends_on_nothing);
+  EXPECT_THAT(geq().SequenceSizes(), ElementsAre(0));
+  EXPECT_THAT(geq().GetAndResetDispatchedEvents(),
+              ElementsAre(ET_GESTURE_BEGIN));
+
+  TPStates depends_on_presses(2,
+                              new TouchPointState(4, true, false, 0, 0),
+                              new TouchPointState(1, true, false, 0, 0));
+  geq().QueueForTest(Gesture(ET_GESTURE_TAP_DOWN),
+                     depends_on_presses);
+  EXPECT_THAT(geq().SequenceSizes(), ElementsAre(1));
+  EXPECT_THAT(geq().GetAndResetDispatchedEvents(), ElementsAre());
+
+  // Ack touch 4 press.
+  geq().OnTouchEventAck(Press(4), ui::ER_UNHANDLED);
+  EXPECT_THAT(geq().SequenceSizes(), ElementsAre(1));
+  EXPECT_THAT(geq().GetAndResetDispatchedEvents(),
+              ElementsAre());
+
+  // Ack touch 1 press.
+  geq().OnTouchEventAck(Press(1), ui::ER_UNHANDLED);
+  EXPECT_THAT(geq().SequenceSizes(), ElementsAre(0));
+  EXPECT_THAT(geq().GetAndResetDispatchedEvents(),
+              ElementsAre(ET_GESTURE_TAP_DOWN));
+}
+
+TEST_F(GestureEventQueueTest, OnTouchEventAckConsumedBeforeGestureArrives) {
+  TPStates depends_on_nothing(0, false, false, 0, 0);
+  geq().QueueForTest(Gesture(ET_GESTURE_BEGIN),
+                     depends_on_nothing);
+  EXPECT_THAT(geq().SequenceSizes(), ElementsAre(0));
+  EXPECT_THAT(geq().GetAndResetDispatchedEvents(),
+              ElementsAre(ET_GESTURE_BEGIN));
+
+  // Consume press event.
+  geq().OnTouchEventAck(Press(0), ui::ER_CONSUMED);
+  EXPECT_THAT(geq().SequenceSizes(), ElementsAre(0));
+  EXPECT_THAT(geq().GetAndResetDispatchedEvents(), ElementsAre());
+
+  TPStates depends_on_press(0, true, false, 0, 0);
+  geq().QueueForTest(Gesture(ET_GESTURE_TAP_DOWN),
+                     depends_on_press);
+  EXPECT_THAT(geq().SequenceSizes(), ElementsAre(0));
+  EXPECT_THAT(geq().GetAndResetDispatchedEvents(), ElementsAre());
+
+  // Ack press event.
+  geq().OnTouchEventAck(Press(0), ui::ER_UNHANDLED);
+  EXPECT_THAT(geq().SequenceSizes(), ElementsAre(0));
+  EXPECT_THAT(geq().GetAndResetDispatchedEvents(), ElementsAre());
+}
+
+// Touch down with touch point 0. Then tap twice with touch point 1.
+TEST_F(GestureEventQueueTest, ResetTouchPointOnRelease) {
+  TPStates depends_on_nothing(0, false, false, 0, 0);
+  geq().QueueForTest(Gesture(ET_GESTURE_BEGIN),
+                     depends_on_nothing);
+  EXPECT_THAT(geq().SequenceSizes(), ElementsAre(0));
+  EXPECT_THAT(geq().GetAndResetDispatchedEvents(),
+              ElementsAre(ET_GESTURE_BEGIN));
+
+  TPStates depends_on_press_0(0, true, false, 0, 0);
+  geq().QueueForTest(Gesture(ET_GESTURE_TAP_DOWN),
+                     depends_on_press_0);
+  EXPECT_THAT(geq().SequenceSizes(), ElementsAre(1));
+  EXPECT_THAT(geq().GetAndResetDispatchedEvents(), ElementsAre());
+
+  // Ack the zeroth press.
+  geq().OnTouchEventAck(Press(0), ui::ER_UNHANDLED);
+  EXPECT_THAT(geq().SequenceSizes(), ElementsAre(0));
+  EXPECT_THAT(geq().GetAndResetDispatchedEvents(),
+              ElementsAre(ET_GESTURE_TAP_DOWN));
+
+  TPStates depends_on_press_1(1, true, false, 0, 0);
+  geq().QueueForTest(Gesture(ET_GESTURE_TAP_DOWN),
+                     depends_on_press_1);
+  EXPECT_THAT(geq().SequenceSizes(), ElementsAre(1));
+  EXPECT_THAT(geq().GetAndResetDispatchedEvents(), ElementsAre());
+
+  TPStates depends_on_release_1(1, true, true, 0, 0);
+  geq().QueueForTest(Gesture(ET_GESTURE_TAP),
+                     depends_on_release_1);
+  EXPECT_THAT(geq().SequenceSizes(), ElementsAre(2));
+  EXPECT_THAT(geq().GetAndResetDispatchedEvents(), ElementsAre());
+
+  // Ack the first press.
+  geq().OnTouchEventAck(Press(1), ui::ER_UNHANDLED);
+  EXPECT_THAT(geq().SequenceSizes(), ElementsAre(1));
+  EXPECT_THAT(geq().GetAndResetDispatchedEvents(),
+              ElementsAre(ET_GESTURE_TAP_DOWN));
+
+  // Ack the release.
+  geq().OnTouchEventAck(Release(1),
+                        ui::ER_UNHANDLED);
+  EXPECT_THAT(geq().SequenceSizes(), ElementsAre(0));
+  EXPECT_THAT(geq().GetAndResetDispatchedEvents(),
+              ElementsAre(ET_GESTURE_TAP));
+
+  TPStates depends_on_press_1_2(1, true, false, 0, 0);
+  // Now tap again with touch point 1.
+  geq().QueueForTest(Gesture(ET_GESTURE_TAP_DOWN),
+                     depends_on_press_1_2);
+  EXPECT_THAT(geq().SequenceSizes(), ElementsAre(1));
+  EXPECT_THAT(geq().GetAndResetDispatchedEvents(), ElementsAre());
+
+  TPStates depends_on_release_1_2(1, true, true, 0, 0);
+  geq().QueueForTest(Gesture(ET_GESTURE_TAP),
+                     depends_on_release_1_2);
+  EXPECT_THAT(geq().SequenceSizes(), ElementsAre(2));
+  EXPECT_THAT(geq().GetAndResetDispatchedEvents(), ElementsAre());
+
+  // Ack touch point 1's second press.
+  geq().OnTouchEventAck(Press(1), ui::ER_UNHANDLED);
+  EXPECT_THAT(geq().SequenceSizes(), ElementsAre(1));
+  EXPECT_THAT(geq().GetAndResetDispatchedEvents(),
+              ElementsAre(ET_GESTURE_TAP_DOWN));
+
+  // Ack touch point 1's second release.
+  geq().OnTouchEventAck(Release(1),
+                        ui::ER_UNHANDLED);
+  EXPECT_THAT(geq().SequenceSizes(), ElementsAre(0));
+  EXPECT_THAT(geq().GetAndResetDispatchedEvents(),
+              ElementsAre(ET_GESTURE_TAP));
+}
+
+TEST_F(GestureEventQueueTest, NoAckTest) {
+  TPStates empty_1(0);
+  geq().QueueForTest(Gesture(ET_GESTURE_BEGIN), empty_1);
+  EXPECT_THAT(geq().SequenceSizes(), ElementsAre(0));
+  EXPECT_THAT(geq().GetAndResetDispatchedEvents(),
+              ElementsAre(ET_GESTURE_BEGIN));
+
+  TPStates empty_2(0);
+  geq().QueueForTest(Gesture(ET_GESTURE_TAP_DOWN), empty_2);
+  EXPECT_THAT(geq().SequenceSizes(), ElementsAre(0));
+  EXPECT_THAT(geq().GetAndResetDispatchedEvents(),
+              ElementsAre(ET_GESTURE_TAP_DOWN));
+
+  TPStates empty_3(0);
+  geq().QueueForTest(Gesture(ET_GESTURE_TAP), empty_3);
+  EXPECT_THAT(geq().SequenceSizes(), ElementsAre(0));
+  EXPECT_THAT(geq().GetAndResetDispatchedEvents(),
+              ElementsAre(ET_GESTURE_TAP));
+}
+
+}  // namespace test
+}  // namespace ui