Suppress Xorg generated key repeat events for Hotrod remote

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"
@@ skipping 12 matching lines @@
 #include "chromeos/ime/ime_keyboard.h"
 #include "chromeos/ime/input_method_manager.h"
 #include "components/user_manager/user_manager.h"
 #include "ui/events/event.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/keycodes/keyboard_code_conversion.h"
 #include "ui/wm/core/window_util.h"
 
 #if defined(USE_X11)
 #include <X11/extensions/XInput2.h>
+#include <X11/Xatom.h>
 #include <X11/Xlib.h>
+
+#ifndef XI_PROP_PRODUCT_ID
+#define XI_PROP_PRODUCT_ID "Device Product ID"
+#endif
+
 // Get rid of macros from Xlib.h that conflicts with other parts of the code.
 #undef RootWindow
 #undef Status
 
 #include "ui/base/x/x11_util.h"
 #include "ui/events/keycodes/keyboard_code_conversion_x.h"
 #endif
 
 namespace chromeos {
 
 namespace {
 
+// Hotrod controller vendor/product ids.
+const int kHotrodRemoteVendorId = 0x0471;
+const int kHotrodRemoteProductId = 0x21cc;
+const int kUnknownVendorId = -1;
+const int kUnknownProductId = -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 64 matching lines @@
   if (!profile || !extensions::ExtensionCommandsGlobalRegistry::Get(profile))
     return false;
 
   int modifiers = flags & (ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN |
                            ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN);
   ui::Accelerator accelerator(key_code, modifiers);
   return extensions::ExtensionCommandsGlobalRegistry::Get(profile)
       ->IsRegistered(accelerator);
 }
 
-EventRewriter::DeviceType GetDeviceType(const std::string& device_name) {
+EventRewriter::DeviceType GetDeviceType(const std::string& device_name,
+                                        int vendor_id,
+                                        int product_id) {
+  if (vendor_id == kHotrodRemoteVendorId &&
+      product_id == kHotrodRemoteProductId) {
+    return EventRewriter::kDeviceHotrodRemote;
+  }
+
+  if (LowerCaseEqualsASCII(device_name, "virtual core keyboard"))
+    return EventRewriter::kDeviceVirtualCoreKeyboard;
+
   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)
@@ skipping 14 matching lines @@
 }
 
 EventRewriter::~EventRewriter() {
 }
 
 EventRewriter::DeviceType EventRewriter::KeyboardDeviceAddedForTesting(
     int device_id,
     const std::string& device_name) {
   // Tests must avoid XI2 reserved device IDs.
   DCHECK((device_id < 0) || (device_id > 1));
-  return KeyboardDeviceAddedInternal(device_id, device_name);
+  return KeyboardDeviceAddedInternal(device_id,
+                                     device_name,
+                                     kUnknownVendorId,
+                                     kUnknownProductId);
 }
 
 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,
@@ skipping 94 matching lines @@
   rewritten_key_event->set_flags(flags);
   rewritten_key_event->set_key_code(key_code);
 #if defined(USE_X11)
   ui::UpdateX11EventForFlags(rewritten_key_event);
   rewritten_key_event->NormalizeFlags();
 #endif
   rewritten_event->reset(rewritten_key_event);
 }
 
 void EventRewriter::DeviceKeyPressedOrReleased(int device_id) {
-  if (!device_id_to_type_.count(device_id))
-    KeyboardDeviceAdded(device_id);
+  std::map<int, DeviceType>::const_iterator iter =
+        device_id_to_type_.find(device_id);
+  DeviceType type;
+  if (iter != device_id_to_type_.end())
+    type = iter->second;
+  else
+    type = KeyboardDeviceAdded(device_id);
+
+  // Ignore virtual Xorg keyboard (magic that generates key repeat
+  // events). Pretend that the previous real keyboard is the one that is still
+  // in use.
+  if (type == kDeviceVirtualCoreKeyboard)
+    return;
+
   last_keyboard_device_id_ = device_id;
 }
 
 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 {
+  return IsLastKeyboardOfType(kDeviceAppleKeyboard);
+}
+
+bool EventRewriter::IsHotrodRemote() const {
+  return IsLastKeyboardOfType(kDeviceHotrodRemote);
+}
+
+bool EventRewriter::IsLastKeyboardOfType(DeviceType device_type) const {
   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_keyboard_device_id_);
   if (iter == device_id_to_type_.end()) {
     LOG(ERROR) << "Device ID " << last_keyboard_device_id_ << " is unknown.";
     return false;
   }
 
   const DeviceType type = iter->second;
-  return type == kDeviceAppleKeyboard;
+  return type == device_type;
 }
 
 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;
