MacViews: Add WidgetEventGenerator to abstract platform-specific event generation for tests.

ui/aura/test/event_generator.h

 // 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.
 
 #ifndef UI_AURA_TEST_EVENT_GENERATOR_H_
 #define UI_AURA_TEST_EVENT_GENERATOR_H_
 
 #include <list>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/time/time.h"
+#include "ui/base/test/event_generator_base.h"
 #include "ui/events/event_constants.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 #include "ui/gfx/point.h"
 
 namespace base {
 class TickClock;
 }
 
 namespace ui {
 class Event;
@@ skipping 48 matching lines @@
 //    handled in the nested message loop.
 // 3) Similarly, |base::MessagePumpObserver| will not be invoked.
 // 4) Any other code that requires native events, such as
 //    tests for WindowTreeHostWin/WindowTreeHostX11.
 //
 // If one of these applies to your test, please use |ui_controls|
 // package instead.
 //
 // Note: The coordinates of the points in API is determined by the
 // EventGeneratorDelegate.
-class EventGenerator {
+class EventGenerator : public ui::test::EventGeneratorBase {
  public:
   // Creates an EventGenerator with the mouse/touch location (0,0),
   // which uses the |root_window|'s coordinates.
   explicit EventGenerator(Window* root_window);
 
   // Create an EventGenerator with EventGeneratorDelegate,
   // which uses the coordinates used by |delegate|.
   explicit EventGenerator(EventGeneratorDelegate* delegate);
 
   // Creates an EventGenerator with the mouse/touch location
   // at |initial_location|, which uses the |root_window|'s coordinates.
   EventGenerator(Window* root_window, const gfx::Point& initial_location);
 
   // Creates an EventGenerator with the mouse/touch location
   // centered over |window|, which uses the |root_window|'s coordinates.
   EventGenerator(Window* root_window, Window* window);
 
   virtual ~EventGenerator();
 
-  // Explicitly sets the location used by mouse/touch events. This is set by the
-  // various methods that take a location but can be manipulated directly,
-  // typically for touch.
-  void set_current_location(const gfx::Point& location) {
-    current_location_ = location;
-  }
-  const gfx::Point& current_location() const { return current_location_; }
-
   void set_async(bool async) { async_ = async; }
   bool async() const { return async_; }
 
-  // Resets the event flags bitmask.
-  void set_flags(int flags) { flags_ = flags; }
-
-  // Generates a left button press event.
-  void PressLeftButton();
-
-  // Generates a left button release event.
-  void ReleaseLeftButton();
-
-  // Generates events to click (press, release) left button.
-  void ClickLeftButton();
-
-  // Generates a double click event using the left button.
-  void DoubleClickLeftButton();
-
-  // Generates a right button press event.
-  void PressRightButton();
-
-  // Generates a right button release event.
-  void ReleaseRightButton();
-
   // Moves the mouse wheel by |delta_x|, |delta_y|.
   void MoveMouseWheel(int delta_x, int delta_y);
 
   // Generates a mouse exit.
   void SendMouseExit();
 
   // Generates events to move mouse to be the given |point| in the
   // |current_root_window_|'s host window coordinates.
   void MoveMouseToInHost(const gfx::Point& point_in_host);
   void MoveMouseToInHost(int x, int y) {
     MoveMouseToInHost(gfx::Point(x, y));
   }
 
-  // Generates events to move mouse to be the given |point| in screen
-  // coordinates.
-  void MoveMouseTo(const gfx::Point& point_in_screen, int count);
-  void MoveMouseTo(const gfx::Point& point_in_screen) {
-    MoveMouseTo(point_in_screen, 1);
-  }
-  void MoveMouseTo(int x, int y) {
-    MoveMouseTo(gfx::Point(x, y));
-  }
-
   // Generates events to move mouse to be the given |point| in |window|'s
   // coordinates.
   void MoveMouseRelativeTo(const Window* window, const gfx::Point& point);
   void MoveMouseRelativeTo(const Window* window, int x, int y) {
     MoveMouseRelativeTo(window, gfx::Point(x, y));
   }
 
   void MoveMouseBy(int x, int y) {
-    MoveMouseTo(current_location_ + gfx::Vector2d(x, y));
-  }
-
-  // Generates events to drag mouse to given |point|.
-  void DragMouseTo(const gfx::Point& point);
-
-  void DragMouseTo(int x, int y) {
-    DragMouseTo(gfx::Point(x, y));
-  }
-
-  void DragMouseBy(int dx, int dy) {
-    DragMouseTo(current_location_ + gfx::Vector2d(dx, dy));
+    MoveMouseTo(current_location() + gfx::Vector2d(x, y));
   }
 
   // Generates events to move the mouse to the center of the window.
   void MoveMouseToCenterOf(Window* window);
 
   // Generates a touch press event.
   void PressTouch();
 
   // Generates a touch press event with |touch_id|.
   void PressTouchId(int touch_id);
@@ skipping 12 matching lines @@
 
   // Generates press, move and release event to move touch
   // to be the given |point|.
   void PressMoveAndReleaseTouchTo(const gfx::Point& point);
 
   void PressMoveAndReleaseTouchTo(int x, int y) {
     PressMoveAndReleaseTouchTo(gfx::Point(x, y));
   }
 
   void PressMoveAndReleaseTouchBy(int x, int y) {
-    PressMoveAndReleaseTouchTo(current_location_ + gfx::Vector2d(x, y));
+    PressMoveAndReleaseTouchTo(current_location() + gfx::Vector2d(x, y));
   }
 
   // Generates press, move and release events to move touch
   // to the center of the window.
   void PressMoveAndReleaseTouchToCenterOf(Window* window);
 
   // Generates and dispatches a Win8 edge-swipe event (swipe up from bottom or
   // swipe down from top).  Note that it is not possible to distinguish between
   // the two edges with this event.
   void GestureEdgeSwipe();
@@ skipping 96 matching lines @@
   void set_current_host(WindowTreeHost* host) {
     current_host_ = host;
   }
 
   // Specify an alternative tick clock to be used for simulating time in tests.
   void SetTickClock(scoped_ptr<base::TickClock> tick_clock);
 
   // Get the current time from the tick clock.
   base::TimeDelta Now();
 
+ protected:
+  // Overridden from EventGeneratorBase:
+  virtual gfx::Point GetLocationInCurrentRoot() const OVERRIDE;
+  virtual void DoMoveMouseTo(const gfx::Point& point_in_screen,
+                             int count) OVERRIDE;
+  virtual void DispatchMouseEvent(ui::EventType type,
+                                  const gfx::Point& location_in_root,
+                                  int flags,
+                                  int changed_button_flags) OVERRIDE;
+
  private:
   // Dispatch a key event to the WindowEventDispatcher.
   void DispatchKeyEvent(bool is_press, ui::KeyboardCode key_code, int flags);
 
   void UpdateCurrentDispatcher(const gfx::Point& point);
-  void PressButton(int flag);
-  void ReleaseButton(int flag);
 
   // Convert a point between API's coordinates and
   // |target|'s coordinates.
   void ConvertPointFromTarget(const aura::Window* target,
                               gfx::Point* point) const;
   void ConvertPointToTarget(const aura::Window* target,
                             gfx::Point* point) const;
 
-  gfx::Point GetLocationInCurrentRoot() const;
   gfx::Point CenterOfWindow(const Window* window) const;
 
   void DispatchNextPendingEvent();
   void DoDispatchEvent(ui::Event* event, bool async);
 
   scoped_ptr<EventGeneratorDelegate> delegate_;
-  gfx::Point current_location_;
   WindowTreeHost* current_host_;

[Ben Goodger (Google), 2014/07/11 18:26:49]

so if I understand this correctly the issue you're having here is that this
class is aura-specific and you want to use it from views. so you extract a base
class & a new specialization in views.

I think a better approach might be to move all of this code into
src/ui/events/test and remove all the aura-specific bits that way. ui/events
already has a number of abstractions implemented in both aura and views for this
specific reason (e.g. PlatformEventSource, et al.)

It seems like every method on this class that takes aura::Window* could for
example take ui::EventTarget*. And so on.

+sadrul to see if he has any further thoughts.

[sadrul, 2014/07/12 07:10:53]

I think this is a good idea! Having a generic EventGenerator (that works with
EventTarget, EventSource etc.) in //ui/events/test/ would be nice. We will
likely need some overrides for aura (and maybe eventually for non-aura views),
but that should be possible.

[tapted, 2014/07/14 11:37:47]

Done.

-  int flags_;
-  bool grab_;
   std::list<ui::Event*> pending_events_;
   // Set to true to cause events to be posted asynchronously.
   bool async_;
   scoped_ptr<base::TickClock> tick_clock_;
 
   DISALLOW_COPY_AND_ASSIGN(EventGenerator);
 };
 
 }  // namespace test
 }  // namespace aura
 
 #endif  // UI_AURA_TEST_EVENT_GENERATOR_H_