Use rewriting to make ChromeOS keyboard F<number> keys produce extended keycodes.

chrome/browser/ui/ash/event_rewriter.cc

Index: chrome/browser/ui/ash/event_rewriter.cc
diff --git a/chrome/browser/ui/ash/event_rewriter.cc b/chrome/browser/ui/ash/event_rewriter.cc
index 759bc0c51b44ae4d45a4e8bf00334affa42fc1e3..03c1441f2b8e73dbd4d1578fe451f960a870c332 100644
--- a/chrome/browser/ui/ash/event_rewriter.cc
+++ b/chrome/browser/ui/ash/event_rewriter.cc
@@ -308,6 +308,18 @@ void EventRewriter::RefreshKeycodes() {
   f10_xkeycode_ = XKeysymToKeycode(display, XK_F10);
   f11_xkeycode_ = XKeysymToKeycode(display, XK_F11);
   f12_xkeycode_ = XKeysymToKeycode(display, XK_F12);
+  browser_back_xkeycode_ = XKeysymToKeycode(display, XF86XK_Back);
+  browser_forward_xkeycode_ = XKeysymToKeycode(display, XF86XK_Forward);
+  browser_refresh_xkeycode_ = XKeysymToKeycode(display, XF86XK_Reload);
+  media_launch_app1_xkeycode_ = XKeysymToKeycode(display, XF86XK_LaunchA);
+  media_launch_app2_xkeycode_ = XKeysymToKeycode(display, XF86XK_LaunchB);
+  brightness_down_xkeycode_ =
+      XKeysymToKeycode(display, XF86XK_MonBrightnessDown);
+  brightness_up_xkeycode_ = XKeysymToKeycode(display, XF86XK_MonBrightnessUp);
+  volume_mute_xkeycode_ = XKeysymToKeycode(display, XF86XK_AudioMute);
+  volume_down_xkeycode_ = XKeysymToKeycode(display, XF86XK_AudioLowerVolume);
+  volume_up_xkeycode_ = XKeysymToKeycode(display, XF86XK_AudioRaiseVolume);
+  power_xkeycode_ = XKeysymToKeycode(display, XF86XK_PowerOff);
 }
 
 KeyCode EventRewriter::NativeKeySymToNativeKeycode(KeySym keysym) {
@@ -382,6 +394,7 @@ ash::EventRewriterDelegate::Action EventRewriter::Rewrite(ui::KeyEvent* event) {
   RewriteModifiers(event);
   RewriteNumPadKeys(event);
   RewriteBackspaceAndArrowKeys(event);
+  RewriteFunctionKeys(event);
   return ash::EventRewriterDelegate::ACTION_REWRITE_EVENT;
 }
 
@@ -737,6 +750,183 @@ bool EventRewriter::RewriteBackspaceAndArrowKeys(ui::KeyEvent* event) {
   return rewritten;
 }
 
+bool EventRewriter::RewriteFunctionKeys(ui::KeyEvent* event) {
+#if defined(OS_CHROMEOS)
+  XEvent* xev = event->native_event();
+  XKeyEvent* xkey = &(xev->xkey);
+  const KeySym keysym = XLookupKeysym(xkey, 0);
+
+  KeyCode remapped_native_keycode = 0;
+  ui::KeyboardCode remapped_keycode = ui::VKEY_UNKNOWN;
+  unsigned int remapped_native_state = xkey->state;
+  int remapped_flags = event->flags();
+
+  // On a ChromeOS keyboard, F<number> keys have special purposes. On other

[Yusuke Sato, 2012/11/26 07:28:19]

What's the expected behavior when Stumpy is used with a generic PC keyboard?
Please add a comment for that case.

[danakj, 2012/11/26 17:50:38]

Stumpy should not --has-chromeos-keyboard, so it should not do any rewriting
here on a stumpy. I can add a comment that "ChromeOS keyboard" means a
chromebook keyboard.

Hopefully I am understanding the flag correctly.

[Yusuke Sato, 2012/11/26 19:00:00]

Sorry: I thought that HasChromeOSKeyboard() was a new function you added, but it
was not true. It was a function I added a while ago..

But anyway, calling the function wouldn't be good in this case because the
function returns false on Parrot (Acer $199 model) although the model has Chrome
OS style top-row keys. How about removing line 767-768 (and possibly rewriting
764-765)? Leaving the TODO comment seems to be good enough for now.


Details: The name might be a bit confusing, but --has-chromeos-keyborad is used
when the device has the same keyboard as Mario (i.e. Search instead of Caps
Lock). So Mario/Alex/ZGB/Lumpy/Lucas have the flag, but Parrot (Acer $199 model
which does have Caps Lock) and Stumpy do not.

[danakj, 2012/11/26 19:07:17]

Ok. I will had an EventSourceIsChromebookKeyboard() method with a TODO, that
just returns true for now. So we'll have  a clear path to check for
internal/external keyboards in the future.

Thanks for the explanation.

+  // keyboards they should act as usual.
+  // TODO(danakj): Early out here when the event came from an external keyboard.
+  if (!HasChromeOSKeyboard())
+    return false;
+
+  // Rewrite the actual F1-F12 keys on a ChromeOS keyboard to special keys.
+  switch (keysym) {
+    case XK_F1:
+      // Remap F1 to BROWSER_BACK
+      remapped_native_keycode = browser_back_xkeycode_;
+      remapped_keycode = ui::VKEY_BROWSER_BACK;
+      break;
+    case XK_F2:
+      // Remap F2 to BROWSER_FORWARD
+      remapped_native_keycode = browser_forward_xkeycode_;
+      remapped_keycode = ui::VKEY_BROWSER_FORWARD;
+      break;
+    case XK_F3:
+      // Remap F3 to BROWSER_REFRESH
+      remapped_native_keycode = browser_refresh_xkeycode_;
+      remapped_keycode = ui::VKEY_BROWSER_REFRESH;
+      break;
+    case XK_F4:
+      // Remap F4 to MEDIA_LAUNCH_APP2
+      remapped_native_keycode = media_launch_app2_xkeycode_;
+      remapped_keycode = ui::VKEY_MEDIA_LAUNCH_APP2;
+      break;
+    case XK_F5:
+      // Remap F5 to MEDIA_LAUNCH_APP1
+      remapped_native_keycode = media_launch_app1_xkeycode_;
+      remapped_keycode = ui::VKEY_MEDIA_LAUNCH_APP1;
+      break;
+    case XK_F6:
+      // Remap F6 to BRIGHTNESS_DOWN
+      remapped_native_keycode = brightness_down_xkeycode_;
+      remapped_keycode = ui::VKEY_BRIGHTNESS_DOWN;
+      break;
+    case XK_F7:
+      // Remap F7 to BRIGHTNESS_UP
+      remapped_native_keycode = brightness_up_xkeycode_;
+      remapped_keycode = ui::VKEY_BRIGHTNESS_UP;
+      break;
+    case XK_F8:
+      // Remap F8 to VOLUME_MUTE
+      remapped_native_keycode = volume_mute_xkeycode_;
+      remapped_keycode = ui::VKEY_VOLUME_MUTE;
+      break;
+    case XK_F9:
+      // Remap F9 to VOLUME_DOWN
+      remapped_native_keycode = volume_down_xkeycode_;
+      remapped_keycode = ui::VKEY_VOLUME_DOWN;
+      break;
+    case XK_F10:
+      // Remap F10 to VOLUME_UP
+      remapped_native_keycode = volume_up_xkeycode_;
+      remapped_keycode = ui::VKEY_VOLUME_UP;
+      break;
+    case XK_F11:
+      // Remap F11 to POWER
+      remapped_native_keycode = power_xkeycode_;
+      remapped_keycode = ui::VKEY_POWER;
+      break;
+    default:
+      break;
+  }
+
+  const PrefService* pref_service =
+      pref_service_ ? pref_service_ : GetPrefService();
+
+  const bool search_as_function_key = pref_service &&
+      pref_service->GetBoolean(prefs::kLanguageSearchKeyActsAsFunctionKey);
+
+  // When using Search as a Function key, remap Search+<number> to F<number>.
+  if (search_as_function_key && xkey->state & Mod4Mask) {
+    switch (keysym) {
+      case XK_1:

[Yusuke Sato, 2012/11/26 07:28:19]

This is very dirty, but probably we should check |native_event()->xkey.keycode|
here rather than X keysym because otherwise we are not able to send Shift+F1 to
an app. Please note that Shift+1 generates XK_exclam, not XK_1.

Similarly, I guess many i18n keyboard layouts that require ShiftMask to generate
XK_1 (such as http://en.wikipedia.org/wiki/Keyboard_layout#French ) are not able
to send F1 to an app. In that case, only Shift+F1 can be sent to an app.

(BTW, if you have a better solution for this, please let me know. Checking X
keycode is not a very clean solution... Since X keycode is actually defined
outside X11 as Wez mentioned, we might end up writing Chrome OS autotests to
prevent regressions. Currently X keycode is defined by Linux kernel module
called evdev, but X server might use other module in the future, or numbers
defined by the kernel might change in the future.)

[danakj, 2012/11/26 21:08:38]

Ok this sounds reasonable. If we check that keycode == XKeySymToKeyCode(XK_1),
then Search-1 does the right thing on US keyboards. And Search-<whatever> will
send F1, where <whatever> would generate a "1" with some modifier set. That way
those keyboards can also pass F1 and Shift-F1 etc.

It's still really US-centric for F11/F12, as "-" and "=" might not be in the
same position beside "0", but it's a start.

Done.

+        // Remap Search+1 to F1.
+        remapped_native_keycode = f1_xkeycode_;
+        remapped_keycode = ui::VKEY_F1;
+        remapped_native_state &= ~Mod4Mask;
+        break;
+      case XK_2:
+        // Remap Search+2 to F2.
+        remapped_native_keycode = f2_xkeycode_;
+        remapped_keycode = ui::VKEY_F2;
+        remapped_native_state &= ~Mod4Mask;
+        break;
+      case XK_3:
+        // Remap Search+3 to F3.
+        remapped_native_keycode = f3_xkeycode_;
+        remapped_keycode = ui::VKEY_F3;
+        remapped_native_state &= ~Mod4Mask;
+        break;
+      case XK_4:
+        // Remap Search+4 to F4.
+        remapped_native_keycode = f4_xkeycode_;
+        remapped_keycode = ui::VKEY_F4;
+        remapped_native_state &= ~Mod4Mask;
+        break;
+      case XK_5:
+        // Remap Search+5 to F5.
+        remapped_native_keycode = f5_xkeycode_;
+        remapped_keycode = ui::VKEY_F5;
+        remapped_native_state &= ~Mod4Mask;
+        break;
+      case XK_6:
+        // Remap Search+6 to F6.
+        remapped_native_keycode = f6_xkeycode_;
+        remapped_keycode = ui::VKEY_F6;
+        remapped_native_state &= ~Mod4Mask;
+        break;
+      case XK_7:
+        // Remap Search+7 to F7.
+        remapped_native_keycode = f7_xkeycode_;
+        remapped_keycode = ui::VKEY_F7;
+        remapped_native_state &= ~Mod4Mask;
+        break;
+      case XK_8:
+        // Remap Search+8 to F8.
+        remapped_native_keycode = f8_xkeycode_;
+        remapped_keycode = ui::VKEY_F8;
+        remapped_native_state &= ~Mod4Mask;
+        break;
+      case XK_9:
+        // Remap Search+9 to F9.
+        remapped_native_keycode = f9_xkeycode_;
+        remapped_keycode = ui::VKEY_F9;
+        remapped_native_state &= ~Mod4Mask;
+        break;
+      case XK_0:
+        // Remap Search+0 to F10.
+        remapped_native_keycode = f10_xkeycode_;
+        remapped_keycode = ui::VKEY_F10;
+        remapped_native_state &= ~Mod4Mask;
+        break;
+      case XK_minus:
+        // Remap Search+- to F11.
+        remapped_native_keycode = f11_xkeycode_;
+        remapped_keycode = ui::VKEY_F11;
+        remapped_native_state &= ~Mod4Mask;
+        break;
+      case XK_equal:
+        // Remap Search+= to F12.
+        remapped_native_keycode = f12_xkeycode_;
+        remapped_keycode = ui::VKEY_F12;
+        remapped_native_state &= ~Mod4Mask;
+        break;
+      default:
+        break;
+    }
+  }
+
+  if (!remapped_native_keycode || remapped_keycode == ui::VKEY_UNKNOWN)
+    return false;
+
+  OverwriteEvent(event, remapped_native_keycode, remapped_native_state,
+                 remapped_keycode, remapped_flags);
+  return true;
+#else
+  // TODO(danakj): Support Ash on other platforms if needed.
+#endif
+
+  return false;
+}
+
 #if defined(OS_CHROMEOS)
 bool EventRewriter::DropSearchKey(ui::KeyEvent* event) {
   const PrefService* pref_service =