Convert chromeos::EventRewriter to a ui::EventRewriter

chrome/browser/chromeos/events/event_rewriter.cc

 // Copyright 2014 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/chromeos/events/event_rewriter.h"
 
-#include <X11/extensions/XInput2.h>
-#include <X11/keysym.h>
-#include <X11/XF86keysym.h>
-#include <X11/Xlib.h>
-// Get rid of macros from Xlib.h that conflicts with other parts of the code.
-#undef RootWindow
-#undef Status
-
 #include <vector>
 
 #include "ash/wm/window_state.h"
 #include "ash/wm/window_util.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_util.h"
 #include "base/sys_info.h"
-#include "chrome/browser/chromeos/events/xinput_hierarchy_changed_event_listener.h"
 #include "chrome/browser/chromeos/login/login_display_host_impl.h"
 #include "chrome/browser/chromeos/login/user_manager.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/common/pref_names.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/ime/ime_keyboard.h"
 #include "chromeos/ime/input_method_manager.h"
-#include "ui/base/x/x11_util.h"
 #include "ui/events/event.h"
 #include "ui/events/event_utils.h"
-#include "ui/events/keycodes/keyboard_code_conversion_x.h"
 #include "ui/events/platform/platform_event_source.h"
 #include "ui/wm/core/window_util.h"
 
+#if defined(USE_X11)
+#include <X11/extensions/XInput2.h>
+#include <X11/Xlib.h>
+// Get rid of macros from Xlib.h that conflicts with other parts of the code.
+#undef RootWindow
+#undef Status
+
+#include "chrome/browser/chromeos/events/xinput_hierarchy_changed_event_listener.h"
+#include "ui/base/x/x11_util.h"
+#endif
+
+namespace chromeos {
+
 namespace {
 
 const int kBadDeviceId = -1;
 
-// A key code and a flag we should use when a key is remapped to |remap_to|.
+// Table of key properties of remappable keys and/or remapping targets.
+// This is searched in two distinct ways:
+//  - |remap_to| is an |input_method::ModifierKey|, which is the form
+//    held in user preferences. |GetRemappedKey()| maps this to the
+//    corresponding |key_code| and characterstic event |flag|.
+//  - |flag| is a |ui::EventFlags|. |GetRemappedModifierMasks()| maps this
+//    to the corresponding user preference |pref_name| for that flag's
+//    key, so that it can then be remapped as above.
+// In addition |kModifierRemappingCtrl| is a direct reference to the
+// Control key entry in the table, used in handling Chromebook Diamond
+// and Apple Command keys.
 const struct ModifierRemapping {
   int remap_to;
   int flag;
-  unsigned int native_modifier;
-  ui::KeyboardCode keycode;
-  KeySym native_keysyms[4];  // left, right, shift+left, shift+right.
+  ui::KeyboardCode key_code;
+  const char* pref_name;
 } kModifierRemappings[] = {
-  { chromeos::input_method::kSearchKey, 0, Mod4Mask, ui::VKEY_LWIN,
-    { XK_Super_L, XK_Super_L, XK_Super_L, XK_Super_L }},
-  { chromeos::input_method::kControlKey, ui::EF_CONTROL_DOWN, ControlMask,
-    ui::VKEY_CONTROL,
-    { XK_Control_L, XK_Control_R, XK_Control_L, XK_Control_R }},
-  { chromeos::input_method::kAltKey, ui::EF_ALT_DOWN, Mod1Mask,
-    ui::VKEY_MENU, { XK_Alt_L, XK_Alt_R, XK_Meta_L, XK_Meta_R }},
-  { chromeos::input_method::kVoidKey, 0, 0U, ui::VKEY_UNKNOWN,
-    { XK_VoidSymbol, XK_VoidSymbol, XK_VoidSymbol, XK_VoidSymbol }},
-  { chromeos::input_method::kCapsLockKey, 0, 0U, ui::VKEY_CAPITAL,
-    { XK_Caps_Lock, XK_Caps_Lock, XK_Caps_Lock, XK_Caps_Lock }},
-  { chromeos::input_method::kEscapeKey, 0, 0U, ui::VKEY_ESCAPE,
-    { XK_Escape, XK_Escape, XK_Escape, XK_Escape }},
+      {input_method::kSearchKey, ui::EF_COMMAND_DOWN, ui::VKEY_LWIN,
+       prefs::kLanguageRemapSearchKeyTo},
+      {input_method::kControlKey, ui::EF_CONTROL_DOWN, ui::VKEY_CONTROL,
+       prefs::kLanguageRemapControlKeyTo},
+      {input_method::kAltKey, ui::EF_ALT_DOWN, ui::VKEY_MENU,
+       prefs::kLanguageRemapAltKeyTo},
+      {input_method::kVoidKey, 0, ui::VKEY_UNKNOWN, NULL},
+      {input_method::kCapsLockKey, ui::EF_CAPS_LOCK_DOWN, ui::VKEY_CAPITAL,
+       prefs::kLanguageRemapCapsLockKeyTo},
+      {input_method::kEscapeKey, 0, ui::VKEY_ESCAPE, NULL},
+      {0, 0, ui::VKEY_F15, prefs::kLanguageRemapDiamondKeyTo},
 };
 
 const ModifierRemapping* kModifierRemappingCtrl = &kModifierRemappings[1];
 
-// A structure for converting |native_modifier| to a pair of |flag| and
-// |pref_name|.
-const struct ModifierFlagToPrefName {
-  unsigned int native_modifier;
-  int flag;
-  const char* pref_name;
-} kModifierFlagToPrefName[] = {
-  // TODO(yusukes): When the device has a Chrome keyboard (i.e. the one without
-  // Caps Lock), we should not check kLanguageRemapCapsLockKeyTo.
-  { Mod3Mask, 0, prefs::kLanguageRemapCapsLockKeyTo },
-  { Mod4Mask, 0, prefs::kLanguageRemapSearchKeyTo },
-  { ControlMask, ui::EF_CONTROL_DOWN, prefs::kLanguageRemapControlKeyTo },
-  { Mod1Mask, ui::EF_ALT_DOWN, prefs::kLanguageRemapAltKeyTo },
-  { Mod2Mask, 0, prefs::kLanguageRemapDiamondKeyTo },
-};
-
 // Gets a remapped key for |pref_name| key. For example, to find out which
 // key Search is currently remapped to, call the function with
 // prefs::kLanguageRemapSearchKeyTo.
 const ModifierRemapping* GetRemappedKey(const std::string& pref_name,
                                         const PrefService& pref_service) {
   if (!pref_service.FindPreference(pref_name.c_str()))
     return NULL;  // The |pref_name| hasn't been registered. On login screen?
   const int value = pref_service.GetInteger(pref_name.c_str());
   for (size_t i = 0; i < arraysize(kModifierRemappings); ++i) {
     if (value == kModifierRemappings[i].remap_to)
       return &kModifierRemappings[i];
   }
   return NULL;
 }
 
-bool IsRight(KeySym native_keysym) {
-  switch (native_keysym) {
-    case XK_Alt_R:
-    case XK_Control_R:
-    case XK_Hyper_R:
-    case XK_Meta_R:
-    case XK_Shift_R:
-    case XK_Super_R:
-      return true;
-    default:
-      break;
-  }
-  return false;
-}
-
 bool HasDiamondKey() {
   return CommandLine::ForCurrentProcess()->HasSwitch(
       chromeos::switches::kHasChromeOSDiamondKey);
 }
 
 bool IsISOLevel5ShiftUsedByCurrentInputMethod() {
   // 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.
-  chromeos::input_method::InputMethodManager* manager =
-      chromeos::input_method::InputMethodManager::Get();
+  input_method::InputMethodManager* manager =
+      input_method::InputMethodManager::Get();
   return manager->IsISOLevel5ShiftUsedByCurrentInputMethod();
 }
 
+EventRewriter::DeviceType GetDeviceType(const std::string& device_name) {
+  std::vector<std::string> tokens;
+  Tokenize(device_name, " .", &tokens);
+
+  // If the |device_name| contains the two words, "apple" and "keyboard", treat
+  // it as an Apple keyboard.
+  bool found_apple = false;
+  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 EventRewriter::kDeviceAppleKeyboard;
+  }
+
+  return EventRewriter::kDeviceUnknown;
+}
+
 }  // namespace
 
