Fix TAP_DOWN gesture event:

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 18 matching lines @@
   return consumer && !consumer->ignores_events() ?
       base::IntToString(static_cast<Window*>(consumer)->id()) : "?";
 }
 
 // A delegate that keeps track of gesture events.
 class GestureEventConsumeDelegate : public TestWindowDelegate {
  public:
   GestureEventConsumeDelegate()
       : tap_(false),
         tap_down_(false),
-        tap_up_(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_x_(0),
         scroll_y_(0),
         velocity_x_(0),
         velocity_y_(0),
         radius_x_(0),
         radius_y_(0) {
   }
 
   virtual ~GestureEventConsumeDelegate() {}
 
   void Reset() {
     tap_ = false;
     tap_down_ = false;
-    tap_up_ = 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;
     radius_x_ = 0;
     radius_y_ = 0;
   }
 
   bool tap() const { return tap_; }
   bool tap_down() const { return tap_down_; }
-  bool tap_up() const { return tap_up_; }
+  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_; }
   bool pinch_begin() const { return pinch_begin_; }
   bool pinch_update() const { return pinch_update_; }
   bool pinch_end() const { return pinch_end_; }
   bool long_press() const { return long_press_; }
   bool fling() const { return fling_; }
   bool two_finger_tap() const { return two_finger_tap_; }
@@ skipping 18 matching lines @@
     switch (gesture->type()) {
       case ui::ET_GESTURE_TAP:
         radius_x_ = gesture->delta_x();
         radius_y_ = gesture->delta_y();
         tap_location_ = gesture->location();
         tap_ = true;
         break;
       case ui::ET_GESTURE_TAP_DOWN:
         tap_down_ = true;
         break;
-      case ui::ET_GESTURE_TAP_UP:
-        tap_up_ = true;
+      case ui::ET_GESTURE_BEGIN:
+        begin_ = true;
+        break;
+      case ui::ET_GESTURE_END:
+        end_ = true;
         break;
       case ui::ET_GESTURE_DOUBLE_TAP:
         double_tap_ = true;
         break;
       case ui::ET_GESTURE_SCROLL_BEGIN:
         scroll_begin_ = true;
         scroll_begin_position_ = gesture->location();
         break;
       case ui::ET_GESTURE_SCROLL_UPDATE:
         scroll_update_ = true;
@@ skipping 27 matching lines @@
         break;
       default:
         NOTREACHED();
     }
     return ui::GESTURE_STATUS_CONSUMED;
   }
 
  private:
   bool tap_;
   bool tap_down_;
-  bool tap_up_;
+  bool begin_;
+  bool end_;
   bool double_tap_;
   bool scroll_begin_;
   bool scroll_update_;
   bool scroll_end_;
   bool pinch_begin_;
   bool pinch_update_;
   bool pinch_end_;
   bool long_press_;
   bool fling_;
   bool two_finger_tap_;
@@ skipping 209 matching lines @@
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, NULL));
 
   delegate->Reset();
   TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
                    kTouchId, GetTime());
   root_window()->DispatchTouchEvent(&press);
   EXPECT_FALSE(delegate->tap());
   EXPECT_TRUE(delegate->tap_down());
+  EXPECT_TRUE(delegate->begin());
   EXPECT_FALSE(delegate->double_tap());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
   EXPECT_FALSE(delegate->long_press());
 
   // Make sure there is enough delay before the touch is released so that it is
   // recognized as a tap.
   delegate->Reset();
   TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
                      kTouchId, press.time_stamp() +
                      base::TimeDelta::FromMilliseconds(50));
 
   root_window()->DispatchTouchEvent(&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());
 }
 
 // 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;
   gfx::Rect bounds(0, 0, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, NULL));
 
   // Test with no ET_TOUCH_MOVED events.
   {
      delegate->Reset();
      TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
                       kTouchId, GetTime());
      press.set_radius_x(5);
      press.set_radius_y(12);
      root_window()->DispatchTouchEvent(&press);
      EXPECT_FALSE(delegate->tap());
      EXPECT_TRUE(delegate->tap_down());
