Prepare for Unified Gesture Recognizer landing in Aura

ui/aura/window_event_dispatcher_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 "ui/aura/window_event_dispatcher.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/run_loop.h"
@@ skipping 377 matching lines @@
 }
 
 // Tests that touch-events that are beyond the bounds of the root-window do get
 // propagated to the event filters correctly with the root as the target.
 TEST_F(WindowEventDispatcherTest, TouchEventsOutsideBounds) {
   ui::test::TestEventHandler handler;
   root_window()->AddPreTargetHandler(&handler);
 
   gfx::Point position = root_window()->bounds().origin();
   position.Offset(-10, -10);
-  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, position, 0, base::TimeDelta());
+  ui::TouchEvent press(
+      ui::ET_TOUCH_PRESSED, position, 0, ui::EventTimeForNow());
   DispatchEventUsingWindowDispatcher(&press);
   EXPECT_EQ(1, handler.num_touch_events());
 
   position = root_window()->bounds().origin();
   position.Offset(root_window()->bounds().width() + 10,
                   root_window()->bounds().height() + 10);
-  ui::TouchEvent release(ui::ET_TOUCH_RELEASED, position, 0, base::TimeDelta());
+  ui::TouchEvent release(
+      ui::ET_TOUCH_RELEASED, position, 0, ui::EventTimeForNow());
   DispatchEventUsingWindowDispatcher(&release);
   EXPECT_EQ(2, handler.num_touch_events());
 }
 
 // Tests that scroll events are dispatched correctly.
 TEST_F(WindowEventDispatcherTest, ScrollEventDispatch) {
   base::TimeDelta now = ui::EventTimeForNow();
   ui::test::TestEventHandler handler;
   root_window()->AddPreTargetHandler(&handler);
 
@@ skipping 76 matching lines @@
 
   virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
     mouse_locations_.push_back(event->location());
     mouse_event_flags_.push_back(event->flags());
   }
 
   virtual void OnTouchEvent(ui::TouchEvent* event) OVERRIDE {
     touch_locations_.push_back(event->location());
   }
 
+  bool HasReceivedEvent(ui::EventType type) {
+    for (size_t i = 0; i < events_.size(); ++i) {
+      if (events_[i] == type)
+        return true;
+    }
+    return false;
+  }
+
  private:
   scoped_ptr<base::RunLoop> run_loop_;
   ui::EventType wait_until_event_;
 
   Events events_;
   EventLocations mouse_locations_;
   EventLocations touch_locations_;
   EventFlags mouse_event_flags_;
 
   DISALLOW_COPY_AND_ASSIGN(EventFilterRecorder);
@@ skipping 208 matching lines @@
   root_window()->AddPreTargetHandler(&recorder);
 
   test::TestWindowDelegate delegate;
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       &delegate, 1, gfx::Rect(50, 50, 100, 100), root_window()));
 
   const gfx::Point touch_location(60, 60);
   // Starting the touch and throwing out the first few events, since the system
   // is going to generate synthetic mouse events that are not relevant to the
   // test.
-  ui::TouchEvent touch_pressed_event(ui::ET_TOUCH_PRESSED, touch_location,
-                                     0, base::TimeDelta());
+  ui::TouchEvent touch_pressed_event(
+      ui::ET_TOUCH_PRESSED, touch_location, 0, ui::EventTimeForNow());
   DispatchEventUsingWindowDispatcher(&touch_pressed_event);
   recorder.WaitUntilReceivedEvent(ui::ET_GESTURE_SHOW_PRESS);
   recorder.Reset();
 
   host()->dispatcher()->HoldPointerMoves();
 
   // Check that we don't immediately dispatch the TOUCH_MOVED event.
-  ui::TouchEvent touch_moved_event(ui::ET_TOUCH_MOVED, touch_location,
-                                   0, base::TimeDelta());
+  ui::TouchEvent touch_moved_event(
+      ui::ET_TOUCH_MOVED, touch_location, 0, ui::EventTimeForNow());
   DispatchEventUsingWindowDispatcher(&touch_moved_event);
   EXPECT_TRUE(recorder.events().empty());
 
   // Check that on ReleasePointerMoves, held events are not dispatched
   // immediately, but posted instead.
   DispatchEventUsingWindowDispatcher(&touch_moved_event);
   host()->dispatcher()->ReleasePointerMoves();
   EXPECT_TRUE(recorder.events().empty());
 
   RunAllPendingInMessageLoop();
   EXPECT_EQ("TOUCH_MOVED", EventTypesToString(recorder.events()));
   recorder.Reset();
 
   // If another touch event occurs then the held touch should be dispatched
   // immediately before it.
-  ui::TouchEvent touch_released_event(ui::ET_TOUCH_RELEASED, touch_location,
-                                      0, base::TimeDelta());
+  ui::TouchEvent touch_released_event(
+      ui::ET_TOUCH_RELEASED, touch_location, 0, ui::EventTimeForNow());
   recorder.Reset();
   host()->dispatcher()->HoldPointerMoves();
   DispatchEventUsingWindowDispatcher(&touch_moved_event);
   DispatchEventUsingWindowDispatcher(&touch_released_event);
