Add GestureTapCancel gesture type

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/root_window.h"
 #include "ui/aura/test/aura_test_base.h"
@@ skipping 12 matching lines @@
 namespace aura {
 namespace test {
 
 namespace {
 
 std::string WindowIDAsString(ui::GestureConsumer* consumer) {
   return consumer && !consumer->ignores_events() ?
       base::IntToString(static_cast<Window*>(consumer)->id()) : "?";
 }
 
+#define EXPECT_0_EVENTS(events) \
+    EXPECT_EQ(0u, events.size())
+
+#define EXPECT_1_EVENT(events, e0) \
+    EXPECT_EQ(1u, events.size()); \
+    EXPECT_EQ(e0, events[0])
+
+#define EXPECT_2_EVENTS(events, e0, e1) \
+    EXPECT_EQ(2u, events.size()); \
+    EXPECT_EQ(e0, events[0]); \
+    EXPECT_EQ(e1, events[1])
+
+#define EXPECT_3_EVENTS(events, e0, e1, e2) \
+    EXPECT_EQ(3u, events.size()); \
+    EXPECT_EQ(e0, events[0]); \
+    EXPECT_EQ(e1, events[1]); \
+    EXPECT_EQ(e2, events[2])
+
+#define EXPECT_4_EVENTS(events, e0, e1, e2, e3) \
+    EXPECT_EQ(4u, events.size()); \
+    EXPECT_EQ(e0, events[0]); \
+    EXPECT_EQ(e1, events[1]); \
+    EXPECT_EQ(e2, events[2]); \
+    EXPECT_EQ(e3, events[3])
+
 // A delegate that keeps track of gesture events.
 class GestureEventConsumeDelegate : public TestWindowDelegate {
  public:
   GestureEventConsumeDelegate()
       : tap_(false),
         tap_down_(false),
+        tap_cancel_(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),
         swipe_left_(false),
         swipe_right_(false),
         swipe_up_(false),
         swipe_down_(false),
         scroll_x_(0),
         scroll_y_(0),
         scroll_velocity_x_(0),
         scroll_velocity_y_(0),
         velocity_x_(0),
         velocity_y_(0),
         tap_count_(0) {
   }
 
   virtual ~GestureEventConsumeDelegate() {}
 
   void Reset() {
+    events_.clear();
     tap_ = false;
     tap_down_ = false;
+    tap_cancel_ = 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;
     swipe_left_ = false;
     swipe_right_ = false;
     swipe_up_ = false;
     swipe_down_ = false;
 
     scroll_begin_position_.SetPoint(0, 0);
     tap_location_.SetPoint(0, 0);
 
     scroll_x_ = 0;
     scroll_y_ = 0;
     scroll_velocity_x_ = 0;
     scroll_velocity_y_ = 0;
     velocity_x_ = 0;
     velocity_y_ = 0;
     tap_count_ = 0;
   }
 
+  const std::vector<ui::EventType>& events() const { return events_; };
+
   bool tap() const { return tap_; }
   bool tap_down() const { return tap_down_; }
+  bool tap_cancel() const { return tap_cancel_; }
   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_; }
@@ skipping 17 matching lines @@
   float scroll_velocity_x() const { return scroll_velocity_x_; }
   float scroll_velocity_y() const { return scroll_velocity_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::EventResult OnGestureEvent(
       ui::GestureEvent* gesture) OVERRIDE {
+    events_.push_back(gesture->type());
     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_TAP_CANCEL:
+        tap_cancel_ = true;
+        break;
       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:
@@ skipping 41 matching lines @@
         swipe_up_ = gesture->details().swipe_up();
         swipe_down_ = gesture->details().swipe_down();
         break;
       default:
         NOTREACHED();
     }
     return ui::ER_CONSUMED;
   }
 
  private:
+  std::vector<ui::EventType> events_;
+
   bool tap_;
   bool tap_down_;
+  bool tap_cancel_;
   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_;
@@ skipping 226 matching lines @@
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, NULL));
 
   delegate->Reset();
   ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
                            kTouchId, GetTime());
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&press);
   EXPECT_FALSE(delegate->tap());
   EXPECT_TRUE(delegate->tap_down());
+  EXPECT_FALSE(delegate->tap_cancel());
   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();
   ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
                              kTouchId, press.time_stamp() +
                              base::TimeDelta::FromMilliseconds(50));
 
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&release);
   EXPECT_TRUE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
+  EXPECT_FALSE(delegate->tap_cancel());
   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());
 }
 
@@ skipping 12 matching lines @@
   // Test with no ET_TOUCH_MOVED events.
   {
      delegate->Reset();
      ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
                               kTouchId, GetTime());
      press.set_radius_x(5);
      press.set_radius_y(12);
      root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&press);
      EXPECT_FALSE(delegate->tap());
      EXPECT_TRUE(delegate->tap_down());
+     EXPECT_FALSE(delegate->tap_cancel());
      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();
      ui::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()->AsRootWindowHostDelegate()->OnHostTouchEvent(&release);
      EXPECT_TRUE(delegate->tap());
      EXPECT_FALSE(delegate->tap_down());
+     EXPECT_FALSE(delegate->tap_cancel());
      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();
      ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(365, 290),
                               kTouchId, GetTime());
      press.set_radius_x(8);
      press.set_radius_y(14);
      root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&press);
      EXPECT_FALSE(delegate->tap());
      EXPECT_TRUE(delegate->tap_down());