@@ skipping 61 matching lines @@
   return false;
 }
 
 ui::EventRewriteStatus EventRewriter::RewriteKeyEvent(
     const ui::KeyEvent& key_event,
     scoped_ptr<ui::Event>* rewritten_event) {
   if (IsExtensionCommandRegistered(key_event.key_code(), key_event.flags()))
     return ui::EVENT_REWRITE_CONTINUE;
   if (key_event.source_device_id() != ui::ED_UNKNOWN_DEVICE)
     DeviceKeyPressedOrReleased(key_event.source_device_id());
+
+  // Drop repeated keys from Hotrod remote.
+  if ((key_event.flags() & ui::EF_IS_REPEAT) &&
+      (key_event.type() == ui::ET_KEY_PRESSED) &&
+      IsHotrodRemote() && key_event.key_code() != ui::VKEY_BACK) {
+    return ui::EVENT_REWRITE_DISCARD;
+  }
+
   MutableKeyState state = {key_event.flags(), key_event.key_code()};
   // Do not rewrite an event sent by ui_controls::SendKeyPress(). See
   // crbug.com/136465.
   if (!(key_event.flags() & ui::EF_FINAL)) {
     RewriteModifierKeys(key_event, &state);
     RewriteNumPadKeys(key_event, &state);
   }
+
   ui::EventRewriteStatus status = ui::EVENT_REWRITE_CONTINUE;
   bool is_sticky_key_extension_command = false;
   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;
     is_sticky_key_extension_command =
         IsExtensionCommandRegistered(state.key_code, state.flags);
   }
@@ skipping 440 matching lines @@
       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);
+    const std::string& device_name,
+    int vendor_id,
+    int product_id) {
+  const DeviceType type = GetDeviceType(device_name, vendor_id, product_id);
   if (type == kDeviceAppleKeyboard) {
     VLOG(1) << "Apple keyboard '" << device_name << "' connected: "
             << "id=" << device_id;
+  } else if (type == kDeviceHotrodRemote) {
+    VLOG(1) << "Hotrod remote '" << device_name << "' connected: "
+            << "id=" << device_id;
+  } else if (type == kDeviceVirtualCoreKeyboard) {
+    VLOG(1) << "Xorg virtual '" << device_name << "' connected: "
+            << "id=" << device_id;
+  } else {
+    VLOG(1) << "Unknown 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) {
+EventRewriter::DeviceType EventRewriter::KeyboardDeviceAdded(int device_id) {
 #if defined(USE_X11)
   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;
+    return kDeviceUnknown;
   }
 
+  Atom product_id_atom =
+      XInternAtom(gfx::GetXDisplay(), XI_PROP_PRODUCT_ID, 1);
+
   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;
+    return kDeviceUnknown;
   }
 
+  DeviceType dev_type;
   DCHECK_EQ(1, ndevices_return);
   for (int i = 0; i < ndevices_return; ++i) {
+    // Get keyboard product and vendor id.
+    int vendor_id = kUnknownVendorId;
+    int product_id = kUnknownProductId;
+    uint32* product_info = NULL;
+    Atom type;
+    int format_return;
+    unsigned long num_items_return;
+    unsigned long bytes_after_return;
+    if (XIGetProperty(gfx::GetXDisplay(),
+                      device_info[i].deviceid,
+                      product_id_atom,
+                      0,
+                      2,
+                      0,
+                      XA_INTEGER,
+                      &type,
+                      &format_return,
+                      &num_items_return,
+                      &bytes_after_return,
+                      reinterpret_cast<unsigned char **>(&product_info)) == 0 &&
+        product_info) {
+      vendor_id = product_info[0];
+      product_id = product_info[1];
+    }
+
     DCHECK_EQ(device_id, device_info[i].deviceid);  // see the comment above.
     DCHECK(device_info[i].name);
-    KeyboardDeviceAddedInternal(device_info[i].deviceid, device_info[i].name);
+    dev_type = KeyboardDeviceAddedInternal(device_info[i].deviceid,
+                                           device_info[i].name,
+                                           vendor_id,
+                                           product_id);
   }
-
   XIFreeDeviceInfo(device_info);
+  return dev_type;
 #else
-  KeyboardDeviceAddedInternal(device_id, "keyboard");
+  // TODO(spang): Figure out where we can get keyboard vendor/product id from in
+  // Ozone/Freon version.
+  return KeyboardDeviceAddedInternal(device_id,
+                                     "keyboard",
+                                     kUnknownVendorId,
+                                     kUnknownProductId);
 #endif
 }
 
 }  // namespace chromeos