GestureRecognizerTest tests both Aura and Unified Gesture Detectors.

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/command_line.h"
 #include "base/memory/scoped_vector.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/timer/timer.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 84 matching lines @@
         velocity_y_(0),
         scroll_x_ordinal_(0),
         scroll_y_ordinal_(0),
         scroll_velocity_x_ordinal_(0),
         scroll_velocity_y_ordinal_(0),
         velocity_x_ordinal_(0),
         velocity_y_ordinal_(0),
         scroll_x_hint_(0),
         scroll_y_hint_(0),
         tap_count_(0),
-        wait_until_event_(ui::ET_UNKNOWN) {
-  }
+        wait_until_event_(ui::ET_UNKNOWN),
+        flags_(0) {}
 
   virtual ~GestureEventConsumeDelegate() {}
 
   void Reset() {
     events_.clear();
     tap_ = false;
     tap_down_ = false;
     tap_cancel_ = false;
     begin_ = false;
     end_ = false;
@@ skipping 25 matching lines @@
     scroll_x_ordinal_ = 0;
     scroll_y_ordinal_ = 0;
     scroll_velocity_x_ordinal_ = 0;
     scroll_velocity_y_ordinal_ = 0;
     velocity_x_ordinal_ = 0;
     velocity_y_ordinal_ = 0;
     scroll_x_hint_ = 0;
     scroll_y_hint_ = 0;
     tap_count_ = 0;
     scale_ = 0;
+    flags_ = 0;
   }
 
   const std::vector<ui::EventType>& events() const { return events_; };
 
   bool tap() const { return tap_; }
   bool tap_down() const { return tap_down_; }
   bool tap_cancel() const { return tap_cancel_; }
   bool begin() const { return begin_; }
   bool end() const { return end_; }
   bool scroll_begin() const { return scroll_begin_; }
@@ skipping 34 matching lines @@
   float scroll_y_ordinal() const { return scroll_y_ordinal_; }
   float scroll_velocity_x_ordinal() const { return scroll_velocity_x_ordinal_; }
   float scroll_velocity_y_ordinal() const { return scroll_velocity_y_ordinal_; }
   float velocity_x_ordinal() const { return velocity_x_ordinal_; }
   float velocity_y_ordinal() const { return velocity_y_ordinal_; }
   float scroll_x_hint() const { return scroll_x_hint_; }
   float scroll_y_hint() const { return scroll_y_hint_; }
   float scale() const { return scale_; }
   const gfx::Rect& bounding_box() const { return bounding_box_; }
   int tap_count() const { return tap_count_; }
+  int flags() const { return flags_; }
 
   void WaitUntilReceivedGesture(ui::EventType type) {
     wait_until_event_ = type;
     run_loop_.reset(new base::RunLoop());
     run_loop_->Run();
   }
 
   virtual void OnGestureEvent(ui::GestureEvent* gesture) OVERRIDE {
     events_.push_back(gesture->type());
     bounding_box_ = gesture->details().bounding_box();
+    flags_ = gesture->flags();
     switch (gesture->type()) {
       case ui::ET_GESTURE_TAP:
         tap_location_ = gesture->location();
         tap_count_ = gesture->details().tap_count();
         tap_ = true;
         break;
       case ui::ET_GESTURE_TAP_DOWN:
         tap_down_ = true;
         break;
       case ui::ET_GESTURE_TAP_CANCEL:
@@ skipping 54 matching lines @@
         break;
       case ui::ET_GESTURE_SHOW_PRESS:
         show_press_ = true;
         break;
       case ui::ET_GESTURE_MULTIFINGER_SWIPE:
         swipe_left_ = gesture->details().swipe_left();
         swipe_right_ = gesture->details().swipe_right();
         swipe_up_ = gesture->details().swipe_up();
         swipe_down_ = gesture->details().swipe_down();
         break;
+      case ui::ET_SCROLL_FLING_CANCEL:
+        // Only used in unified gesture detection.
+        break;
       default:
         NOTREACHED();
     }
     if (wait_until_event_ == gesture->type() && run_loop_) {
       run_loop_->Quit();
       wait_until_event_ = ui::ET_UNKNOWN;
     }
     gesture->StopPropagation();
   }
 
@@ skipping 36 matching lines @@
   float scroll_y_ordinal_;
   float scroll_velocity_x_ordinal_;
   float scroll_velocity_y_ordinal_;
   float velocity_x_ordinal_;
   float velocity_y_ordinal_;
   float scroll_x_hint_;
   float scroll_y_hint_;
   float scale_;
   gfx::Rect bounding_box_;
   int tap_count_;
+  int flags_;
 
   ui::EventType wait_until_event_;
 
   DISALLOW_COPY_AND_ASSIGN(GestureEventConsumeDelegate);
 };
 
 class QueueTouchEventDelegate : public GestureEventConsumeDelegate {
  public:
   explicit QueueTouchEventDelegate(WindowEventDispatcher* dispatcher)
       : window_(NULL),
@@ skipping 193 matching lines @@
   scoped_ptr<ui::GestureRecognizer> new_gr_;
 
   DISALLOW_COPY_AND_ASSIGN(ScopedGestureRecognizerSetter);
 };
 
 class TimedEvents {
  private:
   int simulated_now_;
 
  public:
-  TimedEvents() : simulated_now_(0) {
+  // Use a non-zero start time to pass DCHECKs which ensure events have had a
+  // time assigned.
+  TimedEvents() : simulated_now_(1) {
   }
 
   base::TimeDelta Now() {
     base::TimeDelta t = base::TimeDelta::FromMilliseconds(simulated_now_);
     simulated_now_++;
     return t;
   }
 
   base::TimeDelta LeapForward(int time_in_millis) {
     simulated_now_ += time_in_millis;
@@ skipping 117 matching lines @@
       target->RemovePreTargetHandler(this);
       target->parent()->RemoveChild(target);
     }
   }
 
   DISALLOW_COPY_AND_ASSIGN(RemoveOnTouchCancelHandler);
 };
 
 }  // namespace
 
-class GestureRecognizerTest : public AuraTestBase {
+class GestureRecognizerTest : public AuraTestBase,
+                              public ::testing::WithParamInterface<bool> {
  public:
   GestureRecognizerTest() {}
 
+  bool UsingUnifiedGR() {
+    return GetParam();
+  }
+
   virtual void SetUp() OVERRIDE {
     CommandLine::ForCurrentProcess()->AppendSwitch(
         switches::kEnableScrollPrediction);

[sadrul, 2014/04/25 13:44:12]

Aside: We don't enable this flag by default, right? We shouldn't be setting this
flag in the tests. We should set this flag only for scroll-prediction related
tests.

[tdresser, 2014/04/25 16:46:34]

Doesn't look like any tests rely on the flag being set...
I've removed it.

+    // TODO(tdresser): Once unified GR has landed, only run these tests once.
+    if (UsingUnifiedGR()) {
+      // TODO(tdresser):
+      // CommandLine::ForCurrentProcess()->AppendSwitch(
+      //    switches::kUseUnifiedGestureDetector);
+    }
+
     AuraTestBase::SetUp();
   }
 
   DISALLOW_COPY_AND_ASSIGN(GestureRecognizerTest);
 };
 
 // Check that appropriate touch events generate tap gesture events.
-TEST_F(GestureRecognizerTest, GestureEventTap) {
+TEST_P(GestureRecognizerTest, GestureEventTap) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   TimedEvents tes;
   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, root_window()));
 
@@ skipping 30 matching lines @@
   EXPECT_TRUE(delegate->end());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
 
   EXPECT_EQ(1, delegate->tap_count());
 }
 
 // Check that appropriate touch events generate tap gesture events
 // when information about the touch radii are provided.
-TEST_F(GestureRecognizerTest, GestureEventTapRegion) {
+TEST_P(GestureRecognizerTest, GestureEventTapRegion) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   TimedEvents tes;
   const int kWindowWidth = 800;
   const int kWindowHeight = 600;
   const int kTouchId = 2;
   gfx::Rect bounds(0, 0, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
 
@@ skipping 219 matching lines @@
      EXPECT_EQ(1, delegate->tap_count());
      gfx::Point actual_point(delegate->tap_location());
      EXPECT_EQ(33, delegate->bounding_box().width());
      EXPECT_EQ(32, delegate->bounding_box().height());
      EXPECT_EQ(397, actual_point.x());
      EXPECT_EQ(149, actual_point.y());
   }
 }
 
 // Check that appropriate touch events generate scroll gesture events.
