Gestures are now possible using touch events with any ids

ui/aura/gestures/gesture_recognizer_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/timer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/aura/event.h"
 #include "ui/aura/gestures/gesture_recognizer_aura.h"
 #include "ui/aura/gestures/gesture_sequence.h"
 #include "ui/aura/root_window.h"
@@ skipping 57 matching lines @@
   bool pinch_update() const { return pinch_update_; }
   bool pinch_end() const { return pinch_end_; }
   bool long_press() const { return long_press_; }
 
   const gfx::Point scroll_begin_position() const {
     return scroll_begin_position_;
   }
 
   float scroll_x() const { return scroll_x_; }
   float scroll_y() const { return scroll_y_; }
-  unsigned int touch_id() const { return touch_id_; }
+  int touch_id() const { return touch_id_; }
 
   virtual ui::GestureStatus OnGestureEvent(GestureEvent* gesture) OVERRIDE {
     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:
@@ skipping 39 matching lines @@
   bool scroll_end_;
   bool pinch_begin_;
   bool pinch_update_;
   bool pinch_end_;
   bool long_press_;
 
   gfx::Point scroll_begin_position_;
 
   float scroll_x_;
   float scroll_y_;
-  unsigned int touch_id_;
+  int touch_id_;
 
   DISALLOW_COPY_AND_ASSIGN(GestureEventConsumeDelegate);
 };
 
 class QueueTouchEventDelegate : public GestureEventConsumeDelegate {
  public:
   explicit QueueTouchEventDelegate(RootWindow* root_window)
       : window_(NULL),
         root_window_(root_window) {
   }
@@ skipping 85 matching lines @@
     : public base::OneShotTimer<GestureSequence> {
  public:
   void ForceTimeout() {
     if (delayed_task_)
       delayed_task_->Run();
   }
 };
 
 class TimerTestGestureSequence : public GestureSequence {
  public:
-  TimerTestGestureSequence(RootWindow* root_window)
+  explicit TimerTestGestureSequence(RootWindow* root_window)
       : GestureSequence(root_window) {
   }
 
   void ForceTimeout() {
     static_cast<TestOneShotGestureSequenceTimer*>(
         long_press_timer())->ForceTimeout();
   }
 
   base::OneShotTimer<GestureSequence>* CreateTimer() {
     return new TestOneShotGestureSequenceTimer();
   }
 };
 
 class TestGestureRecognizer : public GestureRecognizerAura {
   public:
-  TestGestureRecognizer(RootWindow* root_window)
+  explicit TestGestureRecognizer(RootWindow* root_window)
       : GestureRecognizerAura(root_window) {
   }
 
   GestureSequence* GetGestureSequenceForTesting() {
     return gesture_sequence();
   }
 
   virtual GestureSequence* CreateSequence(RootWindow* root_window) OVERRIDE {
     return new TimerTestGestureSequence(root_window);
   }
 };
 
 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++) {
     delegate->Reset();
-    TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(x, y), 0);
+    x += dx;
+    y += dy;
+    time = time + base::TimeDelta::FromMilliseconds(time_step);
+    TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(x, y), touch_id);
     Event::TestApi test_move(&move);
     test_move.set_time_stamp(time);
     root_window->DispatchTouchEvent(&move);
-    x += dx;
-    y += dy;
-    time = time + base::TimeDelta::FromMilliseconds(time_step);
   }
 }
 
 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), 0);
+  TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(x, y), touch_id);
   root_window->DispatchTouchEvent(&move);
 }
 
 const int kBufferedPoints = 10;
 
 }  // 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), 0);
+  TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), kTouchId);
   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), 0);
+  TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201), kTouchId);
   Event::TestApi test_release(&release);
   test_release.set_time_stamp(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), 0);
+  TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), kTouchId);
   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, delegate.get());
+  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, delegate.get());
+  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, delegate.get());
+  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), 0);
+  TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201), kTouchId);
   Event::TestApi test_release(&release);
   test_release.set_time_stamp(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 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();
 
   TestGestureRecognizer* gesture_recognizer =
       new TestGestureRecognizer(root_window());
   TimerTestGestureSequence* gesture_sequence =
       static_cast<TimerTestGestureSequence*>(
           gesture_recognizer->GetGestureSequenceForTesting());
 
   root_window()->SetGestureRecognizerForTesting(gesture_recognizer);
 
-  TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), 0);
+  TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), kTouchId);
   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(0u, delegate->touch_id());
+  EXPECT_EQ(0, delegate->touch_id());
 
   delegate->Reset();
