Cleanups for aura/test/event_generator.h (resolve TODOs)

ash/wm/workspace/workspace_event_handler_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 "ash/wm/workspace/workspace_event_handler.h"
 
 #include "ash/screen_util.h"
 #include "ash/shell.h"
 #include "ash/test/ash_test_base.h"
 #include "ash/wm/window_state.h"
 #include "ash/wm/window_util.h"
 #include "ash/wm/wm_event.h"
 #include "ash/wm/workspace_controller.h"
 #include "ash/wm/workspace_controller_test_helper.h"
 #include "ui/aura/client/aura_constants.h"
-#include "ui/aura/test/event_generator.h"
 #include "ui/aura/test/test_window_delegate.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/base/hit_test.h"
 #include "ui/events/event_processor.h"
+#include "ui/events/test/event_generator.h"
 #include "ui/gfx/screen.h"
 #include "ui/wm/core/window_util.h"
 #include "ui/wm/public/window_move_client.h"
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #endif
 
 namespace ash {
 
@@ skipping 54 matching lines @@
   // vertically.
   gfx::Rect restored_bounds(10, 10, 50, 50);
   aura::test::TestWindowDelegate delegate;
   scoped_ptr<aura::Window> window(CreateTestWindow(&delegate, restored_bounds));
 
   wm::ActivateWindow(window.get());
 
   gfx::Rect work_area = Shell::GetScreen()->GetDisplayNearestWindow(
       window.get()).work_area();
 
-  aura::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
-                                       window.get());
+  ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
+                                     window.get());
 
   // Double-click the top resize edge.
   delegate.set_window_component(HTTOP);
   // On X a double click actually generates a drag between each press/release.
   // Explicitly trigger this path since we had bugs in dealing with it
   // correctly.
   generator.PressLeftButton();
   generator.ReleaseLeftButton();
   generator.set_flags(ui::EF_IS_DOUBLE_CLICK);
   generator.PressLeftButton();
@@ skipping 38 matching lines @@
     return;
 #endif
 
   // Verify the double clicking the resize edge works on 2nd display too.
   UpdateDisplay("200x200,400x300");
   gfx::Rect work_area2 = ScreenUtil::GetSecondaryDisplay().work_area();
   restored_bounds.SetRect(220, 20, 50, 50);
   window->SetBoundsInScreen(restored_bounds, ScreenUtil::GetSecondaryDisplay());
   aura::Window* second_root = Shell::GetAllRootWindows()[1];
   EXPECT_EQ(second_root, window->GetRootWindow());
-  aura::test::EventGenerator generator2(second_root, window.get());
+  ui::test::EventGenerator generator2(second_root, window.get());
 
   // Y-axis maximization.
   delegate.set_window_component(HTTOP);
   generator2.PressLeftButton();
   generator2.ReleaseLeftButton();
   generator2.set_flags(ui::EF_IS_DOUBLE_CLICK);
   generator2.PressLeftButton();
   generator2.MoveMouseTo(generator.current_location(), 1);
   generator2.ReleaseLeftButton();
   generator.DoubleClickLeftButton();
@@ skipping 38 matching lines @@
 
   gfx::Rect snapped_bounds_in_screen = window->GetBoundsInScreen();
   EXPECT_EQ(work_area_in_screen.x(), snapped_bounds_in_screen.x());
   EXPECT_EQ(work_area_in_screen.y(), snapped_bounds_in_screen.y());
   EXPECT_GT(work_area_in_screen.width(), snapped_bounds_in_screen.width());
   EXPECT_EQ(work_area_in_screen.height(), snapped_bounds_in_screen.height());
 
   // Double clicking the top border should not do anything for side snapped
   // windows. (They already take up the entire workspace height and reverting
   // to the restored bounds would be weird).
