Prepare for Unified Gesture Recognizer landing in Aura

ui/events/gesture_detection/gesture_provider_unittest.cc

 // Copyright 2014 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 "base/message_loop/message_loop.h"
 #include "base/time/time.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 56 matching lines @@
 
   static MockMotionEvent ObtainMotionEvent(base::TimeTicks event_time,
                                            MotionEvent::Action action,
                                            float x0,
                                            float y0,
                                            float x1,
                                            float y1) {
     return MockMotionEvent(action, event_time, x0, y0, x1, y1);
   }
 
+  static MockMotionEvent ObtainMotionEvent(base::TimeTicks event_time,
+                                           MotionEvent::Action action,
+                                           float x0,
+                                           float y0,
+                                           float x1,
+                                           float y1,
+                                           float x2,
+                                           float y2) {
+    return MockMotionEvent(action, event_time, x0, y0, x1, y1, x2, y2);
+  }
+
+  static MockMotionEvent ObtainMotionEvent(base::TimeTicks event_time,

[jdduke (slow), 2014/05/28 16:26:00]

Hmm, I don't actually see where the 4 pointer case is used?

[tdresser, 2014/05/29 14:26:21]

Oh goodness, you're right. I was using 4 for the begin / end tests at one point,
but then figured 3 was adequate.

Thanks for the catch.

+                                           MotionEvent::Action action,
+                                           float x0,
+                                           float y0,
+                                           float x1,
+                                           float y1,
+                                           float x2,
+                                           float y2,
+                                           float x3,
+                                           float y3) {
+    return MockMotionEvent(action, event_time, x0, y0, x1, y1, x2, y2, x3, y3);
+  }
+
   static MockMotionEvent ObtainMotionEvent(
       base::TimeTicks event_time,
       MotionEvent::Action action,
       const std::vector<gfx::PointF>& positions) {
     switch (positions.size()) {
       case 1:
         return MockMotionEvent(
             action, event_time, positions[0].x(), positions[0].y());
       case 2:
         return MockMotionEvent(action,
                                event_time,
                                positions[0].x(),
                                positions[0].y(),
                                positions[1].x(),
                                positions[1].y());
       case 3:
         return MockMotionEvent(action,
                                event_time,
                                positions[0].x(),
                                positions[0].y(),
                                positions[1].x(),
                                positions[1].y(),
                                positions[2].x(),
                                positions[2].y());
+      case 4:
+        return MockMotionEvent(action,
+                               event_time,
+                               positions[0].x(),
+                               positions[0].y(),
+                               positions[1].x(),
+                               positions[1].y(),
+                               positions[2].x(),
+                               positions[2].y(),
+                               positions[3].x(),
+                               positions[3].y());
+
       default:
-        CHECK(false) << "MockMotionEvent only supports 1-3 pointers";
+        CHECK(false) << "MockMotionEvent only supports 1-4 pointers";
         return MockMotionEvent();
     }
   }
 
   static MockMotionEvent ObtainMotionEvent(base::TimeTicks event_time,
                                            MotionEvent::Action action) {
     return ObtainMotionEvent(event_time, action, kFakeCoordX, kFakeCoordY);
   }
 
   // Test
@@ skipping 1269 matching lines @@
 
   // Toggling double-tap support should not take effect until the next sequence.
   gesture_provider_->SetDoubleTapSupportForPageEnabled(false);
 
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
   EXPECT_EQ(motion_event_id, GetMostRecentGestureEvent().motion_event_id);
   EXPECT_EQ(2, GetMostRecentGestureEvent().details.touch_points());
   EXPECT_TRUE(HasReceivedGesture(ET_GESTURE_PINCH_BEGIN));
   EXPECT_TRUE(HasReceivedGesture(ET_GESTURE_SCROLL_BEGIN));
   EXPECT_TRUE(HasReceivedGesture(ET_GESTURE_SCROLL_UPDATE));
