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

chrome/browser/ui/ash/event_rewriter.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 "chrome/browser/ui/ash/event_rewriter.h"
 
 #include <vector>
 
 #include "ash/shell.h"
 #include "base/logging.h"
@@ skipping 103 matching lines @@
       break;
   }
   return false;
 }
 
 bool HasChromeOSKeyboard() {
   return CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kHasChromeOSKeyboard);
 }
 
-bool EventSourceIsChromebookKeyboard(ui::KeyEvent* /* event */) {
-  // TODO(danakj): Determine if the event came from a Chromebook internal
-  // keyboard.
-  return true;
-}
-
 bool IsMod3UsedByCurrentInputMethod() {
   // Since both German Neo2 XKB layout and Caps Lock depend on Mod3Mask,
   // it's not possible to make both features work. For now, we don't remap
   // Mod3Mask when Neo2 is in use.
   // TODO(yusukes): Remove the restriction.
   return InputMethodManager::GetInstance()->GetCurrentInputMethod().id() ==
       kNeo2LayoutId;
 }
 #endif
 
 const PrefService* GetPrefService() {
   Profile* profile = ProfileManager::GetDefaultProfile();
   if (profile)
     return profile->GetPrefs();
   return NULL;
 }
 
 }  // namespace
 
 EventRewriter::EventRewriter()
     : last_device_id_(kBadDeviceId),
 #if defined(OS_CHROMEOS)
