Use XInput2 events for keyboard events.

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 <vector>
 
 #include "ash/sticky_keys/sticky_keys_controller.h"
 #include "ash/wm/window_state.h"
 #include "ash/wm/window_util.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_util.h"
 #include "base/sys_info.h"
 #include "chrome/browser/chromeos/login/ui/login_display_host_impl.h"
 #include "chrome/browser/chromeos/login/users/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/events/event.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/keycodes/keyboard_code_conversion.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"
 #include "ui/events/keycodes/keyboard_code_conversion_x.h"
 #endif
 
 namespace chromeos {
 
 namespace {
 
-const int kBadDeviceId = -1;
-
 // 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
@@ skipping 87 matching lines @@
     {ui::EF_MIDDLE_MOUSE_BUTTON, Button2Mask},
     {ui::EF_RIGHT_MOUSE_BUTTON, Button3Mask},
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(flags); ++i) {
     if (ui_flags & flags[i].ui)
       *x_flags |= flags[i].x;
     else
       *x_flags &= ~flags[i].x;
   }
 }
+
+void UpdateX11Button(int ui_flag, unsigned int* x_button) {
+  switch (ui_flag) {
+    case ui::EF_LEFT_MOUSE_BUTTON:
+      *x_button = Button1;
+      break;
+    case ui::EF_MIDDLE_MOUSE_BUTTON:
+      *x_button = Button2;
+      break;
+    case ui::EF_RIGHT_MOUSE_BUTTON:
+      *x_button = Button3;
+      break;
+  }
+}
 #endif
 
 bool IsSendEvent(const ui::Event& 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 true;
 #endif
   return false;
 }
 
 }  // namespace
 
 EventRewriter::EventRewriter(ash::StickyKeysController* sticky_keys_controller)