-TEST_F(GestureRecognizerTest, GestureEventScroll) {
+TEST_P(GestureRecognizerTest, GestureEventScroll) {
   // We'll start by moving the touch point by (10.5, 10.5). We want 5 dips of
   // that distance to be consumed by the slop, so we set the slop radius to
   // sqrt(5 * 5 + 5 * 5).
   ui::GestureConfiguration::set_max_touch_move_in_pixels_for_click(
       sqrt(static_cast<double>(5 * 5 + 5 * 5)));
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   TimedEvents tes;
   const int kWindowWidth = 123;
   const int kWindowHeight = 45;
@@ skipping 23 matching lines @@
   // The slop consumed 5 dips
   EXPECT_FLOAT_EQ(5.5, delegate->scroll_x());
   EXPECT_FLOAT_EQ(5.5, delegate->scroll_y());
   EXPECT_EQ(gfx::Point(1, 1).ToString(),
             delegate->scroll_begin_position().ToString());
 
   // When scrolling with a single finger, the bounding box of the gesture should
   // be empty, since it's a single point and the radius for testing is zero.
   EXPECT_TRUE(delegate->bounding_box().IsEmpty());
 
-  // Move some more to generate a few more scroll updates.
-  tes.SendScrollEvent(event_processor(), 91, 192, kTouchId, delegate.get());
+  // Move some more to generate a few more scroll updates. Make sure that we get
+  // out of the snap channel for the unified GR.
+  tes.SendScrollEvent(event_processor(), 20, 120, kTouchId, delegate.get());
   EXPECT_1_EVENT(delegate->events(), ui::ET_GESTURE_SCROLL_UPDATE);
-  EXPECT_FLOAT_EQ(-20.5, delegate->scroll_x());
-  EXPECT_FLOAT_EQ(-19.5, delegate->scroll_y());
+  EXPECT_FLOAT_EQ(-91.5, delegate->scroll_x());
+  EXPECT_FLOAT_EQ(-91.5, delegate->scroll_y());
   EXPECT_TRUE(delegate->bounding_box().IsEmpty());
 
-  tes.SendScrollEvent(event_processor(), 121, 196, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_processor(), 50, 124, kTouchId, delegate.get());
   EXPECT_1_EVENT(delegate->events(), ui::ET_GESTURE_SCROLL_UPDATE);
   EXPECT_EQ(30, delegate->scroll_x());
   EXPECT_EQ(4, delegate->scroll_y());
   EXPECT_TRUE(delegate->bounding_box().IsEmpty());
 
   // Release the touch. This should end the scroll.
   delegate->Reset();
   ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
                          kTouchId,
                          tes.LeapForward(50));
   DispatchEventUsingWindowDispatcher(&release);
   EXPECT_2_EVENTS(delegate->events(),
                   ui::ET_SCROLL_FLING_START,
                   ui::ET_GESTURE_END);
   EXPECT_TRUE(delegate->bounding_box().IsEmpty());
 }
 
 // Check that predicted scroll update positions are correct.
-TEST_F(GestureRecognizerTest, GestureEventScrollPrediction) {
+TEST_P(GestureRecognizerTest, GestureEventScrollPrediction) {
   const double prediction_interval = 0.03;
   ui::GestureConfiguration::set_scroll_prediction_seconds(prediction_interval);
    // We'll start by moving the touch point by (5, 5). We want all of that
   // distance to be consumed by the slop, so we set the slop radius to
   // sqrt(5 * 5 + 5 * 5).
   ui::GestureConfiguration::set_max_touch_move_in_pixels_for_click(
       sqrt(static_cast<double>(5 * 5 + 5 * 5)));
 
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
@@ skipping 11 matching lines @@
   gfx::Vector2dF total_scroll;
   ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(96, 196),
                        kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&press);
   EXPECT_2_EVENTS(delegate->events(),
                   ui::ET_GESTURE_BEGIN,
                   ui::ET_GESTURE_TAP_DOWN);
   delegate->Reset();
 
   // Get rid of touch slop.
-  ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(101, 201),
+  ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(111, 211),
                       kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&move);
   EXPECT_3_EVENTS(delegate->events(),
                   ui::ET_GESTURE_TAP_CANCEL,
                   ui::ET_GESTURE_SCROLL_BEGIN,
                   ui::ET_GESTURE_SCROLL_UPDATE);
   total_scroll.set_x(total_scroll.x() + delegate->scroll_x());
   total_scroll.set_y(total_scroll.y() + delegate->scroll_y());
 
   // Move the touch-point enough so that it is considered as a scroll. This
@@ skipping 22 matching lines @@
 
   // Release the touch. This should end the scroll.
   delegate->Reset();
   ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
                          kTouchId,
                          tes.LeapForward(50));
   DispatchEventUsingWindowDispatcher(&release);
 }
 
 // Check that the bounding box during a scroll event is correct.
-TEST_F(GestureRecognizerTest, GestureEventScrollBoundingBox) {
+TEST_P(GestureRecognizerTest, GestureEventScrollBoundingBox) {
   TimedEvents tes;
   for (int radius = 1; radius <= 10; ++radius) {
     ui::GestureConfiguration::set_default_radius(radius);
     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(
@@ skipping 36 matching lines @@
                         kPositionY + kScrollAmount - radius,
                         radius * 2,
                         radius * 2).ToString(),
               delegate->bounding_box().ToString());
   }
   ui::GestureConfiguration::set_default_radius(0);
 }
 
 // Check Scroll End Events report correct velocities
 // if the user was on a horizontal rail
-TEST_F(GestureRecognizerTest, GestureEventHorizontalRailFling) {
+TEST_P(GestureRecognizerTest, GestureEventHorizontalRailFling) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   TimedEvents tes;
   const int kTouchId = 7;
   gfx::Rect bounds(0, 0, 1000, 1000);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
 
   ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0),
                        kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&press);
 
   // Get rid of touch slop.
-  ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(5, 0),
+  ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(10, 0),
                        kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&move);
   delegate->Reset();
 
 
   // Move the touch-point horizontally enough that it is considered a
   // horizontal scroll.
-  tes.SendScrollEvent(event_processor(), 25, 1, kTouchId, delegate.get());
-  EXPECT_EQ(0, delegate->scroll_y());
-  EXPECT_EQ(1, delegate->scroll_y_ordinal());
-  EXPECT_EQ(20, delegate->scroll_x());
-  EXPECT_EQ(20, delegate->scroll_x_ordinal());
+  tes.SendScrollEvent(event_processor(), 30, 1, kTouchId, delegate.get());
+  EXPECT_FLOAT_EQ(0, delegate->scroll_y());
+  EXPECT_FLOAT_EQ(1, delegate->scroll_y_ordinal());
+  EXPECT_FLOAT_EQ(20, delegate->scroll_x());
+  EXPECT_FLOAT_EQ(20, delegate->scroll_x_ordinal());
 
   // Get a high x velocity, while still staying on the rail
   tes.SendScrollEvents(event_processor(), 1, 1,
                    100, 10, kTouchId, 1,
                    ui::GestureConfiguration::points_buffered_for_velocity(),
                    delegate.get());
 
   delegate->Reset();
   ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
                          kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&release);
 
   EXPECT_TRUE(delegate->fling());
   EXPECT_FALSE(delegate->scroll_end());
   EXPECT_GT(delegate->velocity_x(), 0);
   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) {
+TEST_P(GestureRecognizerTest, GestureEventVerticalRailFling) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   TimedEvents tes;
   const int kTouchId = 7;
   gfx::Rect bounds(0, 0, 1000, 1000);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
 
   ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0),
                        kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&press);
 
   // Get rid of touch slop.
-  ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(0, 5),
+  ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(0, 10),
                        kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&move);
   delegate->Reset();
 
   // Move the touch-point vertically enough that it is considered a
   // vertical scroll.
-  tes.SendScrollEvent(event_processor(), 1, 25, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_processor(), 1, 30, kTouchId, delegate.get());
   EXPECT_EQ(20, delegate->scroll_y());
   EXPECT_EQ(20, delegate->scroll_y_ordinal());
   EXPECT_EQ(0, delegate->scroll_x());
   EXPECT_EQ(1, delegate->scroll_x_ordinal());
   EXPECT_EQ(0, delegate->scroll_velocity_x());
 
   // Get a high y velocity, while still staying on the rail
   tes.SendScrollEvents(event_processor(), 1, 6,
                        10, 100, kTouchId, 1,
                        ui::GestureConfiguration::points_buffered_for_velocity(),
                        delegate.get());
   EXPECT_EQ(0, delegate->scroll_velocity_x());
 
   delegate->Reset();
   ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 206),
                          kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&release);
 
   EXPECT_TRUE(delegate->fling());
   EXPECT_FALSE(delegate->scroll_end());
   EXPECT_EQ(0, delegate->velocity_x());
   EXPECT_GT(delegate->velocity_y(), 0);
 }
 
-// Check Scroll End Events reports zero velocities
-// if the user is not on a rail
-TEST_F(GestureRecognizerTest, GestureEventNonRailFling) {
+// Check Scroll End Events report non-zero velocities if the user is not on a
+// rail
+TEST_P(GestureRecognizerTest, GestureEventNonRailFling) {
   ui::GestureConfiguration::set_max_touch_move_in_pixels_for_click(0);
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   TimedEvents tes;
   const int kTouchId = 7;
   gfx::Rect bounds(0, 0, 1000, 1000);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
 
   ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0),
                        kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&press);
 
