ui: events: Add a class to hold common touch and stylus properties

ui/events/event_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/memory/scoped_ptr.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/events/event.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/keycodes/dom/dom_code.h"
 #include "ui/events/keycodes/dom/keycode_converter.h"
@@ skipping 41 matching lines @@
   EXPECT_EQ(10, keyev3.GetCharacter());
 
   event.InitKeyEvent(ET_KEY_PRESSED, VKEY_RETURN, EF_NONE);
   KeyEvent keyev4(event);
   EXPECT_EQ(13, keyev4.GetCharacter());
 #endif
 }
 
 TEST(EventTest, ClickCount) {
   const gfx::Point origin(0, 0);
-  MouseEvent mouseev(ET_MOUSE_PRESSED, origin, origin, EventTimeForNow(), 0, 0);
+  MouseEvent mouseev(
+      ET_MOUSE_PRESSED, origin, origin, EventTimeForNow(), 0, 0,
+      ui::PointerEventDetails(ui::EventPointerType::POINTER_TYPE_MOUSE));
   for (int i = 1; i <=3 ; ++i) {
     mouseev.SetClickCount(i);
     EXPECT_EQ(i, mouseev.GetClickCount());
   }
 }
 
 TEST(EventTest, RepeatedClick) {
   const gfx::Point origin(0, 0);
-  MouseEvent mouse_ev1(ET_MOUSE_PRESSED, origin, origin, EventTimeForNow(), 0,
-                       0);
-  MouseEvent mouse_ev2(ET_MOUSE_PRESSED, origin, origin, EventTimeForNow(), 0,
-                       0);
+  MouseEvent mouse_ev1(
+      ET_MOUSE_PRESSED, origin, origin, EventTimeForNow(), 0, 0,
+      ui::PointerEventDetails(ui::EventPointerType::POINTER_TYPE_MOUSE));
+  MouseEvent mouse_ev2(
+      ET_MOUSE_PRESSED, origin, origin, EventTimeForNow(), 0, 0,
+      ui::PointerEventDetails(ui::EventPointerType::POINTER_TYPE_MOUSE));
   LocatedEventTestApi test_ev1(&mouse_ev1);
   LocatedEventTestApi test_ev2(&mouse_ev2);
 
   base::TimeDelta start = base::TimeDelta::FromMilliseconds(0);
   base::TimeDelta soon = start + base::TimeDelta::FromMilliseconds(1);
   base::TimeDelta later = start + base::TimeDelta::FromMilliseconds(1000);
 
   // Same event.
   test_ev1.set_location(gfx::Point(0, 0));
   test_ev2.set_location(gfx::Point(1, 0));
@@ skipping 29 matching lines @@
 // double click if a release event was seen for the previous click. This
 // prevents the same PRESSED event from being processed twice:
 // http://crbug.com/389162
 TEST(EventTest, DoubleClickRequiresRelease) {
   const gfx::Point origin1(0, 0);
   const gfx::Point origin2(100, 0);
   scoped_ptr<MouseEvent> ev;
   base::TimeDelta start = base::TimeDelta::FromMilliseconds(0);
   base::TimeDelta soon = start + base::TimeDelta::FromMilliseconds(1);
 
-  ev.reset(new MouseEvent(ET_MOUSE_PRESSED, origin1, origin1, EventTimeForNow(),
-                          0, 0));
+  ev.reset(new MouseEvent(
+      ET_MOUSE_PRESSED, origin1, origin1, EventTimeForNow(), 0, 0,
+      ui::PointerEventDetails(ui::EventPointerType::POINTER_TYPE_MOUSE)));
   ev->set_time_stamp(start);
   EXPECT_EQ(1, MouseEvent::GetRepeatCount(*ev));
-  ev.reset(new MouseEvent(ET_MOUSE_PRESSED, origin1, origin1, EventTimeForNow(),
-                          0, 0));
+  ev.reset(new MouseEvent(
+      ET_MOUSE_PRESSED, origin1, origin1, EventTimeForNow(), 0, 0,
+      ui::PointerEventDetails(ui::EventPointerType::POINTER_TYPE_MOUSE)));
   ev->set_time_stamp(start);
   EXPECT_EQ(1, MouseEvent::GetRepeatCount(*ev));
 
-  ev.reset(new MouseEvent(ET_MOUSE_PRESSED, origin2, origin2, EventTimeForNow(),
-                          0, 0));
+  ev.reset(new MouseEvent(
+      ET_MOUSE_PRESSED, origin2, origin2, EventTimeForNow(), 0, 0,
+      ui::PointerEventDetails(ui::EventPointerType::POINTER_TYPE_MOUSE)));
   ev->set_time_stamp(start);
   EXPECT_EQ(1, MouseEvent::GetRepeatCount(*ev));
-  ev.reset(new MouseEvent(ET_MOUSE_RELEASED, origin2, origin2,
-                          EventTimeForNow(), 0, 0));
+  ev.reset(new MouseEvent(
+      ET_MOUSE_RELEASED, origin2, origin2, EventTimeForNow(), 0, 0,
+      ui::PointerEventDetails(ui::EventPointerType::POINTER_TYPE_MOUSE)));
   ev->set_time_stamp(start);
   EXPECT_EQ(1, MouseEvent::GetRepeatCount(*ev));
-  ev.reset(new MouseEvent(ET_MOUSE_PRESSED, origin2, origin2, EventTimeForNow(),
-                          0, 0));
+  ev.reset(new MouseEvent(
+      ET_MOUSE_PRESSED, origin2, origin2, EventTimeForNow(), 0, 0,
+      ui::PointerEventDetails(ui::EventPointerType::POINTER_TYPE_MOUSE)));
   ev->set_time_stamp(soon);
   EXPECT_EQ(2, MouseEvent::GetRepeatCount(*ev));
-  ev.reset(new MouseEvent(ET_MOUSE_RELEASED, origin2, origin2,
-                          EventTimeForNow(), 0, 0));
+  ev.reset(new MouseEvent(
+      ET_MOUSE_RELEASED, origin2, origin2, EventTimeForNow(), 0, 0,
+      ui::PointerEventDetails(ui::EventPointerType::POINTER_TYPE_MOUSE)));
   ev->set_time_stamp(soon);
   EXPECT_EQ(2, MouseEvent::GetRepeatCount(*ev));
   MouseEvent::ResetLastClickForTest();
 }
 
 // Tests that clicking right and then left clicking does not generate a double
 // click.
 TEST(EventTest, SingleClickRightLeft) {
   const gfx::Point origin(0, 0);
   scoped_ptr<MouseEvent> ev;
   base::TimeDelta start = base::TimeDelta::FromMilliseconds(0);
   base::TimeDelta soon = start + base::TimeDelta::FromMilliseconds(1);
 
-  ev.reset(new MouseEvent(ET_MOUSE_PRESSED, origin, origin, EventTimeForNow(),
-                          ui::EF_RIGHT_MOUSE_BUTTON,
-                          ui::EF_RIGHT_MOUSE_BUTTON));
+  ev.reset(new MouseEvent(
+      ET_MOUSE_PRESSED, origin, origin, EventTimeForNow(),
+      ui::EF_RIGHT_MOUSE_BUTTON, ui::EF_RIGHT_MOUSE_BUTTON,
+      ui::PointerEventDetails(ui::EventPointerType::POINTER_TYPE_MOUSE)));
   ev->set_time_stamp(start);
   EXPECT_EQ(1, MouseEvent::GetRepeatCount(*ev));
-  ev.reset(new MouseEvent(ET_MOUSE_PRESSED, origin, origin, EventTimeForNow(),
-                          ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON));
+  ev.reset(new MouseEvent(
+      ET_MOUSE_PRESSED, origin, origin, EventTimeForNow(),
+      ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON,
+      ui::PointerEventDetails(ui::EventPointerType::POINTER_TYPE_MOUSE)));
   ev->set_time_stamp(start);
   EXPECT_EQ(1, MouseEvent::GetRepeatCount(*ev));
-  ev.reset(new MouseEvent(ET_MOUSE_RELEASED, origin, origin, EventTimeForNow(),
-                          ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON));
+  ev.reset(new MouseEvent(
+      ET_MOUSE_RELEASED, origin, origin, EventTimeForNow(),
+      ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON,
+      ui::PointerEventDetails(ui::EventPointerType::POINTER_TYPE_MOUSE)));
   ev->set_time_stamp(start);
   EXPECT_EQ(1, MouseEvent::GetRepeatCount(*ev));
-  ev.reset(new MouseEvent(ET_MOUSE_PRESSED, origin, origin, EventTimeForNow(),
-                          ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON));
+  ev.reset(new MouseEvent(
+      ET_MOUSE_PRESSED, origin, origin, EventTimeForNow(),
+      ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON,
+      ui::PointerEventDetails(ui::EventPointerType::POINTER_TYPE_MOUSE)));
   ev->set_time_stamp(soon);
   EXPECT_EQ(2, MouseEvent::GetRepeatCount(*ev));
   MouseEvent::ResetLastClickForTest();
 }
 
 TEST(EventTest, KeyEvent) {
   static const struct {
     KeyboardCode key_code;
     int flags;
     uint16 character;
@@ skipping 355 matching lines @@
   }
 #endif
 }
 #endif  // USE_X11 || OS_WIN
 
 TEST(EventTest, TouchEventRadiusDefaultsToOtherAxis) {
   const base::TimeDelta time = base::TimeDelta::FromMilliseconds(0);
   const float non_zero_length1 = 30;
   const float non_zero_length2 = 46;
 
-  TouchEvent event1(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0), 0, 0, time,
-                    non_zero_length1, 0, 0, 0);
+  TouchEvent event1(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0), 0, 0, time, 0,
+                    PointerEventDetails(EventPointerType::POINTER_TYPE_TOUCH,
+                                        non_zero_length1, 0, 0, 0, 0));
   EXPECT_EQ(non_zero_length1, event1.radius_x());
   EXPECT_EQ(non_zero_length1, event1.radius_y());
 