-  EXPECT_EQ("TOUCH_MOVED TOUCH_RELEASED GESTURE_TAP_CANCEL GESTURE_END",
+  EXPECT_EQ("TOUCH_MOVED TOUCH_RELEASED GESTURE_TAP GESTURE_END",
             EventTypesToString(recorder.events()));
   recorder.Reset();
   host()->dispatcher()->ReleasePointerMoves();
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(recorder.events().empty());
 }
 
 class HoldPointerOnScrollHandler : public ui::test::TestEventHandler {
  public:
   HoldPointerOnScrollHandler(WindowEventDispatcher* dispatcher,
@@ skipping 433 matching lines @@
 TEST_F(WindowEventDispatcherTest, RepostTapdownGestureTest) {
   EventFilterRecorder recorder;
   root_window()->AddPreTargetHandler(&recorder);
 
   test::TestWindowDelegate delegate;
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       &delegate, 1, gfx::Rect(0, 0, 100, 100), root_window()));
 
   ui::GestureEventDetails details(ui::ET_GESTURE_TAP_DOWN, 0.0f, 0.0f);
   gfx::Point point(10, 10);
-  ui::GestureEvent event(
-      ui::ET_GESTURE_TAP_DOWN,
-      point.x(),
-      point.y(),
-      0,
-      ui::EventTimeForNow(),
-      details,
-      0);
+  ui::GestureEvent event(ui::ET_GESTURE_TAP_DOWN,
+                         point.x(),
+                         point.y(),
+                         0,
+                         ui::EventTimeForNow(),
+                         details,
+                         0);
   host()->dispatcher()->RepostEvent(event);
   RunAllPendingInMessageLoop();
   // TODO(rbyers): Currently disabled - crbug.com/170987
   EXPECT_FALSE(EventTypesToString(recorder.events()).find("GESTURE_TAP_DOWN") !=
               std::string::npos);
   recorder.Reset();
   root_window()->RemovePreTargetHandler(&recorder);
 }
 
 // This class inherits from the EventFilterRecorder class which provides a
@@ skipping 333 matching lines @@
 
 TEST_F(WindowEventDispatcherTest, WindowHideCancelsActiveTouches) {
   EventFilterRecorder recorder;
   root_window()->AddPreTargetHandler(&recorder);
 
   test::TestWindowDelegate delegate;
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       &delegate, 1, gfx::Rect(0, 0, 100, 100), root_window()));
 
   gfx::Point position1 = root_window()->bounds().origin();
-  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, position1, 0, base::TimeDelta());
+  ui::TouchEvent press(
+      ui::ET_TOUCH_PRESSED, position1, 0, ui::EventTimeForNow());
   DispatchEventUsingWindowDispatcher(&press);
 
   EXPECT_EQ("TOUCH_PRESSED GESTURE_BEGIN GESTURE_TAP_DOWN",
             EventTypesToString(recorder.GetAndResetEvents()));
 
   window->Hide();
 
-  EXPECT_EQ("TOUCH_CANCELLED GESTURE_TAP_CANCEL GESTURE_END",
-            EventTypesToString(recorder.events()));
+  EXPECT_EQ(ui::ET_TOUCH_CANCELLED, recorder.events()[0]);
+  EXPECT_TRUE(recorder.HasReceivedEvent(ui::ET_GESTURE_TAP_CANCEL));
+  EXPECT_TRUE(recorder.HasReceivedEvent(ui::ET_GESTURE_END));
+  EXPECT_EQ(3U, recorder.events().size());
   root_window()->RemovePreTargetHandler(&recorder);
 }
 
 TEST_F(WindowEventDispatcherTest, WindowHideCancelsActiveGestures) {
   EventFilterRecorder recorder;
   root_window()->AddPreTargetHandler(&recorder);
 
   test::TestWindowDelegate delegate;
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       &delegate, 1, gfx::Rect(0, 0, 100, 100), root_window()));
 
   gfx::Point position1 = root_window()->bounds().origin();
   gfx::Point position2 = root_window()->bounds().CenterPoint();
-  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, position1, 0, base::TimeDelta());
+  ui::TouchEvent press(
+      ui::ET_TOUCH_PRESSED, position1, 0, ui::EventTimeForNow());
   DispatchEventUsingWindowDispatcher(&press);
 
-  ui::TouchEvent move(ui::ET_TOUCH_MOVED, position2, 0, base::TimeDelta());
+  ui::TouchEvent move(
+      ui::ET_TOUCH_MOVED, position2, 0, ui::EventTimeForNow());
   DispatchEventUsingWindowDispatcher(&move);
 
-  ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, position1, 1, base::TimeDelta());
+  ui::TouchEvent press2(
+      ui::ET_TOUCH_PRESSED, position1, 1, ui::EventTimeForNow());
   DispatchEventUsingWindowDispatcher(&press2);
 