-  // Move the touch-point such that a non-rail scroll begins
-  tes.SendScrollEvent(event_processor(), 20, 20, kTouchId, delegate.get());
-  EXPECT_EQ(20, delegate->scroll_y());
-  EXPECT_EQ(20, delegate->scroll_x());
+  // Move the touch-point such that a non-rail scroll begins, and we're outside
+  // the snap channel for the unified GR.
+  tes.SendScrollEvent(event_processor(), 50, 50, kTouchId, delegate.get());
+  EXPECT_EQ(50, delegate->scroll_y());
+  EXPECT_EQ(50, delegate->scroll_x());
 
   tes.SendScrollEvents(event_processor(), 1, 1,
                        10, 100, kTouchId, 1,
                        ui::GestureConfiguration::points_buffered_for_velocity(),
                        delegate.get());
 
   delegate->Reset();
   ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
                          kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&release);
 
   EXPECT_TRUE(delegate->fling());
   EXPECT_FALSE(delegate->scroll_end());
   EXPECT_GT(delegate->velocity_x(), 0);
   EXPECT_GT(delegate->velocity_y(), 0);
 }
 
 // Check that appropriate touch events generate long press events
-TEST_F(GestureRecognizerTest, GestureEventLongPress) {
+TEST_P(GestureRecognizerTest, GestureEventLongPress) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
-  TimedEvents tes;
   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, root_window()));
 
   delegate->Reset();
 
   TimerTestGestureRecognizer* gesture_recognizer =
       new TimerTestGestureRecognizer();
 
   ScopedGestureRecognizerSetter gr_setter(gesture_recognizer);
 
   ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
-                        kTouchId, tes.Now());
+                        kTouchId, base::TimeTicks::Now() - base::TimeTicks());

[sadrul, 2014/04/25 13:44:12]

Can we use ui::EventTimeForNow() instead?

[tdresser, 2014/04/25 16:46:34]

Wonderful, done.

   DispatchEventUsingWindowDispatcher(&press1);
   EXPECT_TRUE(delegate->tap_down());
   EXPECT_TRUE(delegate->begin());
   EXPECT_FALSE(delegate->tap_cancel());
 
   // We haven't pressed long enough for a long press to occur
   EXPECT_FALSE(delegate->long_press());
 
   // Wait until the timer runs out
   delegate->WaitUntilReceivedGesture(ui::ET_GESTURE_LONG_PRESS);
   EXPECT_TRUE(delegate->long_press());
   EXPECT_FALSE(delegate->tap_cancel());
 
   delegate->Reset();
   ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
-                          kTouchId, tes.Now());
+                          kTouchId, base::TimeTicks::Now() - base::TimeTicks());
   DispatchEventUsingWindowDispatcher(&release1);
   EXPECT_FALSE(delegate->long_press());
 
-  // Note the tap down isn't cancelled until the release
+  // Note the tap cancel isn't dispatched until the release
   EXPECT_TRUE(delegate->tap_cancel());
+  EXPECT_FALSE(delegate->tap());
 }
 
 // Check that scrolling cancels a long press
-TEST_F(GestureRecognizerTest, GestureEventLongPressCancelledByScroll) {
+TEST_P(GestureRecognizerTest, GestureEventLongPressCancelledByScroll) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   TimedEvents tes;
   ui::GestureConfiguration::set_long_press_time_in_seconds(.01);
   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, root_window()));
@@ skipping 26 matching lines @@
 
   delegate->Reset();
   ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
                           kTouchId, tes.LeapForward(10));
   DispatchEventUsingWindowDispatcher(&release1);
   EXPECT_FALSE(delegate->long_press());
   EXPECT_FALSE(delegate->tap_cancel());
 }
 
 // Check that appropriate touch events generate long tap events
-TEST_F(GestureRecognizerTest, GestureEventLongTap) {
+TEST_P(GestureRecognizerTest, GestureEventLongTap) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
-  TimedEvents tes;
   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, root_window()));
 
   delegate->Reset();
 
   TimerTestGestureRecognizer* gesture_recognizer =
       new TimerTestGestureRecognizer();
 
   ScopedGestureRecognizerSetter gr_setter(gesture_recognizer);
 
   ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
-                        kTouchId, tes.Now());
+                        kTouchId, base::TimeTicks::Now() - base::TimeTicks());
   DispatchEventUsingWindowDispatcher(&press1);
   EXPECT_TRUE(delegate->tap_down());
   EXPECT_TRUE(delegate->begin());
   EXPECT_FALSE(delegate->tap_cancel());
 
   // We haven't pressed long enough for a long press to occur
   EXPECT_FALSE(delegate->long_press());
 
   // Wait until the timer runs out
   delegate->WaitUntilReceivedGesture(ui::ET_GESTURE_LONG_PRESS);
   EXPECT_TRUE(delegate->long_press());
   EXPECT_FALSE(delegate->tap_cancel());
 
   delegate->Reset();
   ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
-                          kTouchId, tes.Now());
+                          kTouchId, base::TimeTicks::Now() - base::TimeTicks());
   DispatchEventUsingWindowDispatcher(&release1);
   EXPECT_FALSE(delegate->long_press());
   EXPECT_TRUE(delegate->long_tap());
 
-  // Note the tap down isn't cancelled until the release
+  // Note the tap cancel isn't dispatched until the release
   EXPECT_TRUE(delegate->tap_cancel());
+  EXPECT_FALSE(delegate->tap());
+

[sadrul, 2014/04/25 13:44:12]

Remove blank line

[tdresser, 2014/04/25 16:46:34]

Done.

 }
 
 // Check that second tap cancels a long press
-TEST_F(GestureRecognizerTest, GestureEventLongPressCancelledBySecondTap) {
+TEST_P(GestureRecognizerTest, GestureEventLongPressCancelledBySecondTap) {
+  // TODO(tdresser): enable this test with unified GR once two finger tap is
+  // supported. See crbug.com/354396.
+  if (UsingUnifiedGR())
+    return;
+
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   TimedEvents tes;
   ui::GestureConfiguration::set_long_press_time_in_seconds(.01);
   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(
@@ skipping 36 matching lines @@
   ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
                           kTouchId1, tes.Now());
   DispatchEventUsingWindowDispatcher(&release1);
   EXPECT_FALSE(delegate->long_press());
   EXPECT_TRUE(delegate->two_finger_tap());
   EXPECT_FALSE(delegate->tap_cancel());
 }
 
 // Check that horizontal scroll gestures cause scrolls on horizontal rails.
 // Also tests that horizontal rails can be broken.
-TEST_F(GestureRecognizerTest, GestureEventHorizontalRailScroll) {
+TEST_P(GestureRecognizerTest, GestureEventHorizontalRailScroll) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   TimedEvents tes;
   const int kTouchId = 7;
   gfx::Rect bounds(0, 0, 1000, 1000);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
 
   ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0),
                        kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&press);
 
   // Get rid of touch slop.
   ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(5, 0),
                       kTouchId, tes.Now());
 
   DispatchEventUsingWindowDispatcher(&move);
   delegate->Reset();
 
   // Move the touch-point horizontally enough that it is considered a
   // horizontal scroll.
-  tes.SendScrollEvent(event_processor(), 25, 1, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_processor(), 25, 0, kTouchId, delegate.get());
   EXPECT_EQ(0, delegate->scroll_y());
   EXPECT_EQ(20, delegate->scroll_x());
 
   tes.SendScrollEvent(event_processor(), 30, 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
   tes.SendScrollEvents(event_processor(), 1, 1,
                        6, 100, kTouchId, 1,
                        ui::GestureConfiguration::points_buffered_for_velocity(),
                        delegate.get());
 
   tes.SendScrollEvent(event_processor(), 5, 0, kTouchId, delegate.get());
   tes.SendScrollEvent(event_processor(), 10, 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) {
+TEST_P(GestureRecognizerTest, GestureEventVerticalRailScroll) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   TimedEvents tes;
   const int kTouchId = 7;
   gfx::Rect bounds(0, 0, 1000, 1000);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
 
   ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0),
                        kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&press);
 
   // Get rid of touch slop.
   ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(0, 5),
                        kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&move);
   delegate->Reset();
 
   // Move the touch-point vertically enough that it is considered a
   // vertical scroll.
