Provide access to the WindowEventDispatcher as a ui::EventProcessor.

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 122 matching lines @@
   EXPECT_TRUE(delegate1->mouse_event_flags() & ui::EF_IS_NON_CLIENT);
 }
 
 TEST_F(WindowEventDispatcherTest, RepostEvent) {
   // Test RepostEvent in RootWindow. It only works for Mouse Press.
   EXPECT_FALSE(Env::GetInstance()->IsMouseButtonDown());
   gfx::Point point(10, 10);
   ui::MouseEvent event(
       ui::ET_MOUSE_PRESSED, point, point, ui::EF_LEFT_MOUSE_BUTTON,
       ui::EF_LEFT_MOUSE_BUTTON);
-  dispatcher()->RepostEvent(event);
+  host()->dispatcher()->RepostEvent(event);
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(Env::GetInstance()->IsMouseButtonDown());
 }
 
 // Check that we correctly track the state of the mouse buttons in response to
 // button press and release events.
 TEST_F(WindowEventDispatcherTest, MouseButtonState) {
   EXPECT_FALSE(Env::GetInstance()->IsMouseButtonDown());
 
   gfx::Point location;
@@ skipping 431 matching lines @@
   // capture).
   EXPECT_FALSE(Env::GetInstance()->IsMouseButtonDown());
   scoped_ptr<Window> window(CreateNormalWindow(1, root_window(), NULL));
   window->SetBounds(gfx::Rect(20, 20, 40, 30));
   EventFilterRecorder* recorder = new EventFilterRecorder;
   window->SetEventFilter(recorder);  // Takes ownership.
   window->SetCapture();
   const ui::MouseEvent press_event(
       ui::ET_MOUSE_PRESSED, gfx::Point(), gfx::Point(),
       ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
-  dispatcher()->RepostEvent(press_event);
+  host()->dispatcher()->RepostEvent(press_event);
   RunAllPendingInMessageLoop();  // Necessitated by RepostEvent().
   // Mouse moves/enters may be generated. We only care about a pressed.
   EXPECT_TRUE(EventTypesToString(recorder->events()).find("MOUSE_PRESSED") !=
               std::string::npos) << EventTypesToString(recorder->events());
 }
 
 TEST_F(WindowEventDispatcherTest, MouseMovesHeld) {
   EventFilterRecorder* filter = new EventFilterRecorder;
   root_window()->SetEventFilter(filter);  // passes ownership
 
   test::TestWindowDelegate delegate;
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       &delegate, 1, gfx::Rect(0, 0, 100, 100), root_window()));
 
   ui::MouseEvent mouse_move_event(ui::ET_MOUSE_MOVED, gfx::Point(0, 0),
                                   gfx::Point(0, 0), 0, 0);
   DispatchEventUsingWindowDispatcher(&mouse_move_event);
   // Discard MOUSE_ENTER.
   filter->Reset();
 