+
+  EXPECT_EQ((kFakeCoordX + secondary_coord_x) / 2, GetReceivedGesture(3).x);
+  EXPECT_EQ((kFakeCoordY + secondary_coord_y) / 2, GetReceivedGesture(3).y);
+
   EXPECT_EQ(
       gfx::RectF(kFakeCoordX - kMockTouchRadius,
                  kFakeCoordY - kMockTouchRadius,
                  secondary_coord_x - kFakeCoordX + kMockTouchRadius * 2,
                  secondary_coord_y - kFakeCoordY + kMockTouchRadius * 2),
       GetMostRecentGestureEvent().details.bounding_box());
 
   secondary_coord_x += 2 * touch_slop;
   secondary_coord_y += 2 * touch_slop;
   event = ObtainMotionEvent(event_time,
@@ skipping 270 matching lines @@
   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
 }
 
 // Verify that gesture begin and gesture end events are dispatched correctly.
 TEST_F(GestureProviderTest, GestureBeginAndEnd) {
   EnableBeginEndTypes();
   base::TimeTicks event_time = base::TimeTicks::Now();
 
   EXPECT_EQ(0U, GetReceivedGestureCount());
   MockMotionEvent event =
-      ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN);
+      ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN, 1, 1);
   event.pointer_count = 1;
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
   EXPECT_EQ(ET_GESTURE_BEGIN, GetReceivedGesture(0).type);
   EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
   EXPECT_EQ(2U, GetReceivedGestureCount());
   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