-  tes.SendScrollEvent(event_processor(), 1, 25, kTouchId, delegate.get());
+  tes.SendScrollEvent(event_processor(), 0, 25, kTouchId, delegate.get());
   EXPECT_EQ(0, delegate->scroll_x());
   EXPECT_EQ(20, delegate->scroll_y());
 
   tes.SendScrollEvent(event_processor(), 6, 30, 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());
   EXPECT_EQ(0, delegate->scroll_velocity_x());
 
   // Send enough information that a velocity can be calculated for the gesture,
   // and we can break the rail
   tes.SendScrollEvents(event_processor(), 1, 6,
                        100, 1, kTouchId, 1,
                        ui::GestureConfiguration::points_buffered_for_velocity(),
                        delegate.get());
 
   tes.SendScrollEvent(event_processor(), 0, 5, kTouchId, delegate.get());
   tes.SendScrollEvent(event_processor(), 5, 10, 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) {
+TEST_P(GestureRecognizerTest, GestureTapFollowedByScroll) {
   // We'll start by moving the touch point by (5, 5). We want all of that
   // distance to be consumed by the slop, so we set the slop radius to
   // sqrt(5 * 5 + 5 * 5).
   ui::GestureConfiguration::set_max_touch_move_in_pixels_for_click(
       sqrt(static_cast<double>(5 * 5 + 5 * 5)));
 
   // First, tap. Then, do a scroll using the same touch-id.
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   TimedEvents tes;
@@ skipping 35 matching lines @@
                         kTouchId, tes.LeapForward(1000));
   DispatchEventUsingWindowDispatcher(&press1);
   EXPECT_FALSE(delegate->tap());
   EXPECT_TRUE(delegate->tap_down());
   EXPECT_FALSE(delegate->tap_cancel());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
 
   // Get rid of touch slop.
-  ui::TouchEvent move_remove_slop(ui::ET_TOUCH_MOVED, gfx::Point(106, 206),
+  ui::TouchEvent move_remove_slop(ui::ET_TOUCH_MOVED, gfx::Point(116, 216),
                                   kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&move_remove_slop);
   EXPECT_TRUE(delegate->tap_cancel());
   EXPECT_TRUE(delegate->scroll_begin());
-  EXPECT_FALSE(delegate->scroll_update());
-  EXPECT_EQ(5, delegate->scroll_x_hint());
-  EXPECT_EQ(5, delegate->scroll_y_hint());
+  EXPECT_TRUE(delegate->scroll_update());

[sadrul, 2014/04/25 13:44:12]

This expectation change is because we changed the move-delta?

[tdresser, 2014/04/25 16:46:34]

Correct. Trying to get rid of the touch slop exactly (which is required in order
to get the scroll begin without the update) is impossible to do for both GRs.

To get both GR's working, we just overshoot the slop, which triggers both the
begin and the update.

+  EXPECT_EQ(15, delegate->scroll_x_hint());
+  EXPECT_EQ(15, delegate->scroll_y_hint());
 
   delegate->Reset();
 
   // Move the touch-point enough so that it is considered as a scroll. This
   // should generate both SCROLL_BEGIN and SCROLL_UPDATE gestures.
   // The first movement is diagonal, to ensure that we have a free scroll,
   // and not a rail scroll.
   delegate->Reset();
   ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(135, 235),
                       kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&move);
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
   EXPECT_FALSE(delegate->tap_cancel());
   EXPECT_FALSE(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(19, delegate->scroll_x());
+  EXPECT_EQ(19, delegate->scroll_y());
 
   // Move some more to generate a few more scroll updates.
   delegate->Reset();
   ui::TouchEvent move1(ui::ET_TOUCH_MOVED, gfx::Point(115, 216),
                        kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&move1);
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
   EXPECT_FALSE(delegate->tap_cancel());
   EXPECT_FALSE(delegate->scroll_begin());
@@ skipping 24 matching lines @@
   DispatchEventUsingWindowDispatcher(&release1);
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
   EXPECT_FALSE(delegate->tap_cancel());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
   EXPECT_TRUE(delegate->fling());
 }
 
-TEST_F(GestureRecognizerTest, AsynchronousGestureRecognition) {
+TEST_P(GestureRecognizerTest, AsynchronousGestureRecognition) {
+  // TODO(tdresser): enable this test with unified GR once two finger tap is
+  // supported. See crbug.com/354396.
+  if (UsingUnifiedGR())
+    return;
   scoped_ptr<QueueTouchEventDelegate> queued_delegate(
       new QueueTouchEventDelegate(host()->dispatcher()));
   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, root_window()));
 
@@ skipping 171 matching lines @@
   EXPECT_FALSE(queued_delegate->end());
   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) {
+TEST_P(GestureRecognizerTest, GestureEventPinchFromScroll) {
+  // Disabled for unified GR due to differences in when pinch begin is sent. The
+  // Aura GR sends it earlier than is necessary.
+  if (UsingUnifiedGR())
+    return;
+
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   TimedEvents tes;
   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, root_window()));
@@ skipping 64 matching lines @@
 
   // Move the second finger. This should still generate a scroll.
   delegate->Reset();
   ui::TouchEvent move5(ui::ET_TOUCH_MOVED, gfx::Point(25, 10),
                        kTouchId2, tes.Now());
   DispatchEventUsingWindowDispatcher(&move5);
   EXPECT_1_EVENT(delegate->events(), ui::ET_GESTURE_SCROLL_UPDATE);
   EXPECT_TRUE(delegate->bounding_box().IsEmpty());
 }
 
-TEST_F(GestureRecognizerTest, GestureEventPinchFromScrollFromPinch) {
+TEST_P(GestureRecognizerTest, GestureEventPinchFromScrollFromPinch) {
 scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   TimedEvents tes;
   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, root_window()));
@@ skipping 27 matching lines @@
   tes.SendScrollEvent(event_processor(), 130, 230, kTouchId2, delegate.get());
   EXPECT_TRUE(delegate->scroll_update());
 
   // Pinch again
   delegate->Reset();
   ui::TouchEvent press3(ui::ET_TOUCH_PRESSED, gfx::Point(10, 10),
                         kTouchId1, tes.Now());
   DispatchEventUsingWindowDispatcher(&press3);
   // Now the touch points are close. So we will go into two finger tap.
   // Move the touch-point enough to break two-finger-tap and enter pinch.
-  ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::Point(101, 202),
+  ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::Point(101, 50),
                        kTouchId1, tes.Now());
   DispatchEventUsingWindowDispatcher(&move2);
   EXPECT_TRUE(delegate->pinch_begin());
 
-  tes.SendScrollEvent(event_processor(), 130, 230, kTouchId1, delegate.get());
+  tes.SendScrollEvent(event_processor(), 230, 280, kTouchId1, delegate.get());
   EXPECT_TRUE(delegate->pinch_update());
 }
 
-TEST_F(GestureRecognizerTest, GestureEventPinchFromTap) {
+TEST_P(GestureRecognizerTest, GestureEventPinchFromTap) {
+  // TODO(tdresser): enable this test with unified GR once two finger tap.
+  if (UsingUnifiedGR())
+    return;
+
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   TimedEvents tes;
   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, root_window()));
@@ skipping 53 matching lines @@
 
   // Move the second finger. This should still generate a scroll.
   delegate->Reset();
   ui::TouchEvent move5(ui::ET_TOUCH_MOVED, gfx::Point(25, 10),
                        kTouchId2, tes.Now());
   DispatchEventUsingWindowDispatcher(&move5);
   EXPECT_1_EVENT(delegate->events(), ui::ET_GESTURE_SCROLL_UPDATE);
   EXPECT_TRUE(delegate->bounding_box().IsEmpty());
 }
 
-TEST_F(GestureRecognizerTest, GestureEventIgnoresDisconnectedEvents) {
+TEST_P(GestureRecognizerTest, GestureEventIgnoresDisconnectedEvents) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   TimedEvents tes;
 
   ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
                           6, tes.Now());
   DispatchEventUsingWindowDispatcher(&release1);
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
 }
 
 // Check that a touch is locked to the window of the closest current touch
 // within max_separation_for_gesture_touches_in_pixels
-TEST_F(GestureRecognizerTest, GestureEventTouchLockSelectsCorrectWindow) {
+TEST_P(GestureRecognizerTest, GestureEventTouchLockSelectsCorrectWindow) {
   ui::GestureRecognizer* gesture_recognizer = new ui::GestureRecognizerImpl();
   TimedEvents tes;
   ScopedGestureRecognizerSetter gr_setter(gesture_recognizer);
 
   ui::GestureConsumer* target;
   const int kNumWindows = 4;
 
   scoped_ptr<GestureEventConsumeDelegate*[]> delegates(
       new GestureEventConsumeDelegate*[kNumWindows]);
 
@@ skipping 65 matching lines @@
 
   for (int i = 0; i < kNumWindows; ++i) {
     // Delete windows before deleting delegates.
     delete windows[i];
     delete delegates[i];
   }
 }
 
 // Check that a touch's target will not be effected by a touch on a different
 // screen.
-TEST_F(GestureRecognizerTest, GestureEventTouchLockIgnoresOtherScreens) {
+TEST_P(GestureRecognizerTest, GestureEventTouchLockIgnoresOtherScreens) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   gfx::Rect bounds(0, 0, 10, 10);
   scoped_ptr<aura::Window> window(
       CreateTestWindowWithDelegate(delegate.get(), 0, bounds, root_window()));
 
   const int kTouchId1 = 8;
   const int kTouchId2 = 2;
   TimedEvents tes;
 
   ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(5, 5),
                         kTouchId1, tes.Now());
   press1.set_source_device_id(1);
   DispatchEventUsingWindowDispatcher(&press1);
 
   ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(20, 20),
                         kTouchId2, tes.Now());
   press2.set_source_device_id(2);
   DispatchEventUsingWindowDispatcher(&press2);
 
   // The second press should not have been locked to the same target as the
   // first, as they occured on different displays.
   EXPECT_NE(
       ui::GestureRecognizer::Get()->GetTouchLockedTarget(press1),
       ui::GestureRecognizer::Get()->GetTouchLockedTarget(press2));
 }
 
 // Check that touch events outside the root window are still handled
 // by the root window's gesture sequence.