+     EXPECT_FALSE(delegate->tap_cancel());
      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();
      ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(367, 291),
                                 kTouchId, press.time_stamp() +
                                 base::TimeDelta::FromMilliseconds(50));
      release.set_radius_x(20);
      release.set_radius_y(13);
 
      root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&release);
      EXPECT_TRUE(delegate->tap());
      EXPECT_FALSE(delegate->tap_down());
+     EXPECT_FALSE(delegate->tap_cancel());
      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(40, delegate->bounding_box().width());
      EXPECT_EQ(40, delegate->bounding_box().height());
      EXPECT_EQ(366, actual_point.x());
      EXPECT_EQ(290, actual_point.y());
   }
 
   // Test with a single ET_TOUCH_MOVED event.
   {
      delegate->Reset();
      ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(46, 205),
                               kTouchId, GetTime());
      press.set_radius_x(6);
      press.set_radius_y(10);
      root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&press);
      EXPECT_FALSE(delegate->tap());
      EXPECT_TRUE(delegate->tap_down());
+     EXPECT_FALSE(delegate->tap_cancel());
      EXPECT_TRUE(delegate->begin());
+     EXPECT_FALSE(delegate->tap_cancel());
      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();
      ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(49, 204),
                              kTouchId, press.time_stamp() +
                              base::TimeDelta::FromMilliseconds(50));
      move.set_radius_x(8);
      move.set_radius_y(12);
      root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&move);
      EXPECT_FALSE(delegate->tap());
      EXPECT_FALSE(delegate->tap_down());
+     EXPECT_FALSE(delegate->tap_cancel());
      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();
      ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(49, 204),
                                 kTouchId, press.time_stamp() +
                                 base::TimeDelta::FromMilliseconds(50));
      release.set_radius_x(4);
      release.set_radius_y(8);
 
      root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&release);
      EXPECT_TRUE(delegate->tap());
      EXPECT_FALSE(delegate->tap_down());
+     EXPECT_FALSE(delegate->tap_cancel());
      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(25, delegate->bounding_box().width());
      EXPECT_EQ(24, delegate->bounding_box().height());
      EXPECT_EQ(48, actual_point.x());
      EXPECT_EQ(203, actual_point.y());
   }
 
   // Test with a few ET_TOUCH_MOVED events.
   {
      delegate->Reset();
      ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(400, 150),
                               kTouchId, GetTime());
      press.set_radius_x(7);
      press.set_radius_y(10);
      root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&press);
      EXPECT_FALSE(delegate->tap());
      EXPECT_TRUE(delegate->tap_down());
+     EXPECT_FALSE(delegate->tap_cancel());
      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();
      ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(397, 151),
                              kTouchId, press.time_stamp() +
                              base::TimeDelta::FromMilliseconds(50));
      move.set_radius_x(13);
      move.set_radius_y(12);
      root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&move);
      EXPECT_FALSE(delegate->tap());
      EXPECT_FALSE(delegate->tap_down());
+     EXPECT_FALSE(delegate->tap_cancel());
      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();
      ui::TouchEvent move1(ui::ET_TOUCH_MOVED, gfx::Point(397, 149),
                               kTouchId, move.time_stamp() +
                               base::TimeDelta::FromMilliseconds(50));
      move1.set_radius_x(16);
      move1.set_radius_y(16);
      root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&move1);
      EXPECT_FALSE(delegate->tap());
      EXPECT_FALSE(delegate->tap_down());
+     EXPECT_FALSE(delegate->tap_cancel());
      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();
      ui::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()->AsRootWindowHostDelegate()->OnHostTouchEvent(&move2);
      EXPECT_FALSE(delegate->tap());
      EXPECT_FALSE(delegate->tap_down());
+     EXPECT_FALSE(delegate->tap_cancel());
      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();
      ui::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()->AsRootWindowHostDelegate()->OnHostTouchEvent(&release);
      EXPECT_TRUE(delegate->tap());
      EXPECT_FALSE(delegate->tap_down());
+     EXPECT_FALSE(delegate->tap_cancel());
      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(33, delegate->bounding_box().width());
@@ skipping 11 matching lines @@
   const int kWindowHeight = 45;
   const int kTouchId = 5;
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, NULL));
 
   delegate->Reset();
   ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
                            kTouchId, GetTime());
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&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_2_EVENTS(delegate->events(),
+                  ui::ET_GESTURE_BEGIN,
+                  ui::ET_GESTURE_TAP_DOWN);
 
   // 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_3_EVENTS(delegate->events(),
