src/content/browser/renderer_host/input/touch_emulator.cc

   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/public/common/content_client.h"
  11 #include "content/public/common/content_switches.h"
  12 #include "grit/content_resources.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
  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
  46 TouchEmulator::TouchEmulator(TouchEmulatorClient* client)
  47     : client_(client),
  48       gesture_provider_(GetGestureProviderConfig(), this),
  49       enabled_(false),
  50       allow_pinch_(false) {
  51   DCHECK(client_);
  52   ResetState();
  53
  54   bool use_2x = gfx::Screen::GetNativeScreen()->
  55       GetPrimaryDisplay().device_scale_factor() > 1.5f;
  56   float cursor_scale_factor = use_2x ? 2.f : 1.f;
  57   InitCursorFromResource(&touch_cursor_,
  58       cursor_scale_factor,
  59       use_2x ? IDR_DEVTOOLS_TOUCH_CURSOR_ICON_2X :
  60           IDR_DEVTOOLS_TOUCH_CURSOR_ICON);
  61   InitCursorFromResource(&pinch_cursor_,
  62       cursor_scale_factor,
  63       use_2x ? IDR_DEVTOOLS_PINCH_CURSOR_ICON_2X :
  64           IDR_DEVTOOLS_PINCH_CURSOR_ICON);
  65
  66   WebCursor::CursorInfo cursor_info;
  67   cursor_info.type = blink::WebCursorInfo::TypePointer;
  68   pointer_cursor_.InitFromCursorInfo(cursor_info);
  69
  70   // TODO(dgozman): Use synthetic secondary touch to support multi-touch.
  71   gesture_provider_.SetMultiTouchZoomSupportEnabled(false);
  72   // TODO(dgozman): Enable double tap if requested by the renderer.
  73   // TODO(dgozman): Don't break double-tap-based pinch with shift handling.
  74   gesture_provider_.SetDoubleTapSupportForPlatformEnabled(false);
  75 }
  76
  77 TouchEmulator::~TouchEmulator() {
  78   // We cannot cleanup properly in destructor, as we need roundtrip to the
  79   // renderer for ack. Instead, the owner should call Disable, and only
  80   // destroy this object when renderer is dead.
  81 }
  82
  83 void TouchEmulator::ResetState() {
  84   last_mouse_event_was_move_ = false;
  85   last_mouse_move_timestamp_ = 0;
  86   mouse_pressed_ = false;
  87   shift_pressed_ = false;
  88   touch_active_ = false;
  89   suppress_next_fling_cancel_ = false;
  90   pinch_scale_ = 1.f;
  91   pinch_gesture_active_ = false;
  92 }
  93
  94 void TouchEmulator::Enable(bool allow_pinch) {
  95   if (!enabled_) {
  96     enabled_ = true;
  97     ResetState();
  98   }
  99   allow_pinch_ = allow_pinch;
 100   UpdateCursor();
 101 }
 102
 103 void TouchEmulator::Disable() {
 104   if (!enabled_)
 105     return;
 106
 107   enabled_ = false;
 108   UpdateCursor();
 109   CancelTouch();
 110 }
 111
 112 void TouchEmulator::InitCursorFromResource(
 113     WebCursor* cursor, float scale, int resource_id) {
 114   gfx::Image& cursor_image =
 115       content::GetContentClient()->GetNativeImageNamed(resource_id);
 116   WebCursor::CursorInfo cursor_info;
 117   cursor_info.type = blink::WebCursorInfo::TypeCustom;
 118   cursor_info.image_scale_factor = scale;
 119   cursor_info.custom_image = cursor_image.AsBitmap();
 120   cursor_info.hotspot =
 121       gfx::Point(cursor_image.Width() / 2, cursor_image.Height() / 2);
 122 #if defined(OS_WIN)
 123   cursor_info.external_handle = 0;
 124 #endif
 125
 126   cursor->InitFromCursorInfo(cursor_info);
 127 }
 128
 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     client_->ForwardTouchEvent(touch_event_);
 163   }
 164
 165   // Do not pass mouse events to the renderer.
 166   return true;
 167 }
 168
 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 touch_active_;
 175 }
 176
 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
 200 bool TouchEmulator::HandleTouchEventAck(InputEventAckState ack_result) {
 201   const bool event_consumed = ack_result == INPUT_EVENT_ACK_STATE_CONSUMED;
 202   gesture_provider_.OnTouchEventAck(event_consumed);
 203   // TODO(dgozman): Disable emulation when real touch events are available.
 204   return true;
 205 }
 206
 207 void TouchEmulator::OnGestureEvent(const ui::GestureEventData& gesture) {
 208   WebGestureEvent gesture_event =
 209       CreateWebGestureEventFromGestureEventData(gesture);
 210
 211   switch (gesture_event.type) {
 212     case WebInputEvent::Undefined:
 213       NOTREACHED() << "Undefined WebInputEvent type";
 214       // Bail without sending the junk event to the client.
 215       return;
 216
 217     case WebInputEvent::GestureScrollBegin:
 218       client_->ForwardGestureEvent(gesture_event);
 219       // PinchBegin must always follow ScrollBegin.
 220       if (InPinchGestureMode())
 221         PinchBegin(gesture_event);
 222       break;
 223
 224     case WebInputEvent::GestureScrollUpdate:
 225       if (InPinchGestureMode()) {
 226         // Convert scrolls to pinches while shift is pressed.
 227         if (!pinch_gesture_active_)
 228           PinchBegin(gesture_event);
 229         else
 230           PinchUpdate(gesture_event);
 231       } else {
 232         // Pass scroll update further. If shift was released, end the pinch.
 233         if (pinch_gesture_active_)
 234           PinchEnd(gesture_event);
 235         client_->ForwardGestureEvent(gesture_event);
 236       }
 237       break;
 238
 239     case WebInputEvent::GestureScrollEnd:
 240       // PinchEnd must precede ScrollEnd.
 241       if (pinch_gesture_active_)
 242         PinchEnd(gesture_event);
 243       client_->ForwardGestureEvent(gesture_event);
 244       break;
 245
 246     case WebInputEvent::GestureFlingStart:
 247       // PinchEnd must precede FlingStart.
 248       if (pinch_gesture_active_)
 249         PinchEnd(gesture_event);
 250       if (InPinchGestureMode()) {
 251         // No fling in pinch mode. Forward scroll end instead of fling start.
 252         suppress_next_fling_cancel_ = true;
 253         ScrollEnd(gesture_event);
 254       } else {
 255         suppress_next_fling_cancel_ = false;
 256         client_->ForwardGestureEvent(gesture_event);
 257       }
 258       break;
 259
 260     case WebInputEvent::GestureFlingCancel:
 261       // If fling start was suppressed, we should not send fling cancel either.
 262       if (!suppress_next_fling_cancel_)
 263         client_->ForwardGestureEvent(gesture_event);
 264       suppress_next_fling_cancel_ = false;
 265       break;
 266
 267     default:
 268       // Everything else goes through.
 269       client_->ForwardGestureEvent(gesture_event);
 270   }
 271 }
 272
 273 void TouchEmulator::CancelTouch() {
 274   if (!touch_active_)
 275     return;
 276
 277   WebTouchEventTraits::ResetTypeAndTouchStates(
 278       WebInputEvent::TouchCancel,
 279       (base::TimeTicks::Now() - base::TimeTicks()).InSecondsF(),
 280       &touch_event_);
 281   touch_active_ = false;
 282   if (gesture_provider_.OnTouchEvent(MotionEventWeb(touch_event_)))
 283     client_->ForwardTouchEvent(touch_event_);
 284 }
 285
 286 void TouchEmulator::UpdateCursor() {
 287   if (!enabled_)
 288     client_->SetCursor(pointer_cursor_);
 289   else
 290     client_->SetCursor(InPinchGestureMode() ? pinch_cursor_ : touch_cursor_);
 291 }
 292
 293 bool TouchEmulator::UpdateShiftPressed(bool shift_pressed) {
 294   if (shift_pressed_ == shift_pressed)
 295     return false;
 296   shift_pressed_ = shift_pressed;
 297   UpdateCursor();
 298   return true;
 299 }
 300
 301 void TouchEmulator::PinchBegin(const WebGestureEvent& event) {
 302   DCHECK(InPinchGestureMode());
 303   DCHECK(!pinch_gesture_active_);
 304   pinch_gesture_active_ = true;
 305   pinch_anchor_ = gfx::Point(event.x, event.y);
 306   pinch_scale_ = 1.f;
 307   FillPinchEvent(event);
 308   pinch_event_.type = WebInputEvent::GesturePinchBegin;
 309   client_->ForwardGestureEvent(pinch_event_);
 310 }
 311
 312 void TouchEmulator::PinchUpdate(const WebGestureEvent& event) {
 313   DCHECK(pinch_gesture_active_);
 314   int dy = pinch_anchor_.y() - event.y;
 315   float scale = exp(dy * 0.002f);
 316   FillPinchEvent(event);
 317   pinch_event_.type = WebInputEvent::GesturePinchUpdate;
 318   pinch_event_.data.pinchUpdate.scale = scale / pinch_scale_;
 319   client_->ForwardGestureEvent(pinch_event_);
 320   pinch_scale_ = scale;
 321 }
 322
 323 void TouchEmulator::PinchEnd(const WebGestureEvent& event) {
 324   DCHECK(pinch_gesture_active_);
 325   pinch_gesture_active_ = false;
 326   FillPinchEvent(event);
 327   pinch_event_.type = WebInputEvent::GesturePinchEnd;
 328   client_->ForwardGestureEvent(pinch_event_);
 329 }
 330
 331 void TouchEmulator::FillPinchEvent(const WebInputEvent& event) {
 332   pinch_event_.timeStampSeconds = event.timeStampSeconds;
 333   pinch_event_.modifiers = event.modifiers;
 334   pinch_event_.sourceDevice = blink::WebGestureDeviceTouchscreen;
 335   pinch_event_.x = pinch_anchor_.x();
 336   pinch_event_.y = pinch_anchor_.y();
 337 }
 338
 339 void TouchEmulator::ScrollEnd(const WebGestureEvent& event) {
 340   WebGestureEvent scroll_event;
 341   scroll_event.timeStampSeconds = event.timeStampSeconds;
 342   scroll_event.modifiers = event.modifiers;
 343   scroll_event.sourceDevice = blink::WebGestureDeviceTouchscreen;
 344   scroll_event.type = WebInputEvent::GestureScrollEnd;
 345   client_->ForwardGestureEvent(scroll_event);
 346 }
 347
 348 bool TouchEmulator::FillTouchEventAndPoint(const WebMouseEvent& mouse_event) {
 349   if (mouse_event.type != WebInputEvent::MouseDown &&
 350       mouse_event.type != WebInputEvent::MouseMove &&
 351       mouse_event.type != WebInputEvent::MouseUp) {
 352     return false;
 353   }
 354
 355   WebInputEvent::Type eventType;
 356   switch (mouse_event.type) {
 357     case WebInputEvent::MouseDown:
 358       eventType = WebInputEvent::TouchStart;
 359       touch_active_ = true;
 360       break;
 361     case WebInputEvent::MouseMove:
 362       eventType = WebInputEvent::TouchMove;
 363       break;
 364     case WebInputEvent::MouseUp:
 365       eventType = WebInputEvent::TouchEnd;
 366       touch_active_ = false;
 367       break;
 368     default:
 369       eventType = WebInputEvent::Undefined;
 370       NOTREACHED();
 371   }
 372   touch_event_.touchesLength = 1;
 373   touch_event_.modifiers = mouse_event.modifiers;
 374   WebTouchEventTraits::ResetTypeAndTouchStates(
 375       eventType, mouse_event.timeStampSeconds, &touch_event_);
 376
 377   WebTouchPoint& point = touch_event_.touches[0];
 378   point.id = 0;
 379   point.radiusX = point.radiusY = 1.f;
 380   point.force = 1.f;
 381   point.rotationAngle = 0.f;
 382   point.position.x = mouse_event.x;
 383   point.screenPosition.x = mouse_event.globalX;
 384   point.position.y = mouse_event.y;
 385   point.screenPosition.y = mouse_event.globalY;
 386
 387   return true;
 388 }
 389
 390 bool TouchEmulator::InPinchGestureMode() const {
 391   return shift_pressed_ && allow_pinch_;
 392 }
 393
 394 }  // namespace content