+      force_external_keyboard_for_testing_(false),
       xkeyboard_(NULL),
 #endif
       pref_service_(NULL) {
   // The ash shell isn't instantiated for our unit tests.
   if (ash::Shell::HasInstance())
     ash::Shell::GetPrimaryRootWindow()->AddRootWindowObserver(this);
 #if defined(OS_CHROMEOS)
   if (base::chromeos::IsRunningOnChromeOS()) {
     chromeos::XInputHierarchyChangedEventListener::GetInstance()
         ->AddObserver(this);
@@ skipping 31 matching lines @@
   bool found_keyboard = false;
   for (size_t i = 0; i < tokens.size(); ++i) {
     if (!found_apple && LowerCaseEqualsASCII(tokens[i], "apple"))
       found_apple = true;
     if (!found_keyboard && LowerCaseEqualsASCII(tokens[i], "keyboard"))
       found_keyboard = true;
     if (found_apple && found_keyboard)
       return kDeviceAppleKeyboard;
   }
 
+  // TODO(danakj): This could also impact laptops other than Chromebooks, and
+  // might belong behind a command-line flag to be used only on Chromebooks.
+  // The chromebook internal keyboard's name.
+  if (LowerCaseEqualsASCII(device_name, "at translated set 2 keyboard"))
+    return kDeviceChromebookKeyboard;
+  // The chromebox chrome-specific keyboard's name.
+  if (LowerCaseEqualsASCII(device_name, "samsung usb keyboard"))
+    return kDeviceChromebookKeyboard;

[Daniel Erat, 2012/11/28 22:23:03]

it's possible that i misunderstood the conversation about this earlier, but it
seems confusing to me that we use "ChromebookKeyboard" to refer to a
chrome-os-specific keyboard attached to a chromebox, but not to refer to
built-in keyboards attached to other devices that i would think of as
chromebooks.  can we use a better name for this?  maybe something like
kDeviceChromeKeyboard?

[danakj, 2012/11/29 01:50:54]

Hm.. It should refer to ChromeOS keyboards that have a search key and top-row
for brightness etc, and no function-key of their own. Will rename this to
kDeviceChromeOSKeyboard and guard this on HasChromeOSKeyboard().

+
   return kDeviceUnknown;
 }
 
 void EventRewriter::RewriteForTesting(ui::KeyEvent* event) {
   Rewrite(event);
 }
 
 ash::EventRewriterDelegate::Action EventRewriter::RewriteOrFilterKeyEvent(
     ui::KeyEvent* event) {
   if (event->HasNativeEvent())
@@ skipping 81 matching lines @@
   kp_1_xkeycode_ = XKeysymToKeycode(display, XK_KP_1);
   kp_2_xkeycode_ = XKeysymToKeycode(display, XK_KP_2);
   kp_3_xkeycode_ = XKeysymToKeycode(display, XK_KP_3);
   kp_4_xkeycode_ = XKeysymToKeycode(display, XK_KP_4);
   kp_5_xkeycode_ = XKeysymToKeycode(display, XK_KP_5);
   kp_6_xkeycode_ = XKeysymToKeycode(display, XK_KP_6);
   kp_7_xkeycode_ = XKeysymToKeycode(display, XK_KP_7);
   kp_8_xkeycode_ = XKeysymToKeycode(display, XK_KP_8);
   kp_9_xkeycode_ = XKeysymToKeycode(display, XK_KP_9);
   kp_decimal_xkeycode_ = XKeysymToKeycode(display, XK_KP_Decimal);
+  f1_xkeycode_ = XKeysymToKeycode(display, XK_F1);
+  f2_xkeycode_ = XKeysymToKeycode(display, XK_F2);
+  f3_xkeycode_ = XKeysymToKeycode(display, XK_F3);
+  f4_xkeycode_ = XKeysymToKeycode(display, XK_F4);
+  f5_xkeycode_ = XKeysymToKeycode(display, XK_F5);
+  f6_xkeycode_ = XKeysymToKeycode(display, XK_F6);
+  f7_xkeycode_ = XKeysymToKeycode(display, XK_F7);
+  f8_xkeycode_ = XKeysymToKeycode(display, XK_F8);
+  f9_xkeycode_ = XKeysymToKeycode(display, XK_F9);
+  f10_xkeycode_ = XKeysymToKeycode(display, XK_F10);
+  f11_xkeycode_ = XKeysymToKeycode(display, XK_F11);
+  f12_xkeycode_ = XKeysymToKeycode(display, XK_F12);
+  number1_xkeycode_ = XKeysymToKeycode(display, XK_1);
+  number2_xkeycode_ = XKeysymToKeycode(display, XK_2);
+  number3_xkeycode_ = XKeysymToKeycode(display, XK_3);
+  number4_xkeycode_ = XKeysymToKeycode(display, XK_4);
+  number5_xkeycode_ = XKeysymToKeycode(display, XK_5);
+  number6_xkeycode_ = XKeysymToKeycode(display, XK_6);
+  number7_xkeycode_ = XKeysymToKeycode(display, XK_7);
+  number8_xkeycode_ = XKeysymToKeycode(display, XK_8);
+  number9_xkeycode_ = XKeysymToKeycode(display, XK_9);
+  number0_xkeycode_ = XKeysymToKeycode(display, XK_0);
+  minus_xkeycode_ = XKeysymToKeycode(display, XK_minus);
+  equal_xkeycode_ = XKeysymToKeycode(display, XK_equal);
+  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) {
   switch (keysym) {
     case XK_Control_L:
       return control_l_xkeycode_;
     case XK_Control_R:
       return control_r_xkeycode_;
     case XK_Alt_L:
       return alt_l_xkeycode_;
@@ skipping 39 matching lines @@
       return kp_8_xkeycode_;
     case XK_KP_9:
       return kp_9_xkeycode_;
     case XK_KP_Decimal:
       return kp_decimal_xkeycode_;
     default:
       break;
   }
   return 0U;
 }
+
+bool EventRewriter::EventSourceIsChromebookKeyboard(ui::KeyEvent* /* event */) {
+  if (force_external_keyboard_for_testing_)
+    return false;
+
+  if (last_device_id_ == kBadDeviceId)
+    return false;
+
+  // Check which device generated |event|.
+  std::map<int, DeviceType>::const_iterator iter =
+      device_id_to_type_.find(last_device_id_);
+  if (iter == device_id_to_type_.end()) {
+    LOG(ERROR) << "Device ID " << last_device_id_ << " is unknown.";
+    return false;
+  }
+
+  const DeviceType type = iter->second;
+  return type == kDeviceChromebookKeyboard;
+}
 #endif
 
 void EventRewriter::Rewrite(ui::KeyEvent* event) {
 #if defined(OS_CHROMEOS)
   // Do not rewrite an event sent by ui_controls::SendKeyPress(). See
   // crbug.com/136465.
   if (event->native_event()->xkey.send_event)
     return;
 #endif
   RewriteModifiers(event);
   RewriteNumPadKeys(event);
   RewriteBackspaceAndArrowKeys(event);
-  // TODO(yusukes): Implement crosbug.com/27167 (allow sending function keys).
+  RewriteFunctionKeys(event);
 }
 
 bool EventRewriter::IsAppleKeyboard() const {
   if (last_device_id_ == kBadDeviceId)
     return false;
 
   // Check which device generated |event|.
   std::map<int, DeviceType>::const_iterator iter =
       device_id_to_type_.find(last_device_id_);
   if (iter == device_id_to_type_.end()) {
@@ skipping 338 matching lines @@
                      ui::VKEY_NEXT, event->flags());
       rewritten = true;
     }
   }
 #else
   // TODO(yusukes): Support Ash on other platforms if needed.
 #endif
   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 Chromebook keyboard, F<number> keys have special purposes. On other