-TEST_F(GestureRecognizerTest, GestureEventOutsideRootWindowTap) {
+TEST_P(GestureRecognizerTest, GestureEventOutsideRootWindowTap) {
+  // TODO(tdresser): write a version of this test for the unified GR.
+  if (UsingUnifiedGR())
+    return;
+
   TestGestureRecognizer* gesture_recognizer =
       new TestGestureRecognizer();
   TimedEvents tes;
   ScopedGestureRecognizerSetter gr_setter(gesture_recognizer);
 
   scoped_ptr<aura::Window> window(CreateTestWindowWithBounds(
       gfx::Rect(-100, -100, 2000, 2000), root_window()));
 
   ui::GestureSequence* window_gesture_sequence =
       gesture_recognizer->GetGestureSequenceForTesting(window.get());
 
   ui::GestureSequence* root_window_gesture_sequence =
       gesture_recognizer->GetGestureSequenceForTesting(root_window());
 
   gfx::Point pos1(-10, -10);
   ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, pos1, 0, tes.Now());
   DispatchEventUsingWindowDispatcher(&press1);
 
   gfx::Point pos2(1000, 1000);
   ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, pos2, 1, tes.Now());
   DispatchEventUsingWindowDispatcher(&press2);
 
   // As these presses were outside the root window, they should be
   // associated with the root window.
   EXPECT_EQ(0, window_gesture_sequence->point_count());
   EXPECT_EQ(2, root_window_gesture_sequence->point_count());
 }
 
-TEST_F(GestureRecognizerTest, NoTapWithPreventDefaultedRelease) {
+TEST_P(GestureRecognizerTest, NoTapWithPreventDefaultedRelease) {
   scoped_ptr<QueueTouchEventDelegate> delegate(
       new QueueTouchEventDelegate(host()->dispatcher()));
   TimedEvents tes;
   const int kTouchId = 2;
   gfx::Rect bounds(100, 200, 100, 100);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
   delegate->set_window(window.get());
 
   delegate->Reset();
   ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
                        kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&press);
   ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
                          kTouchId, tes.LeapForward(50));
   DispatchEventUsingWindowDispatcher(&release);
 
   delegate->Reset();
   delegate->ReceivedAck();
   EXPECT_TRUE(delegate->tap_down());
   delegate->Reset();
   delegate->ReceivedAckPreventDefaulted();
   EXPECT_FALSE(delegate->tap());
   EXPECT_TRUE(delegate->tap_cancel());
 }
 
-TEST_F(GestureRecognizerTest, PinchScrollWithPreventDefaultedRelease) {
+TEST_P(GestureRecognizerTest, PinchScrollWithPreventDefaultedRelease) {
+  // Disabled for unified GR due to differences in when pinch begin is sent. The
+  // Aura GR sends it earlier than is necessary.
+  if (UsingUnifiedGR())
+    return;
+
   scoped_ptr<QueueTouchEventDelegate> delegate(
       new QueueTouchEventDelegate(host()->dispatcher()));
   TimedEvents tes;
   const int kTouchId1 = 7;
   const int kTouchId2 = 5;
   gfx::Rect bounds(10, 20, 100, 100);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
   delegate->set_window(window.get());
 
@@ skipping 73 matching lines @@
   delegate->ReceivedAckPreventDefaulted();
   EXPECT_TRUE(delegate->pinch_end());
   EXPECT_TRUE(delegate->end());
 
   delegate->Reset();
   delegate->ReceivedAckPreventDefaulted();
   EXPECT_TRUE(delegate->scroll_end());
   EXPECT_TRUE(delegate->end());
 }
 
-TEST_F(GestureRecognizerTest, GestureEndLocation) {
+TEST_P(GestureRecognizerTest, GestureEndLocation) {
   GestureEventConsumeDelegate delegate;
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       &delegate, -1234, gfx::Rect(10, 10, 300, 300), root_window()));
   EventGenerator generator(root_window(), window.get());
   const gfx::Point begin(20, 20);
   const gfx::Point end(150, 150);
   const gfx::Vector2d window_offset =
       window->bounds().origin().OffsetFromOrigin();
   generator.GestureScrollSequence(begin, end,
                                   base::TimeDelta::FromMilliseconds(20),
                                   10);
   EXPECT_EQ((begin - window_offset).ToString(),
             delegate.scroll_begin_position().ToString());
   EXPECT_EQ((end - window_offset).ToString(),
             delegate.gesture_end_location().ToString());
 }
 
-TEST_F(GestureRecognizerTest, CaptureSendsGestureEnd) {
+TEST_P(GestureRecognizerTest, CaptureSendsGestureEnd) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   TestGestureRecognizer* gesture_recognizer =
       new TestGestureRecognizer();
   ScopedGestureRecognizerSetter gr_setter(gesture_recognizer);
 
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, gfx::Rect(10, 10, 300, 300), root_window()));
   EventGenerator generator(root_window());
 
   generator.MoveMouseRelativeTo(window.get(), gfx::Point(10, 10));
   generator.PressTouch();
   RunAllPendingInMessageLoop();
 
   EXPECT_TRUE(delegate->tap_down());
 
   scoped_ptr<aura::Window> capture(CreateTestWindowWithBounds(
       gfx::Rect(10, 10, 200, 200), root_window()));
   capture->SetCapture();
   RunAllPendingInMessageLoop();
 
   EXPECT_TRUE(delegate->end());
   EXPECT_TRUE(delegate->tap_cancel());
 }
 
 // Check that previous touch actions that are completely finished (either
 // released or cancelled), do not receive extra synthetic cancels upon change of
 // capture.
-TEST_F(GestureRecognizerTest, CaptureDoesNotCancelFinishedTouches) {
+TEST_P(GestureRecognizerTest, CaptureDoesNotCancelFinishedTouches) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   scoped_ptr<TestEventHandler> handler(new TestEventHandler);
   root_window()->AddPreTargetHandler(handler.get());
 
   // Create a window and set it as the capture window.
   scoped_ptr<aura::Window> window1(CreateTestWindowWithDelegate(delegate.get(),
       -1234, gfx::Rect(10, 10, 300, 300), root_window()));
   window1->SetCapture();
 
@@ skipping 32 matching lines @@
       gfx::Rect(100, 100, 300, 300), root_window()));
   window2->SetCapture();
   RunAllPendingInMessageLoop();
   // Check that setting capture does not generate any synthetic touch-cancels
   // for the two previously finished touch actions.
   EXPECT_EQ(1, handler->touch_cancelled_count());
 
   root_window()->RemovePreTargetHandler(handler.get());
 }
 
-TEST_F(GestureRecognizerTest, PressDoesNotCrash) {
+// Tests that a press with the same touch id as an existing touch is ignored.
+TEST_P(GestureRecognizerTest, PressDoesNotCrash) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   TestGestureRecognizer* gesture_recognizer =
       new TestGestureRecognizer();
   ScopedGestureRecognizerSetter gr_setter(gesture_recognizer);
   TimedEvents tes;
 
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, gfx::Rect(10, 10, 300, 300), root_window()));
 
   ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(45, 45), 7, tes.Now());
   press.set_radius_x(40);
   DispatchEventUsingWindowDispatcher(&press);
   EXPECT_TRUE(delegate->tap_down());
   EXPECT_EQ(gfx::Rect(5, 5, 80, 80).ToString(),
             delegate->bounding_box().ToString());
   delegate->Reset();
 
   ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(55, 45), 7, tes.Now());
   DispatchEventUsingWindowDispatcher(&press2);
 
   // This new press should not generate a tap-down.
   EXPECT_FALSE(delegate->begin());
   EXPECT_FALSE(delegate->tap_down());
   EXPECT_FALSE(delegate->tap_cancel());
   EXPECT_FALSE(delegate->scroll_begin());
 }
 