-  EXPECT_EQ("TOUCH_PRESSED GESTURE_BEGIN GESTURE_TAP_DOWN TOUCH_MOVED "
-            "GESTURE_TAP_CANCEL GESTURE_SCROLL_BEGIN GESTURE_SCROLL_UPDATE "
-            "TOUCH_PRESSED GESTURE_BEGIN GESTURE_PINCH_BEGIN",
-            EventTypesToString(recorder.GetAndResetEvents()));
+  // TODO(tdresser): once the unified Gesture Recognizer has stuck, remove the
+  // special casing here. See crbug.com/332418 for details.
+  std::string expected =
+      "TOUCH_PRESSED GESTURE_BEGIN GESTURE_TAP_DOWN TOUCH_MOVED "
+      "GESTURE_TAP_CANCEL GESTURE_SCROLL_BEGIN GESTURE_SCROLL_UPDATE "
+      "TOUCH_PRESSED GESTURE_BEGIN GESTURE_PINCH_BEGIN";
+
+  std::string expected_ugr =
+      "TOUCH_PRESSED GESTURE_BEGIN GESTURE_TAP_DOWN TOUCH_MOVED "
+      "GESTURE_TAP_CANCEL GESTURE_SCROLL_BEGIN GESTURE_SCROLL_UPDATE "
+      "TOUCH_PRESSED GESTURE_BEGIN";
+
+  std::string events_string = EventTypesToString(recorder.GetAndResetEvents());
+  EXPECT_TRUE((expected == events_string) || (expected_ugr == events_string));
 
   window->Hide();
 
-  EXPECT_EQ("TOUCH_CANCELLED GESTURE_PINCH_END GESTURE_END TOUCH_CANCELLED "
-            "GESTURE_SCROLL_END GESTURE_END",
-            EventTypesToString(recorder.events()));
+  expected =
+      "TOUCH_CANCELLED GESTURE_PINCH_END GESTURE_END TOUCH_CANCELLED "
+      "GESTURE_SCROLL_END GESTURE_END";
+  expected_ugr =
+      "TOUCH_CANCELLED GESTURE_SCROLL_END GESTURE_END GESTURE_END "
+      "TOUCH_CANCELLED";
+
+  events_string = EventTypesToString(recorder.GetAndResetEvents());
+  EXPECT_TRUE((expected == events_string) || (expected_ugr == events_string));
+
   root_window()->RemovePreTargetHandler(&recorder);
 }
 
 // Places two windows side by side. Presses down on one window, and starts a
 // scroll. Sets capture on the other window and ensures that the "ending" events
 // aren't sent to the window which gained capture.
 TEST_F(WindowEventDispatcherTest, EndingEventDoesntRetarget) {
   EventFilterRecorder recorder1;
   EventFilterRecorder recorder2;
   scoped_ptr<Window> window1(CreateNormalWindow(1, root_window(), NULL));
   window1->SetBounds(gfx::Rect(0, 0, 40, 40));
 
   scoped_ptr<Window> window2(CreateNormalWindow(2, root_window(), NULL));
   window2->SetBounds(gfx::Rect(40, 0, 40, 40));
 
   window1->AddPreTargetHandler(&recorder1);
   window2->AddPreTargetHandler(&recorder2);
 
   gfx::Point position = window1->bounds().origin();
-  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, position, 0, base::TimeDelta());
+  ui::TouchEvent press(
+      ui::ET_TOUCH_PRESSED, position, 0, ui::EventTimeForNow());
   DispatchEventUsingWindowDispatcher(&press);
 
   gfx::Point position2 = window1->bounds().CenterPoint();
-  ui::TouchEvent move(ui::ET_TOUCH_MOVED, position2, 0, base::TimeDelta());
+  ui::TouchEvent move(
+      ui::ET_TOUCH_MOVED, position2, 0, ui::EventTimeForNow());
   DispatchEventUsingWindowDispatcher(&move);
 
   window2->SetCapture();
 
   EXPECT_EQ("TOUCH_PRESSED GESTURE_BEGIN GESTURE_TAP_DOWN TOUCH_MOVED "
             "GESTURE_TAP_CANCEL GESTURE_SCROLL_BEGIN GESTURE_SCROLL_UPDATE "
             "TOUCH_CANCELLED GESTURE_SCROLL_END GESTURE_END",
             EventTypesToString(recorder1.events()));
 
   EXPECT_TRUE(recorder2.events().empty());
@@ skipping 457 matching lines @@
   delegate.GetMouseMotionCountsAndReset();
 
   // Notify both hosts that the cursor is now hidden. This should send a single
   // mouse-exit event to |window|.
   host()->OnCursorVisibilityChanged(false);
   second_host->OnCursorVisibilityChanged(false);
   EXPECT_EQ("0 0 1", delegate.GetMouseMotionCountsAndReset());
 }
 
 }  // namespace aura