Support GestureBegin and GestureEnd in ui::GestureProvider

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 23 matching lines @@
   sConfig.gesture_detector_config.showpress_timeout = base::TimeDelta();
   sConfig.gesture_detector_config.longpress_timeout = kOneMicrosecond;
 
   // A valid doubletap timeout should always be non-zero. The value is used not
   // only to trigger the timeout that confirms the tap event, but also to gate
   // whether the second tap is in fact a double-tap (using a strict inequality
   // between times for the first up and the second down events). We use 4
   // microseconds simply to allow several intermediate events to occur before
   // the second tap at microsecond intervals.
   sConfig.gesture_detector_config.double_tap_timeout = kOneMicrosecond * 4;
+  sConfig.send_aura_specific_gestures = true;

[jdduke (slow), 2014/04/03 20:17:16]

I'd prefer if this default'ed to false, and we had a standalone test for
enabling it.

[tdresser, 2014/04/03 21:14:41]

Done.

   return sConfig;
 }
 
 }  // namespace
 
 class GestureProviderTest : public testing::Test, public GestureProviderClient {
  public:
   GestureProviderTest() {}
   virtual ~GestureProviderTest() {}
 
@@ skipping 100 matching lines @@
         ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN);
 
     EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 
     event = ObtainMotionEvent(event_time + kOneSecond,
                               MotionEvent::ACTION_MOVE,
                               scroll_to_x,
                               scroll_to_y);
     EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
     EXPECT_TRUE(gesture_provider_->IsScrollInProgress());
-    EXPECT_TRUE(HasReceivedGesture(ET_GESTURE_SCROLL_BEGIN));
-    EXPECT_EQ(ET_GESTURE_SCROLL_UPDATE, GetMostRecentGestureEventType());
-    ASSERT_EQ(4U, GetReceivedGestureCount()) << "Only TapDown, TapCancel, "
-                                                "ScrollBegin and ScrollBy "
-                                                "should have been sent";
-
-    EXPECT_EQ(ET_GESTURE_TAP_CANCEL, GetReceivedGesture(1).type);
-    EXPECT_EQ(ET_GESTURE_SCROLL_BEGIN, GetReceivedGesture(2).type);
-    EXPECT_EQ(event_time + kOneSecond, GetReceivedGesture(2).time)
+    ASSERT_EQ(5U, GetReceivedGestureCount())
+        << "Only GestureBegin, TapDown, TapCancel, ScrollBegin and ScrollBy "
+        << "should have been sent.";
+    EXPECT_EQ(ET_GESTURE_BEGIN, GetReceivedGesture(0).type);
+    EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetReceivedGesture(1).type);
+    EXPECT_EQ(ET_GESTURE_TAP_CANCEL, GetReceivedGesture(2).type);
+    EXPECT_EQ(ET_GESTURE_SCROLL_BEGIN, GetReceivedGesture(3).type);
+    EXPECT_EQ(event_time + kOneSecond, GetReceivedGesture(3).time)
         << "ScrollBegin should have the time of the ACTION_MOVE";
+    EXPECT_EQ(ET_GESTURE_SCROLL_UPDATE, GetReceivedGesture(4).type);
 
     event = ObtainMotionEvent(
         event_time + kOneSecond, end_action_type, scroll_to_x, scroll_to_y);
     gesture_provider_->OnTouchEvent(event);
     EXPECT_FALSE(gesture_provider_->IsScrollInProgress());
     EXPECT_TRUE(HasReceivedGesture(ET_GESTURE_SCROLL_END));
     EXPECT_EQ(ET_GESTURE_SCROLL_END, GetMostRecentGestureEventType());
   }
 
   static void RunTasksAndWait(base::TimeDelta delay) {
@@ skipping 107 matching lines @@
       ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN);
 
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
 
   event = ObtainMotionEvent(event_time + delta_time,
                             MotionEvent::ACTION_MOVE,
                             kFakeCoordX * 5,
                             kFakeCoordY * 5);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
   EXPECT_TRUE(gesture_provider_->IsScrollInProgress());
-  EXPECT_TRUE(HasReceivedGesture(ET_GESTURE_SCROLL_BEGIN));
-  EXPECT_EQ(ET_GESTURE_SCROLL_UPDATE, GetMostRecentGestureEventType());
-  ASSERT_EQ(4U, GetReceivedGestureCount());
-  ASSERT_EQ(ET_GESTURE_SCROLL_BEGIN, GetReceivedGesture(2).type);
+  ASSERT_EQ(5U, GetReceivedGestureCount());
+  ASSERT_EQ(ET_GESTURE_BEGIN, GetReceivedGesture(0).type);
+  ASSERT_EQ(ET_GESTURE_TAP_DOWN, GetReceivedGesture(1).type);
+  ASSERT_EQ(ET_GESTURE_TAP_CANCEL, GetReceivedGesture(2).type);
+  ASSERT_EQ(ET_GESTURE_SCROLL_BEGIN, GetReceivedGesture(3).type);
+  ASSERT_EQ(ET_GESTURE_SCROLL_UPDATE, GetReceivedGesture(4).type);
 
   // We don't want to take a dependency here on exactly how hints are calculated
   // for a fling (eg. may depend on velocity), so just validate the direction.