+                  ui::ET_GESTURE_TAP_CANCEL,
+                  ui::ET_GESTURE_SCROLL_BEGIN,
+                  ui::ET_GESTURE_SCROLL_UPDATE);
   EXPECT_EQ(29, delegate->scroll_x());
   EXPECT_EQ(29, delegate->scroll_y());
   EXPECT_EQ(0, delegate->scroll_velocity_x());
   EXPECT_EQ(0, delegate->scroll_velocity_y());
   EXPECT_EQ(gfx::Point(1, 1).ToString(),
             delegate->scroll_begin_position().ToString());
 
   // When scrolling with a single finger, the bounding box of the gesture should
   // be empty, since it's a single point and the radius for testing is zero.
   EXPECT_TRUE(delegate->bounding_box().IsEmpty());
 
   // 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_1_EVENT(delegate->events(), ui::ET_GESTURE_SCROLL_UPDATE);
   EXPECT_EQ(-20, delegate->scroll_x());
   EXPECT_EQ(-19, delegate->scroll_y());
   EXPECT_TRUE(delegate->bounding_box().IsEmpty());
 
   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_1_EVENT(delegate->events(), ui::ET_GESTURE_SCROLL_UPDATE);
   EXPECT_EQ(30, delegate->scroll_x());
   EXPECT_EQ(4, delegate->scroll_y());
   EXPECT_TRUE(delegate->bounding_box().IsEmpty());
 
   // Release the touch. This should end the scroll.
   delegate->Reset();
   ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
                              kTouchId, press.time_stamp() +
                              base::TimeDelta::FromMilliseconds(50));
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&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());
+  EXPECT_2_EVENTS(delegate->events(),
+                  ui::ET_GESTURE_SCROLL_END,
+                  ui::ET_GESTURE_END);
   EXPECT_TRUE(delegate->bounding_box().IsEmpty());
 }
 
 // Check that the bounding box during a scroll event is correct.
 TEST_F(GestureRecognizerTest, GestureEventScrollBoundingBox) {
   for (int radius = 1; radius <= 10; ++radius) {
     ui::GestureConfiguration::set_default_radius(radius);
     scoped_ptr<GestureEventConsumeDelegate> delegate(
         new GestureEventConsumeDelegate());
     const int kWindowWidth = 123;
@@ skipping 180 matching lines @@
       static_cast<TimerTestGestureSequence*>(
           gesture_recognizer->GetGestureSequenceForTesting(window.get()));
 
   root_window()->SetGestureRecognizerForTesting(gesture_recognizer);
 
   ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
                             kTouchId, GetTime());
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&press1);
   EXPECT_TRUE(delegate->tap_down());
   EXPECT_TRUE(delegate->begin());
+  EXPECT_FALSE(delegate->tap_cancel());
 
   // 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());
+  EXPECT_FALSE(delegate->tap_cancel());
 
   delegate->Reset();
   ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
                               kTouchId, GetTime());
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&release1);
   EXPECT_FALSE(delegate->long_press());
+
+  // Note the tap down isn't cancelled until the release
+  EXPECT_TRUE(delegate->tap_cancel());
 }
 
 // Check that scrolling cancels a long press
 TEST_F(GestureRecognizerTest, GestureEventLongPressCancelledByScroll) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   const int kWindowWidth = 123;
   const int kWindowHeight = 45;
   const int kTouchId = 6;
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
@@ skipping 10 matching lines @@
 
   root_window()->SetGestureRecognizerForTesting(gesture_recognizer);
 
   ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
                             kTouchId, GetTime());
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&press1);
   EXPECT_TRUE(delegate->tap_down());
 
   // We haven't pressed long enough for a long press to occur
   EXPECT_FALSE(delegate->long_press());
+  EXPECT_FALSE(delegate->tap_cancel());
 
   // Scroll around, to cancel the long press
   SendScrollEvent(root_window(), 130, 230, kTouchId, delegate.get());
   // Wait until the timer runs out
   gesture_sequence->ForceTimeout();
   EXPECT_FALSE(delegate->long_press());
+  EXPECT_TRUE(delegate->tap_cancel());
 
   delegate->Reset();
   ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
                               kTouchId, GetTime());
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&release1);
   EXPECT_FALSE(delegate->long_press());
+  EXPECT_FALSE(delegate->tap_cancel());
 }
 
 // Check that second tap cancels a long press
 TEST_F(GestureRecognizerTest, GestureEventLongPressCancelledBySecondTap) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   const int kWindowWidth = 300;
   const int kWindowHeight = 400;
   const int kTouchId1 = 8;
   const int kTouchId2 = 2;
@@ skipping 18 matching lines @@
 
   // 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();
   ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(10, 10),
                             kTouchId2, GetTime());
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&press2);
   EXPECT_FALSE(delegate->tap_down());  // no touch down for second tap.
+  EXPECT_TRUE(delegate->tap_cancel());
   EXPECT_TRUE(delegate->begin());
 
   // Wait until the timer runs out
   gesture_sequence->ForceTimeout();
 
   // No long press occurred
   EXPECT_FALSE(delegate->long_press());
 
   delegate->Reset();
   ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
                               kTouchId1, GetTime());
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&release1);
   EXPECT_FALSE(delegate->long_press());
   EXPECT_TRUE(delegate->two_finger_tap());
+  EXPECT_FALSE(delegate->tap_cancel());
 }
 
 // Check that horizontal scroll gestures cause scrolls on horizontal rails.
 // Also tests that horizontal rails can be broken.
 TEST_F(GestureRecognizerTest, GestureEventHorizontalRailScroll) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   const int kTouchId = 7;
   gfx::Rect bounds(0, 0, 1000, 1000);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
@@ skipping 93 matching lines @@
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, NULL));
 
   delegate->Reset();
   ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
                            kTouchId, GetTime());
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&press);
   EXPECT_FALSE(delegate->tap());
   EXPECT_TRUE(delegate->tap_down());
+  EXPECT_FALSE(delegate->tap_cancel());
   EXPECT_FALSE(delegate->double_tap());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
 
   // Make sure there is enough delay before the touch is released so that it is
   // recognized as a tap.
   delegate->Reset();
   ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
                              kTouchId, press.time_stamp() +
                              base::TimeDelta::FromMilliseconds(50));
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&release);
   EXPECT_TRUE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