-  EXPECT_EQ(gfx::RectF(kFakeCoordX - kMockTouchRadius,
-                       kFakeCoordY - kMockTouchRadius,
+  EXPECT_EQ(1, GetMostRecentGestureEvent().x);
+  EXPECT_EQ(1, GetMostRecentGestureEvent().y);
+  EXPECT_EQ(gfx::RectF(1 - kMockTouchRadius,
+                       1 - kMockTouchRadius,
                        kMockTouchRadius * 2,
                        kMockTouchRadius * 2),
             GetMostRecentGestureEvent().details.bounding_box());
 
-  event = ObtainMotionEvent(event_time, MotionEvent::ACTION_POINTER_DOWN);
+  event = ObtainMotionEvent(
+      event_time, MotionEvent::ACTION_POINTER_DOWN, 1, 1, 2, 2);
   event.pointer_count = 2;
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
   EXPECT_EQ(ET_GESTURE_BEGIN, GetMostRecentGestureEventType());
   EXPECT_EQ(3U, GetReceivedGestureCount());
   EXPECT_EQ(2, GetMostRecentGestureEvent().details.touch_points());
+  EXPECT_EQ(2, GetMostRecentGestureEvent().x);
+  EXPECT_EQ(2, GetMostRecentGestureEvent().y);
 
-  event = ObtainMotionEvent(event_time, MotionEvent::ACTION_POINTER_DOWN);
+  event = ObtainMotionEvent(
+      event_time, MotionEvent::ACTION_POINTER_DOWN, 1, 1, 2, 2, 3, 3);
   event.pointer_count = 3;
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
   EXPECT_EQ(ET_GESTURE_BEGIN, GetMostRecentGestureEventType());
   EXPECT_EQ(4U, GetReceivedGestureCount());
   EXPECT_EQ(3, GetMostRecentGestureEvent().details.touch_points());
+  EXPECT_EQ(3, GetMostRecentGestureEvent().x);
+  EXPECT_EQ(3, GetMostRecentGestureEvent().y);
 
-  event = ObtainMotionEvent(event_time, MotionEvent::ACTION_POINTER_UP);
+  event = ObtainMotionEvent(
+      event_time, MotionEvent::ACTION_POINTER_UP, 1, 1, 2, 2, 3, 3);
   event.pointer_count = 2;
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
   EXPECT_EQ(ET_GESTURE_END, GetMostRecentGestureEventType());
   EXPECT_EQ(5U, GetReceivedGestureCount());
   EXPECT_EQ(2, GetMostRecentGestureEvent().details.touch_points());
+  EXPECT_EQ(1, GetMostRecentGestureEvent().x);
+  EXPECT_EQ(1, GetMostRecentGestureEvent().y);
 
-  event = ObtainMotionEvent(event_time, MotionEvent::ACTION_POINTER_DOWN);
+  event = ObtainMotionEvent(
+      event_time, MotionEvent::ACTION_POINTER_DOWN, 2, 2, 3, 3, 4, 4);
   event.pointer_count = 3;
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
   EXPECT_EQ(ET_GESTURE_BEGIN, GetMostRecentGestureEventType());
   EXPECT_EQ(6U, GetReceivedGestureCount());
   EXPECT_EQ(3, GetMostRecentGestureEvent().details.touch_points());
+  EXPECT_EQ(4, GetMostRecentGestureEvent().x);
+  EXPECT_EQ(4, GetMostRecentGestureEvent().y);
 
-  event = ObtainMotionEvent(event_time, MotionEvent::ACTION_POINTER_UP);
+  event = ObtainMotionEvent(
+      event_time, MotionEvent::ACTION_POINTER_UP, 2, 2, 3, 3, 4, 4);
   event.pointer_count = 2;
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
   EXPECT_EQ(ET_GESTURE_END, GetMostRecentGestureEventType());
   EXPECT_EQ(7U, GetReceivedGestureCount());
   EXPECT_EQ(2, GetMostRecentGestureEvent().details.touch_points());
+  EXPECT_EQ(2, GetMostRecentGestureEvent().x);
+  EXPECT_EQ(2, GetMostRecentGestureEvent().y);
 
-  event = ObtainMotionEvent(event_time, MotionEvent::ACTION_POINTER_UP);
+  event =
+      ObtainMotionEvent(event_time, MotionEvent::ACTION_POINTER_UP, 3, 3, 4, 4);
   event.pointer_count = 1;
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
   EXPECT_EQ(ET_GESTURE_END, GetMostRecentGestureEventType());
   EXPECT_EQ(8U, GetReceivedGestureCount());
   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
+  EXPECT_EQ(3, GetMostRecentGestureEvent().x);
+  EXPECT_EQ(3, GetMostRecentGestureEvent().y);
 
-  event = ObtainMotionEvent(event_time, MotionEvent::ACTION_UP);
+
+  event = ObtainMotionEvent(event_time, MotionEvent::ACTION_UP, 4, 4);
   event.pointer_count = 1;
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
   EXPECT_EQ(ET_GESTURE_END, GetMostRecentGestureEventType());
   EXPECT_EQ(9U, GetReceivedGestureCount());
   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
+  EXPECT_EQ(4, GetMostRecentGestureEvent().x);
+  EXPECT_EQ(4, GetMostRecentGestureEvent().y);
+}
 
-  event = ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN);
+// Verify that gesture begin and gesture end events are dispatched correctly
+// when an ACTION_CANCEL is received.
+TEST_F(GestureProviderTest, GestureBeginAndEndOnCancel) {
+  EnableBeginEndTypes();
+  base::TimeTicks event_time = base::TimeTicks::Now();
+
+  EXPECT_EQ(0U, GetReceivedGestureCount());
+  MockMotionEvent event =
+      ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN, 1, 1);
   event.pointer_count = 1;
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
-  EXPECT_EQ(ET_GESTURE_BEGIN, GetReceivedGesture(9).type);
+  EXPECT_EQ(ET_GESTURE_BEGIN, GetReceivedGesture(0).type);
   EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
-  EXPECT_EQ(11U, GetReceivedGestureCount());
+  EXPECT_EQ(2U, GetReceivedGestureCount());
   EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
+  EXPECT_EQ(gfx::RectF(1 - kMockTouchRadius,
+                       1 - kMockTouchRadius,
+                       kMockTouchRadius * 2,
+                       kMockTouchRadius * 2),
+            GetMostRecentGestureEvent().details.bounding_box());
+  EXPECT_EQ(1, GetMostRecentGestureEvent().x);
+  EXPECT_EQ(1, GetMostRecentGestureEvent().y);
 
