Add power-user keyboard mode for ChromeOS with Search key acting as a typical Fn key.

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)
+      drop_search_key_release_(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 41 matching lines @@
   return kDeviceUnknown;
 }
 
 void EventRewriter::RewriteForTesting(ui::KeyEvent* event) {
   Rewrite(event);
 }
 
 ash::EventRewriterDelegate::Action EventRewriter::RewriteOrFilterKeyEvent(
     ui::KeyEvent* event) {
   if (event->HasNativeEvent())
-    Rewrite(event);
+    return Rewrite(event);
   return ash::EventRewriterDelegate::ACTION_REWRITE_EVENT;
 }
 
 ash::EventRewriterDelegate::Action EventRewriter::RewriteOrFilterLocatedEvent(
     ui::LocatedEvent* event) {
   if (event->HasNativeEvent())
     RewriteLocatedEvent(event);
   return ash::EventRewriterDelegate::ACTION_REWRITE_EVENT;
 }
 
@@ skipping 131 matching lines @@
       return kp_9_xkeycode_;
     case XK_KP_Decimal:
       return kp_decimal_xkeycode_;
     default:
       break;
   }
   return 0U;
 }
 #endif
 
-void EventRewriter::Rewrite(ui::KeyEvent* event) {
+ash::EventRewriterDelegate::Action 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;
+    return ash::EventRewriterDelegate::ACTION_REWRITE_EVENT;
+
+  if (DropSearchKey(event))
+    return ash::EventRewriterDelegate::ACTION_DROP_EVENT;
 #endif
   RewriteModifiers(event);
   RewriteNumPadKeys(event);
   RewriteBackspaceAndArrowKeys(event);
-  // TODO(yusukes): Implement crosbug.com/27167 (allow sending function keys).
+  return ash::EventRewriterDelegate::ACTION_REWRITE_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 251 matching lines @@
   }
 #else
   // TODO(yusukes): Support Ash on other platforms if needed.
 #endif
   return rewritten;
 }
 
 bool EventRewriter::RewriteBackspaceAndArrowKeys(ui::KeyEvent* event) {
   bool rewritten = false;
 #if defined(OS_CHROMEOS)
+  // On a Chromebook keyboard, modifier keys can be used to access extended
+  // keyboard shortcuts. On other keyboards, keys such as delete and page up are
+  // already available, so we do not need to rewrite anything here.
+  if (!EventSourceIsChromebookKeyboard(event))
+    return rewritten;
+
+  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);
+
   XEvent* xev = event->native_event();
   XKeyEvent* xkey = &(xev->xkey);
+  const KeySym keysym = XLookupKeysym(xkey, 0);
 
