Overhaul Mandoline event transport code

mojo/converters/input_events/input_events_type_converters.cc

Index: mojo/converters/input_events/input_events_type_converters.cc
diff --git a/mojo/converters/input_events/input_events_type_converters.cc b/mojo/converters/input_events/input_events_type_converters.cc
index 88b35fe6a3b2cf739b1b464ddae39a43a091bf07..fda576396528a81c3e7231e81c5048887210dbba 100644
--- a/mojo/converters/input_events/input_events_type_converters.cc
+++ b/mojo/converters/input_events/input_events_type_converters.cc
@@ -30,10 +30,6 @@ ui::EventType MojoMouseEventTypeToUIEvent(const EventPtr& event) {
 
     case EVENT_TYPE_POINTER_MOVE:
       DCHECK(event->pointer_data);
-      if (event->pointer_data->horizontal_wheel != 0 ||
-          event->pointer_data->vertical_wheel != 0) {
-        return ui::ET_MOUSEWHEEL;
-      }
       if (event->flags &
           (EVENT_FLAGS_LEFT_MOUSE_BUTTON | EVENT_FLAGS_MIDDLE_MOUSE_BUTTON |
            EVENT_FLAGS_RIGHT_MOUSE_BUTTON)) {
@@ -71,6 +67,12 @@ ui::EventType MojoTouchEventTypeToUIEvent(const EventPtr& event) {
   return ui::ET_TOUCH_CANCELLED;
 }
 
+ui::EventType MojoWheelEventTypeToUIEvent(const EventPtr& event) {
+  DCHECK(!event->pointer_data.is_null());
+  DCHECK_EQ(POINTER_KIND_WHEEL, event->pointer_data->kind);
+  return ui::ET_MOUSEWHEEL;
+}
+
 void SetPointerDataLocationFromEvent(const ui::LocatedEvent& located_event,
                                      PointerData* pointer_data) {
   pointer_data->x = located_event.location_f().x();
@@ -166,7 +168,6 @@ EventPtr TypeConverter<EventPtr, ui::Event>::Convert(const ui::Event& input) {
   event->flags = EventFlags(input.flags());
   event->time_stamp = input.time_stamp().ToInternalValue();
 
-  PointerData pointer_data;
   if (input.IsMouseEvent()) {
     const ui::LocatedEvent* located_event =
         static_cast<const ui::LocatedEvent*>(&input);
@@ -175,29 +176,57 @@ EventPtr TypeConverter<EventPtr, ui::Event>::Convert(const ui::Event& input) {
     pointer_data->pointer_id = std::numeric_limits<int32>::max();
     pointer_data->kind = POINTER_KIND_MOUSE;
     SetPointerDataLocationFromEvent(*located_event, pointer_data.get());
+
     if (input.IsMouseWheelEvent()) {
+      pointer_data->kind = POINTER_KIND_WHEEL;
       const ui::MouseWheelEvent* wheel_event =
           static_cast<const ui::MouseWheelEvent*>(&input);
-      // This conversion assumes we're using the mojo meaning of these values:
-      // [-1 1].
-      pointer_data->horizontal_wheel =
-          static_cast<float>(wheel_event->x_offset()) / 100.0f;
-      pointer_data->vertical_wheel =
-          static_cast<float>(wheel_event->y_offset()) / 100.0f;
+
+      WheelDataPtr wheel_data(WheelData::New());
+
+      // TODO(rjkroege): Support page scrolling on windows by directly
+      // cracking into a mojo event when the native event is available.
+      wheel_data->mode = WHEEL_MODE_LINE;
+      // TODO(rjkroege): Support precise scrolling deltas.
+
+      if ((input.flags() & ui::EF_SHIFT_DOWN) != 0 &&
+          wheel_event->x_offset() == 0) {
+        wheel_data->delta_x = wheel_event->y_offset();
+        wheel_data->delta_y = 0;
+        wheel_data->delta_z = 0;
+      } else {
+        // TODO(rjkroege): support z in ui::Events.
+        wheel_data->delta_x = wheel_event->x_offset();
+        wheel_data->delta_y = wheel_event->y_offset();
+        wheel_data->delta_z = 0;
+      }
+      pointer_data->wheel_data = wheel_data.Pass();
     }
+
     event->pointer_data = pointer_data.Pass();
   } else if (input.IsTouchEvent()) {
     const ui::TouchEvent* touch_event =
         static_cast<const ui::TouchEvent*>(&input);
+
     PointerDataPtr pointer_data(PointerData::New());
     pointer_data->pointer_id = touch_event->touch_id();
     pointer_data->kind = POINTER_KIND_TOUCH;
     SetPointerDataLocationFromEvent(*touch_event, pointer_data.get());
-    pointer_data->radius_major = touch_event->radius_x();
-    pointer_data->radius_minor = touch_event->radius_y();
-    pointer_data->pressure = touch_event->force();
-    pointer_data->orientation = touch_event->rotation_angle();
+
+    BrushDataPtr brush_data(BrushData::New());
+
+    // TODO(rjkroege): Correct the coordinate system.
+    brush_data->width = touch_event->radius_x();
+    brush_data->height = touch_event->radius_y();
+    brush_data->pressure = touch_event->force();
+    brush_data->tiltY = 0;
+    brush_data->tiltZ = 0;
+    pointer_data->brush_data = brush_data.Pass();
     event->pointer_data = pointer_data.Pass();
+
+    // TODO(rjkroege): Plumb raw pointer events on windows.
+    // TODO(rjkroege): Handle force-touch on MacOS
+    // TODO(rjkroege): Adjust brush data appropriately for Android.
   } else if (input.IsKeyEvent()) {
     const ui::KeyEvent* key_event = static_cast<const ui::KeyEvent*>(&input);
     KeyDataPtr key_data(KeyData::New());
@@ -272,31 +301,44 @@ scoped_ptr<ui::Event> TypeConverter<scoped_ptr<ui::Event>, EventPtr>::Convert(
     case EVENT_TYPE_POINTER_UP:
     case EVENT_TYPE_POINTER_MOVE:
     case EVENT_TYPE_POINTER_CANCEL: {
-      if (input->pointer_data->kind == POINTER_KIND_MOUSE) {
+      switch (input->pointer_data->kind) {
+        case POINTER_KIND_MOUSE: {
         // TODO: last flags isn't right. Need to send changed_flags.
         scoped_ptr<ui::MouseEvent> event(new ui::MouseEvent(
             MojoMouseEventTypeToUIEvent(input), location, screen_location,
             ui::EventTimeForNow(), ui::EventFlags(input->flags),
             ui::EventFlags(input->flags)));
-        if (event->IsMouseWheelEvent()) {
-          // This conversion assumes we're using the mojo meaning of these
-          // values: [-1 1].
-          scoped_ptr<ui::MouseEvent> wheel_event(new ui::MouseWheelEvent(
-              *event,
-              static_cast<int>(input->pointer_data->horizontal_wheel * 100),
-              static_cast<int>(input->pointer_data->vertical_wheel * 100)));
-          event = wheel_event.Pass();
-        }
         return event.Pass();
-      }
-      scoped_ptr<ui::TouchEvent> touch_event(new ui::TouchEvent(
-          MojoTouchEventTypeToUIEvent(input), location,
-          ui::EventFlags(input->flags), input->pointer_data->pointer_id,
-          base::TimeDelta::FromInternalValue(input->time_stamp),
-          input->pointer_data->radius_major, input->pointer_data->radius_minor,
-          input->pointer_data->orientation, input->pointer_data->pressure));
+        } break;
+        case POINTER_KIND_TOUCH: {
+          scoped_ptr<ui::TouchEvent> touch_event(new ui::TouchEvent(
+              MojoTouchEventTypeToUIEvent(input), location,
+              ui::EventFlags(input->flags), input->pointer_data->pointer_id,
+              base::TimeDelta::FromInternalValue(input->time_stamp),
+              input->pointer_data->brush_data->width,
+              input->pointer_data->brush_data->height, 0,
+              input->pointer_data->brush_data->pressure));
       touch_event->set_root_location(screen_location);
       return touch_event.Pass();
+        } break;

[sadrul, 2015/09/09 04:19:04]

The indent above looks broken. 'git cl format'?

[rjkroege, 2015/09/09 19:45:38]

Aside: I did do a 'git cl format'. And I trusted that it had done the right
thing.

I fixed this up by hand.

+        case POINTER_KIND_WHEEL: {
+          scoped_ptr<ui::MouseEvent> pre_wheel_event(new ui::MouseEvent(
+              MojoWheelEventTypeToUIEvent(input), location, screen_location,
+              ui::EventTimeForNow(), ui::EventFlags(input->flags),
+              ui::EventFlags(input->flags)));
+          scoped_ptr<ui::MouseEvent> wheel_event(new ui::MouseWheelEvent(
+              *pre_wheel_event,
+              static_cast<int>(input->pointer_data->wheel_data->delta_x),
+              static_cast<int>(input->pointer_data->wheel_data->delta_y)));
+          return wheel_event.Pass();
+        } break;
+        case POINTER_KIND_UNKNOWN:
+          DCHECK(false);
+          break;
+        case POINTER_KIND_PEN:
+          NOTIMPLEMENTED();
+          break;
+      }
     }
     default:
       NOTIMPLEMENTED();