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

ui/events/event_dispatcher_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 "ui/events/event_dispatcher.h"
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/events/event.h"
 #include "ui/events/event_dispatcher.h"
 #include "ui/events/event_target.h"
@@ skipping 218 matching lines @@
   child.AddPostTargetHandler(&h6);
 
   parent.AddPostTargetHandler(&h7);
   parent.AddPostTargetHandler(&h8);
 
   h5.set_expect_post_target(true);
   h6.set_expect_post_target(true);
   h7.set_expect_post_target(true);
   h8.set_expect_post_target(true);
 
-  MouseEvent mouse(ui::ET_MOUSE_MOVED, gfx::Point(3, 4), gfx::Point(3, 4),
-                   ui::EventTimeForNow(), 0, 0);
+  MouseEvent mouse(
+      ui::ET_MOUSE_MOVED, gfx::Point(3, 4), gfx::Point(3, 4),
+      ui::EventTimeForNow(), 0, 0,
+      ui::PointerEventDetails(ui::EventPointerType::POINTER_TYPE_MOUSE));
   Event::DispatcherApi event_mod(&mouse);
   dispatcher.ProcessEvent(&child, &mouse);
   EXPECT_FALSE(mouse.stopped_propagation());
   EXPECT_FALSE(mouse.handled());
 
   {
     int expected[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
     EXPECT_EQ(
         std::vector<int>(expected, expected + sizeof(expected) / sizeof(int)),
         child.handler_list());
@@ skipping 52 matching lines @@
   TestEventDispatcher dispatcher;
   TestTarget target;
 
   TestEventHandler handler(11);
 
   target.AddPreTargetHandler(&handler);
   target.AddPostTargetHandler(&handler);
   handler.set_expect_pre_target(true);
   handler.set_expect_post_target(true);
 
-  MouseEvent mouse(ui::ET_MOUSE_MOVED, gfx::Point(3, 4), gfx::Point(3, 4),
-                   ui::EventTimeForNow(), 0, 0);
+  MouseEvent mouse(
+      ui::ET_MOUSE_MOVED, gfx::Point(3, 4), gfx::Point(3, 4),
+      ui::EventTimeForNow(), 0, 0,
+      ui::PointerEventDetails(ui::EventPointerType::POINTER_TYPE_MOUSE));
   Event::DispatcherApi event_mod(&mouse);
   dispatcher.ProcessEvent(&target, &mouse);
   EXPECT_EQ(ER_UNHANDLED, mouse.result());
 
   int handlers[] = { 11, 11 };
   EXPECT_EQ(
       std::vector<int>(handlers, handlers + sizeof(handlers) / sizeof(int)),
       target.handler_list());
 }
 
@@ skipping 10 matching lines @@
     target.AddPreTargetHandler(&h1);
     target.AddPreTargetHandler(&handler);
     target.AddPreTargetHandler(&h2);
 
     h1.set_expect_pre_target(true);
     handler.set_expect_pre_target(true);
     // |h2| should not receive any events at all since |handler| will have
     // destroyed the dispatcher.
     h2.set_expect_pre_target(false);
 
-    MouseEvent mouse(ui::ET_MOUSE_MOVED, gfx::Point(3, 4), gfx::Point(3, 4),
-                     ui::EventTimeForNow(), 0, 0);
+    MouseEvent mouse(
+        ui::ET_MOUSE_MOVED, gfx::Point(3, 4), gfx::Point(3, 4),
+        ui::EventTimeForNow(), 0, 0,
+        ui::PointerEventDetails(ui::EventPointerType::POINTER_TYPE_MOUSE));
     EventDispatchDetails details = dispatcher->ProcessEvent(&target, &mouse);
     EXPECT_TRUE(details.dispatcher_destroyed);
     EXPECT_EQ(ER_CONSUMED, mouse.result());
     EXPECT_EQ(2U, target.handler_list().size());
     EXPECT_EQ(1, target.handler_list()[0]);
     EXPECT_EQ(5, target.handler_list()[1]);
   }
 
   // Test for non-cancelable event.
   {
@@ skipping 30 matching lines @@
     target.AddPostTargetHandler(&h1);
     target.AddPostTargetHandler(&handler);
     target.AddPostTargetHandler(&h2);
 
     h1.set_expect_post_target(true);
     handler.set_expect_post_target(true);
     // |h2| should not receive any events at all since |handler| will have
     // destroyed the dispatcher.
     h2.set_expect_post_target(false);
 
-    MouseEvent mouse(ui::ET_MOUSE_MOVED, gfx::Point(3, 4), gfx::Point(3, 4),
-                     ui::EventTimeForNow(), 0, 0);
+    MouseEvent mouse(
+        ui::ET_MOUSE_MOVED, gfx::Point(3, 4), gfx::Point(3, 4),
+        ui::EventTimeForNow(), 0, 0,
+        ui::PointerEventDetails(ui::EventPointerType::POINTER_TYPE_MOUSE));
     EventDispatchDetails details = dispatcher->ProcessEvent(&target, &mouse);
     EXPECT_TRUE(details.dispatcher_destroyed);
     EXPECT_EQ(ER_CONSUMED, mouse.result());
     EXPECT_EQ(2U, target.handler_list().size());
     EXPECT_EQ(1, target.handler_list()[0]);
     EXPECT_EQ(5, target.handler_list()[1]);
   }
 
   // Test for non-cancelable event.
   {
@@ skipping 32 matching lines @@
 
   target.AddPreTargetHandler(&h1);
   target.AddPreTargetHandler(&invalidate_handler);
   target.AddPreTargetHandler(&h3);
 
   h1.set_expect_pre_target(true);
   invalidate_handler.set_expect_pre_target(true);
   // |h3| should not receive events as the target will be invalidated.
   h3.set_expect_pre_target(false);
 
-  MouseEvent mouse(ui::ET_MOUSE_MOVED, gfx::Point(3, 4), gfx::Point(3, 4),
-                   ui::EventTimeForNow(), 0, 0);
+  MouseEvent mouse(
+      ui::ET_MOUSE_MOVED, gfx::Point(3, 4), gfx::Point(3, 4),
+      ui::EventTimeForNow(), 0, 0,
+      ui::PointerEventDetails(ui::EventPointerType::POINTER_TYPE_MOUSE));
   EventDispatchDetails details = dispatcher.ProcessEvent(&target, &mouse);
   EXPECT_FALSE(details.dispatcher_destroyed);
   EXPECT_TRUE(details.target_destroyed);
   EXPECT_FALSE(target.valid());
   EXPECT_TRUE(mouse.stopped_propagation());
   EXPECT_EQ(2U, target.handler_list().size());
   EXPECT_EQ(1, target.handler_list()[0]);
   EXPECT_EQ(2, target.handler_list()[1]);
 
   // Test for non-cancelable event.
@@ skipping 21 matching lines @@
     target.AddPreTargetHandler(&h1);
     target.AddPreTargetHandler(&handle_destroyer);
     target.AddPreTargetHandler(h3);
 
     h1.set_expect_pre_target(true);
     handle_destroyer.set_expect_pre_target(true);
     // |h3| should not receive events since |handle_destroyer| will have
     // destroyed it.
     h3->set_expect_pre_target(false);
 
-    MouseEvent mouse(ui::ET_MOUSE_MOVED, gfx::Point(3, 4), gfx::Point(3, 4),
-                     ui::EventTimeForNow(), 0, 0);
+    MouseEvent mouse(
+        ui::ET_MOUSE_MOVED, gfx::Point(3, 4), gfx::Point(3, 4),
+        ui::EventTimeForNow(), 0, 0,
+        ui::PointerEventDetails(ui::EventPointerType::POINTER_TYPE_MOUSE));
     EventDispatchDetails details = dispatcher.ProcessEvent(&target, &mouse);
     EXPECT_FALSE(details.dispatcher_destroyed);
     EXPECT_FALSE(details.target_destroyed);
     EXPECT_FALSE(mouse.stopped_propagation());
     EXPECT_EQ(2U, target.handler_list().size());
     EXPECT_EQ(1, target.handler_list()[0]);
     EXPECT_EQ(2, target.handler_list()[1]);
   }
 
   // Test for non-cancelable events.