-  dispatcher()->HoldPointerMoves();
+  host()->dispatcher()->HoldPointerMoves();
 
   // Check that we don't immediately dispatch the MOUSE_DRAGGED event.
   ui::MouseEvent mouse_dragged_event(ui::ET_MOUSE_DRAGGED, gfx::Point(0, 0),
                                      gfx::Point(0, 0), 0, 0);
   DispatchEventUsingWindowDispatcher(&mouse_dragged_event);
   EXPECT_TRUE(filter->events().empty());
 
   // Check that we do dispatch the held MOUSE_DRAGGED event before another type
   // of event.
   ui::MouseEvent mouse_pressed_event(ui::ET_MOUSE_PRESSED, gfx::Point(0, 0),
@@ skipping 10 matching lines @@
   DispatchEventUsingWindowDispatcher(&mouse_dragged_event2);
   EXPECT_TRUE(filter->events().empty());
   DispatchEventUsingWindowDispatcher(&mouse_pressed_event);
   EXPECT_EQ("MOUSE_DRAGGED MOUSE_PRESSED",
             EventTypesToString(filter->events()));
   filter->Reset();
 
   // Check that on ReleasePointerMoves, held events are not dispatched
   // immediately, but posted instead.
   DispatchEventUsingWindowDispatcher(&mouse_dragged_event);
-  dispatcher()->ReleasePointerMoves();
+  host()->dispatcher()->ReleasePointerMoves();
   EXPECT_TRUE(filter->events().empty());
   RunAllPendingInMessageLoop();
   EXPECT_EQ("MOUSE_DRAGGED", EventTypesToString(filter->events()));
   filter->Reset();
 
   // However if another message comes in before the dispatch of the posted
   // event, check that the posted event is dispatched before this new event.
-  dispatcher()->HoldPointerMoves();
+  host()->dispatcher()->HoldPointerMoves();
   DispatchEventUsingWindowDispatcher(&mouse_dragged_event);
-  dispatcher()->ReleasePointerMoves();
+  host()->dispatcher()->ReleasePointerMoves();
   DispatchEventUsingWindowDispatcher(&mouse_pressed_event);
   EXPECT_EQ("MOUSE_DRAGGED MOUSE_PRESSED",
             EventTypesToString(filter->events()));
   filter->Reset();
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(filter->events().empty());
 
   // Check that if the other message is another MOUSE_DRAGGED, we still coalesce
   // them.
-  dispatcher()->HoldPointerMoves();
+  host()->dispatcher()->HoldPointerMoves();
   DispatchEventUsingWindowDispatcher(&mouse_dragged_event);
-  dispatcher()->ReleasePointerMoves();
+  host()->dispatcher()->ReleasePointerMoves();
   DispatchEventUsingWindowDispatcher(&mouse_dragged_event2);
   EXPECT_EQ("MOUSE_DRAGGED", EventTypesToString(filter->events()));
   filter->Reset();
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(filter->events().empty());
 
   // Check that synthetic mouse move event has a right location when issued
   // while holding pointer moves.
   ui::MouseEvent mouse_dragged_event3(ui::ET_MOUSE_DRAGGED, gfx::Point(28, 28),
                                       gfx::Point(28, 28), 0, 0);
-  dispatcher()->HoldPointerMoves();
+  host()->dispatcher()->HoldPointerMoves();
   DispatchEventUsingWindowDispatcher(&mouse_dragged_event);
   DispatchEventUsingWindowDispatcher(&mouse_dragged_event2);
   window->SetBounds(gfx::Rect(15, 15, 80, 80));
   DispatchEventUsingWindowDispatcher(&mouse_dragged_event3);
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(filter->events().empty());
-  dispatcher()->ReleasePointerMoves();
+  host()->dispatcher()->ReleasePointerMoves();
   RunAllPendingInMessageLoop();
   EXPECT_EQ("MOUSE_MOVED", EventTypesToString(filter->events()));
   EXPECT_EQ(gfx::Point(13, 13), filter->mouse_location(0));
   filter->Reset();
 }
 
 TEST_F(WindowEventDispatcherTest, TouchMovesHeld) {
   EventFilterRecorder* filter = new EventFilterRecorder;
   root_window()->SetEventFilter(filter);  // passes ownership
 
   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());
   DispatchEventUsingWindowDispatcher(&touch_pressed_event);
   filter->WaitUntilReceivedEvent(ui::ET_GESTURE_SHOW_PRESS);
   filter->Reset();
 
-  dispatcher()->HoldPointerMoves();
+  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());
   DispatchEventUsingWindowDispatcher(&touch_moved_event);
   EXPECT_TRUE(filter->events().empty());
 
   // Check that on ReleasePointerMoves, held events are not dispatched
   // immediately, but posted instead.
   DispatchEventUsingWindowDispatcher(&touch_moved_event);
-  dispatcher()->ReleasePointerMoves();
+  host()->dispatcher()->ReleasePointerMoves();
   EXPECT_TRUE(filter->events().empty());
 
   RunAllPendingInMessageLoop();
   EXPECT_EQ("TOUCH_MOVED", EventTypesToString(filter->events()));
   filter->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());
   filter->Reset();
-  dispatcher()->HoldPointerMoves();
+  host()->dispatcher()->HoldPointerMoves();
   DispatchEventUsingWindowDispatcher(&touch_moved_event);
   DispatchEventUsingWindowDispatcher(&touch_released_event);
   EXPECT_EQ("TOUCH_MOVED TOUCH_RELEASED GESTURE_TAP_CANCEL GESTURE_END",
             EventTypesToString(filter->events()));
   filter->Reset();
-  dispatcher()->ReleasePointerMoves();
+  host()->dispatcher()->ReleasePointerMoves();
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(filter->events().empty());
 }
 
 class HoldPointerOnScrollHandler : public test::TestEventHandler {
  public:
   HoldPointerOnScrollHandler(WindowEventDispatcher* dispatcher,
                                   EventFilterRecorder* filter)
       : dispatcher_(dispatcher),
         filter_(filter),
@@ skipping 20 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(HoldPointerOnScrollHandler);
 };
 
 // Tests that touch-move events don't contribute to an in-progress scroll
 // gesture if touch-move events are being held by the dispatcher.
 TEST_F(WindowEventDispatcherTest, TouchMovesHeldOnScroll) {
   EventFilterRecorder* filter = new EventFilterRecorder;
   root_window()->SetEventFilter(filter);
   test::TestWindowDelegate delegate;
-  HoldPointerOnScrollHandler handler(dispatcher(), filter);
+  HoldPointerOnScrollHandler handler(host()->dispatcher(), filter);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       &delegate, 1, gfx::Rect(50, 50, 100, 100), root_window()));
   window->AddPreTargetHandler(&handler);
 
   test::EventGenerator generator(root_window());
   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
