Expose native, desktop and mobile gesture detection defaults

content/browser/renderer_host/input/touch_emulator.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/renderer_host/input/touch_emulator.h"
 
 #include "content/browser/renderer_host/input/motion_event_web.h"
 #include "content/browser/renderer_host/input/web_input_event_util.h"
 #include "content/common/input/web_touch_event_traits.h"
 #include "content/grit/content_resources.h"
@@ skipping 11 matching lines @@
 using blink::WebMouseWheelEvent;
 using blink::WebTouchEvent;
 using blink::WebTouchPoint;
 
 namespace content {
 
 namespace {
 
 ui::GestureProvider::Config GetGestureProviderConfig() {
   // TODO(dgozman): Use different configs to emulate mobile/desktop as
-  // requested by renderer.
-  ui::GestureProvider::Config config = ui::DefaultGestureProviderConfig();
+  // requested by renderer, crbug/425586.
+  ui::GestureProvider::Config config = ui::GetGestureProviderConfig(
+      ui::GestureProviderConfigType::GENERIC_MOBILE);

[dgozman, 2014/10/28 11:25:21]

Great!

[tdresser, 2014/10/28 13:41:41]

Can't you also emulate a touch screen laptop?

Also, aren't the lines below redundant now?

[jdduke (slow), 2014/10/30 22:06:54]

I guess I would consider desktop as PC/laptop, and mobile as phone/tablet, but
if you have some better names for that dichotomy I'm all ears :)
Yeah, I left them as a safeguard in case |PLATFORM_DEFAULT| is ever a supplied
type.

[tdresser, 2014/10/31 12:34:11]

Oh nevermind, I was confused.

   config.gesture_begin_end_types_enabled = false;
   config.gesture_detector_config.swipe_enabled = false;
   config.gesture_detector_config.two_finger_tap_enabled = false;
   return config;
 }
 
 // Time between two consecutive mouse moves, during which second mouse move
 // is not converted to touch.
 const double kMouseMoveDropIntervalSeconds = 5.f / 1000;
 
@@ skipping 106 matching lines @@
     last_mouse_event_was_move_ = false;
   }
 
   if (mouse_event.type == WebInputEvent::MouseDown)
     mouse_pressed_ = true;
   else if (mouse_event.type == WebInputEvent::MouseUp)
     mouse_pressed_ = false;
 
   UpdateShiftPressed((mouse_event.modifiers & WebInputEvent::ShiftKey) != 0);
 
-  if (FillTouchEventAndPoint(mouse_event) &&
-      gesture_provider_.OnTouchEvent(MotionEventWeb(touch_event_))) {
+  if (mouse_event.type != WebInputEvent::MouseDown &&
+      mouse_event.type != WebInputEvent::MouseMove &&
+      mouse_event.type != WebInputEvent::MouseUp) {
+    return true;
+  }
+
+  if (gesture_provider_.OnTouchEvent(MotionEventWeb(touch_event_))) {
+    FillTouchEventAndPoint(mouse_event);
     ForwardTouchEventToClient();
   }
 
   // Do not pass mouse events to the renderer.
   return true;
 }
 
 bool TouchEmulator::HandleMouseWheelEvent(const WebMouseWheelEvent& event) {
   if (!enabled_)
     return false;
@@ skipping 215 matching lines @@
 void TouchEmulator::ScrollEnd(const WebGestureEvent& event) {
   WebGestureEvent scroll_event;
   scroll_event.timeStampSeconds = event.timeStampSeconds;
   scroll_event.modifiers = event.modifiers;
   scroll_event.sourceDevice = blink::WebGestureDeviceTouchscreen;
   scroll_event.type = WebInputEvent::GestureScrollEnd;
   client_->ForwardGestureEvent(scroll_event);
 }
 
 bool TouchEmulator::FillTouchEventAndPoint(const WebMouseEvent& mouse_event) {
-  if (mouse_event.type != WebInputEvent::MouseDown &&
-      mouse_event.type != WebInputEvent::MouseMove &&
-      mouse_event.type != WebInputEvent::MouseUp) {
-    return false;
-  }
-
   WebInputEvent::Type eventType;
   switch (mouse_event.type) {
     case WebInputEvent::MouseDown:
       eventType = WebInputEvent::TouchStart;
       break;
     case WebInputEvent::MouseMove:
       eventType = WebInputEvent::TouchMove;
       break;
     case WebInputEvent::MouseUp:
       eventType = WebInputEvent::TouchEnd;
       break;
     default:
       eventType = WebInputEvent::Undefined;
-      NOTREACHED();
+      NOTREACHED() << "Invalid event for touch emulation: " << mouse_event.type;
   }
   touch_event_.touchesLength = 1;
   touch_event_.modifiers = mouse_event.modifiers;
   WebTouchEventTraits::ResetTypeAndTouchStates(
       eventType, mouse_event.timeStampSeconds, &touch_event_);
+  touch_event_.defaultActionMayCauseScrolling =

[dgozman, 2014/10/28 11:25:22]

So, this function should be called exactly after
|gesture_provider_.OnTouchEvent| now? Maybe add a comment mentioning this
restriction?

[jdduke (slow), 2014/10/30 22:06:54]

Yeah, this was pretty unclear. I reworked the logic a bit, and made the scroll
causality an explicit part of the GestureProvider::OnTouchEvent API.

+      gesture_provider_.LastTouchEventDidGenerateScroll();
 
   WebTouchPoint& point = touch_event_.touches[0];
   point.id = 0;
   point.radiusX = 0.5f * cursor_size_.width();
   point.radiusY = 0.5f * cursor_size_.height();
   point.force = 1.f;
   point.rotationAngle = 0.f;
   point.position.x = mouse_event.x;
   point.screenPosition.x = mouse_event.globalX;
   point.position.y = mouse_event.y;
   point.screenPosition.y = mouse_event.globalY;
 
   return true;
 }
 
 bool TouchEmulator::InPinchGestureMode() const {
   return shift_pressed_;
 }
 
 }  // namespace content