| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 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 "content/browser/renderer_host/web_input_event_aura.h" | |
| 6 | |
| 7 #include <stddef.h> | |
| 8 #include <stdint.h> | |
| 9 | |
| 10 #include "base/macros.h" | |
| 11 #include "build/build_config.h" | |
| 12 #include "testing/gtest/include/gtest/gtest.h" | |
| 13 #include "ui/events/base_event_utils.h" | |
| 14 #include "ui/events/blink/blink_event_util.h" | |
| 15 #include "ui/events/event.h" | |
| 16 #include "ui/events/event_utils.h" | |
| 17 #include "ui/events/keycodes/dom/dom_code.h" | |
| 18 #include "ui/events/keycodes/dom/dom_key.h" | |
| 19 #include "ui/events/keycodes/dom/keycode_converter.h" | |
| 20 | |
| 21 #if defined(USE_X11) | |
| 22 #include <X11/keysym.h> | |
| 23 #include <X11/Xlib.h> | |
| 24 #include "ui/events/test/events_test_utils_x11.h" | |
| 25 #include "ui/gfx/x/x11_types.h" // nogncheck | |
| 26 #endif | |
| 27 | |
| 28 namespace content { | |
| 29 | |
| 30 // Checks that MakeWebKeyboardEvent makes a DOM3 spec compliant key event. | |
| 31 // crbug.com/127142 | |
| 32 TEST(WebInputEventAuraTest, TestMakeWebKeyboardEvent) { | |
| 33 { | |
| 34 // Press left Ctrl. | |
| 35 ui::KeyEvent event(ui::ET_KEY_PRESSED, ui::VKEY_CONTROL, | |
| 36 ui::DomCode::CONTROL_LEFT, ui::EF_CONTROL_DOWN); | |
| 37 blink::WebKeyboardEvent webkit_event = MakeWebKeyboardEvent(event); | |
| 38 // However, modifier bit for Control in |webkit_event| should be set. | |
| 39 EXPECT_EQ(blink::WebInputEvent::ControlKey | blink::WebInputEvent::IsLeft, | |
| 40 webkit_event.modifiers); | |
| 41 EXPECT_EQ(static_cast<int>(ui::DomCode::CONTROL_LEFT), | |
| 42 webkit_event.domCode); | |
| 43 EXPECT_EQ(static_cast<int>(ui::DomKey::CONTROL), webkit_event.domKey); | |
| 44 } | |
| 45 { | |
| 46 // Release left Ctrl. | |
| 47 ui::KeyEvent event(ui::ET_KEY_RELEASED, ui::VKEY_CONTROL, | |
| 48 ui::DomCode::CONTROL_LEFT, ui::EF_NONE); | |
| 49 blink::WebKeyboardEvent webkit_event = MakeWebKeyboardEvent(event); | |
| 50 // However, modifier bit for Control in |webkit_event| shouldn't be set. | |
| 51 EXPECT_EQ(blink::WebInputEvent::IsLeft, webkit_event.modifiers); | |
| 52 EXPECT_EQ(static_cast<int>(ui::DomCode::CONTROL_LEFT), | |
| 53 webkit_event.domCode); | |
| 54 EXPECT_EQ(static_cast<int>(ui::DomKey::CONTROL), webkit_event.domKey); | |
| 55 } | |
| 56 { | |
| 57 // Press right Ctrl. | |
| 58 ui::KeyEvent event(ui::ET_KEY_PRESSED, ui::VKEY_CONTROL, | |
| 59 ui::DomCode::CONTROL_RIGHT, ui::EF_CONTROL_DOWN); | |
| 60 blink::WebKeyboardEvent webkit_event = MakeWebKeyboardEvent(event); | |
| 61 // However, modifier bit for Control in |webkit_event| should be set. | |
| 62 EXPECT_EQ(blink::WebInputEvent::ControlKey | blink::WebInputEvent::IsRight, | |
| 63 webkit_event.modifiers); | |
| 64 EXPECT_EQ(static_cast<int>(ui::DomCode::CONTROL_RIGHT), | |
| 65 webkit_event.domCode); | |
| 66 } | |
| 67 { | |
| 68 // Release right Ctrl. | |
| 69 ui::KeyEvent event(ui::ET_KEY_RELEASED, ui::VKEY_CONTROL, | |
| 70 ui::DomCode::CONTROL_RIGHT, ui::EF_NONE); | |
| 71 blink::WebKeyboardEvent webkit_event = MakeWebKeyboardEvent(event); | |
| 72 // However, modifier bit for Control in |webkit_event| shouldn't be set. | |
| 73 EXPECT_EQ(blink::WebInputEvent::IsRight, webkit_event.modifiers); | |
| 74 EXPECT_EQ(static_cast<int>(ui::DomCode::CONTROL_RIGHT), | |
| 75 webkit_event.domCode); | |
| 76 EXPECT_EQ(static_cast<int>(ui::DomKey::CONTROL), webkit_event.domKey); | |
| 77 } | |
| 78 #if defined(USE_X11) | |
| 79 const int kLocationModifiers = | |
| 80 blink::WebInputEvent::IsLeft | blink::WebInputEvent::IsRight; | |
| 81 ui::ScopedXI2Event xev; | |
| 82 { | |
| 83 // Press Ctrl. | |
| 84 xev.InitKeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_CONTROL, 0); | |
| 85 ui::KeyEvent event(xev); | |
| 86 blink::WebKeyboardEvent webkit_event = MakeWebKeyboardEvent(event); | |
| 87 // However, modifier bit for Control in |webkit_event| should be set. | |
| 88 EXPECT_EQ(blink::WebInputEvent::ControlKey, | |
| 89 webkit_event.modifiers & ~kLocationModifiers); | |
| 90 } | |
| 91 { | |
| 92 // Release Ctrl. | |
| 93 xev.InitKeyEvent(ui::ET_KEY_RELEASED, ui::VKEY_CONTROL, ControlMask); | |
| 94 ui::KeyEvent event(xev); | |
| 95 blink::WebKeyboardEvent webkit_event = MakeWebKeyboardEvent(event); | |
| 96 // However, modifier bit for Control in |webkit_event| shouldn't be set. | |
| 97 EXPECT_EQ(0, webkit_event.modifiers & ~kLocationModifiers); | |
| 98 } | |
| 99 #endif | |
| 100 } | |
| 101 | |
| 102 // Checks that MakeWebKeyboardEvent returns a correct windowsKeyCode. | |
| 103 #if defined(OS_CHROMEOS) || defined(THREAD_SANITIZER) | |
| 104 // Fails on Chrome OS and under ThreadSanitizer on Linux, see | |
| 105 // https://crbug.com/449103. | |
| 106 #define MAYBE_TestMakeWebKeyboardEventWindowsKeyCode \ | |
| 107 DISABLED_TestMakeWebKeyboardEventWindowsKeyCode | |
| 108 #else | |
| 109 #define MAYBE_TestMakeWebKeyboardEventWindowsKeyCode \ | |
| 110 TestMakeWebKeyboardEventWindowsKeyCode | |
| 111 #endif | |
| 112 TEST(WebInputEventAuraTest, MAYBE_TestMakeWebKeyboardEventWindowsKeyCode) { | |
| 113 #if defined(USE_X11) | |
| 114 ui::ScopedXI2Event xev; | |
| 115 { | |
| 116 // Press left Ctrl. | |
| 117 xev.InitKeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_CONTROL, 0); | |
| 118 XEvent* xevent = xev; | |
| 119 xevent->xkey.keycode = | |
| 120 ui::KeycodeConverter::DomCodeToNativeKeycode(ui::DomCode::CONTROL_LEFT); | |
| 121 ui::KeyEvent event(xev); | |
| 122 blink::WebKeyboardEvent webkit_event = MakeWebKeyboardEvent(event); | |
| 123 EXPECT_EQ(ui::VKEY_CONTROL, webkit_event.windowsKeyCode); | |
| 124 } | |
| 125 { | |
| 126 // Press right Ctrl. | |
| 127 xev.InitKeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_CONTROL, 0); | |
| 128 XEvent* xevent = xev; | |
| 129 xevent->xkey.keycode = ui::KeycodeConverter::DomCodeToNativeKeycode( | |
| 130 ui::DomCode::CONTROL_RIGHT); | |
| 131 ui::KeyEvent event(xev); | |
| 132 blink::WebKeyboardEvent webkit_event = MakeWebKeyboardEvent(event); | |
| 133 EXPECT_EQ(ui::VKEY_CONTROL, webkit_event.windowsKeyCode); | |
| 134 } | |
| 135 #elif defined(OS_WIN) | |
| 136 // TODO(yusukes): Add tests for win_aura once keyboardEvent() in | |
| 137 // third_party/WebKit/Source/web/win/WebInputEventFactory.cpp is modified | |
| 138 // to return VKEY_[LR]XXX instead of VKEY_XXX. | |
| 139 // https://bugs.webkit.org/show_bug.cgi?id=86694 | |
| 140 #endif | |
| 141 { | |
| 142 // Press left Ctrl. | |
| 143 ui::KeyEvent event(ui::ET_KEY_PRESSED, ui::VKEY_CONTROL, | |
| 144 ui::DomCode::CONTROL_LEFT, ui::EF_CONTROL_DOWN, | |
| 145 ui::DomKey::CONTROL, ui::EventTimeForNow()); | |
| 146 blink::WebKeyboardEvent webkit_event = MakeWebKeyboardEvent(event); | |
| 147 EXPECT_EQ(ui::VKEY_CONTROL, webkit_event.windowsKeyCode); | |
| 148 } | |
| 149 { | |
| 150 // Press right Ctrl. | |
| 151 ui::KeyEvent event(ui::ET_KEY_PRESSED, ui::VKEY_CONTROL, | |
| 152 ui::DomCode::CONTROL_RIGHT, ui::EF_CONTROL_DOWN, | |
| 153 ui::DomKey::CONTROL, ui::EventTimeForNow()); | |
| 154 blink::WebKeyboardEvent webkit_event = MakeWebKeyboardEvent(event); | |
| 155 EXPECT_EQ(ui::VKEY_CONTROL, webkit_event.windowsKeyCode); | |
| 156 } | |
| 157 } | |
| 158 | |
| 159 // Checks that MakeWebKeyboardEvent fills a correct keypad modifier. | |
| 160 TEST(WebInputEventAuraTest, TestMakeWebKeyboardEventKeyPadKeyCode) { | |
| 161 #if defined(USE_X11) | |
| 162 #define XK(x) XK_##x | |
| 163 #else | |
| 164 #define XK(x) 0 | |
| 165 #endif | |
| 166 struct TestCase { | |
| 167 ui::DomCode dom_code; // The physical key (location). | |
| 168 ui::KeyboardCode ui_keycode; // The virtual key code. | |
| 169 uint32_t x_keysym; // The X11 keysym. | |
| 170 bool expected_result; // true if the event has "isKeyPad" modifier. | |
| 171 } kTesCases[] = { | |
| 172 {ui::DomCode::DIGIT0, ui::VKEY_0, XK(0), false}, | |
| 173 {ui::DomCode::DIGIT1, ui::VKEY_1, XK(1), false}, | |
| 174 {ui::DomCode::DIGIT2, ui::VKEY_2, XK(2), false}, | |
| 175 {ui::DomCode::DIGIT3, ui::VKEY_3, XK(3), false}, | |
| 176 {ui::DomCode::DIGIT4, ui::VKEY_4, XK(4), false}, | |
| 177 {ui::DomCode::DIGIT5, ui::VKEY_5, XK(5), false}, | |
| 178 {ui::DomCode::DIGIT6, ui::VKEY_6, XK(6), false}, | |
| 179 {ui::DomCode::DIGIT7, ui::VKEY_7, XK(7), false}, | |
| 180 {ui::DomCode::DIGIT8, ui::VKEY_8, XK(8), false}, | |
| 181 {ui::DomCode::DIGIT9, ui::VKEY_9, XK(9), false}, | |
| 182 | |
| 183 {ui::DomCode::NUMPAD0, ui::VKEY_NUMPAD0, XK(KP_0), true}, | |
| 184 {ui::DomCode::NUMPAD1, ui::VKEY_NUMPAD1, XK(KP_1), true}, | |
| 185 {ui::DomCode::NUMPAD2, ui::VKEY_NUMPAD2, XK(KP_2), true}, | |
| 186 {ui::DomCode::NUMPAD3, ui::VKEY_NUMPAD3, XK(KP_3), true}, | |
| 187 {ui::DomCode::NUMPAD4, ui::VKEY_NUMPAD4, XK(KP_4), true}, | |
| 188 {ui::DomCode::NUMPAD5, ui::VKEY_NUMPAD5, XK(KP_5), true}, | |
| 189 {ui::DomCode::NUMPAD6, ui::VKEY_NUMPAD6, XK(KP_6), true}, | |
| 190 {ui::DomCode::NUMPAD7, ui::VKEY_NUMPAD7, XK(KP_7), true}, | |
| 191 {ui::DomCode::NUMPAD8, ui::VKEY_NUMPAD8, XK(KP_8), true}, | |
| 192 {ui::DomCode::NUMPAD9, ui::VKEY_NUMPAD9, XK(KP_9), true}, | |
| 193 | |
| 194 {ui::DomCode::NUMPAD_MULTIPLY, ui::VKEY_MULTIPLY, XK(KP_Multiply), true}, | |
| 195 {ui::DomCode::NUMPAD_SUBTRACT, ui::VKEY_SUBTRACT, XK(KP_Subtract), true}, | |
| 196 {ui::DomCode::NUMPAD_ADD, ui::VKEY_ADD, XK(KP_Add), true}, | |
| 197 {ui::DomCode::NUMPAD_DIVIDE, ui::VKEY_DIVIDE, XK(KP_Divide), true}, | |
| 198 {ui::DomCode::NUMPAD_DECIMAL, ui::VKEY_DECIMAL, XK(KP_Decimal), true}, | |
| 199 {ui::DomCode::NUMPAD_DECIMAL, ui::VKEY_DELETE, XK(KP_Delete), true}, | |
| 200 {ui::DomCode::NUMPAD0, ui::VKEY_INSERT, XK(KP_Insert), true}, | |
| 201 {ui::DomCode::NUMPAD1, ui::VKEY_END, XK(KP_End), true}, | |
| 202 {ui::DomCode::NUMPAD2, ui::VKEY_DOWN, XK(KP_Down), true}, | |
| 203 {ui::DomCode::NUMPAD3, ui::VKEY_NEXT, XK(KP_Page_Down), true}, | |
| 204 {ui::DomCode::NUMPAD4, ui::VKEY_LEFT, XK(KP_Left), true}, | |
| 205 {ui::DomCode::NUMPAD5, ui::VKEY_CLEAR, XK(KP_Begin), true}, | |
| 206 {ui::DomCode::NUMPAD6, ui::VKEY_RIGHT, XK(KP_Right), true}, | |
| 207 {ui::DomCode::NUMPAD7, ui::VKEY_HOME, XK(KP_Home), true}, | |
| 208 {ui::DomCode::NUMPAD8, ui::VKEY_UP, XK(KP_Up), true}, | |
| 209 {ui::DomCode::NUMPAD9, ui::VKEY_PRIOR, XK(KP_Page_Up), true}, | |
| 210 }; | |
| 211 for (const auto& test_case : kTesCases) { | |
| 212 ui::KeyEvent event(ui::ET_KEY_PRESSED, test_case.ui_keycode, | |
| 213 test_case.dom_code, ui::EF_NONE); | |
| 214 blink::WebKeyboardEvent webkit_event = MakeWebKeyboardEvent(event); | |
| 215 EXPECT_EQ(test_case.expected_result, | |
| 216 (webkit_event.modifiers & blink::WebInputEvent::IsKeyPad) != 0) | |
| 217 << "Failed in " | |
| 218 << "{dom_code:" | |
| 219 << ui::KeycodeConverter::DomCodeToCodeString(test_case.dom_code) | |
| 220 << ", ui_keycode:" << test_case.ui_keycode | |
| 221 << "}, expect: " << test_case.expected_result; | |
| 222 } | |
| 223 #if defined(USE_X11) | |
| 224 ui::ScopedXI2Event xev; | |
| 225 for (size_t i = 0; i < arraysize(kTesCases); ++i) { | |
| 226 const TestCase& test_case = kTesCases[i]; | |
| 227 | |
| 228 // TODO: re-enable the two cases excluded here once all trybots | |
| 229 // are sufficiently up to date to round-trip the associated keys. | |
| 230 if ((test_case.x_keysym == XK_KP_Divide) || | |
| 231 (test_case.x_keysym == XK_KP_Decimal)) | |
| 232 continue; | |
| 233 | |
| 234 xev.InitKeyEvent(ui::ET_KEY_PRESSED, test_case.ui_keycode, ui::EF_NONE); | |
| 235 XEvent* xevent = xev; | |
| 236 xevent->xkey.keycode = | |
| 237 XKeysymToKeycode(gfx::GetXDisplay(), test_case.x_keysym); | |
| 238 if (!xevent->xkey.keycode) | |
| 239 continue; | |
| 240 ui::KeyEvent event(xev); | |
| 241 blink::WebKeyboardEvent webkit_event = MakeWebKeyboardEvent(event); | |
| 242 EXPECT_EQ(test_case.expected_result, | |
| 243 (webkit_event.modifiers & blink::WebInputEvent::IsKeyPad) != 0) | |
| 244 << "Failed in " << i << "th test case: " | |
| 245 << "{dom_code:" | |
| 246 << ui::KeycodeConverter::DomCodeToCodeString(test_case.dom_code) | |
| 247 << ", ui_keycode:" << test_case.ui_keycode | |
| 248 << ", x_keysym:" << test_case.x_keysym | |
| 249 << "}, expect: " << test_case.expected_result; | |
| 250 } | |
| 251 #endif | |
| 252 } | |
| 253 | |
| 254 TEST(WebInputEventAuraTest, TestMakeWebMouseEvent) { | |
| 255 { | |
| 256 // Left pressed. | |
| 257 base::TimeTicks timestamp = ui::EventTimeForNow(); | |
| 258 ui::MouseEvent aura_event( | |
| 259 ui::ET_MOUSE_PRESSED, gfx::Point(123, 321), gfx::Point(123, 321), | |
| 260 timestamp, ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON); | |
| 261 blink::WebMouseEvent webkit_event = MakeWebMouseEvent(aura_event); | |
| 262 EXPECT_EQ(ui::EventFlagsToWebEventModifiers(aura_event.flags()), | |
| 263 webkit_event.modifiers); | |
| 264 EXPECT_FLOAT_EQ(ui::EventTimeStampToSeconds(timestamp), | |
| 265 webkit_event.timeStampSeconds); | |
| 266 EXPECT_EQ(blink::WebMouseEvent::ButtonLeft, webkit_event.button); | |
| 267 EXPECT_EQ(blink::WebInputEvent::MouseDown, webkit_event.type); | |
| 268 EXPECT_EQ(aura_event.GetClickCount(), webkit_event.clickCount); | |
| 269 EXPECT_EQ(123, webkit_event.x); | |
| 270 EXPECT_EQ(123, webkit_event.windowX); | |
| 271 EXPECT_EQ(321, webkit_event.y); | |
| 272 EXPECT_EQ(321, webkit_event.windowY); | |
| 273 } | |
| 274 { | |
| 275 // Left released. | |
| 276 base::TimeTicks timestamp = ui::EventTimeForNow(); | |
| 277 ui::MouseEvent aura_event(ui::ET_MOUSE_RELEASED, gfx::Point(123, 321), | |
| 278 gfx::Point(123, 321), timestamp, 0, | |
| 279 ui::EF_LEFT_MOUSE_BUTTON); | |
| 280 blink::WebMouseEvent webkit_event = MakeWebMouseEvent(aura_event); | |
| 281 EXPECT_EQ(ui::EventFlagsToWebEventModifiers(aura_event.flags()), | |
| 282 webkit_event.modifiers); | |
| 283 EXPECT_FLOAT_EQ(ui::EventTimeStampToSeconds(timestamp), | |
| 284 webkit_event.timeStampSeconds); | |
| 285 EXPECT_EQ(blink::WebMouseEvent::ButtonLeft, webkit_event.button); | |
| 286 EXPECT_EQ(blink::WebInputEvent::MouseUp, webkit_event.type); | |
| 287 EXPECT_EQ(aura_event.GetClickCount(), webkit_event.clickCount); | |
| 288 EXPECT_EQ(123, webkit_event.x); | |
| 289 EXPECT_EQ(123, webkit_event.windowX); | |
| 290 EXPECT_EQ(321, webkit_event.y); | |
| 291 EXPECT_EQ(321, webkit_event.windowY); | |
| 292 } | |
| 293 { | |
| 294 // Middle pressed. | |
| 295 base::TimeTicks timestamp = ui::EventTimeForNow(); | |
| 296 ui::MouseEvent aura_event( | |
| 297 ui::ET_MOUSE_PRESSED, gfx::Point(123, 321), gfx::Point(123, 321), | |
| 298 timestamp, ui::EF_MIDDLE_MOUSE_BUTTON, ui::EF_MIDDLE_MOUSE_BUTTON); | |
| 299 blink::WebMouseEvent webkit_event = MakeWebMouseEvent(aura_event); | |
| 300 EXPECT_EQ(ui::EventFlagsToWebEventModifiers(aura_event.flags()), | |
| 301 webkit_event.modifiers); | |
| 302 EXPECT_FLOAT_EQ(ui::EventTimeStampToSeconds(timestamp), | |
| 303 webkit_event.timeStampSeconds); | |
| 304 EXPECT_EQ(blink::WebMouseEvent::ButtonMiddle, webkit_event.button); | |
| 305 EXPECT_EQ(blink::WebInputEvent::MouseDown, webkit_event.type); | |
| 306 EXPECT_EQ(aura_event.GetClickCount(), webkit_event.clickCount); | |
| 307 EXPECT_EQ(123, webkit_event.x); | |
| 308 EXPECT_EQ(123, webkit_event.windowX); | |
| 309 EXPECT_EQ(321, webkit_event.y); | |
| 310 EXPECT_EQ(321, webkit_event.windowY); | |
| 311 } | |
| 312 { | |
| 313 // Middle released. | |
| 314 base::TimeTicks timestamp = ui::EventTimeForNow(); | |
| 315 ui::MouseEvent aura_event(ui::ET_MOUSE_RELEASED, gfx::Point(123, 321), | |
| 316 gfx::Point(123, 321), timestamp, 0, | |
| 317 ui::EF_MIDDLE_MOUSE_BUTTON); | |
| 318 blink::WebMouseEvent webkit_event = MakeWebMouseEvent(aura_event); | |
| 319 EXPECT_EQ(ui::EventFlagsToWebEventModifiers(aura_event.flags()), | |
| 320 webkit_event.modifiers); | |
| 321 EXPECT_FLOAT_EQ(ui::EventTimeStampToSeconds(timestamp), | |
| 322 webkit_event.timeStampSeconds); | |
| 323 EXPECT_EQ(blink::WebMouseEvent::ButtonMiddle, webkit_event.button); | |
| 324 EXPECT_EQ(blink::WebInputEvent::MouseUp, webkit_event.type); | |
| 325 EXPECT_EQ(aura_event.GetClickCount(), webkit_event.clickCount); | |
| 326 EXPECT_EQ(123, webkit_event.x); | |
| 327 EXPECT_EQ(123, webkit_event.windowX); | |
| 328 EXPECT_EQ(321, webkit_event.y); | |
| 329 EXPECT_EQ(321, webkit_event.windowY); | |
| 330 } | |
| 331 { | |
| 332 // Right pressed. | |
| 333 base::TimeTicks timestamp = ui::EventTimeForNow(); | |
| 334 ui::MouseEvent aura_event( | |
| 335 ui::ET_MOUSE_PRESSED, gfx::Point(123, 321), gfx::Point(123, 321), | |
| 336 timestamp, ui::EF_RIGHT_MOUSE_BUTTON, ui::EF_RIGHT_MOUSE_BUTTON); | |
| 337 blink::WebMouseEvent webkit_event = MakeWebMouseEvent(aura_event); | |
| 338 EXPECT_EQ(ui::EventFlagsToWebEventModifiers(aura_event.flags()), | |
| 339 webkit_event.modifiers); | |
| 340 EXPECT_FLOAT_EQ(ui::EventTimeStampToSeconds(timestamp), | |
| 341 webkit_event.timeStampSeconds); | |
| 342 EXPECT_EQ(blink::WebMouseEvent::ButtonRight, webkit_event.button); | |
| 343 EXPECT_EQ(blink::WebInputEvent::MouseDown, webkit_event.type); | |
| 344 EXPECT_EQ(aura_event.GetClickCount(), webkit_event.clickCount); | |
| 345 EXPECT_EQ(123, webkit_event.x); | |
| 346 EXPECT_EQ(123, webkit_event.windowX); | |
| 347 EXPECT_EQ(321, webkit_event.y); | |
| 348 EXPECT_EQ(321, webkit_event.windowY); | |
| 349 } | |
| 350 { | |
| 351 // Right released. | |
| 352 base::TimeTicks timestamp = ui::EventTimeForNow(); | |
| 353 ui::MouseEvent aura_event(ui::ET_MOUSE_RELEASED, gfx::Point(123, 321), | |
| 354 gfx::Point(123, 321), timestamp, 0, | |
| 355 ui::EF_RIGHT_MOUSE_BUTTON); | |
| 356 blink::WebMouseEvent webkit_event = MakeWebMouseEvent(aura_event); | |
| 357 EXPECT_EQ(ui::EventFlagsToWebEventModifiers(aura_event.flags()), | |
| 358 webkit_event.modifiers); | |
| 359 EXPECT_FLOAT_EQ(ui::EventTimeStampToSeconds(timestamp), | |
| 360 webkit_event.timeStampSeconds); | |
| 361 EXPECT_EQ(blink::WebMouseEvent::ButtonRight, webkit_event.button); | |
| 362 EXPECT_EQ(blink::WebInputEvent::MouseUp, webkit_event.type); | |
| 363 EXPECT_EQ(aura_event.GetClickCount(), webkit_event.clickCount); | |
| 364 EXPECT_EQ(123, webkit_event.x); | |
| 365 EXPECT_EQ(123, webkit_event.windowX); | |
| 366 EXPECT_EQ(321, webkit_event.y); | |
| 367 EXPECT_EQ(321, webkit_event.windowY); | |
| 368 } | |
| 369 { | |
| 370 // Moved | |
| 371 base::TimeTicks timestamp = ui::EventTimeForNow(); | |
| 372 ui::MouseEvent aura_event(ui::ET_MOUSE_MOVED, gfx::Point(123, 321), | |
| 373 gfx::Point(123, 321), timestamp, 0, 0); | |
| 374 blink::WebMouseEvent webkit_event = MakeWebMouseEvent(aura_event); | |
| 375 EXPECT_EQ(ui::EventFlagsToWebEventModifiers(aura_event.flags()), | |
| 376 webkit_event.modifiers); | |
| 377 EXPECT_FLOAT_EQ(ui::EventTimeStampToSeconds(timestamp), | |
| 378 webkit_event.timeStampSeconds); | |
| 379 EXPECT_EQ(blink::WebMouseEvent::ButtonNone, webkit_event.button); | |
| 380 EXPECT_EQ(blink::WebInputEvent::MouseMove, webkit_event.type); | |
| 381 EXPECT_EQ(aura_event.GetClickCount(), webkit_event.clickCount); | |
| 382 EXPECT_EQ(123, webkit_event.x); | |
| 383 EXPECT_EQ(123, webkit_event.windowX); | |
| 384 EXPECT_EQ(321, webkit_event.y); | |
| 385 EXPECT_EQ(321, webkit_event.windowY); | |
| 386 } | |
| 387 { | |
| 388 // Moved with left down | |
| 389 base::TimeTicks timestamp = ui::EventTimeForNow(); | |
| 390 ui::MouseEvent aura_event(ui::ET_MOUSE_MOVED, gfx::Point(123, 321), | |
| 391 gfx::Point(123, 321), timestamp, | |
| 392 ui::EF_LEFT_MOUSE_BUTTON, 0); | |
| 393 blink::WebMouseEvent webkit_event = MakeWebMouseEvent(aura_event); | |
| 394 EXPECT_EQ(ui::EventFlagsToWebEventModifiers(aura_event.flags()), | |
| 395 webkit_event.modifiers); | |
| 396 EXPECT_FLOAT_EQ(ui::EventTimeStampToSeconds(timestamp), | |
| 397 webkit_event.timeStampSeconds); | |
| 398 EXPECT_EQ(blink::WebMouseEvent::ButtonLeft, webkit_event.button); | |
| 399 EXPECT_EQ(blink::WebInputEvent::MouseMove, webkit_event.type); | |
| 400 EXPECT_EQ(aura_event.GetClickCount(), webkit_event.clickCount); | |
| 401 EXPECT_EQ(123, webkit_event.x); | |
| 402 EXPECT_EQ(123, webkit_event.windowX); | |
| 403 EXPECT_EQ(321, webkit_event.y); | |
| 404 EXPECT_EQ(321, webkit_event.windowY); | |
| 405 } | |
| 406 { | |
| 407 // Left with shift pressed. | |
| 408 base::TimeTicks timestamp = ui::EventTimeForNow(); | |
| 409 ui::MouseEvent aura_event(ui::ET_MOUSE_PRESSED, gfx::Point(123, 321), | |
| 410 gfx::Point(123, 321), timestamp, | |
| 411 ui::EF_LEFT_MOUSE_BUTTON | ui::EF_SHIFT_DOWN, | |
| 412 ui::EF_LEFT_MOUSE_BUTTON); | |
| 413 blink::WebMouseEvent webkit_event = MakeWebMouseEvent(aura_event); | |
| 414 EXPECT_EQ(ui::EventFlagsToWebEventModifiers(aura_event.flags()), | |
| 415 webkit_event.modifiers); | |
| 416 EXPECT_FLOAT_EQ(ui::EventTimeStampToSeconds(timestamp), | |
| 417 webkit_event.timeStampSeconds); | |
| 418 EXPECT_EQ(blink::WebMouseEvent::ButtonLeft, webkit_event.button); | |
| 419 EXPECT_EQ(blink::WebInputEvent::MouseDown, webkit_event.type); | |
| 420 EXPECT_EQ(aura_event.GetClickCount(), webkit_event.clickCount); | |
| 421 EXPECT_EQ(123, webkit_event.x); | |
| 422 EXPECT_EQ(123, webkit_event.windowX); | |
| 423 EXPECT_EQ(321, webkit_event.y); | |
| 424 EXPECT_EQ(321, webkit_event.windowY); | |
| 425 } | |
| 426 { | |
| 427 // Default values for PointerDetails. | |
| 428 base::TimeTicks timestamp = ui::EventTimeForNow(); | |
| 429 ui::MouseEvent aura_event( | |
| 430 ui::ET_MOUSE_PRESSED, gfx::Point(123, 321), gfx::Point(123, 321), | |
| 431 timestamp, ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON); | |
| 432 blink::WebMouseEvent webkit_event = MakeWebMouseEvent(aura_event); | |
| 433 | |
| 434 EXPECT_EQ(blink::WebPointerProperties::PointerType::Mouse, | |
| 435 webkit_event.pointerType); | |
| 436 EXPECT_EQ(0, webkit_event.tiltX); | |
| 437 EXPECT_EQ(0, webkit_event.tiltY); | |
| 438 EXPECT_TRUE(std::isnan(webkit_event.force)); | |
| 439 EXPECT_EQ(123, webkit_event.x); | |
| 440 EXPECT_EQ(123, webkit_event.windowX); | |
| 441 EXPECT_EQ(321, webkit_event.y); | |
| 442 EXPECT_EQ(321, webkit_event.windowY); | |
| 443 } | |
| 444 { | |
| 445 // Stylus values for PointerDetails. | |
| 446 base::TimeTicks timestamp = ui::EventTimeForNow(); | |
| 447 ui::MouseEvent aura_event( | |
| 448 ui::ET_MOUSE_PRESSED, gfx::Point(123, 321), gfx::Point(123, 321), | |
| 449 timestamp, ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON); | |
| 450 aura_event.set_pointer_details( | |
| 451 ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_PEN, | |
| 452 /* radius_x */ 0.0f, | |
| 453 /* radius_y */ 0.0f, | |
| 454 /* force */ 0.8f, | |
| 455 /* tilt_x */ 89.5f, | |
| 456 /* tilt_y */ -89.5f)); | |
| 457 blink::WebMouseEvent webkit_event = MakeWebMouseEvent(aura_event); | |
| 458 | |
| 459 EXPECT_EQ(blink::WebPointerProperties::PointerType::Pen, | |
| 460 webkit_event.pointerType); | |
| 461 EXPECT_EQ(90, webkit_event.tiltX); | |
| 462 EXPECT_EQ(-90, webkit_event.tiltY); | |
| 463 EXPECT_FLOAT_EQ(0.8f, webkit_event.force); | |
| 464 EXPECT_EQ(123, webkit_event.x); | |
| 465 EXPECT_EQ(123, webkit_event.windowX); | |
| 466 EXPECT_EQ(321, webkit_event.y); | |
| 467 EXPECT_EQ(321, webkit_event.windowY); | |
| 468 } | |
| 469 } | |
| 470 | |
| 471 TEST(WebInputEventAuraTest, TestMakeWebMouseWheelEvent) { | |
| 472 { | |
| 473 // Mouse wheel. | |
| 474 base::TimeTicks timestamp = ui::EventTimeForNow(); | |
| 475 ui::MouseWheelEvent aura_event( | |
| 476 gfx::Vector2d(ui::MouseWheelEvent::kWheelDelta * 2, | |
| 477 -ui::MouseWheelEvent::kWheelDelta * 2), | |
| 478 gfx::Point(123, 321), gfx::Point(123, 321), timestamp, 0, 0); | |
| 479 blink::WebMouseWheelEvent webkit_event = MakeWebMouseWheelEvent(aura_event); | |
| 480 EXPECT_EQ(ui::EventFlagsToWebEventModifiers(aura_event.flags()), | |
| 481 webkit_event.modifiers); | |
| 482 EXPECT_FLOAT_EQ(ui::EventTimeStampToSeconds(timestamp), | |
| 483 webkit_event.timeStampSeconds); | |
| 484 EXPECT_EQ(blink::WebMouseEvent::ButtonNone, webkit_event.button); | |
| 485 EXPECT_EQ(blink::WebInputEvent::MouseWheel, webkit_event.type); | |
| 486 EXPECT_FLOAT_EQ(aura_event.x_offset() / 53.0f, webkit_event.wheelTicksX); | |
| 487 EXPECT_FLOAT_EQ(aura_event.y_offset() / 53.0f, webkit_event.wheelTicksY); | |
| 488 EXPECT_EQ(blink::WebPointerProperties::PointerType::Mouse, | |
| 489 webkit_event.pointerType); | |
| 490 EXPECT_EQ(0, webkit_event.tiltX); | |
| 491 EXPECT_EQ(0, webkit_event.tiltY); | |
| 492 EXPECT_TRUE(std::isnan(webkit_event.force)); | |
| 493 EXPECT_EQ(123, webkit_event.x); | |
| 494 EXPECT_EQ(123, webkit_event.windowX); | |
| 495 EXPECT_EQ(321, webkit_event.y); | |
| 496 EXPECT_EQ(321, webkit_event.windowY); | |
| 497 } | |
| 498 { | |
| 499 // Mouse wheel with shift and no x offset. | |
| 500 base::TimeTicks timestamp = ui::EventTimeForNow(); | |
| 501 ui::MouseWheelEvent aura_event( | |
| 502 gfx::Vector2d(0, -ui::MouseWheelEvent::kWheelDelta * 2), | |
| 503 gfx::Point(123, 321), gfx::Point(123, 321), timestamp, | |
| 504 ui::EF_SHIFT_DOWN, 0); | |
| 505 blink::WebMouseWheelEvent webkit_event = MakeWebMouseWheelEvent(aura_event); | |
| 506 EXPECT_EQ(ui::EventFlagsToWebEventModifiers(aura_event.flags()), | |
| 507 webkit_event.modifiers); | |
| 508 EXPECT_FLOAT_EQ(ui::EventTimeStampToSeconds(timestamp), | |
| 509 webkit_event.timeStampSeconds); | |
| 510 EXPECT_EQ(blink::WebMouseEvent::ButtonNone, webkit_event.button); | |
| 511 EXPECT_EQ(blink::WebInputEvent::MouseWheel, webkit_event.type); | |
| 512 EXPECT_FLOAT_EQ(aura_event.y_offset() / 53.0f, webkit_event.wheelTicksX); | |
| 513 EXPECT_FLOAT_EQ(0, webkit_event.wheelTicksY); | |
| 514 EXPECT_EQ(blink::WebPointerProperties::PointerType::Mouse, | |
| 515 webkit_event.pointerType); | |
| 516 EXPECT_EQ(0, webkit_event.tiltX); | |
| 517 EXPECT_EQ(0, webkit_event.tiltY); | |
| 518 EXPECT_TRUE(std::isnan(webkit_event.force)); | |
| 519 EXPECT_EQ(123, webkit_event.x); | |
| 520 EXPECT_EQ(123, webkit_event.windowX); | |
| 521 EXPECT_EQ(321, webkit_event.y); | |
| 522 EXPECT_EQ(321, webkit_event.windowY); | |
| 523 } | |
| 524 } | |
| 525 | |
| 526 } // namespace content | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2234023002:
Refactor WebInputEventAura to ui/events/blink (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master