-  aura::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
-                                       window.get());
+  ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
+                                     window.get());
   delegate.set_window_component(HTTOP);
   generator.DoubleClickLeftButton();
   EXPECT_EQ(wm::WINDOW_STATE_TYPE_LEFT_SNAPPED, window_state->GetStateType());
   EXPECT_EQ(snapped_bounds_in_screen.ToString(),
             window->GetBoundsInScreen().ToString());
 
   // Double clicking the right border should exit the side snapped state and
   // make the window take up the entire work area.
   delegate.set_window_component(HTRIGHT);
   generator.DoubleClickLeftButton();
   EXPECT_TRUE(window_state->IsNormalStateType());
   EXPECT_EQ(work_area_in_screen.ToString(),
             window->GetBoundsInScreen().ToString());
 }
 
 TEST_F(WorkspaceEventHandlerTest,
        DoubleClickSingleAxisDoesntResizeVerticalEdgeIfConstrained) {
   gfx::Rect restored_bounds(10, 10, 50, 50);
   aura::test::TestWindowDelegate delegate;
   scoped_ptr<aura::Window> window(CreateTestWindow(&delegate, restored_bounds));
 
   wm::ActivateWindow(window.get());
 
   gfx::Rect work_area = Shell::GetScreen()->GetDisplayNearestWindow(
       window.get()).work_area();
 
   delegate.set_maximum_size(gfx::Size(0, 100));
 
-  aura::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
-                                       window.get());
+  ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
+                                     window.get());
   // Double-click the top resize edge.
   delegate.set_window_component(HTTOP);
   generator.DoubleClickLeftButton();
 
   // The size of the window should be unchanged.
   EXPECT_EQ(restored_bounds.y(), window->bounds().y());
   EXPECT_EQ(restored_bounds.height(), window->bounds().height());
 }
 
 TEST_F(WorkspaceEventHandlerTest,
        DoubleClickSingleAxisDoesntResizeHorizontalEdgeIfConstrained) {
   gfx::Rect restored_bounds(10, 10, 50, 50);
   aura::test::TestWindowDelegate delegate;
   scoped_ptr<aura::Window> window(CreateTestWindow(&delegate, restored_bounds));
 
   wm::ActivateWindow(window.get());
 
   gfx::Rect work_area = Shell::GetScreen()->GetDisplayNearestWindow(
       window.get()).work_area();
 
   delegate.set_maximum_size(gfx::Size(100, 0));
 
-  aura::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
-                                       window.get());
+  ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
+                                     window.get());
   // Double-click the top resize edge.
   delegate.set_window_component(HTRIGHT);
   generator.DoubleClickLeftButton();
 
   // The size of the window should be unchanged.
   EXPECT_EQ(restored_bounds.x(), window->bounds().x());
   EXPECT_EQ(restored_bounds.width(), window->bounds().width());
 }
 
 TEST_F(WorkspaceEventHandlerTest,
        DoubleClickOrTapWithModalChildDoesntMaximize) {
   aura::test::TestWindowDelegate delegate1;
   aura::test::TestWindowDelegate delegate2;
   scoped_ptr<aura::Window> window(
       CreateTestWindow(&delegate1, gfx::Rect(10, 20, 30, 40)));
   scoped_ptr<aura::Window> child(
       CreateTestWindow(&delegate2, gfx::Rect(0, 0, 1, 1)));
   window->SetProperty(aura::client::kCanMaximizeKey, true);
   delegate1.set_window_component(HTCAPTION);
 
   child->SetProperty(aura::client::kModalKey, ui::MODAL_TYPE_WINDOW);
   ::wm::AddTransientChild(window.get(), child.get());
 
   wm::WindowState* window_state = wm::GetWindowState(window.get());
   EXPECT_FALSE(window_state->IsMaximized());
   aura::Window* root = Shell::GetPrimaryRootWindow();
-  aura::test::EventGenerator generator(root, window.get());
+  ui::test::EventGenerator generator(root, window.get());
   generator.DoubleClickLeftButton();
   EXPECT_EQ("10,20 30x40", window->bounds().ToString());
   EXPECT_FALSE(window_state->IsMaximized());
 
   generator.GestureTapAt(gfx::Point(25, 25));
   generator.GestureTapAt(gfx::Point(25, 25));
   RunAllPendingInMessageLoop();
   EXPECT_EQ("10,20 30x40", window->bounds().ToString());
   EXPECT_FALSE(window_state->IsMaximized());
 }
 
 // Test the behavior as a result of double clicking the window header.
 TEST_F(WorkspaceEventHandlerTest, DoubleClickCaptionTogglesMaximize) {
   aura::test::TestWindowDelegate delegate;
   scoped_ptr<aura::Window> window(
       CreateTestWindow(&delegate, gfx::Rect(1, 2, 30, 40)));
   window->SetProperty(aura::client::kCanMaximizeKey, true);
 
   wm::WindowState* window_state = wm::GetWindowState(window.get());
   gfx::Rect restore_bounds = window->bounds();
   gfx::Rect work_area_in_parent = ScreenUtil::GetDisplayWorkAreaBoundsInParent(
       window.get());
 
   EXPECT_FALSE(window_state->IsMaximized());
 
   // 1) Double clicking a normal window should maximize.
   delegate.set_window_component(HTCAPTION);
   aura::Window* root = Shell::GetPrimaryRootWindow();
-  aura::test::EventGenerator generator(root, window.get());
+  ui::test::EventGenerator generator(root, window.get());
   generator.ClickLeftButton();
   generator.DoubleClickLeftButton();
   EXPECT_NE(restore_bounds.ToString(), window->bounds().ToString());
   EXPECT_TRUE(window_state->IsMaximized());
 
   generator.ClickLeftButton();
   generator.DoubleClickLeftButton();
   EXPECT_TRUE(window_state->IsNormalStateType());
   EXPECT_EQ(restore_bounds.ToString(), window->bounds().ToString());
 
@@ skipping 35 matching lines @@
 // Test that double clicking the middle button on the window header does not
 // toggle the maximized state.
 TEST_F(WorkspaceEventHandlerTest,
        DoubleClickMiddleButtonDoesNotToggleMaximize) {
   aura::test::TestWindowDelegate delegate;
   scoped_ptr<aura::Window> window(
       CreateTestWindow(&delegate, gfx::Rect(1, 2, 30, 40)));
   window->SetProperty(aura::client::kCanMaximizeKey, true);
   delegate.set_window_component(HTCAPTION);
   aura::Window* root = Shell::GetPrimaryRootWindow();
-  aura::test::EventGenerator generator(root, window.get());
+  ui::test::EventGenerator generator(root, window.get());
 
   WindowPropertyObserver observer(window.get());
   ui::MouseEvent press(ui::ET_MOUSE_PRESSED, generator.current_location(),
                        generator.current_location(),
                        ui::EF_MIDDLE_MOUSE_BUTTON | ui::EF_IS_DOUBLE_CLICK,
                        ui::EF_MIDDLE_MOUSE_BUTTON);
   ui::EventProcessor* dispatcher = root->GetHost()->event_processor();
   ui::EventDispatchDetails details = dispatcher->OnEventFromSource(&press);
   ASSERT_FALSE(details.dispatcher_destroyed);
   ui::MouseEvent release(ui::ET_MOUSE_RELEASED, generator.current_location(),
@@ skipping 10 matching lines @@
 
 TEST_F(WorkspaceEventHandlerTest, DoubleTapCaptionTogglesMaximize) {
   aura::test::TestWindowDelegate delegate;
   gfx::Rect bounds(10, 20, 30, 40);
   scoped_ptr<aura::Window> window(CreateTestWindow(&delegate, bounds));
   window->SetProperty(aura::client::kCanMaximizeKey, true);
   delegate.set_window_component(HTCAPTION);
 
   wm::WindowState* window_state = wm::GetWindowState(window.get());
   EXPECT_FALSE(window_state->IsMaximized());
-  aura::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
-                                       window.get());
+  ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
+                                     window.get());
   generator.GestureTapAt(gfx::Point(25, 25));
   generator.GestureTapAt(gfx::Point(25, 25));
   RunAllPendingInMessageLoop();
   EXPECT_NE(bounds.ToString(), window->bounds().ToString());
   EXPECT_TRUE(window_state->IsMaximized());
 
   generator.GestureTapAt(gfx::Point(5, 5));
   generator.GestureTapAt(gfx::Point(10, 10));
 
   EXPECT_FALSE(window_state->IsMaximized());
   EXPECT_EQ(bounds.ToString(), window->bounds().ToString());
 }
 
 // Verifies deleting the window while dragging doesn't crash.
 TEST_F(WorkspaceEventHandlerTest, DeleteWhenDragging) {
   // Create a large window in the background. This is necessary so that when we
   // delete |window| WorkspaceEventHandler is still the active event handler.
   aura::test::TestWindowDelegate delegate2;
   scoped_ptr<aura::Window> window2(
       CreateTestWindow(&delegate2, gfx::Rect(0, 0, 500, 500)));
 
   aura::test::TestWindowDelegate delegate;
   const gfx::Rect bounds(10, 20, 30, 40);
   scoped_ptr<aura::Window> window(CreateTestWindow(&delegate, bounds));
   delegate.set_window_component(HTCAPTION);
-  aura::test::EventGenerator generator(window->GetRootWindow());
+  ui::test::EventGenerator generator(window->GetRootWindow());
   generator.MoveMouseToCenterOf(window.get());
   generator.PressLeftButton();
   generator.MoveMouseTo(generator.current_location() + gfx::Vector2d(50, 50));
   DCHECK_NE(bounds.origin().ToString(), window->bounds().origin().ToString());
   window.reset();
   generator.MoveMouseTo(generator.current_location() + gfx::Vector2d(50, 50));
 }
 
 // Verifies deleting the window while in a run loop doesn't crash.
 TEST_F(WorkspaceEventHandlerTest, DeleteWhileInRunLoop) {
@@ skipping 22 matching lines @@
   wm::WindowState* window_state = wm::GetWindowState(window.get());
   gfx::Rect restore_bounds = window->bounds();
   gfx::Rect work_area_in_parent = ScreenUtil::GetDisplayWorkAreaBoundsInParent(
       window.get());
 
   EXPECT_FALSE(window_state->IsMaximized());
 
   // First click will go to a client
   delegate.set_window_component(HTCLIENT);
   aura::Window* root = Shell::GetPrimaryRootWindow();
-  aura::test::EventGenerator generator(root, window.get());
+  ui::test::EventGenerator generator(root, window.get());
   generator.ClickLeftButton();
   EXPECT_FALSE(window_state->IsMaximized());
 
   // Second click will go to the header
   delegate.set_window_component(HTCAPTION);
   generator.DoubleClickLeftButton();
   EXPECT_FALSE(window_state->IsMaximized());
 }
 
 // Verifies that double tapping in the header does not maximize if the target
 // component has changed.
 TEST_F(WorkspaceEventHandlerTest, DoubleTapTwoDifferentTargetsDoesntMaximize) {
   aura::test::TestWindowDelegate delegate;
   scoped_ptr<aura::Window> window(
       CreateTestWindow(&delegate, gfx::Rect(1, 2, 30, 40)));
   window->SetProperty(aura::client::kCanMaximizeKey, true);
 
   wm::WindowState* window_state = wm::GetWindowState(window.get());
   gfx::Rect restore_bounds = window->bounds();
   gfx::Rect work_area_in_parent = ScreenUtil::GetDisplayWorkAreaBoundsInParent(
       window.get());
 
   EXPECT_FALSE(window_state->IsMaximized());
 
   // First tap will go to a client
   delegate.set_window_component(HTCLIENT);
   aura::Window* root = Shell::GetPrimaryRootWindow();
-  aura::test::EventGenerator generator(root, window.get());
+  ui::test::EventGenerator generator(root, window.get());
   generator.GestureTapAt(gfx::Point(25, 25));
   EXPECT_FALSE(window_state->IsMaximized());
 
   // Second tap will go to the header
   delegate.set_window_component(HTCAPTION);
   generator.GestureTapAt(gfx::Point(25, 25));
   EXPECT_FALSE(window_state->IsMaximized());
 }
 
 TEST_F(WorkspaceEventHandlerTest,
     RightClickDuringDoubleClickDoesntMaximize) {
   aura::test::TestWindowDelegate delegate;
   scoped_ptr<aura::Window> window(
       CreateTestWindow(&delegate, gfx::Rect(1, 2, 30, 40)));
   window->SetProperty(aura::client::kCanMaximizeKey, true);
 
   wm::WindowState* window_state = wm::GetWindowState(window.get());
   gfx::Rect restore_bounds = window->bounds();
   gfx::Rect work_area_in_parent = ScreenUtil::GetDisplayWorkAreaBoundsInParent(
       window.get());
 
   EXPECT_FALSE(window_state->IsMaximized());
 
   // First click will go to a client
   delegate.set_window_component(HTCLIENT);
   aura::Window* root = Shell::GetPrimaryRootWindow();
-  aura::test::EventGenerator generator(root, window.get());
+  ui::test::EventGenerator generator(root, window.get());
   generator.ClickLeftButton();
   EXPECT_FALSE(window_state->IsMaximized());
 
   // Second click will go to the header
   delegate.set_window_component(HTCAPTION);
   generator.PressRightButton();
   generator.ReleaseRightButton();
   EXPECT_FALSE(window_state->IsMaximized());
   generator.DoubleClickLeftButton();
   EXPECT_FALSE(window_state->IsMaximized());
 }
 
 }  // namespace ash