+     EXPECT_TRUE(delegate->begin());
      EXPECT_FALSE(delegate->double_tap());
      EXPECT_FALSE(delegate->scroll_begin());
      EXPECT_FALSE(delegate->scroll_update());
      EXPECT_FALSE(delegate->scroll_end());
      EXPECT_FALSE(delegate->long_press());
 
      // Make sure there is enough delay before the touch is released so that it
      // is recognized as a tap.
      delegate->Reset();
      TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
                         kTouchId, press.time_stamp() +
                         base::TimeDelta::FromMilliseconds(50));
      release.set_radius_x(5);
      release.set_radius_y(12);
 
      root_window()->DispatchTouchEvent(&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());
 
      gfx::Point actual_point(delegate->tap_location());
      EXPECT_EQ(12, delegate->radius_x());
      EXPECT_EQ(12, delegate->radius_y());
      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();
      TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(365, 290),
                       kTouchId, GetTime());
      press.set_radius_x(8);
      press.set_radius_y(14);
      root_window()->DispatchTouchEvent(&press);
      EXPECT_FALSE(delegate->tap());
      EXPECT_TRUE(delegate->tap_down());
+     EXPECT_TRUE(delegate->begin());
      EXPECT_FALSE(delegate->double_tap());
      EXPECT_FALSE(delegate->scroll_begin());
      EXPECT_FALSE(delegate->scroll_update());
      EXPECT_FALSE(delegate->scroll_end());
      EXPECT_FALSE(delegate->long_press());
 
      delegate->Reset();
      TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(377, 291),
                         kTouchId, press.time_stamp() +
                         base::TimeDelta::FromMilliseconds(50));
      release.set_radius_x(20);
      release.set_radius_y(13);
 
      root_window()->DispatchTouchEvent(&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());
 
      gfx::Point actual_point(delegate->tap_location());
      EXPECT_EQ(23, delegate->radius_x());
      EXPECT_EQ(20, delegate->radius_y());
      EXPECT_EQ(373, actual_point.x());
      EXPECT_EQ(290, actual_point.y());
   }
 
   // Test with a single ET_TOUCH_MOVED event.
   {
      delegate->Reset();
      TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(46, 205),
                       kTouchId, GetTime());
      press.set_radius_x(6);
      press.set_radius_y(10);
      root_window()->DispatchTouchEvent(&press);
      EXPECT_FALSE(delegate->tap());
      EXPECT_TRUE(delegate->tap_down());
+     EXPECT_TRUE(delegate->begin());
      EXPECT_FALSE(delegate->double_tap());
      EXPECT_FALSE(delegate->scroll_begin());
      EXPECT_FALSE(delegate->scroll_update());
      EXPECT_FALSE(delegate->scroll_end());
      EXPECT_FALSE(delegate->long_press());
 
      delegate->Reset();
      TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(52, 200),
                      kTouchId, press.time_stamp() +
                      base::TimeDelta::FromMilliseconds(50));
      move.set_radius_x(8);
      move.set_radius_y(12);
      root_window()->DispatchTouchEvent(&move);
      EXPECT_FALSE(delegate->tap());
      EXPECT_FALSE(delegate->tap_down());
+     EXPECT_FALSE(delegate->begin());
      EXPECT_FALSE(delegate->double_tap());
      EXPECT_FALSE(delegate->scroll_begin());
      EXPECT_FALSE(delegate->scroll_update());
      EXPECT_FALSE(delegate->scroll_end());
      EXPECT_FALSE(delegate->long_press());
 
      delegate->Reset();
      TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(50, 195),
                         kTouchId, press.time_stamp() +
                         base::TimeDelta::FromMilliseconds(50));
      release.set_radius_x(4);
      release.set_radius_y(8);
 
      root_window()->DispatchTouchEvent(&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());
 
      gfx::Point actual_point(delegate->tap_location());
      EXPECT_EQ(14, delegate->radius_x());
      EXPECT_EQ(14, delegate->radius_y());
      EXPECT_EQ(49, actual_point.x());
      EXPECT_EQ(200, actual_point.y());
   }
 
   // Test with a few ET_TOUCH_MOVED events.
   {
      delegate->Reset();
      TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(400, 150),
                       kTouchId, GetTime());
      press.set_radius_x(7);
      press.set_radius_y(10);
      root_window()->DispatchTouchEvent(&press);
      EXPECT_FALSE(delegate->tap());
      EXPECT_TRUE(delegate->tap_down());
