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 #include "content/browser/renderer_host/input/touch_emulator.h"
6
7 #include "content/browser/renderer_host/input/motion_event_web.h"
8 #include "content/browser/renderer_host/input/web_input_event_util.h"
9 #include "content/common/input/web_touch_event_traits.h"
10 #include "content/grit/content_resources.h"
11 #include "content/public/common/content_client.h"
12 #include "content/public/common/content_switches.h"
13 #include "third_party/WebKit/public/platform/WebCursorInfo.h"
14 #include "ui/events/gesture_detection/gesture_config_helper.h"
15 #include "ui/gfx/image/image.h"
16 #include "ui/gfx/screen.h"
17
18 using blink::WebGestureEvent;
19 using blink::WebInputEvent;
20 using blink::WebKeyboardEvent;
21 using blink::WebMouseEvent;
22 using blink::WebMouseWheelEvent;
23 using blink::WebTouchEvent;
24 using blink::WebTouchPoint;
25
26 namespace content {
27
28 namespace {
29
GetGestureProviderConfig()30 ui::GestureProvider::Config GetGestureProviderConfig() {
31 // TODO(dgozman): Use different configs to emulate mobile/desktop as
32 // requested by renderer.
33 ui::GestureProvider::Config config = ui::DefaultGestureProviderConfig();
34 config.gesture_begin_end_types_enabled = false;
35 config.gesture_detector_config.swipe_enabled = false;
36 config.gesture_detector_config.two_finger_tap_enabled = false;
37 return config;
38 }
39
40 // Time between two consecutive mouse moves, during which second mouse move
41 // is not converted to touch.
42 const double kMouseMoveDropIntervalSeconds = 5.f / 1000;
43
44 } // namespace
45
TouchEmulator(TouchEmulatorClient * client)46 TouchEmulator::TouchEmulator(TouchEmulatorClient* client)
47 : client_(client),
48 gesture_provider_(GetGestureProviderConfig(), this),
49 enabled_(false),
50 emulated_stream_active_sequence_count_(0),
51 native_stream_active_sequence_count_(0) {
52 DCHECK(client_);
53 ResetState();
54
55 bool use_2x = gfx::Screen::GetNativeScreen()->
56 GetPrimaryDisplay().device_scale_factor() > 1.5f;
57 float cursor_scale_factor = use_2x ? 2.f : 1.f;
58 cursor_size_ = InitCursorFromResource(&touch_cursor_,
59 cursor_scale_factor,
60 use_2x ? IDR_DEVTOOLS_TOUCH_CURSOR_ICON_2X :
61 IDR_DEVTOOLS_TOUCH_CURSOR_ICON);
62 InitCursorFromResource(&pinch_cursor_,
63 cursor_scale_factor,
64 use_2x ? IDR_DEVTOOLS_PINCH_CURSOR_ICON_2X :
65 IDR_DEVTOOLS_PINCH_CURSOR_ICON);
66
67 WebCursor::CursorInfo cursor_info;
68 cursor_info.type = blink::WebCursorInfo::TypePointer;
69 pointer_cursor_.InitFromCursorInfo(cursor_info);
70
71 // TODO(dgozman): Use synthetic secondary touch to support multi-touch.
72 gesture_provider_.SetMultiTouchZoomSupportEnabled(false);
73 // TODO(dgozman): Enable double tap if requested by the renderer.
74 // TODO(dgozman): Don't break double-tap-based pinch with shift handling.
75 gesture_provider_.SetDoubleTapSupportForPlatformEnabled(false);
76 }
77
~TouchEmulator()78 TouchEmulator::~TouchEmulator() {
79 // We cannot cleanup properly in destructor, as we need roundtrip to the
80 // renderer for ack. Instead, the owner should call Disable, and only
81 // destroy this object when renderer is dead.
82 }
83
ResetState()84 void TouchEmulator::ResetState() {
85 last_mouse_event_was_move_ = false;
86 last_mouse_move_timestamp_ = 0;
87 mouse_pressed_ = false;
88 shift_pressed_ = false;
89 suppress_next_fling_cancel_ = false;
90 pinch_scale_ = 1.f;
91 pinch_gesture_active_ = false;
92 }
93
Enable()94 void TouchEmulator::Enable() {
95 if (!enabled_) {
96 enabled_ = true;
97 ResetState();
98 }
99 UpdateCursor();
100 }
101
Disable()102 void TouchEmulator::Disable() {
103 if (!enabled_)
104 return;
105
106 enabled_ = false;
107 UpdateCursor();
108 CancelTouch();
109 }
110
InitCursorFromResource(WebCursor * cursor,float scale,int resource_id)111 gfx::SizeF TouchEmulator::InitCursorFromResource(
112 WebCursor* cursor, float scale, int resource_id) {
113 gfx::Image& cursor_image =
114 content::GetContentClient()->GetNativeImageNamed(resource_id);
115 WebCursor::CursorInfo cursor_info;
116 cursor_info.type = blink::WebCursorInfo::TypeCustom;
117 cursor_info.image_scale_factor = scale;
118 cursor_info.custom_image = cursor_image.AsBitmap();
119 cursor_info.hotspot =
120 gfx::Point(cursor_image.Width() / 2, cursor_image.Height() / 2);
121 #if defined(OS_WIN)
122 cursor_info.external_handle = 0;
123 #endif
124
125 cursor->InitFromCursorInfo(cursor_info);
126 return gfx::ScaleSize(cursor_image.Size(), 1.f / scale);
127 }
128
HandleMouseEvent(const WebMouseEvent & mouse_event)129 bool TouchEmulator::HandleMouseEvent(const WebMouseEvent& mouse_event) {
130 if (!enabled_)
131 return false;
132
133 if (mouse_event.button == WebMouseEvent::ButtonRight &&
134 mouse_event.type == WebInputEvent::MouseDown) {
135 client_->ShowContextMenuAtPoint(gfx::Point(mouse_event.x, mouse_event.y));
136 }
137
138 if (mouse_event.button != WebMouseEvent::ButtonLeft)
139 return true;
140
141 if (mouse_event.type == WebInputEvent::MouseMove) {
142 if (last_mouse_event_was_move_ &&
143 mouse_event.timeStampSeconds < last_mouse_move_timestamp_ +
144 kMouseMoveDropIntervalSeconds)
145 return true;
146
147 last_mouse_event_was_move_ = true;
148 last_mouse_move_timestamp_ = mouse_event.timeStampSeconds;
149 } else {
150 last_mouse_event_was_move_ = false;
151 }
152
153 if (mouse_event.type == WebInputEvent::MouseDown)
154 mouse_pressed_ = true;
155 else if (mouse_event.type == WebInputEvent::MouseUp)
156 mouse_pressed_ = false;
157
158 UpdateShiftPressed((mouse_event.modifiers & WebInputEvent::ShiftKey) != 0);
159
160 if (FillTouchEventAndPoint(mouse_event) &&
161 gesture_provider_.OnTouchEvent(MotionEventWeb(touch_event_))) {
162 ForwardTouchEventToClient();
163 }
164
165 // Do not pass mouse events to the renderer.
166 return true;
167 }
168
HandleMouseWheelEvent(const WebMouseWheelEvent & event)169 bool TouchEmulator::HandleMouseWheelEvent(const WebMouseWheelEvent& event) {
170 if (!enabled_)
171 return false;
172
173 // Send mouse wheel for easy scrolling when there is no active touch.
174 return emulated_stream_active_sequence_count_ > 0;
175 }
176
HandleKeyboardEvent(const WebKeyboardEvent & event)177 bool TouchEmulator::HandleKeyboardEvent(const WebKeyboardEvent& event) {
178 if (!enabled_)
179 return false;
180
181 if (!UpdateShiftPressed((event.modifiers & WebInputEvent::ShiftKey) != 0))
182 return false;
183
184 if (!mouse_pressed_)
185 return false;
186
187 // Note: The necessary pinch events will be lazily inserted by
188 // |OnGestureEvent| depending on the state of |shift_pressed_|, using the
189 // scroll stream as the event driver.
190 if (shift_pressed_) {
191 // TODO(dgozman): Add secondary touch point and set anchor.
192 } else {
193 // TODO(dgozman): Remove secondary touch point and anchor.
194 }
195
196 // Never block keyboard events.
197 return false;
198 }
199
HandleTouchEvent(const blink::WebTouchEvent & event)200 bool TouchEmulator::HandleTouchEvent(const blink::WebTouchEvent& event) {
201 // Block native event when emulated touch stream is active.
202 if (emulated_stream_active_sequence_count_)
203 return true;
204
205 bool is_sequence_start = WebTouchEventTraits::IsTouchSequenceStart(event);
206 // Do not allow middle-sequence event to pass through, if start was blocked.
207 if (!native_stream_active_sequence_count_ && !is_sequence_start)
208 return true;
209
210 if (is_sequence_start)
211 native_stream_active_sequence_count_++;
212 return false;
213 }
214
ForwardTouchEventToClient()215 void TouchEmulator::ForwardTouchEventToClient() {
216 const bool event_consumed = true;
217 // Block emulated event when emulated native stream is active.
218 if (native_stream_active_sequence_count_) {
219 gesture_provider_.OnTouchEventAck(event_consumed);
220 return;
221 }
222
223 bool is_sequence_start =
224 WebTouchEventTraits::IsTouchSequenceStart(touch_event_);
225 // Do not allow middle-sequence event to pass through, if start was blocked.
226 if (!emulated_stream_active_sequence_count_ && !is_sequence_start) {
227 gesture_provider_.OnTouchEventAck(event_consumed);
228 return;
229 }
230
231 if (is_sequence_start)
232 emulated_stream_active_sequence_count_++;
233 client_->ForwardEmulatedTouchEvent(touch_event_);
234 }
235
HandleTouchEventAck(const blink::WebTouchEvent & event,InputEventAckState ack_result)236 bool TouchEmulator::HandleTouchEventAck(
237 const blink::WebTouchEvent& event, InputEventAckState ack_result) {
238 bool is_sequence_end = WebTouchEventTraits::IsTouchSequenceEnd(event);
239 if (emulated_stream_active_sequence_count_) {
240 if (is_sequence_end)
241 emulated_stream_active_sequence_count_--;
242
243 const bool event_consumed = ack_result == INPUT_EVENT_ACK_STATE_CONSUMED;
244 gesture_provider_.OnTouchEventAck(event_consumed);
245 return true;
246 }
247
248 // We may have not seen native touch sequence start (when created in the
249 // middle of a sequence), so don't decrement sequence count below zero.
250 if (is_sequence_end && native_stream_active_sequence_count_)
251 native_stream_active_sequence_count_--;
252 return false;
253 }
254
OnGestureEvent(const ui::GestureEventData & gesture)255 void TouchEmulator::OnGestureEvent(const ui::GestureEventData& gesture) {
256 WebGestureEvent gesture_event =
257 CreateWebGestureEventFromGestureEventData(gesture);
258
259 switch (gesture_event.type) {
260 case WebInputEvent::Undefined:
261 NOTREACHED() << "Undefined WebInputEvent type";
262 // Bail without sending the junk event to the client.
263 return;
264
265 case WebInputEvent::GestureScrollBegin:
266 client_->ForwardGestureEvent(gesture_event);
267 // PinchBegin must always follow ScrollBegin.
268 if (InPinchGestureMode())
269 PinchBegin(gesture_event);
270 break;
271
272 case WebInputEvent::GestureScrollUpdate:
273 if (InPinchGestureMode()) {
274 // Convert scrolls to pinches while shift is pressed.
275 if (!pinch_gesture_active_)
276 PinchBegin(gesture_event);
277 else
278 PinchUpdate(gesture_event);
279 } else {
280 // Pass scroll update further. If shift was released, end the pinch.
281 if (pinch_gesture_active_)
282 PinchEnd(gesture_event);
283 client_->ForwardGestureEvent(gesture_event);
284 }
285 break;
286
287 case WebInputEvent::GestureScrollEnd:
288 // PinchEnd must precede ScrollEnd.
289 if (pinch_gesture_active_)
290 PinchEnd(gesture_event);
291 client_->ForwardGestureEvent(gesture_event);
292 break;
293
294 case WebInputEvent::GestureFlingStart:
295 // PinchEnd must precede FlingStart.
296 if (pinch_gesture_active_)
297 PinchEnd(gesture_event);
298 if (InPinchGestureMode()) {
299 // No fling in pinch mode. Forward scroll end instead of fling start.
300 suppress_next_fling_cancel_ = true;
301 ScrollEnd(gesture_event);
302 } else {
303 suppress_next_fling_cancel_ = false;
304 client_->ForwardGestureEvent(gesture_event);
305 }
306 break;
307
308 case WebInputEvent::GestureFlingCancel:
309 // If fling start was suppressed, we should not send fling cancel either.
310 if (!suppress_next_fling_cancel_)
311 client_->ForwardGestureEvent(gesture_event);
312 suppress_next_fling_cancel_ = false;
313 break;
314
315 default:
316 // Everything else goes through.
317 client_->ForwardGestureEvent(gesture_event);
318 }
319 }
320
CancelTouch()321 void TouchEmulator::CancelTouch() {
322 if (!emulated_stream_active_sequence_count_)
323 return;
324
325 WebTouchEventTraits::ResetTypeAndTouchStates(
326 WebInputEvent::TouchCancel,
327 (base::TimeTicks::Now() - base::TimeTicks()).InSecondsF(),
328 &touch_event_);
329 if (gesture_provider_.GetCurrentDownEvent() &&
330 gesture_provider_.OnTouchEvent(MotionEventWeb(touch_event_)))
331 ForwardTouchEventToClient();
332 }
333
UpdateCursor()334 void TouchEmulator::UpdateCursor() {
335 if (!enabled_)
336 client_->SetCursor(pointer_cursor_);
337 else
338 client_->SetCursor(InPinchGestureMode() ? pinch_cursor_ : touch_cursor_);
339 }
340
UpdateShiftPressed(bool shift_pressed)341 bool TouchEmulator::UpdateShiftPressed(bool shift_pressed) {
342 if (shift_pressed_ == shift_pressed)
343 return false;
344 shift_pressed_ = shift_pressed;
345 UpdateCursor();
346 return true;
347 }
348
PinchBegin(const WebGestureEvent & event)349 void TouchEmulator::PinchBegin(const WebGestureEvent& event) {
350 DCHECK(InPinchGestureMode());
351 DCHECK(!pinch_gesture_active_);
352 pinch_gesture_active_ = true;
353 pinch_anchor_ = gfx::Point(event.x, event.y);
354 pinch_scale_ = 1.f;
355 FillPinchEvent(event);
356 pinch_event_.type = WebInputEvent::GesturePinchBegin;
357 client_->ForwardGestureEvent(pinch_event_);
358 }
359
PinchUpdate(const WebGestureEvent & event)360 void TouchEmulator::PinchUpdate(const WebGestureEvent& event) {
361 DCHECK(pinch_gesture_active_);
362 int dy = pinch_anchor_.y() - event.y;
363 float scale = exp(dy * 0.002f);
364 FillPinchEvent(event);
365 pinch_event_.type = WebInputEvent::GesturePinchUpdate;
366 pinch_event_.data.pinchUpdate.scale = scale / pinch_scale_;
367 client_->ForwardGestureEvent(pinch_event_);
368 pinch_scale_ = scale;
369 }
370
PinchEnd(const WebGestureEvent & event)371 void TouchEmulator::PinchEnd(const WebGestureEvent& event) {
372 DCHECK(pinch_gesture_active_);
373 pinch_gesture_active_ = false;
374 FillPinchEvent(event);
375 pinch_event_.type = WebInputEvent::GesturePinchEnd;
376 client_->ForwardGestureEvent(pinch_event_);
377 }
378
FillPinchEvent(const WebInputEvent & event)379 void TouchEmulator::FillPinchEvent(const WebInputEvent& event) {
380 pinch_event_.timeStampSeconds = event.timeStampSeconds;
381 pinch_event_.modifiers = event.modifiers;
382 pinch_event_.sourceDevice = blink::WebGestureDeviceTouchscreen;
383 pinch_event_.x = pinch_anchor_.x();
384 pinch_event_.y = pinch_anchor_.y();
385 }
386
ScrollEnd(const WebGestureEvent & event)387 void TouchEmulator::ScrollEnd(const WebGestureEvent& event) {
388 WebGestureEvent scroll_event;
389 scroll_event.timeStampSeconds = event.timeStampSeconds;
390 scroll_event.modifiers = event.modifiers;
391 scroll_event.sourceDevice = blink::WebGestureDeviceTouchscreen;
392 scroll_event.type = WebInputEvent::GestureScrollEnd;
393 client_->ForwardGestureEvent(scroll_event);
394 }
395
FillTouchEventAndPoint(const WebMouseEvent & mouse_event)396 bool TouchEmulator::FillTouchEventAndPoint(const WebMouseEvent& mouse_event) {
397 if (mouse_event.type != WebInputEvent::MouseDown &&
398 mouse_event.type != WebInputEvent::MouseMove &&
399 mouse_event.type != WebInputEvent::MouseUp) {
400 return false;
401 }
402
403 WebInputEvent::Type eventType;
404 switch (mouse_event.type) {
405 case WebInputEvent::MouseDown:
406 eventType = WebInputEvent::TouchStart;
407 break;
408 case WebInputEvent::MouseMove:
409 eventType = WebInputEvent::TouchMove;
410 break;
411 case WebInputEvent::MouseUp:
412 eventType = WebInputEvent::TouchEnd;
413 break;
414 default:
415 eventType = WebInputEvent::Undefined;
416 NOTREACHED();
417 }
418 touch_event_.touchesLength = 1;
419 touch_event_.modifiers = mouse_event.modifiers;
420 WebTouchEventTraits::ResetTypeAndTouchStates(
421 eventType, mouse_event.timeStampSeconds, &touch_event_);
422
423 WebTouchPoint& point = touch_event_.touches[0];
424 point.id = 0;
425 point.radiusX = 0.5f * cursor_size_.width();
426 point.radiusY = 0.5f * cursor_size_.height();
427 point.force = 1.f;
428 point.rotationAngle = 0.f;
429 point.position.x = mouse_event.x;
430 point.screenPosition.x = mouse_event.globalX;
431 point.position.y = mouse_event.y;
432 point.screenPosition.y = mouse_event.globalY;
433
434 return true;
435 }
436
InPinchGestureMode() const437 bool TouchEmulator::InPinchGestureMode() const {
438 return shift_pressed_;
439 }
440
441 } // namespace content
442