-    : last_device_id_(kBadDeviceId),
+    : last_keyboard_device_id_(ui::ED_UNKNOWN_DEVICE),
       ime_keyboard_for_testing_(NULL),
       pref_service_for_testing_(NULL),
       sticky_keys_controller_(sticky_keys_controller) {
-#if defined(USE_X11)
-  ui::PlatformEventSource::GetInstance()->AddPlatformEventObserver(this);
-  if (base::SysInfo::IsRunningOnChromeOS()) {
-    XInputHierarchyChangedEventListener::GetInstance()->AddObserver(this);
-  }
-#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(
+EventRewriter::DeviceType EventRewriter::KeyboardDeviceAddedForTesting(
     int device_id,
     const std::string& device_name) {
-  return DeviceAddedInternal(device_id, device_name);
+  // Tests must avoid XI2 reserved device IDs.
+  DCHECK((device_id < 0) || (device_id > 1));
+  return KeyboardDeviceAddedInternal(device_id, device_name);
 }
 
-void EventRewriter::RewriteLocatedEventForTesting(const ui::Event& event,
-                                                  int* flags) {
-  RewriteLocatedEvent(event, flags);
+void EventRewriter::RewriteMouseButtonEventForTesting(
+    const ui::MouseEvent& event,
+    scoped_ptr<ui::Event>* rewritten_event) {
+  RewriteMouseButtonEvent(event, rewritten_event);
 }
 
 ui::EventRewriteStatus EventRewriter::RewriteEvent(
     const ui::Event& event,
     scoped_ptr<ui::Event>* rewritten_event) {
   if ((event.type() == ui::ET_KEY_PRESSED) ||
       (event.type() == ui::ET_KEY_RELEASED)) {
     return RewriteKeyEvent(static_cast<const ui::KeyEvent&>(event),
                            rewritten_event);
   }
@@ skipping 26 matching lines @@
     // modifier key releases that match the ones previously discarded. So, we
     // know that they don't have to be passed through the post-sticky key
     // rewriting phases, |RewriteExtendedKeys()| and |RewriteFunctionKeys()|,
     // because those phases do nothing with modifier key releases.
     return sticky_keys_controller_->NextDispatchEvent(new_event);
   }
   NOTREACHED();
   return ui::EVENT_REWRITE_CONTINUE;
 }
 
+void EventRewriter::BuildRewrittenKeyEvent(
+    const ui::KeyEvent& key_event,
+    ui::KeyboardCode key_code,
+    int flags,
+    scoped_ptr<ui::Event>* rewritten_event) {
+  ui::KeyEvent* rewritten_key_event = 0;

[Daniel Erat, 2014/06/25 20:06:13]

nit: this should still be NULL

[kpschoedel, 2014/06/25 21:10:40]

Done.

 #if defined(USE_X11)
+  XEvent* xev = key_event.native_event();
+  if (xev) {
+    XEvent xkeyevent;
+    // Convert all XI2-based key events into X11 core-based key events,
+    // until consumers no longer depend on receiving X11 core events.
+    if (xev->type == GenericEvent)
+      ui::InitXKeyEventFromXIDeviceEvent(*xev, &xkeyevent);
+    else
+      xkeyevent.xkey = xev->xkey;
+
+    // Update native event to match rewritten |ui::Event|.
+    xkeyevent.xkey.keycode = XKeysymToKeycode(
+        gfx::GetXDisplay(),
+        ui::XKeysymForWindowsKeyCode(key_code, flags & ui::EF_SHIFT_DOWN));
+    UpdateX11EventMask(flags, &xkeyevent.xkey.state);
+    ui::KeyEvent x11_key_event(&xkeyevent, false);
+    rewritten_key_event = new ui::KeyEvent(x11_key_event);
+  }
+#endif
+  if (!rewritten_key_event)
+    rewritten_key_event = new ui::KeyEvent(key_event);
+  rewritten_key_event->set_flags(flags);
+  rewritten_key_event->set_key_code(key_code);
+  rewritten_key_event->set_character(
+      ui::GetCharacterFromKeyCode(key_code, flags));
+  rewritten_key_event->NormalizeFlags();
+  rewritten_event->reset(rewritten_key_event);
+}
+
 void EventRewriter::DeviceKeyPressedOrReleased(int device_id) {
-  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;
+  if (!device_id_to_type_.count(device_id))
+    KeyboardDeviceAdded(device_id);
+  last_keyboard_device_id_ = device_id;
 }
-#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;
 }
 
 bool EventRewriter::IsAppleKeyboard() const {
-  if (last_device_id_ == kBadDeviceId)
+  if (last_keyboard_device_id_ == ui::ED_UNKNOWN_DEVICE)
     return false;
 
   // Check which device generated |event|.
   std::map<int, DeviceType>::const_iterator iter =
-      device_id_to_type_.find(last_device_id_);
+      device_id_to_type_.find(last_keyboard_device_id_);
   if (iter == device_id_to_type_.end()) {
-    LOG(ERROR) << "Device ID " << last_device_id_ << " is unknown.";
+    LOG(ERROR) << "Device ID " << last_keyboard_device_id_ << " is unknown.";
     return false;
   }
 
   const DeviceType type = iter->second;
   return type == kDeviceAppleKeyboard;
 }
 
 bool EventRewriter::TopRowKeysAreFunctionKeys(const ui::KeyEvent& 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;
 }
 
 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;
+    const ModifierRemapping* remapped_key = NULL;
     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;