+  // keyboards, they should act as usual.
+  if (!EventSourceIsChromebookKeyboard(event))
+    return false;
+
+  // Rewrite the actual F1-F12 keys on a Chromebook 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();
+  bool chromebook_function_key = CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kEnableChromebookFunctionKey);
+
+  bool search_as_function_key = chromebook_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) {
+    // We check the keycode here instead of the keysym, as these keys have
+    // different keysyms when modifiers are pressed, such as shift.
+
+    // TODO(danakj): On some i18n keyboards, these choices will be bad and we
+    // should make layout-specific choices here. For eg. on a french keyboard
+    // "-" and "6" are the same key, so F11 will not be accessible.
+    KeyCode xkeycode = xkey->keycode;
+    if (xkeycode == number1_xkeycode_) {
+      // Remap Search+1 to F1.
+      remapped_native_keycode = f1_xkeycode_;
+      remapped_keycode = ui::VKEY_F1;
+      remapped_native_state &= ~Mod4Mask;
+    } else if (xkeycode == number2_xkeycode_) {
+      // Remap Search+2 to F2.

[Daniel Erat, 2012/11/28 22:23:03]

i'd probably remove these repetitive comments in favor of a single comment at
the beginning describing the general reasoning.  i'm wondering if it'd be best
to just do something like this, actually (untested and probably full of syntax
errors and bugs, but hopefully you'll get the idea):

  // Describes a remapping for a given key.
  struct KeyRemapping {
    KeySym source_keysym;
    KeySym target_keysym;
    ui::KeyboardCode target_keycode;
  };

  static const KeyRemapping kKeysymRemappings[] = {
    { XK_F1, XF86XK_Back, ui::VKEY_BROWSER_BACK },
    { XK_F2, XF86XK_Forward, ui::VKEY_BROWSER_FORWARD },
    // ...
  };

  for (int i = 0; i < arraysize(kKeysymRemappings); ++i) {
    const KeyRemapping& remapping = kKeysymRemappings[i];
    if (keysym == remapping.source_keysym) {
      remapped_native_keycode = GetNativeKeycode(remapping.target_keysym);
      remapped_keycode = remapping.target_keycode;
      break;
    }
  }

  // ...

  if (search_as_function_key && xkey->state & Mod4Mask) {
    static const KeyRemapping kKeycodeRemappings[] = { 
      { XK_1, XK_F1, ui::VKEY_F1 },
      { XK_2, XK_F2, ui::VKEY_F2 },
      // ...
    };

    for (int i = 0; i < arraysize(kKeycodeRemappings); ++i) {
      const KeyRemapping& remapping = kKeycodeRemappings[i];
      if (xkey->keycode == GetNativeKeycode(remapping.source_keysym)) {
        remapped_native_keycode = GetNativeKeycode(remapping.target_keysym);
        remapped_keycode = remapping.target_keyboard_code;
        remapped_native_state &= ~Mod4Mask;
        break;
      }
    }
  }

[danakj, 2012/11/29 01:50:54]

Done.

+      remapped_native_keycode = f2_xkeycode_;
+      remapped_keycode = ui::VKEY_F2;
+      remapped_native_state &= ~Mod4Mask;
+    } else if (xkeycode == number3_xkeycode_) {
+      // Remap Search+3 to F3.
+      remapped_native_keycode = f3_xkeycode_;
+      remapped_keycode = ui::VKEY_F3;
+      remapped_native_state &= ~Mod4Mask;
+    } else if (xkeycode == number4_xkeycode_) {
+      // Remap Search+4 to F4.
+      remapped_native_keycode = f4_xkeycode_;
+      remapped_keycode = ui::VKEY_F4;
+      remapped_native_state &= ~Mod4Mask;
+    } else if (xkeycode == number5_xkeycode_) {
+      // Remap Search+5 to F5.
+      remapped_native_keycode = f5_xkeycode_;
+      remapped_keycode = ui::VKEY_F5;
+      remapped_native_state &= ~Mod4Mask;
+    } else if (xkeycode == number6_xkeycode_) {
+      // Remap Search+6 to F6.
+      remapped_native_keycode = f6_xkeycode_;
+      remapped_keycode = ui::VKEY_F6;
+      remapped_native_state &= ~Mod4Mask;
+    } else if (xkeycode == number7_xkeycode_) {
+      // Remap Search+7 to F7.
+      remapped_native_keycode = f7_xkeycode_;
+      remapped_keycode = ui::VKEY_F7;
+      remapped_native_state &= ~Mod4Mask;
+    } else if (xkeycode == number8_xkeycode_) {
+      // Remap Search+8 to F8.
+      remapped_native_keycode = f8_xkeycode_;
+      remapped_keycode = ui::VKEY_F8;
+      remapped_native_state &= ~Mod4Mask;
+    } else if (xkeycode == number9_xkeycode_) {
+      // Remap Search+9 to F9.
+      remapped_native_keycode = f9_xkeycode_;
+      remapped_keycode = ui::VKEY_F9;
+      remapped_native_state &= ~Mod4Mask;
+    } else if (xkeycode == number0_xkeycode_) {
+      // Remap Search+0 to F10.
+      remapped_native_keycode = f10_xkeycode_;
+      remapped_keycode = ui::VKEY_F10;
+      remapped_native_state &= ~Mod4Mask;
+    } else if (xkeycode == minus_xkeycode_) {
+      // Remap Search+- to F11.
+      remapped_native_keycode = f11_xkeycode_;
+      remapped_keycode = ui::VKEY_F11;
+      remapped_native_state &= ~Mod4Mask;
+    } else if (xkeycode == equal_xkeycode_) {
+      // Remap Search+= to F12.
+      remapped_native_keycode = f12_xkeycode_;
+      remapped_keycode = ui::VKEY_F12;
+      remapped_native_state &= ~Mod4Mask;
+    }
+  }
+
+  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.
+  return false;
+#endif
+}
+
 void EventRewriter::RewriteLocatedEvent(ui::LocatedEvent* event) {
 #if defined(OS_CHROMEOS)
   if (event->flags() & ui::EF_IS_SYNTHESIZED)
     return;
 
   XEvent* xevent = event->native_event();
   if (!xevent || xevent->type != GenericEvent)
     return;
 
   XIDeviceEvent* xievent = static_cast<XIDeviceEvent*>(xevent->xcookie.data);
@@ skipping 49 matching lines @@
 #endif
 }
 
 EventRewriter::DeviceType EventRewriter::DeviceAddedInternal(
     int device_id,
     const std::string& device_name) {
   const DeviceType type = EventRewriter::GetDeviceType(device_name);
   if (type == kDeviceAppleKeyboard) {
     VLOG(1) << "Apple keyboard '" << device_name << "' connected: "
             << "id=" << device_id;
+  } else if (type == kDeviceChromebookKeyboard) {
+    VLOG(1) << "Chromebook keyboard '" << device_name << "' connected: "
+            << "id=" << device_id;
   }
   // Always overwrite the existing device_id since the X server may reuse a
   // device id for an unattached device.
   device_id_to_type_[device_id] = type;
   return type;
 }