ozone: evdev: Factor keyboard into KeyboardEvdev

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/key_event_converter_evdev.h"
+#include "ui/events/ozone/evdev/keyboard_evdev.h"
 
-#include <errno.h>
-#include <linux/input.h>
-
-#include "base/message_loop/message_loop.h"
 #include "ui/events/event.h"
 #include "ui/events/keycodes/dom4/keycode_converter.h"
-#include "ui/events/keycodes/keyboard_codes.h"
 #include "ui/events/ozone/evdev/event_modifiers_evdev.h"
 
 namespace ui {
 
 namespace {
 
 const int kXkbKeycodeOffset = 8;
 
-ui::KeyboardCode KeyboardCodeFromButton(unsigned int code) {
+ui::KeyboardCode KeyboardCodeFromEvdevKey(unsigned int code) {
   static const ui::KeyboardCode kLinuxBaseKeyMap[] = {
       ui::VKEY_UNKNOWN,            // KEY_RESERVED
       ui::VKEY_ESCAPE,             // KEY_ESC
       ui::VKEY_1,                  // KEY_1
       ui::VKEY_2,                  // KEY_2
       ui::VKEY_3,                  // KEY_3
       ui::VKEY_4,                  // KEY_4
       ui::VKEY_5,                  // KEY_5
       ui::VKEY_6,                  // KEY_6
       ui::VKEY_7,                  // KEY_7
@@ skipping 118 matching lines @@
       ui::VKEY_APPS,               // KEY_COMPOSE
   };
 
   if (code < arraysize(kLinuxBaseKeyMap))
     return kLinuxBaseKeyMap[code];
 
   LOG(ERROR) << "Unknown key code: " << code;
   return ui::VKEY_UNKNOWN;
 }
 
-int ModifierFromButton(unsigned int code) {
+int ModifierFromEvdevKey(unsigned int code) {
   switch (code) {
     case KEY_CAPSLOCK:
       return EVDEV_MODIFIER_CAPS_LOCK;
     case KEY_LEFTSHIFT:
     case KEY_RIGHTSHIFT:
       return EVDEV_MODIFIER_SHIFT;
     case KEY_LEFTCTRL:
     case KEY_RIGHTCTRL:
       return EVDEV_MODIFIER_CONTROL;
     case KEY_LEFTALT:
     case KEY_RIGHTALT:
       return EVDEV_MODIFIER_ALT;
     case BTN_LEFT:
       return EVDEV_MODIFIER_LEFT_MOUSE_BUTTON;
     case BTN_MIDDLE:
       return EVDEV_MODIFIER_MIDDLE_MOUSE_BUTTON;
     case BTN_RIGHT:
       return EVDEV_MODIFIER_RIGHT_MOUSE_BUTTON;
     case KEY_LEFTMETA:
     case KEY_RIGHTMETA:
       return EVDEV_MODIFIER_COMMAND;
     default:
       return EVDEV_MODIFIER_NONE;
   }
 }
 
-bool IsLockButton(unsigned int code) { return code == KEY_CAPSLOCK; }
+bool IsModifierLockKeyFromEvdevKey(unsigned int code) {
+  return code == KEY_CAPSLOCK;
+}
 
 }  // namespace
 
-KeyEventConverterEvdev::KeyEventConverterEvdev(
-    int fd,
-    base::FilePath path,
-    int id,
-    EventModifiersEvdev* modifiers,
-    const EventDispatchCallback& callback)
-    : EventConverterEvdev(fd, path, id),
-      callback_(callback),
-      modifiers_(modifiers) {
-  // TODO(spang): Initialize modifiers using EVIOCGKEY.
+KeyboardEvdev::KeyboardEvdev(EventModifiersEvdev* modifiers,
+                             const EventDispatchCallback& callback)
+    : callback_(callback), modifiers_(modifiers) {
 }
 
-KeyEventConverterEvdev::~KeyEventConverterEvdev() {
-  Stop();
-  close(fd_);
+KeyboardEvdev::~KeyboardEvdev() {
 }
 
-void KeyEventConverterEvdev::OnFileCanReadWithoutBlocking(int fd) {
-  input_event inputs[4];
-  ssize_t read_size = read(fd, inputs, sizeof(inputs));
-  if (read_size < 0) {
-    if (errno == EINTR || errno == EAGAIN)
-      return;
-    if (errno != ENODEV)
-      PLOG(ERROR) << "error reading device " << path_.value();
-    Stop();
+void KeyboardEvdev::OnKeyChange(unsigned int key, bool down) {
+  if (key > KEY_MAX)
     return;
+
+  if (down != key_state_.test(key)) {
+    // State transition: !(down) -> (down)
+    if (down)
+      key_state_.set(key);
+    else
+      key_state_.reset(key);
+
+    UpdateModifier(key, down);
   }
 
-  DCHECK_EQ(read_size % sizeof(*inputs), 0u);
-  ProcessEvents(inputs, read_size / sizeof(*inputs));
+  DispatchKey(key, down);
 }
 
-void KeyEventConverterEvdev::ProcessEvents(const input_event* inputs,
-                                           int count) {
-  for (int i = 0; i < count; ++i) {
-    const input_event& input = inputs[i];
-    if (input.type == EV_KEY) {
-      ConvertKeyEvent(input.code, input.value);
-    } else if (input.type == EV_SYN) {
-      // TODO(sadrul): Handle this case appropriately.
-    }
-  }
+void KeyboardEvdev::UpdateModifier(unsigned int key, bool down) {
+  int modifier = ModifierFromEvdevKey(key);
+  int locking = IsModifierLockKeyFromEvdevKey(key);
+
+  if (modifier == EVDEV_MODIFIER_NONE)
+    return;
+
+  if (locking)
+    modifiers_->UpdateModifierLock(modifier, down);
+  else
+    modifiers_->UpdateModifier(modifier, down);
 }
 
-void KeyEventConverterEvdev::ConvertKeyEvent(int key, int value) {
-  int down = (value != 0);
-  int repeat = (value == 2);
-  int modifier = ModifierFromButton(key);
-  ui::KeyboardCode code = KeyboardCodeFromButton(key);
-
-  if (!repeat && (modifier != EVDEV_MODIFIER_NONE)) {
-    if (IsLockButton(key)) {
-      // Locking modifier keys: CapsLock.
-      modifiers_->UpdateModifierLock(modifier, down);
-    } else {
-      // Regular modifier keys: Shift, Ctrl, Alt, etc.
-      modifiers_->UpdateModifier(modifier, down);
-    }
-  }
-
+void KeyboardEvdev::DispatchKey(unsigned int key, bool down) {
+  ui::KeyboardCode code = KeyboardCodeFromEvdevKey(key);
   int flags = modifiers_->GetModifierFlags();
 
   KeyEvent key_event(
       down ? ET_KEY_PRESSED : ET_KEY_RELEASED,
       code,
       KeycodeConverter::NativeKeycodeToCode(key + kXkbKeycodeOffset),
       flags);
   callback_.Run(&key_event);
 }
 
 }  // namespace ui