+  EXPECT_FALSE(delegate->tap_cancel());
   EXPECT_FALSE(delegate->double_tap());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
 
   // Now, do a scroll gesture. Delay it sufficiently so that it doesn't trigger
   // a double-tap.
   delegate->Reset();
   ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
                             kTouchId, release.time_stamp() +
                     base::TimeDelta::FromMilliseconds(1000));
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&press1);
   EXPECT_FALSE(delegate->tap());
   EXPECT_TRUE(delegate->tap_down());
+  EXPECT_FALSE(delegate->tap_cancel());
   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.
   delegate->Reset();
   ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(130, 230),
                           kTouchId, GetTime());
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&move);
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
+  EXPECT_TRUE(delegate->tap_cancel());
   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());
 
   // Move some more to generate a few more scroll updates.
   delegate->Reset();
   ui::TouchEvent move1(ui::ET_TOUCH_MOVED, gfx::Point(110, 211),
                            kTouchId, GetTime());
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&move1);
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
+  EXPECT_FALSE(delegate->tap_cancel());
   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());
 
   delegate->Reset();
   ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::Point(140, 215),
                            kTouchId, GetTime());
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&move2);
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
+  EXPECT_FALSE(delegate->tap_cancel());
   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();
   ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
                               kTouchId, GetTime());
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&release1);
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
+  EXPECT_FALSE(delegate->tap_cancel());
   EXPECT_FALSE(delegate->double_tap());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_TRUE(delegate->scroll_end());
 }
 
 TEST_F(GestureRecognizerTest, AsynchronousGestureRecognition) {
   scoped_ptr<QueueTouchEventDelegate> queued_delegate(
       new QueueTouchEventDelegate(root_window()));
   const int kWindowWidth = 123;
   const int kWindowHeight = 45;
   const int kTouchId1 = 6;
   const int kTouchId2 = 4;
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> queue(CreateTestWindowWithDelegate(
       queued_delegate.get(), -1234, bounds, NULL));
 
   queued_delegate->set_window(queue.get());
 
   // Touch down on the window. This should not generate any gesture event.
   queued_delegate->Reset();
   ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
                            kTouchId1, GetTime());
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&press);
   EXPECT_FALSE(queued_delegate->tap());
   EXPECT_FALSE(queued_delegate->tap_down());
+  EXPECT_FALSE(queued_delegate->tap_cancel());
   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();
   ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
                              kTouchId1, press.time_stamp() +
                                  base::TimeDelta::FromMilliseconds(50));
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&release);
   EXPECT_FALSE(queued_delegate->tap());
   EXPECT_FALSE(queued_delegate->tap_down());
+  EXPECT_FALSE(queued_delegate->tap_cancel());
   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();
   ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(10, 20),
                             kTouchId2, GetTime());
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&press2);
   EXPECT_FALSE(delegate->tap());
   EXPECT_TRUE(delegate->tap_down());
+  EXPECT_FALSE(delegate->tap_cancel());
   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());
 
   ui::TouchEvent release2(ui::ET_TOUCH_RELEASED, gfx::Point(10, 20),
                               kTouchId2, GetTime());
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&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->tap_cancel());
   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->tap_cancel());
   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();
   ui::TouchEvent press3(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
                             kTouchId1, GetTime());
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&press3);
   EXPECT_FALSE(queued_delegate->tap());
   EXPECT_FALSE(queued_delegate->tap_down());
+  EXPECT_FALSE(queued_delegate->tap_cancel());
   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();
   ui::TouchEvent press4(ui::ET_TOUCH_PRESSED, gfx::Point(103, 203),
                             kTouchId2, GetTime());
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&press4);
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
+  EXPECT_FALSE(delegate->tap_cancel());
   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->tap_cancel());
   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();
   ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(103 + x_move, 203),
                           kTouchId2, GetTime());
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&move);
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
+  EXPECT_FALSE(delegate->tap_cancel());
   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->tap_cancel());
   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->tap_cancel());
   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->tap_cancel());
   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->tap_cancel());
   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.
 TEST_F(GestureRecognizerTest, GestureEventPinchFromScroll) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   const int kWindowWidth = 300;
   const int kWindowHeight = 400;
   const int kTouchId1 = 5;
   const int kTouchId2 = 3;
   gfx::Rect bounds(5, 5, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, NULL));
 
   aura::RootWindow* root = root_window();
 
   delegate->Reset();
   ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
                            kTouchId1, GetTime());
   root->AsRootWindowHostDelegate()->OnHostTouchEvent(&press);
-  EXPECT_FALSE(delegate->tap());
-  EXPECT_TRUE(delegate->tap_down());
-  EXPECT_FALSE(delegate->double_tap());
-  EXPECT_FALSE(delegate->scroll_begin());
-  EXPECT_FALSE(delegate->scroll_update());
-  EXPECT_FALSE(delegate->scroll_end());
+  EXPECT_2_EVENTS(delegate->events(),
+                  ui::ET_GESTURE_BEGIN,
+                  ui::ET_GESTURE_TAP_DOWN);
 
   // Move the touch-point enough so that it is considered as a scroll. This
   // should generate both SCROLL_BEGIN and SCROLL_UPDATE gestures.
   delegate->Reset();
   ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(130, 301),
                           kTouchId1, GetTime());
   root->AsRootWindowHostDelegate()->OnHostTouchEvent(&move);
