Reland Unified Gesture Recognizer for Aura

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 664 matching lines @@
  public:
   GestureRecognizerTest() {}
 
   bool UsingUnifiedGR() {
     return GetParam();
   }
 
   virtual void SetUp() OVERRIDE {
     // TODO(tdresser): Once unified GR has landed, only run these tests once.
     if (UsingUnifiedGR()) {
-      // TODO(tdresser): use unified GR once it's available.
-      // CommandLine::ForCurrentProcess()->AppendSwitch(
-      //    switches::kUseUnifiedGestureDetector);
+      CommandLine::ForCurrentProcess()->AppendSwitch(
+          switches::kUseUnifiedGestureDetector);
     }
 
     AuraTestBase::SetUp();
   }
 
+  virtual void TearDown() OVERRIDE {
+    AuraTestBase::TearDown();
+    RunAllPendingInMessageLoop();
+  }
+
   DISALLOW_COPY_AND_ASSIGN(GestureRecognizerTest);
 };
 
 // Check that appropriate touch events generate tap gesture events.
 TEST_P(GestureRecognizerTest, GestureEventTap) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   TimedEvents tes;
   const int kWindowWidth = 123;
   const int kWindowHeight = 45;
@@ skipping 36 matching lines @@
   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_P(GestureRecognizerTest, GestureEventTapRegion) {
+  // TODO(tdresser): enable this test with unified GR once we resolve the
+  // bounding box differences. See crbug.com/366641.
+  if (UsingUnifiedGR())
+    return;
+
   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 695 matching lines @@
   EXPECT_FALSE(delegate->long_press());
   EXPECT_TRUE(delegate->long_tap());
 
   // Note the tap cancel isn't dispatched until the release
   EXPECT_TRUE(delegate->tap_cancel());
   EXPECT_FALSE(delegate->tap());
 }
 
 // Check that second tap cancels a long press
 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 262 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());
 }
 
 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 112 matching lines @@
   EXPECT_FALSE(queued_delegate->end());
   EXPECT_FALSE(queued_delegate->scroll_begin());
   EXPECT_FALSE(queued_delegate->scroll_update());
   EXPECT_FALSE(queued_delegate->scroll_end());
 
   // Move the second touch-point enough so that it is considered a pinch. This
   // should generate both SCROLL_BEGIN and PINCH_BEGIN gestures.
   queued_delegate->Reset();
   delegate->Reset();
   int x_move = ui::GestureConfiguration::max_touch_move_in_pixels_for_click();
-  ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(103 + x_move, 203),
+  ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(203 + x_move, 303),
                           kTouchId2, GetTime());
   DispatchEventUsingWindowDispatcher(&move);
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
   EXPECT_FALSE(delegate->tap_cancel());
   EXPECT_FALSE(delegate->begin());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
   EXPECT_FALSE(queued_delegate->tap());
@@ skipping 30 matching lines @@
   EXPECT_FALSE(queued_delegate->pinch_end());
 
   queued_delegate->Reset();
   queued_delegate->ReceivedAck();
   EXPECT_FALSE(queued_delegate->tap());
   EXPECT_FALSE(queued_delegate->tap_down());
   EXPECT_FALSE(queued_delegate->tap_cancel());
   EXPECT_FALSE(queued_delegate->begin());
   EXPECT_FALSE(queued_delegate->end());
   EXPECT_TRUE(queued_delegate->scroll_begin());
-  EXPECT_FALSE(queued_delegate->scroll_update());
+  // TODO(tdresser): uncomment once we've switched to the unified GR.
+  //  EXPECT_TRUE(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_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.
@@ skipping 766 matching lines @@
   // 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_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
   {
     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),
                           kTouchId1, tes.Now());
     DispatchEventUsingWindowDispatcher(&press1);
 
     delegate->Reset();
     ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(130, 201),
                           kTouchId2, tes.Now());
     DispatchEventUsingWindowDispatcher(&press2);
 
-    tes.SendScrollEvent(event_processor(), 130, 230, kTouchId1, delegate.get());
+    tes.SendScrollEvent(event_processor(), 230, 330, kTouchId1, delegate.get());
     EXPECT_FALSE(delegate->two_finger_tap());
     EXPECT_TRUE(delegate->pinch_begin());
 
     // Make sure there is enough delay before the touch is released so that it
     // is recognized as a tap.
     delegate->Reset();
     ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
                            kTouchId2, tes.LeapForward(50));
 
     DispatchEventUsingWindowDispatcher(&release);
@@ skipping 10 matching lines @@
     delegate->Reset();
     ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
                           kTouchId1, tes.Now());
     DispatchEventUsingWindowDispatcher(&press1);
 
     delegate->Reset();
     ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(130, 201),
                           kTouchId2, tes.Now());
     DispatchEventUsingWindowDispatcher(&press2);
 
-    tes.SendScrollEvent(event_processor(), 101, 230, kTouchId2, delegate.get());
+    tes.SendScrollEvent(event_processor(), 301, 230, kTouchId2, delegate.get());
     EXPECT_FALSE(delegate->two_finger_tap());
     EXPECT_TRUE(delegate->pinch_begin());
 
     // Make sure there is enough delay before the touch is released so that it
     // is recognized as a tap.
     delegate->Reset();
     ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
                            kTouchId1, tes.LeapForward(50));
 
     DispatchEventUsingWindowDispatcher(&release);
@@ skipping 1472 matching lines @@
   move1.set_flags(992);
 
   DispatchEventUsingWindowDispatcher(&move1);
   EXPECT_NE(default_flags, delegate->flags());
 }
 
 // TODO - re-enable these tests once memory management issues have been sorted
 // out. See crbug.com/371990.
 INSTANTIATE_TEST_CASE_P(GestureRecognizer,
                         GestureRecognizerTest,
-                        ::testing::Values(false));
+                        ::testing::Bool());
 
 }  // namespace test
 }  // namespace aura