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