Ozone support for device special cases in keyboard event rewriting.

ui/events/ozone/evdev/keyboard_evdev.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 "ui/events/ozone/evdev/keyboard_evdev.h"
 
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "ui/events/event.h"
 #include "ui/events/event_constants.h"
@@ skipping 45 matching lines @@
 
 KeyboardEvdev::KeyboardEvdev(EventModifiersEvdev* modifiers,
                              KeyboardLayoutEngine* keyboard_layout_engine,
                              const EventDispatchCallback& callback)
     : callback_(callback),
       modifiers_(modifiers),
       keyboard_layout_engine_(keyboard_layout_engine),
       repeat_enabled_(true),
       repeat_key_(KEY_RESERVED),
       repeat_sequence_(0),
+      repeat_device_id_(0),

[spang, 2015/04/08 22:54:30]

We're using -1 for invalid/synthetic/injected device id.

[spang, 2015/04/08 22:56:53]

Oh, it appears I'm wrong. Nevermind.

[kpschoedel, 2015/04/09 18:51:41]

Acknowledged.

       weak_ptr_factory_(this) {
   repeat_delay_ = base::TimeDelta::FromMilliseconds(kRepeatDelayMs);
   repeat_interval_ = base::TimeDelta::FromMilliseconds(kRepeatIntervalMs);
 }
 
 KeyboardEvdev::~KeyboardEvdev() {
 }
 
 void KeyboardEvdev::OnKeyChange(unsigned int key,
                                 bool down,
-                                base::TimeDelta timestamp) {
+                                base::TimeDelta timestamp,
+                                int device_id) {
   if (key > KEY_MAX)
     return;
 
   if (down == key_state_.test(key))
     return;
 
   // State transition: !(down) -> (down)
   if (down)
     key_state_.set(key);
   else
     key_state_.reset(key);
 
-  UpdateKeyRepeat(key, down);
-  DispatchKey(key, down, false /* repeat */, timestamp);
+  UpdateKeyRepeat(key, down, device_id);
+  DispatchKey(key, down, false /* repeat */, timestamp, device_id);
 }
 
 void KeyboardEvdev::SetCapsLockEnabled(bool enabled) {
   modifiers_->SetModifierLock(EVDEV_MODIFIER_CAPS_LOCK, enabled);
 }
 
 bool KeyboardEvdev::IsCapsLockEnabled() {
   return (modifiers_->GetModifierFlags() & EF_CAPS_LOCK_DOWN) != 0;
 }
 
@@ skipping 31 matching lines @@
   // key may or may not be down, but usually isn't). There does need to
   // to be two different flags, since the physical CapsLock key is subject
   // to remapping, but the caps lock state (which can be triggered in a
   // variety of ways) is not.
   if (modifier == EVDEV_MODIFIER_CAPS_LOCK)
     modifiers_->UpdateModifier(EVDEV_MODIFIER_MOD3, down);
   else
     modifiers_->UpdateModifier(modifier, down);
 }
 
-void KeyboardEvdev::UpdateKeyRepeat(unsigned int key, bool down) {
+void KeyboardEvdev::UpdateKeyRepeat(unsigned int key,
+                                    bool down,
+                                    int device_id) {
   if (!repeat_enabled_)
     StopKeyRepeat();
   else if (key != repeat_key_ && down)
-    StartKeyRepeat(key);
+    StartKeyRepeat(key, device_id);
   else if (key == repeat_key_ && !down)
     StopKeyRepeat();
 }
 
-void KeyboardEvdev::StartKeyRepeat(unsigned int key) {
+void KeyboardEvdev::StartKeyRepeat(unsigned int key, int device_id) {
   repeat_key_ = key;
+  repeat_device_id_ = device_id;
   repeat_sequence_++;
 
   ScheduleKeyRepeat(repeat_delay_);
 }
 
 void KeyboardEvdev::StopKeyRepeat() {
+  repeat_key_ = KEY_RESERVED;
   repeat_sequence_++;
 }
 
 void KeyboardEvdev::ScheduleKeyRepeat(const base::TimeDelta& delay) {
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, base::Bind(&KeyboardEvdev::OnRepeatTimeout,
                             weak_ptr_factory_.GetWeakPtr(), repeat_sequence_),
       delay);
 }
 
 void KeyboardEvdev::OnRepeatTimeout(unsigned int sequence) {
   if (repeat_sequence_ != sequence)
     return;
 
   DispatchKey(repeat_key_, true /* down */, true /* repeat */,
-              EventTimeForNow());
+              EventTimeForNow(), repeat_device_id_);
 
   ScheduleKeyRepeat(repeat_interval_);
 }
 
 void KeyboardEvdev::DispatchKey(unsigned int key,
                                 bool down,
                                 bool repeat,
-                                base::TimeDelta timestamp) {
+                                base::TimeDelta timestamp,
+                                int device_id) {
   DomCode dom_code =
       KeycodeConverter::NativeKeycodeToDomCode(EvdevCodeToNativeCode(key));
   // DomCode constants are not included here because of conflicts with
   // evdev preprocessor macros.
   if (!static_cast<int>(dom_code))
     return;
   int flags = modifiers_->GetModifierFlags();
   DomKey dom_key;
   KeyboardCode key_code;
   uint16 character;
   uint32 platform_keycode = 0;
   if (!keyboard_layout_engine_->Lookup(dom_code, flags, &dom_key, &character,
                                        &key_code, &platform_keycode)) {
     return;
   }
   if (!repeat)
     UpdateModifier(ModifierDomKeyToEventFlag(dom_key), down);
 
   KeyEvent event(down ? ET_KEY_PRESSED : ET_KEY_RELEASED, key_code, dom_code,
                  modifiers_->GetModifierFlags(), dom_key, character, timestamp);
+  event.set_source_device_id(device_id);
   if (platform_keycode)
     event.set_platform_keycode(platform_keycode);
   callback_.Run(&event);
 }
 
 }  // namespace ui