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

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/capture_client.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_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/event_generator.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 {
 
 // A delegate that always returns a non-client component for hit tests.
@@ skipping 270 matching lines @@
   client.Lock();
 
   // Since we're locked, the attempt to focus w2 will be ignored.
   w2->Focus();
   EXPECT_TRUE(IsFocusedWindow(w1));
   EXPECT_FALSE(IsFocusedWindow(w2));
 
   {
     // Attempting to send a key event to w1 (not in the lock container) should
     // cause focus to be reset.
-    test::EventGenerator generator(root_window());
+    ui::test::EventGenerator generator(root_window());
     generator.PressKey(ui::VKEY_SPACE, 0);
     EXPECT_EQ(NULL, client::GetFocusClient(w1)->GetFocusedWindow());
     EXPECT_FALSE(IsFocusedWindow(w1));
   }
 
   {
     // Events sent to a window not in the lock container will not be processed.
     // i.e. never sent to the non-lock container's event filter.
-    test::EventGenerator generator(root_window(), w1);
+    ui::test::EventGenerator generator(root_window(), w1);
     generator.ClickLeftButton();
     EXPECT_EQ(0, nonlock_ef.num_mouse_events());
 
     // Events sent to a window in the lock container will be processed.
-    test::EventGenerator generator3(root_window(), w3.get());
+    ui::test::EventGenerator generator3(root_window(), w3.get());
     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) {
@@ skipping 473 matching lines @@
 // gesture if touch-move events are being held by the dispatcher.
 TEST_F(WindowEventDispatcherTest, TouchMovesHeldOnScroll) {
   EventFilterRecorder recorder;
   root_window()->AddPreTargetHandler(&recorder);
   test::TestWindowDelegate delegate;
   HoldPointerOnScrollHandler handler(host()->dispatcher(), &recorder);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       &delegate, 1, gfx::Rect(50, 50, 100, 100), root_window()));
   window->AddPreTargetHandler(&handler);
 
-  test::EventGenerator generator(root_window());
+  ui::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
   // 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();
@@ skipping 316 matching lines @@
   // Deleting the window should not cause a crash, only prevent further
   // processing from occurring.
   scoped_ptr<Window> w1(CreateNormalWindow(1, root_window(), NULL));
   DeletingWindowDelegate d11;
   Window* w11 = CreateNormalWindow(11, w1.get(), &d11);
   WindowTracker tracker;
   DeletingEventFilter w1_filter;
   w1->AddPreTargetHandler(&w1_filter);
   client::GetFocusClient(w1.get())->FocusWindow(w11);
 
-  test::EventGenerator generator(root_window(), w11);
+  ui::test::EventGenerator generator(root_window(), w11);
 
   // First up, no one deletes anything.
   tracker.Add(w11);
   d11.Reset(w11, false);
 
   generator.PressLeftButton();
   EXPECT_TRUE(tracker.Contains(w11));
   EXPECT_TRUE(d11.got_event());
   generator.ReleaseLeftButton();
 
@@ skipping 43 matching lines @@
 }  // namespace
 
 // Tests that the gesture recognizer is reset for all child windows when a
 // window hides. No expectations, just checks that the test does not crash.
 TEST_F(WindowEventDispatcherTest,
        GestureRecognizerResetsTargetWhenParentHides) {
   scoped_ptr<Window> w1(CreateNormalWindow(1, root_window(), NULL));
   DetachesParentOnTapDelegate delegate;
   scoped_ptr<Window> parent(CreateNormalWindow(22, w1.get(), NULL));
   Window* child = CreateNormalWindow(11, parent.get(), &delegate);
-  test::EventGenerator generator(root_window(), child);
+  ui::test::EventGenerator generator(root_window(), child);
   generator.GestureTapAt(gfx::Point(40, 40));
 }
 
 namespace {
 
 // A window delegate that processes nested gestures on tap.
 class NestedGestureDelegate : public test::TestWindowDelegate {
  public:
-  NestedGestureDelegate(test::EventGenerator* generator,
+  NestedGestureDelegate(ui::test::EventGenerator* generator,
                         const gfx::Point tap_location)
       : generator_(generator),
         tap_location_(tap_location),
         gesture_end_count_(0) {}
   virtual ~NestedGestureDelegate() {}
 
   int gesture_end_count() const { return gesture_end_count_; }
 
  private:
   virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE {
     switch (event->type()) {
       case ui::ET_GESTURE_TAP_DOWN:
         event->SetHandled();
         break;
       case ui::ET_GESTURE_TAP:
         if (generator_)
           generator_->GestureTapAt(tap_location_);
         event->SetHandled();
         break;
       case ui::ET_GESTURE_END:
         ++gesture_end_count_;
         break;
       default:
         break;
     }
   }
 
-  test::EventGenerator* generator_;
+  ui::test::EventGenerator* generator_;
   const gfx::Point tap_location_;
   int gesture_end_count_;
   DISALLOW_COPY_AND_ASSIGN(NestedGestureDelegate);
 };
 
 }  // namespace
 
 // Tests that gesture end is delivered after nested gesture processing.
 TEST_F(WindowEventDispatcherTest, GestureEndDeliveredAfterNestedGestures) {
   NestedGestureDelegate d1(NULL, gfx::Point());
   scoped_ptr<Window> w1(CreateNormalWindow(1, root_window(), &d1));
   w1->SetBounds(gfx::Rect(0, 0, 100, 100));
 
-  test::EventGenerator nested_generator(root_window(), w1.get());
+  ui::test::EventGenerator nested_generator(root_window(), w1.get());
   NestedGestureDelegate d2(&nested_generator, w1->bounds().CenterPoint());
   scoped_ptr<Window> w2(CreateNormalWindow(1, root_window(), &d2));
   w2->SetBounds(gfx::Rect(100, 0, 100, 100));
 
   // Tap on w2 which triggers nested gestures for w1.
-  test::EventGenerator generator(root_window(), w2.get());
+  ui::test::EventGenerator generator(root_window(), w2.get());
   generator.GestureTapAt(w2->bounds().CenterPoint());
 
   // Both windows should get their gesture end events.
   EXPECT_EQ(1, d1.gesture_end_count());
   EXPECT_EQ(1, d2.gesture_end_count());
 }
 
 // Tests whether we can repost the Tap down gesture event.
 TEST_F(WindowEventDispatcherTest, RepostTapdownGestureTest) {
   EventFilterRecorder recorder;
@@ skipping 96 matching lines @@
 
   scoped_ptr<aura::Window> repost_source(CreateTestWindowWithDelegate(
       &delegate, 1, gfx::Rect(0, 0, 50, 50), root_window()));
 
   RepostGestureEventRecorder repost_event_recorder(repost_source.get(),
                                                    repost_target.get());
   root_window()->AddPreTargetHandler(&repost_event_recorder);
 
   // Generate a tap down gesture for the repost_source. This will be reposted
   // to repost_target.
-  test::EventGenerator repost_generator(root_window(), repost_source.get());
+  ui::test::EventGenerator repost_generator(root_window(), repost_source.get());
   repost_generator.GestureTapAt(gfx::Point(40, 40));
   RunAllPendingInMessageLoop();
 
-  test::EventGenerator scroll_generator(root_window(), repost_target.get());
+  ui::test::EventGenerator scroll_generator(root_window(), repost_target.get());
   scroll_generator.GestureScrollSequence(
       gfx::Point(80, 80),
       gfx::Point(100, 100),
       base::TimeDelta::FromMilliseconds(100),
       3);
   RunAllPendingInMessageLoop();
 
   int tap_down_count = 0;
   for (size_t i = 0; i < repost_event_recorder.events().size(); ++i) {
     if (repost_event_recorder.events()[i] == ui::ET_GESTURE_TAP_DOWN)
@@ skipping 39 matching lines @@
 // 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;
   w1->AddPreTargetHandler(&w1_filter);
   w1->SetBounds(gfx::Rect(20, 20, 60, 60));
   EXPECT_EQ(NULL, host()->dispatcher()->mouse_moved_handler());
 
-  test::EventGenerator generator(root_window(), w1.get());
+  ui::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(), 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());
@@ skipping 480 matching lines @@
 
 TEST_F(WindowEventDispatcherTestInHighDPI, TouchMovesHeldOnScroll) {
   EventFilterRecorder recorder;
   root_window()->AddPreTargetHandler(&recorder);
   test::TestWindowDelegate delegate;
   HoldPointerOnScrollHandler handler(host()->dispatcher(), &recorder);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       &delegate, 1, gfx::Rect(50, 50, 100, 100), root_window()));
   window->AddPreTargetHandler(&handler);
 
-  test::EventGenerator generator(root_window());
+  ui::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
   // 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();
@@ skipping 21 matching lines @@
     window_ = window.Pass();
   }
   bool has_window() const { return !!window_.get(); }
 
  private:
   scoped_ptr<aura::Window> window_;
   DISALLOW_COPY_AND_ASSIGN(SelfDestructDelegate);
 };
 
 TEST_F(WindowEventDispatcherTest, SynthesizedLocatedEvent) {
-  test::EventGenerator generator(root_window());
+  ui::test::EventGenerator generator(root_window());
   generator.MoveMouseTo(10, 10);
   EXPECT_EQ("10,10",
             Env::GetInstance()->last_mouse_location().ToString());
 
   // Synthesized event should not update the mouse location.
   ui::MouseEvent mouseev(ui::ET_MOUSE_MOVED, gfx::Point(), gfx::Point(),
                          ui::EF_IS_SYNTHESIZED, 0);
   generator.Dispatch(&mouseev);
   EXPECT_EQ("10,10",
             Env::GetInstance()->last_mouse_location().ToString());
@@ skipping 241 matching lines @@
                        ui::EF_LEFT_MOUSE_BUTTON);
   DispatchEventUsingWindowDispatcher(&mouse);
   EXPECT_TRUE(recorder_first.events().empty());
   ASSERT_EQ(1u, recorder_second.events().size());
   EXPECT_EQ(ui::ET_MOUSE_PRESSED, recorder_second.events()[0]);
   EXPECT_EQ(event_location.ToString(),
             recorder_second.mouse_locations()[0].ToString());
 }
 
 }  // namespace aura