-  TouchEvent event2(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0), 0, 0, time,
-                    0, non_zero_length2, 0, 0);
+  TouchEvent event2(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0), 0, 0, time, 0,
+                    PointerEventDetails(EventPointerType::POINTER_TYPE_TOUCH, 0,
+                                        non_zero_length2, 0, 0, 0));
   EXPECT_EQ(non_zero_length2, event2.radius_x());
   EXPECT_EQ(non_zero_length2, event2.radius_y());
 }
 
 TEST(EventTest, TouchEventRotationAngleFixing) {
   const base::TimeDelta time = base::TimeDelta::FromMilliseconds(0);
   const float radius_x = 20;
   const float radius_y = 10;
 
   {
     const float angle_in_range = 0;
     TouchEvent event(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0), 0, 0, time,
-                      radius_x, radius_y, angle_in_range, 0);
+                     angle_in_range,
+                     PointerEventDetails(EventPointerType::POINTER_TYPE_TOUCH,
+                                         radius_x, radius_y, 0, 0, 0));
     EXPECT_FLOAT_EQ(angle_in_range, event.rotation_angle());
   }
 
   {
     const float angle_in_range = 179.9f;
     TouchEvent event(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0), 0, 0, time,
-                    radius_x, radius_y, angle_in_range, 0);
+                     angle_in_range,
+                     PointerEventDetails(EventPointerType::POINTER_TYPE_TOUCH,
+                                         radius_x, radius_y, 0, 0, 0));
     EXPECT_FLOAT_EQ(angle_in_range, event.rotation_angle());
   }
 
   {
     const float angle_negative = -0.1f;
     TouchEvent event(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0), 0, 0, time,
-                    radius_x, radius_y, angle_negative, 0);
+                     angle_negative,
+                     PointerEventDetails(EventPointerType::POINTER_TYPE_TOUCH,
+                                         radius_x, radius_y, 0, 0, 0));
     EXPECT_FLOAT_EQ(180 - 0.1f, event.rotation_angle());
   }
 
   {
     const float angle_negative = -200;
     TouchEvent event(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0), 0, 0, time,
-                    radius_x, radius_y, angle_negative, 0);
+                     angle_negative,
+                     PointerEventDetails(EventPointerType::POINTER_TYPE_TOUCH,
+                                         radius_x, radius_y, 0, 0, 0));
     EXPECT_FLOAT_EQ(360 - 200, event.rotation_angle());
   }
 
   {
     const float angle_too_big = 180;
     TouchEvent event(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0), 0, 0, time,
-                    radius_x, radius_y, angle_too_big, 0);
+                     angle_too_big,
+                     PointerEventDetails(EventPointerType::POINTER_TYPE_TOUCH,
+                                         radius_x, radius_y, 0, 0, 0));
     EXPECT_FLOAT_EQ(0, event.rotation_angle());
   }
 
   {
     const float angle_too_big = 400;
     TouchEvent event(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0), 0, 0, time,
-                    radius_x, radius_y, angle_too_big, 0);
+                     angle_too_big,
+                     PointerEventDetails(EventPointerType::POINTER_TYPE_TOUCH,
+                                         radius_x, radius_y, 0, 0, 0));
     EXPECT_FLOAT_EQ(400 - 360, event.rotation_angle());
   }
 }
 
