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

ui/events/blink/web_input_event.cc

 // Copyright 2016 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 "ui/events/blink/web_input_event.h"
 
 #include "ui/events/base_event_utils.h"
 #include "ui/events/blink/blink_event_util.h"
 #include "ui/events/event.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/keycodes/dom/keycode_converter.h"
 #include "ui/events/keycodes/keyboard_code_conversion.h"
 
 #if defined(OS_WIN)
 #include "ui/events/blink/web_input_event_builders_win.h"
 #endif
 
 namespace ui {
 
 namespace {
-// Used for scrolling. This matches Firefox behavior.
-const int kPixelsPerTick = 53;
 
 gfx::Point GetScreenLocationFromEvent(
     const LocatedEvent& event,
     const base::Callback<gfx::Point(const LocatedEvent& event)>&
         screen_location_callback) {
   DCHECK(!screen_location_callback.is_null());
   return event.target() ? screen_location_callback.Run(event)
                         : event.root_location();
 }
 
@@ skipping 26 matching lines @@
 }  // namespace
 
 #if defined(OS_WIN)
 // On Windows, we can just use the builtin WebKit factory methods to fully
 // construct our pre-translated events.
 
 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(
     const base::NativeEvent& native_event,
     const base::TimeTicks& time_stamp,
     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(
     const base::NativeEvent& native_event,
     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)
 
 blink::WebKeyboardEvent MakeWebKeyboardEventFromUiEvent(const KeyEvent& event) {
   blink::WebKeyboardEvent webkit_event;
 
   webkit_event.timeStampSeconds = EventTimeStampToSeconds(event.time_stamp());
   webkit_event.modifiers = EventFlagsToWebEventModifiers(event.flags()) |
                            DomCodeToWebInputEventModifiers(event.code());
 
@@ skipping 46 matching lines @@
     offset_ordinal_y = event.x_offset_ordinal();
   } else {
     webkit_event.deltaX = event.x_offset();
     webkit_event.deltaY = event.y_offset();
     offset_ordinal_x = event.x_offset_ordinal();
     offset_ordinal_y = event.y_offset_ordinal();
   }
 
   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;
 
   webkit_event.pointerType =
       EventPointerTypeToWebPointerType(event.pointer_details().pointer_type);
   return webkit_event;
 }
 
 blink::WebGestureEvent MakeWebGestureEventFromUiEvent(
     const ScrollEvent& event) {
@@ skipping 44 matching lines @@
 //
 // The exception is mouse events on linux. The MouseEvent contains enough
 // necessary information to construct a WebMouseEvent. So instead of extracting
 // the information from the XEvent, which can be tricky when supporting both
 // XInput2 and XInput, the WebMouseEvent is constructed from the
 // MouseEvent. This will not be necessary once only XInput2 is supported.
 //
 
 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(
                 event.native_event(), event.time_stamp(),
                 EventPointerTypeToWebPointerType(
                     event.pointer_details().pointer_type))
           : MakeWebMouseEventFromUiEvent(event);
 #else
       MakeWebMouseEventFromUiEvent(event);
 #endif
@@ skipping 10 matching lines @@
   const gfx::Point screen_point =
       GetScreenLocationFromEvent(event, screen_location_callback);
   webkit_event.globalX = screen_point.x();
   webkit_event.globalY = screen_point.y();
 
   return webkit_event;
 }
 
 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.
   blink::WebMouseWheelEvent webkit_event =
       event.native_event().message
           ? MakeUntranslatedWebMouseWheelEventFromNativeEvent(
                 event.native_event(), event.time_stamp(),
                 EventPointerTypeToWebPointerType(
                     event.pointer_details().pointer_type))
           : MakeWebMouseWheelEventFromUiEvent(event);
@@ skipping 10 matching lines @@
   const gfx::Point screen_point =
       GetScreenLocationFromEvent(event, screen_location_callback);
   webkit_event.globalX = screen_point.x();
   webkit_event.globalY = screen_point.y();
 
   return webkit_event;
 }
 
 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.
   blink::WebMouseWheelEvent webkit_event =
       event.native_event().message
           ? MakeUntranslatedWebMouseWheelEventFromNativeEvent(
                 event.native_event(), event.time_stamp(),
                 EventPointerTypeToWebPointerType(
                     event.pointer_details().pointer_type))
           : MakeWebMouseWheelEventFromUiEvent(event);
@@ skipping 31 matching lines @@
     webkit_event.domCode = static_cast<int>(event.code());
     webkit_event.domKey = static_cast<int>(event.GetDomKey());
     return webkit_event;
   }
 #endif
   return MakeWebKeyboardEventFromUiEvent(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);
 
   gesture_event.x = event.x();
   gesture_event.y = event.y();
 
   const gfx::Point screen_point =
       GetScreenLocationFromEvent(event, screen_location_callback);
   gesture_event.globalX = screen_point.x();
   gesture_event.globalY = screen_point.y();
 
   return gesture_event;
 }
 
 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();
   gesture_event.y = event.y();
 
   const gfx::Point screen_point =
       GetScreenLocationFromEvent(event, screen_location_callback);
   gesture_event.globalX = screen_point.x();
   gesture_event.globalY = screen_point.y();
 
@@ skipping 70 matching lines @@
   webkit_event.timeStampSeconds = EventTimeStampToSeconds(event.time_stamp());
 
   if ((event.flags() & EF_SHIFT_DOWN) != 0 && event.x_offset() == 0) {
     webkit_event.deltaX = event.y_offset();
     webkit_event.deltaY = 0;
   } else {
     webkit_event.deltaX = event.x_offset();
     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);
   webkit_event.force = event.pointer_details().force;
   webkit_event.pointerType =
       EventPointerTypeToWebPointerType(event.pointer_details().pointer_type);
 
   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