content/browser/renderer_host/web_input_event_aura_unittest.cc

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