@@ skipping 37 matching lines @@
     remapped_state->key_code = map.output_key_code;
     remapped_state->flags = (input.flags & ~map.input_flags) | map.output_flags;
     return true;
   }
   return false;
 }
 
 ui::EventRewriteStatus EventRewriter::RewriteKeyEvent(
     const ui::KeyEvent& key_event,
     scoped_ptr<ui::Event>* rewritten_event) {
+  if (key_event.source_device_id() != ui::ED_UNKNOWN_DEVICE)
+    DeviceKeyPressedOrReleased(key_event.source_device_id());
   MutableKeyState state = {key_event.flags(), key_event.key_code()};
   bool is_send_event = IsSendEvent(key_event);
   if (!is_send_event) {
     RewriteModifierKeys(key_event, &state);
     RewriteNumPadKeys(key_event, &state);
   }
   ui::EventRewriteStatus status = ui::EVENT_REWRITE_CONTINUE;
   if (sticky_keys_controller_) {
     status = sticky_keys_controller_->RewriteKeyEvent(
         key_event, state.key_code, &state.flags);
     if (status == ui::EVENT_REWRITE_DISCARD)
       return ui::EVENT_REWRITE_DISCARD;
   }
   if (!is_send_event) {
     RewriteExtendedKeys(key_event, &state);
     RewriteFunctionKeys(key_event, &state);
   }
   if ((key_event.flags() == state.flags) &&
       (key_event.key_code() == state.key_code) &&
+#if defined(USE_X11)
+      // TODO(kpschoedel): This test is present because several consumers of
+      // key events depend on having a native core X11 event, so we rewrite
+      // all XI2 key events (GenericEvent) into corresponding core X11 key
+      // events. Remove this when event consumers no longer care about
+      // native X11 event details (crbug.com/380349).
+      (!key_event.HasNativeEvent() ||
+       (key_event.native_event()->type != GenericEvent)) &&
+#endif
       (status == ui::EVENT_REWRITE_CONTINUE)) {
     return ui::EVENT_REWRITE_CONTINUE;
   }
   // Sticky keys may have returned a result other than |EVENT_REWRITE_CONTINUE|,
   // in which case we need to preserve that return status. Alternatively, we
-  // might be here because key_event changed, in which case we need to return
-  // |EVENT_REWRITE_REWRITTEN|.
+  // might be here because key_event changed, in which case we need to
+  // return |EVENT_REWRITE_REWRITTEN|.
   if (status == ui::EVENT_REWRITE_CONTINUE)
     status = ui::EVENT_REWRITE_REWRITTEN;
-  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);
-  rewritten_key_event->set_character(
-      ui::GetCharacterFromKeyCode(state.key_code, state.flags));
-  rewritten_key_event->NormalizeFlags();
-#if defined(USE_X11)
-  XEvent* xev = rewritten_key_event->native_event();
-  if (xev) {
-    CHECK(xev->type == KeyPress || xev->type == KeyRelease);
-    XKeyEvent* xkey = &(xev->xkey);
-    UpdateX11EventMask(rewritten_key_event->flags(), &xkey->state);
-    xkey->keycode =
-        XKeysymToKeycode(gfx::GetXDisplay(),
-                         ui::XKeysymForWindowsKeyCode(
-                             state.key_code, state.flags & ui::EF_SHIFT_DOWN));
-  }
-#endif
+  BuildRewrittenKeyEvent(
+      key_event, state.key_code, state.flags, rewritten_event);
   return status;
 }
 
 ui::EventRewriteStatus EventRewriter::RewriteMouseButtonEvent(
     const ui::MouseEvent& mouse_event,
     scoped_ptr<ui::Event>* rewritten_event) {
   int flags = mouse_event.flags();
   RewriteLocatedEvent(mouse_event, &flags);
   ui::EventRewriteStatus status = ui::EVENT_REWRITE_CONTINUE;
   if (sticky_keys_controller_)
     status = sticky_keys_controller_->RewriteMouseEvent(mouse_event, &flags);
+  int changed_button = ui::EF_NONE;
+  if ((mouse_event.type() == ui::ET_MOUSE_PRESSED) ||
+      (mouse_event.type() == ui::ET_MOUSE_RELEASED)) {
+    changed_button = RewriteModifierClick(mouse_event, &flags);
+  }
   if ((mouse_event.flags() == flags) &&
       (status == ui::EVENT_REWRITE_CONTINUE)) {
     return ui::EVENT_REWRITE_CONTINUE;
   }
   if (status == ui::EVENT_REWRITE_CONTINUE)
     status = ui::EVENT_REWRITE_REWRITTEN;
   ui::MouseEvent* rewritten_mouse_event = new ui::MouseEvent(mouse_event);
   rewritten_event->reset(rewritten_mouse_event);
   rewritten_mouse_event->set_flags(flags);
+  if (changed_button != ui::EF_NONE)
+    rewritten_mouse_event->set_changed_button_flags(changed_button);
 #if defined(USE_X11)
   XEvent* xev = rewritten_mouse_event->native_event();
   if (xev) {
     switch (xev->type) {
       case ButtonPress:
       case ButtonRelease: {
         XButtonEvent* xbutton = &(xev->xbutton);
         UpdateX11EventMask(rewritten_mouse_event->flags(), &xbutton->state);
+        if (changed_button)
+          UpdateX11Button(changed_button, &xbutton->button);
         break;
       }
       case GenericEvent: {
         XIDeviceEvent* xievent = static_cast<XIDeviceEvent*>(xev->xcookie.data);
         CHECK(xievent->evtype == XI_ButtonPress ||
               xievent->evtype == XI_ButtonRelease);
         UpdateX11EventMask(
             rewritten_mouse_event->flags(),
             reinterpret_cast<unsigned int*>(&xievent->mods.effective));
+        if (changed_button) {
+          UpdateX11Button(changed_button,
+                          reinterpret_cast<unsigned int*>(&xievent->detail));
+        }
         break;
       }
       default:
         NOTREACHED();
     }
   }
 #endif
   return status;
 }
 
