Add ability for EventGenerator to generate Scroll events asynchronously

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/memory/scoped_ptr.h"
 #include "ui/base/keycodes/keyboard_codes.h"
 #include "ui/gfx/point.h"
 
 namespace base {
 class TimeDelta;
 }
 
 namespace ui {
 class Event;
+class KeyEvent;
+class MouseEvent;
+class ScrollEvent;
+class TouchEvent;
 }
 
 namespace aura {
 class RootWindow;
 class Window;
 
 namespace client {
 class ScreenPositionClient;
 }
 
@@ skipping 39 matching lines @@
   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.
@@ skipping 94 matching lines @@
   // relevant when testing velocity/fling/swipe, otherwise these can be any
   // non-zero value. |delta_x| and |delta_y| are the amount that each finger
   // should be moved.
   void GestureMultiFingerScroll(int count,
                                 const gfx::Point* start,
                                 int event_separation_time_ms,
                                 int steps,
                                 int move_x,
                                 int move_y);
 
+  // Generates scroll sequences of a FlingCancel, Scrolls, FlingStart, with
+  // constant deltas to |x_offset| and |y_offset| in |steps|.
+  void ScrollSequence(const gfx::Point& start,
+                      const base::TimeDelta& step_delay,
+                      float x_offset,
+                      float y_offset,
+                      int steps,
+                      int num_fingers);
+
+  // Generates scroll sequences of a FlingCancel, Scrolls, FlingStart, sending
+  // scrolls of each of the values in |offsets|.
+  void ScrollSequence(const gfx::Point& start,
+                      const base::TimeDelta& step_delay,
+                      const std::vector<gfx::Point>& offsets,
+                      int num_fingers);
+
   // Generates a key press event. On platforms except Windows and X11, a key
   // event without native_event() is generated. Note that ui::EF_ flags should
   // be passed as |flags|, not the native ones like 'ShiftMask' in <X11/X.h>.
   // TODO(yusukes): Support native_event() on all platforms.
   void PressKey(ui::KeyboardCode key_code, int flags);
 
   // Generates a key release event. On platforms except Windows and X11, a key
   // event without native_event() is generated. Note that ui::EF_ flags should
   // be passed as |flags|, not the native ones like 'ShiftMask' in <X11/X.h>.
   // TODO(yusukes): Support native_event() on all platforms.
   void ReleaseKey(ui::KeyboardCode key_code, int flags);
 
-  // Dispatch the |event| to the RootWindow.
-  void Dispatch(ui::Event& event);
+  // Dispatch the event to the RootWindow.
+  void Dispatch(ui::Event* event);
 
   void set_current_root_window(RootWindow* root_window) {
     current_root_window_ = root_window;
   }
 
  private:
   // Dispatch a key event to the RootWindow.
   void DispatchKeyEvent(bool is_press, ui::KeyboardCode key_code, int flags);
 
   void UpdateCurrentRootWindow(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_;
   RootWindow* current_root_window_;
   int flags_;
   bool grab_;
+  std::list<ui::Event*> pending_events_;
+  // Set to true to cause events to be posted asynchronously.
+  bool async_;
 
   DISALLOW_COPY_AND_ASSIGN(EventGenerator);
 };
 
 }  // namespace test
 }  // namespace aura
 
 #endif  // UI_AURA_TEST_EVENT_GENERATOR_H_