events: add ability to serialize TouchEvents

This makes the event serialization code handle TouchEvents. I plan on
doing a cleanup pass to make MouseEvent serialization use the PointerDetails
struct traits.

BUG=865781
TEST=covered by tests

Change-Id: I190ac58a3066c10bc08cd083702bc15232d4141d
Reviewed-on: https://chromium-review.googlesource.com/c/1265160
Commit-Queue: Scott Violet <sky@chromium.org>
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Cr-Commit-Position: refs/heads/master@{#597383}

ui/events/BUILD.gn

@@ -521,6 +521,7 @@ if (!is_ios) {
       "//ipc:test_support",
       "//mojo/core/test:run_all_unittests",
       "//mojo/public/cpp/bindings",
+      "//mojo/public/cpp/test_support:test_utils",
       "//skia",
       "//testing/gmock",
       "//testing/gtest",

ui/events/event.h

@@ -737,6 +737,9 @@ class EVENTS_EXPORT TouchEvent : public LocatedEvent {
     should_remove_native_touch_id_mapping_ =
         should_remove_native_touch_id_mapping;
   }
+  bool should_remove_native_touch_id_mapping() const {
+    return should_remove_native_touch_id_mapping_;
+  }
 
   // Overridden from LocatedEvent.
   void UpdateForRootTransform(
@@ -756,6 +759,9 @@ class EVENTS_EXPORT TouchEvent : public LocatedEvent {
 
  private:
   // A unique identifier for the touch event.
+  // NOTE: this is *not* serialized over mojom, as the number is unique to
+  // a particular process, and as mojom may go cross process, to serialize could
+  // lead to conflicts.
   uint32_t unique_event_id_;
 
   // Whether the (unhandled) touch event will produce a scroll event (e.g., a
@@ -767,6 +773,7 @@ class EVENTS_EXPORT TouchEvent : public LocatedEvent {
   // event id and the touch_id_. This should only be the case for
   // release and cancel events where the associated touch press event
   // created a mapping between the native id and the touch_id_.
+  // NOTE: this is not serialized, as it's generally unique to the source.
   bool should_remove_native_touch_id_mapping_;
 
   // True for devices like some pens when they support hovering over

ui/events/mojo/event.mojom

@@ -140,6 +140,29 @@ struct ScrollData {
   ScrollEventPhase scroll_event_phase;
 };
 
+// This mirrors the C++ class of the same name, see it for details.
+struct PointerDetails {
+  PointerKind pointer_type;
+  float radius_x;
+  float radius_y;
+  float force;
+  float tilt_x;
+  float tilt_y;
+  float tangential_pressure;
+  float twist;
+  int32 id;
+  int32 offset_x;
+  int32 offset_y;
+};
+
+// This is used for TouchEvents.
+struct TouchData {
+  bool may_cause_scrolling;
+  bool hovering;
+  LocationData location;
+  PointerDetails pointer_details;
+};
+
 struct Event {
   // TODO(sky): rename to type.
   EventType action;
@@ -157,5 +180,6 @@ struct Event {
   PointerData? pointer_data;
   GestureData? gesture_data;
   ScrollData? scroll_data;
+  TouchData? touch_data;
   map<string, array<uint8>>? properties;
 };

ui/events/mojo/event.typemap

@@ -22,5 +22,6 @@ sources = [
 type_mappings = [
   "ui.mojom.Event=std::unique_ptr<ui::Event>[move_only]",
   "ui.mojom.EventMomentumPhase=ui::EventMomentumPhase",
+  "ui.mojom.PointerDetails=ui::PointerDetails",
   "ui.mojom.ScrollEventPhase=ui::ScrollEventPhase",
 ]

ui/events/mojo/event_constants.mojom

@@ -40,6 +40,10 @@ enum EventType {
   MOUSE_EXITED_EVENT,
   MOUSE_WHEEL_EVENT,
   MOUSE_CAPTURE_CHANGED_EVENT,
+  TOUCH_RELEASED,
+  TOUCH_PRESSED,
+  TOUCH_MOVED,
+  TOUCH_CANCELLED,
 };
 
 // This mirrors ui::EventFlags
@@ -67,7 +71,9 @@ const int32 kMouseEventFlagIsNonClient   = 0x20000;
 
 // TODO(erg): Move accessibility flags and maybe synthetic touch events here.
 
+// TODO(sky): rename EventPointerType.
 enum PointerKind {
+  UNKNOWN,
   MOUSE,
   PEN,
   TOUCH,

ui/events/mojo/event_struct_traits.cc

@@ -26,21 +26,6 @@ ui::mojom::LocationDataPtr GetLocationData(const ui::LocatedEvent* event) {
   return location_data;
 }
 
-ui::EventPointerType PointerTypeFromPointerKind(ui::mojom::PointerKind kind) {
-  switch (kind) {
-    case ui::mojom::PointerKind::MOUSE:
-      return ui::EventPointerType::POINTER_TYPE_MOUSE;
-    case ui::mojom::PointerKind::TOUCH:
-      return ui::EventPointerType::POINTER_TYPE_TOUCH;
-    case ui::mojom::PointerKind::PEN:
-      return ui::EventPointerType::POINTER_TYPE_PEN;
-    case ui::mojom::PointerKind::ERASER:
-      return ui::EventPointerType::POINTER_TYPE_ERASER;
-  }
-  NOTREACHED();
-  return ui::EventPointerType::POINTER_TYPE_UNKNOWN;
-}
-
 void UpdateEventLocation(const ui::mojom::PointerData& pointer_data,
                          EventUniquePtr* out) {
   // TODO(katie): Update LocationData to have two PointF instead of storing this
@@ -56,9 +41,9 @@ void UpdateEventLocation(const ui::mojom::PointerData& pointer_data,
   out->get()->AsLocatedEvent()->set_root_location_f(screen_location);
 }
 
-bool ReadPointerDetails(ui::mojom::EventType event_type,
-                        const ui::mojom::PointerData& pointer_data,
-                        ui::PointerDetails* out) {
+bool ReadPointerDetailsDeprecated(ui::mojom::EventType event_type,
+                                  const ui::mojom::PointerData& pointer_data,
+                                  ui::PointerDetails* out) {
   switch (pointer_data.kind) {
     case ui::mojom::PointerKind::MOUSE: {
       if (event_type == ui::mojom::EventType::POINTER_WHEEL_CHANGED ||
@@ -76,18 +61,23 @@ bool ReadPointerDetails(ui::mojom::EventType event_type,
     }
     case ui::mojom::PointerKind::TOUCH:
     case ui::mojom::PointerKind::PEN: {
+      ui::EventPointerType pointer_type;
+      if (!EnumTraits<ui::mojom::PointerKind, ui::EventPointerType>::FromMojom(
+              pointer_data.kind, &pointer_type))
+        return false;
       const ui::mojom::BrushData& brush_data = *pointer_data.brush_data;
       *out = ui::PointerDetails(
-          PointerTypeFromPointerKind(pointer_data.kind),
-          pointer_data.pointer_id, brush_data.width, brush_data.height,
-          brush_data.pressure, brush_data.twist, brush_data.tilt_x,
-          brush_data.tilt_y, brush_data.tangential_pressure);
+          pointer_type, pointer_data.pointer_id, brush_data.width,
+          brush_data.height, brush_data.pressure, brush_data.twist,
+          brush_data.tilt_x, brush_data.tilt_y, brush_data.tangential_pressure);
       return true;
     }
     case ui::mojom::PointerKind::ERASER:
       // TODO(jamescook): Eraser support.
       NOTIMPLEMENTED();
       return false;
+    case ui::mojom::PointerKind::UNKNOWN:
+      return false;
   }
   NOTREACHED();
   return false;
@@ -225,6 +215,14 @@ ui::mojom::EventType TypeConverter<ui::mojom::EventType,
       return ui::mojom::EventType::MOUSE_WHEEL_EVENT;
     case ui::ET_MOUSE_CAPTURE_CHANGED:
       return ui::mojom::EventType::MOUSE_CAPTURE_CHANGED_EVENT;
+    case ui::ET_TOUCH_RELEASED:
+      return ui::mojom::EventType::TOUCH_RELEASED;
+    case ui::ET_TOUCH_PRESSED:
+      return ui::mojom::EventType::TOUCH_PRESSED;
+    case ui::ET_TOUCH_MOVED:
+      return ui::mojom::EventType::TOUCH_MOVED;
+    case ui::ET_TOUCH_CANCELLED:
+      return ui::mojom::EventType::TOUCH_CANCELLED;
     default:
       NOTREACHED() << "Using unknown event types closes connections:"
                    << ui::EventTypeName(type);
@@ -283,6 +281,14 @@ ui::EventType TypeConverter<ui::EventType, ui::mojom::EventType>::Convert(
       return ui::ET_MOUSEWHEEL;
     case ui::mojom::EventType::MOUSE_CAPTURE_CHANGED_EVENT:
       return ui::ET_MOUSE_CAPTURE_CHANGED;
+    case ui::mojom::EventType::TOUCH_RELEASED:
+      return ui::ET_TOUCH_RELEASED;
+    case ui::mojom::EventType::TOUCH_PRESSED:
+      return ui::ET_TOUCH_PRESSED;
+    case ui::mojom::EventType::TOUCH_MOVED:
+      return ui::ET_TOUCH_MOVED;
+    case ui::mojom::EventType::TOUCH_CANCELLED:
+      return ui::ET_TOUCH_CANCELLED;
     default:
       NOTREACHED();
   }
@@ -454,6 +460,26 @@ StructTraits<ui::mojom::EventDataView, EventUniquePtr>::scroll_data(
   return scroll_data;
 }
 
+// static
+ui::mojom::TouchDataPtr
+StructTraits<ui::mojom::EventDataView, EventUniquePtr>::touch_data(
+    const EventUniquePtr& event) {
+  if (!event->IsTouchEvent())
+    return nullptr;
+
+  const ui::TouchEvent* touch_event = event->AsTouchEvent();
+  ui::mojom::TouchDataPtr touch_data(ui::mojom::TouchData::New());
+  touch_data->may_cause_scrolling = touch_event->may_cause_scrolling();
+  touch_data->hovering = touch_event->hovering();
+  touch_data->location = ui::mojom::LocationData::New();
+  touch_data->location->x = touch_event->location_f().x();
+  touch_data->location->y = touch_event->location_f().y();
+  touch_data->location->screen_x = touch_event->root_location_f().x();
+  touch_data->location->screen_y = touch_event->root_location_f().y();
+  touch_data->pointer_details = touch_event->pointer_details();
+  return touch_data;
+}
+
 // static
 base::flat_map<std::string, std::vector<uint8_t>>
 StructTraits<ui::mojom::EventDataView, EventUniquePtr>::properties(
@@ -506,7 +532,8 @@ bool StructTraits<ui::mojom::EventDataView, EventUniquePtr>::Read(
         return false;
 
       ui::PointerDetails pointer_details;
-      if (!ReadPointerDetails(event.action(), *pointer_data, &pointer_details))
+      if (!ReadPointerDetailsDeprecated(event.action(), *pointer_data,
+                                        &pointer_details))
         return false;
 
       *out = std::make_unique<ui::PointerEvent>(
@@ -552,7 +579,8 @@ bool StructTraits<ui::mojom::EventDataView, EventUniquePtr>::Read(
         return false;
 
       ui::PointerDetails pointer_details;
-      if (!ReadPointerDetails(event.action(), *pointer_data, &pointer_details))
+      if (!ReadPointerDetailsDeprecated(event.action(), *pointer_data,
+                                        &pointer_details))
         return false;
 
       if (event.action() == ui::mojom::EventType::MOUSE_WHEEL_EVENT) {
@@ -575,6 +603,27 @@ bool StructTraits<ui::mojom::EventDataView, EventUniquePtr>::Read(
       UpdateEventLocation(*pointer_data, out);
       break;
     }
+    case ui::mojom::EventType::TOUCH_RELEASED:
+    case ui::mojom::EventType::TOUCH_PRESSED:
+    case ui::mojom::EventType::TOUCH_MOVED:
+    case ui::mojom::EventType::TOUCH_CANCELLED: {
+      ui::mojom::TouchDataPtr touch_data;
+      if (!event.ReadTouchData(&touch_data))
+        return false;
+      std::unique_ptr<ui::TouchEvent> touch_event =
+          std::make_unique<ui::TouchEvent>(
+              mojo::ConvertTo<ui::EventType>(event.action()),
+              gfx::Point(),  // Real location set below.
+              time_stamp, touch_data->pointer_details, event.flags());
+      touch_event->set_location_f(
+          gfx::PointF(touch_data->location->x, touch_data->location->y));
+      touch_event->set_root_location_f(gfx::PointF(
+          touch_data->location->screen_x, touch_data->location->screen_y));
+      touch_event->set_may_cause_scrolling(touch_data->may_cause_scrolling);
+      touch_event->set_hovering(touch_data->hovering);
+      *out = std::move(touch_event);
+      return true;
+    }
     case ui::mojom::EventType::UNKNOWN:
       NOTREACHED() << "Using unknown event types closes connections";
       return false;
@@ -595,4 +644,23 @@ bool StructTraits<ui::mojom::EventDataView, EventUniquePtr>::Read(
   return true;
 }
 
+// static
+bool StructTraits<ui::mojom::PointerDetailsDataView, ui::PointerDetails>::Read(
+    ui::mojom::PointerDetailsDataView data,
+    ui::PointerDetails* out) {
+  if (!data.ReadPointerType(&out->pointer_type))
+    return false;
+  out->radius_x = data.radius_x();
+  out->radius_y = data.radius_y();
+  out->force = data.force();
+  out->tilt_x = data.tilt_x();
+  out->tilt_y = data.tilt_y();
+  out->tangential_pressure = data.tangential_pressure();
+  out->twist = data.twist();
+  out->id = data.id();
+  out->offset.set_x(data.offset_x());
+  out->offset.set_y(data.offset_y());
+  return true;
+}
+
 }  // namespace mojo

ui/events/mojo/event_struct_traits.h

@@ -18,6 +18,7 @@
 namespace ui {
 class Event;
 class LatencyInfo;
+struct PointerDetails;
 }
 
 namespace mojo {
@@ -44,6 +45,7 @@ struct StructTraits<ui::mojom::EventDataView, EventUniquePtr> {
   static ui::mojom::PointerDataPtr pointer_data(const EventUniquePtr& event);
   static ui::mojom::GestureDataPtr gesture_data(const EventUniquePtr& event);
   static ui::mojom::ScrollDataPtr scroll_data(const EventUniquePtr& event);
+  static ui::mojom::TouchDataPtr touch_data(const EventUniquePtr& event);
   static base::flat_map<std::string, std::vector<uint8_t>> properties(
       const EventUniquePtr& event);
   static bool Read(ui::mojom::EventDataView r, EventUniquePtr* out);
@@ -92,6 +94,71 @@ struct EnumTraits<ui::mojom::EventMomentumPhase, ui::EventMomentumPhase> {
   }
 };
 
+template <>
+struct EnumTraits<ui::mojom::PointerKind, ui::EventPointerType> {
+  static ui::mojom::PointerKind ToMojom(ui::EventPointerType input) {
+    switch (input) {
+      case ui::EventPointerType::POINTER_TYPE_UNKNOWN:
+        return ui::mojom::PointerKind::UNKNOWN;
+      case ui::EventPointerType::POINTER_TYPE_MOUSE:
+        return ui::mojom::PointerKind::MOUSE;
+      case ui::EventPointerType::POINTER_TYPE_PEN:
+        return ui::mojom::PointerKind::PEN;
+      case ui::EventPointerType::POINTER_TYPE_TOUCH:
+        return ui::mojom::PointerKind::TOUCH;
+      case ui::EventPointerType::POINTER_TYPE_ERASER:
+        return ui::mojom::PointerKind::ERASER;
+    }
+    NOTREACHED();
+    return ui::mojom::PointerKind::UNKNOWN;
+  }
+
+  static bool FromMojom(ui::mojom::PointerKind input,
+                        ui::EventPointerType* out) {
+    switch (input) {
+      case ui::mojom::PointerKind::UNKNOWN:
+        *out = ui::EventPointerType::POINTER_TYPE_UNKNOWN;
+        return true;
+      case ui::mojom::PointerKind::MOUSE:
+        *out = ui::EventPointerType::POINTER_TYPE_MOUSE;
+        return true;
+      case ui::mojom::PointerKind::PEN:
+        *out = ui::EventPointerType::POINTER_TYPE_PEN;
+        return true;
+      case ui::mojom::PointerKind::TOUCH:
+        *out = ui::EventPointerType::POINTER_TYPE_TOUCH;
+        return true;
+      case ui::mojom::PointerKind::ERASER:
+        *out = ui::EventPointerType::POINTER_TYPE_ERASER;
+        return true;
+    }
+    NOTREACHED();
+    return false;
+  }
+};
+
+template <>
+struct StructTraits<ui::mojom::PointerDetailsDataView, ui::PointerDetails> {
+  static ui::EventPointerType pointer_type(const ui::PointerDetails& i) {
+    return i.pointer_type;
+  }
+  static float radius_x(const ui::PointerDetails& i) { return i.radius_x; }
+  static float radius_y(const ui::PointerDetails& i) { return i.radius_y; }
+  static float force(const ui::PointerDetails& i) { return i.force; }
+  static float tilt_x(const ui::PointerDetails& i) { return i.tilt_x; }
+  static float tilt_y(const ui::PointerDetails& i) { return i.tilt_y; }
+  static float tangential_pressure(const ui::PointerDetails& i) {
+    return i.tangential_pressure;
+  }
+  static float twist(const ui::PointerDetails& i) { return i.twist; }
+  static int32_t id(const ui::PointerDetails& i) { return i.id; }
+  static int32_t offset_x(const ui::PointerDetails& i) { return i.offset.x(); }
+  static int32_t offset_y(const ui::PointerDetails& i) { return i.offset.y(); }
+
+  static bool Read(ui::mojom::PointerDetailsDataView data,
+                   ui::PointerDetails* out);
+};
+
 template <>
 struct EnumTraits<ui::mojom::ScrollEventPhase, ui::ScrollEventPhase> {
   static ui::mojom::ScrollEventPhase ToMojom(ui::ScrollEventPhase input) {

ui/events/mojo/struct_traits_unittest.cc

@@ -5,8 +5,10 @@
 #include <utility>
 
 #include "base/message_loop/message_loop.h"
+#include "base/stl_util.h"
 #include "mojo/public/cpp/base/time_mojom_traits.h"
 #include "mojo/public/cpp/bindings/binding_set.h"
+#include "mojo/public/cpp/test_support/test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/events/event.h"
 #include "ui/events/keycodes/dom/dom_code.h"
@@ -43,10 +45,48 @@ class StructTraitsTest : public testing::Test, public mojom::TraitsTestService {
   DISALLOW_COPY_AND_ASSIGN(StructTraitsTest);
 };
 
+void ExpectTouchEventsEqual(const TouchEvent& expected,
+                            const TouchEvent& actual) {
+  EXPECT_EQ(expected.may_cause_scrolling(), actual.may_cause_scrolling());
+  EXPECT_EQ(expected.hovering(), actual.hovering());
+  EXPECT_EQ(expected.pointer_details(), actual.pointer_details());
+}
+
+void ExpectLocatedEventsEqual(const LocatedEvent& expected,
+                              const LocatedEvent& actual) {
+  EXPECT_EQ(expected.location_f(), actual.location_f());
+  EXPECT_EQ(expected.root_location_f(), actual.root_location_f());
+}
+
+void ExpectMouseEventsEqual(const MouseEvent& expected,
+                            const MouseEvent& actual) {
+  EXPECT_EQ(expected.pointer_details(), actual.pointer_details());
+  EXPECT_EQ(expected.changed_button_flags(), actual.changed_button_flags());
+}
+
+void ExpectEventsEqual(const Event& expected, const Event& actual) {
+  EXPECT_EQ(expected.type(), actual.type());
+  EXPECT_EQ(expected.time_stamp(), actual.time_stamp());
+  EXPECT_EQ(expected.flags(), actual.flags());
+  if (expected.IsLocatedEvent()) {
+    ASSERT_TRUE(actual.IsLocatedEvent());
+    ExpectLocatedEventsEqual(*expected.AsLocatedEvent(),
+                             *actual.AsLocatedEvent());
+  }
+  if (expected.IsMouseEvent()) {
+    ASSERT_TRUE(actual.IsMouseEvent());
+    ExpectMouseEventsEqual(*expected.AsMouseEvent(), *actual.AsMouseEvent());
+  }
+  if (expected.IsTouchEvent()) {
+    ASSERT_TRUE(actual.IsTouchEvent());
+    ExpectTouchEventsEqual(*expected.AsTouchEvent(), *actual.AsTouchEvent());
+  }
+}
+
 }  // namespace
 
 TEST_F(StructTraitsTest, KeyEvent) {
-  KeyEvent kTestData[] = {
+  const KeyEvent kTestData[] = {
       {ET_KEY_PRESSED, VKEY_RETURN, EF_CONTROL_DOWN},
       {ET_KEY_PRESSED, VKEY_MENU, EF_ALT_DOWN},
       {ET_KEY_RELEASED, VKEY_SHIFT, EF_SHIFT_DOWN},
@@ -64,14 +104,13 @@ TEST_F(StructTraitsTest, KeyEvent) {
   };
 
   mojom::TraitsTestServicePtr proxy = GetTraitsTestProxy();
-  for (size_t i = 0; i < arraysize(kTestData); i++) {
+  for (size_t i = 0; i < base::size(kTestData); i++) {
     std::unique_ptr<Event> output;
     proxy->EchoEvent(Event::Clone(kTestData[i]), &output);
     EXPECT_TRUE(output->IsKeyEvent());
 
     const KeyEvent* output_key_event = output->AsKeyEvent();
-    EXPECT_EQ(kTestData[i].type(), output_key_event->type());
-    EXPECT_EQ(kTestData[i].flags(), output_key_event->flags());
+    ExpectEventsEqual(kTestData[i], *output_key_event);
     EXPECT_EQ(kTestData[i].GetCharacter(), output_key_event->GetCharacter());
     EXPECT_EQ(kTestData[i].GetUnmodifiedText(),
               output_key_event->GetUnmodifiedText());
@@ -81,12 +120,11 @@ TEST_F(StructTraitsTest, KeyEvent) {
     EXPECT_EQ(kTestData[i].GetConflatedWindowsKeyCode(),
               output_key_event->GetConflatedWindowsKeyCode());
     EXPECT_EQ(kTestData[i].code(), output_key_event->code());
-    EXPECT_EQ(kTestData[i].time_stamp(), output_key_event->time_stamp());
   }
 }
 
 TEST_F(StructTraitsTest, PointerEvent) {
-  PointerEvent kTestData[] = {
+  const PointerEvent kTestData[] = {
       // Mouse pointer events:
       {ET_POINTER_DOWN, gfx::Point(10, 10), gfx::Point(20, 30), EF_NONE, 0,
        PointerDetails(EventPointerType::POINTER_TYPE_MOUSE,
@@ -169,7 +207,7 @@ TEST_F(StructTraitsTest, PointerEvent) {
   };
 
   mojom::TraitsTestServicePtr proxy = GetTraitsTestProxy();
-  for (size_t i = 0; i < arraysize(kTestData); i++) {
+  for (size_t i = 0; i < base::size(kTestData); i++) {
     std::unique_ptr<Event> output;
     proxy->EchoEvent(Event::Clone(kTestData[i]), &output);
     EXPECT_TRUE(output->IsPointerEvent());
@@ -190,7 +228,7 @@ TEST_F(StructTraitsTest, PointerEvent) {
 }
 
 TEST_F(StructTraitsTest, MouseEvent) {
-  MouseEvent kTestData[] = {
+  const MouseEvent kTestData[] = {
       {ET_MOUSE_PRESSED, gfx::Point(10, 10), gfx::Point(20, 30),
        base::TimeTicks() + base::TimeDelta::FromMicroseconds(201), EF_NONE, 0,
        PointerDetails(EventPointerType::POINTER_TYPE_MOUSE,
@@ -227,27 +265,17 @@ TEST_F(StructTraitsTest, MouseEvent) {
   };
 
   mojom::TraitsTestServicePtr proxy = GetTraitsTestProxy();
-  for (size_t i = 0; i < arraysize(kTestData); i++) {
+  for (size_t i = 0; i < base::size(kTestData); i++) {
     std::unique_ptr<Event> output;
     proxy->EchoEvent(Event::Clone(kTestData[i]), &output);
     ASSERT_TRUE(output->IsMouseEvent());
 
-    const MouseEvent* output_event = output->AsMouseEvent();
-    EXPECT_EQ(kTestData[i].type(), output_event->type());
-    EXPECT_EQ(kTestData[i].flags(), output_event->flags());
-    EXPECT_EQ(kTestData[i].location(), output_event->location());
-    EXPECT_EQ(kTestData[i].root_location(), output_event->root_location());
-    EXPECT_EQ(kTestData[i].pointer_details().id,
-              output_event->pointer_details().id);
-    EXPECT_EQ(kTestData[i].changed_button_flags(),
-              output_event->changed_button_flags());
-    EXPECT_EQ(kTestData[i].pointer_details(), output_event->pointer_details());
-    EXPECT_EQ(kTestData[i].time_stamp(), output_event->time_stamp());
+    ExpectEventsEqual(kTestData[i], *output);
   }
 }
 
 TEST_F(StructTraitsTest, PointerWheelEvent) {
-  MouseWheelEvent kTestData[] = {
+  const MouseWheelEvent kTestData[] = {
       {gfx::Vector2d(11, 15), gfx::Point(3, 4), gfx::Point(40, 30),
        base::TimeTicks() + base::TimeDelta::FromMicroseconds(301),
        EF_LEFT_MOUSE_BUTTON, EF_LEFT_MOUSE_BUTTON},
@@ -261,7 +289,7 @@ TEST_F(StructTraitsTest, PointerWheelEvent) {
   };
 
   mojom::TraitsTestServicePtr proxy = GetTraitsTestProxy();
-  for (size_t i = 0; i < arraysize(kTestData); i++) {
+  for (size_t i = 0; i < base::size(kTestData); i++) {
     std::unique_ptr<Event> output;
     proxy->EchoEvent(Event::Clone(ui::PointerEvent(kTestData[i])), &output);
     EXPECT_EQ(ET_POINTER_WHEEL_CHANGED, output->type());
@@ -279,7 +307,7 @@ TEST_F(StructTraitsTest, PointerWheelEvent) {
 }
 
 TEST_F(StructTraitsTest, MouseWheelEvent) {
-  MouseWheelEvent kTestData[] = {
+  const MouseWheelEvent kTestData[] = {
       {gfx::Vector2d(11, 15), gfx::Point(3, 4), gfx::Point(40, 30),
        base::TimeTicks() + base::TimeDelta::FromMicroseconds(301),
        EF_LEFT_MOUSE_BUTTON, EF_LEFT_MOUSE_BUTTON},
@@ -293,7 +321,7 @@ TEST_F(StructTraitsTest, MouseWheelEvent) {
   };
 
   mojom::TraitsTestServicePtr proxy = GetTraitsTestProxy();
-  for (size_t i = 0; i < arraysize(kTestData); i++) {
+  for (size_t i = 0; i < base::size(kTestData); i++) {
     std::unique_ptr<Event> output;
     proxy->EchoEvent(
         Event::Clone(ui::MouseWheelEvent(ui::PointerEvent(kTestData[i]))),
@@ -301,6 +329,7 @@ TEST_F(StructTraitsTest, MouseWheelEvent) {
     ASSERT_EQ(ET_MOUSEWHEEL, output->type());
 
     const MouseWheelEvent* output_event = output->AsMouseWheelEvent();
+    // TODO(sky): make this use ExpectEventsEqual().
     EXPECT_EQ(ET_MOUSEWHEEL, output_event->type());
     EXPECT_EQ(kTestData[i].flags(), output_event->flags());
     EXPECT_EQ(kTestData[i].location(), output_event->location());
@@ -325,13 +354,7 @@ TEST_F(StructTraitsTest, FloatingPointLocations) {
   proxy->EchoEvent(Event::Clone(input_event), &output);
   ASSERT_TRUE(output->IsMouseEvent());
 
-  const MouseEvent* output_event = output->AsMouseEvent();
-  EXPECT_EQ(input_event.type(), output_event->type());
-  EXPECT_EQ(input_event.flags(), output_event->flags());
-  EXPECT_EQ(input_event.location(), output_event->location());
-  EXPECT_EQ(input_event.root_location(), output_event->root_location());
-  EXPECT_EQ(input_event.location_f(), output_event->location_f());
-  EXPECT_EQ(input_event.root_location_f(), output_event->root_location_f());
+  ExpectEventsEqual(input_event, *output->AsMouseEvent());
 }
 
 TEST_F(StructTraitsTest, KeyEventPropertiesSerialized) {
@@ -352,7 +375,7 @@ TEST_F(StructTraitsTest, KeyEventPropertiesSerialized) {
 }
 
 TEST_F(StructTraitsTest, GestureEvent) {
-  GestureEvent kTestData[] = {
+  const GestureEvent kTestData[] = {
       {10, 20, EF_NONE,
        base::TimeTicks() + base::TimeDelta::FromMicroseconds(401),
        GestureEventDetails(ET_SCROLL_FLING_START)},
@@ -362,25 +385,21 @@ TEST_F(StructTraitsTest, GestureEvent) {
   };
 
   mojom::TraitsTestServicePtr proxy = GetTraitsTestProxy();
-  for (size_t i = 0; i < arraysize(kTestData); i++) {
+  for (size_t i = 0; i < base::size(kTestData); i++) {
     std::unique_ptr<Event> output;
     proxy->EchoEvent(Event::Clone(kTestData[i]), &output);
     EXPECT_TRUE(output->IsGestureEvent());
 
     const GestureEvent* output_ptr_event = output->AsGestureEvent();
-    EXPECT_EQ(kTestData[i].type(), output_ptr_event->type());
-    EXPECT_EQ(kTestData[i].flags(), output_ptr_event->flags());
-    EXPECT_EQ(kTestData[i].location(), output_ptr_event->location());
-    EXPECT_EQ(kTestData[i].root_location(), output_ptr_event->root_location());
+    ExpectEventsEqual(kTestData[i], *output);
     EXPECT_EQ(kTestData[i].details(), output_ptr_event->details());
     EXPECT_EQ(kTestData[i].unique_touch_event_id(),
               output_ptr_event->unique_touch_event_id());
-    EXPECT_EQ(kTestData[i].time_stamp(), output_ptr_event->time_stamp());
   }
 }
 
 TEST_F(StructTraitsTest, ScrollEvent) {
-  ScrollEvent kTestData[] = {
+  const ScrollEvent kTestData[] = {
       {ET_SCROLL, gfx::Point(10, 20),
        base::TimeTicks() + base::TimeDelta::FromMicroseconds(501), EF_NONE, 1,
        2, 3, 4, 5, EventMomentumPhase::NONE, ScrollEventPhase::kNone},
@@ -412,16 +431,13 @@ TEST_F(StructTraitsTest, ScrollEvent) {
   };
 
   mojom::TraitsTestServicePtr proxy = GetTraitsTestProxy();
-  for (size_t i = 0; i < arraysize(kTestData); i++) {
+  for (size_t i = 0; i < base::size(kTestData); i++) {
     std::unique_ptr<Event> output;
     proxy->EchoEvent(Event::Clone(kTestData[i]), &output);
     EXPECT_TRUE(output->IsScrollEvent());
 
     const ScrollEvent* output_ptr_event = output->AsScrollEvent();
-    EXPECT_EQ(kTestData[i].type(), output_ptr_event->type());
-    EXPECT_EQ(kTestData[i].location(), output_ptr_event->location());
-    EXPECT_EQ(kTestData[i].time_stamp(), output_ptr_event->time_stamp());
-    EXPECT_EQ(kTestData[i].flags(), output_ptr_event->flags());
+    ExpectEventsEqual(kTestData[i], *output_ptr_event);
     EXPECT_EQ(kTestData[i].x_offset(), output_ptr_event->x_offset());
     EXPECT_EQ(kTestData[i].y_offset(), output_ptr_event->y_offset());
     EXPECT_EQ(kTestData[i].x_offset_ordinal(),
@@ -434,4 +450,79 @@ TEST_F(StructTraitsTest, ScrollEvent) {
   }
 }
 
+TEST_F(StructTraitsTest, PointerDetails) {
+  const PointerDetails kTestData[] = {
+      {EventPointerType::POINTER_TYPE_UNKNOWN, 1, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f},
+      {EventPointerType::POINTER_TYPE_MOUSE, 1, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f},
+      {EventPointerType::POINTER_TYPE_PEN, 11, 12.f, 13.f, 14.f, 15.f, 16.f,
+       17.f},
+      {EventPointerType::POINTER_TYPE_TOUCH, 1, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f},
+      {EventPointerType::POINTER_TYPE_ERASER, 21, 22.f, 23.f, 24.f, 25.f, 26.f,
+       27.f},
+  };
+  for (size_t i = 0; i < base::size(kTestData); i++) {
+    // Set |offset| as the constructor used above does not modify it.
+    PointerDetails input(kTestData[i]);
+    input.offset.set_x(i);
+    input.offset.set_y(i + 1);
+
+    PointerDetails output;
+    ASSERT_TRUE(mojo::test::SerializeAndDeserialize<ui::mojom::PointerDetails>(
+        &input, &output));
+    EXPECT_EQ(input, output);
+  }
+}
+
+TEST_F(StructTraitsTest, TouchEvent) {
+  const TouchEvent kTestData[] = {
+      {ET_TOUCH_RELEASED,
+       {1, 2},
+       base::TimeTicks::Now(),
+       {EventPointerType::POINTER_TYPE_UNKNOWN, 1, 2.f, 3.f, 4.f, 5.f, 6.f,
+        7.f},
+       EF_SHIFT_DOWN},
+      {ET_TOUCH_PRESSED, {1, 2}, base::TimeTicks::Now(), {}, EF_CONTROL_DOWN},
+      {ET_TOUCH_MOVED, {1, 2}, base::TimeTicks::Now(), {}, EF_NONE},
+      {ET_TOUCH_CANCELLED, {1, 2}, base::TimeTicks::Now(), {}, EF_NONE},
+  };
+  for (size_t i = 0; i < base::size(kTestData); i++) {
+    std::unique_ptr<Event> expected_copy = Event::Clone(kTestData[i]);
+    std::unique_ptr<Event> output;
+    ASSERT_TRUE(mojo::test::SerializeAndDeserialize<ui::mojom::Event>(
+        &expected_copy, &output));
+    ExpectEventsEqual(*expected_copy, *output);
+  }
+
+  // Serialize/Deserialize with fields that can not be set from constructor.
+  std::unique_ptr<TouchEvent> touch_event =
+      std::make_unique<TouchEvent>(ET_TOUCH_CANCELLED, gfx::Point(),
+                                   base::TimeTicks::Now(), PointerDetails());
+  touch_event->set_may_cause_scrolling(true);
+  touch_event->set_hovering(true);
+  std::unique_ptr<Event> expected = std::move(touch_event);
+  std::unique_ptr<Event> output;
+  ASSERT_TRUE(mojo::test::SerializeAndDeserialize<ui::mojom::Event>(&expected,
+                                                                    &output));
+  ExpectEventsEqual(*expected, *output);
+}
+
+TEST_F(StructTraitsTest, UnserializedTouchEventFields) {
+  std::unique_ptr<TouchEvent> touch_event =
+      std::make_unique<TouchEvent>(ET_TOUCH_CANCELLED, gfx::Point(),
+                                   base::TimeTicks::Now(), PointerDetails());
+  touch_event->set_should_remove_native_touch_id_mapping(true);
+  std::unique_ptr<Event> expected = std::move(touch_event);
+  std::unique_ptr<Event> output;
+  ASSERT_TRUE(mojo::test::SerializeAndDeserialize<ui::mojom::Event>(&expected,
+                                                                    &output));
+  ExpectEventsEqual(*expected, *output);
+  // Have to set this back to false, else the destructor tries to access
+  // state not setup in tests.
+  expected->AsTouchEvent()->set_should_remove_native_touch_id_mapping(false);
+  // See comments in TouchEvent for why these two fields are not persisted.
+  EXPECT_FALSE(output->AsTouchEvent()->should_remove_native_touch_id_mapping());
+  EXPECT_NE(expected->AsTouchEvent()->unique_event_id(),
+            output->AsTouchEvent()->unique_event_id());
+}
+
 }  // namespace ui