Bug 1784438 - Implement key repeat on wayland. r=masayuki

makotokato · makotokato · commit fae34b664e91 · 2025-02-04T04:37:03.000Z
When running Firefox on wayland, we don't set key repeat flag. We should set this flag during repeating key. Differential Revision: https://phabricator.services.mozilla.com/D236097
diff --git a/widget/gtk/mozwayland/mozwayland.c b/widget/gtk/mozwayland/mozwayland.c
@@ -251,6 +251,10 @@ MOZ_EXPORT struct xkb_keymap* xkb_keymap_new_from_string(
   return NULL;
 }
 
+MOZ_EXPORT struct xkb_keymap* xkb_keymap_ref(struct xkb_keymap* keymap) {
+  return NULL;
+}
+
 MOZ_EXPORT void xkb_keymap_unref(struct xkb_keymap* keymap) {}
 
 MOZ_EXPORT const char* xkb_keymap_layout_get_name(struct xkb_keymap* keymap,
@@ -262,3 +266,8 @@ MOZ_EXPORT xkb_mod_index_t xkb_keymap_mod_get_index(struct xkb_keymap* keymap,
                                                     const char* name) {
   return XKB_MOD_INVALID;
 }
+
+MOZ_EXPORT int xkb_keymap_key_repeats(struct xkb_keymap* keymap,
+                                      xkb_keycode_t kc) {
+  return 0;
+}
diff --git a/widget/gtk/nsGtkKeyUtils.cpp b/widget/gtk/nsGtkKeyUtils.cpp
@@ -65,6 +65,10 @@ Time KeymapWrapper::sLastRepeatableKeyTime = 0;
 KeymapWrapper::RepeatState KeymapWrapper::sRepeatState =
     KeymapWrapper::NOT_PRESSED;
 
+#ifdef MOZ_WAYLAND
+uint32_t KeymapWrapper::sLastRepeatableSerial = 0;
+#endif
+
 static const char* GetBoolName(bool aBool) { return aBool ? "TRUE" : "FALSE"; }
 
 static const char* GetStatusName(nsEventStatus aStatus) {
@@ -665,6 +669,8 @@ void KeymapWrapper::SetModifierMasks(xkb_keymap* aKeymap) {
   keymapWrapper->SetModifierMask(aKeymap, INDEX_LEVEL3, "Level3");
   keymapWrapper->SetModifierMask(aKeymap, INDEX_LEVEL5, "Level5");
 
+  keymapWrapper->SetKeymap(aKeymap);
+
   MOZ_LOG(gKeyLog, LogLevel::Info,
           ("%p KeymapWrapper::SetModifierMasks, CapsLock=0x%X, NumLock=0x%X, "
            "ScrollLock=0x%X, Level3=0x%X, Level5=0x%X, "
@@ -707,6 +713,13 @@ void KeymapWrapper::HandleKeymap(uint32_t format, int fd, uint32_t size) {
   }
 
   struct xkb_context* xkb_context = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
+  if (!xkb_context) {
+    MOZ_LOG(gKeyLog, LogLevel::Info,
+            ("KeymapWrapper::HandleKeymap(): failed to get xkb_context!"));
+    close(fd);
+    return;
+  }
+
   struct xkb_keymap* keymap = xkb_keymap_new_from_string(
       xkb_context, mapString, XKB_KEYMAP_FORMAT_TEXT_V1,
       XKB_KEYMAP_COMPILE_NO_FLAGS);
@@ -717,6 +730,7 @@ void KeymapWrapper::HandleKeymap(uint32_t format, int fd, uint32_t size) {
   if (!keymap) {
     MOZ_LOG(gKeyLog, LogLevel::Info,
             ("KeymapWrapper::HandleKeymap(): Failed to compile keymap!"));
+    xkb_context_unref(xkb_context);
     return;
   }
 
@@ -731,6 +745,11 @@ void KeymapWrapper::HandleKeymap(uint32_t format, int fd, uint32_t size) {
 KeymapWrapper::~KeymapWrapper() {
 #ifdef MOZ_X11
   gdk_window_remove_filter(nullptr, FilterEvents, this);
+#endif
+#ifdef MOZ_WAYLAND
+  if (mXkbKeymap) {
+    xkb_keymap_unref(mXkbKeymap);
+  }
 #endif
   if (mOnKeysChangedSignalHandle) {
     g_signal_handler_disconnect(mGdkKeymap, mOnKeysChangedSignalHandle);
@@ -858,6 +877,87 @@ GdkFilterReturn KeymapWrapper::FilterEvents(GdkXEvent* aXEvent,
 }
 #endif
 
+#ifdef MOZ_WAYLAND
+// static
+void KeymapWrapper::KeyboardHandlerForWayland(uint32_t aSerial,
+                                              uint32_t aHardwareKeycode,
+                                              uint32_t aState) {
+  KeymapWrapper* keymapWrapper = GetInstance();
+  if (!keymapWrapper->IsAutoRepeatableKey(aHardwareKeycode)) {
+    MOZ_LOG(gKeyLog, LogLevel::Info,
+            ("KeyboardHandlerForWayland(aSerial=%u, aHardwareKeycode=0x%08X, "
+             "aState=%s), no repeat key",
+             aSerial, aHardwareKeycode,
+             aState == WL_KEYBOARD_KEY_STATE_PRESSED
+                 ? "WL_KEYBOARD_KEY_STATE_PRESSED"
+                 : "WL_KEYBOARD_KEY_STATE_RELEASED"));
+    return;
+  }
+
+  if (aState == WL_KEYBOARD_KEY_STATE_PRESSED) {
+    MOZ_LOG(gKeyLog, LogLevel::Info,
+            ("KeyboardHandlerForWayland(aSerial=%u, aHardwareKeycode=0x%08X, "
+             "aState=WL_KEYBOARD_KEY_STATE_PRESSED), first key pressed",
+             aSerial, aHardwareKeycode));
+
+    sLastRepeatableSerial = aSerial;
+    sLastRepeatableHardwareKeyCode = aHardwareKeycode;
+    sRepeatState = FIRST_PRESS;
+
+    // This runnable will be run after GDK's key event.
+    //
+    // Next key press of GDK will be after repeat's delay ms.
+    // But event time in next key press wonn't updated.
+    //
+    // The delay's default is 400ms in GTK/wayland. Even if we can get this
+    // information from repeat_info, if we wait for this time, it is too late.
+    // We guess that 10ms will be enough durration to set repeat state.
+
+    NS_DelayedDispatchToCurrentThread(
+        NS_NewRunnableFunction(
+            __func__,
+            [aSerial] {
+              if (sLastRepeatableSerial != aSerial) {
+                // We already receive newer key event. Don't set repeat state.
+                return;
+              }
+
+              MOZ_LOG(gKeyLog, LogLevel::Info,
+                      ("KeyboardHandlerForWayland(aSerial=%u, "
+                       "aState=WL_KEYBOARD_KEY_STATE_PRESSED), repeating",
+                       aSerial));
+              sRepeatState = REPEATING;
+            }),
+        10);
+    return;
+  }
+
+  if (sLastRepeatableHardwareKeyCode != aHardwareKeycode) {
+    MOZ_LOG(gKeyLog, LogLevel::Info,
+            ("KeyboardHandlerForWayland(aSerial=%u, aHardwareKeycode=0x%08X "
+             "aState=WL_KEYBOARD_KEY_STATE_RELEASED), released key isn't "
+             "matched",
+             aSerial, aHardwareKeycode));
+    return;
+  }
+
+  MOZ_LOG(gKeyLog, LogLevel::Info,
+          ("KeyboardHandlerForWayland(aSerial=%u, aHardwareKeycode=0x%08X"
+           "aState=WL_KEYBOARD_KEY_STATE_RELEASED), not pressed",
+           aSerial, aHardwareKeycode));
+
+  sLastRepeatableSerial = aSerial;
+  sRepeatState = NOT_PRESSED;
+}
+
+void KeymapWrapper::SetKeymap(xkb_keymap* aKeymap) {
+  if (mXkbKeymap) {
+    xkb_keymap_unref(mXkbKeymap);
+  }
+  mXkbKeymap = xkb_keymap_ref(aKeymap);
+}
+#endif
+
 static void ResetBidiKeyboard() {
   // Reset the bidi keyboard settings for the new GdkKeymap
   nsCOMPtr<nsIBidiKeyboard> bidiKeyboard = nsContentUtils::GetBidiKeyboard();
@@ -2033,15 +2133,28 @@ bool KeymapWrapper::IsLatinGroup(guint8 aGroup) {
 }
 
 bool KeymapWrapper::IsAutoRepeatableKey(guint aHardwareKeyCode) {
+  GdkDisplay* gdkDisplay = gdk_display_get_default();
 #ifdef MOZ_X11
-  uint8_t indexOfArray = aHardwareKeyCode / 8;
-  MOZ_ASSERT(indexOfArray < std::size(mKeyboardState.auto_repeats),
-             "invalid index");
-  char bitMask = 1 << (aHardwareKeyCode % 8);
-  return (mKeyboardState.auto_repeats[indexOfArray] & bitMask) != 0;
-#else
-  return false;
+  if (GdkIsX11Display(gdkDisplay)) {
+    uint8_t indexOfArray = aHardwareKeyCode / 8;
+    MOZ_ASSERT(indexOfArray < std::size(mKeyboardState.auto_repeats),
+               "invalid index");
+    char bitMask = 1 << (aHardwareKeyCode % 8);
+    return (mKeyboardState.auto_repeats[indexOfArray] & bitMask) != 0;
+  }
+#endif
+#ifdef MOZ_WAYLAND
+  if (GdkIsWaylandDisplay(gdkDisplay)) {
+    if (MOZ_UNLIKELY(!mXkbKeymap)) {
+      static bool sWarned = false;
+      NS_WARNING_ASSERTION(sWarned, "no keymap!");
+      sWarned = true;
+      return false;
+    }
+    return !!xkb_keymap_key_repeats(mXkbKeymap, aHardwareKeyCode);
+  }
 #endif
+  return false;
 }
 
 /* static */
@@ -2646,6 +2759,8 @@ void KeymapWrapper::SetFocusOut(wl_surface* aFocusSurface) {
 
   keymapWrapper->mFocusSurface = nullptr;
   keymapWrapper->mFocusSerial = 0;
+
+  sRepeatState = NOT_PRESSED;
 }
 
 void KeymapWrapper::GetFocusInfo(wl_surface** aFocusSurface,
@@ -2654,6 +2769,14 @@ void KeymapWrapper::GetFocusInfo(wl_surface** aFocusSurface,
   *aFocusSurface = keymapWrapper->mFocusSurface;
   *aFocusSerial = keymapWrapper->mFocusSerial;
 }
+
+void KeymapWrapper::ClearKeymap() {
+  KeymapWrapper* keymapWrapper = KeymapWrapper::GetInstance();
+  if (keymapWrapper->mXkbKeymap) {
+    xkb_keymap_unref(keymapWrapper->mXkbKeymap);
+    keymapWrapper->mXkbKeymap = nullptr;
+  }
+}
 #endif
 
 }  // namespace widget
diff --git a/widget/gtk/nsGtkKeyUtils.h b/widget/gtk/nsGtkKeyUtils.h
@@ -207,9 +207,13 @@ class KeymapWrapper {
   static void SetFocusOut(wl_surface* aFocusSurface);
   static void GetFocusInfo(wl_surface** aFocusSurface, uint32_t* aFocusSerial);
 
-  static void SetKeyboard(wl_keyboard* aKeyboard);
-  static wl_keyboard* GetKeyboard();
-  static void ClearKeyboard();
+  /**
+   * Key repeat helpers for Wayland
+   */
+  static void KeyboardHandlerForWayland(uint32_t aSerial,
+                                        uint32_t aHardwareKeycode,
+                                        uint32_t aState);
+  static void ClearKeymap();
 
   /**
    * EnsureInstance() is provided on Wayland to register Wayland callbacks
@@ -350,12 +354,24 @@ class KeymapWrapper {
   enum RepeatState { NOT_PRESSED, FIRST_PRESS, REPEATING };
   static RepeatState sRepeatState;
 
+#ifdef MOZ_WAYLAND
+  xkb_keymap* mXkbKeymap = nullptr;
+  static uint32_t sLastRepeatableSerial;
+#endif
+
   /**
    * IsAutoRepeatableKey() returns true if the key supports auto repeat.
    * Otherwise, false.
    */
   bool IsAutoRepeatableKey(guint aHardwareKeyCode);
 
+#ifdef MOZ_WAYLAND
+  /**
+   * Set current xkb_keymap to detect auto repeat key on Wayland.
+   */
+  void SetKeymap(xkb_keymap* aKeymap);
+#endif
+
   /**
    * Signal handlers.
    */
diff --git a/widget/gtk/nsWaylandDisplay.cpp b/widget/gtk/nsWaylandDisplay.cpp
@@ -342,7 +342,12 @@ static void keyboard_handle_leave(void* data, struct wl_keyboard* keyboard,
 
 static void keyboard_handle_key(void* data, struct wl_keyboard* keyboard,
                                 uint32_t serial, uint32_t time, uint32_t key,
-                                uint32_t state) {}
+                                uint32_t state) {
+  // hardware key code is +8.
+  // https://gitlab.gnome.org/GNOME/gtk/-/blob/3.24.41/gdk/wayland/gdkdevice-wayland.c#L2341
+  KeymapWrapper::KeyboardHandlerForWayland(serial, key + 8, state);
+}
+
 static void keyboard_handle_modifiers(void* data, struct wl_keyboard* keyboard,
                                       uint32_t serial, uint32_t mods_depressed,
                                       uint32_t mods_latched,
@@ -367,6 +372,7 @@ void nsWaylandDisplay::ClearKeyboard() {
   if (mKeyboard) {
     wl_keyboard_destroy(mKeyboard);
     mKeyboard = nullptr;
+    KeymapWrapper::ClearKeymap();
   }
 }
 
