Constructors for ui::MouseEvent/ui::TouchEvent from ui::PointerEvent.

We don't support ui::PointerEvents in mus+ash client side right now, so we
need to convert ui::PointerEvent to ui::MouseEvent/ui::TouchEvent until we
have a better solution. This CL adds constructors we need so we can do this
conversion.

Previously this conversion happened when we deserialized mojom::Event to
ui::Event, but that didn't seem the correct place to do it, since we
serialized ui::PointerEvent (and not touch/mouse events) to mojom::Event, and
we should get the same kind of object when deserializing.

BUG=615094

Review-Url: https://codereview.chromium.org/2029713002
Cr-Commit-Position: refs/heads/master@{#397236}

ui/events/event.cc

@@ -462,6 +462,36 @@ MouseEvent::MouseEvent(const base::NativeEvent& native_event)
     SetClickCount(GetRepeatCount(*this));
 }
 
+MouseEvent::MouseEvent(const PointerEvent& pointer_event)
+    : LocatedEvent(pointer_event),
+      pointer_details_(pointer_event.pointer_details()) {
+  DCHECK(pointer_event.IsMousePointerEvent());
+  switch (pointer_event.type()) {
+    case ET_POINTER_DOWN:
+      SetType(ET_MOUSE_PRESSED);
+      break;
+
+    case ET_POINTER_MOVED:
+      SetType(ET_MOUSE_MOVED);
+      break;
+
+    case ET_POINTER_ENTERED:
+      SetType(ET_MOUSE_ENTERED);
+      break;
+
+    case ET_POINTER_EXITED:
+      SetType(ET_MOUSE_EXITED);
+      break;
+
+    case ET_POINTER_UP:
+      SetType(ET_MOUSE_RELEASED);
+      break;
+
+    default:
+      NOTREACHED();
+  }
+}
+
 MouseEvent::MouseEvent(EventType type,
                        const gfx::Point& location,
                        const gfx::Point& root_location,
@@ -669,6 +699,37 @@ TouchEvent::TouchEvent(const base::NativeEvent& native_event)
     should_remove_native_touch_id_mapping_ = true;
 }
 
