Add ability for EventGenerator to generate Scroll events asynchronously

ui/base/events/event.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_BASE_EVENTS_EVENT_H_
 #define UI_BASE_EVENTS_EVENT_H_
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/event_types.h"
@@ skipping 35 matching lines @@
     Event* event_;
 
     DISALLOW_COPY_AND_ASSIGN(DispatcherApi);
   };
 
   // For testing.
   class TestApi {
    public:
     explicit TestApi(Event* event) : event_(event) {}
 
-    void set_time_stamp(const base::TimeDelta& time_stamp) {
+    void set_time_stamp(base::TimeDelta time_stamp) {
       event_->time_stamp_ = time_stamp;
     }
 
    private:
     TestApi();
     Event* event_;
   };
 
   const base::NativeEvent& native_event() const { return native_event_; }
   EventType type() const { return type_; }
@@ skipping 67 matching lines @@
       case ET_GESTURE_PINCH_BEGIN:
       case ET_GESTURE_PINCH_END:
       case ET_GESTURE_PINCH_UPDATE:
       case ET_GESTURE_LONG_PRESS:
       case ET_GESTURE_LONG_TAP:
       case ET_GESTURE_MULTIFINGER_SWIPE:
         return true;
 
       case ET_SCROLL_FLING_CANCEL:
       case ET_SCROLL_FLING_START:
-        // These can be ScrollEvents too. But for ScrollEvents have valid native
-        // events. No gesture events have native events.
-        return !HasNativeEvent();
+        // These can be ScrollEvents too. EF_FROM_TOUCH determines if they're
+        // Gesture or Scroll events.
+        return (flags_ & EF_FROM_TOUCH) == EF_FROM_TOUCH;
 
       default:
         break;
     }
     return false;
   }
 
   bool IsScrollEvent() const {
+    // Flings can be GestureEvents too. EF_FROM_TOUCH determins if they're
+    // Gesture or Scroll events.
     return type_ == ET_SCROLL ||
            ((type_ == ET_SCROLL_FLING_START ||
-             type_ == ET_SCROLL_FLING_CANCEL) && HasNativeEvent());
+           type_ == ET_SCROLL_FLING_CANCEL) &&
+           !(flags() & EF_FROM_TOUCH));
   }
 
   bool IsScrollGestureEvent() const {
     return type_ == ET_GESTURE_SCROLL_BEGIN ||
            type_ == ET_GESTURE_SCROLL_UPDATE ||
            type_ == ET_GESTURE_SCROLL_END;
   }
 
   bool IsFlingScrollEvent() const {
     return type_ == ET_SCROLL_FLING_CANCEL ||
@@ skipping 24 matching lines @@
   Event(const Event& copy);
   void SetType(EventType type);
   void set_delete_native_event(bool delete_native_event) {
     delete_native_event_ = delete_native_event;
   }
   void set_cancelable(bool cancelable) { cancelable_ = cancelable; }
   void set_dispatch_to_hidden_targets(bool dispatch_to_hidden_targets) {
     dispatch_to_hidden_targets_ = dispatch_to_hidden_targets;
   }
 
+  void set_time_stamp(const base::TimeDelta& time_stamp) {
+    time_stamp_ = time_stamp;
+  }
+
   void set_name(const std::string& name) { name_ = name; }
 
  private:
   void operator=(const Event&);
 
   // Safely initializes the native event members of this class.
   void Init();
   void InitWithNativeEvent(const base::NativeEvent& native_event);
 
   base::NativeEvent native_event_;
@@ skipping 50 matching lines @@
   virtual void UpdateForRootTransform(const gfx::Transform& root_transform);
 
   template <class T> void ConvertLocationToTarget(T* source, T* target) {
     if (target && target != source)
       T::ConvertPointToTarget(source, target, &location_);
   }
 
  protected:
   explicit LocatedEvent(const base::NativeEvent& native_event);
 
+  explicit LocatedEvent(const LocatedEvent& model);
+
   // Create a new LocatedEvent which is identical to the provided model.
   // If source / target windows are provided, the model location will be
   // converted from |source| coordinate system to |target| coordinate system.
   template <class T>
   LocatedEvent(const LocatedEvent& model, T* source, T* target)
       : Event(model),
         location_(model.location_),
         root_location_(model.root_location_),
         valid_system_location_(model.valid_system_location_),
         system_location_(model.system_location_) {
@@ skipping 40 matching lines @@
              T* source,
              T* target,
              EventType type,
              int flags)
       : LocatedEvent(model, source, target),
         changed_button_flags_(model.changed_button_flags_) {
     SetType(type);
     set_flags(flags);
   }
 
+  explicit MouseEvent(const MouseEvent& model)
+      : LocatedEvent(model),
+        changed_button_flags_(model.changed_button_flags_) {
+  }
+
   // Used for synthetic events in testing and by the gesture recognizer.
   MouseEvent(EventType type,
              const gfx::Point& location,
              const gfx::Point& root_location,
              int flags);
 
   // Conveniences to quickly test what button is down
   bool IsOnlyLeftMouseButton() const {
     return (flags() & EF_LEFT_MOUSE_BUTTON) &&
       !(flags() & (EF_MIDDLE_MOUSE_BUTTON | EF_RIGHT_MOUSE_BUTTON));
@@ skipping 163 matching lines @@
   float radius_x_;
 
   // Radius of the Y (minor) axis of the touch ellipse. 0.0 if unknown.
   float radius_y_;
 
   // Angle of the major axis away from the X axis. Default 0.0.
   float rotation_angle_;
 
   // Force (pressure) of the touch. Normalized to be [0, 1]. Default to be 0.0.
   float force_;
-
-  DISALLOW_COPY_AND_ASSIGN(TouchEvent);
 };
 
 class UI_EXPORT KeyEvent : public Event {
  public:
   KeyEvent(const base::NativeEvent& native_event, bool is_char);
 
   // Used for synthetic events in testing.
   KeyEvent(EventType type, KeyboardCode key_code, int flags, bool is_char);
 
   // These setters allow an I18N virtual keyboard to fabricate a keyboard event
@@ skipping 30 matching lines @@
   void NormalizeFlags();
 
  private:
   KeyboardCode key_code_;
   // True if this is a translated character event (vs. a raw key down). Both
   // share the same type: ET_KEY_PRESSED.
   bool is_char_;
 
   uint16 character_;
   uint16 unmodified_character_;
-
-  DISALLOW_COPY_AND_ASSIGN(KeyEvent);
 };
 
 // A key event which is translated by an input method (IME).
 // For example, if an IME receives a KeyEvent(VKEY_SPACE), and it does not
 // consume the key, the IME usually generates and dispatches a
 // TranslatedKeyEvent(VKEY_SPACE) event. If the IME receives a KeyEvent and
 // it does consume the event, it might dispatch a
 // TranslatedKeyEvent(VKEY_PROCESSKEY) event as defined in the DOM spec.
 class UI_EXPORT TranslatedKeyEvent : public KeyEvent {
  public:
@@ skipping 29 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(DropTargetEvent);
 };
 
 class UI_EXPORT ScrollEvent : public MouseEvent {
  public:
   explicit ScrollEvent(const base::NativeEvent& native_event);
   template <class T>
   ScrollEvent(const ScrollEvent& model,
               T* source,
-              T* target,
-              EventType type,
-              int flags)
-      : MouseEvent(model, source, target, type, flags),
+              T* target)
+      : MouseEvent(model, source, target),
         x_offset_(model.x_offset_),
         y_offset_(model.y_offset_),
         finger_count_(model.finger_count_){
   }
 
   // Used for tests.
   ScrollEvent(EventType type,
               const gfx::Point& location,
+              base::TimeDelta time_stamp,
               int flags,
               float x_offset,
-              float y_offset);
+              float y_offset,
+              int finger_count);
 
   // Scale the scroll event's offset value.
   // This is useful in the multi-monitor setup where it needs to be scaled
   // to provide a consistent user experience.
   void Scale(const float factor);
 
   float x_offset() const { return x_offset_; }
   float y_offset() const { return y_offset_; }
   int finger_count() const { return finger_count_; }
 
  private:
   float x_offset_;
   float y_offset_;
   int finger_count_;
-
-  DISALLOW_COPY_AND_ASSIGN(ScrollEvent);
 };
 
 class UI_EXPORT GestureEvent : public LocatedEvent {
  public:
   GestureEvent(EventType type,
                int x,
                int y,
                int flags,
                base::TimeDelta time_stamp,
                const GestureEventDetails& details,
@@ skipping 25 matching lines @@
   // This value is stored as a bitfield because the number of touch ids varies,
   // but we currently don't need more than 32 touches at a time.
   const unsigned int touch_ids_bitfield_;
 
   DISALLOW_COPY_AND_ASSIGN(GestureEvent);
 };
 
 }  // namespace ui
 
 #endif  // UI_BASE_EVENTS_EVENT_H_