-  EXPECT_FALSE(delegate->tap());
-  EXPECT_FALSE(delegate->tap_down());
-  EXPECT_FALSE(delegate->double_tap());
-  EXPECT_TRUE(delegate->scroll_begin());
-  EXPECT_TRUE(delegate->scroll_update());
-  EXPECT_FALSE(delegate->scroll_end());
+  EXPECT_3_EVENTS(delegate->events(),
+                  ui::ET_GESTURE_TAP_CANCEL,
+                  ui::ET_GESTURE_SCROLL_BEGIN,
+                  ui::ET_GESTURE_SCROLL_UPDATE);
 
   // Press the second finger. It should cause pinch-begin. Note that we will not
   // transition to two finger tap here because the touch points are far enough.
   delegate->Reset();
   ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(10, 10),
                             kTouchId2, GetTime());
   root->AsRootWindowHostDelegate()->OnHostTouchEvent(&press2);
-  EXPECT_FALSE(delegate->tap());
-  EXPECT_FALSE(delegate->tap_down());  // no touch down for second tap.
-  EXPECT_FALSE(delegate->double_tap());
-  EXPECT_FALSE(delegate->scroll_begin());
-  EXPECT_FALSE(delegate->scroll_update());
-  EXPECT_FALSE(delegate->scroll_end());
-  EXPECT_TRUE(delegate->pinch_begin());
+  EXPECT_2_EVENTS(delegate->events(),
+                 ui::ET_GESTURE_BEGIN,
+                 ui::ET_GESTURE_PINCH_BEGIN);
   EXPECT_EQ(gfx::Rect(10, 10, 120, 291).ToString(),
             delegate->bounding_box().ToString());
 
   // Move the first finger.
   delegate->Reset();
   ui::TouchEvent move3(ui::ET_TOUCH_MOVED, gfx::Point(95, 201),
                            kTouchId1, GetTime());
   root->AsRootWindowHostDelegate()->OnHostTouchEvent(&move3);
-  EXPECT_FALSE(delegate->tap());
-  EXPECT_FALSE(delegate->tap_down());
-  EXPECT_FALSE(delegate->double_tap());
-  EXPECT_FALSE(delegate->scroll_begin());
-  EXPECT_FALSE(delegate->scroll_update());
-  EXPECT_FALSE(delegate->scroll_end());
-  EXPECT_FALSE(delegate->pinch_begin());
-  EXPECT_TRUE(delegate->pinch_update());
+  EXPECT_1_EVENT(delegate->events(), ui::ET_GESTURE_PINCH_UPDATE);
   EXPECT_EQ(gfx::Rect(10, 10, 85, 191).ToString(),
             delegate->bounding_box().ToString());
 
   // Now move the second finger.
   delegate->Reset();
   ui::TouchEvent move4(ui::ET_TOUCH_MOVED, gfx::Point(55, 15),
                            kTouchId2, GetTime());
   root->AsRootWindowHostDelegate()->OnHostTouchEvent(&move4);
-  EXPECT_FALSE(delegate->tap());
-  EXPECT_FALSE(delegate->tap_down());
-  EXPECT_FALSE(delegate->double_tap());
-  EXPECT_FALSE(delegate->scroll_begin());
-  EXPECT_FALSE(delegate->scroll_update());
-  EXPECT_FALSE(delegate->scroll_end());
-  EXPECT_FALSE(delegate->pinch_begin());
-  EXPECT_TRUE(delegate->pinch_update());
+  EXPECT_1_EVENT(delegate->events(), ui::ET_GESTURE_PINCH_UPDATE);
   EXPECT_EQ(gfx::Rect(55, 15, 40, 186).ToString(),
             delegate->bounding_box().ToString());
 
   // Release the first finger. This should end pinch.
   delegate->Reset();
   ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
                              kTouchId1, press.time_stamp() +
                              base::TimeDelta::FromMilliseconds(50));
   root->AsRootWindowHostDelegate()->OnHostTouchEvent(&release);
-  EXPECT_FALSE(delegate->tap());
-  EXPECT_FALSE(delegate->tap_down());
-  EXPECT_FALSE(delegate->double_tap());
-  EXPECT_FALSE(delegate->scroll_begin());
-  EXPECT_FALSE(delegate->scroll_update());
-  EXPECT_FALSE(delegate->scroll_end());
-  EXPECT_TRUE(delegate->pinch_end());
+  EXPECT_2_EVENTS(delegate->events(),
+                 ui::ET_GESTURE_PINCH_END,
+                 ui::ET_GESTURE_END);
   EXPECT_EQ(gfx::Rect(55, 15, 46, 186).ToString(),
             delegate->bounding_box().ToString());
 
   // Move the second finger. This should still generate a scroll.
   delegate->Reset();
   ui::TouchEvent move5(ui::ET_TOUCH_MOVED, gfx::Point(25, 10),
                            kTouchId2, GetTime());
   root->AsRootWindowHostDelegate()->OnHostTouchEvent(&move5);
-  EXPECT_FALSE(delegate->tap());
-  EXPECT_FALSE(delegate->tap_down());
-  EXPECT_FALSE(delegate->double_tap());
-  EXPECT_FALSE(delegate->scroll_begin());
-  EXPECT_TRUE(delegate->scroll_update());
-  EXPECT_FALSE(delegate->scroll_end());
-  EXPECT_FALSE(delegate->pinch_begin());
-  EXPECT_FALSE(delegate->pinch_update());
+  EXPECT_1_EVENT(delegate->events(), ui::ET_GESTURE_SCROLL_UPDATE);
   EXPECT_TRUE(delegate->bounding_box().IsEmpty());
 }
 
 TEST_F(GestureRecognizerTest, GestureEventPinchFromScrollFromPinch) {
 scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   const int kWindowWidth = 300;
   const int kWindowHeight = 400;
   const int kTouchId1 = 5;
   const int kTouchId2 = 3;
@@ skipping 51 matching lines @@
   gfx::Rect bounds(5, 5, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, NULL));
 
   aura::RootWindow* root = root_window();
 
   delegate->Reset();
   ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 301),
                            kTouchId1, GetTime());
   root->AsRootWindowHostDelegate()->OnHostTouchEvent(&press);
