aura: Allow held touch-events to contribute to gesture events.

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 570 matching lines @@
       return "GESTURE_SHOW_PRESS";
 
     case ui::ET_GESTURE_BEGIN:
       return "GESTURE_BEGIN";
 
     case ui::ET_GESTURE_END:
       return "GESTURE_END";
 
     default:
       // We should explicitly require each event type.
-      NOTREACHED();
+      NOTREACHED() << "Received unexpected event: " << type;
       break;
   }
   return "";
 }
 
 std::string EventTypesToString(const EventFilterRecorder::Events& events) {
   std::string result;
   for (size_t i = 0; i < events.size(); ++i) {
     if (i != 0)
       result += " ";
@@ skipping 135 matching lines @@
       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, ui::EventTimeForNow());
+  ui::TouchEvent touch_moved_event2 = touch_moved_event;
+  ui::TouchEvent touch_moved_event3 = touch_moved_event;
+
   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);
+  DispatchEventUsingWindowDispatcher(&touch_moved_event2);
   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, ui::EventTimeForNow());
   recorder.Reset();
   host()->dispatcher()->HoldPointerMoves();
-  DispatchEventUsingWindowDispatcher(&touch_moved_event);
+  DispatchEventUsingWindowDispatcher(&touch_moved_event3);
   DispatchEventUsingWindowDispatcher(&touch_released_event);
   EXPECT_EQ("TOUCH_MOVED TOUCH_RELEASED GESTURE_TAP GESTURE_END",
             EventTypesToString(recorder.events()));
   recorder.Reset();
   host()->dispatcher()->ReleasePointerMoves();
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(recorder.events().empty());
 }
 
+// This event handler requests the dispatcher to start holding pointer-move
+// events when it receives the first scroll-update gesture.
 class HoldPointerOnScrollHandler : public ui::test::TestEventHandler {
  public:
   HoldPointerOnScrollHandler(WindowEventDispatcher* dispatcher,
-                                  EventFilterRecorder* filter)
+                             EventFilterRecorder* filter)
       : dispatcher_(dispatcher),
         filter_(filter),
-        holding_moves_(false) {
-  }
+        holding_moves_(false) {}
   virtual ~HoldPointerOnScrollHandler() {}
 
  private:
+  // ui::test::TestEventHandler:
   virtual void OnGestureEvent(ui::GestureEvent* gesture) OVERRIDE {
-    if (gesture->type() == ui::ET_GESTURE_SCROLL_UPDATE) {
-      CHECK(!holding_moves_);
+    if (!holding_moves_ && gesture->type() == ui::ET_GESTURE_SCROLL_UPDATE) {
       holding_moves_ = true;
       dispatcher_->HoldPointerMoves();
       filter_->Reset();
     } else if (gesture->type() == ui::ET_GESTURE_SCROLL_END) {
       dispatcher_->ReleasePointerMoves();
       holding_moves_ = false;
     }
   }
 
   WindowEventDispatcher* dispatcher_;
@@ skipping 18 matching lines @@
   generator.GestureScrollSequence(
       gfx::Point(60, 60), gfx::Point(10, 60),
       base::TimeDelta::FromMilliseconds(100), 25);
 
   // |handler| will have reset |filter| and started holding the touch-move
   // events when scrolling started. At the end of the scroll (i.e. upon
   // touch-release), the held touch-move event will have been dispatched first,
   // along with the subsequent events (i.e. touch-release, scroll-end, and
   // gesture-end).
   const EventFilterRecorder::Events& events = recorder.events();
-  EXPECT_EQ("TOUCH_MOVED TOUCH_RELEASED GESTURE_SCROLL_END GESTURE_END",
-            EventTypesToString(events));
+  EXPECT_EQ(
+      "TOUCH_MOVED GESTURE_SCROLL_UPDATE TOUCH_RELEASED "
+      "GESTURE_SCROLL_END GESTURE_END",
+      EventTypesToString(events));
   ASSERT_EQ(2u, recorder.touch_locations().size());
   EXPECT_EQ(gfx::Point(-40, 10).ToString(),
             recorder.touch_locations()[0].ToString());
   EXPECT_EQ(gfx::Point(-40, 10).ToString(),
             recorder.touch_locations()[1].ToString());
 }
 