@@ skipping 61 matching lines @@
   // Dispatch a mouse move event into the window.
   gfx::Point mouse_location(gfx::Point(15, 25));
   ui::MouseEvent mouse1(ui::ET_MOUSE_MOVED, mouse_location,
                         mouse_location, 0, 0);
   EXPECT_TRUE(filter->events().empty());
   DispatchEventUsingWindowDispatcher(&mouse1);
   EXPECT_FALSE(filter->events().empty());
   filter->Reset();
 
   // Hide the cursor and verify a mouse exit was dispatched.
-  dispatcher()->host()->OnCursorVisibilityChanged(false);
+  host()->OnCursorVisibilityChanged(false);
   EXPECT_FALSE(filter->events().empty());
   EXPECT_EQ("MOUSE_EXITED", EventTypesToString(filter->events()));
 
   // Verify the mouse exit was dispatched at the correct location
   // (in the correct coordinate space).
   int translated_x = mouse_location.x() - window_origin.x();
   int translated_y = mouse_location.y() - window_origin.y();
   gfx::Point translated_point(translated_x, translated_y);
   EXPECT_EQ(filter->mouse_location(0).ToString(), translated_point.ToString());
 }
@@ skipping 214 matching lines @@
   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);
-  dispatcher()->RepostEvent(event);
+  host()->dispatcher()->RepostEvent(event);
   RunAllPendingInMessageLoop();
   // TODO(rbyers): Currently disabled - crbug.com/170987
   EXPECT_FALSE(EventTypesToString(filter->events()).find("GESTURE_TAP_DOWN") !=
               std::string::npos);
   filter->Reset();
 }
 
 // This class inherits from the EventFilterRecorder class which provides a
 // facility to record events. This class additionally provides a facility to
 // repost the ET_GESTURE_TAP_DOWN gesture to the target window and records
