Revert 133261 - Gesture Recognition unit tests have too many dependencies.

Most tests in gesture_recognizer_unittest.cc were rewritten to rely solely on GestureSequence.
Several gaps in existing testing were filled, include double tap and touch cancel tests.

The tests now ensure that GestureEvents are returned in the correct order, and consistenly verify
that no unexpected events occurred. 

Tests on the GestureSequence ensure that the sequence of states passed through is as expected.

BUG=120713
TEST=GestureRecognizerTest.*, GestureSequenceTest.*


Review URL: http://codereview.chromium.org/9873033

TBR=tdresser@chromium.org
Review URL: https://chromiumcodereview.appspot.com/10166017

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@133281 0039d316-1c4b-4281-b951-d872f2087c98

11 files changed, 1381 insertions, 1220 deletions

diff --git a/ui/aura/gestures/gesture_recognizer_unittest.cc b/ui/aura/gestures/gesture_recognizer_unittest.cc
index dd63e8d..20ff390 100644
--- a/ui/aura/gestures/gesture_recognizer_unittest.cc
+++ b/ui/aura/gestures/gesture_recognizer_unittest.cc
@@ -2,6 +2,8 @@
 // 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/timer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/aura/event.h"
 #include "ui/aura/root_window.h"
@@ -24,47 +26,148 @@ namespace {
 // A delegate that keeps track of gesture events.
 class GestureEventConsumeDelegate : public TestWindowDelegate {
  public:
-  GestureEventConsumeDelegate() {
-    event_types_.reset(new std::vector<ui::EventType>());
-    Reset();
+  GestureEventConsumeDelegate()
+      : tap_(false),
+        tap_down_(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),
+        three_finger_swipe_(false),
+        scroll_x_(0),
+        scroll_y_(0),
+        velocity_x_(0),
+        velocity_y_(0) {
   }
 
   virtual ~GestureEventConsumeDelegate() {}
 
-  virtual void Reset() {
-    event_types_->clear();
+  void Reset() {
+    tap_ = false;
+    tap_down_ = 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;
+    three_finger_swipe_ = false;
+
+    scroll_begin_position_.SetPoint(0, 0);
+
+    scroll_x_ = 0;
+    scroll_y_ = 0;
+    velocity_x_ = 0;
+    velocity_y_ = 0;
   }
 
-  bool EventTypesAre(size_t num, ...) {
-    if (num != event_types_->size())
-      return false;
-
-    va_list types;
-    va_start(types, num);
-
-    for (size_t i = 0; i < num; ++i) {
-      if ((*event_types_.get())[i] != va_arg(types, int)) {
-        va_end(types);
-        return false;
-      }
-    }
-    va_end(types);
-    return true;
+  bool tap() const { return tap_; }
+  bool tap_down() const { return tap_down_; }
+  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 three_finger_swipe() const { return three_finger_swipe_; }
+
+  const gfx::Point scroll_begin_position() const {
+    return scroll_begin_position_;
   }
 
-  std::vector<ui::EventType>* event_types() {
-    return event_types_.get();
-  }
+  float scroll_x() const { return scroll_x_; }
+  float scroll_y() const { return scroll_y_; }
+  int touch_id() const { return touch_id_; }
+  float velocity_x() const { return velocity_x_; }
+  float velocity_y() const { return velocity_y_; }
 
   virtual ui::GestureStatus OnGestureEvent(GestureEvent* gesture) OVERRIDE {
-    event_types_->push_back(gesture->type());
+    switch (gesture->type()) {
+      case ui::ET_GESTURE_TAP:
+        tap_ = true;
+        break;
+      case ui::ET_GESTURE_TAP_DOWN:
+        tap_down_ = 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;
+        scroll_x_ += gesture->delta_x();
+        scroll_y_ += gesture->delta_y();
+        break;
+      case ui::ET_GESTURE_SCROLL_END:
+        velocity_x_ = gesture->delta_x();
+        velocity_y_ = gesture->delta_y();
+        scroll_end_ = true;
+        break;
+      case ui::ET_GESTURE_PINCH_BEGIN:
+        pinch_begin_ = true;
+        break;
+      case ui::ET_GESTURE_PINCH_UPDATE:
+        pinch_update_ = true;
+        break;
+      case ui::ET_GESTURE_PINCH_END:
+        pinch_end_ = true;
+        break;
+      case ui::ET_GESTURE_LONG_PRESS:
+        long_press_ = true;
+        touch_id_ = gesture->delta_x();
+        break;
+      case ui::ET_SCROLL_FLING_START:
+        EXPECT_TRUE(scroll_end_);
+        EXPECT_TRUE(velocity_x_ != 0 || velocity_y_ != 0);
+        fling_ = true;
+        break;
+      case ui::ET_GESTURE_THREE_FINGER_SWIPE:
+        three_finger_swipe_ = true;
+        velocity_x_ = gesture->delta_x();
+        velocity_y_ = gesture->delta_y();
+        break;
+      default:
+        NOTREACHED();
+    }
     return ui::GESTURE_STATUS_CONSUMED;
   }
 
- protected:
-  scoped_ptr<std::vector<ui::EventType> > event_types_;
-
  private:
+  bool tap_;
+  bool tap_down_;
+  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 three_finger_swipe_;
+
+  gfx::Point scroll_begin_position_;
+
+  float scroll_x_;
+  float scroll_y_;
+  float velocity_x_;
+  float velocity_y_;
+  int touch_id_;
+
   DISALLOW_COPY_AND_ASSIGN(GestureEventConsumeDelegate);
 };
 
@@ -98,36 +201,97 @@ class QueueTouchEventDelegate : public GestureEventConsumeDelegate {
   DISALLOW_COPY_AND_ASSIGN(QueueTouchEventDelegate);
 };
 
-class GestureEventSynthDelegate : public GestureEventConsumeDelegate {
+// A delegate that ignores gesture events but keeps track of [synthetic] mouse
+// events.
+class GestureEventSynthDelegate : public TestWindowDelegate {
  public:
-  GestureEventSynthDelegate() {
+  GestureEventSynthDelegate()
+      : mouse_enter_(false),
+        mouse_exit_(false),
+        mouse_press_(false),
+        mouse_release_(false),
+        mouse_move_(false),
+        double_click_(false) {
   }
 
-  virtual ui::GestureStatus OnGestureEvent(GestureEvent* gesture) OVERRIDE {
-    return ui::GESTURE_STATUS_UNKNOWN;
+  void Reset() {
+    mouse_enter_ = false;
+    mouse_exit_ = false;
+    mouse_press_ = false;
+    mouse_release_ = false;
+    mouse_move_ = false;
+    double_click_ = false;
   }
 
+  bool mouse_enter() const { return mouse_enter_; }
+  bool mouse_exit() const { return mouse_exit_; }
+  bool mouse_press() const { return mouse_press_; }
+  bool mouse_move() const { return mouse_move_; }
+  bool mouse_release() const { return mouse_release_; }
   bool double_click() const { return double_click_; }
 
   virtual bool OnMouseEvent(MouseEvent* event) OVERRIDE {
-    if (event->type() == ui::ET_MOUSE_PRESSED &&
-       event->flags() & ui::EF_IS_DOUBLE_CLICK)
-      double_click_ = true;
-    event_types_->push_back(event->type());
+    switch (event->type()) {
+      case ui::ET_MOUSE_PRESSED:
+        double_click_ = event->flags() & ui::EF_IS_DOUBLE_CLICK;
+        mouse_press_ = true;
+        break;
+      case ui::ET_MOUSE_RELEASED:
+        mouse_release_ = true;
+        break;
+      case ui::ET_MOUSE_MOVED:
+        mouse_move_ = true;
+        break;
+      case ui::ET_MOUSE_ENTERED:
+        mouse_enter_ = true;
+        break;
+      case ui::ET_MOUSE_EXITED:
+        mouse_exit_ = true;
+        break;
+      default:
+        NOTREACHED();
+    }
     return true;
   }
 
-  virtual void Reset() {
-    GestureEventConsumeDelegate::Reset();
-    double_click_ = false;
-  }
-
  private:
+  bool mouse_enter_;
+  bool mouse_exit_;
+  bool mouse_press_;
+  bool mouse_release_;
+  bool mouse_move_;
   bool double_click_;
 
   DISALLOW_COPY_AND_ASSIGN(GestureEventSynthDelegate);
 };
 
+class TestOneShotGestureSequenceTimer
+    : public base::OneShotTimer<ui::GestureSequence> {
+ public:
+  void ForceTimeout() {
+    if (IsRunning()) {
+      user_task().Run();
+      Stop();
+    }
+  }
+};
+
+class TimerTestGestureSequence : public ui::GestureSequence {
+ public:
+  explicit TimerTestGestureSequence(ui::GestureEventHelper* helper)
+      : ui::GestureSequence(helper) {
+  }
+
+  void ForceTimeout() {
+    static_cast<TestOneShotGestureSequenceTimer*>(
+        long_press_timer())->ForceTimeout();
+  }
+
+  base::OneShotTimer<ui::GestureSequence>* CreateTimer() {
+    return new TestOneShotGestureSequenceTimer();
+  }
+};
+
 class TestGestureRecognizer : public ui::GestureRecognizerImpl {
   public:
   explicit TestGestureRecognizer(RootWindow* root_window)
@@ -139,14 +303,603 @@ class TestGestureRecognizer : public ui::GestureRecognizerImpl {
   }
 };
 
+class TimerTestGestureRecognizer : public TestGestureRecognizer {
+ public:
+  explicit TimerTestGestureRecognizer(RootWindow* root_window)
+      : TestGestureRecognizer(root_window) {
+  }
+
+  virtual ui::GestureSequence* CreateSequence(
+      ui::GestureEventHelper* helper) OVERRIDE {
+    return new TimerTestGestureSequence(helper);
+  }
+};
+
 base::TimeDelta GetTime() {
   return base::Time::NowFromSystemTime() - base::Time();
 }
 
+void SendScrollEvents(RootWindow* root_window,
+                      int x_start,
+                      int y_start,
+                      base::TimeDelta time_start,
+                      int dx,
+                      int dy,
+                      int touch_id,
+                      int time_step,
+                      int num_steps,
+                      GestureEventConsumeDelegate* delegate) {
+  int x = x_start;
+  int y = y_start;
+  base::TimeDelta time = time_start;
+
+  for (int i = 0; i < num_steps; i++) {
+    x += dx;
+    y += dy;
+    time = time + base::TimeDelta::FromMilliseconds(time_step);
+    TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(x, y),
+                    touch_id, time);
+    root_window->DispatchTouchEvent(&move);
+  }
+}
+
+void SendScrollEvent(RootWindow* root_window,
+                     int x,
+                     int y,
+                     int touch_id,
+                     GestureEventConsumeDelegate* delegate) {
+  delegate->Reset();
+  TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(x, y),
+                  touch_id, GetTime());
+  root_window->DispatchTouchEvent(&move);
+}
+
 }  // namespace
 
 typedef AuraTestBase GestureRecognizerTest;
 
+// Check that appropriate touch events generate tap gesture events.
+TEST_F(GestureRecognizerTest, GestureEventTap) {
+  scoped_ptr<GestureEventConsumeDelegate> delegate(
+      new GestureEventConsumeDelegate());
+  const int kWindowWidth = 123;
+  const int kWindowHeight = 45;
+  const int kTouchId = 2;
+  gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
+  scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
+      delegate.get(), -1234, bounds, NULL));
+
+  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_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->double_tap());
+  EXPECT_FALSE(delegate->scroll_begin());
+  EXPECT_FALSE(delegate->scroll_update());
+  EXPECT_FALSE(delegate->scroll_end());
+}
+
+// Check that appropriate touch events generate scroll gesture events.
+TEST_F(GestureRecognizerTest, GestureEventScroll) {
+  scoped_ptr<GestureEventConsumeDelegate> delegate(
+      new GestureEventConsumeDelegate());
+  const int kWindowWidth = 123;
+  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();
+  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_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->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->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->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->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(
+      new GestureEventConsumeDelegate());
+  const int kTouchId = 7;
+  gfx::Rect bounds(0, 0, 1000, 1000);
+  scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
+      delegate.get(), -1234, bounds, NULL));
+
+  TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0),
+                   kTouchId, GetTime());
+  root_window()->DispatchTouchEvent(&press);
+
+  // Move the touch-point horizontally enough that it is considered a
+  // horizontal scroll.
+  SendScrollEvent(root_window(), 20, 1, kTouchId, delegate.get());
+  EXPECT_EQ(0, delegate->scroll_y());
+  EXPECT_EQ(20, delegate->scroll_x());
+
+  // Get a high x velocity, while still staying on the rail
+  SendScrollEvents(root_window(), 1, 1, press.time_stamp(),
+                   100, 10, kTouchId, 1,
+                   ui::GestureConfiguration::points_buffered_for_velocity(),
+                   delegate.get());
+
+  delegate->Reset();
+  TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
+                     kTouchId, GetTime());
+  root_window()->DispatchTouchEvent(&release);
+
+  EXPECT_TRUE(delegate->scroll_end());
+  EXPECT_EQ(100000, delegate->velocity_x());
+  EXPECT_EQ(0, delegate->velocity_y());
+}
+
+// Check Scroll End Events report correct velocities
+// if the user was on a vertical rail
+TEST_F(GestureRecognizerTest, GestureEventVerticalRailFling) {
+  scoped_ptr<GestureEventConsumeDelegate> delegate(
+      new GestureEventConsumeDelegate());
+  const int kTouchId = 7;
+  gfx::Rect bounds(0, 0, 1000, 1000);
+  scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
+      delegate.get(), -1234, bounds, NULL));
+
+  TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0),
+                   kTouchId, GetTime());
+  root_window()->DispatchTouchEvent(&press);
+
+  // Move the touch-point vertically enough that it is considered a
+  // vertical scroll.
+  SendScrollEvent(root_window(), 1, 20, kTouchId, delegate.get());
+  EXPECT_EQ(20, delegate->scroll_y());
+  EXPECT_EQ(0, delegate->scroll_x());
+
+  // Get a high y velocity, while still staying on the rail
+  SendScrollEvents(root_window(), 1, 1, press.time_stamp(),
+                   10, 100, kTouchId, 1,
+                   ui::GestureConfiguration::points_buffered_for_velocity(),
+                   delegate.get());
+
+  delegate->Reset();
+  TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
+                     kTouchId, GetTime());
+  root_window()->DispatchTouchEvent(&release);
+
+  EXPECT_TRUE(delegate->scroll_end());
+  EXPECT_EQ(0, delegate->velocity_x());
+  EXPECT_EQ(100000, delegate->velocity_y());
+}
+
+// Check Scroll End Events report correct velocities
+// if the user is not on a rail
+TEST_F(GestureRecognizerTest, GestureEventNonRailFling) {
+  scoped_ptr<GestureEventConsumeDelegate> delegate(
+      new GestureEventConsumeDelegate());
+  const int kTouchId = 7;
+  gfx::Rect bounds(0, 0, 1000, 1000);
+  scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
+      delegate.get(), -1234, bounds, NULL));
+
+  TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0),
+                   kTouchId, GetTime());
+  root_window()->DispatchTouchEvent(&press);
+
+  // Move the touch-point such that a non-rail scroll begins
+  SendScrollEvent(root_window(), 20, 20, kTouchId, delegate.get());
+  EXPECT_EQ(20, delegate->scroll_y());
+  EXPECT_EQ(20, delegate->scroll_x());
+
+  SendScrollEvents(root_window(), 1, 1, press.time_stamp(),
+                   10, 100, kTouchId, 1,
+                   ui::GestureConfiguration::points_buffered_for_velocity(),
+                   delegate.get());
+
+  delegate->Reset();
+  TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
+                     kTouchId, GetTime());
+  root_window()->DispatchTouchEvent(&release);
+
+  EXPECT_TRUE(delegate->scroll_end());
+  EXPECT_EQ(10000, delegate->velocity_x());
+  EXPECT_EQ(100000, delegate->velocity_y());
+}
+
+// Check that appropriate touch events generate long press events
+TEST_F(GestureRecognizerTest, GestureEventLongPress) {
+  scoped_ptr<GestureEventConsumeDelegate> delegate(
+      new GestureEventConsumeDelegate());
+  const int kWindowWidth = 123;
+  const int kWindowHeight = 45;
+  const int kTouchId = 2;
+  gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
+  scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
+      delegate.get(), -1234, bounds, NULL));
+
+  delegate->Reset();
+
+  TimerTestGestureRecognizer* gesture_recognizer =
+      new TimerTestGestureRecognizer(root_window());
+  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());
+
+  // 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();
+  TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
+                      kTouchId, GetTime());
+  root_window()->DispatchTouchEvent(&release1);
+  EXPECT_FALSE(delegate->long_press());
+}
+
+// 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);
+  scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
+      delegate.get(), -1234, bounds, NULL));
+
+  delegate->Reset();
+
+  TimerTestGestureRecognizer* gesture_recognizer =
+      new TimerTestGestureRecognizer(root_window());
+  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());
+
+  // We haven't pressed long enough for a long press to occur
+  EXPECT_FALSE(delegate->long_press());
+
+  // 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());
+
+  delegate->Reset();
+  TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
+                      kTouchId, GetTime());
+  root_window()->DispatchTouchEvent(&release1);
+  EXPECT_FALSE(delegate->long_press());
+}
+
+// Check that pinching cancels a long press
+TEST_F(GestureRecognizerTest, GestureEventLongPressCancelledByPinch) {
+  scoped_ptr<GestureEventConsumeDelegate> delegate(
+      new GestureEventConsumeDelegate());
+  const int kWindowWidth = 300;
+  const int kWindowHeight = 400;
+  const int kTouchId1 = 8;
+  const int kTouchId2 = 2;
+  gfx::Rect bounds(5, 5, kWindowWidth, kWindowHeight);
+  scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
+      delegate.get(), -1234, bounds, NULL));
+
+  TimerTestGestureRecognizer* gesture_recognizer =
+      new TimerTestGestureRecognizer(root_window());
+  TimerTestGestureSequence* gesture_sequence =
+      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());
+
+  // We haven't pressed long enough for a long press to occur
+  EXPECT_FALSE(delegate->long_press());
+
+  // Pinch, to cancel the long press
+  delegate->Reset();
+  TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(10, 10),
+                    kTouchId2, GetTime());
+  root_window()->DispatchTouchEvent(&press2);
+  EXPECT_TRUE(delegate->tap_down());
+  EXPECT_TRUE(delegate->pinch_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());
+  root_window()->DispatchTouchEvent(&release1);
+  EXPECT_FALSE(delegate->long_press());
+}
+
+// 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(
+      delegate.get(), -1234, bounds, NULL));
+
+  TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0),
+                   kTouchId, GetTime());
+  root_window()->DispatchTouchEvent(&press);
+
+  // Move the touch-point horizontally enough that it is considered a
+  // horizontal scroll.
+  SendScrollEvent(root_window(), 20, 1, kTouchId, delegate.get());
+  EXPECT_EQ(0, delegate->scroll_y());
+  EXPECT_EQ(20, delegate->scroll_x());
+
+  SendScrollEvent(root_window(), 25, 6, kTouchId, delegate.get());
+  EXPECT_TRUE(delegate->scroll_update());
+  EXPECT_EQ(5, delegate->scroll_x());
+  // y shouldn't change, as we're on a horizontal rail.
+  EXPECT_EQ(0, delegate->scroll_y());
+
+  // Send enough information that a velocity can be calculated for the gesture,
+  // and we can break the rail
+  SendScrollEvents(root_window(), 1, 1, press.time_stamp(),
+                   1, 100, kTouchId, 1,
+                   ui::GestureConfiguration::points_buffered_for_velocity(),
+                   delegate.get());
+
+  SendScrollEvent(root_window(), 0, 0, kTouchId, delegate.get());
+  SendScrollEvent(root_window(), 5, 5, kTouchId, delegate.get());
+
+  // The rail should be broken
+  EXPECT_TRUE(delegate->scroll_update());
+  EXPECT_EQ(5, delegate->scroll_x());
+  EXPECT_EQ(5, delegate->scroll_y());
+}
+
+// Check that vertical scroll gestures cause scrolls on vertical rails.
+// Also tests that vertical rails can be broken.
+TEST_F(GestureRecognizerTest, GestureEventVerticalRailScroll) {
+  scoped_ptr<GestureEventConsumeDelegate> delegate(
+      new GestureEventConsumeDelegate());
+  const int kTouchId = 7;
+  gfx::Rect bounds(0, 0, 1000, 1000);
+  scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
+      delegate.get(), -1234, bounds, NULL));
+
+  TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0),
+                   kTouchId, GetTime());
+  root_window()->DispatchTouchEvent(&press);
+
+  // Move the touch-point vertically enough that it is considered a
+  // vertical scroll.
+  SendScrollEvent(root_window(), 1, 20, kTouchId, delegate.get());
+  EXPECT_EQ(0, delegate->scroll_x());
+  EXPECT_EQ(20, delegate->scroll_y());
+
+  SendScrollEvent(root_window(), 6, 25, kTouchId, delegate.get());
+  EXPECT_TRUE(delegate->scroll_update());
+  EXPECT_EQ(5, delegate->scroll_y());
+  // x shouldn't change, as we're on a vertical rail.
+  EXPECT_EQ(0, delegate->scroll_x());
+
+  // Send enough information that a velocity can be calculated for the gesture,
+  // and we can break the rail
+  SendScrollEvents(root_window(), 1, 1, press.time_stamp(),
+                   100, 1, kTouchId, 1,
+                   ui::GestureConfiguration::points_buffered_for_velocity(),
+                   delegate.get());
+
+  SendScrollEvent(root_window(), 0, 0, kTouchId, delegate.get());
+  SendScrollEvent(root_window(), 5, 5, kTouchId, delegate.get());
+
+  // The rail should be broken
+  EXPECT_TRUE(delegate->scroll_update());
+  EXPECT_EQ(5, delegate->scroll_x());
+  EXPECT_EQ(5, delegate->scroll_y());
+}
+
+TEST_F(GestureRecognizerTest, GestureTapFollowedByScroll) {
+  // First, tap. Then, do a scroll using the same touch-id.
+  scoped_ptr<GestureEventConsumeDelegate> delegate(
+      new GestureEventConsumeDelegate());
+  const int kWindowWidth = 123;
+  const int kWindowHeight = 45;
+  const int kTouchId = 3;
+  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_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();
+  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->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();
+  TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
+                    kTouchId, release.time_stamp() +
+                    base::TimeDelta::FromMilliseconds(1000));
+  root_window()->DispatchTouchEvent(&press1);
+  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());
+
+  // 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();
+  TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(130, 230),
+                  kTouchId, GetTime());
+  root_window()->DispatchTouchEvent(&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_EQ(29, delegate->scroll_x());
+  EXPECT_EQ(29, delegate->scroll_y());
+
+  // Move some more to generate a few more scroll updates.
+  delegate->Reset();
+  TouchEvent move1(ui::ET_TOUCH_MOVED, gfx::Point(110, 211),
+                   kTouchId, GetTime());
+  root_window()->DispatchTouchEvent(&move1);
+  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_EQ(-20, delegate->scroll_x());
+  EXPECT_EQ(-19, delegate->scroll_y());
+
+  delegate->Reset();
+  TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::Point(140, 215),
+                   kTouchId, GetTime());
+  root_window()->DispatchTouchEvent(&move2);
+  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_EQ(30, delegate->scroll_x());
+  EXPECT_EQ(4, delegate->scroll_y());
+
+  // Release the touch. This should end the scroll.
+  delegate->Reset();
+  TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
+                      kTouchId, GetTime());
+  root_window()->DispatchTouchEvent(&release1);
+  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_TRUE(delegate->scroll_end());
+}
+
 // Check that unprocessed gesture events generate appropriate synthetic mouse
 // events.
 TEST_F(GestureRecognizerTest, GestureTapSyntheticMouse) {
@@ -167,24 +920,20 @@ TEST_F(GestureRecognizerTest, GestureTapSyntheticMouse) {
   GestureEvent tap(ui::ET_GESTURE_TAP, 20, 20, 0,
       base::Time::Now(), 0, 6, 1 << kTouchId);
   root_window()->DispatchGestureEvent(&tap);
-
-  EXPECT_TRUE(delegate->EventTypesAre(4,
-                                      ui::ET_MOUSE_ENTERED,
-                                      ui::ET_MOUSE_PRESSED,
-                                      ui::ET_MOUSE_RELEASED,
-                                      ui::ET_MOUSE_EXITED));
+  EXPECT_TRUE(delegate->mouse_enter());
+  EXPECT_TRUE(delegate->mouse_press());
+  EXPECT_TRUE(delegate->mouse_release());
+  EXPECT_TRUE(delegate->mouse_exit());
   EXPECT_FALSE(delegate->double_click());
-  delegate->Reset();
 
+  delegate->Reset();
   GestureEvent tap2(ui::ET_GESTURE_DOUBLE_TAP, 20, 20, 0,
       base::Time::Now(), 0, 0, 1 << kTouchId);
   root_window()->DispatchGestureEvent(&tap2);
-
-  EXPECT_TRUE(delegate->EventTypesAre(4,
-                                      ui::ET_MOUSE_ENTERED,
-                                      ui::ET_MOUSE_PRESSED,
-                                      ui::ET_MOUSE_RELEASED,
-                                      ui::ET_MOUSE_EXITED));
+  EXPECT_TRUE(delegate->mouse_enter());
+  EXPECT_TRUE(delegate->mouse_press());
+  EXPECT_TRUE(delegate->mouse_release());
+  EXPECT_TRUE(delegate->mouse_exit());
   EXPECT_TRUE(delegate->double_click());
 }
 
@@ -202,22 +951,30 @@ TEST_F(GestureRecognizerTest, AsynchronousGestureRecognition) {
   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_TRUE(queued_delegate->EventTypesAre(0));
-  queued_delegate->Reset();
+  EXPECT_FALSE(queued_delegate->tap());
+  EXPECT_FALSE(queued_delegate->tap_down());
+  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_TRUE(queued_delegate->EventTypesAre(0));
-  queued_delegate->Reset();
+  EXPECT_FALSE(queued_delegate->tap());
+  EXPECT_FALSE(queued_delegate->tap_down());
+  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.
@@ -225,54 +982,389 @@ TEST_F(GestureRecognizerTest, AsynchronousGestureRecognition) {
       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_TRUE(delegate->EventTypesAre(1, ui::ET_GESTURE_TAP_DOWN));
-  delegate->Reset();
+  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());
 
   TouchEvent release2(ui::ET_TOUCH_RELEASED, gfx::Point(10, 20),
                       kTouchId2, GetTime());
   root_window()->DispatchTouchEvent(&release2);
 
   // Process the first queued event.
-  queued_delegate->ReceivedAck();
-  EXPECT_TRUE(queued_delegate->EventTypesAre(1, ui::ET_GESTURE_TAP_DOWN));
   queued_delegate->Reset();
+  queued_delegate->ReceivedAck();
+  EXPECT_FALSE(queued_delegate->tap());
+  EXPECT_TRUE(queued_delegate->tap_down());
+  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->ReceivedAck();
-  EXPECT_TRUE(queued_delegate->EventTypesAre(1, ui::ET_GESTURE_TAP));
   queued_delegate->Reset();
+  queued_delegate->ReceivedAck();
+  EXPECT_TRUE(queued_delegate->tap());
+  EXPECT_FALSE(queued_delegate->tap_down());
+  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_TRUE(delegate->EventTypesAre(0));
+  EXPECT_FALSE(queued_delegate->tap());
+  EXPECT_FALSE(queued_delegate->tap_down());
+  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_TRUE(delegate->EventTypesAre(0));
-  delegate->Reset();
+  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(queued_delegate->tap());
+  EXPECT_FALSE(queued_delegate->tap_down());
+  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_TRUE(queued_delegate->EventTypesAre(0));
   queued_delegate->Reset();
-
   queued_delegate->ReceivedAck();
-  EXPECT_TRUE(queued_delegate->EventTypesAre(1, ui::ET_GESTURE_TAP_DOWN));
-  queued_delegate->Reset();
+  EXPECT_FALSE(queued_delegate->tap());
+  EXPECT_TRUE(queued_delegate->tap_down());
+  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_TRUE(queued_delegate->EventTypesAre(3,
-                                             ui::ET_GESTURE_TAP_DOWN,
-                                             ui::ET_GESTURE_PINCH_BEGIN,
-                                             ui::ET_GESTURE_SCROLL_BEGIN));
+  EXPECT_FALSE(queued_delegate->tap());
+  EXPECT_TRUE(queued_delegate->tap_down());
+  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();
+  TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
+                   kTouchId1, GetTime());
+  root->DispatchTouchEvent(&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());
+
+  // 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();
+  TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(130, 201),
+                  kTouchId1, GetTime());
+  root->DispatchTouchEvent(&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());
+
+  // Press the second finger. It should cause both a tap-down and pinch-begin.
+  delegate->Reset();
+  TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(10, 10),
+                    kTouchId2, GetTime());
+  root->DispatchTouchEvent(&press2);
+  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_TRUE(delegate->pinch_begin());
+
+  // Move the first finger.
+  delegate->Reset();
+  TouchEvent move3(ui::ET_TOUCH_MOVED, gfx::Point(95, 201),
+                   kTouchId1, GetTime());
+  root->DispatchTouchEvent(&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());
+
+  // Now move the second finger.
+  delegate->Reset();
+  TouchEvent move4(ui::ET_TOUCH_MOVED, gfx::Point(55, 15),
+                   kTouchId2, GetTime());
+  root->DispatchTouchEvent(&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());
+
+  // Release the first finger. This should end pinch.
+  delegate->Reset();
+  TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
+                     kTouchId1, press.time_stamp() +
+                     base::TimeDelta::FromMilliseconds(50));
+  root->DispatchTouchEvent(&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());
+
+  // Move the second finger. This should still generate a scroll.
+  delegate->Reset();
+  TouchEvent move5(ui::ET_TOUCH_MOVED, gfx::Point(25, 10),
+                   kTouchId2, GetTime());
+  root->DispatchTouchEvent(&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());
+}
+
+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;
+  gfx::Rect bounds(5, 5, kWindowWidth, kWindowHeight);
+  scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
+      delegate.get(), -1234, bounds, NULL));
+
+  TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
+                   kTouchId1, GetTime());
+  root_window()->DispatchTouchEvent(&press);
+  delegate->Reset();
+  TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(10, 10),
+                    kTouchId2, GetTime());
+  root_window()->DispatchTouchEvent(&press2);
+  EXPECT_TRUE(delegate->pinch_begin());
+
+  SendScrollEvent(root_window(), 130, 230, kTouchId1, delegate.get());
+  EXPECT_TRUE(delegate->pinch_update());
+
+  // Pinch has started, now release the second finger
+  delegate->Reset();
+  TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
+                     kTouchId1, GetTime());
+  root_window()->DispatchTouchEvent(&release);
+  EXPECT_TRUE(delegate->pinch_end());
+
+  SendScrollEvent(root_window(), 130, 230, kTouchId2, delegate.get());
+  EXPECT_TRUE(delegate->scroll_update());
+
+  // Pinch again
+  delegate->Reset();
+  TouchEvent press3(ui::ET_TOUCH_PRESSED, gfx::Point(10, 10),
+                    kTouchId1, GetTime());
+  root_window()->DispatchTouchEvent(&press3);
+  EXPECT_TRUE(delegate->pinch_begin());
+
+  SendScrollEvent(root_window(), 130, 230, kTouchId1, delegate.get());
+  EXPECT_TRUE(delegate->pinch_update());
+}
+
+TEST_F(GestureRecognizerTest, GestureEventPinchFromTap) {
+  scoped_ptr<GestureEventConsumeDelegate> delegate(
+      new GestureEventConsumeDelegate());
+  const int kWindowWidth = 300;
+  const int kWindowHeight = 400;
+  const int kTouchId1 = 3;
+  const int kTouchId2 = 5;
+  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();
+  TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
+                   kTouchId1, GetTime());
+  root->DispatchTouchEvent(&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());
+
+  // Press the second finger. It should cause a tap-down, scroll-begin and
+  // pinch-begin.
+  delegate->Reset();
+  TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(10, 10),
+                    kTouchId2, GetTime());
+  root->DispatchTouchEvent(&press2);
+  EXPECT_FALSE(delegate->tap());
+  EXPECT_TRUE(delegate->tap_down());
+  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());
+
+  // Move the first finger.
+  delegate->Reset();
+  TouchEvent move3(ui::ET_TOUCH_MOVED, gfx::Point(65, 201),
+                   kTouchId1, GetTime());
+  root->DispatchTouchEvent(&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());
+
+  // Now move the second finger.
+  delegate->Reset();
+  TouchEvent move4(ui::ET_TOUCH_MOVED, gfx::Point(55, 15),
+                   kTouchId2, GetTime());
+  root->DispatchTouchEvent(&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());
+
+  // Release the first finger. This should end pinch.
+  delegate->Reset();
+  TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
+                     kTouchId1, press.time_stamp() +
+                     base::TimeDelta::FromMilliseconds(50));
+  root->DispatchTouchEvent(&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());
+
+  // Move the second finger. This should still generate a scroll.
+  delegate->Reset();
+  TouchEvent move5(ui::ET_TOUCH_MOVED, gfx::Point(25, 10),
+                   kTouchId2, GetTime());
+  root->DispatchTouchEvent(&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());
+}
+
+TEST_F(GestureRecognizerTest, GestureEventPinchScrollOnlyWhenBothFingersMove) {
+  scoped_ptr<GestureEventConsumeDelegate> delegate(
+      new GestureEventConsumeDelegate());
+  const int kWindowWidth = 1000;
+  const int kWindowHeight = 1000;
+  const int kTouchId1 = 3;
+  const int kTouchId2 = 5;
+  gfx::Rect bounds(0, 0, kWindowWidth, kWindowHeight);
+  scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
+      delegate.get(), -1234, bounds, NULL));
+
+  delegate->Reset();
+  TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(100, 100),
+                    kTouchId1, GetTime());
+
+  root_window()->DispatchTouchEvent(&press1);
+
+  delegate->Reset();
+  TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(110, 110),
+                    kTouchId2, GetTime());
+  root_window()->DispatchTouchEvent(&press2);
+
+  SendScrollEvents(root_window(), 100, 100, press1.time_stamp(),
+                   1, 10, kTouchId1, 1,
+                   ui::GestureConfiguration::points_buffered_for_velocity(),
+                   delegate.get());
+
+  SendScrollEvents(root_window(), 110, 110, press1.time_stamp() +
+                   base::TimeDelta::FromMilliseconds(1000),
+                   1, 10, kTouchId2, 1,
+                   ui::GestureConfiguration::points_buffered_for_velocity(),
+                   delegate.get());
+  // At no point were both fingers moving at the same time,
+  // so no scrolling should have occurred
+
+  EXPECT_EQ(0, delegate->scroll_x());
+  EXPECT_EQ(0, delegate->scroll_y());
+}
+
+TEST_F(GestureRecognizerTest, GestureEventIgnoresDisconnectedEvents) {
+  scoped_ptr<GestureEventConsumeDelegate> delegate(
+      new GestureEventConsumeDelegate());
+
+  TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
+                      6, GetTime());
+  root_window()->DispatchTouchEvent(&release1);
+  EXPECT_FALSE(delegate->tap());
+  EXPECT_FALSE(delegate->tap_down());
 }
 
 // Check that a touch is locked to the window of the closest current touch
