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)

[sadrul, 2015/05/04 17:31:01]

?

[kpschoedel, 2015/05/04 17:49:19]

With the removal of EventsXTest.NumpadKeyEvents this is only called under
OS_CHROMEOS, yielding an unused-function error.

 // 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;
 }
-
-// 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;
-}
+#endif
 
 }  // 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