+TouchEvent::TouchEvent(const PointerEvent& pointer_event)
+    : LocatedEvent(pointer_event),
+      touch_id_(pointer_event.pointer_id()),
+      unique_event_id_(ui::GetNextTouchEventId()),
+      rotation_angle_(0.0f),
+      may_cause_scrolling_(false),
+      should_remove_native_touch_id_mapping_(false),
+      pointer_details_(pointer_event.pointer_details()) {
+  DCHECK(pointer_event.IsTouchPointerEvent());
+  switch (pointer_event.type()) {
+    case ET_POINTER_DOWN:
+      SetType(ET_TOUCH_PRESSED);
+      break;
+
+    case ET_POINTER_MOVED:
+      SetType(ET_TOUCH_MOVED);
+      break;
+
+    case ET_POINTER_UP:
+      SetType(ET_TOUCH_RELEASED);
+      break;
+
+    case ET_POINTER_CANCELLED:
+      SetType(ET_TOUCH_CANCELLED);
+      break;
+
+    default:
+      NOTREACHED();
+  }
+}
+
 TouchEvent::TouchEvent(EventType type,
                        const gfx::Point& location,
                        int touch_id,

ui/events/event.h

@@ -465,6 +465,9 @@ class EVENTS_EXPORT MouseEvent : public LocatedEvent {
  public:
   explicit MouseEvent(const base::NativeEvent& native_event);
 
+  // |pointer_event.IsMousePointerEvent()| must be true.
+  explicit MouseEvent(const PointerEvent& pointer_event);
+
   // Create a new MouseEvent based on the provided model.
   // Uses the provided |type| and |flags| for the new event.
   // If source / target windows are provided, the model location will be
@@ -640,6 +643,9 @@ class EVENTS_EXPORT TouchEvent : public LocatedEvent {
  public:
   explicit TouchEvent(const base::NativeEvent& native_event);
 
+  // |pointer_event.IsTouchPointerEvent()| must be true.
+  explicit TouchEvent(const PointerEvent& pointer_event);
+
   // Create a new TouchEvent which is identical to the provided model.
   // If source / target windows are provided, the model location will be
   // converted from |source| coordinate system to |target| coordinate system.

ui/events/event_unittest.cc

@@ -887,6 +887,70 @@ TEST(EventTest, PointerEventClone) {
   }
 }
 
+TEST(EventTest, PointerEventToMouseEvent) {
+  const struct {
+    ui::EventType in_type;
+    ui::EventType out_type;
+    gfx::Point location;
+    gfx::Point root_location;
+    int flags;
+  } kTestData[] = {
+      {ui::ET_POINTER_DOWN, ui::ET_MOUSE_PRESSED, gfx::Point(10, 20),
+       gfx::Point(110, 120), 0},
+      {ui::ET_POINTER_MOVED, ui::ET_MOUSE_MOVED, gfx::Point(20, 10),
+       gfx::Point(1, 2), EF_LEFT_MOUSE_BUTTON},
+      {ui::ET_POINTER_ENTERED, ui::ET_MOUSE_ENTERED, gfx::Point(), gfx::Point(),
+       EF_MIDDLE_MOUSE_BUTTON | EF_RIGHT_MOUSE_BUTTON},
+      {ui::ET_POINTER_EXITED, ui::ET_MOUSE_EXITED, gfx::Point(5, 1),
+       gfx::Point(1, 5), EF_RIGHT_MOUSE_BUTTON},
+      {ui::ET_POINTER_UP, ui::ET_MOUSE_RELEASED, gfx::Point(1000, 1000),
+       gfx::Point(14, 15), EF_MIDDLE_MOUSE_BUTTON}};
+
+  for (size_t i = 0; i < arraysize(kTestData); i++) {
+    ui::PointerEvent pointer_event(
+        kTestData[i].in_type, ui::EventPointerType::POINTER_TYPE_MOUSE,
+        kTestData[i].location, kTestData[i].root_location, kTestData[i].flags,
+        0, base::TimeDelta());
+    ui::MouseEvent mouse_event(pointer_event);
+
+    EXPECT_EQ(kTestData[i].out_type, mouse_event.type());
+    EXPECT_EQ(kTestData[i].location, mouse_event.location());
+    EXPECT_EQ(kTestData[i].root_location, mouse_event.root_location());
+    EXPECT_EQ(kTestData[i].flags, mouse_event.flags());
+  }
+}
+
+TEST(EventTest, PointerEventToTouchEventType) {
+  ui::EventType kTouchTypeMap[][2] = {
+      {ui::ET_POINTER_DOWN, ui::ET_TOUCH_PRESSED},
+      {ui::ET_POINTER_MOVED, ui::ET_TOUCH_MOVED},
+      {ui::ET_POINTER_UP, ui::ET_TOUCH_RELEASED},
+      {ui::ET_POINTER_CANCELLED, ui::ET_TOUCH_CANCELLED},
+  };
+
+  for (size_t i = 0; i < arraysize(kTouchTypeMap); i++) {
+    ui::PointerEvent pointer_event(
+        kTouchTypeMap[i][0], ui::EventPointerType::POINTER_TYPE_TOUCH,
+        gfx::Point(), gfx::Point(), 0, 0, base::TimeDelta());
+    ui::TouchEvent touch_event(pointer_event);
+
+    EXPECT_EQ(kTouchTypeMap[i][1], touch_event.type());
+  }
+}
+
+TEST(EventTest, PointerEventToTouchEventDetails) {
+  ui::PointerEvent pointer_event(
+      ui::TouchEvent(ui::ET_TOUCH_PRESSED, gfx::Point(12, 14), 0, 15,
+                     EventTimeForNow(), 11.5, 13.5, 13.0, 0.5));
+  ui::TouchEvent touch_event(pointer_event);
+
+  EXPECT_EQ(pointer_event.location(), touch_event.location());
+  EXPECT_EQ(pointer_event.flags(), touch_event.flags());
+  EXPECT_EQ(pointer_event.pointer_id(), touch_event.touch_id());
+  EXPECT_EQ(pointer_event.pointer_details(), touch_event.pointer_details());
+  EXPECT_EQ(pointer_event.time_stamp(), touch_event.time_stamp());
+}
+
 // Checks that Event.Latency.OS.TOUCH_PRESSED, TOUCH_MOVED,
 // and TOUCH_RELEASED histograms are computed properly.
 #if defined(USE_X11)