+     EXPECT_TRUE(delegate->begin());
      EXPECT_FALSE(delegate->double_tap());
      EXPECT_FALSE(delegate->scroll_begin());
      EXPECT_FALSE(delegate->scroll_update());
      EXPECT_FALSE(delegate->scroll_end());
      EXPECT_FALSE(delegate->long_press());
 
      delegate->Reset();
      TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(397, 155),
                      kTouchId, press.time_stamp() +
                      base::TimeDelta::FromMilliseconds(50));
      move.set_radius_x(13);
      move.set_radius_y(12);
      root_window()->DispatchTouchEvent(&move);
      EXPECT_FALSE(delegate->tap());
      EXPECT_FALSE(delegate->tap_down());
+     EXPECT_FALSE(delegate->begin());
      EXPECT_FALSE(delegate->double_tap());
      EXPECT_FALSE(delegate->scroll_begin());
      EXPECT_FALSE(delegate->scroll_update());
      EXPECT_FALSE(delegate->scroll_end());
      EXPECT_FALSE(delegate->long_press());
 
      delegate->Reset();
      TouchEvent move1(ui::ET_TOUCH_MOVED, gfx::Point(395, 148),
                       kTouchId, move.time_stamp() +
                       base::TimeDelta::FromMilliseconds(50));
      move1.set_radius_x(16);
      move1.set_radius_y(16);
      root_window()->DispatchTouchEvent(&move1);
      EXPECT_FALSE(delegate->tap());
      EXPECT_FALSE(delegate->tap_down());
+     EXPECT_FALSE(delegate->begin());
      EXPECT_FALSE(delegate->double_tap());
      EXPECT_FALSE(delegate->scroll_begin());
      EXPECT_FALSE(delegate->scroll_update());
      EXPECT_FALSE(delegate->scroll_end());
      EXPECT_FALSE(delegate->long_press());
 
      delegate->Reset();
      TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::Point(400, 150),
                       kTouchId, move1.time_stamp() +
                       base::TimeDelta::FromMilliseconds(50));
      move2.set_radius_x(14);
      move2.set_radius_y(10);
      root_window()->DispatchTouchEvent(&move2);
      EXPECT_FALSE(delegate->tap());
      EXPECT_FALSE(delegate->tap_down());
+     EXPECT_FALSE(delegate->begin());
      EXPECT_FALSE(delegate->double_tap());
      EXPECT_FALSE(delegate->scroll_begin());
      EXPECT_FALSE(delegate->scroll_update());
      EXPECT_FALSE(delegate->scroll_end());
      EXPECT_FALSE(delegate->long_press());
 
      delegate->Reset();
      TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(401, 149),
                         kTouchId, press.time_stamp() +
                         base::TimeDelta::FromMilliseconds(50));
      release.set_radius_x(8);
      release.set_radius_y(9);
 
      root_window()->DispatchTouchEvent(&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());
 
      gfx::Point actual_point(delegate->tap_location());
      EXPECT_EQ(17, delegate->radius_x());
      EXPECT_EQ(18, delegate->radius_y());
      EXPECT_EQ(396, actual_point.x());
      EXPECT_EQ(149, actual_point.y());
@@ skipping 10 matching lines @@
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, NULL));
 
   delegate->Reset();
   TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
                    kTouchId, GetTime());
   root_window()->DispatchTouchEvent(&press);
   EXPECT_FALSE(delegate->tap());
   EXPECT_TRUE(delegate->tap_down());
