Distinguish between keystroke and character events.

ui/events/x/events_x_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 <cstring>
 #include <set>
 
 #include <X11/extensions/XInput2.h>
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 #include <X11/XKBlib.h>
 
 // Generically-named #defines from Xlib that conflict with symbols in GTest.
 #undef Bool
 #undef None
 
 #include "base/memory/scoped_ptr.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/events/event.h"
 #include "ui/events/event_constants.h"
 #include "ui/events/event_utils.h"
+#include "ui/events/test/events_test_utils.h"
 #include "ui/events/test/events_test_utils_x11.h"
 #include "ui/events/x/device_data_manager_x11.h"
 #include "ui/events/x/touch_factory_x11.h"
 #include "ui/gfx/point.h"
 
 namespace ui {
 
 namespace {
 
 // Initializes the passed-in Xlib event.
@@ skipping 32 matching lines @@
 }
 
 // Returns true if the keysym maps to a KeyEvent with the EF_FUNCTION_KEY
 // flag set, or the keysym maps to a zero key code.
 bool HasFunctionKeyFlagSetIfSupported(Display* display, int x_keysym) {
   XEvent event;
   int x_keycode = XKeysymToKeycode(display, x_keysym);
   // Exclude keysyms for which the server has no corresponding keycode.
   if (x_keycode) {
     InitKeyEvent(display, &event, true, x_keycode, 0);
-    ui::KeyEvent ui_key_event(&event, false);
+    ui::KeyEvent ui_key_event(&event);
     return (ui_key_event.flags() & ui::EF_FUNCTION_KEY);
   }
   return true;
 }
 
 }  // namespace
 
 class EventsXTest : public testing::Test {
  public:
   EventsXTest() {}
@@ skipping 303 matching lines @@
     { false, XK_A },
   };
 
   for (size_t k = 0; k < ARRAYSIZE_UNSAFE(keys); ++k) {
     int x_keycode = XKeysymToKeycode(display, keys[k].x_keysym);
     // Exclude keysyms for which the server has no corresponding keycode.
     if (x_keycode) {
       InitKeyEvent(display, &event, true, x_keycode, 0);
       // int keysym = XLookupKeysym(&event.xkey, 0);
       // if (keysym) {
-      ui::KeyEvent ui_key_event(&event, false);
+      ui::KeyEvent ui_key_event(&event);
       EXPECT_EQ(keys[k].is_numpad_key ? ui::EF_NUMPAD_KEY : 0,
                 ui_key_event.flags() & ui::EF_NUMPAD_KEY);
     }
   }
 }
 
 TEST_F(EventsXTest, FunctionKeyEvents) {
   Display* display = gfx::GetXDisplay();
 
   // Min  function key code minus 1.
@@ skipping 103 matching lines @@
   Display* display = gfx::GetXDisplay();
 
   unsigned int state_to_be_fabricated[] = {
     0, ShiftMask, LockMask, ShiftMask | LockMask,
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(state_to_be_fabricated); ++i) {
     unsigned int state = state_to_be_fabricated[i];
     for (int is_char = 0; is_char < 2; ++is_char) {
       XEvent x_event;
       InitKeyEvent(display, &x_event, true, 0, state);
-      ui::KeyEvent key_event(&x_event, is_char);
+      ui::KeyEvent key_event(&x_event);
+      if (is_char) {
+        KeyEventTestApi test_event(&key_event);
+        test_event.set_is_char(true);
+      }
       EXPECT_TRUE(key_event.flags() & ui::EF_IME_FABRICATED_KEY);
     }
   }
 
   unsigned int state_to_be_not_fabricated[] = {
     ControlMask, Mod1Mask, Mod2Mask, ShiftMask | ControlMask,
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(state_to_be_not_fabricated); ++i) {
     unsigned int state = state_to_be_not_fabricated[i];
     for (int is_char = 0; is_char < 2; ++is_char) {
       XEvent x_event;
       InitKeyEvent(display, &x_event, true, 0, state);
-      ui::KeyEvent key_event(&x_event, is_char);
+      ui::KeyEvent key_event(&x_event);
+      if (is_char) {
+        KeyEventTestApi test_event(&key_event);
+        test_event.set_is_char(true);
+      }
       EXPECT_FALSE(key_event.flags() & ui::EF_IME_FABRICATED_KEY);
     }
   }
 }
 #endif
 
 }  // namespace ui