@@ -285,6 +1377,9 @@ TEST_F(GestureRecognizerTest, GestureEventTouchLockSelectsCorrectWindow) {
   ui::GestureConsumer* target;
   const int kNumWindows = 4;
 
+  scoped_array<GestureEventConsumeDelegate*> delegates(
+      new GestureEventConsumeDelegate*[kNumWindows]);
+
   ui::GestureConfiguration::
       set_max_separation_for_gesture_touches_in_pixels(499);
 
@@ -299,8 +1394,9 @@ TEST_F(GestureRecognizerTest, GestureEventTouchLockSelectsCorrectWindow) {
   // Instantiate windows with |window_bounds| and touch each window at
   // its origin.
   for (int i = 0; i < kNumWindows; ++i) {
+    delegates[i] = new GestureEventConsumeDelegate();
     windows[i] = CreateTestWindowWithDelegate(
-        new TestWindowDelegate(), i, *window_bounds[i], NULL);
+        delegates[i], i, *window_bounds[i], NULL);
     TouchEvent press(ui::ET_TOUCH_PRESSED, window_bounds[i]->origin(),
                      i, GetTime());
     root_window()->DispatchTouchEvent(&press);
@@ -400,12 +1496,194 @@ TEST_F(GestureRecognizerTest, NoTapWithPreventDefaultedRelease) {
 
   delegate->Reset();
   delegate->ReceivedAck();
-  EXPECT_TRUE(delegate->EventTypesAre(1,
-                                      ui::ET_GESTURE_TAP_DOWN));
+  EXPECT_TRUE(delegate->tap_down());
   delegate->Reset();
   delegate->ReceivedAckPreventDefaulted();
-  // No tap fired.
-  EXPECT_TRUE(delegate->EventTypesAre(0));
+  EXPECT_FALSE(delegate->tap());
+}
+
+TEST_F(GestureRecognizerTest, GestureEventThreeFingerSwipe) {
+  scoped_ptr<GestureEventConsumeDelegate> delegate(
+      new GestureEventConsumeDelegate());
+  const int kTouchId1 = 7;
+  const int kTouchId2 = 2;
+  const int kTouchId3 = 9;
+  gfx::Rect bounds(0, 0, 1000, 1000);
+  scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
+      delegate.get(), -1234, bounds, NULL));
+
+  TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0),
+                    kTouchId1, GetTime());
+  TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0),
+                    kTouchId2, GetTime());
+  TouchEvent press3(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0),
+                    kTouchId3, GetTime());
+
+  TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(0, 0),
+                      kTouchId1, GetTime());
+  TouchEvent release2(ui::ET_TOUCH_RELEASED, gfx::Point(0, 0),
+                      kTouchId2, GetTime());
+  TouchEvent release3(ui::ET_TOUCH_RELEASED, gfx::Point(0, 0),
+                      kTouchId3, GetTime());
+
+  root_window()->DispatchTouchEvent(&press1);
+  root_window()->DispatchTouchEvent(&press2);
+  root_window()->DispatchTouchEvent(&press3);
+
+  delegate->Reset();
+
+  // Start by testing all four directions
+
+  int kBufferedPoints =
+    ui::GestureConfiguration::points_buffered_for_velocity();
+
+  // Swipe right
+  SendScrollEvents(root_window(), 1, 1, press1.time_stamp(),
+                   100, 10, kTouchId1, 1, kBufferedPoints, delegate.get());
+  SendScrollEvents(root_window(), 1, 1, press2.time_stamp(),
+                   100, 10, kTouchId2, 1, kBufferedPoints, delegate.get());
+  SendScrollEvents(root_window(), 1, 1, press3.time_stamp(),
+                   100, 10, kTouchId3, 1, kBufferedPoints, delegate.get());
+
+  EXPECT_TRUE(delegate->three_finger_swipe());
+  EXPECT_EQ(1, delegate->velocity_x());
+  EXPECT_EQ(0, delegate->velocity_y());
+
+  root_window()->DispatchTouchEvent(&release1);
+  root_window()->DispatchTouchEvent(&release2);
+  root_window()->DispatchTouchEvent(&release3);
+
+  root_window()->DispatchTouchEvent(&press1);
+  root_window()->DispatchTouchEvent(&press2);
+  root_window()->DispatchTouchEvent(&press3);
+
+  delegate->Reset();
+
+  // Swipe left
+  SendScrollEvents(root_window(), 1, 1,
+                   press1.time_stamp(),
+                   -100, 10, kTouchId1, 1, kBufferedPoints, delegate.get());
+  SendScrollEvents(root_window(), 1, 1,
+                   press2.time_stamp(),
+                   -100, 10, kTouchId2, 1, kBufferedPoints, delegate.get());
+  SendScrollEvents(root_window(), 1, 1,
+                   press3.time_stamp(),
+                   -100, 10, kTouchId3, 1, kBufferedPoints, delegate.get());
+
+  EXPECT_TRUE(delegate->three_finger_swipe());
+  EXPECT_EQ(-1, delegate->velocity_x());
+  EXPECT_EQ(0, delegate->velocity_y());
+
+  root_window()->DispatchTouchEvent(&release1);
+  root_window()->DispatchTouchEvent(&release2);
+  root_window()->DispatchTouchEvent(&release3);
+
+  root_window()->DispatchTouchEvent(&press1);
+  root_window()->DispatchTouchEvent(&press2);
+  root_window()->DispatchTouchEvent(&press3);
+
+  delegate->Reset();
+
+  // Swipe down
+  SendScrollEvents(root_window(), 1, 1,
+                   press1.time_stamp(),
+                   10, 100, kTouchId1, 1, kBufferedPoints, delegate.get());
+  SendScrollEvents(root_window(), 1, 1,
+                   press2.time_stamp(),
+                   10, 100, kTouchId2, 1, kBufferedPoints, delegate.get());
+  SendScrollEvents(root_window(), 1, 1,
+                   press3.time_stamp(),
+                   10, 100, kTouchId3, 1, kBufferedPoints, delegate.get());
+
+  EXPECT_TRUE(delegate->three_finger_swipe());
+  EXPECT_EQ(0, delegate->velocity_x());
+  EXPECT_EQ(1, delegate->velocity_y());
+
+  root_window()->DispatchTouchEvent(&release1);
+  root_window()->DispatchTouchEvent(&release2);
+  root_window()->DispatchTouchEvent(&release3);
+
+  root_window()->DispatchTouchEvent(&press1);
+  root_window()->DispatchTouchEvent(&press2);
+  root_window()->DispatchTouchEvent(&press3);
+
+  delegate->Reset();
+
+  // Swipe up
+  SendScrollEvents(root_window(), 1, 1,
+                   press1.time_stamp(),
+                   10, -100, kTouchId1, 1, kBufferedPoints, delegate.get());
+  SendScrollEvents(root_window(), 1, 1,
+                   press2.time_stamp(),
+                   10, -100, kTouchId2, 1, kBufferedPoints, delegate.get());
+  SendScrollEvents(root_window(), 1, 1,
+                   press3.time_stamp(),
+                   10, -100, kTouchId3, 1, kBufferedPoints, delegate.get());
+
+  EXPECT_TRUE(delegate->three_finger_swipe());
+  EXPECT_EQ(0, delegate->velocity_x());
+  EXPECT_EQ(-1, delegate->velocity_y());
+
+  // Only one swipe can occur per press of three fingers
+  delegate->Reset();
+
+  SendScrollEvents(root_window(), 1, 1,
+                   press1.time_stamp(),
+                   10, -100, kTouchId1, 1, kBufferedPoints, delegate.get());
+  SendScrollEvents(root_window(), 1, 1,
+                   press2.time_stamp(),
+                   10, -100, kTouchId2, 1, kBufferedPoints, delegate.get());
+  SendScrollEvents(root_window(), 1, 1,
+                   press3.time_stamp(),
+                   10, -100, kTouchId3, 1, kBufferedPoints, delegate.get());
+
+  EXPECT_FALSE(delegate->three_finger_swipe());
+
+  root_window()->DispatchTouchEvent(&release1);
+  root_window()->DispatchTouchEvent(&release2);
+  root_window()->DispatchTouchEvent(&release3);
+
+  root_window()->DispatchTouchEvent(&press1);
+  root_window()->DispatchTouchEvent(&press2);
+  root_window()->DispatchTouchEvent(&press3);
+
+  delegate->Reset();
+
+  // Swiping diagonally doesn't fire an event
+  SendScrollEvents(root_window(), 1, 1,
+                   press1.time_stamp(),
+                   100, -100, kTouchId1, 1, kBufferedPoints, delegate.get());
+  SendScrollEvents(root_window(), 1, 1,
+                   press2.time_stamp(),
+                   100, -100, kTouchId2, 1, kBufferedPoints, delegate.get());
+  SendScrollEvents(root_window(), 1, 1,
+                   press3.time_stamp(),
+                   100, -100, kTouchId3, 1, kBufferedPoints, delegate.get());
+
+  EXPECT_FALSE(delegate->three_finger_swipe());
+
+  root_window()->DispatchTouchEvent(&release1);
+  root_window()->DispatchTouchEvent(&release2);
+  root_window()->DispatchTouchEvent(&release3);
+
+  root_window()->DispatchTouchEvent(&press1);
+  root_window()->DispatchTouchEvent(&press2);
+  root_window()->DispatchTouchEvent(&press3);
+
+  delegate->Reset();
+
+  // Have to swipe in a consistent direction
+  SendScrollEvents(root_window(), 1, 1,
+                   press1.time_stamp(),
+                   100, 10, kTouchId1, 1, kBufferedPoints, delegate.get());
+  SendScrollEvents(root_window(), 1, 1,
+                   press2.time_stamp(),
+                   100, 10, kTouchId2, 1, kBufferedPoints, delegate.get());
+  SendScrollEvents(root_window(), 1, 1,
+                   press3.time_stamp(),
+                   -100, 10, kTouchId3, 1, kBufferedPoints, delegate.get());
+
+  EXPECT_FALSE(delegate->three_finger_swipe());
 }
 
 }  // namespace test