@@ skipping 36 matching lines @@
     target.AddPreTargetHandler(&destroyer);
     target.AddPreTargetHandler(h3);
 
     h1.set_expect_pre_target(true);
     destroyer.set_expect_pre_target(true);
     destroyer.set_dispatcher_delegate(dispatcher);
     // |h3| should not receive events since |destroyer| will have destroyed
     // it.
     h3->set_expect_pre_target(false);
 
-    MouseEvent mouse(ui::ET_MOUSE_MOVED, gfx::Point(3, 4), gfx::Point(3, 4),
-                     ui::EventTimeForNow(), 0, 0);
+    MouseEvent mouse(
+        ui::ET_MOUSE_MOVED, gfx::Point(3, 4), gfx::Point(3, 4),
+        ui::EventTimeForNow(), 0, 0,
+        ui::PointerEventDetails(ui::EventPointerType::POINTER_TYPE_MOUSE));
     EventDispatchDetails details = dispatcher->ProcessEvent(&target, &mouse);
     EXPECT_TRUE(details.dispatcher_destroyed);
     EXPECT_TRUE(mouse.stopped_propagation());
     EXPECT_EQ(2U, target.handler_list().size());
     EXPECT_EQ(1, target.handler_list()[0]);
     EXPECT_EQ(2, target.handler_list()[1]);
   }
 
   // Test for non-cancelable events.
   {
@@ skipping 17 matching lines @@
     NonCancelableEvent event;
     EventDispatchDetails details = dispatcher->ProcessEvent(&target, &event);
     EXPECT_TRUE(details.dispatcher_destroyed);
     EXPECT_EQ(2U, target.handler_list().size());
     EXPECT_EQ(1, target.handler_list()[0]);
     EXPECT_EQ(2, target.handler_list()[1]);
   }
 }
 
 }  // namespace ui