-namespace chromeos {
-
 EventRewriter::EventRewriter()
     : last_device_id_(kBadDeviceId),
-      keyboard_for_testing_(NULL),
+      ime_keyboard_for_testing_(NULL),
       pref_service_for_testing_(NULL) {
+#if defined(USE_X11)
   ui::PlatformEventSource::GetInstance()->AddPlatformEventObserver(this);
   if (base::SysInfo::IsRunningOnChromeOS()) {
     XInputHierarchyChangedEventListener::GetInstance()->AddObserver(this);
   }
-  RefreshKeycodes();
+#endif
 }
 
 EventRewriter::~EventRewriter() {
+#if defined(USE_X11)
   ui::PlatformEventSource::GetInstance()->RemovePlatformEventObserver(this);
   if (base::SysInfo::IsRunningOnChromeOS()) {
     XInputHierarchyChangedEventListener::GetInstance()->RemoveObserver(this);
   }
+#endif
 }
 
 EventRewriter::DeviceType EventRewriter::DeviceAddedForTesting(
     int device_id,
     const std::string& device_name) {
   return DeviceAddedInternal(device_id, device_name);
 }
 
-// static
-EventRewriter::DeviceType EventRewriter::GetDeviceType(
-    const std::string& device_name) {
-  std::vector<std::string> tokens;
-  Tokenize(device_name, " .", &tokens);
-
-  // If the |device_name| contains the two words, "apple" and "keyboard", treat
-  // it as an Apple keyboard.
-  bool found_apple = false;
-  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;
-  }
-
-  return kDeviceUnknown;
+void EventRewriter::RewriteLocatedEventForTesting(const ui::Event& event,
+                                                  int* flags) {
+  MutableKeyState state = {*flags, ui::VKEY_UNKNOWN};
+  RewriteLocatedEvent(event, &state);
+  *flags = state.flags;
 }
 
-void EventRewriter::RewriteForTesting(XEvent* event) {
-  Rewrite(event);
+ui::EventRewriteStatus EventRewriter::RewriteEvent(
+    const ui::Event& event,
+    scoped_ptr<ui::Event>* rewritten_event) {
+#if defined(USE_X11)
+  // Do not rewrite an event sent by ui_controls::SendKeyPress(). See
+  // crbug.com/136465.
+  XEvent* xev = event.native_event();
+  if (xev && xev->xany.send_event)
+    return ui::EVENT_REWRITE_CONTINUE;
+#endif
+  switch (event.type()) {
+    case ui::ET_KEY_PRESSED:
+    case ui::ET_KEY_RELEASED: {
+      const ui::KeyEvent& key_event = static_cast<const ui::KeyEvent&>(event);
+      MutableKeyState state = {key_event.flags(), key_event.key_code()};
+      RewriteModifierKeys(key_event, &state);
+      RewriteNumPadKeys(key_event, &state);
+      RewriteExtendedKeys(key_event, &state);
+      RewriteFunctionKeys(key_event, &state);
+      if ((key_event.flags() != state.flags) ||
+          (key_event.key_code() != state.key_code)) {
+        ui::KeyEvent* rewritten_key_event = new ui::KeyEvent(key_event);
+        rewritten_event->reset(rewritten_key_event);
+        rewritten_key_event->set_flags(state.flags);
+        rewritten_key_event->set_key_code(state.key_code);
+        return ui::EVENT_REWRITE_REWRITTEN;
+      }
+      return ui::EVENT_REWRITE_CONTINUE;
+    }
+    case ui::ET_MOUSE_PRESSED:
+    case ui::ET_MOUSE_RELEASED:
+    case ui::ET_TOUCH_PRESSED:
+    case ui::ET_TOUCH_RELEASED: {
+      MutableKeyState state = {event.flags(), ui::VKEY_UNKNOWN};
+      RewriteLocatedEvent(event, &state);
+      if (event.flags() != state.flags) {
+        if (event.IsMouseEvent()) {
+          rewritten_event->reset(
+              new ui::MouseEvent(static_cast<const ui::MouseEvent&>(event)));
+        } else {
+          rewritten_event->reset(
+              new ui::TouchEvent(static_cast<const ui::TouchEvent&>(event)));
+        }
+        rewritten_event->get()->set_flags(state.flags);
+        return ui::EVENT_REWRITE_REWRITTEN;
+      }
+      return ui::EVENT_REWRITE_CONTINUE;
+    }
+    default:
+      return ui::EVENT_REWRITE_CONTINUE;
+  }
+  NOTREACHED();
 }
 
+ui::EventRewriteStatus EventRewriter::NextDispatchEvent(
+    const ui::Event& last_event,
+    scoped_ptr<ui::Event>* new_event) {
+  NOTREACHED();
+  return ui::EVENT_REWRITE_CONTINUE;
+}
+
+#if defined(USE_X11)
 void EventRewriter::DeviceKeyPressedOrReleased(int device_id) {
-  std::map<int, DeviceType>::const_iterator iter =
-      device_id_to_type_.find(device_id);
-  if (iter == device_id_to_type_.end()) {
+  if (!device_id_to_type_.count(device_id)) {
     // |device_id| is unknown. This means the device was connected before
     // booting the OS. Query the name of the device and add it to the map.
     DeviceAdded(device_id);
   }
-
   last_device_id_ = device_id;
 }
-
-void EventRewriter::WillProcessEvent(const ui::PlatformEvent& event) {
-  XEvent* xevent = event;
-  if (xevent->type == KeyPress || xevent->type == KeyRelease) {
-    Rewrite(xevent);
-  } else if (xevent->type == GenericEvent) {
-    XIDeviceEvent* xievent = static_cast<XIDeviceEvent*>(xevent->xcookie.data);
-    if (xievent->evtype == XI_KeyPress || xievent->evtype == XI_KeyRelease) {
-      if (xievent->deviceid == xievent->sourceid)
-        DeviceKeyPressedOrReleased(xievent->deviceid);
-    } else {
-      RewriteLocatedEvent(xevent);
-    }
-  } else if (xevent->type == MappingNotify) {
-    if (xevent->xmapping.request == MappingModifier ||
-        xevent->xmapping.request == MappingKeyboard) {
-      RefreshKeycodes();
-    }
-  }
-}
-
-void EventRewriter::DidProcessEvent(const ui::PlatformEvent& event) {
-}
-
-void EventRewriter::DeviceHierarchyChanged() {}
-
-void EventRewriter::DeviceAdded(int device_id) {
-  DCHECK_NE(XIAllDevices, device_id);
-  DCHECK_NE(XIAllMasterDevices, device_id);
-  if (device_id == XIAllDevices || device_id == XIAllMasterDevices) {
-    LOG(ERROR) << "Unexpected device_id passed: " << device_id;
-    return;
-  }
-
-  int ndevices_return = 0;
-  XIDeviceInfo* device_info = XIQueryDevice(gfx::GetXDisplay(),
-                                            device_id,
-                                            &ndevices_return);
-
-  // Since |device_id| is neither XIAllDevices nor XIAllMasterDevices,
-  // the number of devices found should be either 0 (not found) or 1.
-  if (!device_info) {
-    LOG(ERROR) << "XIQueryDevice: Device ID " << device_id << " is unknown.";
-    return;
-  }
-
-  DCHECK_EQ(1, ndevices_return);
-  for (int i = 0; i < ndevices_return; ++i) {
-    DCHECK_EQ(device_id, device_info[i].deviceid);  // see the comment above.
-    DCHECK(device_info[i].name);
-    DeviceAddedInternal(device_info[i].deviceid, device_info[i].name);
-  }
-
-  XIFreeDeviceInfo(device_info);
-}
-
-void EventRewriter::DeviceRemoved(int device_id) {
-  device_id_to_type_.erase(device_id);
-}
-
-void EventRewriter::RefreshKeycodes() {
-  keysym_to_keycode_map_.clear();
-}
-
-KeyCode EventRewriter::NativeKeySymToNativeKeycode(KeySym keysym) {
-  if (keysym_to_keycode_map_.count(keysym))
-    return keysym_to_keycode_map_[keysym];
-
-  XDisplay* display = gfx::GetXDisplay();
-  KeyCode keycode = XKeysymToKeycode(display, keysym);
-  keysym_to_keycode_map_[keysym] = keycode;
-  return keycode;
-}
-
-bool EventRewriter::TopRowKeysAreFunctionKeys(XEvent* event) const {
-  const PrefService* prefs = GetPrefService();
-  if (prefs &&
-      prefs->FindPreference(prefs::kLanguageSendFunctionKeys) &&
-      prefs->GetBoolean(prefs::kLanguageSendFunctionKeys))
-    return true;
-
-  ash::wm::WindowState* state = ash::wm::GetActiveWindowState();
-  return state ? state->top_row_keys_are_function_keys() : false;
-}
-
-bool EventRewriter::RewriteWithKeyboardRemappingsByKeySym(
-    const KeyboardRemapping* remappings,
-    size_t num_remappings,
-    KeySym keysym,
-    unsigned int native_mods,
-    KeySym* remapped_native_keysym,
-    unsigned int* remapped_native_mods) {
-  for (size_t i = 0; i < num_remappings; ++i) {
-    const KeyboardRemapping& map = remappings[i];
-
-    if (keysym != map.input_keysym)
-      continue;
-    unsigned int matched_mods = native_mods & map.input_native_mods;
-    if (matched_mods != map.input_native_mods)
-      continue;
-
-    *remapped_native_keysym = map.output_keysym;
-    *remapped_native_mods = (native_mods & ~map.input_native_mods) |
-                            map.output_native_mods;
-    return true;
-  }
-
-  return false;
-}
-
-bool EventRewriter::RewriteWithKeyboardRemappingsByKeyCode(
-    const KeyboardRemapping* remappings,
-    size_t num_remappings,
-    KeyCode keycode,
-    unsigned int native_mods,
-    KeySym* remapped_native_keysym,
-    unsigned int* remapped_native_mods) {
-  for (size_t i = 0; i < num_remappings; ++i) {
-    const KeyboardRemapping& map = remappings[i];
-
-    KeyCode input_keycode = NativeKeySymToNativeKeycode(map.input_keysym);
-    if (keycode != input_keycode)
-      continue;
-    unsigned int matched_mods = native_mods & map.input_native_mods;
-    if (matched_mods != map.input_native_mods)
-      continue;
-
-    *remapped_native_keysym = map.output_keysym;
-    *remapped_native_mods = (native_mods & ~map.input_native_mods) |
-                            map.output_native_mods;
-    return true;
-  }
-
-  return false;
-}
+#endif
 
 const PrefService* EventRewriter::GetPrefService() const {
   if (pref_service_for_testing_)
     return pref_service_for_testing_;
   Profile* profile = ProfileManager::GetActiveUserProfile();
   return profile ? profile->GetPrefs() : NULL;
 }
 
-void EventRewriter::Rewrite(XEvent* event) {
-  // Do not rewrite an event sent by ui_controls::SendKeyPress(). See
-  // crbug.com/136465.
-  if (event->xkey.send_event)
-    return;
-
-  RewriteModifiers(event);
-  RewriteNumPadKeys(event);
-  RewriteExtendedKeys(event);
-  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()) {
     LOG(ERROR) << "Device ID " << last_device_id_ << " is unknown.";
     return false;
   }
 
   const DeviceType type = iter->second;
   return type == kDeviceAppleKeyboard;
 }
 
-void EventRewriter::GetRemappedModifierMasks(
-    unsigned int original_native_modifiers,
-    unsigned int* remapped_native_modifiers) const {
-  // TODO(glotov): remove the following condition when we do not restart chrome
-  // when user logs in as guest. See Rewrite() for details.
-  if (UserManager::Get()->IsLoggedInAsGuest() &&
-      LoginDisplayHostImpl::default_host()) {
-    return;
-  }
+bool EventRewriter::TopRowKeysAreFunctionKeys(const ui::KeyEvent& event) const {
+  const PrefService* prefs = GetPrefService();
+  if (prefs && prefs->FindPreference(prefs::kLanguageSendFunctionKeys) &&
+      prefs->GetBoolean(prefs::kLanguageSendFunctionKeys))
+    return true;
 
-  const PrefService* pref_service = GetPrefService();
-  if (!pref_service)
-    return;
+  ash::wm::WindowState* state = ash::wm::GetActiveWindowState();
+  return state ? state->top_row_keys_are_function_keys() : false;
+}
 
-  // When a diamond key is not available, a Mod2Mask should not treated as a
-  // configurable modifier because Mod2Mask may be worked as NumLock mask.
-  // (cf. http://crbug.com/173956)
-  const bool skip_mod2 = !HasDiamondKey();
-  // If Mod3 is used by the current input method, don't allow the CapsLock
-  // pref to remap it, or the keyboard behavior will be broken.
-  const bool skip_mod3 = IsISOLevel5ShiftUsedByCurrentInputMethod();
-
-  for (size_t i = 0; i < arraysize(kModifierFlagToPrefName); ++i) {
-    if ((skip_mod2 && kModifierFlagToPrefName[i].native_modifier == Mod2Mask) ||
-        (skip_mod3 && kModifierFlagToPrefName[i].native_modifier == Mod3Mask)) {
+int EventRewriter::GetRemappedModifierMasks(const PrefService& pref_service,
+                                            const ui::Event& event,
+                                            int original_flags) const {
+  int unmodified_flags = original_flags;
+  int rewritten_flags = 0;
+  for (size_t i = 0; unmodified_flags && (i < arraysize(kModifierRemappings));
+       ++i) {
+    const ModifierRemapping* remapped_key = 0;
+    if (!(unmodified_flags & kModifierRemappings[i].flag))
       continue;
+    switch (kModifierRemappings[i].flag) {
+      case ui::EF_COMMAND_DOWN:
+        // Rewrite Command key presses on an Apple keyboard to Control.
+        if (IsAppleKeyboard()) {
+          DCHECK_EQ(ui::EF_CONTROL_DOWN, kModifierRemappingCtrl->flag);
+          remapped_key = kModifierRemappingCtrl;
+        }
+        break;
+      case ui::EF_CAPS_LOCK_DOWN:
+        // If CapsLock is used by the current input method, don't allow the
+        // CapsLock pref to remap it, or the keyboard behavior will be broken.
+        if (IsISOLevel5ShiftUsedByCurrentInputMethod())
+          continue;
+        break;
+      default:
+        break;
     }
-    if (original_native_modifiers &
-        kModifierFlagToPrefName[i].native_modifier) {
-      const ModifierRemapping* remapped_key =
-          GetRemappedKey(kModifierFlagToPrefName[i].pref_name, *pref_service);
-      // Rewrite Command-L/R key presses on an Apple keyboard to Control-L/R.
-      if (IsAppleKeyboard() &&
-          (kModifierFlagToPrefName[i].native_modifier == Mod4Mask)) {
-        remapped_key = kModifierRemappingCtrl;
-      }
-      if (remapped_key) {
-        *remapped_native_modifiers |= remapped_key->native_modifier;
-      } else {
-        *remapped_native_modifiers |=
-            kModifierFlagToPrefName[i].native_modifier;
-      }
+    if (!remapped_key && kModifierRemappings[i].pref_name) {
+      remapped_key =
+          GetRemappedKey(kModifierRemappings[i].pref_name, pref_service);
+    }
+    if (remapped_key) {
+      unmodified_flags &= ~kModifierRemappings[i].flag;
+      rewritten_flags |= remapped_key->flag;
     }
   }
-
-  unsigned int native_mask = Mod4Mask | ControlMask | Mod1Mask;
-  if (!skip_mod2)
-    native_mask |= Mod2Mask;
-  if (!skip_mod3)
-    native_mask |= Mod3Mask;
-  *remapped_native_modifiers =
-      (original_native_modifiers & ~native_mask) |
-      *remapped_native_modifiers;
+  return rewritten_flags | unmodified_flags;
 }
 
-bool EventRewriter::RewriteModifiers(XEvent* event) {
-  DCHECK(event->type == KeyPress || event->type == KeyRelease);
+bool EventRewriter::RewriteWithKeyboardRemappingsByKeyCode(
+    const KeyboardRemapping* remappings,
+    size_t num_remappings,
+    const MutableKeyState& input,
+    MutableKeyState* remapped_state) {
+  for (size_t i = 0; i < num_remappings; ++i) {
+    const KeyboardRemapping& map = remappings[i];
+    if (input.key_code != map.input_key_code)
+      continue;
+    if ((input.flags & map.input_flags) != map.input_flags)
+      continue;
+    remapped_state->key_code = map.output_key_code;
+    remapped_state->flags = (input.flags & ~map.input_flags) | map.output_flags;
+    return true;
+  }
+  return false;
+}
+
+void EventRewriter::RewriteModifierKeys(const ui::KeyEvent& key_event,
+                                        MutableKeyState* state) {
+  DCHECK(key_event.type() == ui::ET_KEY_PRESSED ||
+         key_event.type() == ui::ET_KEY_RELEASED);
+
   // Do nothing if we have just logged in as guest but have not restarted chrome
   // process yet (so we are still on the login screen). In this situations we
   // have no user profile so can not do anything useful.
   // Note that currently, unlike other accounts, when user logs in as guest, we
   // restart chrome process. In future this is to be changed.
   // TODO(glotov): remove the following condition when we do not restart chrome
   // when user logs in as guest.
+  // TODO(kpschoedel): check whether this is still necessary.
   if (UserManager::Get()->IsLoggedInAsGuest() &&
       LoginDisplayHostImpl::default_host())
-    return false;
+    return;
 
   const PrefService* pref_service = GetPrefService();
   if (!pref_service)
-    return false;
+    return;
 
-  DCHECK_EQ(input_method::kControlKey, kModifierRemappingCtrl->remap_to);
+  MutableKeyState incoming = *state;
+  state->flags = ui::EF_NONE;
+  int characteristic_flag = ui::EF_NONE;
 
-  XKeyEvent* xkey = &event->xkey;
-  KeySym keysym = XLookupKeysym(xkey, 0);
-  ui::KeyboardCode original_keycode = ui::KeyboardCodeFromNative(event);
-  ui::KeyboardCode remapped_keycode = original_keycode;
-  KeyCode remapped_native_keycode = xkey->keycode;
-
-  // First, remap |keysym|.
+  // First, remap the key code.
   const ModifierRemapping* remapped_key = NULL;
-  switch (keysym) {
-    // On Chrome OS, XF86XK_Launch6 (F15) with Mod2Mask is sent when Diamond
-    // key is pressed.
-    case XF86XK_Launch6:
+  switch (incoming.key_code) {
+    // On Chrome OS, F15 (XF86XK_Launch6) with NumLock (Mod2Mask) is sent
+    // when Diamond key is pressed.
+    case ui::VKEY_F15:
       // When diamond key is not available, the configuration UI for Diamond
       // key is not shown. Therefore, ignore the kLanguageRemapDiamondKeyTo
       // syncable pref.
       if (HasDiamondKey())
         remapped_key =
             GetRemappedKey(prefs::kLanguageRemapDiamondKeyTo, *pref_service);
       // Default behavior is Ctrl key.
-      if (!remapped_key)
+      if (!remapped_key) {
+        DCHECK_EQ(ui::VKEY_CONTROL, kModifierRemappingCtrl->key_code);
         remapped_key = kModifierRemappingCtrl;
+        characteristic_flag = ui::EF_CONTROL_DOWN;
+      }
       break;
     // On Chrome OS, XF86XK_Launch7 (F16) with Mod3Mask is sent when Caps Lock
     // is pressed (with one exception: when
     // IsISOLevel5ShiftUsedByCurrentInputMethod() is true, the key generates
     // XK_ISO_Level3_Shift with Mod3Mask, not XF86XK_Launch7).
-    case XF86XK_Launch7:
+    case ui::VKEY_F16:
+      characteristic_flag = ui::EF_CAPS_LOCK_DOWN;
       remapped_key =
           GetRemappedKey(prefs::kLanguageRemapCapsLockKeyTo, *pref_service);
       break;
-    case XK_Super_L:
-    case XK_Super_R:
-      // Rewrite Command-L/R key presses on an Apple keyboard to Control-L/R.
-      if (IsAppleKeyboard())
+    case ui::VKEY_LWIN:
+    case ui::VKEY_RWIN:
+      characteristic_flag = ui::EF_COMMAND_DOWN;
+      // Rewrite Command-L/R key presses on an Apple keyboard to Control.
+      if (IsAppleKeyboard()) {
+        DCHECK_EQ(ui::VKEY_CONTROL, kModifierRemappingCtrl->key_code);
         remapped_key = kModifierRemappingCtrl;
-      else
+      } else {
         remapped_key =
             GetRemappedKey(prefs::kLanguageRemapSearchKeyTo, *pref_service);
+      }
       // Default behavior is Super key, hence don't remap the event if the pref
       // is unavailable.
       break;
-    case XK_Control_L:
-    case XK_Control_R:
+    case ui::VKEY_CONTROL:
+      characteristic_flag = ui::EF_CONTROL_DOWN;
       remapped_key =
           GetRemappedKey(prefs::kLanguageRemapControlKeyTo, *pref_service);
       break;
-    case XK_Alt_L:
-    case XK_Alt_R:
-    case XK_Meta_L:
-    case XK_Meta_R:
+    case ui::VKEY_MENU:
+      // ALT key
+      characteristic_flag = ui::EF_ALT_DOWN;
       remapped_key =
           GetRemappedKey(prefs::kLanguageRemapAltKeyTo, *pref_service);
       break;
     default:
       break;
   }
 
   if (remapped_key) {
-    int flags = ui::EventFlagsFromNative(event);
-    remapped_keycode = remapped_key->keycode;
-    const size_t level = ((flags & ui::EF_SHIFT_DOWN) ? (1 << 1) : 0) +
-        (IsRight(keysym) ? (1 << 0) : 0);
-    const KeySym native_keysym = remapped_key->native_keysyms[level];
-    remapped_native_keycode = NativeKeySymToNativeKeycode(native_keysym);
+    state->key_code = remapped_key->key_code;
+    incoming.flags |= characteristic_flag;
+    characteristic_flag = remapped_key->flag;
   }
 
   // Next, remap modifier bits.
-  unsigned int remapped_native_modifiers = 0U;
-  GetRemappedModifierMasks(xkey->state, &remapped_native_modifiers);
+  state->flags |=
+      GetRemappedModifierMasks(*pref_service, key_event, incoming.flags);
+  if (key_event.type() == ui::ET_KEY_PRESSED)
+    state->flags |= characteristic_flag;
+  else
+    state->flags &= ~characteristic_flag;
 
   // Toggle Caps Lock if the remapped key is ui::VKEY_CAPITAL, but do nothing if
   // the original key is ui::VKEY_CAPITAL (i.e. a Caps Lock key on an external
   // keyboard is pressed) since X can handle that case.
-  if (event->type == KeyPress &&
-      original_keycode != ui::VKEY_CAPITAL &&
-      remapped_keycode == ui::VKEY_CAPITAL) {
-    input_method::ImeKeyboard* keyboard = keyboard_for_testing_ ?
-        keyboard_for_testing_ :
-        input_method::InputMethodManager::Get()->GetImeKeyboard();
-    keyboard->SetCapsLockEnabled(!keyboard->CapsLockIsEnabled());
+  if (key_event.type() == ui::ET_KEY_PRESSED &&
+      incoming.key_code != ui::VKEY_CAPITAL &&
+      state->key_code == ui::VKEY_CAPITAL) {
+    chromeos::input_method::ImeKeyboard* ime_keyboard =
+        ime_keyboard_for_testing_
+            ? ime_keyboard_for_testing_
+            : chromeos::input_method::InputMethodManager::Get()
+                  ->GetImeKeyboard();
+    ime_keyboard->SetCapsLockEnabled(!ime_keyboard->CapsLockIsEnabled());
+  }
+}
+
+void EventRewriter::RewriteNumPadKeys(const ui::KeyEvent& key_event,
+                                      MutableKeyState* state) {
+  DCHECK(key_event.type() == ui::ET_KEY_PRESSED ||
+         key_event.type() == ui::ET_KEY_RELEASED);
+  if (!(state->flags & ui::EF_NUMPAD_KEY))
+    return;
+  MutableKeyState incoming = *state;
+
+  static const KeyboardRemapping kNumPadRemappings[] = {
+      {ui::VKEY_INSERT, ui::EF_NUMPAD_KEY, ui::VKEY_NUMPAD0, ui::EF_NUMPAD_KEY},
+      {ui::VKEY_DELETE, ui::EF_NUMPAD_KEY, ui::VKEY_DECIMAL, ui::EF_NUMPAD_KEY},
+      {ui::VKEY_END, ui::EF_NUMPAD_KEY, ui::VKEY_NUMPAD1, ui::EF_NUMPAD_KEY},
+      {ui::VKEY_DOWN, ui::EF_NUMPAD_KEY, ui::VKEY_NUMPAD2, ui::EF_NUMPAD_KEY},
+      {ui::VKEY_NEXT, ui::EF_NUMPAD_KEY, ui::VKEY_NUMPAD3, ui::EF_NUMPAD_KEY},
+      {ui::VKEY_LEFT, ui::EF_NUMPAD_KEY, ui::VKEY_NUMPAD4, ui::EF_NUMPAD_KEY},
+      {ui::VKEY_CLEAR, ui::EF_NUMPAD_KEY, ui::VKEY_NUMPAD5, ui::EF_NUMPAD_KEY},
+      {ui::VKEY_RIGHT, ui::EF_NUMPAD_KEY, ui::VKEY_NUMPAD6, ui::EF_NUMPAD_KEY},
+      {ui::VKEY_HOME, ui::EF_NUMPAD_KEY, ui::VKEY_NUMPAD7, ui::EF_NUMPAD_KEY},
+      {ui::VKEY_UP, ui::EF_NUMPAD_KEY, ui::VKEY_NUMPAD8, ui::EF_NUMPAD_KEY},
+      {ui::VKEY_PRIOR, ui::EF_NUMPAD_KEY, ui::VKEY_NUMPAD9, ui::EF_NUMPAD_KEY},
+  };
+
+  RewriteWithKeyboardRemappingsByKeyCode(
+      kNumPadRemappings, arraysize(kNumPadRemappings), incoming, state);
+}
+
+void EventRewriter::RewriteExtendedKeys(const ui::KeyEvent& key_event,
+                                        MutableKeyState* state) {
+  DCHECK(key_event.type() == ui::ET_KEY_PRESSED ||
+         key_event.type() == ui::ET_KEY_RELEASED);
+
+  MutableKeyState incoming = *state;
+  bool rewritten = false;
+
+  if ((incoming.flags & (ui::EF_COMMAND_DOWN | ui::EF_ALT_DOWN)) ==
+      (ui::EF_COMMAND_DOWN | ui::EF_ALT_DOWN)) {
+    // Allow Search to avoid rewriting extended keys.
+    static const KeyboardRemapping kAvoidRemappings[] = {
+        {  // Alt+Backspace
+         ui::VKEY_BACK, ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN, ui::VKEY_BACK,
+         ui::EF_ALT_DOWN,
+        },
+        {  // Control+Alt+Up
+         ui::VKEY_UP,
+         ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN | ui::EF_COMMAND_DOWN,
+         ui::VKEY_UP, ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN,
+        },
+        {  // Alt+Up
+         ui::VKEY_UP, ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN, ui::VKEY_UP,
+         ui::EF_ALT_DOWN,
+        },
+        {  // Control+Alt+Down
+         ui::VKEY_DOWN,
+         ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN | ui::EF_COMMAND_DOWN,
+         ui::VKEY_DOWN, ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN,
+        },
+        {  // Alt+Down
+         ui::VKEY_DOWN, ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN, ui::VKEY_DOWN,
+         ui::EF_ALT_DOWN,
+        }};
+
+    rewritten = RewriteWithKeyboardRemappingsByKeyCode(
+        kAvoidRemappings, arraysize(kAvoidRemappings), incoming, state);
   }
 
-  OverwriteEvent(event, remapped_native_keycode, remapped_native_modifiers);
-  return true;
+  if (!rewritten && (incoming.flags & ui::EF_COMMAND_DOWN)) {
+    static const KeyboardRemapping kSearchRemappings[] = {
+        {  // Search+BackSpace -> Delete
+         ui::VKEY_BACK, ui::EF_COMMAND_DOWN, ui::VKEY_DELETE, 0},
+        {  // Search+Left -> Home
+         ui::VKEY_LEFT, ui::EF_COMMAND_DOWN, ui::VKEY_HOME, 0},
+        {  // Search+Up -> Prior (aka PageUp)
+         ui::VKEY_UP, ui::EF_COMMAND_DOWN, ui::VKEY_PRIOR, 0},
+        {  // Search+Right -> End
+         ui::VKEY_RIGHT, ui::EF_COMMAND_DOWN, ui::VKEY_END, 0},
+        {  // Search+Down -> Next (aka PageDown)
+         ui::VKEY_DOWN, ui::EF_COMMAND_DOWN, ui::VKEY_NEXT, 0},
+        {  // Search+Period -> Insert
+         ui::VKEY_OEM_PERIOD, ui::EF_COMMAND_DOWN, ui::VKEY_INSERT, 0}};
+
+    rewritten = RewriteWithKeyboardRemappingsByKeyCode(
+        kSearchRemappings, arraysize(kSearchRemappings), incoming, state);
+  }
+
+  if (!rewritten && (incoming.flags & ui::EF_ALT_DOWN)) {
+    static const KeyboardRemapping kNonSearchRemappings[] = {
+        {  // Alt+BackSpace -> Delete
+         ui::VKEY_BACK, ui::EF_ALT_DOWN, ui::VKEY_DELETE, 0},
+        {  // Control+Alt+Up -> Home
+         ui::VKEY_UP, ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN, ui::VKEY_HOME, 0},
+        {  // Alt+Up -> Prior (aka PageUp)
+         ui::VKEY_UP, ui::EF_ALT_DOWN, ui::VKEY_PRIOR, 0},
+        {  // Control+Alt+Down -> End
+         ui::VKEY_DOWN, ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN, ui::VKEY_END, 0},
+        {  // Alt+Down -> Next (aka PageDown)
+         ui::VKEY_DOWN, ui::EF_ALT_DOWN, ui::VKEY_NEXT, 0}};
+
+    rewritten = RewriteWithKeyboardRemappingsByKeyCode(
+        kNonSearchRemappings, arraysize(kNonSearchRemappings), incoming, state);
+  }
 }
 
-bool EventRewriter::RewriteNumPadKeys(XEvent* event) {
-  DCHECK(event->type == KeyPress || event->type == KeyRelease);
-  bool rewritten = false;
-  XKeyEvent* xkey = &event->xkey;
-  const KeySym keysym = XLookupKeysym(xkey, 0);
-  switch (keysym) {
-    case XK_KP_Insert:
-      OverwriteEvent(event, NativeKeySymToNativeKeycode(XK_KP_0),
-                     xkey->state | Mod2Mask);
-      rewritten = true;
-      break;
-    case XK_KP_Delete:
-      OverwriteEvent(event, NativeKeySymToNativeKeycode(XK_KP_Decimal),
-                     xkey->state | Mod2Mask);
-      rewritten = true;
-      break;
-    case XK_KP_End:
-      OverwriteEvent(event, NativeKeySymToNativeKeycode(XK_KP_1),
-                     xkey->state | Mod2Mask);
-      rewritten = true;
-      break;
-    case XK_KP_Down:
-      OverwriteEvent(event, NativeKeySymToNativeKeycode(XK_KP_2),
-                     xkey->state | Mod2Mask);
-      rewritten = true;
-      break;
-    case XK_KP_Next:
-      OverwriteEvent(event, NativeKeySymToNativeKeycode(XK_KP_3),
-                     xkey->state | Mod2Mask);
-      rewritten = true;
-      break;
-    case XK_KP_Left:
-      OverwriteEvent(event, NativeKeySymToNativeKeycode(XK_KP_4),
-                     xkey->state | Mod2Mask);
-      rewritten = true;
-      break;
-    case XK_KP_Begin:
-      OverwriteEvent(event, NativeKeySymToNativeKeycode(XK_KP_5),
-                     xkey->state | Mod2Mask);
-      rewritten = true;
-      break;
-    case XK_KP_Right:
-      OverwriteEvent(event, NativeKeySymToNativeKeycode(XK_KP_6),
-                     xkey->state | Mod2Mask);
-      rewritten = true;
-      break;
-    case XK_KP_Home:
-      OverwriteEvent(event, NativeKeySymToNativeKeycode(XK_KP_7),
-                     xkey->state | Mod2Mask);
-      rewritten = true;
-      break;
-    case XK_KP_Up:
-      OverwriteEvent(event, NativeKeySymToNativeKeycode(XK_KP_8),
-                     xkey->state | Mod2Mask);
-      rewritten = true;
-      break;
-    case XK_KP_Prior:
-      OverwriteEvent(event, NativeKeySymToNativeKeycode(XK_KP_9),
-                     xkey->state | Mod2Mask);
-      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.
-      OverwriteEvent(event, xkey->keycode, xkey->state | Mod2Mask);
-      rewritten = true;
-      break;
-    default:
-      break;
-  }
-  return rewritten;
-}
-
-bool EventRewriter::RewriteExtendedKeys(XEvent* event) {
-  DCHECK(event->type == KeyPress || event->type == KeyRelease);
-  XKeyEvent* xkey = &event->xkey;
-  const KeySym keysym = XLookupKeysym(xkey, 0);
-
-  KeySym remapped_native_keysym = 0;
-  unsigned int remapped_native_mods = 0;
+void EventRewriter::RewriteFunctionKeys(const ui::KeyEvent& key_event,
+                                        MutableKeyState* state) {
+  CHECK(key_event.type() == ui::ET_KEY_PRESSED ||
+        key_event.type() == ui::ET_KEY_RELEASED);
+  MutableKeyState incoming = *state;
   bool rewritten = false;
 
-  if (xkey->state & Mod4Mask) {
-    // Allow Search to avoid rewriting extended keys.
-    static const KeyboardRemapping kAvoidRemappings[] = {
-      { // Alt+Backspace
-        XK_BackSpace, Mod1Mask | Mod4Mask,
-        XK_BackSpace, Mod1Mask,
-      },
-      { // Control+Alt+Up
-        XK_Up, Mod1Mask | ControlMask | Mod4Mask,
-        XK_Up, Mod1Mask | ControlMask,
-      },
-      { // Alt+Up
-        XK_Up, Mod1Mask | Mod4Mask,
-        XK_Up, Mod1Mask,
-      },
-      { // Control+Alt+Down
-        XK_Down, Mod1Mask | ControlMask | Mod4Mask,
-        XK_Down, Mod1Mask | ControlMask,
-      },
-      { // Alt+Down
-        XK_Down, Mod1Mask | Mod4Mask,
-        XK_Down, Mod1Mask,
-      }
-    };
+  if ((incoming.key_code >= ui::VKEY_F1) &&
+      (incoming.key_code <= ui::VKEY_F24)) {
+    // By default the top row (F1-F12) keys are system keys for back, forward,
+    // brightness, volume, etc. However, windows for v2 apps can optionally
+    // request raw function keys for these keys.
+    bool top_row_keys_are_function_keys = TopRowKeysAreFunctionKeys(key_event);
+    bool search_is_pressed = (incoming.flags & ui::EF_COMMAND_DOWN) != 0;
 
-    rewritten = RewriteWithKeyboardRemappingsByKeySym(
-        kAvoidRemappings,
-        arraysize(kAvoidRemappings),
-        keysym,
-        xkey->state,
-        &remapped_native_keysym,
-        &remapped_native_mods);
-  }
-
-  if (!rewritten) {
-    static const KeyboardRemapping kSearchRemappings[] = {
-      { // Search+BackSpace -> Delete
-        XK_BackSpace, Mod4Mask,
-        XK_Delete, 0
-      },
-      { // Search+Left -> Home
-        XK_Left, Mod4Mask,
-        XK_Home, 0
-      },
-      { // Search+Up -> Prior (aka PageUp)
-        XK_Up, Mod4Mask,
-        XK_Prior, 0
-      },
-      { // Search+Right -> End
-        XK_Right, Mod4Mask,
-        XK_End, 0
-      },
-      { // Search+Down -> Next (aka PageDown)
-        XK_Down, Mod4Mask,
-        XK_Next, 0
-      },
-      { // Search+Period -> Insert
-        XK_period, Mod4Mask,
-        XK_Insert, 0
-      }
-    };
-
-    rewritten = RewriteWithKeyboardRemappingsByKeySym(
-        kSearchRemappings,
-        arraysize(kSearchRemappings),
-        keysym,
-        xkey->state,
-        &remapped_native_keysym,
-        &remapped_native_mods);
-  }
-
-  if (!rewritten) {
-    static const KeyboardRemapping kNonSearchRemappings[] = {
-      { // Alt+BackSpace -> Delete
-        XK_BackSpace, Mod1Mask,
-        XK_Delete, 0
-      },
-      { // Control+Alt+Up -> Home
-        XK_Up, Mod1Mask | ControlMask,
-        XK_Home, 0
-      },
-      { // Alt+Up -> Prior (aka PageUp)
-        XK_Up, Mod1Mask,
-        XK_Prior, 0
-      },
-      { // Control+Alt+Down -> End
-        XK_Down, Mod1Mask | ControlMask,
-        XK_End, 0
-      },
-      { // Alt+Down -> Next (aka PageDown)
-        XK_Down, Mod1Mask,
-        XK_Next, 0
-      }
-    };
-
-    rewritten = RewriteWithKeyboardRemappingsByKeySym(
-        kNonSearchRemappings,
-        arraysize(kNonSearchRemappings),
-        keysym,
-        xkey->state,
-        &remapped_native_keysym,
-        &remapped_native_mods);
-  }
-
-  if (!rewritten)
-    return false;
-
-  OverwriteEvent(event,
-                 NativeKeySymToNativeKeycode(remapped_native_keysym),
-                 remapped_native_mods);
-  return true;
-}
-
-bool EventRewriter::RewriteFunctionKeys(XEvent* event) {
-  DCHECK(event->type == KeyPress || event->type == KeyRelease);
-  XKeyEvent* xkey = &event->xkey;
-  const KeySym keysym = XLookupKeysym(xkey, 0);
-
-  KeySym remapped_native_keysym = 0;
-  unsigned int remapped_native_mods = 0;
-  bool rewritten = false;
-
-  // By default the top row (F1-F12) keys are special keys for back, forward,
-  // brightness, volume, etc. However, windows for v2 apps can optionally
-  // request raw function keys for these keys.
-  bool top_row_keys_are_special_keys = !TopRowKeysAreFunctionKeys(event);
-
-  if ((xkey->state & Mod4Mask) && top_row_keys_are_special_keys) {
-    // Allow Search to avoid rewriting F1-F12.
-    static const KeyboardRemapping kFkeysToFkeys[] = {
-      { XK_F1, Mod4Mask, XK_F1, },
-      { XK_F2, Mod4Mask, XK_F2, },
-      { XK_F3, Mod4Mask, XK_F3, },
-      { XK_F4, Mod4Mask, XK_F4, },
-      { XK_F5, Mod4Mask, XK_F5, },
-      { XK_F6, Mod4Mask, XK_F6, },
-      { XK_F7, Mod4Mask, XK_F7, },
-      { XK_F8, Mod4Mask, XK_F8, },
-      { XK_F9, Mod4Mask, XK_F9, },
-      { XK_F10, Mod4Mask, XK_F10, },
-      { XK_F11, Mod4Mask, XK_F11, },
-      { XK_F12, Mod4Mask, XK_F12, },
-    };
-
-    rewritten = RewriteWithKeyboardRemappingsByKeySym(
-        kFkeysToFkeys,
-        arraysize(kFkeysToFkeys),
-        keysym,
-        xkey->state,
-        &remapped_native_keysym,
-        &remapped_native_mods);
-  }
-
-  if (!rewritten) {
-    static const KeyboardRemapping kFkeysToSpecialKeys[] = {
-      { XK_F1, 0, XF86XK_Back, 0 },
-      { XK_F2, 0, XF86XK_Forward, 0 },
-      { XK_F3, 0, XF86XK_Reload, 0 },
-      { XK_F4, 0, XF86XK_LaunchB, 0 },
-      { XK_F5, 0, XF86XK_LaunchA, 0 },
-      { XK_F6, 0, XF86XK_MonBrightnessDown, 0 },
-      { XK_F7, 0, XF86XK_MonBrightnessUp, 0 },
-      { XK_F8, 0, XF86XK_AudioMute, 0 },
-      { XK_F9, 0, XF86XK_AudioLowerVolume, 0 },
-      { XK_F10, 0, XF86XK_AudioRaiseVolume, 0 },
-    };
-
-    if (top_row_keys_are_special_keys) {
-      // Rewrite the F1-F12 keys on a Chromebook keyboard to special keys.
-      rewritten = RewriteWithKeyboardRemappingsByKeySym(
-          kFkeysToSpecialKeys,
-          arraysize(kFkeysToSpecialKeys),
-          keysym,
-          xkey->state,
-          &remapped_native_keysym,
-          &remapped_native_mods);
-    } else if (xkey->state & Mod4Mask) {
-      // Use Search + F1-F12 for the special keys.
-      rewritten = RewriteWithKeyboardRemappingsByKeySym(
-          kFkeysToSpecialKeys,
-          arraysize(kFkeysToSpecialKeys),
-          keysym,
-          xkey->state & ~Mod4Mask,
-          &remapped_native_keysym,
-          &remapped_native_mods);
+    //  Search? Top Row   Result
+    //  ------- --------  ------
+    //  No      Fn        Unchanged
+    //  No      System    Fn -> System
+    //  Yes     Fn        Fn -> System
+    //  Yes     System    Search+Fn -> Fn
+    if (top_row_keys_are_function_keys == search_is_pressed) {
+      // Rewrite the F1-F12 keys on a Chromebook keyboard to system keys.
+      static const KeyboardRemapping kFkeysToSystemKeys[] = {
+          {ui::VKEY_F1, 0, ui::VKEY_BROWSER_BACK, 0},
+          {ui::VKEY_F2, 0, ui::VKEY_BROWSER_FORWARD, 0},
+          {ui::VKEY_F3, 0, ui::VKEY_BROWSER_REFRESH, 0},
+          {ui::VKEY_F4, 0, ui::VKEY_MEDIA_LAUNCH_APP2, 0},
+          {ui::VKEY_F5, 0, ui::VKEY_MEDIA_LAUNCH_APP1, 0},
+          {ui::VKEY_F6, 0, ui::VKEY_BRIGHTNESS_DOWN, 0},
+          {ui::VKEY_F7, 0, ui::VKEY_BRIGHTNESS_UP, 0},
+          {ui::VKEY_F8, 0, ui::VKEY_VOLUME_MUTE, 0},
+          {ui::VKEY_F9, 0, ui::VKEY_VOLUME_DOWN, 0},
+          {ui::VKEY_F10, 0, ui::VKEY_VOLUME_UP, 0},
+      };
+      MutableKeyState incoming_without_command = incoming;
+      incoming_without_command.flags &= ~ui::EF_COMMAND_DOWN;
+      rewritten =
+          RewriteWithKeyboardRemappingsByKeyCode(kFkeysToSystemKeys,
+                                                 arraysize(kFkeysToSystemKeys),
+                                                 incoming_without_command,
+                                                 state);
+    } else if (search_is_pressed) {
+      // Allow Search to avoid rewriting F1-F12.
+      state->flags &= ~ui::EF_COMMAND_DOWN;
+      rewritten = true;
     }
   }
 
-  if (!rewritten && (xkey->state & Mod4Mask)) {
+  if (!rewritten && (incoming.flags & ui::EF_COMMAND_DOWN)) {
     // Remap Search+<number> to F<number>.
     // 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.
     static const KeyboardRemapping kNumberKeysToFkeys[] = {
-      { XK_1, Mod4Mask, XK_F1, 0 },
-      { XK_2, Mod4Mask, XK_F2, 0 },
-      { XK_3, Mod4Mask, XK_F3, 0 },
-      { XK_4, Mod4Mask, XK_F4, 0 },
-      { XK_5, Mod4Mask, XK_F5, 0 },
-      { XK_6, Mod4Mask, XK_F6, 0 },
-      { XK_7, Mod4Mask, XK_F7, 0 },
-      { XK_8, Mod4Mask, XK_F8, 0 },
-      { XK_9, Mod4Mask, XK_F9, 0 },
-      { XK_0, Mod4Mask, XK_F10, 0 },
-      { XK_minus, Mod4Mask, XK_F11, 0 },
-      { XK_equal, Mod4Mask, XK_F12, 0 }
-    };
-
+        {ui::VKEY_1, ui::EF_COMMAND_DOWN, ui::VKEY_F1, 0},
+        {ui::VKEY_2, ui::EF_COMMAND_DOWN, ui::VKEY_F2, 0},
+        {ui::VKEY_3, ui::EF_COMMAND_DOWN, ui::VKEY_F3, 0},
+        {ui::VKEY_4, ui::EF_COMMAND_DOWN, ui::VKEY_F4, 0},
+        {ui::VKEY_5, ui::EF_COMMAND_DOWN, ui::VKEY_F5, 0},
+        {ui::VKEY_6, ui::EF_COMMAND_DOWN, ui::VKEY_F6, 0},
+        {ui::VKEY_7, ui::EF_COMMAND_DOWN, ui::VKEY_F7, 0},
+        {ui::VKEY_8, ui::EF_COMMAND_DOWN, ui::VKEY_F8, 0},
+        {ui::VKEY_9, ui::EF_COMMAND_DOWN, ui::VKEY_F9, 0},
+        {ui::VKEY_0, ui::EF_COMMAND_DOWN, ui::VKEY_F10, 0},
+        {ui::VKEY_OEM_MINUS, ui::EF_COMMAND_DOWN, ui::VKEY_F11, 0},
+        {ui::VKEY_OEM_PLUS, ui::EF_COMMAND_DOWN, ui::VKEY_F12, 0}};
     rewritten = RewriteWithKeyboardRemappingsByKeyCode(
-        kNumberKeysToFkeys,
-        arraysize(kNumberKeysToFkeys),
-        xkey->keycode,
-        xkey->state,
-        &remapped_native_keysym,
-        &remapped_native_mods);
+        kNumberKeysToFkeys, arraysize(kNumberKeysToFkeys), incoming, state);
   }
-
-  if (!rewritten)
-    return false;
-
-  OverwriteEvent(event,
-                 NativeKeySymToNativeKeycode(remapped_native_keysym),
-                 remapped_native_mods);
-  return true;
 }
 
-void EventRewriter::RewriteLocatedEvent(XEvent* event) {
-  DCHECK_EQ(GenericEvent, event->type);
-  XIDeviceEvent* xievent = static_cast<XIDeviceEvent*>(event->xcookie.data);
-  if (xievent->evtype != XI_ButtonPress && xievent->evtype != XI_ButtonRelease)
+void EventRewriter::RewriteLocatedEvent(const ui::Event& event,
+                                        MutableKeyState* state) {
+  const PrefService* pref_service = GetPrefService();
+  if (!pref_service)
     return;
 
   // First, remap modifier masks.
-  unsigned int remapped_native_modifiers = 0U;
-  GetRemappedModifierMasks(xievent->mods.effective, &remapped_native_modifiers);
-  xievent->mods.effective = remapped_native_modifiers;
+  state->flags = GetRemappedModifierMasks(*pref_service, event, state->flags);
+
+#if defined(USE_X11)
+  // TODO(kpschoedel): de-X11 with unified device ids from crbug.com/360377
+  XEvent* xevent = event.native_event();
+  if (!xevent || xevent->type != GenericEvent)
+    return;
+  XIDeviceEvent* xievent = static_cast<XIDeviceEvent*>(xevent->xcookie.data);
+  if (xievent->evtype != XI_ButtonPress && xievent->evtype != XI_ButtonRelease)
+    return;
 
   // Then, remap Alt+Button1 to Button3.
   if ((xievent->evtype == XI_ButtonPress ||
        pressed_device_ids_.count(xievent->sourceid)) &&
       (xievent->mods.effective & Mod1Mask) && xievent->detail == Button1) {
+    state->flags &= ~(ui::EF_ALT_DOWN | ui::EF_LEFT_MOUSE_BUTTON);
+    state->flags |= ui::EF_RIGHT_MOUSE_BUTTON;
     xievent->mods.effective &= ~Mod1Mask;
     xievent->detail = Button3;
     if (xievent->evtype == XI_ButtonRelease) {
       // On the release clear the left button from the existing state and the
       // mods, and set the right button.
       XISetMask(xievent->buttons.mask, Button3);
       XIClearMask(xievent->buttons.mask, Button1);
       xievent->mods.effective &= ~Button1Mask;
       pressed_device_ids_.erase(xievent->sourceid);
     } else {
       pressed_device_ids_.insert(xievent->sourceid);
     }
   }
-}
-
-void EventRewriter::OverwriteEvent(XEvent* event,
-                                   unsigned int new_native_keycode,
-                                   unsigned int new_native_state) {
-  DCHECK(event->type == KeyPress || event->type == KeyRelease);
-  XKeyEvent* xkey = &event->xkey;
-  xkey->keycode = new_native_keycode;
-  xkey->state = new_native_state;
+#endif  // defined(USE_X11)
 }
 
 EventRewriter::DeviceType EventRewriter::DeviceAddedInternal(
     int device_id,
     const std::string& device_name) {
-  const DeviceType type = EventRewriter::GetDeviceType(device_name);
+  const DeviceType type = 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;
 }
 
+#if defined(USE_X11)
+void EventRewriter::WillProcessEvent(const ui::PlatformEvent& event) {
+  XEvent* xevent = event;
+  if (xevent->type == GenericEvent) {
+    XIDeviceEvent* xievent = static_cast<XIDeviceEvent*>(xevent->xcookie.data);
+    if (xievent->evtype == XI_KeyPress || xievent->evtype == XI_KeyRelease) {
+      if (xievent->deviceid == xievent->sourceid)
+        DeviceKeyPressedOrReleased(xievent->deviceid);
+    }
+  }
+}
+
+void EventRewriter::DidProcessEvent(const ui::PlatformEvent& event) {
+}
+
+void EventRewriter::DeviceHierarchyChanged() {
+}
+
+void EventRewriter::DeviceAdded(int device_id) {
+  DCHECK_NE(XIAllDevices, device_id);
+  DCHECK_NE(XIAllMasterDevices, device_id);
+  if (device_id == XIAllDevices || device_id == XIAllMasterDevices) {
+    LOG(ERROR) << "Unexpected device_id passed: " << device_id;
+    return;
+  }
+
+  int ndevices_return = 0;
+  XIDeviceInfo* device_info =
+      XIQueryDevice(gfx::GetXDisplay(), device_id, &ndevices_return);
+
+  // Since |device_id| is neither XIAllDevices nor XIAllMasterDevices,
+  // the number of devices found should be either 0 (not found) or 1.
+  if (!device_info) {
+    LOG(ERROR) << "XIQueryDevice: Device ID " << device_id << " is unknown.";
+    return;
+  }
+
+  DCHECK_EQ(1, ndevices_return);
+  for (int i = 0; i < ndevices_return; ++i) {
+    DCHECK_EQ(device_id, device_info[i].deviceid);  // see the comment above.
+    DCHECK(device_info[i].name);
+    DeviceAddedInternal(device_info[i].deviceid, device_info[i].name);
+  }
+
+  XIFreeDeviceInfo(device_info);
+}
+
+void EventRewriter::DeviceRemoved(int device_id) {
+  device_id_to_type_.erase(device_id);
+}
+#endif
+
 }  // namespace chromeos