-  int hint_x = GetReceivedGesture(2).details.scroll_x_hint();
-  int hint_y = GetReceivedGesture(2).details.scroll_y_hint();
+  int hint_x = GetReceivedGesture(3).details.scroll_x_hint();
+  int hint_y = GetReceivedGesture(3).details.scroll_y_hint();
   EXPECT_TRUE(hint_x > 0 && hint_y > 0 && hint_x > hint_y)
       << "ScrollBegin hint should be in positive X axis";
 
   event = ObtainMotionEvent(event_time + delta_time * 2,
                             MotionEvent::ACTION_UP,
                             kFakeCoordX * 10,
                             kFakeCoordY * 10);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
   EXPECT_FALSE(gesture_provider_->IsScrollInProgress());
   EXPECT_EQ(ET_SCROLL_FLING_START, GetMostRecentGestureEventType());
@@ skipping 172 matching lines @@
   EXPECT_EQ(ET_GESTURE_SCROLL_END, GetMostRecentGestureEventType());
   const size_t gesture_count = GetReceivedGestureCount();
 
   event = ObtainMotionEvent(down_time_2 + kOneMicrosecond * 3,
                             MotionEvent::ACTION_POINTER_UP,
                             kFakeCoordX,
                             kFakeCoordY - 30,
                             kFakeCoordX + 50,
                             kFakeCoordY + 50);
   gesture_provider_->OnTouchEvent(event);
-  EXPECT_EQ(gesture_count, GetReceivedGestureCount());
+  EXPECT_EQ(ET_GESTURE_END, GetMostRecentGestureEventType());
+  EXPECT_EQ(gesture_count + 1, GetReceivedGestureCount());
 }
 
 // Generate a scroll gesture and verify that the resulting scroll motion event
 // has both absolute and relative position information.
 TEST_F(GestureProviderTest, ScrollUpdateValues) {
   const int delta_x = 16;
   const int delta_y = 84;
 
   const base::TimeTicks event_time = TimeTicks::Now();
 
@@ skipping 254 matching lines @@
   EXPECT_EQ(scroll_delta, gesture.details.scroll_y());
 }
 
 TEST_F(GestureProviderTest, NoDoubleTapWhenExplicitlyDisabled) {
   gesture_provider_->SetDoubleTapSupportForPlatformEnabled(false);
 
   base::TimeTicks event_time = base::TimeTicks::Now();
   MockMotionEvent event = ObtainMotionEvent(
       event_time, MotionEvent::ACTION_DOWN, kFakeCoordX, kFakeCoordY);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
-  EXPECT_EQ(1U, GetReceivedGestureCount());
+  EXPECT_EQ(2U, GetReceivedGestureCount());
   EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
+  EXPECT_EQ(ET_GESTURE_BEGIN, GetReceivedGesture(0).type);
 
   event = ObtainMotionEvent(event_time + kOneMicrosecond,
                             MotionEvent::ACTION_UP,
                             kFakeCoordX,
                             kFakeCoordY);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
   EXPECT_EQ(ET_GESTURE_TAP, GetMostRecentGestureEventType());
 
   event = ObtainMotionEvent(event_time + kOneMicrosecond * 2,
                             MotionEvent::ACTION_DOWN,
@@ skipping 202 matching lines @@
 
   gesture_provider_->SetMultiTouchSupportEnabled(true);
 
   int secondary_coord_x = kFakeCoordX + 20 * scaled_touch_slop;
   int secondary_coord_y = kFakeCoordY + 20 * scaled_touch_slop;
 
   MockMotionEvent event =
       ObtainMotionEvent(event_time, MotionEvent::ACTION_DOWN);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
   EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
+  EXPECT_EQ(ET_GESTURE_BEGIN, GetReceivedGesture(0).type);
 
   event = ObtainMotionEvent(event_time,
                             MotionEvent::ACTION_POINTER_DOWN,
                             kFakeCoordX,
                             kFakeCoordY,
                             secondary_coord_x,
                             secondary_coord_y);
   gesture_provider_->OnTouchEvent(event);
-  EXPECT_EQ(1U, GetReceivedGestureCount());
+  EXPECT_EQ(3U, GetReceivedGestureCount());
+  EXPECT_EQ(ET_GESTURE_BEGIN, GetReceivedGesture(2).type);
 
   secondary_coord_x += 5 * scaled_touch_slop;
   secondary_coord_y += 5 * scaled_touch_slop;
 
   event = ObtainMotionEvent(event_time,
                             MotionEvent::ACTION_MOVE,
                             kFakeCoordX,
                             kFakeCoordY,
                             secondary_coord_x,
                             secondary_coord_y);
@@ skipping 68 matching lines @@
                             MotionEvent::ACTION_UP);
   EXPECT_FALSE(gesture_provider_->OnTouchEvent(event));
 
   event = ObtainMotionEvent(event_time + kOneMicrosecond * 3,
                             MotionEvent::ACTION_DOWN);
   EXPECT_TRUE(gesture_provider_->OnTouchEvent(event));
   EXPECT_EQ(ET_GESTURE_TAP_DOWN, GetMostRecentGestureEventType());
 }
 
 }  // namespace ui