Move TestEventHandler to ui/events/test

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"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/aura/client/event_client.h"
 #include "ui/aura/client/focus_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/test/aura_test_base.h"
 #include "ui/aura/test/env_test_helper.h"
 #include "ui/aura/test/event_generator.h"
 #include "ui/aura/test/test_cursor_client.h"
-#include "ui/aura/test/test_event_handler.h"
 #include "ui/aura/test/test_screen.h"
 #include "ui/aura/test/test_window_delegate.h"
 #include "ui/aura/test/test_windows.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_tracker.h"
 #include "ui/base/hit_test.h"
 #include "ui/events/event.h"
 #include "ui/events/event_handler.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/gestures/gesture_configuration.h"
 #include "ui/events/keycodes/keyboard_codes.h"
+#include "ui/events/test/test_event_handler.h"
 #include "ui/gfx/point.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/transform.h"
 
 namespace aura {
 namespace {
 
 bool PlatformSupportsMultipleHosts() {
 #if defined(USE_OZONE)
@@ skipping 37 matching lines @@
   int non_client_count_;
   gfx::Point non_client_location_;
   int mouse_event_count_;
   gfx::Point mouse_event_location_;
   int mouse_event_flags_;
 
   DISALLOW_COPY_AND_ASSIGN(NonClientDelegate);
 };
 
 // A simple event handler that consumes key events.
-class ConsumeKeyHandler : public test::TestEventHandler {
+class ConsumeKeyHandler : public ui::test::TestEventHandler {
  public:
   ConsumeKeyHandler() {}
   virtual ~ConsumeKeyHandler() {}
 
   // Overridden from ui::EventHandler:
   virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE {
-    test::TestEventHandler::OnKeyEvent(event);
+    ui::test::TestEventHandler::OnKeyEvent(event);
     event->StopPropagation();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ConsumeKeyHandler);
 };
 
 bool IsFocusedWindow(aura::Window* window) {
   return client::GetFocusClient(window)->GetFocusedWindow() == window;
 }
@@ skipping 185 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(TestEventClient);
 };
 
 }  // namespace
 
 TEST_F(WindowEventDispatcherTest, CanProcessEventsWithinSubtree) {
   TestEventClient client(root_window());
   test::TestWindowDelegate d;
 
-  test::TestEventHandler* nonlock_ef = new test::TestEventHandler;
-  test::TestEventHandler* lock_ef = new test::TestEventHandler;
+  ui::test::TestEventHandler* nonlock_ef = new ui::test::TestEventHandler;
+  ui::test::TestEventHandler* lock_ef = new ui::test::TestEventHandler;
   client.GetNonLockWindow()->SetEventFilter(nonlock_ef);
   client.GetLockWindow()->SetEventFilter(lock_ef);
 
   Window* w1 = test::CreateTestWindowWithBounds(gfx::Rect(10, 10, 20, 20),
                                                 client.GetNonLockWindow());
   w1->set_id(1);
   Window* w2 = test::CreateTestWindowWithBounds(gfx::Rect(30, 30, 20, 20),
                                                 client.GetNonLockWindow());
   w2->set_id(2);
   scoped_ptr<Window> w3(
@@ skipping 31 matching lines @@
     generator3.PressLeftButton();
     EXPECT_EQ(1, lock_ef->num_mouse_events());
   }
 
   // Prevent w3 from being deleted by the hierarchy since its delegate is owned
   // by this scope.
   w3->parent()->RemoveChild(w3.get());
 }
 
 TEST_F(WindowEventDispatcherTest, IgnoreUnknownKeys) {
-  test::TestEventHandler* filter = new ConsumeKeyHandler;
+  ui::test::TestEventHandler* filter = new ConsumeKeyHandler;
   root_window()->SetEventFilter(filter);  // passes ownership
 
   ui::KeyEvent unknown_event(ui::ET_KEY_PRESSED, ui::VKEY_UNKNOWN, 0, false);
   DispatchEventUsingWindowDispatcher(&unknown_event);
   EXPECT_FALSE(unknown_event.handled());
   EXPECT_EQ(0, filter->num_key_events());
 
   ui::KeyEvent known_event(ui::ET_KEY_PRESSED, ui::VKEY_A, 0, false);
   DispatchEventUsingWindowDispatcher(&known_event);
   EXPECT_TRUE(known_event.handled());
   EXPECT_EQ(1, filter->num_key_events());
 }
 
 TEST_F(WindowEventDispatcherTest, NoDelegateWindowReceivesKeyEvents) {
   scoped_ptr<Window> w1(CreateNormalWindow(1, root_window(), NULL));
   w1->Show();
   w1->Focus();
 
-  test::TestEventHandler handler;
+  ui::test::TestEventHandler handler;
   w1->AddPreTargetHandler(&handler);
   ui::KeyEvent key_press(ui::ET_KEY_PRESSED, ui::VKEY_A, 0, false);
   DispatchEventUsingWindowDispatcher(&key_press);
   EXPECT_TRUE(key_press.handled());
   EXPECT_EQ(1, handler.num_key_events());
 
   w1->RemovePreTargetHandler(&handler);
 }
 
 // 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) {
-  test::TestEventHandler* filter = new test::TestEventHandler;
+  ui::test::TestEventHandler* filter = new ui::test::TestEventHandler;
   root_window()->SetEventFilter(filter);  // passes ownership
 
   gfx::Point position = root_window()->bounds().origin();
   position.Offset(-10, -10);
   ui::TouchEvent press(ui::ET_TOUCH_PRESSED, position, 0, base::TimeDelta());
   DispatchEventUsingWindowDispatcher(&press);
   EXPECT_EQ(1, filter->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());
   DispatchEventUsingWindowDispatcher(&release);
   EXPECT_EQ(2, filter->num_touch_events());
 }
 
 // Tests that scroll events are dispatched correctly.
 TEST_F(WindowEventDispatcherTest, ScrollEventDispatch) {
   base::TimeDelta now = ui::EventTimeForNow();
-  test::TestEventHandler* filter = new test::TestEventHandler;
+  ui::test::TestEventHandler* filter = new ui::test::TestEventHandler;
   root_window()->SetEventFilter(filter);
 
   test::TestWindowDelegate delegate;
   scoped_ptr<Window> w1(CreateNormalWindow(1, root_window(), &delegate));
   w1->SetBounds(gfx::Rect(20, 20, 40, 40));
 
   // A scroll event on the root-window itself is dispatched.
   ui::ScrollEvent scroll1(ui::ET_SCROLL,
                           gfx::Point(10, 10),
                           now,
@@ skipping 329 matching lines @@
   DispatchEventUsingWindowDispatcher(&touch_moved_event);
   DispatchEventUsingWindowDispatcher(&touch_released_event);
   EXPECT_EQ("TOUCH_MOVED TOUCH_RELEASED GESTURE_TAP_CANCEL GESTURE_END",
             EventTypesToString(filter->events()));
   filter->Reset();
   host()->dispatcher()->ReleasePointerMoves();
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(filter->events().empty());
 }
 
-class HoldPointerOnScrollHandler : public test::TestEventHandler {
+class HoldPointerOnScrollHandler : public ui::test::TestEventHandler {
  public:
   HoldPointerOnScrollHandler(WindowEventDispatcher* dispatcher,
                                   EventFilterRecorder* filter)
       : dispatcher_(dispatcher),
         filter_(filter),
         holding_moves_(false) {
   }
   virtual ~HoldPointerOnScrollHandler() {}
 
  private:
@@ skipping 818 matching lines @@
 }
 
 // Verifies handling loss of capture by the capture window being destroyed.
 TEST_F(WindowEventDispatcherTest, CaptureWindowDestroyed) {
   CaptureWindowTracker capture_window_tracker;
   capture_window_tracker.CreateCaptureWindow(root_window());
   capture_window_tracker.reset();
   EXPECT_EQ(NULL, capture_window_tracker.capture_window());
 }
 
-class ExitMessageLoopOnMousePress : public test::TestEventHandler {
+class ExitMessageLoopOnMousePress : public ui::test::TestEventHandler {
  public:
   ExitMessageLoopOnMousePress() {}
   virtual ~ExitMessageLoopOnMousePress() {}
 
  protected:
   virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
-    test::TestEventHandler::OnMouseEvent(event);
+    ui::test::TestEventHandler::OnMouseEvent(event);
     if (event->type() == ui::ET_MOUSE_PRESSED)
       base::MessageLoopForUI::current()->Quit();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ExitMessageLoopOnMousePress);
 };
 
 class WindowEventDispatcherTestWithMessageLoop
     : public WindowEventDispatcherTest {
@@ skipping 81 matching lines @@
     test_screen()->SetDeviceScaleFactor(2.f);
   }
 };
 
 TEST_F(WindowEventDispatcherTestInHighDPI, EventLocationTransform) {
   test::TestWindowDelegate delegate;
   scoped_ptr<aura::Window> child(test::CreateTestWindowWithDelegate(&delegate,
       1234, gfx::Rect(20, 20, 100, 100), root_window()));
   child->Show();
 
-  test::TestEventHandler handler_child;
-  test::TestEventHandler handler_root;
+  ui::test::TestEventHandler handler_child;
+  ui::test::TestEventHandler handler_root;
   root_window()->AddPreTargetHandler(&handler_root);
   child->AddPreTargetHandler(&handler_child);
 
   {
     ui::MouseEvent move(ui::ET_MOUSE_MOVED,
                         gfx::Point(30, 30), gfx::Point(30, 30),
                         ui::EF_NONE, ui::EF_NONE);
     DispatchEventUsingWindowDispatcher(&move);
     EXPECT_EQ(0, handler_child.num_mouse_events());
     EXPECT_EQ(1, handler_root.num_mouse_events());
@@ skipping 284 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