-  event = ObtainMotionEvent(event_time, MotionEvent::ACTION_CANCEL);
-  event.pointer_count = 1;
+  event = ObtainMotionEvent(
+      event_time, MotionEvent::ACTION_POINTER_DOWN, 1, 1, 2, 2);
+  event.pointer_count = 2;
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
-  EXPECT_EQ(ET_GESTURE_END, GetMostRecentGestureEventType());
-  EXPECT_EQ(12U, GetReceivedGestureCount());
-  EXPECT_EQ(1, GetMostRecentGestureEvent().details.touch_points());
+  EXPECT_EQ(ET_GESTURE_BEGIN, GetMostRecentGestureEventType());
+  EXPECT_EQ(3U, GetReceivedGestureCount());
+  EXPECT_EQ(2, GetMostRecentGestureEvent().details.touch_points());
+  EXPECT_EQ(2, GetMostRecentGestureEvent().x);
+  EXPECT_EQ(2, GetMostRecentGestureEvent().y);
+
+
+  event = ObtainMotionEvent(
+      event_time, MotionEvent::ACTION_POINTER_DOWN, 1, 1, 2, 2, 3, 3);
+  event.pointer_count = 3;
+  EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
+  EXPECT_EQ(ET_GESTURE_BEGIN, GetMostRecentGestureEventType());
+  EXPECT_EQ(4U, GetReceivedGestureCount());
+  EXPECT_EQ(3, GetMostRecentGestureEvent().details.touch_points());
+  EXPECT_EQ(3, GetMostRecentGestureEvent().x);
+  EXPECT_EQ(3, GetMostRecentGestureEvent().y);
+
+  event = ObtainMotionEvent(
+      event_time, MotionEvent::ACTION_CANCEL, 1, 1, 2, 2, 3, 3);
+  event.pointer_count = 3;
+  EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
+  EXPECT_EQ(7U, GetReceivedGestureCount());
+  EXPECT_EQ(3, GetReceivedGesture(4).details.touch_points());
+  EXPECT_EQ(ET_GESTURE_END, GetReceivedGesture(4).details.type());
+  EXPECT_EQ(2, GetReceivedGesture(5).details.touch_points());
+  EXPECT_EQ(ET_GESTURE_END, GetReceivedGesture(5).details.type());
+  EXPECT_EQ(1, GetReceivedGesture(6).details.touch_points());
+  EXPECT_EQ(ET_GESTURE_END, GetReceivedGesture(6).details.type());
+  EXPECT_EQ(1, GetReceivedGesture(4).x);
+  EXPECT_EQ(1, GetReceivedGesture(4).y);
+  EXPECT_EQ(2, GetReceivedGesture(5).x);
+  EXPECT_EQ(2, GetReceivedGesture(5).y);
+  EXPECT_EQ(3, GetReceivedGesture(6).x);
+  EXPECT_EQ(3, GetReceivedGesture(6).y);
 }
 
-
 // Test a simple two finger tap
 TEST_F(GestureProviderTest, TwoFingerTap) {
   // The time between ACTION_POINTER_DOWN and ACTION_POINTER_UP must be <= the
   // two finger tap delay.
   EnableTwoFingerTap(kMaxTwoFingerTapSeparation, base::TimeDelta());
   const float scaled_touch_slop = GetTouchSlop();
 
   base::TimeTicks event_time = base::TimeTicks::Now();
 
   MockMotionEvent event =
@@ skipping 221 matching lines @@
                             secondary_coord_x + kMinPinchUpdateDistance +
                                 kOvershootMinPinchUpdateDistance,
                             secondary_coord_y);
 
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
   EXPECT_TRUE(HasReceivedGesture(ET_GESTURE_PINCH_UPDATE));
   EXPECT_EQ(2, GetMostRecentGestureEvent().details.touch_points());
 }
 
 }  // namespace ui