Pass tap count (1 or 2) with tap gesture events

ui/aura/gestures/gesture_recognizer_unittest.cc

 // Copyright (c) 2012 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/memory/scoped_vector.h"
 #include "base/string_number_conversions.h"
 #include "base/timer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/aura/event.h"
 #include "ui/aura/root_window.h"
@@ skipping 33 matching lines @@
         scroll_end_(false),
         pinch_begin_(false),
         pinch_update_(false),
         pinch_end_(false),
         long_press_(false),
         fling_(false),
         two_finger_tap_(false),
         scroll_x_(0),
         scroll_y_(0),
         velocity_x_(0),
-        velocity_y_(0) {
+        velocity_y_(0),
+        tap_count_(0) {
   }
 
   virtual ~GestureEventConsumeDelegate() {}
 
   void Reset() {
     tap_ = false;
     tap_down_ = false;
     begin_ = false;
     end_ = false;
     double_tap_ = false;
     scroll_begin_ = false;
     scroll_update_ = false;
     scroll_end_ = false;
     pinch_begin_ = false;
     pinch_update_ = false;
     pinch_end_ = false;
     long_press_ = false;
     fling_ = false;
     two_finger_tap_ = false;
 
     scroll_begin_position_.SetPoint(0, 0);
     tap_location_.SetPoint(0, 0);
 
     scroll_x_ = 0;
     scroll_y_ = 0;
     velocity_x_ = 0;
     velocity_y_ = 0;
+    tap_count_ = 0;
   }
 
   bool tap() const { return tap_; }
   bool tap_down() const { return tap_down_; }
   bool begin() const { return begin_; }
   bool end() const { return end_; }
   bool double_tap() const { return double_tap_; }
   bool scroll_begin() const { return scroll_begin_; }
   bool scroll_update() const { return scroll_update_; }
   bool scroll_end() const { return scroll_end_; }
@@ skipping 11 matching lines @@
   const gfx::Point tap_location() const {
     return tap_location_;
   }
 
   float scroll_x() const { return scroll_x_; }
   float scroll_y() const { return scroll_y_; }
   int touch_id() const { return touch_id_; }
   float velocity_x() const { return velocity_x_; }
   float velocity_y() const { return velocity_y_; }
   const gfx::Rect& bounding_box() const { return bounding_box_; }
+  int tap_count() const { return tap_count_; }
 
   virtual ui::GestureStatus OnGestureEvent(GestureEvent* gesture) OVERRIDE {
     bounding_box_ = gesture->details().bounding_box();
     switch (gesture->type()) {
       case ui::ET_GESTURE_TAP:
         tap_location_ = gesture->location();
+        tap_count_ = gesture->details().tap_count();
         tap_ = true;
         break;
       case ui::ET_GESTURE_TAP_DOWN:
         tap_down_ = true;
         break;
       case ui::ET_GESTURE_BEGIN:
         begin_ = true;
         break;
       case ui::ET_GESTURE_END:
         end_ = true;
@@ skipping 60 matching lines @@
 
   gfx::Point scroll_begin_position_;
   gfx::Point tap_location_;
 
   float scroll_x_;
   float scroll_y_;
   float velocity_x_;
   float velocity_y_;
   int touch_id_;
   gfx::Rect bounding_box_;
+  int tap_count_;
 
   DISALLOW_COPY_AND_ASSIGN(GestureEventConsumeDelegate);
 };
 
 class QueueTouchEventDelegate : public GestureEventConsumeDelegate {
  public:
   explicit QueueTouchEventDelegate(RootWindow* root_window)
       : window_(NULL),
         root_window_(root_window) {
   }
@@ skipping 215 matching lines @@
 
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&release);
   EXPECT_TRUE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
   EXPECT_FALSE(delegate->begin());
   EXPECT_TRUE(delegate->end());
   EXPECT_FALSE(delegate->double_tap());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
+
+  EXPECT_EQ(1, delegate->tap_count());
 }
 
 // Check that appropriate touch events generate tap gesture events
 // when information about the touch radii are provided.
 TEST_F(GestureRecognizerTest, GestureEventTapRegion) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   const int kWindowWidth = 800;
   const int kWindowHeight = 600;
   const int kTouchId = 2;
@@ skipping 30 matching lines @@
      root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&release);
      EXPECT_TRUE(delegate->tap());
      EXPECT_FALSE(delegate->tap_down());
      EXPECT_FALSE(delegate->begin());
      EXPECT_TRUE(delegate->end());
      EXPECT_FALSE(delegate->double_tap());
      EXPECT_FALSE(delegate->scroll_begin());
      EXPECT_FALSE(delegate->scroll_update());
      EXPECT_FALSE(delegate->scroll_end());
 
