| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2016 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "components/mus/common/event_param_traits.h" | |
| 6 | |
| 7 #include <limits> | |
| 8 | |
| 9 #include "ipc/ipc_message.h" | |
| 10 #include "ipc/ipc_param_traits.h" | |
| 11 #include "testing/gtest/include/gtest/gtest.h" | |
| 12 #include "ui/events/event.h" | |
| 13 #include "ui/events/event_constants.h" | |
| 14 #include "ui/gfx/geometry/point.h" | |
| 15 #include "ui/gfx/geometry/rect_f.h" | |
| 16 #include "ui/gfx/geometry/vector2d.h" | |
| 17 | |
| 18 namespace ui { | |
| 19 namespace { | |
| 20 | |
| 21 #define CAST_EVENT(T, e) (*static_cast<const T*>(e.get())) | |
| 22 #define FEQ(a, b) (a == b || (std::isnan(a) && std::isnan(b))) | |
| 23 #define ASSERT_FEQ(a, b) ASSERT_TRUE(FEQ(a, b)) | |
| 24 #define MIN(T) std::numeric_limits<T>::min() | |
| 25 #define MAX(T) std::numeric_limits<T>::max() | |
| 26 #define IMIN MIN(int) | |
| 27 #define IMAX MAX(int) | |
| 28 #define FMIN MIN(float) | |
| 29 #define FMAX MAX(float) | |
| 30 #define FNAN std::numeric_limits<float>::quiet_NaN() | |
| 31 | |
| 32 class EventParamTraitsTest : public testing::Test { | |
| 33 protected: | |
| 34 // Implements event downcasting as performed by param traits. This enables | |
| 35 // testing the interface that client code actually uses: (de)serialization of | |
| 36 // scoped Event pointers that contain a concrete type. | |
| 37 static void CompareEvents(const ScopedEvent& a, const ScopedEvent& b) { | |
| 38 ASSERT_EQ(!!a, !!b); | |
| 39 ASSERT_EQ(a->type(), b->type()); | |
| 40 switch (a->type()) { | |
| 41 case EventType::ET_MOUSE_PRESSED: | |
| 42 case EventType::ET_MOUSE_DRAGGED: | |
| 43 case EventType::ET_MOUSE_RELEASED: | |
| 44 case EventType::ET_MOUSE_MOVED: | |
| 45 case EventType::ET_MOUSE_ENTERED: | |
| 46 case EventType::ET_MOUSE_EXITED: | |
| 47 case EventType::ET_MOUSE_CAPTURE_CHANGED: | |
| 48 Compare(CAST_EVENT(MouseEvent, a), CAST_EVENT(MouseEvent, b)); | |
| 49 break; | |
| 50 case EventType::ET_KEY_PRESSED: | |
| 51 case EventType::ET_KEY_RELEASED: | |
| 52 Compare(CAST_EVENT(KeyEvent, a), CAST_EVENT(KeyEvent, b)); | |
| 53 break; | |
| 54 case EventType::ET_MOUSEWHEEL: | |
| 55 Compare(CAST_EVENT(MouseWheelEvent, a), CAST_EVENT(MouseWheelEvent, b)); | |
| 56 break; | |
| 57 case EventType::ET_TOUCH_RELEASED: | |
| 58 case EventType::ET_TOUCH_PRESSED: | |
| 59 case EventType::ET_TOUCH_MOVED: | |
| 60 case EventType::ET_TOUCH_CANCELLED: | |
| 61 case EventType::ET_DROP_TARGET_EVENT: | |
| 62 Compare(CAST_EVENT(TouchEvent, a), CAST_EVENT(TouchEvent, b)); | |
| 63 break; | |
| 64 case EventType::ET_POINTER_DOWN: | |
| 65 case EventType::ET_POINTER_MOVED: | |
| 66 case EventType::ET_POINTER_UP: | |
| 67 case EventType::ET_POINTER_CANCELLED: | |
| 68 case EventType::ET_POINTER_ENTERED: | |
| 69 case EventType::ET_POINTER_EXITED: | |
| 70 Compare(CAST_EVENT(PointerEvent, a), CAST_EVENT(PointerEvent, b)); | |
| 71 break; | |
| 72 case EventType::ET_GESTURE_SCROLL_BEGIN: | |
| 73 case EventType::ET_GESTURE_SCROLL_END: | |
| 74 case EventType::ET_GESTURE_SCROLL_UPDATE: | |
| 75 case EventType::ET_GESTURE_SHOW_PRESS: | |
| 76 case EventType::ET_GESTURE_WIN8_EDGE_SWIPE: | |
| 77 case EventType::ET_GESTURE_TAP: | |
| 78 case EventType::ET_GESTURE_TAP_DOWN: | |
| 79 case EventType::ET_GESTURE_TAP_CANCEL: | |
| 80 case EventType::ET_GESTURE_BEGIN: | |
| 81 case EventType::ET_GESTURE_END: | |
| 82 case EventType::ET_GESTURE_TWO_FINGER_TAP: | |
| 83 case EventType::ET_GESTURE_PINCH_BEGIN: | |
| 84 case EventType::ET_GESTURE_PINCH_END: | |
| 85 case EventType::ET_GESTURE_PINCH_UPDATE: | |
| 86 case EventType::ET_GESTURE_LONG_PRESS: | |
| 87 case EventType::ET_GESTURE_LONG_TAP: | |
| 88 case EventType::ET_GESTURE_SWIPE: | |
| 89 case EventType::ET_GESTURE_TAP_UNCONFIRMED: | |
| 90 case EventType::ET_GESTURE_DOUBLE_TAP: | |
| 91 Compare(CAST_EVENT(GestureEvent, a), CAST_EVENT(GestureEvent, b)); | |
| 92 break; | |
| 93 case EventType::ET_SCROLL: | |
| 94 Compare(CAST_EVENT(ScrollEvent, a), CAST_EVENT(ScrollEvent, b)); | |
| 95 break; | |
| 96 case EventType::ET_SCROLL_FLING_START: | |
| 97 case EventType::ET_SCROLL_FLING_CANCEL: | |
| 98 ASSERT_EQ(a->flags() & MouseEventFlags::EF_FROM_TOUCH, | |
| 99 b->flags() & MouseEventFlags::EF_FROM_TOUCH); | |
| 100 if (a->flags() & MouseEventFlags::EF_FROM_TOUCH) { | |
| 101 Compare(CAST_EVENT(GestureEvent, a), CAST_EVENT(GestureEvent, b)); | |
| 102 } else { | |
| 103 Compare(CAST_EVENT(MouseEvent, a), CAST_EVENT(MouseEvent, b)); | |
| 104 } | |
| 105 break; | |
| 106 case EventType::ET_CANCEL_MODE: | |
| 107 Compare(CAST_EVENT(CancelModeEvent, a), CAST_EVENT(CancelModeEvent, b)); | |
| 108 break; | |
| 109 default: | |
| 110 NOTREACHED(); | |
| 111 } | |
| 112 } | |
| 113 | |
| 114 #undef CAST_EVENT | |
| 115 | |
| 116 #define CAST_EVENT(T, e) static_cast<const T&>(e) | |
| 117 #define COMPARE_BASE(T, a, b) Compare(CAST_EVENT(T, a), CAST_EVENT(T, b)) | |
| 118 | |
| 119 static void Compare(const Event& a, const Event& b) { | |
| 120 ASSERT_EQ(a.type(), b.type()); | |
| 121 ASSERT_EQ(a.name(), b.name()); | |
| 122 ASSERT_EQ(a.time_stamp(), b.time_stamp()); | |
| 123 ASSERT_EQ(a.flags(), b.flags()); | |
| 124 ASSERT_EQ(a.phase(), b.phase()); | |
| 125 ASSERT_EQ(a.result(), b.result()); | |
| 126 ASSERT_EQ(a.cancelable(), b.cancelable()); | |
| 127 ASSERT_EQ(a.IsShiftDown(), b.IsShiftDown()); | |
| 128 ASSERT_EQ(a.IsControlDown(), b.IsControlDown()); | |
| 129 ASSERT_EQ(a.IsAltDown(), b.IsAltDown()); | |
| 130 ASSERT_EQ(a.IsCommandDown(), b.IsCommandDown()); | |
| 131 ASSERT_EQ(a.IsAltGrDown(), b.IsAltGrDown()); | |
| 132 ASSERT_EQ(a.IsCapsLockOn(), b.IsCapsLockOn()); | |
| 133 ASSERT_EQ(a.IsKeyEvent(), b.IsKeyEvent()); | |
| 134 ASSERT_EQ(a.IsMouseEvent(), b.IsMouseEvent()); | |
| 135 ASSERT_EQ(a.IsTouchEvent(), b.IsTouchEvent()); | |
| 136 ASSERT_EQ(a.IsGestureEvent(), b.IsGestureEvent()); | |
| 137 ASSERT_EQ(a.IsEndingEvent(), b.IsEndingEvent()); | |
| 138 ASSERT_EQ(a.IsScrollEvent(), b.IsScrollEvent()); | |
| 139 ASSERT_EQ(a.IsScrollGestureEvent(), b.IsScrollGestureEvent()); | |
| 140 ASSERT_EQ(a.IsFlingScrollEvent(), b.IsFlingScrollEvent()); | |
| 141 ASSERT_EQ(a.IsMouseWheelEvent(), b.IsMouseWheelEvent()); | |
| 142 ASSERT_EQ(a.IsLocatedEvent(), b.IsLocatedEvent()); | |
| 143 ASSERT_EQ(a.handled(), b.handled()); | |
| 144 } | |
| 145 | |
| 146 static void Compare(const CancelModeEvent& a, const CancelModeEvent& b) { | |
| 147 COMPARE_BASE(Event, a, b); | |
| 148 } | |
| 149 | |
| 150 static void Compare(const LocatedEvent& a, const LocatedEvent& b) { | |
| 151 COMPARE_BASE(Event, a, b); | |
| 152 | |
| 153 ASSERT_EQ(a.x(), b.x()); | |
| 154 ASSERT_EQ(a.y(), b.y()); | |
| 155 ASSERT_EQ(a.location(), b.location()); | |
| 156 ASSERT_EQ(a.location_f(), b.location_f()); | |
| 157 ASSERT_EQ(a.root_location(), b.root_location()); | |
| 158 ASSERT_EQ(a.root_location_f(), b.root_location_f()); | |
| 159 } | |
| 160 | |
| 161 static void Compare(const MouseEvent& a, const MouseEvent& b) { | |
| 162 COMPARE_BASE(LocatedEvent, a, b); | |
| 163 | |
| 164 ASSERT_EQ(a.IsOnlyLeftMouseButton(), b.IsOnlyLeftMouseButton()); | |
| 165 ASSERT_EQ(a.IsLeftMouseButton(), b.IsLeftMouseButton()); | |
| 166 ASSERT_EQ(a.IsOnlyMiddleMouseButton(), b.IsOnlyMiddleMouseButton()); | |
| 167 ASSERT_EQ(a.IsMiddleMouseButton(), b.IsMiddleMouseButton()); | |
| 168 ASSERT_EQ(a.IsOnlyRightMouseButton(), b.IsOnlyRightMouseButton()); | |
| 169 ASSERT_EQ(a.IsRightMouseButton(), b.IsRightMouseButton()); | |
| 170 ASSERT_EQ(a.IsAnyButton(), b.IsAnyButton()); | |
| 171 ASSERT_EQ(a.button_flags(), b.button_flags()); | |
| 172 ASSERT_EQ(a.GetClickCount(), b.GetClickCount()); | |
| 173 ASSERT_EQ(a.changed_button_flags(), b.changed_button_flags()); | |
| 174 | |
| 175 Compare(a.pointer_details(), b.pointer_details()); | |
| 176 } | |
| 177 | |
| 178 static void Compare(const MouseWheelEvent& a, const MouseWheelEvent& b) { | |
| 179 COMPARE_BASE(MouseEvent, a, b); | |
| 180 | |
| 181 ASSERT_EQ(a.x_offset(), b.x_offset()); | |
| 182 ASSERT_EQ(a.y_offset(), b.y_offset()); | |
| 183 ASSERT_EQ(a.offset(), b.offset()); | |
| 184 } | |
| 185 | |
| 186 static void Compare(const TouchEvent& a, const TouchEvent& b) { | |
| 187 COMPARE_BASE(LocatedEvent, a, b); | |
| 188 | |
| 189 ASSERT_EQ(a.touch_id(), b.touch_id()); | |
| 190 ASSERT_EQ(a.unique_event_id(), b.unique_event_id()); | |
| 191 ASSERT_FEQ(a.rotation_angle(), b.rotation_angle()); | |
| 192 ASSERT_EQ(a.may_cause_scrolling(), b.may_cause_scrolling()); | |
| 193 ASSERT_EQ(a.synchronous_handling_disabled(), | |
| 194 b.synchronous_handling_disabled()); | |
| 195 | |
| 196 Compare(a.pointer_details(), b.pointer_details()); | |
| 197 } | |
| 198 | |
| 199 static void Compare(const KeyEvent& a, const KeyEvent& b) { | |
| 200 COMPARE_BASE(Event, a, b); | |
| 201 | |
| 202 ASSERT_EQ(a.GetCharacter(), b.GetCharacter()); | |
| 203 ASSERT_EQ(a.GetUnmodifiedText(), b.GetUnmodifiedText()); | |
| 204 ASSERT_EQ(a.GetText(), b.GetText()); | |
| 205 ASSERT_EQ(a.is_char(), b.is_char()); | |
| 206 ASSERT_EQ(a.is_repeat(), b.is_repeat()); | |
| 207 ASSERT_EQ(a.key_code(), b.key_code()); | |
| 208 ASSERT_EQ(a.GetLocatedWindowsKeyboardCode(), | |
| 209 b.GetLocatedWindowsKeyboardCode()); | |
| 210 ASSERT_EQ(a.GetConflatedWindowsKeyCode(), b.GetConflatedWindowsKeyCode()); | |
| 211 ASSERT_EQ(a.IsUnicodeKeyCode(), b.IsUnicodeKeyCode()); | |
| 212 ASSERT_EQ(a.code(), b.code()); | |
| 213 ASSERT_EQ(a.GetCodeString(), b.GetCodeString()); | |
| 214 ASSERT_EQ(a.GetDomKey(), b.GetDomKey()); | |
| 215 } | |
| 216 | |
| 217 static void Compare(const ScrollEvent& a, const ScrollEvent& b) { | |
| 218 COMPARE_BASE(MouseEvent, a, b); | |
| 219 | |
| 220 ASSERT_FEQ(a.x_offset(), b.x_offset()); | |
| 221 ASSERT_FEQ(a.y_offset(), b.y_offset()); | |
| 222 ASSERT_FEQ(a.x_offset_ordinal(), b.x_offset_ordinal()); | |
| 223 ASSERT_FEQ(a.y_offset_ordinal(), b.y_offset_ordinal()); | |
| 224 ASSERT_EQ(a.finger_count(), b.finger_count()); | |
| 225 } | |
| 226 | |
| 227 static void Compare(const GestureEvent& a, const GestureEvent& b) { | |
| 228 COMPARE_BASE(LocatedEvent, a, b); | |
| 229 | |
| 230 ASSERT_EQ(a.details(), b.details()); | |
| 231 } | |
| 232 | |
| 233 static void Compare(const PointerDetails& a, const PointerDetails& b) { | |
| 234 ASSERT_EQ(a.pointer_type, b.pointer_type); | |
| 235 ASSERT_FEQ(a.radius_x, b.radius_x); | |
| 236 ASSERT_FEQ(a.radius_y, b.radius_y); | |
| 237 ASSERT_FEQ(a.force, b.force); | |
| 238 ASSERT_FEQ(a.tilt_x, b.tilt_x); | |
| 239 ASSERT_FEQ(a.tilt_y, b.tilt_y); | |
| 240 } | |
| 241 | |
| 242 static void Verify(const ScopedEvent& event_in) { | |
| 243 IPC::Message msg; | |
| 244 IPC::ParamTraits<ScopedEvent>::Write(&msg, event_in); | |
| 245 | |
| 246 ScopedEvent event_out; | |
| 247 base::PickleIterator iter(msg); | |
| 248 EXPECT_TRUE(IPC::ParamTraits<ScopedEvent>::Read(&msg, &iter, &event_out)); | |
| 249 | |
| 250 CompareEvents(event_in, event_out); | |
| 251 | |
| 252 // Perform a sanity check that logging doesn't explode. | |
| 253 std::string event_in_string; | |
| 254 IPC::ParamTraits<ScopedEvent>::Log(event_in, &event_in_string); | |
| 255 std::string event_out_string; | |
| 256 IPC::ParamTraits<ScopedEvent>::Log(event_out, &event_out_string); | |
| 257 ASSERT_FALSE(event_in_string.empty()); | |
| 258 EXPECT_EQ(event_in_string, event_out_string); | |
| 259 } | |
| 260 | |
| 261 static GestureEventDetails CreateCornerCaseGestureEventDetails( | |
| 262 EventType type) { | |
| 263 GestureEventDetails details; | |
| 264 | |
| 265 // Only some types support |delta_x| and |delta_y| parameters. | |
| 266 if (type == EventType::ET_GESTURE_SCROLL_BEGIN || | |
| 267 type == EventType::ET_GESTURE_SCROLL_UPDATE || | |
| 268 type == EventType::ET_SCROLL_FLING_START || | |
| 269 type == EventType::ET_GESTURE_TWO_FINGER_TAP || | |
| 270 type == EventType::ET_GESTURE_SWIPE) { | |
| 271 details = GestureEventDetails(type, FMIN, FMAX); | |
| 272 } else { | |
| 273 details = GestureEventDetails(type); | |
| 274 } | |
| 275 | |
| 276 details.set_bounding_box(gfx::RectF(FMIN, FMAX, FNAN, FNAN)); | |
| 277 | |
| 278 // Note: Positive values and |type| check dodges DCHECKs that are not being | |
| 279 // tested here. | |
| 280 details.set_touch_points(IMAX); | |
| 281 if (type == EventType::ET_GESTURE_TAP || | |
| 282 type == EventType::ET_GESTURE_TAP_UNCONFIRMED || | |
| 283 type == EventType::ET_GESTURE_DOUBLE_TAP) { | |
| 284 details.set_tap_count(IMAX); | |
| 285 } | |
| 286 if (type == EventType::ET_GESTURE_PINCH_UPDATE) { | |
| 287 details.set_scale(FMAX); | |
| 288 } | |
| 289 | |
| 290 return details; | |
| 291 } | |
| 292 }; | |
| 293 | |
| 294 TEST_F(EventParamTraitsTest, GoodCancelModeEvent) { | |
| 295 ScopedEvent event(new CancelModeEvent()); | |
| 296 Verify(event); | |
| 297 } | |
| 298 | |
| 299 TEST_F(EventParamTraitsTest, GoodSimpleMouseEvent) { | |
| 300 EventType event_types[7] = { | |
| 301 EventType::ET_MOUSE_PRESSED, EventType::ET_MOUSE_DRAGGED, | |
| 302 EventType::ET_MOUSE_RELEASED, EventType::ET_MOUSE_MOVED, | |
| 303 EventType::ET_MOUSE_ENTERED, EventType::ET_MOUSE_EXITED, | |
| 304 EventType::ET_MOUSE_CAPTURE_CHANGED, | |
| 305 }; | |
| 306 for (int i = 0; i < 7; i++) { | |
| 307 ScopedEvent event(new MouseEvent(event_types[i], gfx::Point(), gfx::Point(), | |
| 308 base::TimeDelta(), 0, 0)); | |
| 309 Verify(event); | |
| 310 } | |
| 311 } | |
| 312 | |
| 313 TEST_F(EventParamTraitsTest, GoodCornerCaseMouseEvent) { | |
| 314 EventType event_types[7] = { | |
| 315 EventType::ET_MOUSE_PRESSED, EventType::ET_MOUSE_DRAGGED, | |
| 316 EventType::ET_MOUSE_RELEASED, EventType::ET_MOUSE_MOVED, | |
| 317 EventType::ET_MOUSE_ENTERED, EventType::ET_MOUSE_EXITED, | |
| 318 EventType::ET_MOUSE_CAPTURE_CHANGED, | |
| 319 }; | |
| 320 for (int i = 0; i < 7; i++) { | |
| 321 ScopedEvent event(new MouseEvent(event_types[i], gfx::Point(IMIN, IMIN), | |
| 322 gfx::Point(IMAX, IMAX), | |
| 323 base::TimeDelta::Max(), IMIN, IMAX)); | |
| 324 Verify(event); | |
| 325 } | |
| 326 } | |
| 327 | |
| 328 TEST_F(EventParamTraitsTest, GoodSimpleMouseWheelEvent) { | |
| 329 ScopedEvent event(new MouseWheelEvent(gfx::Vector2d(), gfx::Point(), | |
| 330 gfx::Point(), base::TimeDelta(), 0, 0)); | |
| 331 Verify(event); | |
| 332 } | |
| 333 | |
| 334 TEST_F(EventParamTraitsTest, GoodCornerCaseMouseWheelEvent) { | |
| 335 ScopedEvent event(new MouseWheelEvent( | |
| 336 gfx::Vector2d(IMIN, IMAX), gfx::Point(IMIN, IMIN), gfx::Point(IMAX, IMAX), | |
| 337 base::TimeDelta::Max(), IMIN, IMAX)); | |
| 338 Verify(event); | |
| 339 } | |
| 340 | |
| 341 TEST_F(EventParamTraitsTest, GoodSimpleTouchEvent) { | |
| 342 EventType event_types[5] = { | |
| 343 EventType::ET_TOUCH_RELEASED, EventType::ET_TOUCH_PRESSED, | |
| 344 EventType::ET_TOUCH_MOVED, EventType::ET_TOUCH_CANCELLED, | |
| 345 EventType::ET_DROP_TARGET_EVENT, | |
| 346 }; | |
| 347 for (int i = 0; i < 5; i++) { | |
| 348 ScopedEvent event(new TouchEvent(event_types[i], gfx::Point(), 0, 0, | |
| 349 base::TimeDelta(), 0.0, 0.0, 0.0, 0.0)); | |
| 350 Verify(event); | |
| 351 } | |
| 352 } | |
| 353 | |
| 354 TEST_F(EventParamTraitsTest, GoodCornerCaseTouchEvent) { | |
| 355 EventType event_types[5] = { | |
| 356 EventType::ET_TOUCH_RELEASED, EventType::ET_TOUCH_PRESSED, | |
| 357 EventType::ET_TOUCH_MOVED, EventType::ET_TOUCH_CANCELLED, | |
| 358 EventType::ET_DROP_TARGET_EVENT, | |
| 359 }; | |
| 360 for (int i = 0; i < 5; i++) { | |
| 361 ScopedEvent event(new TouchEvent(event_types[i], gfx::Point(IMIN, IMAX), | |
| 362 IMIN, IMAX, base::TimeDelta::Max(), FMIN, | |
| 363 FMAX, FNAN, FNAN)); | |
| 364 Verify(event); | |
| 365 } | |
| 366 } | |
| 367 | |
| 368 TEST_F(EventParamTraitsTest, GoodSimpleKeyEvent) { | |
| 369 EventType event_types[2] = { | |
| 370 EventType::ET_KEY_PRESSED, EventType::ET_KEY_RELEASED, | |
| 371 }; | |
| 372 for (int i = 0; i < 2; i++) { | |
| 373 ScopedEvent event(new KeyEvent(event_types[i], KeyboardCode::VKEY_UNKNOWN, | |
| 374 static_cast<DomCode>(0), 0, DomKey(0), | |
| 375 base::TimeDelta())); | |
| 376 Verify(event); | |
| 377 } | |
| 378 } | |
| 379 | |
| 380 TEST_F(EventParamTraitsTest, GoodCornerCaseKeyEvent) { | |
| 381 EventType event_types[2] = { | |
| 382 EventType::ET_KEY_PRESSED, EventType::ET_KEY_RELEASED, | |
| 383 }; | |
| 384 for (int i = 0; i < 2; i++) { | |
| 385 ScopedEvent event(new KeyEvent(event_types[i], KeyboardCode::VKEY_OEM_CLEAR, | |
| 386 static_cast<DomCode>(0x0c028c), IMIN, | |
| 387 MIN(DomKey), base::TimeDelta::Max())); | |
| 388 Verify(event); | |
| 389 } | |
| 390 } | |
| 391 | |
| 392 TEST_F(EventParamTraitsTest, GoodSimpleScrollEvent) { | |
| 393 ScopedEvent event(new ScrollEvent(EventType::ET_SCROLL, gfx::Point(), | |
| 394 base::TimeDelta(), 0, 0.0, 0.0, 0.0, 0.0, | |
| 395 0)); | |
| 396 Verify(event); | |
| 397 } | |
| 398 | |
| 399 TEST_F(EventParamTraitsTest, GoodCornerCaseScrollEvent) { | |
| 400 ScopedEvent event(new ScrollEvent(EventType::ET_SCROLL, gfx::Point(), | |
| 401 base::TimeDelta(), IMIN, FMIN, FMAX, FNAN, | |
| 402 FMIN, IMAX)); | |
| 403 Verify(event); | |
| 404 } | |
| 405 | |
| 406 TEST_F(EventParamTraitsTest, GoodSimpleGestureEvent) { | |
| 407 EventType event_types[19] = { | |
| 408 EventType::ET_GESTURE_SCROLL_BEGIN, | |
| 409 EventType::ET_GESTURE_SCROLL_END, | |
| 410 EventType::ET_GESTURE_SCROLL_UPDATE, | |
| 411 EventType::ET_GESTURE_SHOW_PRESS, | |
| 412 EventType::ET_GESTURE_WIN8_EDGE_SWIPE, | |
| 413 EventType::ET_GESTURE_TAP, | |
| 414 EventType::ET_GESTURE_TAP_DOWN, | |
| 415 EventType::ET_GESTURE_TAP_CANCEL, | |
| 416 EventType::ET_GESTURE_BEGIN, | |
| 417 EventType::ET_GESTURE_END, | |
| 418 EventType::ET_GESTURE_TWO_FINGER_TAP, | |
| 419 EventType::ET_GESTURE_PINCH_BEGIN, | |
| 420 EventType::ET_GESTURE_PINCH_END, | |
| 421 EventType::ET_GESTURE_PINCH_UPDATE, | |
| 422 EventType::ET_GESTURE_LONG_PRESS, | |
| 423 EventType::ET_GESTURE_LONG_TAP, | |
| 424 EventType::ET_GESTURE_SWIPE, | |
| 425 EventType::ET_GESTURE_TAP_UNCONFIRMED, | |
| 426 EventType::ET_GESTURE_DOUBLE_TAP, | |
| 427 }; | |
| 428 for (int i = 0; i < 19; i++) { | |
| 429 ScopedEvent event(new GestureEvent(0.0, 0.0, 0, base::TimeDelta(), | |
| 430 GestureEventDetails(event_types[i]))); | |
| 431 Verify(event); | |
| 432 } | |
| 433 } | |
| 434 | |
| 435 TEST_F(EventParamTraitsTest, GoodCornerCaseGestureEvent) { | |
| 436 EventType event_types[17] = { | |
| 437 EventType::ET_GESTURE_SCROLL_UPDATE, | |
| 438 EventType::ET_GESTURE_SHOW_PRESS, | |
| 439 EventType::ET_GESTURE_WIN8_EDGE_SWIPE, | |
| 440 EventType::ET_GESTURE_TAP, | |
| 441 EventType::ET_GESTURE_TAP_DOWN, | |
| 442 EventType::ET_GESTURE_TAP_CANCEL, | |
| 443 EventType::ET_GESTURE_BEGIN, | |
| 444 EventType::ET_GESTURE_END, | |
| 445 EventType::ET_GESTURE_TWO_FINGER_TAP, | |
| 446 EventType::ET_GESTURE_PINCH_BEGIN, | |
| 447 EventType::ET_GESTURE_PINCH_END, | |
| 448 EventType::ET_GESTURE_PINCH_UPDATE, | |
| 449 EventType::ET_GESTURE_LONG_PRESS, | |
| 450 EventType::ET_GESTURE_LONG_TAP, | |
| 451 EventType::ET_GESTURE_SWIPE, | |
| 452 EventType::ET_GESTURE_TAP_UNCONFIRMED, | |
| 453 EventType::ET_GESTURE_DOUBLE_TAP, | |
| 454 }; | |
| 455 for (int i = 0; i < 17; i++) { | |
| 456 ScopedEvent event( | |
| 457 new GestureEvent(0.0, 0.0, 0, base::TimeDelta(), | |
| 458 CreateCornerCaseGestureEventDetails(event_types[i]))); | |
| 459 Verify(event); | |
| 460 } | |
| 461 } | |
| 462 | |
| 463 TEST_F(EventParamTraitsTest, GoodSimplePointerEvent) { | |
| 464 EventType event_types[] = { | |
| 465 ET_POINTER_DOWN, ET_POINTER_MOVED, ET_POINTER_UP, | |
| 466 ET_POINTER_CANCELLED, ET_POINTER_ENTERED, ET_POINTER_EXITED, | |
| 467 }; | |
| 468 EventPointerType pointer_types[] = { | |
| 469 EventPointerType::POINTER_TYPE_MOUSE, | |
| 470 EventPointerType::POINTER_TYPE_TOUCH, | |
| 471 }; | |
| 472 | |
| 473 for (size_t i = 0; i < arraysize(event_types); i++) { | |
| 474 for (size_t j = 0; j < arraysize(pointer_types); j++) { | |
| 475 ScopedEvent event(new PointerEvent(event_types[i], pointer_types[j], | |
| 476 gfx::Point(), gfx::Point(), 0, 0, | |
| 477 base::TimeDelta())); | |
| 478 Verify(event); | |
| 479 } | |
| 480 } | |
| 481 } | |
| 482 | |
| 483 #undef FEQ | |
| 484 #undef ASSERT_FEQ | |
| 485 #undef CAST_EVENT | |
| 486 #undef COMPARE_BASE | |
| 487 #undef MIN | |
| 488 #undef MAX | |
| 489 #undef IMIN | |
| 490 #undef IMAX | |
| 491 #undef FMIN | |
| 492 #undef FMAX | |
| 493 #undef FNAN | |
| 494 | |
| 495 } // namespace | |
| 496 } // namespace ui | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2049053003:
Remove IPC::ParamTraits for ui::Event. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master