-  TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201), 0);
+  TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201), kTouchId);
   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();
 
   TestGestureRecognizer* gesture_recognizer =
       new TestGestureRecognizer(root_window());
   TimerTestGestureSequence* gesture_sequence =
       static_cast<TimerTestGestureSequence*>(
           gesture_recognizer->GetGestureSequenceForTesting());
 
   root_window()->SetGestureRecognizerForTesting(gesture_recognizer);
 
-  TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), 0);
+  TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), kTouchId);
   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, delegate.get());
+  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), 0);
+  TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201), kTouchId);
   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));
 
   TestGestureRecognizer* gesture_recognizer =
       new TestGestureRecognizer(root_window());
   TimerTestGestureSequence* gesture_sequence =
       static_cast<TimerTestGestureSequence*>(
           gesture_recognizer->GetGestureSequenceForTesting());
 
   root_window()->SetGestureRecognizerForTesting(gesture_recognizer);
 
   delegate->Reset();
-  TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), 0);
+  TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), kTouchId1);
   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), 1);
+  TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(10, 10), kTouchId2);
   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), 0);
+  TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201), kTouchId1);
   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), 0);
+  TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0), kTouchId);
   root_window()->DispatchTouchEvent(&press);
 
   // Move the touch-point horizontally enough that it is considered a
   // horizontal scroll.
-  SendScrollEvent(root_window(), 20, 1, delegate.get());
+  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, delegate.get());
+  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, 1, kBufferedPoints, delegate.get());
+                   1, 100, kTouchId, 1, kBufferedPoints, delegate.get());
 
-  SendScrollEvent(root_window(), 0, 0, delegate.get());
-  SendScrollEvent(root_window(), 5, 5, 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), 0);
+  TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0), kTouchId);
   root_window()->DispatchTouchEvent(&press);
 
   // Move the touch-point vertically enough that it is considered a
   // vertical scroll.
-  SendScrollEvent(root_window(), 1, 20, delegate.get());
+  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, delegate.get());
+  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, 1, kBufferedPoints, delegate.get());
+                   100, 1, kTouchId, 1, kBufferedPoints, delegate.get());
 
-  SendScrollEvent(root_window(), 0, 0, delegate.get());
-  SendScrollEvent(root_window(), 5, 5, 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), 0);
+  TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), kTouchId);
   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), 0);
+  TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201), kTouchId);
   Event::TestApi test_release(&release);
   test_release.set_time_stamp(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), 0);
+  TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), kTouchId);
   Event::TestApi test_release1(&press1);
   test_release1.set_time_stamp(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), 0);
+  TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(130, 230), kTouchId);
   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), 0);
+  TouchEvent move1(ui::ET_TOUCH_MOVED, gfx::Point(110, 211), kTouchId);
   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), 0);
+  TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::Point(140, 215), kTouchId);
   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), 0);
+  TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201), kTouchId);
   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) {
   scoped_ptr<GestureEventSynthDelegate> delegate(
       new GestureEventSynthDelegate());
   scoped_ptr<Window> window(CreateTestWindowWithDelegate(delegate.get(), -1234,
         gfx::Rect(0, 0, 123, 45), NULL));
 
   delegate->Reset();
-  GestureEvent tap(ui::ET_GESTURE_TAP, 20, 20, 0, base::Time::Now(), 0, 0);
+  GestureEvent tap(ui::ET_GESTURE_TAP, 20, 20, 0, base::Time::Now(), 0, 6);
   root_window()->DispatchGestureEvent(&tap);
   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();
   GestureEvent tap2(ui::ET_GESTURE_DOUBLE_TAP, 20, 20, 0,
       base::Time::Now(), 0, 0);
   root_window()->DispatchGestureEvent(&tap2);
   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());
 }
 
 TEST_F(GestureRecognizerTest, AsynchronousGestureRecognition) {
   scoped_ptr<QueueTouchEventDelegate> queued_delegate(
       new QueueTouchEventDelegate(root_window()));
   const int kWindowWidth = 123;
   const int kWindowHeight = 45;
+  const int kTouchId1 = 6;
+  const int kTouchId2 = 4;
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> queue(CreateTestWindowWithDelegate(
       queued_delegate.get(), -1234, bounds, NULL));
 
   queued_delegate->set_window(queue.get());
 
   // Touch down on the window. This should not generate any gesture event.
   queued_delegate->Reset();
-  TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), 0);
+  TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), kTouchId1);
   root_window()->DispatchTouchEvent(&press);
   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), 0);