+     EXPECT_EQ(1, delegate->tap_count());
      gfx::Point actual_point(delegate->tap_location());
      EXPECT_EQ(24, delegate->bounding_box().width());
      EXPECT_EQ(24, delegate->bounding_box().height());
      EXPECT_EQ(100, actual_point.x());
      EXPECT_EQ(200, actual_point.y());
   }
 
   // Test with no ET_TOUCH_MOVED events but different touch points and radii.
   {
      delegate->Reset();
@@ skipping 21 matching lines @@
      root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&release);
      EXPECT_TRUE(delegate->tap());
      EXPECT_FALSE(delegate->tap_down());
      EXPECT_FALSE(delegate->begin());
      EXPECT_TRUE(delegate->end());
      EXPECT_FALSE(delegate->double_tap());
      EXPECT_FALSE(delegate->scroll_begin());
      EXPECT_FALSE(delegate->scroll_update());
      EXPECT_FALSE(delegate->scroll_end());
 
+     EXPECT_EQ(1, delegate->tap_count());
      gfx::Point actual_point(delegate->tap_location());
      EXPECT_EQ(46, delegate->bounding_box().width());
      EXPECT_EQ(40, delegate->bounding_box().height());
      EXPECT_EQ(373, actual_point.x());
      EXPECT_EQ(290, actual_point.y());
   }
 
   // Test with a single ET_TOUCH_MOVED event.
   {
      delegate->Reset();
@@ skipping 37 matching lines @@
      root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&release);
      EXPECT_TRUE(delegate->tap());
      EXPECT_FALSE(delegate->tap_down());
      EXPECT_FALSE(delegate->begin());
      EXPECT_TRUE(delegate->end());
      EXPECT_FALSE(delegate->double_tap());
      EXPECT_FALSE(delegate->scroll_begin());
      EXPECT_FALSE(delegate->scroll_update());
      EXPECT_FALSE(delegate->scroll_end());
 
+     EXPECT_EQ(1, delegate->tap_count());
      gfx::Point actual_point(delegate->tap_location());
      EXPECT_EQ(28, delegate->bounding_box().width());
      EXPECT_EQ(28, delegate->bounding_box().height());
      EXPECT_EQ(49, actual_point.x());
      EXPECT_EQ(200, actual_point.y());
   }
 
   // Test with a few ET_TOUCH_MOVED events.
   {
      delegate->Reset();
@@ skipping 69 matching lines @@
      root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&release);
      EXPECT_TRUE(delegate->tap());
      EXPECT_FALSE(delegate->tap_down());
      EXPECT_FALSE(delegate->begin());
      EXPECT_TRUE(delegate->end());
      EXPECT_FALSE(delegate->double_tap());
      EXPECT_FALSE(delegate->scroll_begin());
      EXPECT_FALSE(delegate->scroll_update());
      EXPECT_FALSE(delegate->scroll_end());
 
+     EXPECT_EQ(1, delegate->tap_count());
      gfx::Point actual_point(delegate->tap_location());
      EXPECT_EQ(35, delegate->bounding_box().width());
      EXPECT_EQ(36, delegate->bounding_box().height());
      EXPECT_EQ(396, actual_point.x());
      EXPECT_EQ(149, actual_point.y());
   }
 }
 
 // Check that appropriate touch events generate scroll gesture events.
 TEST_F(GestureRecognizerTest, GestureEventScroll) {
@@ skipping 1687 matching lines @@
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
   EXPECT_FALSE(delegate->begin());
   EXPECT_TRUE(delegate->end());
   EXPECT_FALSE(delegate->double_tap());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_TRUE(delegate->scroll_end());
 }
 
