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/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
23namespace blink {
24class WebFrame;
25class WebView;
26struct WebContextMenuData;
27}
28
29namespace gin {
30class Arguments;
31}
32
33namespace content {
34
35class TestInterfaces;
36class 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
40enum KeyLocationCode {
41  DOMKeyLocationStandard      = 0x00,
42  DOMKeyLocationLeft          = 0x01,
43  DOMKeyLocationRight         = 0x02,
44  DOMKeyLocationNumpad        = 0x03
45};
46
47class 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 SetPageScaleFactor(float scale_factor, int x, int y);
103
104  void ClearTouchPoints();
105  void ReleaseTouchPoint(unsigned index);
106  void UpdateTouchPoint(unsigned index, float x, float y);
107  void CancelTouchPoint(unsigned index);
108  void SetTouchModifier(const std::string& key_name, bool set_mask);
109  void SetTouchCancelable(bool cancelable);
110  void ThrowTouchPointError();
111
112  void DumpFilenameBeingDragged();
113
114  void GestureFlingCancel();
115  void GestureFlingStart(float x, float y, float velocity_x, float velocity_y);
116  void GestureScrollFirstPoint(int x, int y);
117
118  void TouchStart();
119  void TouchMove();
120  void TouchCancel();
121  void TouchEnd();
122
123  void LeapForward(int milliseconds);
124
125  void BeginDragWithFiles(const std::vector<std::string>& files);
126
127  void AddTouchPoint(gin::Arguments* args);
128
129  void MouseDragBegin();
130  void MouseDragEnd();
131
132  void GestureScrollBegin(gin::Arguments* args);
133  void GestureScrollEnd(gin::Arguments* args);
134  void GestureScrollUpdate(gin::Arguments* args);
135  void GestureScrollUpdateWithoutPropagation(gin::Arguments* args);
136  void GestureTap(gin::Arguments* args);
137  void GestureTapDown(gin::Arguments* args);
138  void GestureShowPress(gin::Arguments* args);
139  void GestureTapCancel(gin::Arguments* args);
140  void GestureLongPress(gin::Arguments* args);
141  void GestureLongTap(gin::Arguments* args);
142  void GestureTwoFingerTap(gin::Arguments* args);
143
144  void ContinuousMouseScrollBy(gin::Arguments* args);
145  void MouseMoveTo(gin::Arguments* args);
146  void TrackpadScrollBegin();
147  void TrackpadScroll(gin::Arguments* args);
148  void TrackpadScrollEnd();
149  void MouseScrollBy(gin::Arguments* args);
150  void MouseMomentumBegin();
151  void MouseMomentumBegin2(gin::Arguments* args);
152  void MouseMomentumScrollBy(gin::Arguments* args);
153  void MouseMomentumEnd();
154  void ScheduleAsynchronousClick(int button_number, int modifiers);
155  void ScheduleAsynchronousKeyDown(const std::string& code_str,
156                                   int modifiers,
157                                   KeyLocationCode location);
158
159  double GetCurrentEventTimeSec();
160
161  void DoLeapForward(int milliseconds);
162
163  void SendCurrentTouchEvent(blink::WebInputEvent::Type);
164
165  void GestureEvent(blink::WebInputEvent::Type, gin::Arguments*);
166
167  void UpdateClickCountForButton(blink::WebMouseEvent::Button);
168
169  void InitMouseWheelEvent(gin::Arguments* args,
170                           bool continuous,
171                           blink::WebMouseWheelEvent* event);
172
173  void FinishDragAndDrop(const blink::WebMouseEvent&, blink::WebDragOperation);
174
175  void DoMouseUp(const blink::WebMouseEvent&);
176  void DoMouseMove(const blink::WebMouseEvent&);
177  void ReplaySavedEvents();
178
179  bool force_layout_on_events() const { return force_layout_on_events_; }
180  void set_force_layout_on_events(bool force) {
181    force_layout_on_events_ = force;
182  }
183
184  bool is_drag_mode() const { return is_drag_mode_; }
185  void set_is_drag_mode(bool drag_mode) { is_drag_mode_ = drag_mode; }
186
187#if defined(OS_WIN)
188  int wm_key_down() const { return wm_key_down_; }
189  void set_wm_key_down(int key_down) { wm_key_down_ = key_down; }
190
191  int wm_key_up() const { return wm_key_up_; }
192  void set_wm_key_up(int key_up) { wm_key_up_ = key_up; }
193
194  int wm_char() const { return wm_char_; }
195  void set_wm_char(int wm_char) { wm_char_ = wm_char; }
196
197  int wm_dead_char() const { return wm_dead_char_; }
198  void set_wm_dead_char(int dead_char) {
199    wm_dead_char_ = dead_char;
200  }
201
202  int wm_sys_key_down() const { return wm_sys_key_down_; }
203  void set_wm_sys_key_down(int key_down) { wm_sys_key_down_ = key_down; }
204
205  int wm_sys_key_up() const { return wm_sys_key_up_; }
206  void set_wm_sys_key_up(int key_up) { wm_sys_key_up_ = key_up; }
207
208  int wm_sys_char() const { return wm_sys_char_; }
209  void set_wm_sys_char(int sys_char) { wm_sys_char_ = sys_char; }
210
211  int wm_sys_dead_char() const { return wm_sys_dead_char_; }
212  void set_wm_sys_dead_char(int sys_dead_char) {
213    wm_sys_dead_char_ = sys_dead_char;
214  }
215
216  int wm_key_down_;
217  int wm_key_up_;
218  int wm_char_;
219  int wm_dead_char_;
220  int wm_sys_key_down_;
221  int wm_sys_key_up_;
222  int wm_sys_char_;
223  int wm_sys_dead_char_;
224#endif
225
226  WebTaskList task_list_;
227
228  TestInterfaces* interfaces_;
229  WebTestDelegate* delegate_;
230  blink::WebView* view_;
231
232  bool force_layout_on_events_;
233
234  // When set to true (the default value), we batch mouse move and mouse up
235  // events so we can simulate drag & drop.
236  bool is_drag_mode_;
237
238  int touch_modifiers_;
239  bool touch_cancelable_;
240  std::vector<blink::WebTouchPoint> touch_points_;
241
242  scoped_ptr<blink::WebContextMenuData> last_context_menu_data_;
243
244  blink::WebDragData current_drag_data_;
245
246  // Location of the touch point that initiated a gesture.
247  blink::WebPoint current_gesture_location_;
248
249  // Currently pressed mouse button (Left/Right/Middle or None).
250  static blink::WebMouseEvent::Button pressed_button_;
251
252  bool replaying_saved_events_;
253
254  std::deque<SavedEvent> mouse_event_queue_;
255
256  blink::WebDragOperationsMask current_drag_effects_allowed_;
257
258  // Location of last mouseMoveTo event.
259  static blink::WebPoint last_mouse_pos_;
260
261  // Time and place of the last mouse up event.
262  double last_click_time_sec_;
263  blink::WebPoint last_click_pos_;
264
265  // The last button number passed to mouseDown and mouseUp.
266  // Used to determine whether the click count continues to increment or not.
267  static blink::WebMouseEvent::Button last_button_type_;
268
269  blink::WebDragOperation current_drag_effect_;
270
271  uint32 time_offset_ms_;
272  int click_count_;
273
274  base::WeakPtrFactory<EventSender> weak_factory_;
275
276  DISALLOW_COPY_AND_ASSIGN(EventSender);
277};
278
279}  // namespace content
280
281#endif  // CONTENT_SHELL_RENDERER_TEST_RUNNER_EVENT_SENDER_H_
282