Distinguish between keystroke and character events.

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/dom4/keycode_converter.h"
 #include "ui/events/test/events_test_utils.h"
 
 #if defined(USE_X11)
 #include <X11/Xlib.h>
 #include "ui/events/test/events_test_utils_x11.h"
 #include "ui/gfx/x/x11_types.h"
 #endif
 
 namespace ui {
 
 TEST(EventTest, NoNativeEvent) {
-  KeyEvent keyev(ET_KEY_PRESSED, VKEY_SPACE, 0, false);
+  KeyEvent keyev(ET_KEY_PRESSED, VKEY_SPACE, EF_NONE);
   EXPECT_FALSE(keyev.HasNativeEvent());
 }
 
 TEST(EventTest, NativeEvent) {
 #if defined(OS_WIN)
   MSG native_event = { NULL, WM_KEYUP, VKEY_A, 0 };
-  KeyEvent keyev(native_event, false);
+  KeyEvent keyev(native_event);
   EXPECT_TRUE(keyev.HasNativeEvent());
 #elif defined(USE_X11)
   ScopedXI2Event event;
-  event.InitKeyEvent(ET_KEY_RELEASED, VKEY_A, 0);
-  KeyEvent keyev(event, false);
+  event.InitKeyEvent(ET_KEY_RELEASED, VKEY_A, EF_NONE);
+  KeyEvent keyev(event);
   EXPECT_TRUE(keyev.HasNativeEvent());
 #endif
 }
 
 TEST(EventTest, GetCharacter) {
   // Check if Control+Enter returns 10.
-  KeyEvent keyev1(ET_KEY_PRESSED, VKEY_RETURN, EF_CONTROL_DOWN, false);
+  KeyEvent keyev1(ET_KEY_PRESSED, VKEY_RETURN, EF_CONTROL_DOWN);
   EXPECT_EQ(10, keyev1.GetCharacter());
   // Check if Enter returns 13.
-  KeyEvent keyev2(ET_KEY_PRESSED, VKEY_RETURN, 0, false);
+  KeyEvent keyev2(ET_KEY_PRESSED, VKEY_RETURN, EF_NONE);
   EXPECT_EQ(13, keyev2.GetCharacter());
 
 #if defined(USE_X11)
   // For X11, test the functions with native_event() as well. crbug.com/107837
   ScopedXI2Event event;
   event.InitKeyEvent(ET_KEY_PRESSED, VKEY_RETURN, EF_CONTROL_DOWN);
-  KeyEvent keyev3(event, false);
+  KeyEvent keyev3(event);
   EXPECT_EQ(10, keyev3.GetCharacter());
 
-  event.InitKeyEvent(ET_KEY_PRESSED, VKEY_RETURN, 0);
-  KeyEvent keyev4(event, false);
+  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, 0, 0);
   for (int i = 1; i <=3 ; ++i) {
     mouseev.SetClickCount(i);
     EXPECT_EQ(i, mouseev.GetClickCount());
@@ skipping 166 matching lines @@
     { VKEY_OEM_COMMA, EF_SHIFT_DOWN, '<' },
     { VKEY_OEM_PERIOD, EF_CONTROL_DOWN, '\0' },
     { VKEY_OEM_PERIOD, EF_SHIFT_DOWN, '>' },
     { VKEY_OEM_3, EF_CONTROL_DOWN, '\0' },
     { VKEY_OEM_3, EF_SHIFT_DOWN, '~' },
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestData); ++i) {
     KeyEvent key(ET_KEY_PRESSED,
                  kTestData[i].key_code,
-                 kTestData[i].flags,
-                 false);
+                 kTestData[i].flags);
     EXPECT_EQ(kTestData[i].character, key.GetCharacter())
         << " Index:" << i << " key_code:" << kTestData[i].key_code;
   }
 }
 
 TEST(EventTest, KeyEventDirectUnicode) {
-  KeyEvent key(ET_KEY_PRESSED, VKEY_UNKNOWN, EF_SHIFT_DOWN, false);
-  key.set_character(0x1234U);
+  KeyEvent key(0x1234U, ui::VKEY_UNKNOWN, ui::EF_NONE);
   EXPECT_EQ(0x1234U, key.GetCharacter());
-  KeyEvent key2(ET_KEY_RELEASED, VKEY_UNKNOWN, EF_CONTROL_DOWN, false);
-  key2.set_character(0x4321U);
-  EXPECT_EQ(0x4321U, key2.GetCharacter());
+  EXPECT_EQ(ET_KEY_PRESSED, key.type());
+  EXPECT_TRUE(key.is_char());
 }
 
 TEST(EventTest, NormalizeKeyEventFlags) {
 #if defined(USE_X11)
   // Normalize flags when KeyEvent is created from XEvent.
   ScopedXI2Event event;
   {
     event.InitKeyEvent(ET_KEY_PRESSED, VKEY_SHIFT, EF_SHIFT_DOWN);
-    KeyEvent keyev(event, false);
+    KeyEvent keyev(event);
     EXPECT_EQ(EF_SHIFT_DOWN, keyev.flags());
   }
   {
     event.InitKeyEvent(ET_KEY_RELEASED, VKEY_SHIFT, EF_SHIFT_DOWN);
-    KeyEvent keyev(event, false);
+    KeyEvent keyev(event);
     EXPECT_EQ(EF_NONE, keyev.flags());
   }
   {
     event.InitKeyEvent(ET_KEY_PRESSED, VKEY_CONTROL, EF_CONTROL_DOWN);
-    KeyEvent keyev(event, false);
+    KeyEvent keyev(event);
     EXPECT_EQ(EF_CONTROL_DOWN, keyev.flags());
   }
   {
     event.InitKeyEvent(ET_KEY_RELEASED, VKEY_CONTROL, EF_CONTROL_DOWN);
-    KeyEvent keyev(event, false);
+    KeyEvent keyev(event);
     EXPECT_EQ(EF_NONE, keyev.flags());
   }
   {
     event.InitKeyEvent(ET_KEY_PRESSED, VKEY_MENU,  EF_ALT_DOWN);
-    KeyEvent keyev(event, false);
+    KeyEvent keyev(event);
     EXPECT_EQ(EF_ALT_DOWN, keyev.flags());
   }
   {
     event.InitKeyEvent(ET_KEY_RELEASED, VKEY_MENU, EF_ALT_DOWN);
-    KeyEvent keyev(event, false);
+    KeyEvent keyev(event);
     EXPECT_EQ(EF_NONE, keyev.flags());
   }
 #endif
 
   // Do not normalize flags for synthesized events without
   // KeyEvent::NormalizeFlags called explicitly.
   {
-    KeyEvent keyev(ET_KEY_PRESSED, VKEY_SHIFT, EF_SHIFT_DOWN, false);
+    KeyEvent keyev(ET_KEY_PRESSED, VKEY_SHIFT, EF_SHIFT_DOWN);
     EXPECT_EQ(EF_SHIFT_DOWN, keyev.flags());
   }
   {
-    KeyEvent keyev(ET_KEY_RELEASED, VKEY_SHIFT, EF_SHIFT_DOWN, false);
+    KeyEvent keyev(ET_KEY_RELEASED, VKEY_SHIFT, EF_SHIFT_DOWN);
     EXPECT_EQ(EF_SHIFT_DOWN, keyev.flags());
     keyev.NormalizeFlags();
     EXPECT_EQ(EF_NONE, keyev.flags());
   }
   {
-    KeyEvent keyev(ET_KEY_PRESSED, VKEY_CONTROL, EF_CONTROL_DOWN, false);
+    KeyEvent keyev(ET_KEY_PRESSED, VKEY_CONTROL, EF_CONTROL_DOWN);
     EXPECT_EQ(EF_CONTROL_DOWN, keyev.flags());
   }
   {
-    KeyEvent keyev(ET_KEY_RELEASED, VKEY_CONTROL, EF_CONTROL_DOWN, false);
+    KeyEvent keyev(ET_KEY_RELEASED, VKEY_CONTROL, EF_CONTROL_DOWN);
     EXPECT_EQ(EF_CONTROL_DOWN, keyev.flags());
     keyev.NormalizeFlags();
     EXPECT_EQ(EF_NONE, keyev.flags());
   }
   {
-    KeyEvent keyev(ET_KEY_PRESSED, VKEY_MENU,  EF_ALT_DOWN, false);
+    KeyEvent keyev(ET_KEY_PRESSED, VKEY_MENU,  EF_ALT_DOWN);
     EXPECT_EQ(EF_ALT_DOWN, keyev.flags());
   }
   {
-    KeyEvent keyev(ET_KEY_RELEASED, VKEY_MENU, EF_ALT_DOWN, false);
+    KeyEvent keyev(ET_KEY_RELEASED, VKEY_MENU, EF_ALT_DOWN);
     EXPECT_EQ(EF_ALT_DOWN, keyev.flags());
     keyev.NormalizeFlags();
     EXPECT_EQ(EF_NONE, keyev.flags());
   }
 }
 
 TEST(EventTest, KeyEventCopy) {
-  KeyEvent key(ET_KEY_PRESSED, VKEY_A, EF_NONE, false);
+  KeyEvent key(ET_KEY_PRESSED, VKEY_A, EF_NONE);
   scoped_ptr<KeyEvent> copied_key(new KeyEvent(key));
   EXPECT_EQ(copied_key->type(), key.type());
   EXPECT_EQ(copied_key->key_code(), key.key_code());
 }
 
 TEST(EventTest, KeyEventCode) {
   KeycodeConverter* conv = KeycodeConverter::GetInstance();
 
   const char kCodeForSpace[] = "Space";
   const uint16 kNativeCodeSpace = conv->CodeToNativeKeycode(kCodeForSpace);
   ASSERT_NE(conv->InvalidNativeKeycode(), kNativeCodeSpace);
 
   {
-    KeyEvent key(ET_KEY_PRESSED, VKEY_SPACE, kCodeForSpace, EF_NONE, false);
+    KeyEvent key(ET_KEY_PRESSED, VKEY_SPACE, kCodeForSpace, EF_NONE);
     EXPECT_EQ(kCodeForSpace, key.code());
   }
   {
     // Regardless the KeyEvent.key_code (VKEY_RETURN), code should be
     // the specified value.
-    KeyEvent key(ET_KEY_PRESSED, VKEY_RETURN, kCodeForSpace, EF_NONE, false);
+    KeyEvent key(ET_KEY_PRESSED, VKEY_RETURN, kCodeForSpace, EF_NONE);
     EXPECT_EQ(kCodeForSpace, key.code());
   }
   {
     // If the synthetic event is initialized without code, it returns
     // an empty string.
     // TODO(komatsu): Fill a fallback value assuming the US keyboard layout.
-    KeyEvent key(ET_KEY_PRESSED, VKEY_SPACE, EF_NONE, false);
+    KeyEvent key(ET_KEY_PRESSED, VKEY_SPACE, EF_NONE);
     EXPECT_TRUE(key.code().empty());
   }
 #if defined(USE_X11)
   {
     // KeyEvent converts from the native keycode (XKB) to the code.
     ScopedXI2Event xevent;
     xevent.InitKeyEvent(ET_KEY_PRESSED, VKEY_SPACE, kNativeCodeSpace);
-    KeyEvent key(xevent, false);
+    KeyEvent key(xevent);
     EXPECT_EQ(kCodeForSpace, key.code());
   }
 #endif  // USE_X11
 #if defined(OS_WIN)
   {
     // Test a non extended key.
     ASSERT_EQ((kNativeCodeSpace & 0xFF), kNativeCodeSpace);
 
     const LPARAM lParam = GetLParamFromScanCode(kNativeCodeSpace);
     MSG native_event = { NULL, WM_KEYUP, VKEY_SPACE, lParam };
-    KeyEvent key(native_event, false);
+    KeyEvent key(native_event);
 
     // KeyEvent converts from the native keycode (scan code) to the code.
     EXPECT_EQ(kCodeForSpace, key.code());
   }
   {
     const char kCodeForHome[]  = "Home";
     const uint16 kNativeCodeHome  = 0xe047;
 
     // 'Home' is an extended key with 0xe000 bits.
     ASSERT_NE((kNativeCodeHome & 0xFF), kNativeCodeHome);
     const LPARAM lParam = GetLParamFromScanCode(kNativeCodeHome);
 
     MSG native_event = { NULL, WM_KEYUP, VKEY_HOME, lParam };
-    KeyEvent key(native_event, false);
+    KeyEvent key(native_event);
 
     // KeyEvent converts from the native keycode (scan code) to the code.
     EXPECT_EQ(kCodeForHome, key.code());
   }
 #endif  // OS_WIN
 }
 
 #if defined(USE_X11) || defined(OS_WIN)
 TEST(EventTest, AutoRepeat) {
   KeycodeConverter* conv = KeycodeConverter::GetInstance();
@@ skipping 13 matching lines @@
   // IBUS-GTK uses the mask (1 << 25) to detect reposted event.
   static_cast<XEvent*>(native_event_a_pressed_nonstandard_state)->xkey.state |=
       1 << 25;
 #elif defined(OS_WIN)
   const LPARAM lParam_a = GetLParamFromScanCode(kNativeCodeA);
   const LPARAM lParam_b = GetLParamFromScanCode(kNativeCodeB);
   MSG native_event_a_pressed = { NULL, WM_KEYDOWN, VKEY_A, lParam_a };
   MSG native_event_a_released = { NULL, WM_KEYUP, VKEY_A, lParam_a };
   MSG native_event_b_pressed = { NULL, WM_KEYUP, VKEY_B, lParam_b };
 #endif
-  KeyEvent key_a1(native_event_a_pressed, false);
+  KeyEvent key_a1(native_event_a_pressed);
   EXPECT_FALSE(key_a1.IsRepeat());
-  KeyEvent key_a1_released(native_event_a_released, false);
+  KeyEvent key_a1_released(native_event_a_released);
   EXPECT_FALSE(key_a1_released.IsRepeat());
 
-  KeyEvent key_a2(native_event_a_pressed, false);
+  KeyEvent key_a2(native_event_a_pressed);
   EXPECT_FALSE(key_a2.IsRepeat());
-  KeyEvent key_a2_repeated(native_event_a_pressed, false);
+  KeyEvent key_a2_repeated(native_event_a_pressed);
   EXPECT_TRUE(key_a2_repeated.IsRepeat());
-  KeyEvent key_a2_released(native_event_a_released, false);
+  KeyEvent key_a2_released(native_event_a_released);
   EXPECT_FALSE(key_a2_released.IsRepeat());
 
-  KeyEvent key_a3(native_event_a_pressed, false);
+  KeyEvent key_a3(native_event_a_pressed);
   EXPECT_FALSE(key_a3.IsRepeat());
-  KeyEvent key_b(native_event_b_pressed, false);
+  KeyEvent key_b(native_event_b_pressed);
   EXPECT_FALSE(key_b.IsRepeat());
-  KeyEvent key_a3_again(native_event_a_pressed, false);
+  KeyEvent key_a3_again(native_event_a_pressed);
   EXPECT_FALSE(key_a3_again.IsRepeat());
-  KeyEvent key_a3_repeated(native_event_a_pressed, false);
+  KeyEvent key_a3_repeated(native_event_a_pressed);
   EXPECT_TRUE(key_a3_repeated.IsRepeat());
-  KeyEvent key_a3_repeated2(native_event_a_pressed, false);
+  KeyEvent key_a3_repeated2(native_event_a_pressed);
   EXPECT_TRUE(key_a3_repeated2.IsRepeat());
-  KeyEvent key_a3_released(native_event_a_released, false);
+  KeyEvent key_a3_released(native_event_a_released);
   EXPECT_FALSE(key_a3_released.IsRepeat());
 
 #if defined(USE_X11)
-  KeyEvent key_a4_pressed(native_event_a_pressed, false);
+  KeyEvent key_a4_pressed(native_event_a_pressed);
   EXPECT_FALSE(key_a4_pressed.IsRepeat());
 
   KeyEvent key_a4_pressed_nonstandard_state(
-      native_event_a_pressed_nonstandard_state, false);
+      native_event_a_pressed_nonstandard_state);
   EXPECT_FALSE(key_a4_pressed_nonstandard_state.IsRepeat());
 #endif
 }
 #endif  // USE_X11 || OS_WIN
 
 }  // namespace ui