-  EXPECT_FALSE(delegate->tap());
-  EXPECT_TRUE(delegate->tap_down());
-  EXPECT_FALSE(delegate->double_tap());
-  EXPECT_FALSE(delegate->scroll_begin());
-  EXPECT_FALSE(delegate->scroll_update());
-  EXPECT_FALSE(delegate->scroll_end());
+  EXPECT_2_EVENTS(delegate->events(),
+                  ui::ET_GESTURE_BEGIN,
+                  ui::ET_GESTURE_TAP_DOWN);
   EXPECT_TRUE(delegate->bounding_box().IsEmpty());
 
   // Press the second finger far enough to break two finger tap. It should
   // instead cause a scroll-begin and pinch-begin.
   delegate->Reset();
   ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(10, 10),
                             kTouchId2, GetTime());
   root->AsRootWindowHostDelegate()->OnHostTouchEvent(&press2);
-  EXPECT_FALSE(delegate->tap());
-  EXPECT_FALSE(delegate->tap_down());  // no touch down for second tap.
-  EXPECT_FALSE(delegate->double_tap());
-  EXPECT_TRUE(delegate->scroll_begin());
-  EXPECT_FALSE(delegate->scroll_update());
-  EXPECT_FALSE(delegate->scroll_end());
-  EXPECT_TRUE(delegate->pinch_begin());
+  EXPECT_4_EVENTS(delegate->events(),
+                  ui::ET_GESTURE_TAP_CANCEL,
+                  ui::ET_GESTURE_BEGIN,
+                  ui::ET_GESTURE_PINCH_BEGIN,
+                  ui::ET_GESTURE_SCROLL_BEGIN);
   EXPECT_EQ(gfx::Rect(10, 10, 91, 291).ToString(),
             delegate->bounding_box().ToString());
 
   // Move the first finger.
   delegate->Reset();
   ui::TouchEvent move3(ui::ET_TOUCH_MOVED, gfx::Point(65, 201),
                            kTouchId1, GetTime());
   root->AsRootWindowHostDelegate()->OnHostTouchEvent(&move3);
-  EXPECT_FALSE(delegate->tap());
-  EXPECT_FALSE(delegate->tap_down());
-  EXPECT_FALSE(delegate->double_tap());
-  EXPECT_FALSE(delegate->scroll_begin());
-  EXPECT_FALSE(delegate->scroll_update());
-  EXPECT_FALSE(delegate->scroll_end());
-  EXPECT_FALSE(delegate->pinch_begin());
-  EXPECT_TRUE(delegate->pinch_update());
+  EXPECT_1_EVENT(delegate->events(), ui::ET_GESTURE_PINCH_UPDATE);
   EXPECT_EQ(gfx::Rect(10, 10, 55, 191).ToString(),
             delegate->bounding_box().ToString());
 
   // Now move the second finger.
   delegate->Reset();
   ui::TouchEvent move4(ui::ET_TOUCH_MOVED, gfx::Point(55, 15),
                            kTouchId2, GetTime());
   root->AsRootWindowHostDelegate()->OnHostTouchEvent(&move4);
-  EXPECT_FALSE(delegate->tap());
-  EXPECT_FALSE(delegate->tap_down());
-  EXPECT_FALSE(delegate->double_tap());
-  EXPECT_FALSE(delegate->scroll_begin());
-  EXPECT_FALSE(delegate->scroll_update());
-  EXPECT_FALSE(delegate->scroll_end());
-  EXPECT_FALSE(delegate->pinch_begin());
-  EXPECT_TRUE(delegate->pinch_update());
+  EXPECT_1_EVENT(delegate->events(), ui::ET_GESTURE_PINCH_UPDATE);
   EXPECT_EQ(gfx::Rect(55, 15, 10, 186).ToString(),
             delegate->bounding_box().ToString());
 
   // Release the first finger. This should end pinch.
   delegate->Reset();
   ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
                              kTouchId1, press.time_stamp() +
                              base::TimeDelta::FromMilliseconds(50));
   root->AsRootWindowHostDelegate()->OnHostTouchEvent(&release);
-  EXPECT_FALSE(delegate->tap());
-  EXPECT_FALSE(delegate->tap_down());
-  EXPECT_FALSE(delegate->double_tap());
-  EXPECT_FALSE(delegate->scroll_begin());
-  EXPECT_FALSE(delegate->scroll_update());
-  EXPECT_FALSE(delegate->scroll_end());
-  EXPECT_TRUE(delegate->pinch_end());
+  EXPECT_2_EVENTS(delegate->events(),
+                  ui::ET_GESTURE_PINCH_END,
+                  ui::ET_GESTURE_END);
   EXPECT_EQ(gfx::Rect(55, 15, 46, 186).ToString(),
             delegate->bounding_box().ToString());
 
   // Move the second finger. This should still generate a scroll.
   delegate->Reset();
   ui::TouchEvent move5(ui::ET_TOUCH_MOVED, gfx::Point(25, 10),
                            kTouchId2, GetTime());
   root->AsRootWindowHostDelegate()->OnHostTouchEvent(&move5);