@@ skipping 378 matching lines @@
     rewritten = RewriteWithKeyboardRemappingsByKeyCode(
         kNumberKeysToFkeys, arraysize(kNumberKeysToFkeys), incoming, state);
   }
 }
 
 void EventRewriter::RewriteLocatedEvent(const ui::Event& event,
                                         int* flags) {
   const PrefService* pref_service = GetPrefService();
   if (!pref_service)
     return;
-
-  // First, remap modifier masks.
   *flags = GetRemappedModifierMasks(*pref_service, event, *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;
-  UpdateX11EventMask(*flags,
-                     reinterpret_cast<unsigned int*>(&xievent->mods.effective));
-
-  // Then, remap Alt+Button1 to Button3.
-  if ((xievent->evtype == XI_ButtonPress ||
-       pressed_device_ids_.count(xievent->sourceid)) &&
-      (xievent->mods.effective & Mod1Mask) && xievent->detail == Button1) {
-    *flags &= ~(ui::EF_ALT_DOWN | ui::EF_LEFT_MOUSE_BUTTON);
-    *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);
-    }
-  }
-#endif  // defined(USE_X11)
 }
 
-EventRewriter::DeviceType EventRewriter::DeviceAddedInternal(
+int EventRewriter::RewriteModifierClick(const ui::MouseEvent& mouse_event,
+                                        int* flags) {
+  // Remap Alt+Button1 to Button3.
+  const int kAltLeftButton = (ui::EF_ALT_DOWN | ui::EF_LEFT_MOUSE_BUTTON);
+  if (((*flags & kAltLeftButton) == kAltLeftButton) &&
+      ((mouse_event.type() == ui::ET_MOUSE_PRESSED) ||
+       pressed_device_ids_.count(mouse_event.source_device_id()))) {
+    *flags &= ~kAltLeftButton;
+    *flags |= ui::EF_RIGHT_MOUSE_BUTTON;
+    if (mouse_event.type() == ui::ET_MOUSE_PRESSED)
+      pressed_device_ids_.insert(mouse_event.source_device_id());
+    else
+      pressed_device_ids_.erase(mouse_event.source_device_id());
+    return ui::EF_RIGHT_MOUSE_BUTTON;
+  }
+  return ui::EF_NONE;
+}
+
+EventRewriter::DeviceType EventRewriter::KeyboardDeviceAddedInternal(
     int device_id,
     const std::string& 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;
 }
 
+void EventRewriter::KeyboardDeviceAdded(int device_id) {
 #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);
+    KeyboardDeviceAddedInternal(device_info[i].deviceid, device_info[i].name);
   }
 
   XIFreeDeviceInfo(device_info);
+#else
+  KeyboardDeviceAddedInternal(device_id, "keyboard");
+#endif
 }
 
-void EventRewriter::DeviceRemoved(int device_id) {
-  device_id_to_type_.erase(device_id);
-}
-#endif
-
 }  // namespace chromeos