@@ skipping 133 matching lines @@
 // a child, but the child is destroyed because of the synthesized mouse-exit
 // event generated on the previous mouse_moved_handler_.
 TEST_F(WindowEventDispatcherTest, DeleteWindowDuringMouseMovedDispatch) {
   // Create window 1 and set its event filter. Window 1 will take ownership of
   // the event filter.
   scoped_ptr<Window> w1(CreateNormalWindow(1, root_window(), NULL));
   OnMouseExitDeletingEventFilter* w1_filter =
       new OnMouseExitDeletingEventFilter();
   w1->SetEventFilter(w1_filter);
   w1->SetBounds(gfx::Rect(20, 20, 60, 60));
-  EXPECT_EQ(NULL, dispatcher()->mouse_moved_handler());
+  EXPECT_EQ(NULL, host()->dispatcher()->mouse_moved_handler());
 
   test::EventGenerator generator(root_window(), w1.get());
 
   // Move mouse over window 1 to set it as the |mouse_moved_handler_| for the
   // root window.
   generator.MoveMouseTo(51, 51);
-  EXPECT_EQ(w1.get(), dispatcher()->mouse_moved_handler());
+  EXPECT_EQ(w1.get(), host()->dispatcher()->mouse_moved_handler());
 
   // Create window 2 under the mouse cursor and stack it above window 1.
   Window* w2 = CreateNormalWindow(2, root_window(), NULL);
   w2->SetBounds(gfx::Rect(30, 30, 40, 40));
   root_window()->StackChildAbove(w2, w1.get());
 
   // Set window 2 as the window that is to be deleted when a mouse-exited event
   // happens on window 1.
   w1_filter->set_window_to_delete(w2);
 
   // Move mosue over window 2. This should generate a mouse-exited event for
   // window 1 resulting in deletion of window 2. The original mouse-moved event
   // that was targeted to window 2 should be dropped since window 2 is
   // destroyed. This test passes if no crash happens.
   generator.MoveMouseTo(52, 52);
-  EXPECT_EQ(NULL, dispatcher()->mouse_moved_handler());
+  EXPECT_EQ(NULL, host()->dispatcher()->mouse_moved_handler());
 
   // Check events received by window 1.
   EXPECT_EQ("MOUSE_ENTERED MOUSE_MOVED MOUSE_EXITED",
             EventTypesToString(w1_filter->events()));
 }
 
 namespace {
 
 // Used to track if OnWindowDestroying() is invoked and if there is a valid
 // RootWindow at such time.
@@ skipping 332 matching lines @@
     // (e.g. mouse-move events if the mouse cursor is over the window).
     handler_.Reset();
 
     // Start a nested message-loop, post an event to be dispatched, and then
     // terminate the message-loop. When the message-loop unwinds and gets back,
     // the reposted event should not have fired.
     ui::MouseEvent mouse(ui::ET_MOUSE_PRESSED, gfx::Point(10, 10),
                          gfx::Point(10, 10), ui::EF_NONE, ui::EF_NONE);
     message_loop()->PostTask(FROM_HERE,
                              base::Bind(&WindowEventDispatcher::RepostEvent,
-                                        base::Unretained(dispatcher()),
+                                        base::Unretained(host()->dispatcher()),
                                         mouse));
     message_loop()->PostTask(FROM_HERE,
                              message_loop()->QuitClosure());
 
     base::MessageLoop::ScopedNestableTaskAllower allow(message_loop());
     base::RunLoop loop;
     loop.Run();
     EXPECT_EQ(0, handler_.num_mouse_events());
 
     // Let the current message-loop run. The event-handler will terminate the
@@ skipping 79 matching lines @@
   }
 
   child->RemovePreTargetHandler(&handler_child);
   root_window()->RemovePreTargetHandler(&handler_root);
 }
 
 TEST_F(WindowEventDispatcherTestInHighDPI, TouchMovesHeldOnScroll) {
   EventFilterRecorder* filter = new EventFilterRecorder;
   root_window()->SetEventFilter(filter);
   test::TestWindowDelegate delegate;
-  HoldPointerOnScrollHandler handler(dispatcher(), filter);
+  HoldPointerOnScrollHandler handler(host()->dispatcher(), filter);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       &delegate, 1, gfx::Rect(50, 50, 100, 100), root_window()));
   window->AddPreTargetHandler(&handler);
 
   test::EventGenerator generator(root_window());
   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
@@ skipping 84 matching lines @@
 // when the focused window does not live in the dispatcher's tree.
 TEST_F(WindowEventDispatcherTest, HostCancelModeWithFocusedWindowOutside) {
   test::TestWindowDelegate delegate;
   scoped_ptr<Window> focused(CreateTestWindowWithDelegate(&delegate, 123,
       gfx::Rect(20, 30, 100, 50), NULL));
   StaticFocusClient focus_client(focused.get());
   client::SetFocusClient(root_window(), &focus_client);
   EXPECT_FALSE(root_window()->Contains(focused.get()));
   EXPECT_EQ(focused.get(),
             client::GetFocusClient(root_window())->GetFocusedWindow());
-  dispatcher()->DispatchCancelModeEvent();
+  host()->dispatcher()->DispatchCancelModeEvent();
   EXPECT_EQ(focused.get(),
             client::GetFocusClient(root_window())->GetFocusedWindow());
 }
 
 // Dispatches a mouse-move event to |target| when it receives a mouse-move
 // event.
 class DispatchEventHandler : public ui::EventHandler {
  public:
   explicit DispatchEventHandler(Window* target)
       : target_(target),
@@ skipping 79 matching lines @@
   second->AddPreTargetHandler(&move_window);
 
   // Some sanity checks: |first| is inside |root_window()|'s tree.
   EXPECT_EQ(root_window(), first->GetRootWindow());
   // The two root windows are different.
   EXPECT_NE(root_window(), second_root);
 
   // Dispatch an event to |first|.
   ui::MouseEvent move(ui::ET_MOUSE_MOVED, first->bounds().CenterPoint(),
                       first->bounds().CenterPoint(), ui::EF_NONE, ui::EF_NONE);
-  ui::EventDispatchDetails details = dispatcher()->OnEventFromSource(&move);
+  ui::EventDispatchDetails details =
+      host()->dispatcher()->OnEventFromSource(&move);
   ASSERT_FALSE(details.dispatcher_destroyed);
   EXPECT_TRUE(details.target_destroyed);
   EXPECT_EQ(first.get(), move.target());
   EXPECT_TRUE(dispatch_event.dispatched());
   EXPECT_EQ(second_root, first->GetRootWindow());
 
   first->RemovePreTargetHandler(&dispatch_event);
   second->RemovePreTargetHandler(&move_window);
 }
 
 }  // namespace aura