-TEST_F(GestureRecognizerTest, TwoFingerTap) {
+TEST_P(GestureRecognizerTest, TwoFingerTap) {
+  // TODO(tdresser): enable this test with unified GR once two finger tap is
+  // supported. See crbug.com/354396.
+  if (UsingUnifiedGR())
+    return;
+
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   const int kWindowWidth = 123;
   const int kWindowHeight = 45;
   const int kTouchId1 = 2;
   const int kTouchId2 = 3;
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
   TimedEvents tes;
@@ skipping 67 matching lines @@
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
   EXPECT_FALSE(delegate->tap_cancel());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
   EXPECT_TRUE(delegate->fling());
   EXPECT_FALSE(delegate->two_finger_tap());
 }
 
-TEST_F(GestureRecognizerTest, TwoFingerTapExpired) {
+TEST_P(GestureRecognizerTest, TwoFingerTapExpired) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   const int kWindowWidth = 123;
   const int kWindowHeight = 45;
   const int kTouchId1 = 2;
   const int kTouchId2 = 3;
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
   TimedEvents tes;
@@ skipping 20 matching lines @@
   // Make sure there is enough delay before the touch is released so that it is
   // recognized as a tap.
   delegate->Reset();
   ui::TouchEvent release2(ui::ET_TOUCH_RELEASED, gfx::Point(130, 201),
                           kTouchId2, tes.LeapForward(50));
 
   DispatchEventUsingWindowDispatcher(&release2);
   EXPECT_FALSE(delegate->two_finger_tap());
 }
 
-TEST_F(GestureRecognizerTest, TwoFingerTapChangesToPinch) {
+TEST_P(GestureRecognizerTest, TwoFingerTapChangesToPinch) {
+  // TODO(tdresser): enable this test with unified GR once two finger tap is
+  // supported. See crbug.com/354396.
+  if (UsingUnifiedGR())
+    return;
+
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   const int kWindowWidth = 123;
   const int kWindowHeight = 45;
   const int kTouchId1 = 2;
   const int kTouchId2 = 3;
   TimedEvents tes;
 
   // Test moving first finger
   {
@@ skipping 51 matching lines @@
     delegate->Reset();
     ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
                            kTouchId1, tes.LeapForward(50));
 
     DispatchEventUsingWindowDispatcher(&release);
     EXPECT_FALSE(delegate->two_finger_tap());
     EXPECT_TRUE(delegate->pinch_end());
   }
 }
 
-TEST_F(GestureRecognizerTest, NoTwoFingerTapWhenFirstFingerHasScrolled) {
+TEST_P(GestureRecognizerTest, NoTwoFingerTapWhenFirstFingerHasScrolled) {
+  // Disabled for unified GR due to differences in when pinch begin is sent. The
+  // Aura GR sends it earlier than is necessary.
+  if (UsingUnifiedGR())
+    return;
+
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   const int kWindowWidth = 123;
   const int kWindowHeight = 45;
   const int kTouchId1 = 2;
   const int kTouchId2 = 3;
   TimedEvents tes;
 
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
@@ skipping 16 matching lines @@
   // is recognized as a tap.
   delegate->Reset();
   ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
                          kTouchId2, tes.LeapForward(50));
 
   DispatchEventUsingWindowDispatcher(&release);
   EXPECT_FALSE(delegate->two_finger_tap());
   EXPECT_TRUE(delegate->pinch_end());
 }
 
-TEST_F(GestureRecognizerTest, MultiFingerSwipe) {
+TEST_P(GestureRecognizerTest, MultiFingerSwipe) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   const int kWindowWidth = 123;
   const int kWindowHeight = 45;
 
   gfx::Rect bounds(5, 10, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
 
   const int kSteps = 15;
@@ skipping 23 matching lines @@
     EXPECT_TRUE(delegate->swipe_left());
     delegate->Reset();
 
     generator.GestureMultiFingerScroll(
         count, points, 1000, kSteps, 11 * kSteps, 0);
     EXPECT_TRUE(delegate->swipe_right());
     delegate->Reset();
   }
 }
 
-TEST_F(GestureRecognizerTest, TwoFingerTapCancelled) {
+TEST_P(GestureRecognizerTest, TwoFingerTapCancelled) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   const int kWindowWidth = 123;
   const int kWindowHeight = 45;
   const int kTouchId1 = 2;
   const int kTouchId2 = 3;
   TimedEvents tes;
 
   // Test canceling first finger.
   {
@@ skipping 53 matching lines @@
     // is recognized as a tap.
     delegate->Reset();
     ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
                            kTouchId1, tes.LeapForward(50));
 
     DispatchEventUsingWindowDispatcher(&release);
     EXPECT_FALSE(delegate->two_finger_tap());
   }
 }
 
-TEST_F(GestureRecognizerTest, VeryWideTwoFingerTouchDownShouldBeAPinch) {
+TEST_P(GestureRecognizerTest, VeryWideTwoFingerTouchDownShouldBeAPinch) {
+  // Disabled for unified GR due to differences in when scroll update is
+  // sent. The Aura GR will never send a ScrollUpdate with a ScrollBegin, but
+  // the unified GR will.
+  if (UsingUnifiedGR())
+    return;
+
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   const int kWindowWidth = 523;
   const int kWindowHeight = 45;
   const int kTouchId1 = 2;
   const int kTouchId2 = 3;
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
   TimedEvents tes;
@@ skipping 36 matching lines @@
   EXPECT_TRUE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
   EXPECT_FALSE(delegate->long_press());
   EXPECT_FALSE(delegate->two_finger_tap());
   EXPECT_TRUE(delegate->pinch_begin());
 }
 
 // Verifies if a window is the target of multiple touch-ids and we hide the
 // window everything is cleaned up correctly.
-TEST_F(GestureRecognizerTest, FlushAllOnHide) {
+TEST_P(GestureRecognizerTest, FlushAllOnHide) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   gfx::Rect bounds(0, 0, 200, 200);
   scoped_ptr<aura::Window> window(
       CreateTestWindowWithDelegate(delegate.get(), 0, bounds, root_window()));
   const int kTouchId1 = 8;
   const int kTouchId2 = 2;
   TimedEvents tes;
 
   ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(10, 10),
                         kTouchId1, tes.Now());
   DispatchEventUsingWindowDispatcher(&press1);
   ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(20, 20),
                         kTouchId2, tes.Now());
   DispatchEventUsingWindowDispatcher(&press2);
   window->Hide();
   EXPECT_EQ(NULL,
       ui::GestureRecognizer::Get()->GetTouchLockedTarget(press1));
   EXPECT_EQ(NULL,
       ui::GestureRecognizer::Get()->GetTouchLockedTarget(press2));
 }
 
-TEST_F(GestureRecognizerTest, LongPressTimerStopsOnPreventDefaultedTouchMoves) {
+TEST_P(GestureRecognizerTest, LongPressTimerStopsOnPreventDefaultedTouchMoves) {
+  // TODO(tdresser): write a version of this test for the unified GR.
+  if (UsingUnifiedGR())
+    return;
+
   scoped_ptr<QueueTouchEventDelegate> delegate(
       new QueueTouchEventDelegate(host()->dispatcher()));
   const int kTouchId = 2;
   gfx::Rect bounds(100, 200, 100, 100);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
   delegate->set_window(window.get());
   TimedEvents tes;
 
   TimerTestGestureRecognizer* gesture_recognizer =
@@ skipping 39 matching lines @@
       GestureEventConsumeDelegate::OnTouchEvent(touch);
   }
 
   bool consume_touch_move_;
 
   DISALLOW_COPY_AND_ASSIGN(ConsumesTouchMovesDelegate);
 };
 
 // Same as GestureEventScroll, but tests that the behavior is the same
 // even if all the touch-move events are consumed.
-TEST_F(GestureRecognizerTest, GestureEventScrollTouchMoveConsumed) {
+TEST_P(GestureRecognizerTest, GestureEventScrollTouchMoveConsumed) {
   scoped_ptr<ConsumesTouchMovesDelegate> delegate(
       new ConsumesTouchMovesDelegate());
   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, root_window()));
   TimedEvents tes;
 
@@ skipping 31 matching lines @@
   EXPECT_FALSE(delegate->tap_down());
   EXPECT_FALSE(delegate->tap_cancel());
   EXPECT_FALSE(delegate->begin());
   EXPECT_TRUE(delegate->end());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
 }
 
 // Tests the behavior of 2F scroll when all the touch-move events are consumed.
