Revert of Remove EF_FUNCTION_KEY and EF_NUMPAD_KEY.

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>
@@ skipping 29 matching lines @@
   // We don't bother setting fields that the event code doesn't use, such as
   // x_root/y_root and window/root/subwindow.
   XButtonEvent* button_event = &(event->xbutton);
   button_event->type = is_press ? ButtonPress : ButtonRelease;
   button_event->x = location.x();
   button_event->y = location.y();
   button_event->button = button;
   button_event->state = state;
 }
 
-#if !defined(OS_CHROMEOS)
 // Initializes the passed-in Xlib event.
 void InitKeyEvent(Display* display,
                   XEvent* event,
                   bool is_press,
                   int keycode,
                   int state) {
   memset(event, 0, sizeof(*event));
 
   // We don't bother setting fields that the event code doesn't use, such as
   // x_root/y_root and window/root/subwindow.
   XKeyEvent* key_event = &(event->xkey);
   key_event->display = display;
   key_event->type = is_press ? KeyPress : KeyRelease;
   key_event->keycode = keycode;
   key_event->state = state;
 }
-#endif
+
+// 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);
+    return (ui_key_event.flags() & ui::EF_FUNCTION_KEY);
+  }
+  return true;
+}
 
 }  // namespace
 
 class EventsXTest : public testing::Test {
  public:
   EventsXTest() {}
   ~EventsXTest() override {}
 
   void SetUp() override {
     DeviceDataManagerX11::CreateInstance();
@@ skipping 280 matching lines @@
   ui::ScopedXI2Event xrelease0;
   xrelease0.InitTouchEvent(0, XI_TouchEnd, 0, gfx::Point(10, 10), valuators);
   ui::TouchEvent urelease0(xrelease0);
   {
     // When the copy is destructed it should not attempt to remove the mapping.
     // Exiting this scope should not cause a crash.
     ui::TouchEvent copy = urelease0;
   }
 }
 
+TEST_F(EventsXTest, NumpadKeyEvents) {
+  XEvent event;
+  Display* display = gfx::GetXDisplay();
+
+  struct {
+    bool is_numpad_key;
+    int x_keysym;
+  } keys[] = {
+    // XK_KP_Space and XK_KP_Equal are the extrema in the conventional
+    // keysymdef.h numbering.
+    { true,  XK_KP_Space },
+    { true,  XK_KP_Equal },
+    // Other numpad keysyms. (This is actually exhaustive in the current list.)
+    { true,  XK_KP_Tab },
+    { true,  XK_KP_Enter },
+    { true,  XK_KP_F1 },
+    { true,  XK_KP_F2 },
+    { true,  XK_KP_F3 },
+    { true,  XK_KP_F4 },
+    { true,  XK_KP_Home },
+    { true,  XK_KP_Left },
+    { true,  XK_KP_Up },
+    { true,  XK_KP_Right },
+    { true,  XK_KP_Down },
+    { true,  XK_KP_Prior },
+    { true,  XK_KP_Page_Up },
+    { true,  XK_KP_Next },
+    { true,  XK_KP_Page_Down },
+    { true,  XK_KP_End },
+    { true,  XK_KP_Begin },
+    { true,  XK_KP_Insert },
+    { true,  XK_KP_Delete },
+    { true,  XK_KP_Multiply },
+    { true,  XK_KP_Add },
+    { true,  XK_KP_Separator },
+    { true,  XK_KP_Subtract },
+    { true,  XK_KP_Decimal },
+    { true,  XK_KP_Divide },
+    { true,  XK_KP_0 },
+    { true,  XK_KP_1 },
+    { true,  XK_KP_2 },
+    { true,  XK_KP_3 },
+    { true,  XK_KP_4 },
+    { true,  XK_KP_5 },
+    { true,  XK_KP_6 },
+    { true,  XK_KP_7 },
+    { true,  XK_KP_8 },
+    { true,  XK_KP_9 },
+    // Largest keysym preceding XK_KP_Space.
+    { false, XK_Num_Lock },
+    // Smallest keysym following XK_KP_Equal.
+    { false, XK_F1 },
+    // Non-numpad analogues of numpad keysyms.
+    { false, XK_Tab },
+    { false, XK_Return },
+    { false, XK_F1 },
+    { false, XK_F2 },
+    { false, XK_F3 },
+    { false, XK_F4 },
+    { false, XK_Home },
+    { false, XK_Left },
+    { false, XK_Up },
+    { false, XK_Right },
+    { false, XK_Down },
+    { false, XK_Prior },
+    { false, XK_Page_Up },
+    { false, XK_Next },
+    { false, XK_Page_Down },
+    { false, XK_End },
+    { false, XK_Insert },
+    { false, XK_Delete },
+    { false, XK_multiply },
+    { false, XK_plus },
+    { false, XK_minus },
+    { false, XK_period },
+    { false, XK_slash },
+    { false, XK_0 },
+    { false, XK_1 },
+    { false, XK_2 },
+    { false, XK_3 },
+    { false, XK_4 },
+    { false, XK_5 },
+    { false, XK_6 },
+    { false, XK_7 },
+    { false, XK_8 },
+    { false, XK_9 },
+    // Miscellaneous other keysyms.
+    { false, XK_BackSpace },
+    { false, XK_Scroll_Lock },
+    { false, XK_Multi_key },
+    { false, XK_Select },
+    { false, XK_Num_Lock },
+    { false, XK_Shift_L },
+    { false, XK_space },
+    { false, XK_A },
+  };
+
+  for (size_t k = 0; k < arraysize(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);
+      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.
+  EXPECT_FALSE(HasFunctionKeyFlagSetIfSupported(display, XK_F1 - 1));
+  // All function keys.
+  EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F1));
+  EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F2));
+  EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F3));
+  EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F4));
+  EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F5));
+  EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F6));
+  EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F7));
+  EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F8));
+  EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F9));
+  EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F10));
+  EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F11));
+  EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F12));
+  EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F13));
+  EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F14));
+  EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F15));
+  EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F16));
+  EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F17));
+  EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F18));
+  EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F19));
+  EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F20));
+  EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F21));
+  EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F22));
+  EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F23));
+  EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F24));
+  EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F25));
+  EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F26));
+  EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F27));
+  EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F28));
+  EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F29));
+  EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F30));
+  EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F31));
+  EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F32));
+  EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F33));
+  EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F34));
+  EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F35));
+  // Max function key code plus 1.
+  EXPECT_FALSE(HasFunctionKeyFlagSetIfSupported(display, XK_F35 + 1));
+}
+
 // Verifies that the type of events from a disabled keyboard is ET_UNKNOWN, but
 // that an exception list of keys can still be processed.
 TEST_F(EventsXTest, DisableKeyboard) {
   DeviceDataManagerX11* device_data_manager =
       static_cast<DeviceDataManagerX11*>(
           DeviceDataManager::GetInstance());
   int blocked_device_id = 1;
   int other_device_id = 2;
   int master_device_id = 3;
   device_data_manager->DisableDevice(blocked_device_id);
@@ skipping 109 matching lines @@
         KeyEventTestApi test_event(&key_event);
         test_event.set_is_char(true);
       }
       EXPECT_FALSE(key_event.flags() & ui::EF_IME_FABRICATED_KEY);
     }
   }
 }
 #endif
 
 }  // namespace ui