+  EXPECT_TRUE(delegate->begin());
   EXPECT_FALSE(delegate->double_tap());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
 
   // Move the touch-point enough so that it is considered as a scroll. This
   // should generate both SCROLL_BEGIN and SCROLL_UPDATE gestures.
   // The first movement is diagonal, to ensure that we have a free scroll,
   // and not a rail scroll.
   SendScrollEvent(root_window(), 130, 230, kTouchId, delegate.get());
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
+  EXPECT_FALSE(delegate->begin());
   EXPECT_FALSE(delegate->double_tap());
   EXPECT_TRUE(delegate->scroll_begin());
   EXPECT_TRUE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
   EXPECT_EQ(29, delegate->scroll_x());
   EXPECT_EQ(29, delegate->scroll_y());
   EXPECT_EQ(gfx::Point(1, 1).ToString(),
             delegate->scroll_begin_position().ToString());
 
   // Move some more to generate a few more scroll updates.
   SendScrollEvent(root_window(), 110, 211, kTouchId, delegate.get());
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
+  EXPECT_FALSE(delegate->begin());
   EXPECT_FALSE(delegate->double_tap());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_TRUE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
   EXPECT_EQ(-20, delegate->scroll_x());
   EXPECT_EQ(-19, delegate->scroll_y());
 
   SendScrollEvent(root_window(), 140, 215, kTouchId, delegate.get());
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
+  EXPECT_FALSE(delegate->begin());
   EXPECT_FALSE(delegate->double_tap());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_TRUE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
   EXPECT_EQ(30, delegate->scroll_x());
   EXPECT_EQ(4, delegate->scroll_y());
 
   // Release the touch. This should end the scroll.
   delegate->Reset();
   TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
                      kTouchId, press.time_stamp() +
                      base::TimeDelta::FromMilliseconds(50));
   root_window()->DispatchTouchEvent(&release);
   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 Scroll End Events report correct velocities
 // if the user was on a horizontal rail
 TEST_F(GestureRecognizerTest, GestureEventHorizontalRailFling) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
@@ skipping 117 matching lines @@
   TimerTestGestureSequence* gesture_sequence =
       static_cast<TimerTestGestureSequence*>(
           gesture_recognizer->GetGestureSequenceForTesting(window.get()));
 
   root_window()->SetGestureRecognizerForTesting(gesture_recognizer);
 
   TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
                     kTouchId, GetTime());
   root_window()->DispatchTouchEvent(&press1);
   EXPECT_TRUE(delegate->tap_down());
+  EXPECT_TRUE(delegate->begin());
 
   // We haven't pressed long enough for a long press to occur
   EXPECT_FALSE(delegate->long_press());
 
   // Wait until the timer runs out
   gesture_sequence->ForceTimeout();
   EXPECT_TRUE(delegate->long_press());
   EXPECT_EQ(0, delegate->touch_id());
 
   delegate->Reset();
@@ skipping 63 matching lines @@
       static_cast<TimerTestGestureSequence*>(
           gesture_recognizer->GetGestureSequenceForTesting(window.get()));
 
   root_window()->SetGestureRecognizerForTesting(gesture_recognizer);
 
   delegate->Reset();
   TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
                    kTouchId1, GetTime());
   root_window()->DispatchTouchEvent(&press);
   EXPECT_TRUE(delegate->tap_down());
+  EXPECT_TRUE(delegate->begin());
 
   // We haven't pressed long enough for a long press to occur
   EXPECT_FALSE(delegate->long_press());
 
   // Second tap, to cancel the long press
   delegate->Reset();
   TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(10, 10),
                     kTouchId2, GetTime());
   root_window()->DispatchTouchEvent(&press2);
   EXPECT_FALSE(delegate->tap_down());  // no touch down for second tap.
+  EXPECT_TRUE(delegate->begin());
 
   // Wait until the timer runs out
   gesture_sequence->ForceTimeout();
 
   // No long press occurred
   EXPECT_FALSE(delegate->long_press());
 
   delegate->Reset();
   TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
                       kTouchId1, GetTime());
@@ skipping 243 matching lines @@
 
   queued_delegate->set_window(queue.get());
 
   // Touch down on the window. This should not generate any gesture event.
   queued_delegate->Reset();
   TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
                    kTouchId1, GetTime());
   root_window()->DispatchTouchEvent(&press);
   EXPECT_FALSE(queued_delegate->tap());
   EXPECT_FALSE(queued_delegate->tap_down());
+  EXPECT_FALSE(queued_delegate->begin());
   EXPECT_FALSE(queued_delegate->double_tap());
   EXPECT_FALSE(queued_delegate->scroll_begin());
   EXPECT_FALSE(queued_delegate->scroll_update());
   EXPECT_FALSE(queued_delegate->scroll_end());
 
   // Introduce some delay before the touch is released so that it is recognized
   // as a tap. However, this still should not create any gesture events.
   queued_delegate->Reset();
   TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
                      kTouchId1, press.time_stamp() +
                      base::TimeDelta::FromMilliseconds(50));
   root_window()->DispatchTouchEvent(&release);
   EXPECT_FALSE(queued_delegate->tap());
   EXPECT_FALSE(queued_delegate->tap_down());
