Minor improvements for key_rewriter.cc.

chrome/browser/ui/views/ash/key_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/views/ash/key_rewriter.h"
 
 #include <vector>
 
 #include "ash/shell.h"
 #include "base/logging.h"
@@ skipping 64 matching lines @@
       found_apple = true;
     if (!found_keyboard && LowerCaseEqualsASCII(tokens[i], "keyboard"))
       found_keyboard = true;
     if (found_apple && found_keyboard)
       return kDeviceAppleKeyboard;
   }
 
   return kDeviceUnknown;
 }
 
-void KeyRewriter::RewriteCommandToControlForTesting(aura::KeyEvent* event) {
-  RewriteCommandToControl(event);
-}
-
-void KeyRewriter::RewriteNumPadKeysForTesting(aura::KeyEvent* event) {
-  RewriteNumPadKeys(event);
+void KeyRewriter::RewriteForTesting(aura::KeyEvent* event) {
+  Rewrite(event);
 }
 
 ash::KeyRewriterDelegate::Action KeyRewriter::RewriteOrFilterKeyEvent(
     aura::KeyEvent* event) {
   const ash::KeyRewriterDelegate::Action kActionRewrite =
       ash::KeyRewriterDelegate::ACTION_REWRITE_EVENT;
   if (!event->HasNativeEvent()) {
     // Do not handle a fabricated event generated by tests.
     return kActionRewrite;
   }
-
-  if (RewriteCommandToControl(event))
-    return kActionRewrite;
-  if (RewriteNumPadKeys(event))
-    return kActionRewrite;
-
-  // TODO(yusukes): Implement crbug.com/115112 (Search/Ctrl/Alt remapping) and
-  // crosbug.com/27167 (allow sending function keys) here.
-
+  Rewrite(event);
   return kActionRewrite;  // Do not drop the event.
 }
 
 void KeyRewriter::OnKeyboardMappingChanged(const aura::RootWindow* root) {
 #if defined(OS_CHROMEOS)
   RefreshKeycodes();
 #endif
 }
 
 #if defined(OS_CHROMEOS)
@@ skipping 54 matching lines @@
   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);
 }
 #endif
 