diff --git a/ui/aura/test/aura_test_base.cc b/ui/aura/test/aura_test_base.cc
index 9d8d426..9a0a7ae 100644
--- a/ui/aura/test/aura_test_base.cc
+++ b/ui/aura/test/aura_test_base.cc
@@ -32,7 +32,23 @@ void AuraTestBase::SetUp() {
   // Changing the parameters for gesture recognition shouldn't cause
   // tests to fail, so we use a separate set of parameters for unit
   // testing.
-  ui::GestureConfiguration::use_test_values();
+  ui::GestureConfiguration::set_long_press_time_in_seconds(0.5);
+  ui::GestureConfiguration::set_max_seconds_between_double_click(0.7);
+  ui::GestureConfiguration::
+      set_max_separation_for_gesture_touches_in_pixels(150);
+  ui::GestureConfiguration::
+      set_max_touch_down_duration_in_seconds_for_click(0.8);
+  ui::GestureConfiguration::set_max_touch_move_in_pixels_for_click(20);
+  ui::GestureConfiguration::set_min_distance_for_pinch_scroll_in_pixels(20);
+  ui::GestureConfiguration::set_min_flick_speed_squared(550.f * 550.f);
+  ui::GestureConfiguration::set_min_pinch_update_distance_in_pixels(5);
+  ui::GestureConfiguration::set_min_rail_break_velocity(200);
+  ui::GestureConfiguration::set_min_scroll_delta_squared(5 * 5);
+  ui::GestureConfiguration::
+      set_min_touch_down_duration_in_seconds_for_click(0.01);
+  ui::GestureConfiguration::set_points_buffered_for_velocity(10);
+  ui::GestureConfiguration::set_rail_break_proportion(15);
+  ui::GestureConfiguration::set_rail_start_proportion(2);
 
   Env::GetInstance()->SetMonitorManager(new SingleMonitorManager);
   root_window_.reset(Env::GetInstance()->monitor_manager()->
diff --git a/ui/base/gestures/gesture_configuration.cc b/ui/base/gestures/gesture_configuration.cc
index aa0b01d..17a9d6f 100644
--- a/ui/base/gestures/gesture_configuration.cc
+++ b/ui/base/gestures/gesture_configuration.cc
@@ -32,25 +32,4 @@ int GestureConfiguration::points_buffered_for_velocity_ = 10;
 double GestureConfiguration::rail_break_proportion_ = 15;
 double GestureConfiguration::rail_start_proportion_ = 2;
 
-// Use a separate set of value for unit testing, so that changing the
-// real values won't cause tests to fail.
-void GestureConfiguration::use_test_values() {
-  long_press_time_in_seconds_ = 0.5;
-  max_seconds_between_double_click_ = 0.7;
-  max_separation_for_gesture_touches_in_pixels_ = 150;
-  max_swipe_deviation_ratio_ = 3;
-  max_touch_down_duration_in_seconds_for_click_ = 0.8;
-  max_touch_move_in_pixels_for_click_ = 20;
-  min_distance_for_pinch_scroll_in_pixels_ = 20;
-  min_flick_speed_squared_ = 550.f * 550.f;
-  min_pinch_update_distance_in_pixels_ = 5;
-  min_rail_break_velocity_ = 200;
-  min_scroll_delta_squared_ = 5 * 5;
-  min_swipe_speed_ = 20;
-  min_touch_down_duration_in_seconds_for_click_ = 0.01;
-  points_buffered_for_velocity_ = 10;
-  rail_break_proportion_ = 15;
-  rail_start_proportion_ = 2;
-}
-
 }  // namespace ui
diff --git a/ui/base/gestures/gesture_configuration.h b/ui/base/gestures/gesture_configuration.h
index 1b56c9f..c1aa5dc 100644
--- a/ui/base/gestures/gesture_configuration.h
+++ b/ui/base/gestures/gesture_configuration.h
@@ -116,8 +116,6 @@ class UI_EXPORT GestureConfiguration {
     rail_start_proportion_ = val;
   }
 
-  static void use_test_values();
-
  private:
   // These are listed in alphabetical order ignoring underscores, to
   // align with the associated list of preferences in
diff --git a/ui/base/gestures/gesture_sequence.h b/ui/base/gestures/gesture_sequence.h
index eaf51ed..e8d7aab 100644
--- a/ui/base/gestures/gesture_sequence.h
+++ b/ui/base/gestures/gesture_sequence.h
@@ -56,9 +56,6 @@ class UI_EXPORT GestureSequence {
     return long_press_timer_.get();
   }
 
-  // Current state of gesture recognizer.
-  GestureState state_;
-
  private:
   void Reset();
 
@@ -149,6 +146,9 @@ class UI_EXPORT GestureSequence {
                               const GesturePoint& point,
                               Gestures* gestures);
 
+  // Current state of gesture recognizer.
+  GestureState state_;
+
   // ui::EventFlags.
   int flags_;
 
diff --git a/ui/base/gestures/gesture_sequence_test_base.cc b/ui/base/gestures/gesture_sequence_test_base.cc
deleted file mode 100644
index 6442780..0000000
--- a/ui/base/gestures/gesture_sequence_test_base.cc
+++ /dev/null
@@ -1,237 +0,0 @@
-// 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 "ui/base/gestures/gesture_sequence_test_base.h"
-
-#include <vector>
-#include "ui/base/gestures/gesture_configuration.h"
-#include "ui/base/gestures/gesture_sequence.h"
-
-namespace ui {
-namespace test {
-
-int FakeGestureEvent::GetLowestTouchId() const {
-  if (touch_ids_bitfield_ == 0)
-    return -1;
-  int i = -1;
-  // Find the index of the least significant 1 bit
-  while (!(1 << ++i & touch_ids_bitfield_));
-  return i;
-}
-
-EventType FakeTouchEvent::GetEventType() const {
-  return type_;
-}
-
-gfx::Point FakeTouchEvent::GetLocation() const {
-  return location_;
-}
-
-int FakeTouchEvent::GetTouchId() const {
-  return touch_id_;
-}
-
-int FakeTouchEvent::GetEventFlags() const {
-  return 0;
-}
-
-base::TimeDelta FakeTouchEvent::GetTimestamp() const {
-  return timestamp_;
-};
-
-TouchEvent* FakeTouchEvent::Copy() const {
-  return new FakeTouchEvent(type_, location_, touch_id_, timestamp_);
-};
-
-
-GestureSequenceTestBase::GestureSequenceTestBase() {
-}
-
-GestureSequenceTestBase::~GestureSequenceTestBase() {
-}
-
-GestureEvent* MockGestureEventHelper::CreateGestureEvent(EventType type,
-      const gfx::Point& location,
-      int flags,
-      const base::Time time,
-      float param_first,
-      float param_second,
-      unsigned int touch_ids_bitfield) {
-  return new FakeGestureEvent(type, param_first,
-                              param_second, touch_ids_bitfield);
-}
-
-
-TouchEvent* MockGestureEventHelper::CreateTouchEvent(EventType type,
-      const gfx::Point& location,
-      int touch_id,
-      base::TimeDelta time_stamp) {
-  return NULL;
-}
-
-bool MockGestureEventHelper::DispatchLongPressGestureEvent(
-    GestureEvent* event) {
-  long_press_fired_ = true;
-  return true;
-};
-
-bool MockGestureEventHelper::DispatchCancelTouchEvent(TouchEvent* event) {
-  return false;
-}
-
-FakeGestures* GestureSequenceTestBase::Press(
-    int x, int y, int touch_id) {
-  return DoTouchWithDelay(ET_TOUCH_PRESSED, x, y, touch_id, 0);
-}
-
-FakeGestures* GestureSequenceTestBase::Move(
-    int x, int y, int touch_id) {
-  return DoTouchWithDelay(ET_TOUCH_MOVED, x, y, touch_id, 0);
-}
-
-FakeGestures* GestureSequenceTestBase::Release(
-    int x, int y, int touch_id) {
-  return DoTouchWithDelay(ET_TOUCH_RELEASED, x, y, touch_id, 0);
-}
-
-FakeGestures* GestureSequenceTestBase::Cancel(
-    int x, int y, int touch_id) {
-  return DoTouchWithDelay(ET_TOUCH_CANCELLED, x, y, touch_id, 0);
-}
-
-FakeGestures* GestureSequenceTestBase::Press(
-    int x, int y, int touch_id, int delay) {
-  return DoTouchWithDelay(ET_TOUCH_PRESSED, x, y, touch_id, delay);
-}
-
-FakeGestures* GestureSequenceTestBase::Move(
-    int x, int y, int touch_id, int delay) {
-  return DoTouchWithDelay(ET_TOUCH_MOVED, x, y, touch_id, delay);
-}
-
-FakeGestures* GestureSequenceTestBase::Release(
-    int x, int y, int touch_id, int delay) {
-  return DoTouchWithDelay(ET_TOUCH_RELEASED, x, y, touch_id, delay);
-}
-
-FakeGestures* GestureSequenceTestBase::Cancel(
-    int x, int y, int touch_id, int delay) {
-  return DoTouchWithDelay(ET_TOUCH_CANCELLED, x, y, touch_id, delay);
-}
-
-FakeGestures* GestureSequenceTestBase::ThreeFingeredSwipe(
-    int id1, int x1, int y1, int id2, int x2, int y2, int id3, int x3, int y3) {
-  Press(0, 0, id1);
-  Press(0, 0, id2);
-  Press(0, 0, id3);
-
-  FakeGestures* gestures = new FakeGestures();
-  for (int i = 0;
-       i < GestureConfiguration::points_buffered_for_velocity();
-       ++i) {
-    FakeGestures* a = Move(x1 * i, y1 * i, id1);
-    FakeGestures* b = Move(x2 * i, y2 * i, id2);
-    FakeGestures* c = Move(x3 * i, y3 * i, id3);
-    gestures->insert(gestures->end(), a->begin(), a->end());
-    gestures->insert(gestures->end(), b->begin(), b->end());
-    gestures->insert(gestures->end(), c->begin(), c->end());
-  }
-
-  return gestures;
-}
-
-FakeGestures* GestureSequenceTestBase::DoTouchWithDelay(
-    EventType type,
-    int x,
-    int y,
-    int touch_id,
-    int delay) {
-  base::TimeDelta now = base::Time::NowFromSystemTime() - base::Time();
-
-  if (last_event_time_ < now)
-    last_event_time_ = now;
-
-  last_event_time_ += base::TimeDelta::FromMilliseconds(delay);
-  FakeTouchEvent event(type, gfx::Point(x, y), touch_id, last_event_time_);
-
-  GestureRecognizer::Gestures* gestures =
-      gesture_sequence()->ProcessTouchEventForGesture(
-          event, TOUCH_STATUS_UNKNOWN);
-
-  FakeGestures* fake_gestures = NULL;
-
-  if (gestures) {
-    fake_gestures = new FakeGestures();
-
-    for (size_t i = 0; i < gestures->size(); ++i)
-      fake_gestures->push_back(static_cast<FakeGestureEvent*>((*gestures)[i]));
-
-    gestures->weak_erase(gestures->begin(), gestures->end());
-    delete gestures;
-  }
-
-  GestureState current_state = gesture_sequence()->state();
-  if (current_state != states_->back())
-    states_->push_back(gesture_sequence()->state());
-  return fake_gestures;
-}
-
-bool GestureSequenceTestBase::EventTypesAre(
-    FakeGestures* gestures,
-    size_t num,
-    ... /*EventType types */) {
-  if (num != gestures->size())
-    return false;
-
-  va_list types;
-  va_start(types, num);
-
-  for (size_t i = 0; i < num; ++i) {
-    if ((*gestures)[i]->type() != va_arg(types, int)) {
-      va_end(types);
-      return false;
-    }
-  }
-  va_end(types);
-  return true;
-}
-
-bool GestureSequenceTestBase::StatesAre(size_t num,
-                                        ... /*GestureState* states*/) {
-  if (num != states_->size())
-    return false;
-
-  va_list states;
-  va_start(states, num);
-
-  for (size_t i = 0; i < num; ++i) {
-    if ((*states_)[i] != va_arg(states, int)) {
-      va_end(states);
-      return false;
-    }
-  }
-  va_end(states);
-  return true;
-}
-
-void GestureSequenceTestBase::SetUp() {
-  testing::Test::SetUp();
-
-  // Changing the parameters for gesture recognition shouldn't cause
-  // tests to fail, so we use a separate set of parameters for unit
-  // testing.
-  GestureConfiguration::use_test_values();
-
-  states_.reset(new std::vector<GestureState>());
-  gesture_sequence_.reset(new TestGestureSequence(&helper_));
-  states_->push_back(gesture_sequence()->state());
-}
-
-void GestureSequenceTestBase::TearDown() {
-  gesture_sequence_.reset();
-  testing::Test::TearDown();
-}
-
-}  // namespace test
-}  // namespace ui
diff --git a/ui/base/gestures/gesture_sequence_test_base.h b/ui/base/gestures/gesture_sequence_test_base.h
deleted file mode 100644
index 93136db..0000000
--- a/ui/base/gestures/gesture_sequence_test_base.h
+++ /dev/null
@@ -1,170 +0,0 @@
-// 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.
-
-#ifndef UI_BASE_GESTURES_GESTURE_SEQUENCE_TEST_BASE_H_
-#define UI_BASE_GESTURES_GESTURE_SEQUENCE_TEST_BASE_H_
-#pragma once
-
-#include <vector>
-
-#include "base/basictypes.h"
-#include "base/compiler_specific.h"
-#include "base/message_loop.h"
-#include "base/timer.h"
-#include "testing/gtest/include/gtest/gtest.h"
-#include "ui/base/gestures/gesture_types.h"
-#include "ui/base/test/test_gesture_sequence.h"
-
-namespace ui {
-namespace test {
-
-class FakeGestureEvent : public GestureEvent {
- public:
-  FakeGestureEvent(EventType type,
-                   float param_first,
-                   float param_second,
-                   unsigned int touch_ids_bitfield)
-      : type_(type),
-        param_first_(param_first),
-        param_second_(param_second),
-        touch_ids_bitfield_(touch_ids_bitfield) {
-  }
-
-  virtual ~FakeGestureEvent() {}
-
-  EventType type() const { return type_; }
-  float param_first() const { return param_first_; }
-  float param_second() const { return param_second_; }
-
-  virtual int GetLowestTouchId() const OVERRIDE;
-
-  EventType type_;
-  float param_first_;
-  float param_second_;
-  int touch_ids_bitfield_;
-};
-
-typedef ScopedVector<FakeGestureEvent> FakeGestures;
-
-class FakeTouchEvent : public TouchEvent {
- public:
-  FakeTouchEvent(
-      EventType type,
-      gfx::Point location,
-      int touch_id,
-      base::TimeDelta timestamp)
-      : type_(type),
-        location_(location),
-        touch_id_(touch_id),
-        timestamp_(timestamp) {
-  }
-
-  virtual ~FakeTouchEvent() {}
-
-  virtual EventType GetEventType() const OVERRIDE;
-  virtual gfx::Point GetLocation() const OVERRIDE;
-  virtual int GetTouchId() const OVERRIDE;
-  virtual int GetEventFlags() const OVERRIDE;
-  virtual base::TimeDelta GetTimestamp() const OVERRIDE;
-
-  // Returns a copy of this touch event. Used when queueing events for
-  // asynchronous gesture recognition.
-  virtual TouchEvent* Copy() const OVERRIDE;
-
-  EventType type_;
-  gfx::Point location_;
-  int touch_id_;
-  int flags_;
-  base::TimeDelta timestamp_;
-};
-
-class MockGestureEventHelper : public GestureEventHelper {
- public:
-  MockGestureEventHelper()
-      : long_press_fired_(false) {
-  }
-
-  virtual GestureEvent* CreateGestureEvent(
-      EventType type,
-      const gfx::Point& location,
-      int flags,
-      const base::Time time,
-      float param_first,
-      float param_second,
-      unsigned int touch_ids_bitfield) OVERRIDE;
-
-  virtual TouchEvent* CreateTouchEvent(EventType type,
-                                       const gfx::Point& location,
-                                       int touch_id,
-                                       base::TimeDelta time_stamp) OVERRIDE;
-
-  virtual bool DispatchLongPressGestureEvent(GestureEvent* event) OVERRIDE;
-
-  virtual bool DispatchCancelTouchEvent(TouchEvent* event) OVERRIDE;
-
-  bool long_press_fired() {
-    return long_press_fired_;
-  }
-
-  void Reset() {
-    long_press_fired_ = false;
-  }
-
- private:
-  bool long_press_fired_;
-};
-
-// A base class for gesture sequence unit tests.
-
-class GestureSequenceTestBase : public testing::Test {
- public:
-  GestureSequenceTestBase();
-  virtual ~GestureSequenceTestBase();
-
-  // testing::Test:
-  virtual void SetUp() OVERRIDE;
-  virtual void TearDown() OVERRIDE;
-
- protected:
-  TestGestureSequence* gesture_sequence() { return gesture_sequence_.get(); }
-
-  FakeGestures* Press(int x, int y, int touch_id);
-  FakeGestures* Press(int x, int y, int touch_id, int delay);
-  FakeGestures* Move(int x, int y, int touch_id);
-  FakeGestures* Move(int x, int y, int touch_id, int delay);
-  FakeGestures* Release(int x, int y, int touch_id);
-  FakeGestures* Release(int x, int y, int touch_id, int delay);
-  FakeGestures* Cancel(int x, int y, int touch_id);
-  FakeGestures* Cancel(int x, int y, int touch_id, int delay);
-
-  FakeGestures* ThreeFingeredSwipe(
-      int id1, int x1, int y1,
-      int id2, int x2, int y2,
-      int id3, int x3, int y3);
-
-  bool EventTypesAre(FakeGestures* gestures,
-                     size_t num,
-                     ... /*EventType types */);
-  bool StatesAre(size_t num, ... /*GestureState* states*/);
-  MockGestureEventHelper helper_;
-
- private:
-  FakeGestures* DoTouchWithDelay(
-      EventType type,
-      int x,
-      int y,
-      int touch_id,
-      int delay);
-
-  scoped_ptr<TestGestureSequence> gesture_sequence_;
-  scoped_ptr<std::vector<GestureState> > states_;
-  base::TimeDelta last_event_time_;
-  MessageLoopForUI message_loop_;
-  DISALLOW_COPY_AND_ASSIGN(GestureSequenceTestBase);
-};
-
-}  // namespace test
-}  // namespace ui
-
-#endif  // UI_BASE_GESTURES_GESTURE_SEQUENCE_TEST_BASE_H_
diff --git a/ui/base/gestures/gesture_sequence_unittest.cc b/ui/base/gestures/gesture_sequence_unittest.cc
deleted file mode 100644
index f5851b6..0000000
--- a/ui/base/gestures/gesture_sequence_unittest.cc
+++ /dev/null
@@ -1,624 +0,0 @@
-// 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/basictypes.h"
-#include "testing/gtest/include/gtest/gtest.h"
-#include "ui/base/gestures/gesture_configuration.h"
-#include "ui/base/gestures/gesture_sequence.h"
-#include "ui/base/gestures/gesture_sequence_test_base.h"
-#include "ui/base/gestures/gesture_types.h"
-
-namespace ui {
-namespace test {
-
-namespace {
-const int kTouchId1 = 2;
-const int kTouchId2 = 5;
-const int kTouchId3 = 3;
-}  // namespace
-
-typedef GestureSequenceTestBase GestureSequenceTest;
-typedef scoped_ptr<FakeGestures> Gestures;
-
-TEST_F(GestureSequenceTest, TapDown) {
-  Gestures gestures(Press(0, 0, kTouchId1));
-
-  EXPECT_TRUE(EventTypesAre(gestures.get(), 1, ET_GESTURE_TAP_DOWN));
-  EXPECT_TRUE(StatesAre(2,
-                        GS_NO_GESTURE,
-                        GS_PENDING_SYNTHETIC_CLICK));
-}
-
-TEST_F(GestureSequenceTest, Tap) {
-  Press(0, 0, kTouchId1);
-
-  Gestures gestures(Release(0, 0, kTouchId1, 50));
-
-  EXPECT_TRUE(EventTypesAre(gestures.get(), 1, ET_GESTURE_TAP));
-
-  EXPECT_TRUE(StatesAre(3,
-                        GS_NO_GESTURE,
-                        GS_PENDING_SYNTHETIC_CLICK,
-                        GS_NO_GESTURE));
-}
-
-TEST_F(GestureSequenceTest, TapCancel) {
-  Press(0, 0, kTouchId1);
-  Gestures gestures(Cancel(0, 0, kTouchId1));
-
-  EXPECT_TRUE(EventTypesAre(gestures.get(), 0));
-
-  EXPECT_TRUE(StatesAre(3,
-                        GS_NO_GESTURE,
-                        GS_PENDING_SYNTHETIC_CLICK,
-                        GS_NO_GESTURE));
-}
-
-TEST_F(GestureSequenceTest, NonRailScroll) {
-  Press(0, 0, kTouchId1);
-  Gestures gestures(Move(50, 51, kTouchId1));
-
-  EXPECT_TRUE(EventTypesAre(gestures.get(), 2,
-                            ET_GESTURE_SCROLL_BEGIN,
-                            ET_GESTURE_SCROLL_UPDATE));
-
-  EXPECT_EQ(50, (*gestures)[1]->param_first());
-  EXPECT_EQ(51, (*gestures)[1]->param_second());
-
-  gestures.reset(Move(150, 150, kTouchId1));
-
-  EXPECT_TRUE(EventTypesAre(gestures.get(), 1,
-                            ET_GESTURE_SCROLL_UPDATE));
-
-  EXPECT_EQ(100, (*gestures)[0]->param_first());
-  EXPECT_EQ(99, (*gestures)[0]->param_second());
-
-  gestures.reset(Release(0, 0, kTouchId1));
-
-  EXPECT_TRUE(EventTypesAre(gestures.get(), 1,
-                            ET_GESTURE_SCROLL_END));
-
-  EXPECT_TRUE(StatesAre(4,
-                        GS_NO_GESTURE,
-                        GS_PENDING_SYNTHETIC_CLICK,
-                        GS_SCROLL,
-                        GS_NO_GESTURE));
-}
-
-// Check that horizontal touch moves cause scrolls on horizontal rails.
-// Also tests that horizontal rails can be broken.
-TEST_F(GestureSequenceTest, HorizontalRailScroll) {
-  Press(0, 0, kTouchId1);
-  Gestures gestures(Move(20, 1, kTouchId1));
-
-  EXPECT_TRUE(EventTypesAre(gestures.get(), 2,
-                            ET_GESTURE_SCROLL_BEGIN,
-                            ET_GESTURE_SCROLL_UPDATE));
-
-  EXPECT_EQ(20, (*gestures)[1]->param_first());
-  // We should be on a horizontal rail.
-  EXPECT_EQ(0, (*gestures)[1]->param_second());
-
-  // Break the rail.
-  for (int i = 0; i < GestureConfiguration::points_buffered_for_velocity(); ++i)
-    Move(1, i * 100, kTouchId1, 50);
-
-  Move(0, 0, kTouchId1);
-  gestures.reset(Move(20, 1, kTouchId1));
-
-  EXPECT_TRUE(EventTypesAre(gestures.get(), 1,
-                            ET_GESTURE_SCROLL_UPDATE));
-
-  EXPECT_EQ(20, (*gestures)[0]->param_first());
-  // We shouldn't be on a horizontal rail.
-  EXPECT_EQ(1, (*gestures)[0]->param_second());
-
-  EXPECT_TRUE(StatesAre(3,
-                        GS_NO_GESTURE,
-                        GS_PENDING_SYNTHETIC_CLICK,
-                        GS_SCROLL));
-}
-
-// Check that vertical touch moves cause scrolls on vertical rails.
-// Also tests that vertical rails can be broken.
-TEST_F(GestureSequenceTest, VerticalRailScroll) {
-  Press(0, 0, kTouchId1);
-  Gestures gestures(Move(1, 20, kTouchId1));
-
-  EXPECT_TRUE(EventTypesAre(gestures.get(), 2,
-                            ET_GESTURE_SCROLL_BEGIN,
-                            ET_GESTURE_SCROLL_UPDATE));
-
-  // We should be on a vertical rail.
-  EXPECT_EQ(0, (*gestures)[1]->param_first());
-  EXPECT_EQ(20, (*gestures)[1]->param_second());
-
-  // Break the rail.
-  for (int i = 0; i < GestureConfiguration::points_buffered_for_velocity(); ++i)
-    Move(i * 100, 1, kTouchId1, 50);
-
-  Move(0, 0, kTouchId1);
-  gestures.reset(Move(1, 20, kTouchId1));
-
-  EXPECT_TRUE(EventTypesAre(gestures.get(), 1,
-                            ET_GESTURE_SCROLL_UPDATE));
-
-  // We shouldn't be on a vertical rail.
-  EXPECT_EQ(1, (*gestures)[0]->param_first());
-  EXPECT_EQ(20, (*gestures)[0]->param_second());
-
-  EXPECT_TRUE(StatesAre(3,
-                        GS_NO_GESTURE,
-                        GS_PENDING_SYNTHETIC_CLICK,
-                        GS_SCROLL));
-}
-
-// Check Scroll End Events report correct velocities if the user was
-// on a horizontal rail.
-TEST_F(GestureSequenceTest, HorizontalRailFling) {
-  Press(0, 0, kTouchId1);
-
-  // Get a high x velocity, while still staying on a horizontal rail.
-  for (int i = 0; i < GestureConfiguration::points_buffered_for_velocity(); ++i)
-    Move(i * 100, 1, kTouchId1, 1);
-
-  Gestures gestures(Release(
-      GestureConfiguration::points_buffered_for_velocity() * 100,
-      GestureConfiguration::points_buffered_for_velocity(),
-      kTouchId1));
-
-  EXPECT_TRUE(EventTypesAre(gestures.get(), 2,
-                            ET_GESTURE_SCROLL_END,
-                            ET_SCROLL_FLING_START));
-
-  // We should be on a horizontal rail.
-  EXPECT_EQ(100000, (*gestures)[0]->param_first());
-  EXPECT_EQ(0, (*gestures)[0]->param_second());
-
-  EXPECT_TRUE(StatesAre(4,
-                        GS_NO_GESTURE,
-                        GS_PENDING_SYNTHETIC_CLICK,
-                        GS_SCROLL,
-                        GS_NO_GESTURE));
-}
-
-// Check Scroll End Events report correct velocities if the user was
-// on a vertical rail.
-TEST_F(GestureSequenceTest, VerticalRailFling) {
-  Press(0, 0, kTouchId1);
-
-  // Get a high y velocity, while still staying on a vertical rail.
-  for (int i = 0; i < GestureConfiguration::points_buffered_for_velocity(); ++i)
-    Move(1, i * 100, kTouchId1, 1);
-
-  Gestures gestures(Release(
-      GestureConfiguration::points_buffered_for_velocity(),
-      GestureConfiguration::points_buffered_for_velocity() * 100,
-      kTouchId1));
-
-  EXPECT_TRUE(EventTypesAre(gestures.get(), 2,
-                            ET_GESTURE_SCROLL_END,
-                            ET_SCROLL_FLING_START));
-
-  // We should be on a vertical rail.
-  EXPECT_EQ(0, (*gestures)[0]->param_first());
-  EXPECT_EQ(100000, (*gestures)[0]->param_second());
-
-  EXPECT_TRUE(StatesAre(4,
-                        GS_NO_GESTURE,
-                        GS_PENDING_SYNTHETIC_CLICK,
-                        GS_SCROLL,
-                        GS_NO_GESTURE));
-}
-
-// Check Scroll End Events report correct velocities if the user was
-// not on a rail.
-TEST_F(GestureSequenceTest, NonRailFling) {
-  Press(0, 0, kTouchId1);
-  // Start a non rail scroll.
-  Move(20, 20, kTouchId1);
-
-  // Get a high velocity.
-  for (int i = 0; i < GestureConfiguration::points_buffered_for_velocity(); ++i)
-    Move(i * 10, i * 100, kTouchId1, 1);
-
-  Gestures gestures(Release(
-      GestureConfiguration::points_buffered_for_velocity() * 10,
-      GestureConfiguration::points_buffered_for_velocity() * 100,
-      kTouchId1));
-
-  EXPECT_TRUE(EventTypesAre(gestures.get(), 2,
-                            ET_GESTURE_SCROLL_END,
-                            ET_SCROLL_FLING_START));
-
-  EXPECT_EQ(10000, (*gestures)[0]->param_first());
-  EXPECT_EQ(100000, (*gestures)[0]->param_second());
-
-  EXPECT_TRUE(StatesAre(4,
-                        GS_NO_GESTURE,
-                        GS_PENDING_SYNTHETIC_CLICK,
-                        GS_SCROLL,
-                        GS_NO_GESTURE));
-}
-
-TEST_F(GestureSequenceTest, TapFollowedByScroll) {
-  Press(101, 201, kTouchId1);
-  Gestures gestures(Release(101, 201, kTouchId1, 50));
-
-  EXPECT_TRUE(EventTypesAre(gestures.get(), 1,
-                            ET_GESTURE_TAP));
-
-  // Make sure it isn't counted as a double tap, with a big delay.
-  gestures.reset(Press(101, 201, kTouchId1, 1000));
-  EXPECT_TRUE(EventTypesAre(gestures.get(), 1,
-                            ET_GESTURE_TAP_DOWN));
-
-  gestures.reset(Move(130, 230, kTouchId1));
-  EXPECT_TRUE(EventTypesAre(gestures.get(), 2,
-                            ET_GESTURE_SCROLL_BEGIN,
-                            ET_GESTURE_SCROLL_UPDATE));
-
-  EXPECT_EQ(29, (*gestures)[1]->param_first());
-  EXPECT_EQ(29, (*gestures)[1]->param_second());
-
-  gestures.reset(Move(110, 211, kTouchId1));
-  EXPECT_TRUE(EventTypesAre(gestures.get(), 1,
-                            ET_GESTURE_SCROLL_UPDATE));
-
-  EXPECT_EQ(-20, (*gestures)[0]->param_first());
-  EXPECT_EQ(-19, (*gestures)[0]->param_second());
-
-  gestures.reset(Move(140, 215, kTouchId1));
-  EXPECT_TRUE(EventTypesAre(gestures.get(), 1,
-                            ET_GESTURE_SCROLL_UPDATE));
-
-  EXPECT_EQ(30, (*gestures)[0]->param_first());
-  EXPECT_EQ(4, (*gestures)[0]->param_second());
-
-  gestures.reset(Release(101, 201, kTouchId1));
-  EXPECT_TRUE(EventTypesAre(gestures.get(), 1,
-                            ET_GESTURE_SCROLL_END));
-
-  EXPECT_TRUE(StatesAre(6,
-                        GS_NO_GESTURE,
-                        GS_PENDING_SYNTHETIC_CLICK,
-                        GS_NO_GESTURE,
-                        GS_PENDING_SYNTHETIC_CLICK,
-                        GS_SCROLL,
-                        GS_NO_GESTURE));
-}
-
-TEST_F(GestureSequenceTest, Pinch) {
-  Press(101, 201, kTouchId1);
-  Gestures gestures(Press(10, 10, kTouchId2));
-  EXPECT_TRUE(EventTypesAre(gestures.get(), 3,
-                            ET_GESTURE_TAP_DOWN,
-                            ET_GESTURE_PINCH_BEGIN,
-                            ET_GESTURE_SCROLL_BEGIN));
-
-  gestures.reset(Release(101, 201, kTouchId1));
-  EXPECT_TRUE(EventTypesAre(gestures.get(), 1,
-                            ET_GESTURE_PINCH_END));
-
-  gestures.reset(Release(10, 10, kTouchId2));
-  EXPECT_TRUE(EventTypesAre(gestures.get(), 1,
-                            ET_GESTURE_SCROLL_END));
-
-  EXPECT_TRUE(StatesAre(5,
-                        GS_NO_GESTURE,
-                        GS_PENDING_SYNTHETIC_CLICK,
-                        GS_PINCH,
-                        GS_SCROLL,
-                        GS_NO_GESTURE));
-}
-
-TEST_F(GestureSequenceTest, PinchFromScroll) {
-  Press(101, 201, kTouchId1);
-  Move(130, 201, kTouchId1);
-  // Press finger 2
-  Gestures gestures(Press(10, 10, kTouchId2));
-  EXPECT_TRUE(EventTypesAre(gestures.get(), 2,
-                            ET_GESTURE_TAP_DOWN,
-                            ET_GESTURE_PINCH_BEGIN));
-  // Move finger 1 away from finger 2.
-  gestures.reset(Move(400, 400, kTouchId1));
-  EXPECT_TRUE(EventTypesAre(gestures.get(), 1,
-                            ET_GESTURE_PINCH_UPDATE));
-
-  // We should have zoomed in.
-  EXPECT_LT(2, (*gestures)[0]->param_first());
-  EXPECT_GT(3, (*gestures)[0]->param_first());
-  // Move finger 2 towards finger 1.
-  gestures.reset(Move(300, 300, kTouchId2));
-  EXPECT_TRUE(EventTypesAre(gestures.get(), 1,
-                            ET_GESTURE_PINCH_UPDATE));
-
-  // We should have zoomed out.
-  EXPECT_LT(0.2, (*gestures)[0]->param_first());
-  EXPECT_GT(0.5, (*gestures)[0]->param_first());
-  // Release with finger 1
-  gestures.reset(Release(101, 201, kTouchId1));
-  EXPECT_TRUE(EventTypesAre(gestures.get(), 1,
-                            ET_GESTURE_PINCH_END));
-
-  // Should still be able to scroll with one finger.
-  gestures.reset(Move(25, 10, kTouchId2));
-  EXPECT_TRUE(EventTypesAre(gestures.get(), 1,
-                            ET_GESTURE_SCROLL_UPDATE));
-
-  EXPECT_TRUE(StatesAre(5,
-                        GS_NO_GESTURE,
-                        GS_PENDING_SYNTHETIC_CLICK,
-                        GS_SCROLL,
-                        GS_PINCH,
-                        GS_SCROLL));
-}
-
-TEST_F(GestureSequenceTest, PinchFromScrollFromPinch) {
-  Press(101, 201, kTouchId1);
-  Press(10, 10, kTouchId2);
-  // Pinch.
-  Gestures gestures(Move(130, 230, kTouchId1));
-  EXPECT_TRUE(EventTypesAre(gestures.get(), 1,
-                            ET_GESTURE_PINCH_UPDATE));
-
-  // Release finger 1.
-  gestures.reset(Release(101, 201, kTouchId1));
-  EXPECT_TRUE(EventTypesAre(gestures.get(), 1,
-                            ET_GESTURE_PINCH_END));
-
-  // Press finger one again.
-  Press(101, 201, kTouchId1);
-  // Pinch.
-  gestures.reset(Move(130, 230, kTouchId1));
-  EXPECT_TRUE(EventTypesAre(gestures.get(), 1,
-                            ET_GESTURE_PINCH_UPDATE));
-
-  EXPECT_TRUE(StatesAre(5,
-                        GS_NO_GESTURE,
-                        GS_PENDING_SYNTHETIC_CLICK,
-                        GS_PINCH,
-                        GS_SCROLL,
-                        GS_PINCH));
-}
-
-TEST_F(GestureSequenceTest, PinchFromTap) {
-  Press(101, 201, kTouchId1);
-  Press(10, 10, kTouchId2);
-
-  // Move finger 1 away from finger 2.
-  Gestures gestures(Move(400, 400, kTouchId1));
-  EXPECT_TRUE(EventTypesAre(gestures.get(), 1,
-                            ET_GESTURE_PINCH_UPDATE));
-
-  // We should have zoomed in.
-  EXPECT_LT(2, (*gestures)[0]->param_first());
-  EXPECT_GT(3, (*gestures)[0]->param_first());
-  // Move finger 2 towards finger 1.
-  gestures.reset(Move(300, 300, kTouchId2));
-  EXPECT_TRUE(EventTypesAre(gestures.get(), 1,
-                            ET_GESTURE_PINCH_UPDATE));
-
-  // We should have zoomed out.
-  EXPECT_LT(0.2, (*gestures)[0]->param_first());
-  EXPECT_GT(0.5, (*gestures)[0]->param_first());
-  // Release with finger 1
-  gestures.reset(Release(101, 201, kTouchId1));
-  EXPECT_TRUE(EventTypesAre(gestures.get(), 1,
-                            ET_GESTURE_PINCH_END));
-
-  // Should still be able to scroll with one finger.
-  gestures.reset(Move(25, 10, kTouchId2));
-  EXPECT_TRUE(EventTypesAre(gestures.get(), 1,
-                            ET_GESTURE_SCROLL_UPDATE));
-
-  EXPECT_TRUE(StatesAre(4,
-                        GS_NO_GESTURE,
-                        GS_PENDING_SYNTHETIC_CLICK,
-                        GS_PINCH,
-                        GS_SCROLL));
-}
-
-TEST_F(GestureSequenceTest, PinchScroll) {
-  Press(0, 0, kTouchId1);
-  Press(100, 0, kTouchId2);
-
-  // Pinch scroll events only occur once the total movement of the
-  // users fingers exceed
-  // GestureConfiguration::minimum_distance_for_pinch_scroll_in_pixels().
-
-  // This will generate a series of events, all of which should be
-  // scroll updates, but there will be some touch moves which don't
-  // generate any events at all.
-  Gestures gestures(new FakeGestures());
-  for (int i = 0;
-       i < GestureConfiguration::points_buffered_for_velocity();
-       ++i) {
-    FakeGestures* a = Move(0, 10 * i, kTouchId1);
-    FakeGestures* b = Move(100, 10 * i, kTouchId2);
-    gestures->insert(gestures->end(), a->begin(), a->end());
-    gestures->insert(gestures->end(), b->begin(), b->end());
-  }
-
-  // All events were scroll updates.
-  for (size_t i = 0; i < gestures->size(); i++)
-    EXPECT_EQ((*gestures)[i]->type(), ET_GESTURE_SCROLL_UPDATE);
-
-  // More than 1 scroll update event occurred.
-  EXPECT_LT(1U, gestures->size());
-
-  EXPECT_TRUE(StatesAre(3,
-                        GS_NO_GESTURE,
-                        GS_PENDING_SYNTHETIC_CLICK,
-                        GS_PINCH));
-}
-
-TEST_F(GestureSequenceTest, IgnoreDisconnectedEvents) {
-  Gestures gestures(Release(0, 0, kTouchId1));
-  EXPECT_EQ(NULL, gestures.get());
-
-  gestures.reset(Move(10, 10, kTouchId1));
-  EXPECT_EQ(NULL, gestures.get());
-
-  EXPECT_TRUE(StatesAre(1, GS_NO_GESTURE));
-}
-
-TEST_F(GestureSequenceTest, LongPress) {
-  Press(0, 0, kTouchId1);
-
-  EXPECT_FALSE(helper_.long_press_fired());
-  gesture_sequence()->ForceTimeout();
-  EXPECT_TRUE(helper_.long_press_fired());
-
-  Release(0, 0, kTouchId1);
-
-  EXPECT_TRUE(StatesAre(3,
-                        GS_NO_GESTURE,
-                        GS_PENDING_SYNTHETIC_CLICK,
-                        GS_NO_GESTURE));
-}
-
-TEST_F(GestureSequenceTest, LongPressCancelledByScroll) {
-  Press(0, 0, kTouchId1);
-  Move(10, 10, kTouchId1);
-
-  gesture_sequence()->ForceTimeout();
-  EXPECT_FALSE(helper_.long_press_fired());
-
-  EXPECT_TRUE(StatesAre(3,
-                        GS_NO_GESTURE,
-                        GS_PENDING_SYNTHETIC_CLICK,
-                        GS_SCROLL));
-}
-
-TEST_F(GestureSequenceTest, LongPressCancelledByPinch) {
-  Press(0, 0, kTouchId1);
-  Press(10, 10, kTouchId2);
-
-  gesture_sequence()->ForceTimeout();
-  EXPECT_FALSE(helper_.long_press_fired());
-
-  EXPECT_TRUE(StatesAre(3,
-                        GS_NO_GESTURE,
-                        GS_PENDING_SYNTHETIC_CLICK,
-                        GS_PINCH));
-}
-
-TEST_F(GestureSequenceTest, DoubleTap) {
-  Press(0, 0, kTouchId1);
-  Release(0, 0, kTouchId1, 50);
-  Press(0, 0, kTouchId1);
-
-  Gestures gestures(Release(0, 0, kTouchId1, 50));
-
-  EXPECT_TRUE(EventTypesAre(gestures.get(), 2,
-                            ET_GESTURE_TAP,
-                            ET_GESTURE_DOUBLE_TAP));
-
-  EXPECT_TRUE(StatesAre(5,
-                        GS_NO_GESTURE,
-                        GS_PENDING_SYNTHETIC_CLICK,
-                        GS_NO_GESTURE,
-                        GS_PENDING_SYNTHETIC_CLICK,
-                        GS_NO_GESTURE));
-}
-
-TEST_F(GestureSequenceTest, OnlyDoubleTapIfClose) {
-  Press(0, 0, kTouchId1);
-  Release(0, 0, kTouchId1, 50);
-  Press(0, 100, kTouchId1);
-
-  Gestures gestures(Release(0, 100, kTouchId1, 50));
-
-  EXPECT_TRUE(EventTypesAre(gestures.get(), 1,
-                            ET_GESTURE_TAP));
-
-  EXPECT_TRUE(StatesAre(5,
-                        GS_NO_GESTURE,
-                        GS_PENDING_SYNTHETIC_CLICK,
-                        GS_NO_GESTURE,
-                        GS_PENDING_SYNTHETIC_CLICK,
-                        GS_NO_GESTURE));
-}
-
-// Three Fingered Swipes always report a downward swipe on Win. crbug.com/124410
-#if defined(OS_WIN)
-#define MAYBE_ThreeFingeredSwipeRight DISABLED_ThreeFingeredSwipeRight
-#define MAYBE_ThreeFingeredSwipeLeft DISABLED_ThreeFingeredSwipeLeft
-#define MAYBE_ThreeFingeredSwipeUp DISABLED_ThreeFingeredSwipeUp
-#define MAYBE_ThreeFingeredSwipeDown DISABLED_ThreeFingeredSwipeDown
-#define MAYBE_ThreeFingeredSwipeDiagonal DISABLED_ThreeFingeredSwipeDiagonal
-#define MAYBE_ThreeFingeredSwipeSpread DISABLED_ThreeFingeredSwipeSpread
-#else
-#define MAYBE_ThreeFingeredSwipeRight ThreeFingeredSwipeRight
-#define MAYBE_ThreeFingeredSwipeLeft ThreeFingeredSwipeLeft
-#define MAYBE_ThreeFingeredSwipeUp ThreeFingeredSwipeUp
-#define MAYBE_ThreeFingeredSwipeDown ThreeFingeredSwipeDown
-#define MAYBE_ThreeFingeredSwipeDiagonal ThreeFingeredSwipeDiagonal
-#define MAYBE_ThreeFingeredSwipeSpread ThreeFingeredSwipeSpread
-#endif
-
-TEST_F(GestureSequenceTest, MAYBE_ThreeFingeredSwipeRight) {
-  Gestures gestures(ThreeFingeredSwipe(kTouchId1, 10, 0,
-                                       kTouchId2, 10, 0,
-                                       kTouchId3, 10, 0));
-
-  EXPECT_TRUE(EventTypesAre(gestures.get(), 1,
-                            ET_GESTURE_THREE_FINGER_SWIPE));
-
-  EXPECT_EQ(1, (*gestures)[0]->param_first());
-  EXPECT_EQ(0, (*gestures)[0]->param_second());
-}
-
-TEST_F(GestureSequenceTest, MAYBE_ThreeFingeredSwipeLeft) {
-  Gestures gestures(ThreeFingeredSwipe(kTouchId1, -10, 0,
-                                       kTouchId2, -10, 0,
-                                       kTouchId3, -10, 0));
-
-  EXPECT_TRUE(EventTypesAre(gestures.get(), 1,
-                            ET_GESTURE_THREE_FINGER_SWIPE));
-  EXPECT_EQ(-1, (*gestures)[0]->param_first());
-  EXPECT_EQ(0, (*gestures)[0]->param_second());
-}
-
-TEST_F(GestureSequenceTest, MAYBE_ThreeFingeredSwipeUp) {
-  Gestures gestures(ThreeFingeredSwipe(kTouchId1, 0, 10,
-                                       kTouchId2, 0, 10,
-                                       kTouchId3, 0, 10));
-
-  EXPECT_TRUE(EventTypesAre(gestures.get(), 1,
-                            ET_GESTURE_THREE_FINGER_SWIPE));
-  EXPECT_EQ(0, (*gestures)[0]->param_first());
-  EXPECT_EQ(1, (*gestures)[0]->param_second());
-}
-
-TEST_F(GestureSequenceTest, MAYBE_ThreeFingeredSwipeDown) {
-  Gestures gestures(ThreeFingeredSwipe(kTouchId1, 0, -10,
-                                       kTouchId2, 0, -10,
-                                       kTouchId3, 0, -10));
-
-  EXPECT_TRUE(EventTypesAre(gestures.get(), 1,
-                            ET_GESTURE_THREE_FINGER_SWIPE));
-  EXPECT_EQ(0, (*gestures)[0]->param_first());
-  EXPECT_EQ(-1, (*gestures)[0]->param_second());
-}
-
-TEST_F(GestureSequenceTest, MAYBE_ThreeFingeredSwipeDiagonal) {
-  Gestures gestures(ThreeFingeredSwipe(kTouchId1, 10, 10,
-                                       kTouchId2, 10, 10,
-                                       kTouchId3, 10, 10));
-
-  EXPECT_TRUE(EventTypesAre(gestures.get(), 0));
-}
-
-TEST_F(GestureSequenceTest, MAYBE_ThreeFingeredSwipeSpread) {
-  Gestures gestures(ThreeFingeredSwipe(kTouchId1, 10, 0,
-                                       kTouchId2, 10, 0,
-                                       kTouchId3, -10, 0));
-
-  EXPECT_TRUE(EventTypesAre(gestures.get(), 0));
-}
-
-}  // namespace test
-}  // namespace ui
diff --git a/ui/base/test/test_gesture_sequence.cc b/ui/base/test/test_gesture_sequence.cc
deleted file mode 100644
index 74e77e0..0000000
--- a/ui/base/test/test_gesture_sequence.cc
+++ /dev/null
@@ -1,26 +0,0 @@
-// 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 "ui/base/test/test_gesture_sequence.h"
-
-namespace ui {
-class RootWindow;
-namespace test {
-
-TestGestureSequence::TestGestureSequence(GestureEventHelper* consumer)
-    : GestureSequence(consumer) {
-}
-
-void TestGestureSequence::ForceTimeout() {
-  static_cast<TestOneShotGestureSequenceTimer*>(
-      long_press_timer())->ForceTimeout();
-}
-
-base::OneShotTimer<GestureSequence>*
-    TestGestureSequence::CreateTimer() {
-  return new TestOneShotGestureSequenceTimer();
-}
-
-}  // namespace test
-}  // namespace ui
diff --git a/ui/base/test/test_gesture_sequence.h b/ui/base/test/test_gesture_sequence.h
deleted file mode 100644
index c5df861..0000000
--- a/ui/base/test/test_gesture_sequence.h
+++ /dev/null
@@ -1,48 +0,0 @@
-// 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.
-
-#ifndef UI_BASE_TEST_TEST_GESTURE_SEQUENCE_H_
-#define UI_BASE_TEST_TEST_GESTURE_SEQUENCE_H_
-#pragma once
-
-#include "ui/base/gestures/gesture_sequence.h"
-
-namespace ui {
-class RootWindow;
-namespace test {
-
-class TestGestureSequence : public ui::GestureSequence {
- public:
-  explicit TestGestureSequence(ui::GestureEventHelper* consumer);
-
-  // Make the timer fire.
-  void ForceTimeout();
-  ui::GestureState state() const { return state_; }
-  virtual base::OneShotTimer<GestureSequence>* CreateTimer() OVERRIDE;
-
- private:
-  class TestOneShotGestureSequenceTimer
-      : public base::OneShotTimer<ui::GestureSequence> {
-   public:
-    TestOneShotGestureSequenceTimer() {
-    }
-
-    void ForceTimeout() {
-      if (IsRunning()) {
-        user_task().Run();
-        Stop();
-      }
-    }
-
-   private:
-    DISALLOW_COPY_AND_ASSIGN(TestOneShotGestureSequenceTimer);
-  };
-
-  DISALLOW_COPY_AND_ASSIGN(TestGestureSequence);
-};
-
-}  // namespace test
-}  // namespace ui
-
-#endif  // UI_BASE_TEST_TEST_GESTURE_SEQUENCE_H_
diff --git a/ui/ui_unittests.gypi b/ui/ui_unittests.gypi
index 1c33e0e..d68c9c7 100644
--- a/ui/ui_unittests.gypi
+++ b/ui/ui_unittests.gypi
@@ -192,11 +192,6 @@
         }],
         ['use_aura==1 or toolkit_views==1', {
           'sources': [
-            'base/gestures/gesture_sequence_test_base.cc',
-            'base/gestures/gesture_sequence_test_base.h',
-            'base/gestures/gesture_sequence_unittest.cc',
-            'base/test/test_gesture_sequence.cc',
-            'base/test/test_gesture_sequence.h',
             'base/gestures/velocity_calculator_unittest.cc',
           ],
         }],