+  EXPECT_FALSE(queued_delegate->begin());
+  EXPECT_FALSE(queued_delegate->end());
   EXPECT_FALSE(queued_delegate->double_tap());
   EXPECT_FALSE(queued_delegate->scroll_begin());
   EXPECT_FALSE(queued_delegate->scroll_update());
   EXPECT_FALSE(queued_delegate->scroll_end());
 
   // Create another window, and place a touch-down on it. This should create a
   // tap-down gesture.
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -2345, gfx::Rect(0, 0, 50, 50), NULL));
   delegate->Reset();
   TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(10, 20),
                     kTouchId2, GetTime());
   root_window()->DispatchTouchEvent(&press2);
   EXPECT_FALSE(delegate->tap());
   EXPECT_TRUE(delegate->tap_down());
+  EXPECT_FALSE(queued_delegate->begin());
+  EXPECT_FALSE(queued_delegate->end());
   EXPECT_FALSE(delegate->double_tap());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
 
   TouchEvent release2(ui::ET_TOUCH_RELEASED, gfx::Point(10, 20),
                       kTouchId2, GetTime());
   root_window()->DispatchTouchEvent(&release2);
 
   // Process the first queued event.
   queued_delegate->Reset();
   queued_delegate->ReceivedAck();
   EXPECT_FALSE(queued_delegate->tap());
   EXPECT_TRUE(queued_delegate->tap_down());
+  EXPECT_TRUE(queued_delegate->begin());
+  EXPECT_FALSE(queued_delegate->end());
   EXPECT_FALSE(queued_delegate->double_tap());
   EXPECT_FALSE(queued_delegate->scroll_begin());
   EXPECT_FALSE(queued_delegate->scroll_update());
   EXPECT_FALSE(queued_delegate->scroll_end());
 
   // Now, process the second queued event.
   queued_delegate->Reset();
   queued_delegate->ReceivedAck();
   EXPECT_TRUE(queued_delegate->tap());
   EXPECT_FALSE(queued_delegate->tap_down());
+  EXPECT_FALSE(queued_delegate->begin());
+  EXPECT_TRUE(queued_delegate->end());
   EXPECT_FALSE(queued_delegate->double_tap());
   EXPECT_FALSE(queued_delegate->scroll_begin());
   EXPECT_FALSE(queued_delegate->scroll_update());
   EXPECT_FALSE(queued_delegate->scroll_end());
 
   // Start all over. Press on the first window, then press again on the second
   // window. The second press should still go to the first window.
   queued_delegate->Reset();
   TouchEvent press3(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
                     kTouchId1, GetTime());
   root_window()->DispatchTouchEvent(&press3);
   EXPECT_FALSE(queued_delegate->tap());
   EXPECT_FALSE(queued_delegate->tap_down());
+  EXPECT_FALSE(queued_delegate->begin());
+  EXPECT_FALSE(queued_delegate->end());
+  EXPECT_FALSE(queued_delegate->begin());
+  EXPECT_FALSE(queued_delegate->end());
   EXPECT_FALSE(queued_delegate->double_tap());
   EXPECT_FALSE(queued_delegate->scroll_begin());
   EXPECT_FALSE(queued_delegate->scroll_update());
   EXPECT_FALSE(queued_delegate->scroll_end());
 
   queued_delegate->Reset();
   delegate->Reset();
   TouchEvent press4(ui::ET_TOUCH_PRESSED, gfx::Point(103, 203),
                     kTouchId2, GetTime());
   root_window()->DispatchTouchEvent(&press4);
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
+  EXPECT_FALSE(delegate->begin());
+  EXPECT_FALSE(delegate->end());
   EXPECT_FALSE(delegate->double_tap());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
   EXPECT_FALSE(queued_delegate->tap());
   EXPECT_FALSE(queued_delegate->tap_down());
