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/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
  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       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
  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
  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
  94 void TouchEmulator::Enable() {
  95   if (!enabled_) {
  96     enabled_ = true;
  97     ResetState();
  98   }
  99   UpdateCursor();
 100 }
 101
 102 void TouchEmulator::Disable() {
 103   if (!enabled_)
 104     return;
 105
 106   enabled_ = false;
 107   UpdateCursor();
 108   CancelTouch();
 109 }
 110
 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
 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
 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
 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::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
 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
 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
 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
 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
 334 void TouchEmulator::UpdateCursor() {
 335   if (!enabled_)
 336     client_->SetCursor(pointer_cursor_);
 337   else
 338     client_->SetCursor(InPinchGestureMode() ? pinch_cursor_ : touch_cursor_);
 339 }
 340
 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
 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
 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
 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
 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
 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
 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
 437 bool TouchEmulator::InPinchGestureMode() const {
 438   return shift_pressed_;
 439 }
 440
 441 }  // namespace content