-  const KeySym keysym = XLookupKeysym(xkey, 0);
-  if (keysym == XK_BackSpace && (xkey->state & Mod1Mask)) {
-    // Remap Alt+Backspace to Delete.
+  if (!search_as_function_key &&
+      keysym == XK_BackSpace && (xkey->state & Mod1Mask)) {
+    // Without Search as Function key: Remap Alt+Backspace to Delete.
     OverwriteEvent(event, delete_xkeycode_, xkey->state & ~Mod1Mask,
                    ui::VKEY_DELETE, event->flags() & ~ui::EF_ALT_DOWN);
     rewritten = true;
-  } else if (keysym == XK_Up &&
+  } else if (search_as_function_key &&
+             keysym == XK_BackSpace && (xkey->state & Mod4Mask)) {
+    // With Search as Function key: Remap Search+Backspace to Delete.
+    OverwriteEvent(event, delete_xkeycode_, xkey->state & ~Mod4Mask,
+                   ui::VKEY_DELETE, event->flags());
+    rewritten = true;
+  } else if (!search_as_function_key && keysym == XK_Up &&
              (xkey->state & ControlMask) && (xkey->state & Mod1Mask)) {
-    // Remap Ctrl+Alt+Up to Home.
+    // Without Search as Function key: Remap Ctrl+Alt+Up to Home.
     OverwriteEvent(event,
                    home_xkeycode_,
                    xkey->state & ~(Mod1Mask | ControlMask),
                    ui::VKEY_HOME,
                    event->flags() & ~(ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN));
     rewritten = true;
-  } else if (keysym == XK_Up && (xkey->state & Mod1Mask)) {
-    // Remap Alt+Up to Prior (aka PageUp).
+  } else if (search_as_function_key &&
+             keysym == XK_Left && (xkey->state & Mod4Mask)) {
+    // With Search as Function key: Remap Search+Left to Home.
+    OverwriteEvent(event, home_xkeycode_, xkey->state & ~Mod4Mask,
+                   ui::VKEY_HOME, event->flags());
+    rewritten = true;
+  } else if (!search_as_function_key &&
+             keysym == XK_Up && (xkey->state & Mod1Mask)) {
+    // Without Search as Function key: Remap Alt+Up to Prior (aka PageUp).
     OverwriteEvent(event, prior_xkeycode_, xkey->state & ~Mod1Mask,
-                 ui::VKEY_PRIOR, event->flags() & ~ui::EF_ALT_DOWN);
+                   ui::VKEY_PRIOR, event->flags() & ~ui::EF_ALT_DOWN);
     rewritten = true;
-  } else if (keysym == XK_Down &&
+  } else if (search_as_function_key &&
+             keysym == XK_Up && (xkey->state & Mod4Mask)) {
+    // With Search as Function key: Remap Search+Up to Prior (aka PageUp).
+    OverwriteEvent(event, prior_xkeycode_, xkey->state & ~Mod4Mask,
+                   ui::VKEY_PRIOR, event->flags());
+    rewritten = true;
+  } else if (!search_as_function_key && keysym == XK_Down &&
              (xkey->state & ControlMask) && (xkey->state & Mod1Mask)) {
-    // Remap Ctrl+Alt+Down to End.
+    // Without Search as Function key: Remap Ctrl+Alt+Down to End.
     OverwriteEvent(event,
                    end_xkeycode_,
                    xkey->state & ~(Mod1Mask | ControlMask),
                    ui::VKEY_END,
                    event->flags() & ~(ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN));
     rewritten = true;
-  } else if (keysym == XK_Down && (xkey->state & Mod1Mask)) {
-    // Remap Alt+Down to Next (aka PageDown).
+  } else if (search_as_function_key &&
+             keysym == XK_Right && (xkey->state & Mod4Mask)) {
+    // With Search as Function key: Remap Search+Right to End.
+    OverwriteEvent(event, end_xkeycode_, xkey->state & ~Mod4Mask,
+                   ui::VKEY_END, event->flags());
+    rewritten = true;
+  } else if (!search_as_function_key &&
+             keysym == XK_Down && (xkey->state & Mod1Mask)) {
+    // Without Search as Function key: Remap Alt+Down to Next (aka PageDown).
     OverwriteEvent(event, next_xkeycode_, xkey->state & ~Mod1Mask,
                    ui::VKEY_NEXT, event->flags() & ~ui::EF_ALT_DOWN);
     rewritten = true;
+  } else if (search_as_function_key &&
+             keysym == XK_Down && (xkey->state & Mod4Mask)) {
+    // With Search as Function key: Remap Search+Down to Next (aka PageDown).
+    OverwriteEvent(event, next_xkeycode_, xkey->state & ~Mod4Mask,
+                   ui::VKEY_NEXT, event->flags());
+    rewritten = true;
   }
 #else
   // TODO(yusukes): Support Ash on other platforms if needed.
 #endif
   return rewritten;
 }
 
+#if defined(OS_CHROMEOS)
+bool EventRewriter::DropSearchKey(ui::KeyEvent* event) {
+  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);
+
+  if (!search_as_function_key)
+    return false;
+
+  XEvent* xev = event->native_event();
+  XKeyEvent* xkey = &(xev->xkey);
+
+  const KeySym keysym = XLookupKeysym(xkey, 0);
+
+  bool drop_key = false;
+  unsigned int nonsearch_modifiers = Mod1Mask | ControlMask | ShiftMask;
+
+  // If the Search key acts like a modifier for another key, then drop the
+  // release of the Search key when it happens.
+  if ((xkey->state & Mod4Mask) && keysym != XK_Super_L)
+    drop_search_key_release_ = true;
+
+  if (event->type() == ui::ET_KEY_PRESSED && keysym == XK_Super_L &&
+      // Only drop the Search key press if no other modifier was present.
+      !(xkey->state & nonsearch_modifiers)) {
+    // When Search key is acting as Function key, then drop Search key presses
+    // that don't include other modifiers.
+    drop_key = true;

[Yusuke Sato, 2012/11/26 21:15:05]

I'm wondering if this is still necessary. If it is, could you let me know why?

[danakj, 2012/11/26 21:17:59]

Actually, it was just to make sure future shortcuts/changes wouldn't ever break
this feature, which the dev might not use.

Should I remove then?

[Yusuke Sato, 2012/11/26 21:26:34]

I see. Then I'd prefer to add a test to accelerator_table_unittest.cc which is
something like EXPECT_EQ(0U, accelerator_list.count(LWIN+Press)) and remove the
DropSearchKey() function.

[danakj, 2012/11/26 21:47:50]

Ah, okay. By solving this in accelerator_controller.cc, the unit test has to
send a press, so it was easy to verify it did nothing at that time.

+  } else if (event->type() == ui::ET_KEY_RELEASED && keysym == XK_Super_L) {
+    if (drop_search_key_release_) {
+      // If we ate the Search key press, then also drop the release if another
+      // key used Search as a modifier.
+      drop_key = true;
+    }
+    drop_search_key_release_ = false;

[Yusuke Sato, 2012/11/26 21:15:05]

As I wrote above, please do that kind of suppression in
accelerator_controller.cc, rather than here.

[danakj, 2012/11/26 21:17:59]

Ah, okay will do!

+  }
+
+  return drop_key;
+}
+#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 55 matching lines @@
   const DeviceType type = EventRewriter::GetDeviceType(device_name);
   if (type == kDeviceAppleKeyboard) {
     VLOG(1) << "Apple 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;
 }