-TEST_F(GestureRecognizerTest, GestureEventScrollTwoFingerTouchMoveConsumed) {
+TEST_P(GestureRecognizerTest, GestureEventScrollTwoFingerTouchMoveConsumed) {
+  // TODO(tdresser): enable this test with unified GR once two finger tap is
+  // supported. See crbug.com/354396.
+  if (UsingUnifiedGR())
+    return;
+
   scoped_ptr<ConsumesTouchMovesDelegate> delegate(
       new ConsumesTouchMovesDelegate());
   const int kWindowWidth = 123;
   const int kWindowHeight = 100;
   const int kTouchId1 = 2;
   const int kTouchId2 = 3;
   TimedEvents tes;
 
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
@@ skipping 86 matching lines @@
   EXPECT_TRUE(delegate->fling());
 
   EXPECT_FALSE(delegate->pinch_begin());
   EXPECT_FALSE(delegate->pinch_update());
   EXPECT_FALSE(delegate->pinch_end());
 }
 
 // Like as GestureEventTouchMoveConsumed but tests the different behavior
 // depending on whether the events were consumed before or after the scroll
 // started.
-TEST_F(GestureRecognizerTest, GestureEventScrollTouchMovePartialConsumed) {
+TEST_P(GestureRecognizerTest, GestureEventScrollTouchMovePartialConsumed) {
   scoped_ptr<ConsumesTouchMovesDelegate> delegate(
       new ConsumesTouchMovesDelegate());
   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, root_window()));
   TimedEvents tes;
 
@@ skipping 73 matching lines @@
   EXPECT_FALSE(delegate->tap_cancel());
   EXPECT_FALSE(delegate->begin());
   EXPECT_TRUE(delegate->end());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
   EXPECT_FALSE(delegate->fling());
 }
 
 // Check that appropriate touch events generate double tap gesture events.
-TEST_F(GestureRecognizerTest, GestureEventDoubleTap) {
+TEST_P(GestureRecognizerTest, GestureEventDoubleTap) {
+  // TODO(tdresser): enable this test with unified GR once double / triple tap
+  // gestures work. See crbug.com/357270.
+  if (UsingUnifiedGR())
+    return;
+
   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, root_window()));
   TimedEvents tes;
 
@@ skipping 20 matching lines @@
   EXPECT_TRUE(delegate->begin());
   EXPECT_TRUE(delegate->end());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
 
   EXPECT_EQ(2, delegate->tap_count());
 }
 
 // Check that appropriate touch events generate triple tap gesture events.
-TEST_F(GestureRecognizerTest, GestureEventTripleTap) {
+TEST_P(GestureRecognizerTest, GestureEventTripleTap) {
+  // TODO(tdresser): enable this test with unified GR once double / triple tap
+  // gestures work. See crbug.com/357270.
+  if (UsingUnifiedGR())
+    return;
+
   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, root_window()));
   TimedEvents tes;
 
@@ skipping 34 matching lines @@
   EXPECT_TRUE(delegate->begin());
   EXPECT_TRUE(delegate->end());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
 
   EXPECT_EQ(3, delegate->tap_count());
 }
 
 // Check that we don't get a double tap when the two taps are far apart.
-TEST_F(GestureRecognizerTest, TwoTapsFarApart) {
+TEST_P(GestureRecognizerTest, TwoTapsFarApart) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   const int kWindowWidth = 123;
   const int kWindowHeight = 45;
   const int kTouchId = 2;
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
   TimedEvents tes;
 
@@ skipping 21 matching lines @@
   EXPECT_TRUE(delegate->end());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
 
   EXPECT_EQ(1, delegate->tap_count());
 }
 
 // Check that we don't get a double tap when the two taps have a long enough
 // delay in between.
-TEST_F(GestureRecognizerTest, TwoTapsWithDelayBetween) {
+TEST_P(GestureRecognizerTest, TwoTapsWithDelayBetween) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   const int kWindowWidth = 123;
   const int kWindowHeight = 45;
   const int kTouchId = 2;
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
   TimedEvents tes;
 
@@ skipping 22 matching lines @@
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
 
   EXPECT_EQ(1, delegate->tap_count());
 }
 
 // Checks that if the bounding-box of a gesture changes because of change in
 // radius of a touch-point, and not because of change in position, then there
 // are not gesture events from that.
-TEST_F(GestureRecognizerTest, BoundingBoxRadiusChange) {
+TEST_P(GestureRecognizerTest, BoundingBoxRadiusChange) {
+  // TODO(tdresser): enable this test with unified GR when (if?) bounding box
+  // behavior is unified.
+  if (UsingUnifiedGR())
+    return;
+
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   const int kWindowWidth = 234;
   const int kWindowHeight = 345;
   const int kTouchId = 5, kTouchId2 = 7;
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
   TimedEvents tes;
 
@@ skipping 33 matching lines @@
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_cancel());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->pinch_update());
 
   delegate->Reset();
 }
 
 // Checks that slow scrolls deliver the correct deltas.
 // In particular, fix for http;//crbug.com/150573.
-TEST_F(GestureRecognizerTest, NoDriftInScroll) {
+TEST_P(GestureRecognizerTest, NoDriftInScroll) {
   ui::GestureConfiguration::set_max_touch_move_in_pixels_for_click(3);
   ui::GestureConfiguration::set_min_scroll_delta_squared(9);
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   const int kWindowWidth = 234;
   const int kWindowHeight = 345;
   const int kTouchId = 5;
   TimedEvents tes;
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
@@ skipping 37 matching lines @@
   DispatchEventUsingWindowDispatcher(&move4);
   EXPECT_TRUE(delegate->scroll_update());
   EXPECT_EQ(-1, delegate->scroll_y());
 
   delegate->Reset();
 }
 
 // Ensure that move events which are preventDefaulted will cause a tap
 // cancel gesture event to be fired if the move would normally cause a
 // scroll. See bug http://crbug.com/146397.
-TEST_F(GestureRecognizerTest, GestureEventConsumedTouchMoveCanFireTapCancel) {
+TEST_P(GestureRecognizerTest, GestureEventConsumedTouchMoveCanFireTapCancel) {
   scoped_ptr<ConsumesTouchMovesDelegate> delegate(
       new ConsumesTouchMovesDelegate());
   const int kTouchId = 5;
   gfx::Rect bounds(100, 200, 123, 45);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
   TimedEvents tes;
 
   delegate->Reset();
   ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
                        kTouchId, tes.Now());
 
   delegate->set_consume_touch_move(false);
   DispatchEventUsingWindowDispatcher(&press);
   delegate->set_consume_touch_move(true);
   delegate->Reset();
   // Move the touch-point enough so that it would normally be considered a
   // scroll. But since the touch-moves will be consumed, the scroll should not
   // start.
   tes.SendScrollEvent(event_processor(), 130, 230, kTouchId, delegate.get());
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
   EXPECT_TRUE(delegate->tap_cancel());
   EXPECT_FALSE(delegate->begin());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
 }
 
-TEST_F(GestureRecognizerTest,
+TEST_P(GestureRecognizerTest,
        TransferEventDispatchesTouchCancel) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   TimedEvents tes;
   const int kWindowWidth = 800;
   const int kWindowHeight = 600;
   const int kTouchId = 2;
   gfx::Rect bounds(0, 0, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
@@ skipping 22 matching lines @@
             gesture_recognizer->GetTouchLockedTarget(press));
   gesture_recognizer->TransferEventsTo(window.get(), NULL);
   EXPECT_EQ(NULL,
             gesture_recognizer->GetTouchLockedTarget(press));
   // The event-handler removes |window| from its parent on the first
   // touch-cancel event, so it won't receive the second touch-cancel event.
   EXPECT_EQ(1, handler->touch_cancelled_count());
 }
 
 // Check that appropriate touch events generate show press events
-TEST_F(GestureRecognizerTest, GestureEventShowPress) {
+TEST_P(GestureRecognizerTest, GestureEventShowPress) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   TimedEvents tes;
   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, root_window()));
 
@@ skipping 18 matching lines @@
   delegate->WaitUntilReceivedGesture(ui::ET_GESTURE_SHOW_PRESS);
   EXPECT_TRUE(delegate->show_press());
   EXPECT_FALSE(delegate->tap_cancel());
 
   delegate->Reset();
   ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
                           kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&release1);
   EXPECT_FALSE(delegate->long_press());
 
-  // Note the tap down isn't cancelled until the release
-  EXPECT_TRUE(delegate->tap_cancel());
+  // Note the tap isn't dispatched until the release
+  EXPECT_FALSE(delegate->tap_cancel());
+  EXPECT_TRUE(delegate->tap());
 }
 
 // Check that scrolling cancels a show press
-TEST_F(GestureRecognizerTest, GestureEventShowPressCancelledByScroll) {
+TEST_P(GestureRecognizerTest, GestureEventShowPressCancelledByScroll) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   TimedEvents tes;
   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, root_window()));
 
@@ skipping 26 matching lines @@
 
   delegate->Reset();
   ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
                           kTouchId, tes.LeapForward(10));
   DispatchEventUsingWindowDispatcher(&release1);
   EXPECT_FALSE(delegate->show_press());
   EXPECT_FALSE(delegate->tap_cancel());
 }
 
 // Test that show press events are sent immediately on tap
-TEST_F(GestureRecognizerTest, GestureEventShowPressSentOnTap) {
+TEST_P(GestureRecognizerTest, GestureEventShowPressSentOnTap) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   TimedEvents tes;
   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, root_window()));
 