+  TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201), kTouchId1);
   Event::TestApi test_release(&release);
   test_release.set_time_stamp(press.time_stamp() +
                               base::TimeDelta::FromMilliseconds(50));
   root_window()->DispatchTouchEvent(&release);
   EXPECT_FALSE(queued_delegate->tap());
   EXPECT_FALSE(queued_delegate->tap_down());
   EXPECT_FALSE(queued_delegate->double_tap());
   EXPECT_FALSE(queued_delegate->scroll_begin());
   EXPECT_FALSE(queued_delegate->scroll_update());
   EXPECT_FALSE(queued_delegate->scroll_end());
 
   // Create another window, and place a touch-down on it. This should create a
   // tap-down gesture.
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -2345, gfx::Rect(0, 0, 50, 50), NULL));
   delegate->Reset();
-  TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(10, 20), 0);
+  TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(10, 20), kTouchId2);
   root_window()->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());
 
-  TouchEvent release2(ui::ET_TOUCH_RELEASED, gfx::Point(10, 20), 0);
+  TouchEvent release2(ui::ET_TOUCH_RELEASED, gfx::Point(10, 20), kTouchId2);
   root_window()->DispatchTouchEvent(&release2);
 
   // Process the first queued event.
   queued_delegate->Reset();
   queued_delegate->ReceivedAck();
   EXPECT_FALSE(queued_delegate->tap());
   EXPECT_TRUE(queued_delegate->tap_down());
   EXPECT_FALSE(queued_delegate->double_tap());
   EXPECT_FALSE(queued_delegate->scroll_begin());
   EXPECT_FALSE(queued_delegate->scroll_update());
   EXPECT_FALSE(queued_delegate->scroll_end());
 
   // Now, process the second queued event.
   queued_delegate->Reset();
   queued_delegate->ReceivedAck();
   EXPECT_TRUE(queued_delegate->tap());
   EXPECT_FALSE(queued_delegate->tap_down());
   EXPECT_FALSE(queued_delegate->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), 0);
+  TouchEvent press3(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), kTouchId1);
   root_window()->DispatchTouchEvent(&press3);
   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(10, 20), 1);
+  TouchEvent press4(ui::ET_TOUCH_PRESSED, gfx::Point(10, 20), kTouchId2);
   root_window()->DispatchTouchEvent(&press4);
   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());
@@ skipping 22 matching lines @@
   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), 0);
+  TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), kTouchId1);
   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), 0);
+  TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(130, 201), kTouchId1);
   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), 1);
+  TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(10, 10), kTouchId2);
   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), 0);
+  TouchEvent move3(ui::ET_TOUCH_MOVED, gfx::Point(95, 201), kTouchId1);
   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), 1);
+  TouchEvent move4(ui::ET_TOUCH_MOVED, gfx::Point(55, 15), kTouchId2);
   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), 0);
+  TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201), kTouchId1);
   Event::TestApi test_release(&release);
   test_release.set_time_stamp(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), 1);
+  TouchEvent move5(ui::ET_TOUCH_MOVED, gfx::Point(25, 10), kTouchId2);
   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);
+  root_window()->DispatchTouchEvent(&press);
+  delegate->Reset();
+  TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(10, 10), kTouchId2);
+  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);
+  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);
+  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), 0);
+  TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), kTouchId1);
   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), 1);
+  TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(10, 10), kTouchId2);
   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), 0);
+  TouchEvent move3(ui::ET_TOUCH_MOVED, gfx::Point(65, 201), kTouchId1);
   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), 1);
+  TouchEvent move4(ui::ET_TOUCH_MOVED, gfx::Point(55, 15), kTouchId2);
   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), 0);
+  TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201), kTouchId1);
   Event::TestApi test_release(&release);
   test_release.set_time_stamp(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), 1);
+  TouchEvent move5(ui::ET_TOUCH_MOVED, gfx::Point(25, 10), kTouchId2);
   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);
+
+  root_window()->DispatchTouchEvent(&press1);
+
+  delegate->Reset();
+  TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(110, 110), kTouchId2);
+  root_window()->DispatchTouchEvent(&press2);
+
+  SendScrollEvents(root_window(), 100, 100, press1.time_stamp(),
+                   1, 10, kTouchId1, 1, kBufferedPoints, delegate.get());
+
+  SendScrollEvents(root_window(), 110, 110, press1.time_stamp() +
+                   base::TimeDelta::FromMilliseconds(1000),
+                   1, 10, kTouchId2, 1, kBufferedPoints, 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);
+  root_window()->DispatchTouchEvent(&release1);
+  EXPECT_FALSE(delegate->tap());
+  EXPECT_FALSE(delegate->tap_down());
+}
+
 }  // namespace test
 }  // namespace aura