[ozone/wayland] Implement basic keyboard handling support

ui/ozone/platform/wayland/wayland_keyboard.cc

+// Copyright 2016 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/ozone/platform/wayland/wayland_keyboard.h"
+
+#include <sys/mman.h>
+#include <wayland-client.h>
+
+#include "ui/base/ui_features.h"
+#include "ui/events/event.h"
+#include "ui/events/keycodes/dom/dom_code.h"
+#include "ui/events/keycodes/dom/keycode_converter.h"
+#include "ui/events/ozone/evdev/keyboard_util_evdev.h"
+#include "ui/events/ozone/layout/keyboard_layout_engine.h"
+#include "ui/events/ozone/layout/keyboard_layout_engine_manager.h"
+#include "ui/ozone/platform/wayland/wayland_window.h"
+
+#if BUILDFLAG(USE_XKBCOMMON)
+#include "ui/events/ozone/layout/xkb/xkb_keyboard_layout_engine.h"
+#endif
+
+namespace ui {
+
+WaylandKeyboard::WaylandKeyboard(wl_keyboard* keyboard,
+                                 const EventDispatchCallback& callback)
+    : obj_(keyboard), callback_(callback) {
+  static const wl_keyboard_listener listener = {
+      &WaylandKeyboard::Keymap,    &WaylandKeyboard::Enter,
+      &WaylandKeyboard::Leave,     &WaylandKeyboard::Key,
+      &WaylandKeyboard::Modifiers, &WaylandKeyboard::RepeatInfo,
+  };
+
+  wl_keyboard_add_listener(obj_.get(), &listener, this);
+
+  // TODO(tonikitoo): Default auto-repeat to ON here?
+}
+
+WaylandKeyboard::~WaylandKeyboard() {}
+
+void WaylandKeyboard::Keymap(void* data,
+                             wl_keyboard* obj,
+                             uint32_t format,
+                             int32_t fd,
+                             uint32_t size) {

[spang, 2017/01/24 20:41:50]

ScopedFD keymap_fd(fd);

and remove all the manual close() calls.

[tonikitoo, 2017/01/24 21:51:11]

Done.

+  if (!data || format != WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1) {
+    close(fd);
+    return;
+  }
+
+  char* keymap_str = reinterpret_cast<char*>(
+      mmap(nullptr, size, PROT_READ, MAP_SHARED, fd, 0));
+  if (keymap_str == MAP_FAILED)
+    return;
+
+  bool success =
+      KeyboardLayoutEngineManager::GetKeyboardLayoutEngine()
+          ->SetCurrentLayoutFromBuffer(keymap_str, strlen(keymap_str));

[spang, 2017/01/24 20:41:50]

Please don't strlen a mmap'd file - this is unsafe.

strlen(keymap_str) -> size

[tonikitoo, 2017/01/24 21:51:11]

Ok, I was willing to use 'size' to begin with BUT it was failing.

It turns out that my Wayland compositor (weston) sends 'size' with different
value than 'strlen(keymap_str)', and xkb_keymap_new_from_buffer fails down the
road.

The difference is '1', so I am using 'size - 1' here rather than 'size' so that
it succeeds.

WDYT?

[Michael Forney, 2017/01/24 22:11:47]

Hmm, so I looked into this a bit further.

All wayland compositors I looked at create a temporary file containing the
entire keymap string including a NULL-terminator. Clients use size for mmap and
assume that the mapped file is NULL-terminated, but the protocol specification
doesn't make it clear if that can be relied on.

Maybe the safest thing to do is pass strnlen(keymap_str, size) here, which
should handle both cases.

[spang, 2017/01/24 22:24:07]

SGTM.

+  DCHECK(success) << "Failed to set the XKB keyboard mapping.";
+  munmap(keymap_str, size);
+  close(fd);
+}
+
+void WaylandKeyboard::Enter(void* data,
+                            wl_keyboard* obj,
+                            uint32_t serial,
+                            wl_surface* surface,
+                            wl_array* keys) {
+  WaylandWindow::FromSurface(surface)->set_keyboard_focus(true);
+  // TODO(forney): The KeyboardEvdev object should update its state using the
+  // passed key array.
+}
+
+void WaylandKeyboard::Leave(void* data,
+                            wl_keyboard* obj,
+                            uint32_t serial,
+                            wl_surface* surface) {
+  WaylandWindow::FromSurface(surface)->set_keyboard_focus(false);
+}
+
+void WaylandKeyboard::Key(void* data,
+                          wl_keyboard* obj,
+                          uint32_t serial,
+                          uint32_t time,
+                          uint32_t key,
+                          uint32_t state) {
+  WaylandKeyboard* keyboard = static_cast<WaylandKeyboard*>(data);
+  DomCode dom_code =
+      KeycodeConverter::NativeKeycodeToDomCode(EvdevCodeToNativeCode(key));
+  if (dom_code == ui::DomCode::NONE)
+    return;
+
+  uint8_t flags = keyboard->modifiers_;
+  DomKey dom_key;
+  KeyboardCode key_code;
+  if (!KeyboardLayoutEngineManager::GetKeyboardLayoutEngine()->Lookup(
+          dom_code, flags, &dom_key, &key_code))
+    return;
+
+  // TODO(tonikitoo): handle repeat here.

[spang, 2017/01/24 20:41:50]

What happens when you get a repeat?

[Michael Forney, 2017/01/24 20:47:53]

The wayland server doesn't send repeats, and expects clients to generate them
based on the rate and delay sent in RepeatInfo. This TODO is about implementing
this functionality.

[tonikitoo, 2017/01/24 21:51:11]

Exactly.

+  bool down = state == WL_KEYBOARD_KEY_STATE_PRESSED;
+  ui::KeyEvent event(
+      down ? ET_KEY_PRESSED : ET_KEY_RELEASED, key_code, dom_code,
+      keyboard->modifiers_, dom_key,
+      base::TimeTicks() + base::TimeDelta::FromMilliseconds(time));
+  event.set_source_device_id(keyboard->obj_.id());
+  keyboard->callback_.Run(&event);
+}
+
+void WaylandKeyboard::Modifiers(void* data,
+                                wl_keyboard* obj,
+                                uint32_t serial,
+                                uint32_t mods_depressed,
+                                uint32_t mods_latched,
+                                uint32_t mods_locked,
+                                uint32_t group) {
+#if BUILDFLAG(USE_XKBCOMMON)
+  WaylandKeyboard* keyboard = static_cast<WaylandKeyboard*>(data);
+  auto* engine = static_cast<XkbKeyboardLayoutEngine*>(
+      KeyboardLayoutEngineManager::GetKeyboardLayoutEngine());
+  keyboard->modifiers_ =
+      engine->UpdateModifiers(mods_depressed, mods_latched, mods_locked, group);
+#endif
+}
+
+void WaylandKeyboard::RepeatInfo(void* data,
+                                 wl_keyboard* obj,
+                                 int32_t rate,
+                                 int32_t delay) {
+  // TODO(tonikitoo): Implement proper repeat handling.
+  NOTIMPLEMENTED();
+}
+
+}  // namespace ui