Convert ui::Event directly to blink::WebInputEvent.

mojo/converters/blink/blink_input_events_type_converters.cc

Index: mojo/converters/blink/blink_input_events_type_converters.cc
diff --git a/mojo/converters/blink/blink_input_events_type_converters.cc b/mojo/converters/blink/blink_input_events_type_converters.cc
index 990defdba5157cd7e7fb436b6f977e2aa44a071f..9c7e63911ea646b46b9341c8cb42ab2992cd96b4 100644
--- a/mojo/converters/blink/blink_input_events_type_converters.cc
+++ b/mojo/converters/blink/blink_input_events_type_converters.cc
@@ -8,142 +8,120 @@
 
 #include "base/logging.h"
 #include "base/time/time.h"
-#include "components/mus/public/interfaces/input_event_constants.mojom.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 #include "ui/events/base_event_utils.h"
 #include "ui/events/event.h"
+#include "ui/events/keycodes/dom/keycode_converter.h"
 
 namespace mojo {
 namespace {
 
-double EventTimeToWebEventTime(const mus::mojom::EventPtr& event) {
-  return base::TimeDelta::FromInternalValue(event->time_stamp).InSecondsF();
+double EventTimeToWebEventTime(const ui::Event& event) {
+  return base::TimeDelta::FromInternalValue(
+             event.time_stamp().ToInternalValue())
+      .InSecondsF();
 }
 
 int EventFlagsToWebEventModifiers(int flags) {
   int modifiers = 0;
 
-  if (flags & mus::mojom::kEventFlagShiftDown)
+  if (flags & ui::EF_SHIFT_DOWN)
     modifiers |= blink::WebInputEvent::ShiftKey;
-  if (flags & mus::mojom::kEventFlagControlDown)
+  if (flags & ui::EF_CONTROL_DOWN)
     modifiers |= blink::WebInputEvent::ControlKey;
-  if (flags & mus::mojom::kEventFlagAltDown)
+  if (flags & ui::EF_ALT_DOWN)
     modifiers |= blink::WebInputEvent::AltKey;
   // TODO(beng): MetaKey/META_MASK
-  if (flags & mus::mojom::kEventFlagLeftMouseButton)
+  if (flags & ui::EF_LEFT_MOUSE_BUTTON)
     modifiers |= blink::WebInputEvent::LeftButtonDown;
-  if (flags & mus::mojom::kEventFlagMiddleMouseButton)
+  if (flags & ui::EF_MIDDLE_MOUSE_BUTTON)
     modifiers |= blink::WebInputEvent::MiddleButtonDown;
-  if (flags & mus::mojom::kEventFlagRightMouseButton)
+  if (flags & ui::EF_RIGHT_MOUSE_BUTTON)
     modifiers |= blink::WebInputEvent::RightButtonDown;
-  if (flags & mus::mojom::kEventFlagCapsLockOn)
+  if (flags & ui::EF_CAPS_LOCK_ON)
     modifiers |= blink::WebInputEvent::CapsLockOn;
   return modifiers;
 }
 
 int EventFlagsToWebInputEventModifiers(int flags) {
-  return (flags & mus::mojom::kEventFlagShiftDown
-              ? blink::WebInputEvent::ShiftKey
-              : 0) |
-         (flags & mus::mojom::kEventFlagControlDown
-              ? blink::WebInputEvent::ControlKey
-              : 0) |
-         (flags & mus::mojom::kEventFlagCapsLockOn
-              ? blink::WebInputEvent::CapsLockOn
-              : 0) |
-         (flags & mus::mojom::kEventFlagAltDown ? blink::WebInputEvent::AltKey
-                                                : 0);
+  return (flags & ui::EF_SHIFT_DOWN ? blink::WebInputEvent::ShiftKey : 0) |
+         (flags & ui::EF_CONTROL_DOWN ? blink::WebInputEvent::ControlKey : 0) |
+         (flags & ui::EF_CAPS_LOCK_ON ? blink::WebInputEvent::CapsLockOn : 0) |
+         (flags & ui::EF_ALT_DOWN ? blink::WebInputEvent::AltKey : 0);
 }
 
 int GetClickCount(int flags) {
-  if (flags & mus::mojom::kMouseEventFlagIsTripleClick)
+  if (flags & ui::EF_IS_TRIPLE_CLICK)
     return 3;
-  else if (flags & mus::mojom::kMouseEventFlagIsDoubleClick)
+  else if (flags & ui::EF_IS_DOUBLE_CLICK)
     return 2;
 
   return 1;
 }
 
-blink::WebPointerProperties::PointerType EventPointerKindToWebPointerType(
-    mus::mojom::PointerKind pointer_kind) {
-  switch (pointer_kind) {
-    case mus::mojom::PointerKind::MOUSE:
-      return blink::WebPointerProperties::PointerType::Mouse;
-    case mus::mojom::PointerKind::TOUCH:
-      return blink::WebPointerProperties::PointerType::Touch;
-    case mus::mojom::PointerKind::PEN:
-      return blink::WebPointerProperties::PointerType::Pen;
-  }
-  NOTREACHED();
-  return blink::WebPointerProperties::PointerType::Unknown;
-}
-
-void SetWebMouseEventLocation(const mus::mojom::LocationData& location_data,
+void SetWebMouseEventLocation(const ui::LocatedEvent& located_event,
                               blink::WebMouseEvent* web_event) {
-  web_event->x = static_cast<int>(location_data.x);
-  web_event->y = static_cast<int>(location_data.y);
-  web_event->globalX = static_cast<int>(location_data.screen_x);
-  web_event->globalY = static_cast<int>(location_data.screen_y);
+  web_event->x = static_cast<int>(located_event.x());
+  web_event->y = static_cast<int>(located_event.y());
+  web_event->globalX = static_cast<int>(located_event.root_location_f().x());
+  web_event->globalY = static_cast<int>(located_event.root_location_f().y());
 }
 
 std::unique_ptr<blink::WebInputEvent> BuildWebMouseEventFrom(
-    const mus::mojom::EventPtr& event) {
+    const ui::PointerEvent& event) {
   std::unique_ptr<blink::WebMouseEvent> web_event(new blink::WebMouseEvent);
-  web_event->pointerType =
-      EventPointerKindToWebPointerType(event->pointer_data->kind);
 
-  if (event->pointer_data && event->pointer_data->location)
-    SetWebMouseEventLocation(*(event->pointer_data->location), web_event.get());
+  web_event->pointerType = blink::WebPointerProperties::PointerType::Mouse;
+  SetWebMouseEventLocation(event, web_event.get());
 
-  web_event->modifiers = EventFlagsToWebEventModifiers(event->flags);
+  web_event->modifiers = EventFlagsToWebEventModifiers(event.flags());
   web_event->timeStampSeconds = EventTimeToWebEventTime(event);
 
   web_event->button = blink::WebMouseEvent::ButtonNone;
-  if (event->flags & mus::mojom::kEventFlagLeftMouseButton)
+  if (event.flags() & ui::EF_LEFT_MOUSE_BUTTON)
     web_event->button = blink::WebMouseEvent::ButtonLeft;
-  if (event->flags & mus::mojom::kEventFlagMiddleMouseButton)
+  if (event.flags() & ui::EF_MIDDLE_MOUSE_BUTTON)
     web_event->button = blink::WebMouseEvent::ButtonMiddle;
-  if (event->flags & mus::mojom::kEventFlagRightMouseButton)
+  if (event.flags() & ui::EF_RIGHT_MOUSE_BUTTON)
     web_event->button = blink::WebMouseEvent::ButtonRight;
 
-  switch (event->action) {
-    case mus::mojom::EventType::POINTER_DOWN:
+  switch (event.type()) {
+    case ui::ET_POINTER_DOWN:
       web_event->type = blink::WebInputEvent::MouseDown;
       break;
-    case mus::mojom::EventType::POINTER_UP:
+    case ui::ET_POINTER_UP:
       web_event->type = blink::WebInputEvent::MouseUp;
       break;
-    case mus::mojom::EventType::POINTER_MOVE:
+    case ui::ET_POINTER_MOVED:
       web_event->type = blink::WebInputEvent::MouseMove;
       break;
-    case mus::mojom::EventType::MOUSE_EXIT:
+    case ui::ET_MOUSE_EXITED:
       web_event->type = blink::WebInputEvent::MouseLeave;
       break;
     default:
-      NOTIMPLEMENTED() << "Received unexpected event: " << event->action;
+      NOTIMPLEMENTED() << "Received unexpected event: " << event.type();
       break;
   }
 
-  web_event->clickCount = GetClickCount(event->flags);
+  web_event->clickCount = GetClickCount(event.flags());
 
   return std::move(web_event);
 }
 
 std::unique_ptr<blink::WebInputEvent> BuildWebKeyboardEvent(
-    const mus::mojom::EventPtr& event) {
+    const ui::KeyEvent& event) {
   std::unique_ptr<blink::WebKeyboardEvent> web_event(
       new blink::WebKeyboardEvent);
 
-  web_event->modifiers = EventFlagsToWebInputEventModifiers(event->flags);
+  web_event->modifiers = EventFlagsToWebInputEventModifiers(event.flags());
   web_event->timeStampSeconds = EventTimeToWebEventTime(event);
 
-  switch (event->action) {
-    case mus::mojom::EventType::KEY_PRESSED:
-      web_event->type = event->key_data->is_char
-                            ? blink::WebInputEvent::Char
-                            : blink::WebInputEvent::RawKeyDown;
+  switch (event.type()) {
+    case ui::ET_KEY_PRESSED:
+      web_event->type = event.is_char() ? blink::WebInputEvent::Char
+                                        : blink::WebInputEvent::RawKeyDown;
       break;
-    case mus::mojom::EventType::KEY_RELEASED:
+    case ui::ET_KEY_RELEASED:
       web_event->type = blink::WebInputEvent::KeyUp;
       break;
     default:
@@ -153,139 +131,89 @@ std::unique_ptr<blink::WebInputEvent> BuildWebKeyboardEvent(
   if (web_event->modifiers & blink::WebInputEvent::AltKey)
     web_event->isSystemKey = true;
 
-  web_event->windowsKeyCode =
-      static_cast<int>(event->key_data->windows_key_code);
-  web_event->nativeKeyCode = event->key_data->native_key_code;
-  web_event->text[0] = event->key_data->text;
-  web_event->unmodifiedText[0] = event->key_data->unmodified_text;
+  web_event->windowsKeyCode = event.GetLocatedWindowsKeyboardCode();
+  web_event->nativeKeyCode =
+      ui::KeycodeConverter::DomCodeToNativeKeycode(event.code());
+  web_event->text[0] = event.GetText();
+  web_event->unmodifiedText[0] = event.GetUnmodifiedText();
 
   web_event->setKeyIdentifierFromWindowsKeyCode();
   return std::move(web_event);
 }
 
 std::unique_ptr<blink::WebInputEvent> BuildWebMouseWheelEventFrom(
-    const mus::mojom::EventPtr& event) {
-  DCHECK(event->pointer_data && event->pointer_data->wheel_data);
-  const mus::mojom::WheelData& wheel_data = *event->pointer_data->wheel_data;
+    const ui::MouseWheelEvent& event) {
   std::unique_ptr<blink::WebMouseWheelEvent> web_event(
       new blink::WebMouseWheelEvent);
   web_event->type = blink::WebInputEvent::MouseWheel;
   web_event->button = blink::WebMouseEvent::ButtonNone;
-  web_event->modifiers = EventFlagsToWebEventModifiers(event->flags);
+  web_event->modifiers = EventFlagsToWebEventModifiers(event.flags());
   web_event->timeStampSeconds = EventTimeToWebEventTime(event);
 
-  SetWebMouseEventLocation(*(event->pointer_data->location), web_event.get());
+  SetWebMouseEventLocation(event, web_event.get());
 
   // TODO(rjkroege): Update the following code once Blink supports
   // DOM Level 3 wheel events
   // (http://www.w3.org/TR/DOM-Level-3-Events/#events-wheelevents)
-  web_event->deltaX = wheel_data.delta_x;
-  web_event->deltaY = wheel_data.delta_y;
+  web_event->deltaX = event.x_offset();
+  web_event->deltaY = event.y_offset();
 
   web_event->wheelTicksX = web_event->deltaX / ui::MouseWheelEvent::kWheelDelta;
   web_event->wheelTicksY = web_event->deltaY / ui::MouseWheelEvent::kWheelDelta;
 
-  // TODO(rjkroege): Mandoline currently only generates WHEEL_MODE_LINE
-  // wheel events so the other modes are not yet tested. Verify that
-  // the implementation is correct.
-  switch (wheel_data.mode) {
-    case mus::mojom::WheelMode::PIXEL:
-      web_event->hasPreciseScrollingDeltas = true;
-      web_event->scrollByPage = false;
-      web_event->canScroll = true;
-      break;
-    case mus::mojom::WheelMode::LINE:
-      web_event->hasPreciseScrollingDeltas = false;
-      web_event->scrollByPage = false;
-      web_event->canScroll = true;
-      break;
-    case mus::mojom::WheelMode::PAGE:
-      web_event->hasPreciseScrollingDeltas = false;
-      web_event->scrollByPage = true;
-      web_event->canScroll = true;
-      break;
-    case mus::mojom::WheelMode::SCALING:
-      web_event->hasPreciseScrollingDeltas = false;
-      web_event->scrollByPage = false;
-      web_event->canScroll = false;
-      break;
-  }
+  // TODO(moshayedi): ui::WheelEvent currently only supports WHEEL_MODE_LINE.
+  // Add support for other wheel modes once ui::WheelEvent has support for them.
+  web_event->hasPreciseScrollingDeltas = false;
+  web_event->scrollByPage = false;
+  web_event->canScroll = true;
 
   return std::move(web_event);
 }
 
-void SetWebTouchEventLocation(const mus::mojom::PointerData& pointer_data,
-                              mus::mojom::EventType action,
+void SetWebTouchEventLocation(const ui::PointerEvent& event,
                               blink::WebTouchPoint* touch) {
-  if (pointer_data.location) {
-    touch->position.x = pointer_data.location->x;
-    touch->position.y = pointer_data.location->y;
-    touch->screenPosition.x = pointer_data.location->screen_x;
-    touch->screenPosition.y = pointer_data.location->screen_y;
-  }
-  if (pointer_data.brush_data) {
-    touch->radiusX = pointer_data.brush_data->width;
-    touch->radiusY = pointer_data.brush_data->height;
-  }
-  touch->pointerType = blink::WebPointerProperties::PointerType::Touch;
-  switch (action) {
-    case mus::mojom::EventType::POINTER_DOWN:
-      touch->state = blink::WebTouchPoint::StatePressed;
-      break;
-    case mus::mojom::EventType::POINTER_UP:
-      touch->state = blink::WebTouchPoint::StateReleased;
-      break;
-    case mus::mojom::EventType::POINTER_MOVE:
-      touch->state = blink::WebTouchPoint::StateMoved;
-      break;
-    case mus::mojom::EventType::POINTER_CANCEL:
-      touch->state = blink::WebTouchPoint::StateCancelled;
-      break;
-    case mus::mojom::EventType::UNKNOWN:
-    case mus::mojom::EventType::KEY_PRESSED:
-    case mus::mojom::EventType::KEY_RELEASED:
-    case mus::mojom::EventType::MOUSE_EXIT:
-    case mus::mojom::EventType::WHEEL:
-      NOTIMPLEMENTED() << "Received non touch event action: " << action;
-      break;
-  }
+  touch->position.x = event.x();
+  touch->position.y = event.y();
+  touch->screenPosition.x = event.root_location_f().x();
+  touch->screenPosition.y = event.root_location_f().y();
 }
 
 std::unique_ptr<blink::WebInputEvent> BuildWebTouchEvent(
-    const mus::mojom::EventPtr& event) {
+    const ui::PointerEvent& event) {
   std::unique_ptr<blink::WebTouchEvent> web_event(new blink::WebTouchEvent);
+  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)
-  if (event->pointer_data) {
-    SetWebTouchEventLocation(
-        *event->pointer_data, event->action,
-        &web_event->touches[event->pointer_data->pointer_id]);
-  }
+  SetWebTouchEventLocation(event, touch);
+  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->modifiers = EventFlagsToWebEventModifiers(event.flags());
   web_event->timeStampSeconds = EventTimeToWebEventTime(event);
   web_event->uniqueTouchEventId = ui::GetNextTouchEventId();
 
-  switch (event->action) {
-    case mus::mojom::EventType::POINTER_DOWN:
+  switch (event.type()) {
+    case ui::ET_POINTER_DOWN:
       web_event->type = blink::WebInputEvent::TouchStart;
+      touch->state = blink::WebTouchPoint::StatePressed;
       break;
-    case mus::mojom::EventType::POINTER_UP:
+    case ui::ET_POINTER_UP:
       web_event->type = blink::WebInputEvent::TouchEnd;
+      touch->state = blink::WebTouchPoint::StateReleased;
       break;
-    case mus::mojom::EventType::POINTER_MOVE:
+    case ui::ET_POINTER_MOVED:
       web_event->type = blink::WebInputEvent::TouchMove;
+      touch->state = blink::WebTouchPoint::StateMoved;
       break;
-    case mus::mojom::EventType::POINTER_CANCEL:
+    case ui::ET_POINTER_CANCELLED:
       web_event->type = blink::WebInputEvent::TouchCancel;
+      touch->state = blink::WebTouchPoint::StateCancelled;
       break;
-    case mus::mojom::EventType::UNKNOWN:
-    case mus::mojom::EventType::KEY_PRESSED:
-    case mus::mojom::EventType::KEY_RELEASED:
-    case mus::mojom::EventType::MOUSE_EXIT:
-    case mus::mojom::EventType::WHEEL:
-      NOTIMPLEMENTED() << "Received non touch event action: " << event->action;
+    default:
+      NOTIMPLEMENTED() << "Received non touch pointer event action: "
+                       << event.type();
       break;
   }
 
@@ -295,35 +223,31 @@ std::unique_ptr<blink::WebInputEvent> BuildWebTouchEvent(
 }  // namespace
 
 // static
-std::unique_ptr<blink::WebInputEvent> TypeConverter<
-    std::unique_ptr<blink::WebInputEvent>,
-    mus::mojom::EventPtr>::Convert(const mus::mojom::EventPtr& event) {
-  switch (event->action) {
-    case mus::mojom::EventType::POINTER_DOWN:
-    case mus::mojom::EventType::POINTER_UP:
-    case mus::mojom::EventType::POINTER_CANCEL:
-    case mus::mojom::EventType::POINTER_MOVE:
-    case mus::mojom::EventType::MOUSE_EXIT:
-      if (event->pointer_data) {
-        switch (event->pointer_data->kind) {
-          case mus::mojom::PointerKind::MOUSE:
-            return BuildWebMouseEventFrom(event);
-          case mus::mojom::PointerKind::PEN:
-            return nullptr;
-          case mus::mojom::PointerKind::TOUCH:
-            return BuildWebTouchEvent(event);
-        }
-      }
-      return nullptr;
-    case mus::mojom::EventType::WHEEL:
-      return BuildWebMouseWheelEventFrom(event);
-    case mus::mojom::EventType::KEY_PRESSED:
-    case mus::mojom::EventType::KEY_RELEASED:
-      return BuildWebKeyboardEvent(event);
-    case mus::mojom::EventType::UNKNOWN:
+std::unique_ptr<blink::WebInputEvent>
+TypeConverter<std::unique_ptr<blink::WebInputEvent>, ui::Event>::Convert(
+    const ui::Event& event) {
+  DCHECK(event.IsKeyEvent() || event.IsPointerEvent() ||
+         event.IsMouseWheelEvent());
+  switch (event.type()) {
+    case ui::ET_POINTER_DOWN:
+    case ui::ET_POINTER_UP:
+    case ui::ET_POINTER_CANCELLED:
+    case ui::ET_POINTER_MOVED:
+    case ui::ET_POINTER_EXITED:
+      if (event.IsMousePointerEvent())
+        return BuildWebMouseEventFrom(*event.AsPointerEvent());
+      else if (event.IsTouchPointerEvent())
+        return BuildWebTouchEvent(*event.AsPointerEvent());
+      else
+        return nullptr;
+    case ui::ET_MOUSEWHEEL:
+      return BuildWebMouseWheelEventFrom(*event.AsMouseWheelEvent());
+    case ui::ET_KEY_PRESSED:
+    case ui::ET_KEY_RELEASED:
+      return BuildWebKeyboardEvent(*event.AsKeyEvent());
+    default:
       return nullptr;
   }
-  return nullptr;
 }
 
 }  // namespace mojo