Cleans up events to just the parts we're actually using

sky/viewer/converters/input_event_types.cc

Index: sky/viewer/converters/input_event_types.cc
diff --git a/sky/viewer/converters/input_event_types.cc b/sky/viewer/converters/input_event_types.cc
index 3aa297d4902b88a5da238456ce3a45059fa5cfba..ae032b3fc510f4e718637a64860744fdbd1c8624 100644
--- a/sky/viewer/converters/input_event_types.cc
+++ b/sky/viewer/converters/input_event_types.cc
@@ -8,6 +8,7 @@
 #include "base/time/time.h"
 #include "mojo/services/input_events/public/interfaces/input_event_constants.mojom.h"
 #include "sky/engine/public/platform/WebInputEvent.h"
+#include "ui/events/event.h"
 
 namespace sky {
 namespace {
@@ -24,6 +25,14 @@ int EventFlagsToWebInputEventModifiers(int flags) {
        blink::WebInputEvent::AltKey : 0);
 }
 
+int UIEventFlagsToWebInputEventModifiers(int flags) {
+  return (flags & ui::EF_SHIFT_DOWN ? blink::WebInputEvent::ShiftKey : 0) |
+         (flags & ui::EF_CONTROL_DOWN ? blink::WebInputEvent::ControlKey : 0) |
+         (flags & ui::EF_CAPS_LOCK_DOWN ? blink::WebInputEvent::CapsLockOn
+                                        : 0) |
+         (flags & ui::EF_ALT_DOWN ? blink::WebInputEvent::AltKey : 0);
+}
+
 scoped_ptr<blink::WebInputEvent> BuildWebPointerEvent(
     const mojo::EventPtr& event, float device_pixel_ratio) {
   scoped_ptr<blink::WebPointerEvent> web_event(new blink::WebPointerEvent);
@@ -33,19 +42,16 @@ scoped_ptr<blink::WebInputEvent> BuildWebPointerEvent(
       base::TimeDelta::FromInternalValue(event->time_stamp).InMillisecondsF();
 
   switch (event->action) {
-    case mojo::EVENT_TYPE_TOUCH_PRESSED:
-    case mojo::EVENT_TYPE_MOUSE_PRESSED:
+    case mojo::EVENT_TYPE_POINTER_DOWN:
       web_event->type = blink::WebInputEvent::PointerDown;
       break;
-    case mojo::EVENT_TYPE_TOUCH_MOVED:
-    case mojo::EVENT_TYPE_MOUSE_DRAGGED:
+    case mojo::EVENT_TYPE_POINTER_MOVE:
       web_event->type = blink::WebInputEvent::PointerMove;
       break;
-    case mojo::EVENT_TYPE_TOUCH_RELEASED:
-    case mojo::EVENT_TYPE_MOUSE_RELEASED:
+    case mojo::EVENT_TYPE_POINTER_UP:
       web_event->type = blink::WebInputEvent::PointerUp;
       break;
-    case mojo::EVENT_TYPE_TOUCH_CANCELLED:
+    case mojo::EVENT_TYPE_POINTER_CANCEL:
       // FIXME: What mouse event should we listen to in order to learn when the
       // mouse moves out of the mojo::View?
       web_event->type = blink::WebInputEvent::PointerCancel;
@@ -55,114 +61,98 @@ scoped_ptr<blink::WebInputEvent> BuildWebPointerEvent(
       break;
   }
 
-  switch (event->action) {
-    case mojo::EVENT_TYPE_TOUCH_CANCELLED:
-    case mojo::EVENT_TYPE_TOUCH_MOVED:
-    case mojo::EVENT_TYPE_TOUCH_PRESSED:
-    case mojo::EVENT_TYPE_TOUCH_RELEASED:
-      web_event->kind = blink::WebPointerEvent::Touch;
-      break;
-    case mojo::EVENT_TYPE_MOUSE_DRAGGED:
-    case mojo::EVENT_TYPE_MOUSE_EXITED:
-    case mojo::EVENT_TYPE_MOUSE_PRESSED:
-    case mojo::EVENT_TYPE_MOUSE_RELEASED:
-      web_event->kind = blink::WebPointerEvent::Mouse;
-      break;
-    default:
-      NOTIMPLEMENTED() << "Received unexpected event: " << event->action;
-      break;
+  if (event->pointer_data->kind == mojo::POINTER_KIND_TOUCH) {
+    web_event->kind = blink::WebPointerEvent::Touch;
+    web_event->pointer = event->pointer_data->pointer_id;
+  } else {
+    web_event->kind = blink::WebPointerEvent::Mouse;
   }
 
-  if (event->touch_data)
-    web_event->pointer = event->touch_data->pointer_id;
-
-  const auto& location = event->location_data->in_view_location;
-  web_event->x = location->x / device_pixel_ratio;
-  web_event->y = location->y / device_pixel_ratio;
+  web_event->x = event->pointer_data->x / device_pixel_ratio;
+  web_event->y = event->pointer_data->y / device_pixel_ratio;
 
   return web_event.Pass();
 }
 
 scoped_ptr<blink::WebInputEvent> BuildWebGestureEvent(
-    const mojo::EventPtr& event,
+    const ui::GestureEvent& event,
     float device_pixel_ratio) {
   scoped_ptr<blink::WebGestureEvent> web_event(new blink::WebGestureEvent);
 
-  web_event->modifiers = EventFlagsToWebInputEventModifiers(event->flags);
-  web_event->timeStampMS =
-      base::TimeDelta::FromInternalValue(event->time_stamp).InMillisecondsF();
+  web_event->modifiers = UIEventFlagsToWebInputEventModifiers(event.flags());
+  web_event->timeStampMS = event.time_stamp().InMillisecondsF();
 
-  switch (event->action) {
-    case mojo::EVENT_TYPE_GESTURE_SCROLL_BEGIN:
+  switch (event.type()) {
+    case ui::ET_GESTURE_SCROLL_BEGIN:
       web_event->type = blink::WebInputEvent::GestureScrollBegin;
       break;
-    case mojo::EVENT_TYPE_GESTURE_SCROLL_END:
+    case ui::ET_GESTURE_SCROLL_END:
       web_event->type = blink::WebInputEvent::GestureScrollEnd;
       break;
-    case mojo::EVENT_TYPE_GESTURE_SCROLL_UPDATE:
+    case ui::ET_GESTURE_SCROLL_UPDATE:
       web_event->type = blink::WebInputEvent::GestureScrollUpdate;
       web_event->data.scrollUpdate.deltaX =
-          event->gesture_data->scroll_x / device_pixel_ratio;
+          event.details().scroll_x() / device_pixel_ratio;
       web_event->data.scrollUpdate.deltaY =
-          event->gesture_data->scroll_y / device_pixel_ratio;
+          event.details().scroll_y() / device_pixel_ratio;
       break;
-    case mojo::EVENT_TYPE_SCROLL_FLING_START:
+    case ui::ET_SCROLL_FLING_START:
       web_event->type = blink::WebInputEvent::GestureFlingStart;
       web_event->data.flingStart.velocityX =
-          event->gesture_data->velocity_x / device_pixel_ratio;
+          event.details().velocity_x() / device_pixel_ratio;
       web_event->data.flingStart.velocityY =
-          event->gesture_data->velocity_y / device_pixel_ratio;
+          event.details().velocity_y() / device_pixel_ratio;
       break;
-    case mojo::EVENT_TYPE_SCROLL_FLING_CANCEL:
+    case ui::ET_SCROLL_FLING_CANCEL:
       web_event->type = blink::WebInputEvent::GestureFlingCancel;
       break;
-    case mojo::EVENT_TYPE_GESTURE_SHOW_PRESS:
+    case ui::ET_GESTURE_SHOW_PRESS:
       web_event->type = blink::WebInputEvent::GestureShowPress;
       break;
-    case mojo::EVENT_TYPE_GESTURE_TAP:
+    case ui::ET_GESTURE_TAP:
       web_event->type = blink::WebInputEvent::GestureTap;
-      web_event->data.tap.tapCount = event->gesture_data->tap_count;
+      web_event->data.tap.tapCount = event.details().tap_count();
       break;
-    case mojo::EVENT_TYPE_GESTURE_TAP_UNCONFIRMED:
+    case ui::ET_GESTURE_TAP_UNCONFIRMED:
       web_event->type = blink::WebInputEvent::GestureTapUnconfirmed;
-      web_event->data.tap.tapCount = event->gesture_data->tap_count;
+      web_event->data.tap.tapCount = event.details().tap_count();
       break;
-    case mojo::EVENT_TYPE_GESTURE_TAP_DOWN:
+    case ui::ET_GESTURE_TAP_DOWN:
       web_event->type = blink::WebInputEvent::GestureTapDown;
       break;
-    case mojo::EVENT_TYPE_GESTURE_TAP_CANCEL:
+    case ui::ET_GESTURE_TAP_CANCEL:
       web_event->type = blink::WebInputEvent::GestureTapCancel;
       break;
-    case mojo::EVENT_TYPE_GESTURE_DOUBLE_TAP:
+    case ui::ET_GESTURE_DOUBLE_TAP:
       web_event->type = blink::WebInputEvent::GestureDoubleTap;
-      web_event->data.tap.tapCount = event->gesture_data->tap_count;
+      web_event->data.tap.tapCount = event.details().tap_count();
       break;
-    case mojo::EVENT_TYPE_GESTURE_TWO_FINGER_TAP:
+    case ui::ET_GESTURE_TWO_FINGER_TAP:
       web_event->type = blink::WebInputEvent::GestureTwoFingerTap;
       break;
-    case mojo::EVENT_TYPE_GESTURE_LONG_PRESS:
+    case ui::ET_GESTURE_LONG_PRESS:
       web_event->type = blink::WebInputEvent::GestureLongPress;
       break;
-    case mojo::EVENT_TYPE_GESTURE_LONG_TAP:
+    case ui::ET_GESTURE_LONG_TAP:
       web_event->type = blink::WebInputEvent::GestureLongTap;
       break;
-    case mojo::EVENT_TYPE_GESTURE_PINCH_BEGIN:
+    case ui::ET_GESTURE_PINCH_BEGIN:
       web_event->type = blink::WebInputEvent::GesturePinchBegin;
       break;
-    case mojo::EVENT_TYPE_GESTURE_PINCH_END:
+    case ui::ET_GESTURE_PINCH_END:
       web_event->type = blink::WebInputEvent::GesturePinchEnd;
       break;
-    case mojo::EVENT_TYPE_GESTURE_PINCH_UPDATE:
+    case ui::ET_GESTURE_PINCH_UPDATE:
       web_event->type = blink::WebInputEvent::GesturePinchUpdate;
       web_event->data.pinchUpdate.scale =
-          event->gesture_data->scale / device_pixel_ratio;
+          event.details().scale() / device_pixel_ratio;
       break;
     default:
       break;
   }
 
-  web_event->x = event->location_data->in_view_location->x / device_pixel_ratio;
-  web_event->y = event->location_data->in_view_location->y / device_pixel_ratio;
+  web_event->x = event.location().x() / device_pixel_ratio;
+  web_event->y = event.location().y() / device_pixel_ratio;
 
   return web_event.Pass();
 }
@@ -205,12 +195,14 @@ scoped_ptr<blink::WebInputEvent> BuildWebWheelEvent(
 
   web_event->type = blink::WebInputEvent::WheelEvent;
 
-  const auto& location = event->location_data->in_view_location;
-  web_event->x = location->x / device_pixel_ratio;
-  web_event->y = location->y / device_pixel_ratio;
+  web_event->x = event->pointer_data->x / device_pixel_ratio;
+  web_event->y = event->pointer_data->y / device_pixel_ratio;
 
-  web_event->offsetX = event->wheel_data->x_offset / device_pixel_ratio;
-  web_event->offsetY = event->wheel_data->y_offset / device_pixel_ratio;
+  // The times 100 is arbitrary. Need a better way to deal.
+  web_event->offsetX =
+      event->pointer_data->horizontal_wheel * 100 / device_pixel_ratio;
+  web_event->offsetY =
+      event->pointer_data->vertical_wheel * 100 / device_pixel_ratio;
 
   return web_event.Pass();
 }
@@ -219,46 +211,27 @@ scoped_ptr<blink::WebInputEvent> BuildWebWheelEvent(
 
 scoped_ptr<blink::WebInputEvent> ConvertEvent(const mojo::EventPtr& event,
                                               float device_pixel_ratio) {
-  if (event->action == mojo::EVENT_TYPE_TOUCH_RELEASED ||
-      event->action == mojo::EVENT_TYPE_TOUCH_PRESSED ||
-      event->action == mojo::EVENT_TYPE_TOUCH_MOVED ||
-      event->action == mojo::EVENT_TYPE_TOUCH_CANCELLED ||
-      event->action == mojo::EVENT_TYPE_MOUSE_DRAGGED ||
-      event->action == mojo::EVENT_TYPE_MOUSE_PRESSED ||
-      event->action == mojo::EVENT_TYPE_MOUSE_RELEASED) {
+  if (event->action == mojo::EVENT_TYPE_POINTER_DOWN ||
+      event->action == mojo::EVENT_TYPE_POINTER_UP ||
+      event->action == mojo::EVENT_TYPE_POINTER_CANCEL ||
+      event->action == mojo::EVENT_TYPE_POINTER_MOVE) {
+    if (event->pointer_data->horizontal_wheel != 0 ||
+        event->pointer_data->vertical_wheel != 0) {
+      return BuildWebWheelEvent(event, device_pixel_ratio);
+    }
     return BuildWebPointerEvent(event, device_pixel_ratio);
-  } else if (event->action == mojo::EVENT_TYPE_GESTURE_SCROLL_BEGIN ||
-             event->action == mojo::EVENT_TYPE_GESTURE_SCROLL_END ||
-             event->action == mojo::EVENT_TYPE_GESTURE_SCROLL_UPDATE ||
-             event->action == mojo::EVENT_TYPE_GESTURE_TAP ||
-             event->action == mojo::EVENT_TYPE_GESTURE_TAP_DOWN ||
-             event->action == mojo::EVENT_TYPE_GESTURE_TAP_CANCEL ||
-             event->action == mojo::EVENT_TYPE_GESTURE_TAP_UNCONFIRMED ||
-             event->action == mojo::EVENT_TYPE_GESTURE_DOUBLE_TAP ||
-             event->action == mojo::EVENT_TYPE_GESTURE_BEGIN ||
-             event->action == mojo::EVENT_TYPE_GESTURE_END ||
-             event->action == mojo::EVENT_TYPE_GESTURE_TWO_FINGER_TAP ||
-             event->action == mojo::EVENT_TYPE_GESTURE_PINCH_BEGIN ||
-             event->action == mojo::EVENT_TYPE_GESTURE_PINCH_END ||
-             event->action == mojo::EVENT_TYPE_GESTURE_PINCH_UPDATE ||
-             event->action == mojo::EVENT_TYPE_GESTURE_LONG_PRESS ||
-             event->action == mojo::EVENT_TYPE_GESTURE_LONG_TAP ||
-             event->action == mojo::EVENT_TYPE_GESTURE_SWIPE ||
-             event->action == mojo::EVENT_TYPE_GESTURE_SHOW_PRESS ||
-             event->action == mojo::EVENT_TYPE_GESTURE_WIN8_EDGE_SWIPE ||
-             event->action == mojo::EVENT_TYPE_SCROLL_FLING_START ||
-             event->action == mojo::EVENT_TYPE_SCROLL_FLING_CANCEL) {
-    return BuildWebGestureEvent(event, device_pixel_ratio);
   } else if ((event->action == mojo::EVENT_TYPE_KEY_PRESSED ||
               event->action == mojo::EVENT_TYPE_KEY_RELEASED) &&
              event->key_data) {
     return BuildWebKeyboardEvent(event, device_pixel_ratio);
-  } else if (event->action == mojo::EVENT_TYPE_MOUSEWHEEL &&
-             event->wheel_data) {
-    return BuildWebWheelEvent(event, device_pixel_ratio);
   }
 
-  return scoped_ptr<blink::WebInputEvent>();
+  return nullptr;
+}
+
+scoped_ptr<blink::WebInputEvent> ConvertEvent(const ui::GestureEvent& event,
+                                              float device_pixel_ratio) {
+  return BuildWebGestureEvent(event, device_pixel_ratio);
 }
 
 }  // namespace mojo