+// Check that appropriate touch events generate double tap gesture events.
+TEST_F(GestureRecognizerTest, GestureEventDoubleTap) {
+  scoped_ptr<GestureEventConsumeDelegate> delegate(
+      new GestureEventConsumeDelegate());
+  const int kWindowWidth = 123;
+  const int kWindowHeight = 45;
+  const int kTouchId = 2;
+  gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
+  scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
+      delegate.get(), -1234, bounds, NULL));
+
+  // First tap (tested in GestureEventTap)
+  TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(104, 201),
+                   kTouchId, GetTime());
+  root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&press1);
+  TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(104, 201),
+                     kTouchId, press1.time_stamp() +
+                     base::TimeDelta::FromMilliseconds(50));
+  root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&release1);
+  delegate->Reset();
+
+  // Second tap
+  TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(101, 203),
+                   kTouchId, release1.time_stamp() +
+                   base::TimeDelta::FromMilliseconds(200));
+  root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&press2);
+  TouchEvent release2(ui::ET_TOUCH_RELEASED, gfx::Point(102, 206),
+                     kTouchId, press2.time_stamp() +
+                     base::TimeDelta::FromMilliseconds(50));
+  root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&release2);
+
+  EXPECT_TRUE(delegate->tap());
+  EXPECT_TRUE(delegate->tap_down());
+  EXPECT_TRUE(delegate->begin());
+  EXPECT_TRUE(delegate->end());
+  EXPECT_TRUE(delegate->double_tap());
+  EXPECT_FALSE(delegate->scroll_begin());
+  EXPECT_FALSE(delegate->scroll_update());
+  EXPECT_FALSE(delegate->scroll_end());
+
+  EXPECT_EQ(2, delegate->tap_count());
+}
+
+// Check that we don't get a double tap when the two taps are far apart.
+TEST_F(GestureRecognizerTest, TwoTapsFarApart) {
+  scoped_ptr<GestureEventConsumeDelegate> delegate(
+      new GestureEventConsumeDelegate());
+  const int kWindowWidth = 123;
+  const int kWindowHeight = 45;
+  const int kTouchId = 2;
+  gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
+  scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
+      delegate.get(), -1234, bounds, NULL));
+
+  // First tap (tested in GestureEventTap)
+  TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
+                   kTouchId, GetTime());
+  root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&press1);
+  TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
+                     kTouchId, press1.time_stamp() +
+                     base::TimeDelta::FromMilliseconds(50));
+  root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&release1);
+  delegate->Reset();
+
+  // Second tap, close in time but far in distance
+  TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(201, 201),
+                   kTouchId, release1.time_stamp() +
+                   base::TimeDelta::FromMilliseconds(200));
+  root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&press2);
+  TouchEvent release2(ui::ET_TOUCH_RELEASED, gfx::Point(201, 201),
+                     kTouchId, press2.time_stamp() +
+                     base::TimeDelta::FromMilliseconds(50));
+  root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&release2);
+
+  EXPECT_TRUE(delegate->tap());
+  EXPECT_TRUE(delegate->tap_down());
+  EXPECT_TRUE(delegate->begin());
+  EXPECT_TRUE(delegate->end());
+  EXPECT_FALSE(delegate->double_tap());
+  EXPECT_FALSE(delegate->scroll_begin());
+  EXPECT_FALSE(delegate->scroll_update());
+  EXPECT_FALSE(delegate->scroll_end());
+
+  EXPECT_EQ(1, delegate->tap_count());
+}
+
+// Check that we don't get a double tap when the two taps have a long enough
+// delay in between.
+TEST_F(GestureRecognizerTest, TwoTapsWithDelayBetween) {
+  scoped_ptr<GestureEventConsumeDelegate> delegate(
+      new GestureEventConsumeDelegate());
+  const int kWindowWidth = 123;
+  const int kWindowHeight = 45;
+  const int kTouchId = 2;
+  gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
+  scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
+      delegate.get(), -1234, bounds, NULL));
+
+  // First tap (tested in GestureEventTap)
+  TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
+                   kTouchId, GetTime());
+  root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&press1);
+  TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
+                     kTouchId, press1.time_stamp() +
+                     base::TimeDelta::FromMilliseconds(50));
+  root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&release1);
+  delegate->Reset();
+
+  // Second tap, close in distance but after some delay
+  TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
+                   kTouchId, release1.time_stamp() +
+                   base::TimeDelta::FromMilliseconds(2000));
+  root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&press2);
+  TouchEvent release2(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
+                     kTouchId, press2.time_stamp() +
+                     base::TimeDelta::FromMilliseconds(50));
+  root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&release2);
+
+  EXPECT_TRUE(delegate->tap());
+  EXPECT_TRUE(delegate->tap_down());
+  EXPECT_TRUE(delegate->begin());
+  EXPECT_TRUE(delegate->end());
+  EXPECT_FALSE(delegate->double_tap());
+  EXPECT_FALSE(delegate->scroll_begin());
+  EXPECT_FALSE(delegate->scroll_update());
+  EXPECT_FALSE(delegate->scroll_end());
+
+  EXPECT_EQ(1, delegate->tap_count());
+}
+
 }  // namespace test
 }  // namespace aura