components/test_runner/event_sender.h

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef COMPONENTS_TEST_RUNNER_EVENT_SENDER_H_
   6 #define COMPONENTS_TEST_RUNNER_EVENT_SENDER_H_
   7
   8 #include <queue>
   9 #include <string>
  10 #include <vector>
  11
  12 #include "base/macros.h"
  13 #include "base/memory/scoped_ptr.h"
  14 #include "base/memory/weak_ptr.h"
  15 #include "build/build_config.h"
  16 #include "components/test_runner/web_task.h"
  17 #include "third_party/WebKit/public/platform/WebDragData.h"
  18 #include "third_party/WebKit/public/platform/WebPoint.h"
  19 #include "third_party/WebKit/public/web/WebDragOperation.h"
  20 #include "third_party/WebKit/public/web/WebInputEvent.h"
  21 #include "third_party/WebKit/public/web/WebTouchPoint.h"
  22
  23 namespace blink {
  24 class WebFrame;
  25 class WebView;
  26 struct WebContextMenuData;
  27 }
  28
  29 namespace gin {
  30 class Arguments;
  31 }
  32
  33 namespace test_runner {
  34
  35 class TestInterfaces;
  36 class WebTestDelegate;
  37
  38 // Key event location code introduced in DOM Level 3.
  39 // See also: http://www.w3.org/TR/DOM-Level-3-Events/#events-keyboardevents
  40 enum KeyLocationCode {
  41   DOMKeyLocationStandard      = 0x00,
  42   DOMKeyLocationLeft          = 0x01,
  43   DOMKeyLocationRight         = 0x02,
  44   DOMKeyLocationNumpad        = 0x03
  45 };
  46
  47 class EventSender : public base::SupportsWeakPtr<EventSender> {
  48  public:
  49   explicit EventSender(TestInterfaces*);
  50   virtual ~EventSender();
  51
  52   void Reset();
  53   void Install(blink::WebFrame*);
  54   void SetDelegate(WebTestDelegate*);
  55   void SetWebView(blink::WebView*);
  56
  57   void SetContextMenuData(const blink::WebContextMenuData&);
  58
  59   void DoDragDrop(const blink::WebDragData&, blink::WebDragOperationsMask);
  60
  61   void MouseDown(int button_number, int modifiers);
  62   void MouseUp(int button_number, int modifiers);
  63   void KeyDown(const std::string& code_str,
  64                int modifiers,
  65                KeyLocationCode location);
  66
  67   WebTaskList* mutable_task_list() { return &task_list_; }
  68
  69  private:
  70   friend class EventSenderBindings;
  71
  72   struct SavedEvent {
  73     enum SavedEventType {
  74       TYPE_UNSPECIFIED,
  75       TYPE_MOUSE_UP,
  76       TYPE_MOUSE_MOVE,
  77       TYPE_LEAP_FORWARD
  78     };
  79
  80     SavedEvent();
  81
  82     SavedEventType type;
  83     blink::WebMouseEvent::Button button_type;  // For MouseUp.
  84     blink::WebPoint pos;                       // For MouseMove.
  85     int milliseconds;                          // For LeapForward.
  86     int modifiers;
  87   };
  88
  89   void EnableDOMUIEventLogging();
  90   void FireKeyboardEventsToElement();
  91   void ClearKillRing();
  92
  93   std::vector<std::string> ContextClick();
  94
  95   void TextZoomIn();
  96   void TextZoomOut();
  97
  98   void ZoomPageIn();
  99   void ZoomPageOut();
 100   void SetPageZoomFactor(double zoom_factor);
 101
 102   void ClearTouchPoints();
 103   void ReleaseTouchPoint(unsigned index);
 104   void UpdateTouchPoint(unsigned index, float x, float y);
 105   void CancelTouchPoint(unsigned index);
 106   void SetTouchModifier(const std::string& key_name, bool set_mask);
 107   void SetTouchCancelable(bool cancelable);
 108   void ThrowTouchPointError();
 109
 110   void DumpFilenameBeingDragged();
 111
 112   void GestureFlingCancel();
 113   void GestureFlingStart(float x,
 114                          float y,
 115                          float velocity_x,
 116                          float velocity_y,
 117                          gin::Arguments* args);
 118   void GestureScrollFirstPoint(int x, int y);
 119
 120   void TouchStart();
 121   void TouchMove();
 122   void TouchCancel();
 123   void TouchEnd();
 124
 125   void LeapForward(int milliseconds);
 126
 127   void BeginDragWithFiles(const std::vector<std::string>& files);
 128
 129   void AddTouchPoint(gin::Arguments* args);
 130
 131   void MouseDragBegin();
 132   void MouseDragEnd();
 133
 134   void GestureScrollBegin(gin::Arguments* args);
 135   void GestureScrollEnd(gin::Arguments* args);
 136   void GestureScrollUpdate(gin::Arguments* args);
 137   void GesturePinchBegin(gin::Arguments* args);
 138   void GesturePinchEnd(gin::Arguments* args);
 139   void GesturePinchUpdate(gin::Arguments* args);
 140   void GestureTap(gin::Arguments* args);
 141   void GestureTapDown(gin::Arguments* args);
 142   void GestureShowPress(gin::Arguments* args);
 143   void GestureTapCancel(gin::Arguments* args);
 144   void GestureLongPress(gin::Arguments* args);
 145   void GestureLongTap(gin::Arguments* args);
 146   void GestureTwoFingerTap(gin::Arguments* args);
 147
 148   void ContinuousMouseScrollBy(gin::Arguments* args);
 149   void MouseMoveTo(gin::Arguments* args);
 150   void MouseLeave();
 151   void TrackpadScrollBegin();
 152   void TrackpadScroll(gin::Arguments* args);
 153   void TrackpadScrollEnd();
 154   void MouseScrollBy(gin::Arguments* args);
 155   void MouseMomentumBegin();
 156   void MouseMomentumBegin2(gin::Arguments* args);
 157   void MouseMomentumScrollBy(gin::Arguments* args);
 158   void MouseMomentumEnd();
 159   void ScheduleAsynchronousClick(int button_number, int modifiers);
 160   void ScheduleAsynchronousKeyDown(const std::string& code_str,
 161                                    int modifiers,
 162                                    KeyLocationCode location);
 163
 164   double GetCurrentEventTimeSec();
 165
 166   void DoLeapForward(int milliseconds);
 167
 168   void SendCurrentTouchEvent(blink::WebInputEvent::Type);
 169
 170   void GestureEvent(blink::WebInputEvent::Type,
 171                     gin::Arguments*);
 172
 173   void UpdateClickCountForButton(blink::WebMouseEvent::Button);
 174
 175   void InitMouseWheelEvent(gin::Arguments* args,
 176                            bool continuous,
 177                            blink::WebMouseWheelEvent* event);
 178
 179   void FinishDragAndDrop(const blink::WebMouseEvent&, blink::WebDragOperation);
 180
 181   void DoMouseUp(const blink::WebMouseEvent&);
 182   void DoMouseMove(const blink::WebMouseEvent&);
 183   void ReplaySavedEvents();
 184   bool HandleInputEventOnViewOrPopup(const blink::WebInputEvent&);
 185
 186   bool force_layout_on_events() const { return force_layout_on_events_; }
 187   void set_force_layout_on_events(bool force) {
 188     force_layout_on_events_ = force;
 189   }
 190
 191   bool is_drag_mode() const { return is_drag_mode_; }
 192   void set_is_drag_mode(bool drag_mode) { is_drag_mode_ = drag_mode; }
 193
 194 #if defined(OS_WIN)
 195   int wm_key_down() const { return wm_key_down_; }
 196   void set_wm_key_down(int key_down) { wm_key_down_ = key_down; }
 197
 198   int wm_key_up() const { return wm_key_up_; }
 199   void set_wm_key_up(int key_up) { wm_key_up_ = key_up; }
 200
 201   int wm_char() const { return wm_char_; }
 202   void set_wm_char(int wm_char) { wm_char_ = wm_char; }
 203
 204   int wm_dead_char() const { return wm_dead_char_; }
 205   void set_wm_dead_char(int dead_char) {
 206     wm_dead_char_ = dead_char;
 207   }
 208
 209   int wm_sys_key_down() const { return wm_sys_key_down_; }
 210   void set_wm_sys_key_down(int key_down) { wm_sys_key_down_ = key_down; }
 211
 212   int wm_sys_key_up() const { return wm_sys_key_up_; }
 213   void set_wm_sys_key_up(int key_up) { wm_sys_key_up_ = key_up; }
 214
 215   int wm_sys_char() const { return wm_sys_char_; }
 216   void set_wm_sys_char(int sys_char) { wm_sys_char_ = sys_char; }
 217
 218   int wm_sys_dead_char() const { return wm_sys_dead_char_; }
 219   void set_wm_sys_dead_char(int sys_dead_char) {
 220     wm_sys_dead_char_ = sys_dead_char;
 221   }
 222
 223   int wm_key_down_;
 224   int wm_key_up_;
 225   int wm_char_;
 226   int wm_dead_char_;
 227   int wm_sys_key_down_;
 228   int wm_sys_key_up_;
 229   int wm_sys_char_;
 230   int wm_sys_dead_char_;
 231 #endif
 232
 233   WebTaskList task_list_;
 234
 235   TestInterfaces* interfaces_;
 236   WebTestDelegate* delegate_;
 237   blink::WebView* view_;
 238
 239   bool force_layout_on_events_;
 240
 241   // When set to true (the default value), we batch mouse move and mouse up
 242   // events so we can simulate drag & drop.
 243   bool is_drag_mode_;
 244
 245   int touch_modifiers_;
 246   bool touch_cancelable_;
 247   std::vector<blink::WebTouchPoint> touch_points_;
 248
 249   scoped_ptr<blink::WebContextMenuData> last_context_menu_data_;
 250
 251   blink::WebDragData current_drag_data_;
 252
 253   // Location of the touch point that initiated a gesture.
 254   blink::WebPoint current_gesture_location_;
 255
 256   // Currently pressed mouse button (Left/Right/Middle or None).
 257   static blink::WebMouseEvent::Button pressed_button_;
 258   static int modifiers_;
 259
 260   bool replaying_saved_events_;
 261
 262   std::deque<SavedEvent> mouse_event_queue_;
 263
 264   blink::WebDragOperationsMask current_drag_effects_allowed_;
 265
 266   // Location of last mouseMoveTo event.
 267   static blink::WebPoint last_mouse_pos_;
 268
 269   // Time and place of the last mouse up event.
 270   double last_click_time_sec_;
 271   blink::WebPoint last_click_pos_;
 272
 273   // The last button number passed to mouseDown and mouseUp.
 274   // Used to determine whether the click count continues to increment or not.
 275   static blink::WebMouseEvent::Button last_button_type_;
 276
 277   blink::WebDragOperation current_drag_effect_;
 278
 279   uint32 time_offset_ms_;
 280   int click_count_;
 281
 282   base::WeakPtrFactory<EventSender> weak_factory_;
 283
 284   DISALLOW_COPY_AND_ASSIGN(EventSender);
 285 };
 286
 287 }  // namespace test_runner
 288
 289 #endif  // COMPONENTS_TEST_RUNNER_EVENT_SENDER_H_