+// Tests that a 'held' touch-event does contribute to gesture event when it is
+// dispatched.
+TEST_F(WindowEventDispatcherTest, HeldTouchMoveContributesToGesture) {
+  EventFilterRecorder recorder;
+  root_window()->AddPreTargetHandler(&recorder);
+
+  const gfx::Point location(20, 20);
+  ui::TouchEvent press(
+      ui::ET_TOUCH_PRESSED, location, 0, ui::EventTimeForNow());
+  DispatchEventUsingWindowDispatcher(&press);
+  EXPECT_TRUE(recorder.HasReceivedEvent(ui::ET_TOUCH_PRESSED));
+  recorder.Reset();
+
+  host()->dispatcher()->HoldPointerMoves();
+
+  ui::TouchEvent move(ui::ET_TOUCH_MOVED,
+                      location + gfx::Vector2d(100, 100),
+                      0,
+                      ui::EventTimeForNow());
+  DispatchEventUsingWindowDispatcher(&move);
+  EXPECT_FALSE(recorder.HasReceivedEvent(ui::ET_TOUCH_MOVED));
+  EXPECT_FALSE(recorder.HasReceivedEvent(ui::ET_GESTURE_SCROLL_BEGIN));
+  recorder.Reset();
+
+  host()->dispatcher()->ReleasePointerMoves();
+  EXPECT_FALSE(recorder.HasReceivedEvent(ui::ET_TOUCH_MOVED));
+  RunAllPendingInMessageLoop();
+  EXPECT_TRUE(recorder.HasReceivedEvent(ui::ET_TOUCH_MOVED));
+  EXPECT_TRUE(recorder.HasReceivedEvent(ui::ET_GESTURE_SCROLL_BEGIN));
+  EXPECT_TRUE(recorder.HasReceivedEvent(ui::ET_GESTURE_SCROLL_UPDATE));
+
+  root_window()->RemovePreTargetHandler(&recorder);
+}
+
 // Tests that synthetic mouse events are ignored when mouse
 // events are disabled.
 TEST_F(WindowEventDispatcherTest, DispatchSyntheticMouseEvents) {
   EventFilterRecorder recorder;
   root_window()->AddPreTargetHandler(&recorder);
 
   test::TestWindowDelegate delegate;
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       &delegate, 1234, gfx::Rect(5, 5, 100, 100), root_window()));
   window->Show();
@@ skipping 1041 matching lines @@
   generator.GestureScrollSequence(
       gfx::Point(120, 120), gfx::Point(20, 120),
       base::TimeDelta::FromMilliseconds(100), 25);
 
   // |handler| will have reset |filter| and started holding the touch-move
   // events when scrolling started. At the end of the scroll (i.e. upon
   // touch-release), the held touch-move event will have been dispatched first,
   // along with the subsequent events (i.e. touch-release, scroll-end, and
   // gesture-end).
   const EventFilterRecorder::Events& events = recorder.events();
-  EXPECT_EQ("TOUCH_MOVED TOUCH_RELEASED GESTURE_SCROLL_END GESTURE_END",
-            EventTypesToString(events));
+  EXPECT_EQ(
+      "TOUCH_MOVED GESTURE_SCROLL_UPDATE TOUCH_RELEASED "
+      "GESTURE_SCROLL_END GESTURE_END",
+      EventTypesToString(events));
   ASSERT_EQ(2u, recorder.touch_locations().size());
   EXPECT_EQ(gfx::Point(-40, 10).ToString(),
             recorder.touch_locations()[0].ToString());
   EXPECT_EQ(gfx::Point(-40, 10).ToString(),
             recorder.touch_locations()[1].ToString());
 }
 
 class SelfDestructDelegate : public test::TestWindowDelegate {
  public:
   SelfDestructDelegate() {}
@@ skipping 230 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