+void KeyRewriter::Rewrite(aura::KeyEvent* event) {
+  RewriteCommandToControl(event);
+  RewriteNumPadKeys(event);
+  // TODO(yusukes): Implement crbug.com/115112 (Search/Ctrl/Alt remapping) and
+  // crosbug.com/27167 (allow sending function keys) here.
+}
+
 bool KeyRewriter::RewriteCommandToControl(aura::KeyEvent* event) {
   bool rewritten = false;
   if (last_device_id_ == kBadDeviceId)
     return rewritten;
 
   // 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 rewritten;
   }
 
   const DeviceType type = iter->second;
   if (type != kDeviceAppleKeyboard)
     return rewritten;
 
 #if defined(OS_CHROMEOS)
   XEvent* xev = event->native_event();
   XKeyEvent* xkey = &(xev->xkey);
 
   // Mod4 is the Windows key on a PC keyboard or Command key on an Apple
   // keyboard.
   if (xkey->state & Mod4Mask) {
     xkey->state &= ~Mod4Mask;
     xkey->state |= ControlMask;
     event->set_flags(event->flags() | ui::EF_CONTROL_DOWN);
+    rewritten = true;
   }
 
   const KeySym keysym = XLookupKeysym(xkey, 0);
   switch (keysym) {
     case XK_Super_L:
       // left Command -> left Control
-      Rewrite(event, control_l_xkeycode_, xkey->state,
-              ui::VKEY_LCONTROL, event->flags());
+      OverwriteEvent(event, control_l_xkeycode_, xkey->state,
+                     ui::VKEY_CONTROL, event->flags());
       rewritten = true;
       break;
     case XK_Super_R:
       // right Command -> right Control
-      Rewrite(event, control_r_xkeycode_, xkey->state,
-              ui::VKEY_RCONTROL, event->flags());
+      OverwriteEvent(event, control_r_xkeycode_, xkey->state,
+                     ui::VKEY_CONTROL, event->flags());
       rewritten = true;
       break;
     default:
       break;
   }
 
   DCHECK_NE(ui::VKEY_LWIN, ui::KeyboardCodeFromXKeyEvent(xev));
   DCHECK_NE(ui::VKEY_RWIN, ui::KeyboardCodeFromXKeyEvent(xev));
 #else
   // TODO(yusukes): Support Ash on other platforms if needed.
 #endif
   return rewritten;
 }
 
 bool KeyRewriter::RewriteNumPadKeys(aura::KeyEvent* event) {
   bool rewritten = false;
 #if defined(OS_CHROMEOS)
   XEvent* xev = event->native_event();
   XKeyEvent* xkey = &(xev->xkey);
 
   const KeySym keysym = XLookupKeysym(xkey, 0);
   switch (keysym) {
     case XK_KP_Insert:
-      Rewrite(event, kp_0_xkeycode_, xkey->state | Mod2Mask,
-              ui::VKEY_NUMPAD0, event->flags());
+      OverwriteEvent(event, kp_0_xkeycode_, xkey->state | Mod2Mask,
+                     ui::VKEY_NUMPAD0, event->flags());
       rewritten = true;
       break;
     case XK_KP_Delete:
-      Rewrite(event, kp_decimal_xkeycode_, xkey->state | Mod2Mask,
-              ui::VKEY_DECIMAL, event->flags());
+      OverwriteEvent(event, kp_decimal_xkeycode_, xkey->state | Mod2Mask,
+                     ui::VKEY_DECIMAL, event->flags());
       rewritten = true;
       break;
     case XK_KP_End:
-      Rewrite(event, kp_1_xkeycode_, xkey->state | Mod2Mask,
-              ui::VKEY_NUMPAD1, event->flags());
+      OverwriteEvent(event, kp_1_xkeycode_, xkey->state | Mod2Mask,
+                     ui::VKEY_NUMPAD1, event->flags());
       rewritten = true;
       break;
     case XK_KP_Down:
-      Rewrite(event, kp_2_xkeycode_, xkey->state | Mod2Mask,
-              ui::VKEY_NUMPAD2, event->flags());
+      OverwriteEvent(event, kp_2_xkeycode_, xkey->state | Mod2Mask,
+                     ui::VKEY_NUMPAD2, event->flags());
       rewritten = true;
       break;
     case XK_KP_Next:
-      Rewrite(event, kp_3_xkeycode_, xkey->state | Mod2Mask,
-              ui::VKEY_NUMPAD3, event->flags());
+      OverwriteEvent(event, kp_3_xkeycode_, xkey->state | Mod2Mask,
+                     ui::VKEY_NUMPAD3, event->flags());
       rewritten = true;
       break;
     case XK_KP_Left:
-      Rewrite(event, kp_4_xkeycode_, xkey->state | Mod2Mask,
-              ui::VKEY_NUMPAD4, event->flags());
+      OverwriteEvent(event, kp_4_xkeycode_, xkey->state | Mod2Mask,
+                     ui::VKEY_NUMPAD4, event->flags());
       rewritten = true;
       break;
     case XK_KP_Begin:
-      Rewrite(event, kp_5_xkeycode_, xkey->state | Mod2Mask,
-              ui::VKEY_NUMPAD5, event->flags());
+      OverwriteEvent(event, kp_5_xkeycode_, xkey->state | Mod2Mask,
+                     ui::VKEY_NUMPAD5, event->flags());
       rewritten = true;
       break;
     case XK_KP_Right:
-      Rewrite(event, kp_6_xkeycode_, xkey->state | Mod2Mask,
-              ui::VKEY_NUMPAD6, event->flags());
+      OverwriteEvent(event, kp_6_xkeycode_, xkey->state | Mod2Mask,
+                     ui::VKEY_NUMPAD6, event->flags());
       rewritten = true;
       break;
     case XK_KP_Home:
-      Rewrite(event, kp_7_xkeycode_, xkey->state | Mod2Mask,
-              ui::VKEY_NUMPAD7, event->flags());
+      OverwriteEvent(event, kp_7_xkeycode_, xkey->state | Mod2Mask,
+                     ui::VKEY_NUMPAD7, event->flags());
       rewritten = true;
       break;
     case XK_KP_Up:
-      Rewrite(event, kp_8_xkeycode_, xkey->state | Mod2Mask,
-              ui::VKEY_NUMPAD8, event->flags());
+      OverwriteEvent(event, kp_8_xkeycode_, xkey->state | Mod2Mask,
+                     ui::VKEY_NUMPAD8, event->flags());
       rewritten = true;
       break;
     case XK_KP_Prior:
-      Rewrite(event, kp_9_xkeycode_, xkey->state | Mod2Mask,
-              ui::VKEY_NUMPAD9, event->flags());
+      OverwriteEvent(event, kp_9_xkeycode_, xkey->state | Mod2Mask,
+                     ui::VKEY_NUMPAD9, event->flags());
       rewritten = true;
       break;
     case XK_KP_Divide:
     case XK_KP_Multiply:
     case XK_KP_Subtract:
     case XK_KP_Add:
     case XK_KP_Enter:
       // Add Mod2Mask for consistency.
-      Rewrite(event, xkey->keycode, xkey->state | Mod2Mask,
-              event->key_code(), event->flags());
+      OverwriteEvent(event, xkey->keycode, xkey->state | Mod2Mask,
+                     event->key_code(), event->flags());
       rewritten = true;
       break;
     default:
       break;
   }
 #else
   // TODO(yusukes): Support Ash on other platforms if needed.
 #endif
   return rewritten;
 }
 
-void KeyRewriter::Rewrite(aura::KeyEvent* event,
-                          unsigned int new_native_keycode,
-                          unsigned int new_native_state,
-                          ui::KeyboardCode new_keycode,
-                          int new_flags) {
+void KeyRewriter::OverwriteEvent(aura::KeyEvent* event,
+                                 unsigned int new_native_keycode,
+                                 unsigned int new_native_state,
+                                 ui::KeyboardCode new_keycode,
+                                 int new_flags) {
 #if defined(OS_CHROMEOS)
   XEvent* xev = event->native_event();
   XKeyEvent* xkey = &(xev->xkey);
   xkey->keycode = new_native_keycode;
   xkey->state = new_native_state;
   event->set_key_code(new_keycode);
   event->set_character(ui::GetCharacterFromKeyCode(event->key_code(),
                                                    new_flags));
   event->set_flags(new_flags);
 #else
   // TODO(yusukes): Support Ash on other platforms if needed.
 #endif
 }
 
 KeyRewriter::DeviceType KeyRewriter::DeviceAddedInternal(
     int device_id,
     const std::string& device_name) {
   const DeviceType type = KeyRewriter::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;
 }