@@ skipping 11 matching lines @@
   delegate->Reset();
   ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
                           kTouchId, tes.LeapForward(50));
   DispatchEventUsingWindowDispatcher(&release1);
   EXPECT_TRUE(delegate->show_press());
   EXPECT_FALSE(delegate->tap_cancel());
   EXPECT_TRUE(delegate->tap());
 }
 
 // Test that consuming the first move touch event prevents a scroll.
-TEST_F(GestureRecognizerTest, GestureEventConsumedTouchMoveScrollTest) {
+TEST_P(GestureRecognizerTest, GestureEventConsumedTouchMoveScrollTest) {
   scoped_ptr<QueueTouchEventDelegate> delegate(
       new QueueTouchEventDelegate(host()->dispatcher()));
   TimedEvents tes;
   const int kTouchId = 7;
   gfx::Rect bounds(0, 0, 1000, 1000);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
 
   ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0),
                        kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&press);
   delegate->ReceivedAck();
 
-  ui::TouchEvent move1(ui::ET_TOUCH_MOVED, gfx::Point(2, 2),
+  // A touch move within the slop region is never consumed in web contents. The
+  // unified GR won't prevent scroll if a touch move within the slop region is
+  // consumed, so make sure this touch move exceeds the slop region.
+  ui::TouchEvent move1(ui::ET_TOUCH_MOVED, gfx::Point(10, 10),
                        kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&move1);
   delegate->ReceivedAckPreventDefaulted();
 
   ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::Point(20, 20),
                        kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&move2);
   delegate->ReceivedAck();
 
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
 }
 
 // Test that consuming the first touch move event of a touch point doesn't
 // prevent pinching once an additional touch has been pressed.
-TEST_F(GestureRecognizerTest, GestureEventConsumedTouchMovePinchTest) {
+TEST_P(GestureRecognizerTest, GestureEventConsumedTouchMovePinchTest) {
+  // Consuming moves within the touch slop and the the disposition handling of
+  // pinch events behave differently between the Unified GR and the Aura GR.
+  if (UsingUnifiedGR())
+    return;
+
   scoped_ptr<QueueTouchEventDelegate> delegate(
       new QueueTouchEventDelegate(host()->dispatcher()));
   TimedEvents tes;
   const int kTouchId1 = 7;
   const int kTouchId2 = 4;
   gfx::Rect bounds(0, 0, 1000, 1000);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
 
   ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0),
@@ skipping 36 matching lines @@
                        kTouchId2, tes.Now());
   DispatchEventUsingWindowDispatcher(&move4);
   delegate->ReceivedAck();
 
   EXPECT_TRUE(delegate->pinch_update());
   EXPECT_EQ(10, delegate->scroll_x());
   EXPECT_EQ(10, delegate->scroll_y());
 }
 
 // Test that consuming the first move touch doesn't prevent a tap.
-TEST_F(GestureRecognizerTest, GestureEventConsumedTouchMoveTapTest) {
+TEST_P(GestureRecognizerTest, GestureEventConsumedTouchMoveTapTest) {
   scoped_ptr<QueueTouchEventDelegate> delegate(
       new QueueTouchEventDelegate(host()->dispatcher()));
   TimedEvents tes;
   const int kTouchId = 7;
   gfx::Rect bounds(0, 0, 1000, 1000);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
 
   ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0),
                        kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&press);
   delegate->ReceivedAck();
 
   ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(2, 2),
                        kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&move);
   delegate->ReceivedAckPreventDefaulted();
 
   ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(2, 2),
                          kTouchId, tes.LeapForward(50));
   DispatchEventUsingWindowDispatcher(&release);
   delegate->ReceivedAck();
 
   EXPECT_TRUE(delegate->tap());
 }
 
 // Test that consuming the first move touch doesn't prevent a long press.
-TEST_F(GestureRecognizerTest, GestureEventConsumedTouchMoveLongPressTest) {
+TEST_P(GestureRecognizerTest, GestureEventConsumedTouchMoveLongPressTest) {
   scoped_ptr<QueueTouchEventDelegate> delegate(
       new QueueTouchEventDelegate(host()->dispatcher()));
   TimedEvents tes;
   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, root_window()));
 
@@ skipping 13 matching lines @@
                        kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&move);
   delegate->ReceivedAckPreventDefaulted();
 
   // Wait until the timer runs out
   delegate->WaitUntilReceivedGesture(ui::ET_GESTURE_LONG_PRESS);
   EXPECT_TRUE(delegate->long_press());
 }
 
 // Tests that the deltas are correct when leaving the slop region very slowly.
-TEST_F(GestureRecognizerTest, TestExceedingSlopSlowly) {
+TEST_P(GestureRecognizerTest, TestExceedingSlopSlowly) {
+  // Disabled for unified GR due to subtle differences in touch slop handling.
+  if (UsingUnifiedGR())
+    return;
+
   ui::GestureConfiguration::set_max_touch_move_in_pixels_for_click(3);
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   const int kWindowWidth = 234;
   const int kWindowHeight = 345;
   const int kTouchId = 5;
   TimedEvents tes;
   gfx::Rect bounds(0, 0, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
@@ skipping 37 matching lines @@
   ui::TouchEvent move4(ui::ET_TOUCH_MOVED, gfx::Point(14, 10), kTouchId,
                        tes.LeapForward(40));
   DispatchEventUsingWindowDispatcher(&move4);
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_TRUE(delegate->scroll_update());
   EXPECT_EQ(1, delegate->scroll_x());
   EXPECT_EQ(0, delegate->scroll_x_hint());
   delegate->Reset();
 }
 
-TEST_F(GestureRecognizerTest, ScrollAlternatelyConsumedTest) {
+TEST_P(GestureRecognizerTest, ScrollAlternatelyConsumedTest) {
   scoped_ptr<QueueTouchEventDelegate> delegate(
       new QueueTouchEventDelegate(host()->dispatcher()));
   TimedEvents tes;
   const int kWindowWidth = 3000;
   const int kWindowHeight = 3000;
   const int kTouchId = 2;
   gfx::Rect bounds(0, 0, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
 
@@ skipping 38 matching lines @@
     ui::TouchEvent move3(
         ui::ET_TOUCH_MOVED, gfx::Point(x, y), kTouchId, tes.Now());
     DispatchEventUsingWindowDispatcher(&move3);
     delegate->ReceivedAckPreventDefaulted();
     EXPECT_FALSE(delegate->scroll_begin());
     EXPECT_FALSE(delegate->scroll_update());
     delegate->Reset();
   }
 }
 
-TEST_F(GestureRecognizerTest, PinchAlternatelyConsumedTest) {
+TEST_P(GestureRecognizerTest, PinchAlternatelyConsumedTest) {
+  // Disabled for unified GR due to differences in when scroll update is
+  // sent. The Aura GR will never send a ScrollUpdate with a ScrollBegin, but
+  // the unified GR will.
+  if (UsingUnifiedGR())
+    return;
+
   scoped_ptr<QueueTouchEventDelegate> delegate(
       new QueueTouchEventDelegate(host()->dispatcher()));
   TimedEvents tes;
   const int kWindowWidth = 3000;
   const int kWindowHeight = 3000;
   const int kTouchId1 = 5;
   const int kTouchId2 = 7;
   gfx::Rect bounds(0, 0, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
@@ skipping 63 matching lines @@
     EXPECT_FALSE(delegate->scroll_begin());
     EXPECT_FALSE(delegate->scroll_update());
     EXPECT_FALSE(delegate->scroll_end());
     EXPECT_FALSE(delegate->pinch_begin());
     EXPECT_FALSE(delegate->pinch_update());
     EXPECT_FALSE(delegate->pinch_end());
     delegate->Reset();
   }
 }
 
+// Test that touch event flags are passed through to the gesture event.
+TEST_P(GestureRecognizerTest, GestureEventFlagsPassedFromTouchEvent) {
+  scoped_ptr<GestureEventConsumeDelegate> delegate(
+      new GestureEventConsumeDelegate());
+  TimedEvents tes;
+  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, root_window()));
+
+  delegate->Reset();
+
+  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
+                        kTouchId, tes.Now());
+  DispatchEventUsingWindowDispatcher(&press1);
+  EXPECT_TRUE(delegate->tap_down());
+
+  int default_flags = delegate->flags();
+
+  ui::TouchEvent move1(
+      ui::ET_TOUCH_MOVED, gfx::Point(397, 149), kTouchId, tes.LeapForward(50));
+  move1.set_flags(992);
+
+  DispatchEventUsingWindowDispatcher(&move1);
+  EXPECT_NE(default_flags, delegate->flags());
+}
+
+INSTANTIATE_TEST_CASE_P(GestureRecognizer,
+                        GestureRecognizerTest,
+                        ::testing::Bool());
+
 }  // namespace test
 }  // namespace aura