Merge the mojo blink type converter into ui/events/blink

ui/events/blink/web_input_event.cc

Index: ui/events/blink/web_input_event.cc
diff --git a/ui/events/blink/web_input_event.cc b/ui/events/blink/web_input_event.cc
index 202a669324c72735b93239e88b72f50a000e4efa..719e199172339b4a060e51594ca8cc768daf5543 100644
--- a/ui/events/blink/web_input_event.cc
+++ b/ui/events/blink/web_input_event.cc
@@ -18,8 +18,6 @@
 namespace ui {
 
 namespace {
-// Used for scrolling. This matches Firefox behavior.
-const int kPixelsPerTick = 53;
 
 gfx::Point GetScreenLocationFromEvent(
     const LocatedEvent& event,
@@ -66,10 +64,9 @@ blink::WebMouseEvent MakeUntranslatedWebMouseEventFromNativeEvent(
     const base::NativeEvent& native_event,
     const base::TimeTicks& time_stamp,
     blink::WebPointerProperties::PointerType pointer_type) {
-  return WebMouseEventBuilder::Build(native_event.hwnd, native_event.message,
-                                     native_event.wParam, native_event.lParam,
-                                     ui::EventTimeStampToSeconds(time_stamp),
-                                     pointer_type);
+  return WebMouseEventBuilder::Build(
+      native_event.hwnd, native_event.message, native_event.wParam,
+      native_event.lParam, EventTimeStampToSeconds(time_stamp), pointer_type);
 }
 
 blink::WebMouseWheelEvent MakeUntranslatedWebMouseWheelEventFromNativeEvent(
@@ -78,8 +75,7 @@ blink::WebMouseWheelEvent MakeUntranslatedWebMouseWheelEventFromNativeEvent(
     blink::WebPointerProperties::PointerType pointer_type) {
   return WebMouseWheelEventBuilder::Build(
       native_event.hwnd, native_event.message, native_event.wParam,
-      native_event.lParam, ui::EventTimeStampToSeconds(time_stamp),
-      pointer_type);
+      native_event.lParam, EventTimeStampToSeconds(time_stamp), pointer_type);
 }
 
 blink::WebKeyboardEvent MakeWebKeyboardEventFromNativeEvent(
@@ -87,7 +83,7 @@ blink::WebKeyboardEvent MakeWebKeyboardEventFromNativeEvent(
     const base::TimeTicks& time_stamp) {
   return WebKeyboardEventBuilder::Build(
       native_event.hwnd, native_event.message, native_event.wParam,
-      native_event.lParam, ui::EventTimeStampToSeconds(time_stamp));
+      native_event.lParam, EventTimeStampToSeconds(time_stamp));
 }
 #endif  // defined(OS_WIN)
 
@@ -154,8 +150,8 @@ blink::WebMouseWheelEvent MakeWebMouseWheelEventFromUiEvent(
 
   if (offset_ordinal_x != 0.f && webkit_event.deltaX != 0.f)
     webkit_event.accelerationRatioX = offset_ordinal_x / webkit_event.deltaX;
-  webkit_event.wheelTicksX = webkit_event.deltaX / kPixelsPerTick;
-  webkit_event.wheelTicksY = webkit_event.deltaY / kPixelsPerTick;
+  webkit_event.wheelTicksX = webkit_event.deltaX / MouseWheelEvent::kWheelDelta;
+  webkit_event.wheelTicksY = webkit_event.deltaY / MouseWheelEvent::kWheelDelta;
   if (offset_ordinal_y != 0.f && webkit_event.deltaY != 0.f)
     webkit_event.accelerationRatioY = offset_ordinal_y / webkit_event.deltaY;
 
@@ -220,12 +216,12 @@ blink::WebMouseWheelEvent MakeWebMouseWheelEventFromUiEvent(
 
 blink::WebMouseEvent MakeWebMouseEvent(
     const MouseEvent& event,
-    const base::Callback<gfx::Point(const ui::LocatedEvent& event)>&
+    const base::Callback<gfx::Point(const LocatedEvent& event)>&
         screen_location_callback) {
   // Construct an untranslated event from the platform event data.
   blink::WebMouseEvent webkit_event =
 #if defined(OS_WIN)
-      // On Windows we have WM_ events comming from desktop and pure ui::Events
+      // On Windows we have WM_ events comming from desktop and pure Events
       // comming from metro mode.
       event.native_event().message && (event.type() != ET_MOUSE_EXITED)
           ? MakeUntranslatedWebMouseEventFromNativeEvent(
@@ -256,7 +252,7 @@ blink::WebMouseEvent MakeWebMouseEvent(
 
 blink::WebMouseWheelEvent MakeWebMouseWheelEvent(
     const MouseWheelEvent& event,
-    const base::Callback<gfx::Point(const ui::LocatedEvent& event)>&
+    const base::Callback<gfx::Point(const LocatedEvent& event)>&
         screen_location_callback) {
 #if defined(OS_WIN)
   // Construct an untranslated event from the platform event data.
@@ -287,7 +283,7 @@ blink::WebMouseWheelEvent MakeWebMouseWheelEvent(
 
 blink::WebMouseWheelEvent MakeWebMouseWheelEvent(
     const ScrollEvent& event,
-    const base::Callback<gfx::Point(const ui::LocatedEvent& event)>&
+    const base::Callback<gfx::Point(const LocatedEvent& event)>&
         screen_location_callback) {
 #if defined(OS_WIN)
   // Construct an untranslated event from the platform event data.
@@ -339,7 +335,7 @@ blink::WebKeyboardEvent MakeWebKeyboardEvent(const KeyEvent& event) {
 
 blink::WebGestureEvent MakeWebGestureEvent(
     const GestureEvent& event,
-    const base::Callback<gfx::Point(const ui::LocatedEvent& event)>&
+    const base::Callback<gfx::Point(const LocatedEvent& event)>&
         screen_location_callback) {
   blink::WebGestureEvent gesture_event = MakeWebGestureEventFromUIEvent(event);
 
@@ -356,7 +352,7 @@ blink::WebGestureEvent MakeWebGestureEvent(
 
 blink::WebGestureEvent MakeWebGestureEvent(
     const ScrollEvent& event,
-    const base::Callback<gfx::Point(const ui::LocatedEvent& event)>&
+    const base::Callback<gfx::Point(const LocatedEvent& event)>&
         screen_location_callback) {
   blink::WebGestureEvent gesture_event = MakeWebGestureEventFromUiEvent(event);
   gesture_event.x = event.x();
@@ -447,8 +443,8 @@ blink::WebMouseWheelEvent MakeWebMouseWheelEventFromUiEvent(
     webkit_event.deltaY = event.y_offset();
   }
 
-  webkit_event.wheelTicksX = webkit_event.deltaX / kPixelsPerTick;
-  webkit_event.wheelTicksY = webkit_event.deltaY / kPixelsPerTick;
+  webkit_event.wheelTicksX = webkit_event.deltaX / MouseWheelEvent::kWheelDelta;
+  webkit_event.wheelTicksY = webkit_event.deltaY / MouseWheelEvent::kWheelDelta;
 
   webkit_event.tiltX = roundf(event.pointer_details().tilt_x);
   webkit_event.tiltY = roundf(event.pointer_details().tilt_y);
@@ -459,4 +455,53 @@ blink::WebMouseWheelEvent MakeWebMouseWheelEventFromUiEvent(
   return webkit_event;
 }
 
+blink::WebTouchEvent MakeWebTouchEvent(
+    const PointerEvent& event,
+    const base::Callback<gfx::Point(const LocatedEvent& event)>&
+        screen_location_callback) {

[sadrul, 2016/08/24 18:05:36]

Let's leave this out for now.

Explanation: WebTouchEvent contains information about multiple touch-points. A
PointerEvent tracks a single touch point. So there's no good mapping between the
two. What CompositorMusConnection should do instead, is to maintain a
ui::MotionEvent[Aura], feed the ui::TouchEvent to that, and use the existing
CreateWebTouchEventFromMotionEvent() to generate the WebTouchEvent.

[jonross, 2016/08/25 15:11:59]

Done.

+  blink::WebTouchEvent web_event;
+  blink::WebTouchPoint* touch = &web_event.touches[event.pointer_id()];
+
+  // TODO(jonross): we will need to buffer input events, as blink expects all
+  // active touch points to be in each WebInputEvent (crbug.com/578160)
+  touch->position.x = event.x();
+  touch->position.y = event.y();
+  const gfx::Point screen_point =
+      GetScreenLocationFromEvent(event, screen_location_callback);
+  touch->screenPosition.x = screen_point.x();
+  touch->screenPosition.y = screen_point.y();
+
+  touch->pointerType = blink::WebPointerProperties::PointerType::Touch;
+  touch->radiusX = event.pointer_details().radius_x;
+  touch->radiusY = event.pointer_details().radius_y;
+
+  web_event.modifiers = EventFlagsToWebEventModifiers(event.flags());
+  web_event.timeStampSeconds = EventTimeStampToSeconds(event.time_stamp());
+  web_event.uniqueTouchEventId = GetNextTouchEventId();
+
+  switch (event.type()) {
+    case ET_POINTER_DOWN:
+      web_event.type = blink::WebInputEvent::TouchStart;
+      touch->state = blink::WebTouchPoint::StatePressed;
+      break;
+    case ET_POINTER_UP:
+      web_event.type = blink::WebInputEvent::TouchEnd;
+      touch->state = blink::WebTouchPoint::StateReleased;
+      break;
+    case ET_POINTER_MOVED:
+      web_event.type = blink::WebInputEvent::TouchMove;
+      touch->state = blink::WebTouchPoint::StateMoved;
+      break;
+    case ET_POINTER_CANCELLED:
+      web_event.type = blink::WebInputEvent::TouchCancel;
+      touch->state = blink::WebTouchPoint::StateCancelled;
+      break;
+    default:
+      NOTIMPLEMENTED() << "Received non touch pointer event action: "
+                       << event.type();
+      break;
+  }
+  return web_event;
+}
+
 }  // namespace ui