-  EXPECT_FALSE(delegate->tap());
-  EXPECT_FALSE(delegate->tap_down());
-  EXPECT_FALSE(delegate->double_tap());
-  EXPECT_FALSE(delegate->scroll_begin());
-  EXPECT_TRUE(delegate->scroll_update());
-  EXPECT_FALSE(delegate->scroll_end());
-  EXPECT_FALSE(delegate->pinch_begin());
-  EXPECT_FALSE(delegate->pinch_update());
+  EXPECT_1_EVENT(delegate->events(), ui::ET_GESTURE_SCROLL_UPDATE);
   EXPECT_TRUE(delegate->bounding_box().IsEmpty());
 }
 
 TEST_F(GestureRecognizerTest, GestureEventIgnoresDisconnectedEvents) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
 
   ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
                               6, GetTime());
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&release1);
@@ skipping 134 matching lines @@
                              kTouchId, press.time_stamp() +
                              base::TimeDelta::FromMilliseconds(50));
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&release);
 
   delegate->Reset();
   delegate->ReceivedAck();
   EXPECT_TRUE(delegate->tap_down());
   delegate->Reset();
   delegate->ReceivedAckPreventDefaulted();
   EXPECT_FALSE(delegate->tap());
+  EXPECT_TRUE(delegate->tap_cancel());
 }
 
 TEST_F(GestureRecognizerTest, PinchScrollWithPreventDefaultedRelease) {
   scoped_ptr<QueueTouchEventDelegate> delegate(
       new QueueTouchEventDelegate(root_window()));
   const int kTouchId1 = 7;
   const int kTouchId2 = 5;
   gfx::Rect bounds(10, 20, 100, 100);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, NULL));
@@ skipping 11 matching lines @@
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&release);
   delegate->Reset();
 
   // Ack the press event.
   delegate->ReceivedAck();
   EXPECT_TRUE(delegate->tap_down());
   delegate->Reset();
 
   // Ack the move event.
   delegate->ReceivedAck();
+  EXPECT_TRUE(delegate->tap_cancel());
   EXPECT_TRUE(delegate->scroll_begin());
   delegate->Reset();
 
   // Ack the release event. Although the release event has been processed, it
   // should still generate a scroll-end event.
   delegate->ReceivedAckPreventDefaulted();
   EXPECT_TRUE(delegate->scroll_end());
 
   ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(55, 25), kTouchId2,
       GetTime());
@@ skipping 58 matching lines @@
   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->end());
+  EXPECT_TRUE(delegate->tap_cancel());
 }
 
 TEST_F(GestureRecognizerTest, PressDoesNotCrash) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   TestGestureRecognizer* gesture_recognizer =
       new TestGestureRecognizer(root_window());
   root_window()->SetGestureRecognizerForTesting(gesture_recognizer);
 
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, gfx::Rect(10, 10, 300, 300), NULL));
 
   ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(45, 45), 7, GetTime());
   press.set_radius_x(40);
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&press);
   EXPECT_TRUE(delegate->tap_down());
   EXPECT_EQ(gfx::Rect(5, 5, 80, 80).ToString(),
             delegate->bounding_box().ToString());
   delegate->Reset();
 
   ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(55, 45), 7, GetTime());
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&press2);
 
   // This new press should not generate a tap-down.
   EXPECT_FALSE(delegate->begin());
   EXPECT_FALSE(delegate->tap_down());
+  EXPECT_FALSE(delegate->tap_cancel());
   EXPECT_FALSE(delegate->scroll_begin());
 }
 
 // Tests that if a consumer has touch-events queued, then no touch-event gets
 // processed synchronously until all the queued evets are processed.
 TEST_F(GestureRecognizerTest, SyncTouchEventWithQueuedTouchEvents) {
   scoped_ptr<QueueTouchEventDelegate> queued_delegate(
       new QueueTouchEventDelegate(root_window()));
   const int kWindowWidth = 123;
   const int kWindowHeight = 45;
@@ skipping 24 matching lines @@
 
   // Process the two queued events.
   queued_delegate->ReceivedAck();
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(queued_delegate->begin());
   EXPECT_TRUE(queued_delegate->tap_down());
   queued_delegate->Reset();
 
   queued_delegate->ReceivedAck();
   RunAllPendingInMessageLoop();
+  EXPECT_TRUE(queued_delegate->tap_cancel());
   EXPECT_TRUE(queued_delegate->scroll_begin());
   EXPECT_TRUE(queued_delegate->scroll_update());
   EXPECT_TRUE(queued_delegate->scroll_end());
   EXPECT_TRUE(queued_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);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, NULL));
 
   delegate->Reset();
   ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
                             kTouchId1, GetTime());
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&press1);
   EXPECT_FALSE(delegate->tap());
   EXPECT_TRUE(delegate->tap_down());