+  EXPECT_FALSE(queued_delegate->begin());
+  EXPECT_FALSE(queued_delegate->end());
   EXPECT_FALSE(queued_delegate->double_tap());
   EXPECT_FALSE(queued_delegate->scroll_begin());
   EXPECT_FALSE(queued_delegate->scroll_update());
   EXPECT_FALSE(queued_delegate->scroll_end());
 
   // Move the second touch-point enough so that it is considered a pinch. This
   // should generate both SCROLL_BEGIN and PINCH_BEGIN gestures.
   queued_delegate->Reset();
   delegate->Reset();
   int x_move = ui::GestureConfiguration::max_touch_move_in_pixels_for_click();
   TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(103 + x_move, 203),
                   kTouchId2, GetTime());
   root_window()->DispatchTouchEvent(&move);
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
+  EXPECT_FALSE(delegate->begin());
   EXPECT_FALSE(delegate->double_tap());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
   EXPECT_FALSE(queued_delegate->tap());
   EXPECT_FALSE(queued_delegate->tap_down());
+  EXPECT_FALSE(queued_delegate->begin());
   EXPECT_FALSE(queued_delegate->double_tap());
   EXPECT_FALSE(queued_delegate->scroll_begin());
   EXPECT_FALSE(queued_delegate->scroll_update());
   EXPECT_FALSE(queued_delegate->scroll_end());
 
   queued_delegate->Reset();
   queued_delegate->ReceivedAck();
   EXPECT_FALSE(queued_delegate->tap());
   EXPECT_TRUE(queued_delegate->tap_down());
+  EXPECT_TRUE(queued_delegate->begin());
+  EXPECT_FALSE(queued_delegate->end());
   EXPECT_FALSE(queued_delegate->double_tap());
   EXPECT_FALSE(queued_delegate->scroll_begin());
   EXPECT_FALSE(queued_delegate->scroll_update());
   EXPECT_FALSE(queued_delegate->scroll_end());
 
   queued_delegate->Reset();
   queued_delegate->ReceivedAck();
   EXPECT_FALSE(queued_delegate->tap());
   EXPECT_FALSE(queued_delegate->tap_down());  // no touch down for second tap.
+  EXPECT_TRUE(queued_delegate->begin());
+  EXPECT_FALSE(queued_delegate->end());
   EXPECT_FALSE(queued_delegate->double_tap());
   EXPECT_FALSE(queued_delegate->scroll_begin());
   EXPECT_FALSE(queued_delegate->scroll_update());
   EXPECT_FALSE(queued_delegate->scroll_end());
   EXPECT_FALSE(queued_delegate->pinch_begin());
   EXPECT_FALSE(queued_delegate->pinch_update());
   EXPECT_FALSE(queued_delegate->pinch_end());
 
   queued_delegate->Reset();
   queued_delegate->ReceivedAck();
   EXPECT_FALSE(queued_delegate->tap());
   EXPECT_FALSE(queued_delegate->tap_down());
+  EXPECT_FALSE(queued_delegate->begin());
+  EXPECT_FALSE(queued_delegate->end());
   EXPECT_FALSE(queued_delegate->double_tap());
   EXPECT_TRUE(queued_delegate->scroll_begin());
   EXPECT_FALSE(queued_delegate->scroll_update());
   EXPECT_FALSE(queued_delegate->scroll_end());
   EXPECT_TRUE(queued_delegate->pinch_begin());
   EXPECT_FALSE(queued_delegate->pinch_update());
   EXPECT_FALSE(queued_delegate->pinch_end());
 }
 
 // Check that appropriate touch events generate pinch gesture events.
@@ skipping 413 matching lines @@
   generator.PressTouch();
   RunAllPendingInMessageLoop();
 
   EXPECT_TRUE(delegate->tap_down());
 
   scoped_ptr<aura::Window> capture(CreateTestWindowWithBounds(
       gfx::Rect(10, 10, 200, 200), NULL));
   capture->SetCapture();
   RunAllPendingInMessageLoop();
 
-  EXPECT_TRUE(delegate->tap_up());
+  EXPECT_TRUE(delegate->end());
 }
 
 TEST_F(GestureRecognizerTest, TwoFingerTap) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   const int kWindowWidth = 123;
   const int kWindowHeight = 45;
   const int kTouchId1 = 2;
   const int kTouchId2 = 3;
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
@@ skipping 324 matching lines @@
   root_window()->DispatchTouchEvent(&press2);
   window->Hide();
   EXPECT_EQ(NULL,
             root_window()->gesture_recognizer()->GetTouchLockedTarget(&press1));
   EXPECT_EQ(NULL,
             root_window()->gesture_recognizer()->GetTouchLockedTarget(&press2));
 }
 
 }  // namespace test
 }  // namespace aura