+TEST(EventTest, PointerEventDetailsTouch) {
+  ui::TouchEvent touch_event_plain(
+      ET_TOUCH_PRESSED, gfx::Point(0, 0), 0, 0, ui::EventTimeForNow(), 0.0f,
+      PointerEventDetails(EventPointerType::POINTER_TYPE_TOUCH));
+
+  EXPECT_EQ(EventPointerType::POINTER_TYPE_TOUCH,
+            touch_event_plain.pointer_details().pointer_type());
+  EXPECT_EQ(0.0f, touch_event_plain.pointer_details().radius_x());
+  EXPECT_EQ(0.0f, touch_event_plain.pointer_details().radius_y());
+  EXPECT_EQ(0.0f, touch_event_plain.pointer_details().force());
+  EXPECT_EQ(0.0f, touch_event_plain.pointer_details().tilt_x());
+  EXPECT_EQ(0.0f, touch_event_plain.pointer_details().tilt_y());
+
+  EXPECT_EQ(0.0f, touch_event_plain.radius_x());
+  EXPECT_EQ(0.0f, touch_event_plain.radius_y());
+  EXPECT_EQ(0.0f, touch_event_plain.force());
+
+  ui::TouchEvent touch_event_with_details(
+      ET_TOUCH_PRESSED, gfx::Point(0, 0), 0, 0, ui::EventTimeForNow(), 0.0f,
+      PointerEventDetails(EventPointerType::POINTER_TYPE_TOUCH, 10.0f, 5.0f,
+                          15.0f, 90.0f, -90.0f));
+
+  EXPECT_EQ(EventPointerType::POINTER_TYPE_TOUCH,
+            touch_event_with_details.pointer_details().pointer_type());
+  EXPECT_EQ(10.0f, touch_event_with_details.pointer_details().radius_x());
+  EXPECT_EQ(5.0f, touch_event_with_details.pointer_details().radius_y());
+  EXPECT_EQ(15.0f, touch_event_with_details.pointer_details().force());
+  EXPECT_EQ(90.0f, touch_event_with_details.pointer_details().tilt_x());
+  EXPECT_EQ(-90.0f, touch_event_with_details.pointer_details().tilt_y());
+
+  EXPECT_EQ(10.0f, touch_event_with_details.radius_x());
+  EXPECT_EQ(5.0f, touch_event_with_details.radius_y());
+  EXPECT_EQ(15.0f, touch_event_with_details.force());
+
+  ui::TouchEvent touch_event_copy(touch_event_with_details);
+  EXPECT_EQ(EventPointerType::POINTER_TYPE_TOUCH,
+            touch_event_copy.pointer_details().pointer_type());
+  EXPECT_EQ(10.0f, touch_event_copy.pointer_details().radius_x());
+  EXPECT_EQ(5.0f, touch_event_copy.pointer_details().radius_y());
+  EXPECT_EQ(15.0f, touch_event_copy.pointer_details().force());
+  EXPECT_EQ(90.0f, touch_event_copy.pointer_details().tilt_x());
+  EXPECT_EQ(-90.0f, touch_event_copy.pointer_details().tilt_y());
+}
+
+TEST(EventTest, PointerEventDetailsMouse) {
+  ui::MouseEvent mouse_event(
+      ET_MOUSE_PRESSED, gfx::PointF(0, 0), gfx::PointF(0, 0),
+      ui::EventTimeForNow(), 0, 0,
+      PointerEventDetails(EventPointerType::POINTER_TYPE_MOUSE));
+
+  EXPECT_EQ(EventPointerType::POINTER_TYPE_MOUSE,
+            mouse_event.pointer_details().pointer_type());
+  EXPECT_EQ(0.0f, mouse_event.pointer_details().radius_x());
+  EXPECT_EQ(0.0f, mouse_event.pointer_details().radius_y());
+  EXPECT_EQ(0.0f, mouse_event.pointer_details().force());
+  EXPECT_EQ(0.0f, mouse_event.pointer_details().tilt_x());
+  EXPECT_EQ(0.0f, mouse_event.pointer_details().tilt_y());
+
+  ui::MouseEvent mouse_event_copy(mouse_event);
+  EXPECT_EQ(EventPointerType::POINTER_TYPE_MOUSE,
+            mouse_event_copy.pointer_details().pointer_type());
+  EXPECT_EQ(0.0f, mouse_event_copy.pointer_details().radius_x());
+  EXPECT_EQ(0.0f, mouse_event_copy.pointer_details().radius_y());
+  EXPECT_EQ(0.0f, mouse_event_copy.pointer_details().force());
+  EXPECT_EQ(0.0f, mouse_event_copy.pointer_details().tilt_x());
+  EXPECT_EQ(0.0f, mouse_event_copy.pointer_details().tilt_y());
+}
+
+TEST(EventTest, PointerEventDetailsStylus) {
+  ui::MouseEvent stylus_event(
+      ET_MOUSE_PRESSED, gfx::PointF(0, 0), gfx::PointF(0, 0),
+      ui::EventTimeForNow(), 0, 0,
+      PointerEventDetails(EventPointerType::POINTER_TYPE_PEN, 5.0f, 5.0f, 10.0f,
+                          -90.0f, 90.0f));
+
+  EXPECT_EQ(EventPointerType::POINTER_TYPE_PEN,
+            stylus_event.pointer_details().pointer_type());
+  EXPECT_EQ(5.0f, stylus_event.pointer_details().radius_x());
+  EXPECT_EQ(5.0f, stylus_event.pointer_details().radius_y());
+  EXPECT_EQ(10.0f, stylus_event.pointer_details().force());
+  EXPECT_EQ(-90.0f, stylus_event.pointer_details().tilt_x());
+  EXPECT_EQ(90.0f, stylus_event.pointer_details().tilt_y());
+
+  ui::MouseEvent stylus_event_copy(stylus_event);
+  EXPECT_EQ(EventPointerType::POINTER_TYPE_PEN,
+            stylus_event_copy.pointer_details().pointer_type());
+  EXPECT_EQ(5.0f, stylus_event_copy.pointer_details().radius_x());
+  EXPECT_EQ(5.0f, stylus_event_copy.pointer_details().radius_y());
+  EXPECT_EQ(10.0f, stylus_event_copy.pointer_details().force());
+  EXPECT_EQ(-90.0f, stylus_event_copy.pointer_details().tilt_x());
+  EXPECT_EQ(90.0f, stylus_event_copy.pointer_details().tilt_y());
+}
+
 }  // namespace ui