+  EXPECT_FALSE(delegate->tap_cancel());
   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());
   EXPECT_FALSE(delegate->two_finger_tap());
 
   delegate->Reset();
   ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(130, 201),
                             kTouchId2, GetTime());
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&press2);
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());  // no touch down for second tap.
+  EXPECT_TRUE(delegate->tap_cancel());
   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());
   EXPECT_FALSE(delegate->two_finger_tap());
 
   // Little bit of touch move should not affect our state.
   delegate->Reset();
   ui::TouchEvent move1(ui::ET_TOUCH_MOVED, gfx::Point(102, 202),
                            kTouchId1, GetTime());
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&move1);
   ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::Point(131, 202),
                            kTouchId2, GetTime());
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&move2);
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
+  EXPECT_FALSE(delegate->tap_cancel());
   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());
   EXPECT_FALSE(delegate->two_finger_tap());
 
   // Make sure there is enough delay before the touch is released so that it is
   // recognized as a tap.
   delegate->Reset();
   ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
                               kTouchId1, press1.time_stamp() +
                               base::TimeDelta::FromMilliseconds(50));
 
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&release1);
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
+  EXPECT_FALSE(delegate->tap_cancel());
   EXPECT_FALSE(delegate->double_tap());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
   EXPECT_TRUE(delegate->two_finger_tap());
 
   // Lift second finger.
   // Make sure there is enough delay before the touch is released so that it is
   // recognized as a tap.
   delegate->Reset();
   ui::TouchEvent release2(ui::ET_TOUCH_RELEASED, gfx::Point(130, 201),
                               kTouchId2, press2.time_stamp() +
                                   base::TimeDelta::FromMilliseconds(50));
 
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&release2);
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
+  EXPECT_FALSE(delegate->tap_cancel());
   EXPECT_FALSE(delegate->double_tap());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_TRUE(delegate->scroll_end());
   EXPECT_FALSE(delegate->two_finger_tap());
 }
 
 TEST_F(GestureRecognizerTest, TwoFingerTapExpired) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
@@ skipping 234 matching lines @@
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, NULL));
 
   delegate->Reset();
   ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
                             kTouchId1, GetTime());
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&press1);
   EXPECT_FALSE(delegate->tap());
   EXPECT_TRUE(delegate->tap_down());
+  EXPECT_FALSE(delegate->tap_cancel());
   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());
   EXPECT_FALSE(delegate->two_finger_tap());
 
   delegate->Reset();
   ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(430, 201),
                             kTouchId2, GetTime());
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&press2);
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());  // no touch down for second tap.
+  EXPECT_TRUE(delegate->tap_cancel());
   EXPECT_FALSE(delegate->double_tap());
   EXPECT_TRUE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
   EXPECT_FALSE(delegate->long_press());
   EXPECT_FALSE(delegate->two_finger_tap());
   EXPECT_TRUE(delegate->pinch_begin());
 }
 
 // Verifies if a window is the target of multiple touch-ids and we hide the
@@ skipping 86 matching lines @@
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, NULL));
 
   delegate->Reset();
   ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
                            kTouchId, GetTime());
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&press);
   EXPECT_FALSE(delegate->tap());
   EXPECT_TRUE(delegate->tap_down());
+  EXPECT_FALSE(delegate->tap_cancel());
   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 would normally be considered a
   // scroll. But since the touch-moves will be consumed, the scroll should not
-  // start.
+  // start.  We should, however, get the TAP_CANCEL event now (since it's now
+  // impossible for the gesture to become a tap).
   SendScrollEvent(root_window(), 130, 230, kTouchId, delegate.get());
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
+  // TODO(rbyers): Really we should get the TapCancel here instead of below,
+  // but this is a symptom of a larger issue: crbug.com/146397.
+  EXPECT_FALSE(delegate->tap_cancel());
   EXPECT_FALSE(delegate->begin());
   EXPECT_FALSE(delegate->double_tap());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
 
   // Now, stop consuming touch-move events, and move the touch-point again.
   delegate->set_consume_touch_move(false);
   SendScrollEvent(root_window(), 159, 259, kTouchId, delegate.get());
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
+  EXPECT_TRUE(delegate->tap_cancel());
   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());
 
   // Start consuming touch-move events again. However, since gesture-scroll has
   // already started, the touch-move events should still result in scroll-update
   // gesturs.
   delegate->set_consume_touch_move(true);
 
   // 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->tap_cancel());
   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(-49, delegate->scroll_x());
   EXPECT_EQ(-48, delegate->scroll_y());
 
   SendScrollEvent(root_window(), 140, 215, kTouchId, delegate.get());
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
+  EXPECT_FALSE(delegate->tap_cancel());
   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();
   ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
                              kTouchId, press.time_stamp() +
                                  base::TimeDelta::FromMilliseconds(50));
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&release);
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
+  EXPECT_FALSE(delegate->tap_cancel());
   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) {
@@ skipping 21 matching lines @@
                             kTouchId, release1.time_stamp() +
                                 base::TimeDelta::FromMilliseconds(200));
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&press2);
   ui::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_FALSE(delegate->tap_cancel());
   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());
 }
 
@@ skipping 23 matching lines @@
                             kTouchId, release1.time_stamp() +
                                 base::TimeDelta::FromMilliseconds(200));
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&press2);
   ui::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_FALSE(delegate->tap_cancel());
   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());
 }
 
@@ skipping 24 matching lines @@
                             kTouchId, release1.time_stamp() +
                                 base::TimeDelta::FromMilliseconds(2000));
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&press2);
   ui::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_FALSE(delegate->tap_cancel());
   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());
 }
 
@@ skipping 35 matching lines @@
 
   delegate->Reset();
 
   // The position doesn't move, but the radius changes.
   ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::Point(101, 201), kTouchId,
       press2.time_stamp() + base::TimeDelta::FromMilliseconds(40));
   move2.set_radius_x(50);
   move2.set_radius_y(60);
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&move2);
   EXPECT_FALSE(delegate->tap());
+  EXPECT_FALSE(delegate->tap_cancel());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->pinch_update());
 
   delegate->Reset();
 }
 
 }  // namespace test
 }  // namespace aura