components/exo/wayland/wayland_keyboard_delegate.cc

// Copyright 2018 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifdef UNSAFE_BUFFERS_BUILD
// TODO(crbug.com/40285824): Remove this and convert code to safer constructs.
#pragma allow_unsafe_buffers
#endif

#include "components/exo/wayland/wayland_keyboard_delegate.h"

#include <wayland-server-core.h>
#include <wayland-server-protocol-core.h>

#include <cstring>
#include <string_view>

#include "base/containers/flat_map.h"
#include "base/memory/unsafe_shared_memory_region.h"
#include "base/numerics/safe_conversions.h"
#include "components/exo/wayland/serial_tracker.h"
#include "ui/events/keycodes/dom/dom_code.h"
#include "ui/events/keycodes/dom/keycode_converter.h"

#if BUILDFLAG(USE_XKBCOMMON)
#include <xkbcommon/xkbcommon.h>
#endif

namespace exo {
namespace wayland {

#if BUILDFLAG(USE_XKBCOMMON)

WaylandKeyboardDelegate::WaylandKeyboardDelegate(wl_resource* keyboard_resource,
                                                 SerialTracker* serial_tracker)
    : keyboard_resource_(keyboard_resource), serial_tracker_(serial_tracker) {}

WaylandKeyboardDelegate::~WaylandKeyboardDelegate() = default;

bool WaylandKeyboardDelegate::CanAcceptKeyboardEventsForSurface(
    Surface* surface) const {
  wl_resource* surface_resource = GetSurfaceResource(surface);
  // We can accept events for this surface if the client is the same as the
  // keyboard.
  return surface_resource &&
         wl_resource_get_client(surface_resource) == client();
}

void WaylandKeyboardDelegate::OnKeyboardEnter(
    Surface* surface,
    const base::flat_map<PhysicalCode, base::flat_set<KeyState>>&
        pressed_keys) {
  wl_resource* surface_resource = GetSurfaceResource(surface);
  DCHECK(surface_resource);
  wl_array keys;
  wl_array_init(&keys);
  for (const auto& entry : pressed_keys) {
    for (const auto& key_state : entry.second) {
      uint32_t* value =
          static_cast<uint32_t*>(wl_array_add(&keys, sizeof(uint32_t)));
      DCHECK(value);
      *value = ui::KeycodeConverter::DomCodeToEvdevCode(key_state.code);
    }
  }
  wl_keyboard_send_enter(
      keyboard_resource_,
      serial_tracker_->GetNextSerial(SerialTracker::EventType::OTHER_EVENT),
      surface_resource, &keys);
  wl_array_release(&keys);
  wl_client_flush(client());
}

void WaylandKeyboardDelegate::OnKeyboardLeave(Surface* surface) {
  wl_resource* surface_resource = GetSurfaceResource(surface);
  DCHECK(surface_resource);
  wl_keyboard_send_leave(
      keyboard_resource_,
      serial_tracker_->GetNextSerial(SerialTracker::EventType::OTHER_EVENT),
      surface_resource);
  wl_client_flush(client());
}

uint32_t WaylandKeyboardDelegate::OnKeyboardKey(base::TimeTicks time_stamp,
                                                ui::DomCode code,
                                                bool pressed) {
  uint32_t serial = serial_tracker_->MaybeNextKeySerial();
  serial_tracker_->ResetKeySerial();
  SendTimestamp(time_stamp);
  wl_keyboard_send_key(
      keyboard_resource_, serial, TimeTicksToMilliseconds(time_stamp),
      ui::KeycodeConverter::DomCodeToEvdevCode(code),
      pressed ? WL_KEYBOARD_KEY_STATE_PRESSED : WL_KEYBOARD_KEY_STATE_RELEASED);
  // Unlike normal wayland clients, the X11 server tries to maintain its own
  // modifier state, which it updates based on key events. To prevent numlock
  // presses from allowing numpad keys to be interpreted as directions, we
  // re-send the modifier state after a numlock press.
  if (code == ui::DomCode::NUM_LOCK)
    SendKeyboardModifiers();
  wl_client_flush(client());
  return serial;
}

void WaylandKeyboardDelegate::OnKeyboardModifiers(
    const KeyboardModifiers& modifiers) {
  // Send the update only when they're different.
  if (current_modifiers_ == modifiers)
    return;
  current_modifiers_ = modifiers;
  SendKeyboardModifiers();
}

void WaylandKeyboardDelegate::OnKeyboardLayoutUpdated(std::string_view keymap) {
  // Sent the content of |keymap| with trailing '\0' termination via shared
  // memory.
  base::UnsafeSharedMemoryRegion shared_keymap_region =
      base::UnsafeSharedMemoryRegion::Create(keymap.size() + 1);
  base::WritableSharedMemoryMapping shared_keymap = shared_keymap_region.Map();
  base::subtle::PlatformSharedMemoryRegion platform_shared_keymap =
      base::UnsafeSharedMemoryRegion::TakeHandleForSerialization(
          std::move(shared_keymap_region));
  DCHECK(shared_keymap.IsValid());

  std::memcpy(shared_keymap.memory(), keymap.data(), keymap.size());
  static_cast<uint8_t*>(shared_keymap.memory())[keymap.size()] = '\0';
  wl_keyboard_send_keymap(keyboard_resource_, WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1,
                          platform_shared_keymap.GetPlatformHandle().fd,
                          keymap.size() + 1);
  wl_client_flush(client());
}

void WaylandKeyboardDelegate::SendKeyboardModifiers() {
  wl_keyboard_send_modifiers(
      keyboard_resource_,
      serial_tracker_->GetNextSerial(SerialTracker::EventType::OTHER_EVENT),
      current_modifiers_.depressed, current_modifiers_.locked,
      current_modifiers_.latched, current_modifiers_.group);
  wl_client_flush(client());
}

// Convert from ChromeOS's key repeat interval to Wayland's key repeat rate.
// For example, an interval of 500ms is a rate of 1000/500 = 2 Hz.
//
// Known issue: A 2000ms interval is 0.5 Hz. This rounds to 1 Hz, which
// is twice as fast. This is not fixable without Wayland spec changes.
int32_t GetWaylandRepeatRate(bool enabled, base::TimeDelta interval) {
  DCHECK(interval.InMillisecondsF() > 0.0);
  int32_t rate;
  if (enabled) {
    // Most of ChromeOS's interval options divide perfectly into 1000,
    // but a few do need rounding.
    rate = base::ClampRound<int32_t>(interval.ToHz());

    // Avoid disabling key repeat if the interval is >2000ms.
    rate = std::max(1, rate);
  } else {
    // Disables key repeat, as documented in Wayland spec.
    rate = 0;
  }
  return rate;
}

// Expose GetWaylandRepeatRate() to tests.
int32_t GetWaylandRepeatRateForTesting(bool enabled, base::TimeDelta interval) {
  return GetWaylandRepeatRate(enabled, interval);
}

void WaylandKeyboardDelegate::OnKeyRepeatSettingsChanged(
    bool enabled,
    base::TimeDelta delay,
    base::TimeDelta interval) {
  // delay may be zero, but not negative (per Wayland spec).
  DCHECK_GE(delay.InMilliseconds(), 0);

  uint32_t version = wl_resource_get_version(keyboard_resource_);
  if (version >= WL_KEYBOARD_REPEAT_INFO_SINCE_VERSION) {
    wl_keyboard_send_repeat_info(keyboard_resource_,
                                 GetWaylandRepeatRate(enabled, interval),
                                 static_cast<int32_t>(delay.InMilliseconds()));
    wl_client_flush(client());
  }
}

wl_client* WaylandKeyboardDelegate::client() const {
  return wl_resource_get_client(keyboard_resource_);
}

#endif  // BUILDFLAG(USE_XKBCOMMON)

}  // namespace wayland
}  // namespace exo