File: event_rewriter_unittest.cc

package info (click to toggle)
chromium 139.0.7258.127-1
links: PTS, VCS
area: main
in suites:
size: 6,122,068 kB
sloc: cpp: 35,100,771; ansic: 7,163,530; javascript: 4,103,002; python: 1,436,920; asm: 946,517; xml: 746,709; pascal: 187,653; perl: 88,691; sh: 88,436; objc: 79,953; sql: 51,488; cs: 44,583; fortran: 24,137; makefile: 22,147; tcl: 15,277; php: 13,980; yacc: 8,984; ruby: 7,485; awk: 3,720; lisp: 3,096; lex: 1,327; ada: 727; jsp: 228; sed: 36
file content (5882 lines) | stat: -rw-r--r-- 249,182 bytes
parent folder | download | duplicates (5)
// Copyright 2014 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "ui/events/event_rewriter.h"

#include <memory>
#include <optional>
#include <vector>

#include "ash/accelerators/accelerator_controller_impl.h"
#include "ash/accessibility/sticky_keys/sticky_keys_controller.h"
#include "ash/accessibility/sticky_keys/sticky_keys_overlay.h"
#include "ash/constants/ash_features.h"
#include "ash/constants/ash_pref_names.h"
#include "ash/public/cpp/input_device_settings_controller.h"
#include "ash/public/cpp/test/mock_input_device_settings_controller.h"
#include "ash/public/mojom/input_device_settings.mojom.h"
#include "ash/shell.h"
#include "ash/system/input_device_settings/input_device_settings_notification_controller.h"
#include "ash/system/input_device_settings/input_device_settings_pref_names.h"
#include "ash/system/toast/anchored_nudge_manager_impl.h"
#include "base/command_line.h"
#include "base/containers/adapters.h"
#include "base/containers/contains.h"
#include "base/containers/flat_set.h"
#include "base/memory/ptr_util.h"
#include "base/memory/raw_ptr.h"
#include "base/memory/scoped_refptr.h"
#include "base/strings/strcat.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_util.h"
#include "base/strings/stringprintf.h"
#include "base/test/metrics/histogram_tester.h"
#include "base/test/scoped_feature_list.h"
#include "chrome/browser/ash/events/event_rewriter_delegate_impl.h"
#include "chrome/browser/ash/input_method/input_method_configuration.h"
#include "chrome/browser/ash/login/users/fake_chrome_user_manager.h"
#include "chrome/browser/ash/notifications/deprecation_notification_controller.h"
#include "chrome/browser/ash/preferences/preferences.h"
#include "chrome/common/pref_names.h"
#include "chrome/test/base/chrome_ash_test_base.h"
#include "components/prefs/pref_member.h"
#include "components/sync_preferences/testing_pref_service_syncable.h"
#include "components/user_manager/scoped_user_manager.h"
#include "device/udev_linux/fake_udev_loader.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "ui/aura/window.h"
#include "ui/aura/window_tree_host.h"
#include "ui/base/accelerators/accelerator.h"
#include "ui/base/ime/ash/fake_ime_keyboard.h"
#include "ui/base/ime/ash/input_method_manager.h"
#include "ui/base/ime/ash/mock_input_method_manager.h"
#include "ui/base/ime/ash/mock_input_method_manager_impl.h"
#include "ui/base/shortcut_mapping_pref_delegate.h"
#include "ui/base/ui_base_features.h"
#include "ui/events/ash/caps_lock_event_rewriter.h"
#include "ui/events/ash/discard_key_event_rewriter.h"
#include "ui/events/ash/event_rewriter_ash.h"
#include "ui/events/ash/event_rewriter_metrics.h"
#include "ui/events/ash/keyboard_capability.h"
#include "ui/events/ash/keyboard_device_id_event_rewriter.h"
#include "ui/events/ash/keyboard_modifier_event_rewriter.h"
#include "ui/events/ash/mojom/extended_fkeys_modifier.mojom-shared.h"
#include "ui/events/ash/mojom/modifier_key.mojom-shared.h"
#include "ui/events/ash/mojom/modifier_key.mojom.h"
#include "ui/events/ash/mojom/simulate_right_click_modifier.mojom-shared.h"
#include "ui/events/ash/mojom/six_pack_shortcut_modifier.mojom-shared.h"
#include "ui/events/ash/pref_names.h"
#include "ui/events/devices/device_data_manager.h"
#include "ui/events/devices/device_data_manager_test_api.h"
#include "ui/events/devices/input_device.h"
#include "ui/events/devices/keyboard_device.h"
#include "ui/events/devices/touchpad_device.h"
#include "ui/events/event.h"
#include "ui/events/event_constants.h"
#include "ui/events/event_utils.h"
#include "ui/events/keycodes/dom/dom_code.h"
#include "ui/events/keycodes/dom/dom_key.h"
#include "ui/events/keycodes/dom/keycode_converter.h"
#include "ui/events/keycodes/keyboard_codes_posix.h"
#include "ui/events/ozone/layout/stub/stub_keyboard_layout_engine.h"
#include "ui/events/test/events_test_utils.h"
#include "ui/events/test/test_event_processor.h"
#include "ui/events/test/test_event_rewriter_continuation.h"
#include "ui/events/test/test_event_source.h"
#include "ui/events/types/event_type.h"
#include "ui/message_center/fake_message_center.h"
#include "ui/wm/core/window_util.h"

namespace {

constexpr int kKeyboardDeviceId = 123;
constexpr uint32_t kNoScanCode = 0;
constexpr char kKbdSysPath[] = "/devices/platform/i8042/serio2/input/input1";
constexpr char kKbdTopRowPropertyName[] = "CROS_KEYBOARD_TOP_ROW_LAYOUT";
constexpr char kKbdTopRowLayoutAttributeName[] = "function_row_physmap";
constexpr char kSixPackKeyNoMatchNudgeId[] = "six-patch-key-no-match-nudge-id";
constexpr char kTopRowKeyNoMatchNudgeId[] = "top-row-key-no-match-nudge-id";

constexpr char kKbdTopRowLayoutUnspecified[] = "";
constexpr char kKbdTopRowLayout1Tag[] = "1";
constexpr char kKbdTopRowLayout2Tag[] = "2";
constexpr char kKbdTopRowLayoutWilcoTag[] = "3";
constexpr char kKbdTopRowLayoutDrallionTag[] = "4";

constexpr int kTouchpadId1 = 10;
constexpr int kTouchpadId2 = 11;

constexpr int kMouseDeviceId = 456;

// A default example of the layout string read from the function_row_physmap
// sysfs attribute. The values represent the scan codes for each position
// in the top row, which maps to F-Keys.
constexpr char kKbdDefaultCustomTopRowLayout[] =
    "01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f";

// Tag used to mark events as being for quick insert.
constexpr std::pair<std::string, std::vector<uint8_t>> kPropertyQuickInsert = {
    "quick_insert_event",
    {}};

#if BUILDFLAG(GOOGLE_CHROME_BRANDING)
constexpr char kCros1pInputMethodIdPrefix[] =
    "_comp_ime_jkghodnilhceideoidjikpgommlajknk";
#endif

class TestEventSink : public ui::EventSink {
 public:
  TestEventSink() = default;
  TestEventSink(const TestEventSink&) = delete;
  TestEventSink& operator=(const TestEventSink&) = delete;
  ~TestEventSink() override = default;

  // Returns the recorded events.
  std::vector<std::unique_ptr<ui::Event>> TakeEvents() {
    return std::move(events_);
  }

  // ui::EventSink:
  ui::EventDispatchDetails OnEventFromSource(ui::Event* event) override {
    auto cloned_event = event->Clone();
    ui::EventTestApi(cloned_event.get())
        .set_native_event(event->native_event());
    events_.emplace_back(std::move(cloned_event));
    return ui::EventDispatchDetails();
  }

 private:
  std::vector<std::unique_ptr<ui::Event>> events_;
};

class TestKeyboardModifierEventRewriterDelegate
    : public ui::KeyboardModifierEventRewriter::Delegate {
 public:
  explicit TestKeyboardModifierEventRewriterDelegate(
      ui::EventRewriterAsh::Delegate* ash_delegate)
      : ash_delegate_(ash_delegate) {}

  std::optional<ui::mojom::ModifierKey> GetKeyboardRemappedModifierValue(
      int device_id,
      ui::mojom::ModifierKey modifier_key,
      const std::string& pref_name) const override {
    return ash_delegate_->GetKeyboardRemappedModifierValue(
        device_id, modifier_key, pref_name);
  }

  bool RewriteModifierKeys() override {
    return ash_delegate_->RewriteModifierKeys();
  }

 private:
  raw_ptr<ui::EventRewriterAsh::Delegate> ash_delegate_;
};

class TestEventRewriterContinuation
    : public ui::test::TestEventRewriterContinuation {
 public:
  TestEventRewriterContinuation() = default;
  ~TestEventRewriterContinuation() override = default;
  TestEventRewriterContinuation(const TestEventRewriterContinuation&) = delete;
  TestEventRewriterContinuation& operator=(
      const TestEventRewriterContinuation&) = delete;

  ui::EventDispatchDetails SendEvent(const ui::Event* event) override {
    passthrough_events.push_back(event->Clone());
    return ui::EventDispatchDetails();
  }

  ui::EventDispatchDetails SendEventFinally(const ui::Event* event) override {
    rewritten_events.push_back(event->Clone());
    return ui::EventDispatchDetails();
  }

  ui::EventDispatchDetails DiscardEvent() override {
    return ui::EventDispatchDetails();
  }

  std::vector<std::unique_ptr<ui::Event>> rewritten_events;
  std::vector<std::unique_ptr<ui::Event>> passthrough_events;

  base::WeakPtrFactory<TestEventRewriterContinuation> weak_ptr_factory_{this};
};

// Key representation in test cases.
struct TestKeyEvent {
  ui::EventType type;
  ui::DomCode code;
  ui::DomKey key;
  ui::KeyboardCode keycode;
  ui::EventFlags flags = ui::EF_NONE;
  uint32_t scan_code = kNoScanCode;
  std::vector<std::pair<std::string, std::vector<uint8_t>>> properties;

  std::string ToString() const;
};

std::string TestKeyEvent::ToString() const {
  std::string type_name(ui::EventTypeName(type));
  std::string flags_name = base::JoinString(ui::EventFlagsNames(flags), "|");

  std::string property_dump;
  for (const auto& property : properties) {
    property_dump += (property_dump.empty() ? "" : "|") + property.first;
    property_dump += "=" + base::HexEncode(property.second);
  }

  return base::StringPrintf(
      "type=%s(%d) "
      "code=%s(0x%06X) "
      "key=%s(0x%08X) "
      "keycode=0x%02X "
      "flags=%s(0x%X) "
      "scan_code=0x%08X "
      "properties=%s",
      type_name.c_str(), type,
      ui::KeycodeConverter::DomCodeToCodeString(code).c_str(),
      static_cast<uint32_t>(code),
      ui::KeycodeConverter::DomKeyToKeyString(key).c_str(),
      static_cast<uint32_t>(key), keycode, flags_name.c_str(), flags, scan_code,
      property_dump.data());
}

inline std::ostream& operator<<(std::ostream& os, const TestKeyEvent& event) {
  return os << event.ToString();
}

inline bool operator==(const TestKeyEvent& e1, const TestKeyEvent& e2) {
  return e1.type == e2.type && e1.code == e2.code && e1.key == e2.key &&
         e1.keycode == e2.keycode && e1.flags == e2.flags &&
         e1.scan_code == e2.scan_code && e1.properties == e2.properties;
}

// Factory template of TestKeyEvents just to reduce a lot of code/data
// duplication.
template <ui::DomCode code,
          ui::DomKey::Base key,
          ui::KeyboardCode keycode,
          ui::EventFlags modifier_flag = ui::EF_NONE,
          ui::DomKey::Base shifted_key = key>
struct TestKey {
  // Returns press key event.
  static constexpr TestKeyEvent Pressed(
      ui::EventFlags flags = ui::EF_NONE,
      std::vector<std::pair<std::string, std::vector<uint8_t>>> properties =
          {}) {
    return {ui::EventType::kKeyPressed,
            code,
            (flags & ui::EF_SHIFT_DOWN) ? shifted_key : key,
            keycode,
            flags | modifier_flag,
            kNoScanCode,
            std::move(properties)};
  }

  // Returns release key event.
  static constexpr TestKeyEvent Released(
      ui::EventFlags flags = ui::EF_NONE,
      std::vector<std::pair<std::string, std::vector<uint8_t>>> properties =
          {}) {
    // Note: modifier flag should not be present on release events.
    return {ui::EventType::kKeyReleased,
            code,
            (flags & ui::EF_SHIFT_DOWN) ? shifted_key : key,
            keycode,
            flags,
            kNoScanCode,
            std::move(properties)};
  }

  // Returns press then release key events.
  static std::vector<TestKeyEvent> Typed(
      ui::EventFlags flags = ui::EF_NONE,
      std::vector<std::pair<std::string, std::vector<uint8_t>>> properties =
          {}) {
    return {Pressed(flags, properties), Released(flags, std::move(properties))};
  }
};

// Short cut of TestKey construction for Character keys.
template <ui::DomCode code,
          char key,
          ui::KeyboardCode keycode,
          char shifted_key = key>
using TestCharKey = TestKey<code,
                            ui::DomKey::FromCharacter(key),
                            keycode,
                            ui::EF_NONE,
                            ui::DomKey::FromCharacter(shifted_key)>;

using KeyUnknown =
    TestKey<ui::DomCode::NONE, ui::DomKey::UNIDENTIFIED, ui::VKEY_UNKNOWN>;

// Character keys. Shift chars are based on US layout.
using KeyA = TestCharKey<ui::DomCode::US_A, 'a', ui::VKEY_A, 'A'>;
using KeyB = TestCharKey<ui::DomCode::US_B, 'b', ui::VKEY_B, 'B'>;
using KeyC = TestCharKey<ui::DomCode::US_C, 'c', ui::VKEY_C, 'C'>;
using KeyD = TestCharKey<ui::DomCode::US_D, 'd', ui::VKEY_D, 'D'>;
using KeyN = TestCharKey<ui::DomCode::US_N, 'n', ui::VKEY_N, 'N'>;
using KeyT = TestCharKey<ui::DomCode::US_T, 't', ui::VKEY_T, 'T'>;
using KeyComma = TestCharKey<ui::DomCode::COMMA, ',', ui::VKEY_OEM_COMMA, '<'>;
using KeyPeriod =
    TestCharKey<ui::DomCode::PERIOD, '.', ui::VKEY_OEM_PERIOD, '>'>;
using KeyDigit1 = TestCharKey<ui::DomCode::DIGIT1, '1', ui::VKEY_1, '!'>;
using KeyDigit2 = TestCharKey<ui::DomCode::DIGIT2, '2', ui::VKEY_2, '@'>;
using KeyDigit3 = TestCharKey<ui::DomCode::DIGIT3, '3', ui::VKEY_3, '#'>;
using KeyDigit4 = TestCharKey<ui::DomCode::DIGIT4, '4', ui::VKEY_4, '$'>;
using KeyDigit5 = TestCharKey<ui::DomCode::DIGIT5, '5', ui::VKEY_5, '%'>;
using KeyDigit6 = TestCharKey<ui::DomCode::DIGIT6, '6', ui::VKEY_6, '^'>;
using KeyDigit7 = TestCharKey<ui::DomCode::DIGIT7, '7', ui::VKEY_7, '&'>;
using KeyDigit8 = TestCharKey<ui::DomCode::DIGIT8, '8', ui::VKEY_8, '*'>;
using KeyDigit9 = TestCharKey<ui::DomCode::DIGIT9, '9', ui::VKEY_9, '('>;
using KeyDigit0 = TestCharKey<ui::DomCode::DIGIT0, '0', ui::VKEY_0, ')'>;
using KeyMinus = TestCharKey<ui::DomCode::MINUS, '-', ui::VKEY_OEM_MINUS, '_'>;
using KeyEqual = TestCharKey<ui::DomCode::EQUAL, '=', ui::VKEY_OEM_PLUS, '+'>;

// Modifier keys.
using KeyLShift = TestKey<ui::DomCode::SHIFT_LEFT,
                          ui::DomKey::SHIFT,
                          ui::VKEY_SHIFT,
                          ui::EF_SHIFT_DOWN>;
using KeyRShift = TestKey<ui::DomCode::SHIFT_RIGHT,
                          ui::DomKey::SHIFT,
                          ui::VKEY_SHIFT,
                          ui::EF_SHIFT_DOWN>;
using KeyLMeta = TestKey<ui::DomCode::META_LEFT,
                         ui::DomKey::META,
                         ui::VKEY_LWIN,
                         ui::EF_COMMAND_DOWN>;
using KeyRMeta = TestKey<ui::DomCode::META_RIGHT,
                         ui::DomKey::META,
                         ui::VKEY_RWIN,
                         ui::EF_COMMAND_DOWN>;
using KeyLControl = TestKey<ui::DomCode::CONTROL_LEFT,
                            ui::DomKey::CONTROL,
                            ui::VKEY_CONTROL,
                            ui::EF_CONTROL_DOWN>;
using KeyRControl = TestKey<ui::DomCode::CONTROL_RIGHT,
                            ui::DomKey::CONTROL,
                            ui::VKEY_CONTROL,
                            ui::EF_CONTROL_DOWN>;
using KeyLAlt = TestKey<ui::DomCode::ALT_LEFT,
                        ui::DomKey::ALT,
                        ui::VKEY_MENU,
                        ui::EF_ALT_DOWN>;
using KeyRAlt = TestKey<ui::DomCode::ALT_RIGHT,
                        ui::DomKey::ALT,
                        ui::VKEY_MENU,
                        ui::EF_ALT_DOWN>;
using KeyCapsLock = TestKey<ui::DomCode::CAPS_LOCK,
                            ui::DomKey::CAPS_LOCK,
                            ui::VKEY_CAPITAL,
                            ui::EF_MOD3_DOWN>;
using KeyJpnAlphanumeric = TestKey<ui::DomCode::LAUNCH_ASSISTANT,
                                   ui::DomKey::ALPHANUMERIC,
                                   ui::VKEY_CAPITAL,
                                   ui::EF_MOD3_DOWN>;
using KeyFunction = TestKey<ui::DomCode::FN,
                            ui::DomKey::FN,
                            ui::VKEY_FUNCTION,
                            ui::EF_FUNCTION_DOWN>;

// Function keys.
using KeyEscape =
    TestKey<ui::DomCode::ESCAPE, ui::DomKey::ESCAPE, ui::VKEY_ESCAPE>;
using KeyF1 = TestKey<ui::DomCode::F1, ui::DomKey::F1, ui::VKEY_F1>;
using KeyF2 = TestKey<ui::DomCode::F2, ui::DomKey::F2, ui::VKEY_F2>;
using KeyF3 = TestKey<ui::DomCode::F3, ui::DomKey::F3, ui::VKEY_F3>;
using KeyF4 = TestKey<ui::DomCode::F4, ui::DomKey::F4, ui::VKEY_F4>;
using KeyF5 = TestKey<ui::DomCode::F5, ui::DomKey::F5, ui::VKEY_F5>;
using KeyF6 = TestKey<ui::DomCode::F6, ui::DomKey::F6, ui::VKEY_F6>;
using KeyF7 = TestKey<ui::DomCode::F7, ui::DomKey::F7, ui::VKEY_F7>;
using KeyF8 = TestKey<ui::DomCode::F8, ui::DomKey::F8, ui::VKEY_F8>;
using KeyF9 = TestKey<ui::DomCode::F9, ui::DomKey::F9, ui::VKEY_F9>;
using KeyF10 = TestKey<ui::DomCode::F10, ui::DomKey::F10, ui::VKEY_F10>;
using KeyF11 = TestKey<ui::DomCode::F11, ui::DomKey::F11, ui::VKEY_F11>;
using KeyF12 = TestKey<ui::DomCode::F12, ui::DomKey::F12, ui::VKEY_F12>;
using KeyF13 = TestKey<ui::DomCode::F13, ui::DomKey::F13, ui::VKEY_F13>;
using KeyF14 = TestKey<ui::DomCode::F14, ui::DomKey::F14, ui::VKEY_F14>;
using KeyF15 = TestKey<ui::DomCode::F15, ui::DomKey::F15, ui::VKEY_F15>;
using KeyBackspace =
    TestKey<ui::DomCode::BACKSPACE, ui::DomKey::BACKSPACE, ui::VKEY_BACK>;

// Chrome OS Special keys.
using KeyBrowserBack = TestKey<ui::DomCode::BROWSER_BACK,
                               ui::DomKey::BROWSER_BACK,
                               ui::VKEY_BROWSER_BACK>;
using KeyBrowserForward = TestKey<ui::DomCode::BROWSER_FORWARD,
                                  ui::DomKey::BROWSER_FORWARD,
                                  ui::VKEY_BROWSER_FORWARD>;
using KeyBrowserRefresh = TestKey<ui::DomCode::BROWSER_REFRESH,
                                  ui::DomKey::BROWSER_REFRESH,
                                  ui::VKEY_BROWSER_REFRESH>;
using KeyZoomToggle =
    TestKey<ui::DomCode::ZOOM_TOGGLE, ui::DomKey::ZOOM_TOGGLE, ui::VKEY_ZOOM>;
using KeySelectTask = TestKey<ui::DomCode::SELECT_TASK,
                              ui::DomKey::LAUNCH_MY_COMPUTER,
                              ui::VKEY_MEDIA_LAUNCH_APP1>;
using KeyBrightnessDown = TestKey<ui::DomCode::BRIGHTNESS_DOWN,
                                  ui::DomKey::BRIGHTNESS_DOWN,
                                  ui::VKEY_BRIGHTNESS_DOWN>;
using KeyBrightnessUp = TestKey<ui::DomCode::BRIGHTNESS_UP,
                                ui::DomKey::BRIGHTNESS_UP,
                                ui::VKEY_BRIGHTNESS_UP>;
using KeyMediaPlayPause = TestKey<ui::DomCode::MEDIA_PLAY_PAUSE,
                                  ui::DomKey::MEDIA_PLAY_PAUSE,
                                  ui::VKEY_MEDIA_PLAY_PAUSE>;
using KeyVolumeMute = TestKey<ui::DomCode::VOLUME_MUTE,
                              ui::DomKey::AUDIO_VOLUME_MUTE,
                              ui::VKEY_VOLUME_MUTE>;
using KeyVolumeDown = TestKey<ui::DomCode::VOLUME_DOWN,
                              ui::DomKey::AUDIO_VOLUME_DOWN,
                              ui::VKEY_VOLUME_DOWN>;
using KeyVolumeUp = TestKey<ui::DomCode::VOLUME_UP,
                            ui::DomKey::AUDIO_VOLUME_UP,
                            ui::VKEY_VOLUME_UP>;
using KeyPrivacyScreenToggle =
    TestKey<ui::DomCode::PRIVACY_SCREEN_TOGGLE,
            ui::DomKey::F12,  // no DomKey for PRIVACY_SCREEN_TOGGLE>
            ui::VKEY_PRIVACY_SCREEN_TOGGLE>;
using KeyLaunchAssistant = TestKey<ui::DomCode::LAUNCH_ASSISTANT,
                                   ui::DomKey::LAUNCH_ASSISTANT,
                                   ui::VKEY_ASSISTANT>;
using KeyQuickInsert = TestKey<ui::DomCode::LAUNCH_ASSISTANT,
                               ui::DomKey::LAUNCH_ASSISTANT,
                               ui::VKEY_ASSISTANT,
                               ui::EF_NONE,
                               ui::DomKey::LAUNCH_ASSISTANT>;

using KeyHangulMode =
    TestKey<ui::DomCode::ALT_RIGHT, ui::DomKey::HANGUL_MODE, ui::VKEY_HANGUL>;

// 6-pack keys.
using KeyInsert =
    TestKey<ui::DomCode::INSERT, ui::DomKey::INSERT, ui::VKEY_INSERT>;
using KeyDelete = TestKey<ui::DomCode::DEL, ui::DomKey::DEL, ui::VKEY_DELETE>;
using KeyHome = TestKey<ui::DomCode::HOME, ui::DomKey::HOME, ui::VKEY_HOME>;
using KeyEnd = TestKey<ui::DomCode::END, ui::DomKey::END, ui::VKEY_END>;
using KeyPageUp =
    TestKey<ui::DomCode::PAGE_UP, ui::DomKey::PAGE_UP, ui::VKEY_PRIOR>;
using KeyPageDown =
    TestKey<ui::DomCode::PAGE_DOWN, ui::DomKey::PAGE_DOWN, ui::VKEY_NEXT>;

// Arrow keys.
using KeyArrowUp =
    TestKey<ui::DomCode::ARROW_UP, ui::DomKey::ARROW_UP, ui::VKEY_UP>;
using KeyArrowDown =
    TestKey<ui::DomCode::ARROW_DOWN, ui::DomKey::ARROW_DOWN, ui::VKEY_DOWN>;
using KeyArrowLeft =
    TestKey<ui::DomCode::ARROW_LEFT, ui::DomKey::ARROW_LEFT, ui::VKEY_LEFT>;
using KeyArrowRight =
    TestKey<ui::DomCode::ARROW_RIGHT, ui::DomKey::ARROW_RIGHT, ui::VKEY_RIGHT>;

// Numpad keys.
using KeyNumpad0 = TestCharKey<ui::DomCode::NUMPAD0, '0', ui::VKEY_NUMPAD0>;
using KeyNumpadDecimal =
    TestCharKey<ui::DomCode::NUMPAD_DECIMAL, '.', ui::VKEY_DECIMAL>;
using KeyNumpad1 = TestCharKey<ui::DomCode::NUMPAD1, '1', ui::VKEY_NUMPAD1>;
using KeyNumpad2 = TestCharKey<ui::DomCode::NUMPAD2, '2', ui::VKEY_NUMPAD2>;
using KeyNumpad3 = TestCharKey<ui::DomCode::NUMPAD3, '3', ui::VKEY_NUMPAD3>;
using KeyNumpad4 = TestCharKey<ui::DomCode::NUMPAD4, '4', ui::VKEY_NUMPAD4>;
using KeyNumpad5 = TestCharKey<ui::DomCode::NUMPAD5, '5', ui::VKEY_NUMPAD5>;
using KeyNumpad6 = TestCharKey<ui::DomCode::NUMPAD6, '6', ui::VKEY_NUMPAD6>;
using KeyNumpad7 = TestCharKey<ui::DomCode::NUMPAD7, '7', ui::VKEY_NUMPAD7>;
using KeyNumpad8 = TestCharKey<ui::DomCode::NUMPAD8, '8', ui::VKEY_NUMPAD8>;
using KeyNumpad9 = TestCharKey<ui::DomCode::NUMPAD9, '9', ui::VKEY_NUMPAD9>;

// Numpad keys without NumLock key.
using KeyNumpadInsert =
    TestKey<ui::DomCode::NUMPAD0, ui::DomKey::INSERT, ui::VKEY_INSERT>;
using KeyNumpadDelete =
    TestKey<ui::DomCode::NUMPAD_DECIMAL, ui::DomKey::DEL, ui::VKEY_DELETE>;
using KeyNumpadEnd =
    TestKey<ui::DomCode::NUMPAD1, ui::DomKey::END, ui::VKEY_END>;
using KeyNumpadArrowDown =
    TestKey<ui::DomCode::NUMPAD2, ui::DomKey::ARROW_DOWN, ui::VKEY_DOWN>;
using KeyNumpadPageDown =
    TestKey<ui::DomCode::NUMPAD3, ui::DomKey::PAGE_DOWN, ui::VKEY_NEXT>;
using KeyNumpadArrowLeft =
    TestKey<ui::DomCode::NUMPAD4, ui::DomKey::ARROW_LEFT, ui::VKEY_LEFT>;
using KeyNumpadClear =
    TestKey<ui::DomCode::NUMPAD5, ui::DomKey::CLEAR, ui::VKEY_CLEAR>;
using KeyNumpadArrowRight =
    TestKey<ui::DomCode::NUMPAD6, ui::DomKey::ARROW_RIGHT, ui::VKEY_RIGHT>;
using KeyNumpadHome =
    TestKey<ui::DomCode::NUMPAD7, ui::DomKey::HOME, ui::VKEY_HOME>;
using KeyNumpadArrowUp =
    TestKey<ui::DomCode::NUMPAD8, ui::DomKey::ARROW_UP, ui::VKEY_UP>;
using KeyNumpadPageUp =
    TestKey<ui::DomCode::NUMPAD9, ui::DomKey::PAGE_UP, ui::VKEY_PRIOR>;

// Keyboard representation in tests.
struct TestKeyboard {
  const char* name;
  const char* layout;
  ui::InputDeviceType type;
  bool has_custom_top_row;
  bool has_assistant_key = false;
  bool has_function_key = false;
};
constexpr TestKeyboard kInternalChromeKeyboard = {
    "Internal Keyboard",
    kKbdTopRowLayoutUnspecified,
    ui::INPUT_DEVICE_INTERNAL,
    /*has_custom_top_row=*/false,
};
constexpr TestKeyboard kInternalChromeCustomLayoutKeyboard = {
    "Internal Custom Layout Keyboard",
    kKbdDefaultCustomTopRowLayout,
    ui::INPUT_DEVICE_INTERNAL,
    /*has_custom_top_row=*/true,
};
constexpr TestKeyboard kInternalChromeSplitModifierLayoutKeyboard = {
    "Internal Custom Layout Keyboard", kKbdDefaultCustomTopRowLayout,
    ui::INPUT_DEVICE_INTERNAL,
    /*has_custom_top_row=*/true,
    /*has_assistant_key=*/true,
    /*has_function_key=*/true,
};
constexpr TestKeyboard kExternalChromeKeyboard = {
    "External Chrome Keyboard",
    kKbdTopRowLayout1Tag,
    ui::INPUT_DEVICE_UNKNOWN,
    /*has_custom_top_row=*/false,
};
constexpr TestKeyboard kExternalChromeCustomLayoutKeyboard = {
    "External Chrome Custom Layout Keyboard",
    kKbdDefaultCustomTopRowLayout,
    ui::INPUT_DEVICE_UNKNOWN,
    /*has_custom_top_row=*/true,
};
constexpr TestKeyboard kExternalGenericKeyboard = {
    "PC Keyboard",
    kKbdTopRowLayoutUnspecified,
    ui::INPUT_DEVICE_UNKNOWN,
    /*has_custom_top_row=*/false,
};
constexpr TestKeyboard kExternalAppleKeyboard = {
    "Apple Keyboard",
    kKbdTopRowLayoutUnspecified,
    ui::INPUT_DEVICE_UNKNOWN,
    /*has_custom_top_row=*/false,
};

constexpr TestKeyboard kChromeKeyboardVariants[] = {
    kInternalChromeKeyboard,
    kExternalChromeKeyboard,
};
constexpr TestKeyboard kChromeCustomKeyboardVariants[] = {
    kInternalChromeCustomLayoutKeyboard,
    kExternalChromeCustomLayoutKeyboard,
};
constexpr TestKeyboard kNonAppleKeyboardVariants[] = {
    kInternalChromeKeyboard,  kInternalChromeCustomLayoutKeyboard,
    kExternalChromeKeyboard,  kExternalChromeCustomLayoutKeyboard,
    kExternalGenericKeyboard,
};
constexpr TestKeyboard kNonAppleNonCustomLayoutKeyboardVariants[] = {
    kInternalChromeKeyboard,
    kExternalChromeKeyboard,
    kExternalGenericKeyboard,
};
constexpr TestKeyboard kAllKeyboardVariants[] = {
    kInternalChromeKeyboard,
    kInternalChromeCustomLayoutKeyboard,
    kInternalChromeSplitModifierLayoutKeyboard,
    kExternalChromeKeyboard,
    kExternalChromeCustomLayoutKeyboard,
    kExternalGenericKeyboard,
    kExternalAppleKeyboard,
};

// Wilco keyboard configs

constexpr TestKeyboard kWilco1_0Keyboard{
    "Wilco Keyboard",
    kKbdTopRowLayoutWilcoTag,
    ui::INPUT_DEVICE_INTERNAL,
    /*has_custom_top_row=*/false,
};

constexpr TestKeyboard kWilco1_5Keyboard{
    "Drallion Keyboard",
    kKbdTopRowLayoutDrallionTag,
    ui::INPUT_DEVICE_INTERNAL,
    /*has_custom_top_row=*/false,
};

constexpr TestKeyboard kWilcoKeyboardVariants[] = {
    kWilco1_0Keyboard,
    kWilco1_5Keyboard,
};

// Use to emulate `ImprovedKeyboardShortcuts` is disabled by the policy on
// enrolled device.
class TestShortcutMappingPrefDelegate : public ui::ShortcutMappingPrefDelegate {
 public:
  TestShortcutMappingPrefDelegate() = default;
  TestShortcutMappingPrefDelegate(const TestShortcutMappingPrefDelegate&) =
      delete;
  TestShortcutMappingPrefDelegate& operator=(
      const TestShortcutMappingPrefDelegate&) = delete;
  ~TestShortcutMappingPrefDelegate() override = default;

  // ui::ShortcutMappingPrefDelegate:
  bool IsDeviceEnterpriseManaged() const override { return true; }
  bool IsI18nShortcutPrefEnabled() const override { return false; }
};

}  // namespace

namespace ash {

class EventRewriterTestBase : public ChromeAshTestBase {
 public:
  EventRewriterTestBase()
      : fake_user_manager_(new FakeChromeUserManager),
        user_manager_enabler_(base::WrapUnique(fake_user_manager_.get())) {}
  ~EventRewriterTestBase() override = default;

  void SetUp() override {
    keyboard_layout_engine_ = std::make_unique<ui::StubKeyboardLayoutEngine>();
    // Inject custom table to make this closer to en-US behavior.
    keyboard_layout_engine_->SetCustomLookupTableForTesting({
        // Keep MetaRight as MetaRight.
        {ui::DomCode::META_RIGHT, ui::DomKey::META, ui::DomKey::META,
         ui::VKEY_RWIN},

        // Inject select_task key.
        {ui::DomCode::SELECT_TASK, ui::DomKey::LAUNCH_MY_COMPUTER,
         ui::DomKey::LAUNCH_MY_COMPUTER, ui::VKEY_MEDIA_LAUNCH_APP1},

        // Map numpad keys.
        {ui::DomCode::NUMPAD0, ui::DomKey::FromCharacter('0'),
         ui::DomKey::INSERT, ui::VKEY_NUMPAD0},
        {ui::DomCode::NUMPAD1, ui::DomKey::FromCharacter('1'), ui::DomKey::END,
         ui::VKEY_NUMPAD1},
        {ui::DomCode::NUMPAD2, ui::DomKey::FromCharacter('2'),
         ui::DomKey::ARROW_DOWN, ui::VKEY_NUMPAD2},
        {ui::DomCode::NUMPAD3, ui::DomKey::FromCharacter('3'),
         ui::DomKey::PAGE_DOWN, ui::VKEY_NUMPAD3},
        {ui::DomCode::NUMPAD4, ui::DomKey::FromCharacter('4'),
         ui::DomKey::ARROW_RIGHT, ui::VKEY_NUMPAD4},
        {ui::DomCode::NUMPAD5, ui::DomKey::FromCharacter('5'),
         ui::DomKey::CLEAR, ui::VKEY_NUMPAD5},
        {ui::DomCode::NUMPAD6, ui::DomKey::FromCharacter('6'),
         ui::DomKey::ARROW_LEFT, ui::VKEY_NUMPAD6},
        {ui::DomCode::NUMPAD7, ui::DomKey::FromCharacter('7'), ui::DomKey::HOME,
         ui::VKEY_NUMPAD7},
        {ui::DomCode::NUMPAD8, ui::DomKey::FromCharacter('8'),
         ui::DomKey::ARROW_UP, ui::VKEY_NUMPAD8},
        {ui::DomCode::NUMPAD9, ui::DomKey::FromCharacter('9'),
         ui::DomKey::PAGE_UP, ui::VKEY_NUMPAD9},
    });
    keyboard_capability_ =
        ui::KeyboardCapability::CreateStubKeyboardCapability();
    input_method_manager_mock_ = new input_method::MockInputMethodManagerImpl;
    input_method::InitializeForTesting(
        input_method_manager_mock_);  // pass ownership
    auto deprecation_controller =
        std::make_unique<DeprecationNotificationController>(&message_center_);
    deprecation_controller_ = deprecation_controller.get();
    auto input_device_settings_notification_controller =
        std::make_unique<InputDeviceSettingsNotificationController>(
            &message_center_);
    input_device_settings_notification_controller_ =
        input_device_settings_notification_controller.get();
    ChromeAshTestBase::SetUp();

    input_device_settings_controller_resetter_ = std::make_unique<
        InputDeviceSettingsController::ScopedResetterForTest>();
    input_device_settings_controller_mock_ =
        std::make_unique<MockInputDeviceSettingsController>();
    keyboard_settings = mojom::KeyboardSettings::New();
    // Disable F11/F12 settings by default.
    keyboard_settings->f11 = ui::mojom::ExtendedFkeysModifier::kDisabled;
    keyboard_settings->f12 = ui::mojom::ExtendedFkeysModifier::kDisabled;
    EXPECT_CALL(*input_device_settings_controller_mock_,
                GetKeyboardSettings(testing::_))
        .WillRepeatedly(testing::Return(keyboard_settings.get()));

    delegate_ = std::make_unique<EventRewriterDelegateImpl>(
        nullptr, std::move(deprecation_controller),
        std::move(input_device_settings_notification_controller),
        input_device_settings_controller_mock_.get());
    delegate_->set_pref_service_for_testing(prefs());
    device_data_manager_test_api_.SetKeyboardDevices({});
    keyboard_device_id_event_rewriter_ =
        std::make_unique<ui::KeyboardDeviceIdEventRewriter>(
            keyboard_capability_.get());
    keyboard_modifier_event_rewriter_ =
        std::make_unique<ui::KeyboardModifierEventRewriter>(
            std::make_unique<TestKeyboardModifierEventRewriterDelegate>(
                delegate_.get()),
            keyboard_layout_engine_.get(), keyboard_capability_.get(),
            &fake_ime_keyboard_);
    caps_lock_event_rewriter_ = std::make_unique<ui::CapsLockEventRewriter>(
        keyboard_layout_engine_.get(), keyboard_capability_.get(),
        &fake_ime_keyboard_);
    event_rewriter_ash_ = std::make_unique<ui::EventRewriterAsh>(
        delegate_.get(), keyboard_capability_.get(),
        Shell::Get()->sticky_keys_controller(), false, &fake_ime_keyboard_);
    discard_key_event_rewriter_ =
        std::make_unique<ui::DiscardKeyEventRewriter>();

    source_.AddEventRewriter(keyboard_device_id_event_rewriter_.get());
    if (ash::features::IsKeyboardRewriterFixEnabled()) {
      source_.AddEventRewriter(keyboard_modifier_event_rewriter_.get());
    }
    if (ash::features::IsKeyboardRewriterFixEnabled() &&
        features::IsModifierSplitEnabled()) {
      source_.AddEventRewriter(caps_lock_event_rewriter_.get());
    }
    source_.AddEventRewriter(event_rewriter_ash_.get());
    if (!ash::features::IsKeyboardRewriterFixEnabled() &&
        features::IsModifierSplitEnabled()) {
      source_.AddEventRewriter(caps_lock_event_rewriter_.get());
    }
    if (features::IsModifierSplitEnabled()) {
      source_.AddEventRewriter(discard_key_event_rewriter_.get());
    }
  }

  void TearDown() override {
    if (features::IsModifierSplitEnabled()) {
      source_.RemoveEventRewriter(discard_key_event_rewriter_.get());
    }
    if (!ash::features::IsKeyboardRewriterFixEnabled() &&
        features::IsModifierSplitEnabled()) {
      source_.RemoveEventRewriter(caps_lock_event_rewriter_.get());
    }
    source_.RemoveEventRewriter(event_rewriter_ash_.get());
    if (ash::features::IsKeyboardRewriterFixEnabled() &&
        features::IsModifierSplitEnabled()) {
      source_.RemoveEventRewriter(caps_lock_event_rewriter_.get());
    }
    if (ash::features::IsKeyboardRewriterFixEnabled()) {
      source_.RemoveEventRewriter(keyboard_modifier_event_rewriter_.get());
    }
    source_.RemoveEventRewriter(keyboard_device_id_event_rewriter_.get());

    event_rewriter_ash_.reset();
    caps_lock_event_rewriter_.reset();
    keyboard_modifier_event_rewriter_.reset();
    keyboard_device_id_event_rewriter_.reset();

    input_device_settings_controller_mock_.reset();
    input_device_settings_controller_resetter_.reset();
    ChromeAshTestBase::TearDown();
    // Shutdown() deletes the IME mock object.
    input_method::Shutdown();
    keyboard_capability_.reset();
    keyboard_layout_engine_.reset();
  }

  ui::test::TestEventSource& source() { return source_; }

 protected:
  std::vector<TestKeyEvent> RunRewriter(
      const std::vector<TestKeyEvent>& events,
      ui::EventFlags extra_flags = ui::EF_NONE,
      int device_id = kKeyboardDeviceId) {
    struct ModifierInfo {
      ui::EventFlags flag;
      ui::DomCode code;
      ui::DomKey key;
      ui::KeyboardCode keycode;
    };
    // We'll use modifier keys at left side heuristically.
    static constexpr ModifierInfo kModifierList[] = {
        {ui::EF_SHIFT_DOWN, ui::DomCode::SHIFT_LEFT, ui::DomKey::SHIFT,
         ui::VKEY_SHIFT},
        {ui::EF_CONTROL_DOWN, ui::DomCode::CONTROL_LEFT, ui::DomKey::CONTROL,
         ui::VKEY_CONTROL},
        {ui::EF_ALT_DOWN, ui::DomCode::ALT_LEFT, ui::DomKey::ALT,
         ui::VKEY_MENU},
        {ui::EF_COMMAND_DOWN, ui::DomCode::META_LEFT, ui::DomKey::META,
         ui::VKEY_LWIN},
        {ui::EF_MOD3_DOWN, ui::DomCode::CAPS_LOCK, ui::DomKey::CAPS_LOCK,
         ui::VKEY_CAPITAL},
        {ui::EF_FUNCTION_DOWN, ui::DomCode::FN, ui::DomKey::FN,
         ui::VKEY_FUNCTION},
    };

    // Send modifier key press events to update rewriter's modifier flag state.
    ui::EventFlags current_flags = 0;
    for (const auto& modifier : kModifierList) {
      if (!(extra_flags & modifier.flag)) {
        continue;
      }
      current_flags |= modifier.flag;
      SendKeyEvent(TestKeyEvent{ui::EventType::kKeyPressed, modifier.code,
                                modifier.key, modifier.keycode, current_flags},
                   device_id);
    }
    CHECK_EQ(current_flags, extra_flags);

    // Add extra_flags to each TestkeyEvent.
    std::vector<TestKeyEvent> key_events;
    for (const auto& event : events) {
      key_events.push_back(TestKeyEvent{
          event.type, event.code, event.key, event.keycode,
          event.flags | current_flags, event.scan_code, event.properties});
    }
    auto result = SendKeyEvents(key_events, device_id);

    // Send modifier key release events to unset rewriter'.s modifier flag
    // state.
    for (const auto& modifier : base::Reversed(kModifierList)) {
      if (!(extra_flags & modifier.flag)) {
        continue;
      }
      current_flags &= ~modifier.flag;
      SendKeyEvent(TestKeyEvent{ui::EventType::kKeyReleased, modifier.code,
                                modifier.key, modifier.keycode, current_flags},
                   device_id);
    }
    CHECK_EQ(current_flags, 0);

    return result;
  }

  // Sends a KeyEvent to the rewriter, returns the rewritten events.
  // Note: one event may be rewritten into multiple events.
  std::vector<TestKeyEvent> SendKeyEvent(const TestKeyEvent& event,
                                         int device_id = kKeyboardDeviceId) {
    return SendKeyEvents({event}, device_id);
  }

  std::vector<TestKeyEvent> SendKeyEvents(
      const std::vector<TestKeyEvent>& events,
      int device_id = kKeyboardDeviceId) {
    // Just in case some events may be there.
    if (!TakeEvents().empty()) {
      ADD_FAILURE() << "Rewritten events were left";
    }

    // Convert TestKeyEvent into ui::KeyEvent, then dispatch it to the
    // rewriter.
    for (const TestKeyEvent& event : events) {
      ui::KeyEvent key_event(event.type, event.keycode, event.code, event.flags,
                             event.key, ui::EventTimeForNow());
      key_event.set_scan_code(event.scan_code);
      key_event.set_source_device_id(device_id);
      ui::EventDispatchDetails details = source_.Send(&key_event);
      CHECK(!details.dispatcher_destroyed);
    }

    // Convert the rewritten ui::Events back to TestKeyEvent.
    auto rewritten_events = TakeEvents();
    std::vector<TestKeyEvent> result;
    for (const auto& rewritten_event : rewritten_events) {
      auto* rewritten_key_event = rewritten_event->AsKeyEvent();
      if (!rewritten_key_event) {
        ADD_FAILURE() << "Unexpected rewritten key event: "
                      << rewritten_event->ToString();
        continue;
      }
      std::vector<std::pair<std::string, std::vector<uint8_t>>> properties;
      if (rewritten_key_event->properties()) {
        for (const auto& property : *rewritten_key_event->properties()) {
          properties.push_back(property);
        }
      }
      result.push_back(
          {rewritten_key_event->type(), rewritten_key_event->code(),
           rewritten_key_event->GetDomKey(), rewritten_key_event->key_code(),
           rewritten_key_event->flags(), rewritten_key_event->scan_code(),
           std::move(properties)});
    }
    return result;
  }

  // Parameterized version of test depending on feature flag values. The feature
  // kUseSearchClickForRightClick determines if this should test for alt-click
  // or search-click.
  void DontRewriteIfNotRewritten(int right_click_flags);

  ui::MouseEvent RewriteMouseButtonEvent(const ui::MouseEvent& event) {
    TestEventRewriterContinuation continuation;
    event_rewriter_ash_->RewriteMouseButtonEventForTesting(
        event, continuation.weak_ptr_factory_.GetWeakPtr());
    if (!continuation.rewritten_events.empty()) {
      return ui::MouseEvent(*continuation.rewritten_events[0]->AsMouseEvent());
    }
    return ui::MouseEvent(event);
  }

  sync_preferences::TestingPrefServiceSyncable* prefs() { return &prefs_; }

  void InitModifierKeyPref(IntegerPrefMember* int_pref,
                           const std::string& pref_name,
                           ui::mojom::ModifierKey remap_from,
                           ui::mojom::ModifierKey remap_to) {
    if (!features::IsInputDeviceSettingsSplitEnabled()) {
      if (int_pref->GetPrefName() !=
          pref_name) {  // skip if already initialized.
        int_pref->Init(pref_name, prefs());
      }
      int_pref->SetValue(static_cast<int>(remap_to));
      return;
    }
    if (remap_from == remap_to) {
      keyboard_settings->modifier_remappings.erase(remap_from);
      return;
    }

    keyboard_settings->modifier_remappings[remap_from] = remap_to;
  }

  void SetUpKeyboard(const TestKeyboard& test_keyboard) {
    // Add a fake device to udev.
    const ui::KeyboardDevice keyboard(
        kKeyboardDeviceId, test_keyboard.type, test_keyboard.name,
        /*phys=*/"", base::FilePath(kKbdSysPath),
        /*vendor=*/-1,
        /*product=*/-1, /*version=*/-1,
        /*has_assistant_key=*/test_keyboard.has_assistant_key,
        /*has_function_key=*/test_keyboard.has_function_key);

    // Old CrOS keyboards supply an integer/enum as a sysfs property to identify
    // their layout type. New keyboards provide the mapping of scan codes to
    // F-Key position via an attribute.
    std::map<std::string, std::string> sysfs_properties;
    std::map<std::string, std::string> sysfs_attributes;
    if (!std::string_view(test_keyboard.layout).empty()) {
      (test_keyboard.has_custom_top_row
           ? sysfs_attributes[kKbdTopRowLayoutAttributeName]
           : sysfs_properties[kKbdTopRowPropertyName]) = test_keyboard.layout;
    }

    fake_udev_.Reset();
    fake_udev_.AddFakeDevice(keyboard.name, keyboard.sys_path.value(),
                             /*subsystem=*/"input", /*devnode=*/std::nullopt,
                             /*devtype=*/std::nullopt,
                             std::move(sysfs_attributes),
                             std::move(sysfs_properties));

    // Reset the state of the device manager.
    device_data_manager_test_api_.SetKeyboardDevices({});
    device_data_manager_test_api_.SetKeyboardDevices({keyboard});

    // Reset the state of the EventRewriter.
    event_rewriter_ash_->ResetStateForTesting();
    event_rewriter_ash_->set_last_keyboard_device_id_for_testing(
        kKeyboardDeviceId);
  }

  void SetExtensionCommands(
      std::optional<base::flat_set<std::pair<ui::KeyboardCode, int>>>
          commands) {
    delegate_->SetExtensionCommandsOverrideForTesting(std::move(commands));
  }

  std::vector<std::unique_ptr<ui::Event>> TakeEvents() {
    return sink_.TakeEvents();
  }

  void ClearNotifications() {
    message_center_.RemoveAllNotifications(
        false, message_center::FakeMessageCenter::RemoveType::ALL);
    deprecation_controller_->ResetStateForTesting();
  }

  base::test::ScopedFeatureList scoped_feature_list_;
  raw_ptr<FakeChromeUserManager, DanglingUntriaged>
      fake_user_manager_;  // Not owned.
  user_manager::ScopedUserManager user_manager_enabler_;
  raw_ptr<input_method::MockInputMethodManagerImpl, DanglingUntriaged>
      input_method_manager_mock_;
  testing::FakeUdevLoader fake_udev_;
  ui::DeviceDataManagerTestApi device_data_manager_test_api_;
  std::unique_ptr<InputDeviceSettingsController::ScopedResetterForTest>
      input_device_settings_controller_resetter_;
  std::unique_ptr<MockInputDeviceSettingsController>
      input_device_settings_controller_mock_;
  mojom::KeyboardSettingsPtr keyboard_settings;

  sync_preferences::TestingPrefServiceSyncable prefs_;
  std::unique_ptr<EventRewriterDelegateImpl> delegate_;
  std::unique_ptr<ui::StubKeyboardLayoutEngine> keyboard_layout_engine_;
  std::unique_ptr<ui::KeyboardCapability> keyboard_capability_;
  input_method::FakeImeKeyboard fake_ime_keyboard_;
  std::unique_ptr<ui::KeyboardDeviceIdEventRewriter>
      keyboard_device_id_event_rewriter_;
  std::unique_ptr<ui::KeyboardModifierEventRewriter>
      keyboard_modifier_event_rewriter_;
  std::unique_ptr<ui::CapsLockEventRewriter> caps_lock_event_rewriter_;
  std::unique_ptr<ui::EventRewriterAsh> event_rewriter_ash_;
  std::unique_ptr<ui::DiscardKeyEventRewriter> discard_key_event_rewriter_;
  TestEventSink sink_;
  ui::test::TestEventSource source_{&sink_};
  message_center::FakeMessageCenter message_center_;
  raw_ptr<DeprecationNotificationController>
      deprecation_controller_;  // Not owned.
  raw_ptr<InputDeviceSettingsNotificationController>
      input_device_settings_notification_controller_;  // Not owned.
};

class EventRewriterTest
    : public EventRewriterTestBase,
      public testing::WithParamInterface<std::tuple<bool, bool>> {
 public:
  void SetUp() override {
    auto [enable_keyboard_rewriter_fix, enable_modifier_split] = GetParam();
    if (enable_keyboard_rewriter_fix) {
      fix_feature_list_.InitAndEnableFeature(
          ash::features::kEnableKeyboardRewriterFix);
    } else {
      fix_feature_list_.InitAndDisableFeature(
          ash::features::kEnableKeyboardRewriterFix);
    }

    if (enable_modifier_split) {
      modifier_split_feature_list_.InitAndEnableFeature(
          ash::features::kModifierSplit);
    } else {
      modifier_split_feature_list_.InitAndDisableFeature(
          ash::features::kModifierSplit);
    }

    EventRewriterTestBase::SetUp();
  }

  void TearDown() override {
    EventRewriterTestBase::TearDown();
    modifier_split_feature_list_.Reset();
    fix_feature_list_.Reset();
  }

 private:
  base::test::ScopedFeatureList fix_feature_list_;
  base::test::ScopedFeatureList modifier_split_feature_list_;
};

INSTANTIATE_TEST_SUITE_P(All,
                         EventRewriterTest,
                         testing::Combine(testing::Bool(), testing::Bool()));

// TestKeyRewriteLatency checks that the event rewriter
// publishes a latency metric every time a key is pressed.
TEST_P(EventRewriterTest, TestKeyRewriteLatency) {
  SendKeyEvent(KeyLControl::Pressed());

  base::HistogramTester histogram_tester;
  EXPECT_EQ(std::vector({KeyB::Pressed(ui::EF_CONTROL_DOWN),
                         KeyB::Pressed(ui::EF_CONTROL_DOWN)}),
            SendKeyEvents({KeyB::Pressed(ui::EF_CONTROL_DOWN),
                           KeyB::Pressed(ui::EF_CONTROL_DOWN)}));
  histogram_tester.ExpectTotalCount(
      "ChromeOS.Inputs.EventRewriter.KeyRewriteLatency", 2);
}

TEST_P(EventRewriterTest, ModifiersNotRemappedWhenSuppressed) {
  // Remap Control -> Alt.
  Preferences::RegisterProfilePrefs(prefs()->registry());
  IntegerPrefMember control;
  InitModifierKeyPref(&control, ::prefs::kLanguageRemapControlKeyTo,
                      ui::mojom::ModifierKey::kControl,
                      ui::mojom::ModifierKey::kAlt);

  // Pressing Control + B should now be remapped to Alt + B.
  delegate_->SuppressModifierKeyRewrites(false);
  EXPECT_EQ(KeyB::Typed(ui::EF_ALT_DOWN),
            RunRewriter(KeyB::Typed(), ui::EF_CONTROL_DOWN));

  // Pressing Control + B should no longer be remapped.
  delegate_->SuppressModifierKeyRewrites(true);
  EXPECT_EQ(KeyB::Typed(ui::EF_CONTROL_DOWN),
            RunRewriter(KeyB::Typed(), ui::EF_CONTROL_DOWN));
}

TEST_P(EventRewriterTest, TestRewriteNumPadKeys) {
  // Even if most Chrome OS keyboards do not have numpad, they should still
  // handle it the same way as generic PC keyboards.
  for (const auto& keyboard : kNonAppleKeyboardVariants) {
    SCOPED_TRACE(keyboard.name);
    SetUpKeyboard(keyboard);

    // XK_KP_Insert (= NumPad 0 without Num Lock), no modifier.
    EXPECT_EQ(KeyNumpad0::Typed(), RunRewriter(KeyNumpadInsert::Typed()));

    // XK_KP_Insert (= NumPad 0 without Num Lock), Alt modifier.
    EXPECT_EQ(KeyNumpad0::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyNumpadInsert::Typed(), ui::EF_ALT_DOWN));

    // XK_KP_Delete (= NumPad . without Num Lock), Alt modifier.
    EXPECT_EQ(KeyNumpadDecimal::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyNumpadDelete::Typed(), ui::EF_ALT_DOWN));

    // XK_KP_End (= NumPad 1 without Num Lock), Alt modifier.
    EXPECT_EQ(KeyNumpad1::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyNumpadEnd::Typed(), ui::EF_ALT_DOWN));

    // XK_KP_Down (= NumPad 2 without Num Lock), Alt modifier.
    EXPECT_EQ(KeyNumpad2::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyNumpadArrowDown::Typed(), ui::EF_ALT_DOWN));

    // XK_KP_Next (= NumPad 3 without Num Lock), Alt modifier.
    EXPECT_EQ(KeyNumpad3::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyNumpadPageDown::Typed(), ui::EF_ALT_DOWN));

    // XK_KP_Left (= NumPad 4 without Num Lock), Alt modifier.
    EXPECT_EQ(KeyNumpad4::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyNumpadArrowLeft::Typed(), ui::EF_ALT_DOWN));

    // XK_KP_Begin (= NumPad 5 without Num Lock), Alt modifier.
    EXPECT_EQ(KeyNumpad5::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyNumpadClear::Typed(), ui::EF_ALT_DOWN));

    // XK_KP_Right (= NumPad 6 without Num Lock), Alt modifier.
    EXPECT_EQ(KeyNumpad6::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyNumpadArrowRight::Typed(), ui::EF_ALT_DOWN));

    // XK_KP_Home (= NumPad 7 without Num Lock), Alt modifier.
    EXPECT_EQ(KeyNumpad7::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyNumpadHome::Typed(), ui::EF_ALT_DOWN));

    // XK_KP_Up (= NumPad 8 without Num Lock), Alt modifier.
    EXPECT_EQ(KeyNumpad8::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyNumpadArrowUp::Typed(), ui::EF_ALT_DOWN));

    // XK_KP_Prior (= NumPad 9 without Num Lock), Alt modifier.
    EXPECT_EQ(KeyNumpad9::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyNumpadPageUp::Typed(), ui::EF_ALT_DOWN));

    // XK_KP_{N} (= NumPad {N} with Num Lock), Num Lock modifier.
    EXPECT_EQ(KeyNumpad0::Typed(), RunRewriter(KeyNumpad0::Typed()));
    EXPECT_EQ(KeyNumpad1::Typed(), RunRewriter(KeyNumpad1::Typed()));
    EXPECT_EQ(KeyNumpad2::Typed(), RunRewriter(KeyNumpad2::Typed()));
    EXPECT_EQ(KeyNumpad3::Typed(), RunRewriter(KeyNumpad3::Typed()));
    EXPECT_EQ(KeyNumpad4::Typed(), RunRewriter(KeyNumpad4::Typed()));
    EXPECT_EQ(KeyNumpad5::Typed(), RunRewriter(KeyNumpad5::Typed()));
    EXPECT_EQ(KeyNumpad6::Typed(), RunRewriter(KeyNumpad6::Typed()));
    EXPECT_EQ(KeyNumpad7::Typed(), RunRewriter(KeyNumpad7::Typed()));
    EXPECT_EQ(KeyNumpad8::Typed(), RunRewriter(KeyNumpad8::Typed()));
    EXPECT_EQ(KeyNumpad9::Typed(), RunRewriter(KeyNumpad9::Typed()));

    // XK_KP_DECIMAL (= NumPad . with Num Lock), Num Lock modifier.
    EXPECT_EQ(KeyNumpadDecimal::Typed(),
              RunRewriter(KeyNumpadDecimal::Typed()));
  }
}

// Tests if the rewriter can handle a Command + Num Pad event.
TEST_P(EventRewriterTest, TestRewriteNumPadKeysOnAppleKeyboard) {
  // Simulate the default initialization of the Apple Command key remap pref to
  // Ctrl.
  Preferences::RegisterProfilePrefs(prefs()->registry());

  if (features::IsInputDeviceSettingsSplitEnabled()) {
    keyboard_settings->modifier_remappings[ui::mojom::ModifierKey::kMeta] =
        ui::mojom::ModifierKey::kControl;
  }

  SetUpKeyboard(kExternalAppleKeyboard);

  // XK_KP_End (= NumPad 1 without Num Lock), Win modifier.
  // The result should be "Num Pad 1 with Control + Num Lock modifiers".
  EXPECT_EQ(KeyNumpad1::Typed(ui::EF_CONTROL_DOWN),
            RunRewriter(KeyNumpadEnd::Typed(), ui::EF_COMMAND_DOWN));

  // XK_KP_1 (= NumPad 1 with Num Lock), Win modifier.
  // The result should also be "Num Pad 1 with Control + Num Lock
  // modifiers".
  EXPECT_EQ(KeyNumpad1::Typed(ui::EF_CONTROL_DOWN),
            RunRewriter(KeyNumpad1::Typed(), ui::EF_COMMAND_DOWN));
}

TEST_P(EventRewriterTest, TestRewriteModifiersNoRemap) {
  for (const auto& keyboard : kAllKeyboardVariants) {
    SCOPED_TRACE(keyboard.name);
    SetUpKeyboard(keyboard);

    // Press Search. Confirm the event is not rewritten.
    EXPECT_EQ(KeyLMeta::Typed(), RunRewriter(KeyLMeta::Typed()));

    // Press left Control. Confirm the event is not rewritten.
    EXPECT_EQ(KeyLControl::Typed(), RunRewriter(KeyLControl::Typed()));

    // Press right Control. Confirm the event is not rewritten.
    EXPECT_EQ(KeyRControl::Typed(), RunRewriter(KeyRControl::Typed()));

    // Press left Alt. Confirm the event is not rewritten.
    EXPECT_EQ(KeyLAlt::Typed(), RunRewriter(KeyLAlt::Typed()));

    // Press quick insert. Confirm the event is not rewritten.
    EXPECT_EQ(KeyRAlt::Typed(), RunRewriter(KeyRAlt::Typed()));
  }
}

TEST_P(EventRewriterTest, TestRewriteModifiersNoRemapMultipleKeys) {
  for (const auto& keyboard : kAllKeyboardVariants) {
    SCOPED_TRACE(keyboard.name);
    SetUpKeyboard(keyboard);

    // Press Alt with Shift. Confirm the event is not rewritten.
    EXPECT_EQ(KeyLAlt::Typed(ui::EF_SHIFT_DOWN),
              RunRewriter(KeyLAlt::Typed(), ui::EF_SHIFT_DOWN));

    // Press Escape with Alt and Shift. Confirm the event is not rewritten.
    EXPECT_EQ(
        KeyEscape::Typed(ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN),
        RunRewriter(KeyEscape::Typed(), ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN));

    // Toggling on CapsLock.
    EXPECT_EQ(KeyCapsLock::Typed(ui::EF_CAPS_LOCK_ON),
              RunRewriter(KeyCapsLock::Typed(ui::EF_CAPS_LOCK_ON)));

    // Press Search with Caps Lock mask. Confirm the event is not rewritten.
    EXPECT_EQ(KeyLMeta::Typed(ui::EF_CAPS_LOCK_ON),
              RunRewriter(KeyLMeta::Typed(ui::EF_CAPS_LOCK_ON)));

    // Toggling off CapsLock.
    EXPECT_EQ(KeyCapsLock::Typed(), RunRewriter(KeyCapsLock::Typed()));

    // Press Shift+Ctrl+Alt+Search+Escape. Confirm the event is not rewritten.
    EXPECT_EQ(KeyEscape::Typed(ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN |
                               ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN),
              RunRewriter(KeyEscape::Typed(),
                          ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN |
                              ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN));

    // Press Shift+Ctrl+Alt+Search+B. Confirm the event is not rewritten.
    EXPECT_EQ(KeyB::Typed(ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN |
                          ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN),
              RunRewriter(
                  // In this case, SHIFT modifier will be set on pressing B,
                  // thus we should use capital 'B' as DomKey, which the current
                  // factory does not support.
                  // Modifier flags will be annotated to TestKeyEvents inside
                  // RunRewriter.
                  {TestKeyEvent{ui::EventType::kKeyPressed, ui::DomCode::US_B,
                                ui::DomKey::FromCharacter('B'), ui::VKEY_B},
                   TestKeyEvent{ui::EventType::kKeyReleased, ui::DomCode::US_B,
                                ui::DomKey::FromCharacter('B'), ui::VKEY_B}},
                  ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN |
                      ui::EF_COMMAND_DOWN));
  }
}

TEST_P(EventRewriterTest, TestRewriteModifiersDisableSome) {
  // Disable Search, Control and Escape keys.
  Preferences::RegisterProfilePrefs(prefs()->registry());
  IntegerPrefMember search;
  InitModifierKeyPref(&search, ::prefs::kLanguageRemapSearchKeyTo,
                      ui::mojom::ModifierKey::kMeta,
                      ui::mojom::ModifierKey::kVoid);
  IntegerPrefMember control;
  InitModifierKeyPref(&control, ::prefs::kLanguageRemapControlKeyTo,
                      ui::mojom::ModifierKey::kControl,
                      ui::mojom::ModifierKey::kVoid);
  IntegerPrefMember escape;
  InitModifierKeyPref(&escape, ::prefs::kLanguageRemapEscapeKeyTo,
                      ui::mojom::ModifierKey::kEscape,
                      ui::mojom::ModifierKey::kVoid);

  for (const auto& keyboard : kChromeKeyboardVariants) {
    SCOPED_TRACE(keyboard.name);
    SetUpKeyboard(keyboard);

    // Press Alt with Shift. This key press shouldn't be affected by the
    // pref. Confirm the event is not rewritten.
    EXPECT_EQ(KeyLAlt::Typed(ui::EF_SHIFT_DOWN),
              RunRewriter(KeyLAlt::Typed(ui::EF_SHIFT_DOWN)));

    // Press Search. Confirm the event is now VKEY_UNKNOWN.
    EXPECT_EQ(KeyUnknown::Typed(), RunRewriter(KeyLMeta::Typed()));

    // Press Control. Confirm the event is now VKEY_UNKNOWN.
    EXPECT_EQ(KeyUnknown::Typed(), RunRewriter(KeyLControl::Typed()));

    // Press Escape. Confirm the event is now VKEY_UNKNOWN.
    EXPECT_EQ(KeyUnknown::Typed(), RunRewriter(KeyEscape::Typed()));

    // Press Control+Search. Confirm the event is now VKEY_UNKNOWN
    // without any modifiers.
    if (ash::features::IsKeyboardRewriterFixEnabled()) {
      EXPECT_EQ(KeyUnknown::Typed(),
                RunRewriter(KeyLMeta::Typed(), ui::EF_CONTROL_DOWN));
    } else {
      // TODO(crbug.com/40265877): Release key event is not dispatched in old
      // rewriter. Remove this once the old rewriter is no longer used.
      EXPECT_EQ(std::vector({KeyUnknown::Pressed()}),
                RunRewriter(KeyLMeta::Typed(), ui::EF_CONTROL_DOWN));
    }

    // Press Control+Search+a. Confirm the event is now VKEY_A without any
    // modifiers.
    EXPECT_EQ(KeyA::Typed(), RunRewriter(KeyA::Typed(), ui::EF_CONTROL_DOWN));

    // Press Control+Search+Alt+a. Confirm the event is now VKEY_A only with
    // the Alt modifier.
    EXPECT_EQ(
        KeyA::Typed(ui::EF_ALT_DOWN),
        RunRewriter(KeyA::Typed(), ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN));
  }

  // Remap Alt to Control.
  IntegerPrefMember alt;
  InitModifierKeyPref(&alt, ::prefs::kLanguageRemapAltKeyTo,
                      ui::mojom::ModifierKey::kAlt,
                      ui::mojom::ModifierKey::kControl);

  for (const auto& keyboard : kChromeKeyboardVariants) {
    SCOPED_TRACE(keyboard.name);
    SetUpKeyboard(keyboard);

    // Press left Alt. Confirm the event is now VKEY_CONTROL
    // even though the Control key itself is disabled.
    EXPECT_EQ(KeyLControl::Typed(), RunRewriter(KeyLAlt::Typed()));

    // Press Alt+a. Confirm the event is now Control+a even though the Control
    // key itself is disabled.
    EXPECT_EQ(KeyA::Typed(ui::EF_CONTROL_DOWN),
              RunRewriter(KeyA::Typed(), ui::EF_ALT_DOWN));
  }
}

TEST_P(EventRewriterTest, TestRewriteModifiersRemapToControl) {
  // Remap Search to Control.
  Preferences::RegisterProfilePrefs(prefs()->registry());
  IntegerPrefMember search;
  InitModifierKeyPref(&search, ::prefs::kLanguageRemapSearchKeyTo,
                      ui::mojom::ModifierKey::kMeta,
                      ui::mojom::ModifierKey::kControl);

  for (const auto& keyboard : kChromeKeyboardVariants) {
    SCOPED_TRACE(keyboard.name);
    SetUpKeyboard(keyboard);

    // Press Search. Confirm the event is now VKEY_CONTROL.
    EXPECT_EQ(KeyLControl::Typed(), RunRewriter(KeyLMeta::Typed()));
  }

  // Remap Alt to Control too.
  IntegerPrefMember alt;
  InitModifierKeyPref(&alt, ::prefs::kLanguageRemapAltKeyTo,
                      ui::mojom::ModifierKey::kAlt,
                      ui::mojom::ModifierKey::kControl);

  for (const auto& keyboard : kChromeKeyboardVariants) {
    SCOPED_TRACE(keyboard.name);
    SetUpKeyboard(keyboard);

    // Press Alt. Confirm the event is now VKEY_CONTROL.
    EXPECT_EQ(KeyLControl::Typed(), RunRewriter(KeyLAlt::Typed()));

    // Press Alt+Search. Confirm the event is now VKEY_CONTROL.
    if (ash::features::IsKeyboardRewriterFixEnabled()) {
      // In this case, both pressed/released events have EF_CONTROL_DOWN,
      // because ALT key mapped to CONTROL is held.
      EXPECT_EQ(KeyLControl::Typed(ui::EF_CONTROL_DOWN),
                RunRewriter(KeyLMeta::Typed(), ui::EF_ALT_DOWN));
    } else {
      // TODO(crbug.com/40265877): Release key event is not dispatched in old
      // rewriter. Remove this once the old rewriter is no longer used.
      EXPECT_EQ(std::vector({KeyLControl::Pressed()}),
                RunRewriter(KeyLMeta::Typed(), ui::EF_ALT_DOWN));
    }

    // Press Control+Alt+Search. Confirm the event is now VKEY_CONTROL.
    if (ash::features::IsKeyboardRewriterFixEnabled()) {
      // In this case, both pressed/released events have EF_CONTROL_DOWN,
      // because ALT key mapped to CONTROL is held.
      EXPECT_EQ(KeyLControl::Typed(ui::EF_CONTROL_DOWN),
                RunRewriter(KeyLMeta::Typed(),
                            ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN));
    } else {
      // TODO(crbug.com/40265877): Release key event is not dispatched in old
      // rewriter. Remove this once the old rewriter is no longer used.
      EXPECT_EQ(std::vector({KeyLControl::Pressed()}),
                RunRewriter(KeyLMeta::Typed(),
                            ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN));
    }

    // Press Shift+Control+Alt+Search. Confirm the event is now Control with
    // Shift and Control modifiers.
    if (ash::features::IsKeyboardRewriterFixEnabled()) {
      // In this case, both pressed/released events have EF_CONTROL_DOWN,
      // because ALT key mapped to CONTROL is held.
      EXPECT_EQ(KeyLControl::Typed(ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN),
                RunRewriter(KeyLMeta::Typed(), ui::EF_SHIFT_DOWN |
                                                   ui::EF_CONTROL_DOWN |
                                                   ui::EF_ALT_DOWN));
    } else {
      // TODO(crbug.com/40265877): Release key event is not dispatched in old
      // rewriter. Remove this once the old rewriter is no longer used.
      EXPECT_EQ(std::vector({KeyLControl::Pressed(ui::EF_SHIFT_DOWN)}),
                RunRewriter(KeyLMeta::Typed(), ui::EF_SHIFT_DOWN |
                                                   ui::EF_CONTROL_DOWN |
                                                   ui::EF_ALT_DOWN));
    }

    // Press Shift+Control+Alt+Search+B. Confirm the event is now B with Shift
    // and Control modifiers.
    EXPECT_EQ(
        KeyB::Typed(ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN),
        RunRewriter(KeyB::Typed(), ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN |
                                       ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN));
  }
}

TEST_P(EventRewriterTest, TestRewriteModifiersRemapToEscape) {
  // Remap Search to Escape.
  Preferences::RegisterProfilePrefs(prefs()->registry());
  IntegerPrefMember search;
  InitModifierKeyPref(&search, ::prefs::kLanguageRemapSearchKeyTo,
                      ui::mojom::ModifierKey::kMeta,
                      ui::mojom::ModifierKey::kEscape);

  for (const auto& keyboard : kChromeKeyboardVariants) {
    SCOPED_TRACE(keyboard.name);
    SetUpKeyboard(keyboard);

    // Press Search. Confirm the event is now VKEY_ESCAPE.
    EXPECT_EQ(KeyEscape::Typed(), RunRewriter(KeyLMeta::Typed()));
  }
}

TEST_P(EventRewriterTest, TestRewriteModifiersRemapEscapeToAlt) {
  // Remap Escape to Alt.
  Preferences::RegisterProfilePrefs(prefs()->registry());
  IntegerPrefMember escape;
  InitModifierKeyPref(&escape, ::prefs::kLanguageRemapEscapeKeyTo,
                      ui::mojom::ModifierKey::kEscape,
                      ui::mojom::ModifierKey::kAlt);

  for (const auto& keyboard : kAllKeyboardVariants) {
    SCOPED_TRACE(keyboard.name);
    SetUpKeyboard(keyboard);

    // Press Escape. Confirm the event is now VKEY_MENU.
    EXPECT_EQ(KeyLAlt::Typed(), RunRewriter(KeyEscape::Typed()));
  }
}

TEST_P(EventRewriterTest, TestRewriteModifiersRemapAltToControl) {
  // Remap Alt to Control.
  Preferences::RegisterProfilePrefs(prefs()->registry());
  IntegerPrefMember alt;
  InitModifierKeyPref(&alt, ::prefs::kLanguageRemapAltKeyTo,
                      ui::mojom::ModifierKey::kAlt,
                      ui::mojom::ModifierKey::kControl);

  for (const auto& keyboard : kAllKeyboardVariants) {
    SCOPED_TRACE(keyboard.name);
    SetUpKeyboard(keyboard);

    // Press left Alt. Confirm the event is now VKEY_CONTROL.
    EXPECT_EQ(KeyLControl::Typed(), RunRewriter(KeyLAlt::Typed()));

    // Press Shift+comma. Verify that only the flags are changed.
    EXPECT_EQ(
        KeyComma::Typed(ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN),
        RunRewriter(KeyComma::Typed(), ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN));

    // Press Shift+9. Verify that only the flags are changed.
    EXPECT_EQ(
        KeyDigit9::Typed(ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN),
        RunRewriter(KeyDigit9::Typed(), ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN));
  }
}

TEST_P(EventRewriterTest, TestRewriteModifiersRemapUnderEscapeControlAlt) {
  Preferences::RegisterProfilePrefs(prefs()->registry());

  // Remap Escape to Alt.
  IntegerPrefMember escape;
  InitModifierKeyPref(&escape, ::prefs::kLanguageRemapEscapeKeyTo,
                      ui::mojom::ModifierKey::kEscape,
                      ui::mojom::ModifierKey::kAlt);

  // Remap Alt to Control.
  IntegerPrefMember alt;
  InitModifierKeyPref(&alt, ::prefs::kLanguageRemapAltKeyTo,
                      ui::mojom::ModifierKey::kAlt,
                      ui::mojom::ModifierKey::kControl);

  // Remap Control to Search.
  IntegerPrefMember control;
  InitModifierKeyPref(&control, ::prefs::kLanguageRemapControlKeyTo,
                      ui::mojom::ModifierKey::kControl,
                      ui::mojom::ModifierKey::kMeta);

  for (const auto& keyboard : kAllKeyboardVariants) {
    SCOPED_TRACE(keyboard.name);
    SetUpKeyboard(keyboard);

    // Press left Control. Confirm the event is now VKEY_LWIN.
    EXPECT_EQ(KeyLMeta::Typed(), RunRewriter(KeyLControl::Typed()));

    // Then, press all of the three, Control+Alt+Escape.
    EXPECT_EQ(
        KeyLAlt::Typed(ui::EF_CONTROL_DOWN | ui::EF_COMMAND_DOWN),
        RunRewriter(KeyEscape::Typed(), ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN));

    // Press Shift+Control+Alt+Escape.
    EXPECT_EQ(
        KeyLAlt::Typed(ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN |
                       ui::EF_COMMAND_DOWN),
        RunRewriter(KeyEscape::Typed(),
                    ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN));

    // Press Shift+Control+Alt+B
    EXPECT_EQ(
        KeyB::Typed(ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN |
                    ui::EF_COMMAND_DOWN),
        RunRewriter(KeyB::Typed(),
                    ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN));
  }
}

TEST_P(EventRewriterTest,
       TestRewriteModifiersRemapUnderEscapeControlAltSearch) {
  Preferences::RegisterProfilePrefs(prefs()->registry());

  // Remap Escape to Alt.
  IntegerPrefMember escape;
  InitModifierKeyPref(&escape, ::prefs::kLanguageRemapEscapeKeyTo,
                      ui::mojom::ModifierKey::kEscape,
                      ui::mojom::ModifierKey::kAlt);

  // Remap Alt to Control.
  IntegerPrefMember alt;
  InitModifierKeyPref(&alt, ::prefs::kLanguageRemapAltKeyTo,
                      ui::mojom::ModifierKey::kAlt,
                      ui::mojom::ModifierKey::kControl);

  // Remap Control to Search.
  IntegerPrefMember control;
  InitModifierKeyPref(&control, ::prefs::kLanguageRemapControlKeyTo,
                      ui::mojom::ModifierKey::kControl,
                      ui::mojom::ModifierKey::kMeta);

  // Remap Search to Backspace.
  IntegerPrefMember search;
  InitModifierKeyPref(&search, ::prefs::kLanguageRemapSearchKeyTo,
                      ui::mojom::ModifierKey::kMeta,
                      ui::mojom::ModifierKey::kBackspace);

  for (const auto& keyboard : kChromeKeyboardVariants) {
    SCOPED_TRACE(keyboard.name);
    SetUpKeyboard(keyboard);

    // Release Control and Escape, as Search and Alt would transform Backspace
    // to Delete.
    EXPECT_EQ(std::vector({KeyLMeta::Pressed()}),
              SendKeyEvent(KeyLControl::Pressed()));
    EXPECT_EQ(std::vector({KeyLAlt::Pressed(ui::EF_COMMAND_DOWN)}),
              SendKeyEvent(KeyEscape::Pressed(ui::EF_CONTROL_DOWN)));

    if (ash::features::IsKeyboardRewriterFixEnabled()) {
      EXPECT_EQ(std::vector({KeyLMeta::Released(ui::EF_ALT_DOWN)}),
                SendKeyEvent(KeyLControl::Released()));
      EXPECT_EQ(std::vector({KeyLAlt::Released()}),
                SendKeyEvent(KeyEscape::Released()));
    } else {
      // TODO(crbug.com/40265877): Due to old rewriter implementation,
      // unexpected key release events are dispatched, followed by wrongly
      // un-rewritten event is dispatched. Fix them.
      EXPECT_EQ(std::vector({KeyLMeta::Released(ui::EF_ALT_DOWN),
                             KeyLAlt::Released(ui::EF_ALT_DOWN)}),
                SendKeyEvent(KeyLControl::Released()));
      EXPECT_EQ(std::vector({KeyEscape::Released()}),
                SendKeyEvent(KeyEscape::Released()));
    }

    // Press Search. Confirm the event is now VKEY_BACK.
    EXPECT_EQ(KeyBackspace::Typed(), RunRewriter(KeyLMeta::Typed()));
  }
}

TEST_P(EventRewriterTest, TestRewriteModifiersRemapBackspaceToEscape) {
  // Remap Backspace to Escape.
  Preferences::RegisterProfilePrefs(prefs()->registry());
  IntegerPrefMember backspace;
  InitModifierKeyPref(&backspace, ::prefs::kLanguageRemapBackspaceKeyTo,
                      ui::mojom::ModifierKey::kBackspace,
                      ui::mojom::ModifierKey::kEscape);

  for (const auto& keyboard : kAllKeyboardVariants) {
    SCOPED_TRACE(keyboard.name);
    SetUpKeyboard(keyboard);

    // Press Backspace. Confirm the event is now VKEY_ESCAPE.
    EXPECT_EQ(KeyEscape::Typed(), RunRewriter(KeyBackspace::Typed()));
  }
}

TEST_P(EventRewriterTest,
       TestRewriteNonModifierToModifierWithRemapBetweenKeyEvents) {
  // Remap Escape to Alt.
  Preferences::RegisterProfilePrefs(prefs()->registry());
  IntegerPrefMember escape;
  InitModifierKeyPref(&escape, ::prefs::kLanguageRemapEscapeKeyTo,
                      ui::mojom::ModifierKey::kEscape,
                      ui::mojom::ModifierKey::kAlt);

  SetUpKeyboard(kInternalChromeKeyboard);

  // Press Escape.
  EXPECT_EQ(std::vector({KeyLAlt::Pressed()}),
            SendKeyEvent(KeyEscape::Pressed()));

  // Remap Escape to Control before releasing Escape.
  InitModifierKeyPref(&escape, ::prefs::kLanguageRemapEscapeKeyTo,
                      ui::mojom::ModifierKey::kEscape,
                      ui::mojom::ModifierKey::kControl);

  // Release Escape.
  if (ash::features::IsKeyboardRewriterFixEnabled()) {
    EXPECT_EQ(std::vector({KeyLAlt::Released()}),
              SendKeyEvent(KeyEscape::Released()));
  } else {
    EXPECT_EQ(std::vector({KeyEscape::Released()}),
              SendKeyEvent(KeyEscape::Released()));
  }

  // Type A, expect that Alt is not stickied.
  EXPECT_EQ(KeyA::Typed(), RunRewriter(KeyA::Typed()));
}

TEST_P(EventRewriterTest, TestRewriteModifiersRemapToCapsLock) {
  // Remap Search to Caps Lock.
  Preferences::RegisterProfilePrefs(prefs()->registry());
  IntegerPrefMember search;
  InitModifierKeyPref(&search, ::prefs::kLanguageRemapSearchKeyTo,
                      ui::mojom::ModifierKey::kMeta,
                      ui::mojom::ModifierKey::kCapsLock);

  SetUpKeyboard(kInternalChromeKeyboard);
  EXPECT_FALSE(fake_ime_keyboard_.IsCapsLockEnabled());

  // Press Search.
  EXPECT_EQ(std::vector({KeyCapsLock::Pressed(ui::EF_CAPS_LOCK_ON)}),
            SendKeyEvent(KeyLMeta::Pressed()));
  EXPECT_TRUE(fake_ime_keyboard_.IsCapsLockEnabled());

  // Release Search.
  EXPECT_EQ(std::vector({KeyCapsLock::Released(ui::EF_CAPS_LOCK_ON)}),
            SendKeyEvent(KeyLMeta::Released()));
  EXPECT_TRUE(fake_ime_keyboard_.IsCapsLockEnabled());

  // Press Search.
  EXPECT_EQ(std::vector({KeyCapsLock::Pressed()}),
            SendKeyEvent(KeyLMeta::Pressed()));
  EXPECT_FALSE(fake_ime_keyboard_.IsCapsLockEnabled());

  // Release Search.
  EXPECT_EQ(std::vector({KeyCapsLock::Released()}),
            SendKeyEvent(KeyLMeta::Released()));
  EXPECT_FALSE(fake_ime_keyboard_.IsCapsLockEnabled());

  // Do the same on external Chrome OS keyboard.
  SetUpKeyboard(kExternalChromeKeyboard);

  // Press Search.
  EXPECT_EQ(std::vector({KeyCapsLock::Pressed(ui::EF_CAPS_LOCK_ON)}),
            SendKeyEvent(KeyLMeta::Pressed()));
  EXPECT_TRUE(fake_ime_keyboard_.IsCapsLockEnabled());

  // Release Search.
  EXPECT_EQ(std::vector({KeyCapsLock::Released(ui::EF_CAPS_LOCK_ON)}),
            SendKeyEvent(KeyLMeta::Released()));
  EXPECT_TRUE(fake_ime_keyboard_.IsCapsLockEnabled());

  // Press Search.
  EXPECT_EQ(std::vector({KeyCapsLock::Pressed()}),
            SendKeyEvent(KeyLMeta::Pressed()));
  EXPECT_FALSE(fake_ime_keyboard_.IsCapsLockEnabled());

  // Release Search.
  EXPECT_EQ(std::vector({KeyCapsLock::Released()}),
            SendKeyEvent(KeyLMeta::Released()));
  EXPECT_FALSE(fake_ime_keyboard_.IsCapsLockEnabled());

  // Try external keyboard with Caps Lock.
  SetUpKeyboard(kExternalGenericKeyboard);

  // Press Caps Lock.
  EXPECT_EQ(std::vector({KeyCapsLock::Pressed(ui::EF_CAPS_LOCK_ON)}),
            SendKeyEvent(KeyCapsLock::Pressed(ui::EF_CAPS_LOCK_ON)));
  EXPECT_TRUE(fake_ime_keyboard_.IsCapsLockEnabled());

  // Release Caps Lock.
  EXPECT_EQ(std::vector({KeyCapsLock::Released(ui::EF_CAPS_LOCK_ON)}),
            SendKeyEvent(KeyCapsLock::Released(ui::EF_CAPS_LOCK_ON)));
  EXPECT_TRUE(fake_ime_keyboard_.IsCapsLockEnabled());
}

TEST_P(EventRewriterTest, TestRewriteCapsLock) {
  Preferences::RegisterProfilePrefs(prefs()->registry());

  SetUpKeyboard(kExternalGenericKeyboard);
  EXPECT_FALSE(fake_ime_keyboard_.IsCapsLockEnabled());

  // On Chrome OS, CapsLock is mapped to CapsLock with Mod3Mask.
  EXPECT_EQ(std::vector({KeyCapsLock::Pressed(ui::EF_CAPS_LOCK_ON)}),
            SendKeyEvent(KeyCapsLock::Pressed()));
  EXPECT_TRUE(fake_ime_keyboard_.IsCapsLockEnabled());

  // Key repeating should not toggle CapsLock state.
  EXPECT_EQ(std::vector({KeyCapsLock::Pressed(ui::EF_CAPS_LOCK_ON)}),
            SendKeyEvent(KeyCapsLock::Pressed()));
  EXPECT_TRUE(fake_ime_keyboard_.IsCapsLockEnabled());

  EXPECT_EQ(std::vector({KeyCapsLock::Released(ui::EF_CAPS_LOCK_ON)}),
            SendKeyEvent(KeyCapsLock::Released(ui::EF_CAPS_LOCK_ON)));
  EXPECT_TRUE(fake_ime_keyboard_.IsCapsLockEnabled());

  // Remap Caps Lock to Control.
  IntegerPrefMember caps_lock;
  InitModifierKeyPref(&caps_lock, ::prefs::kLanguageRemapCapsLockKeyTo,
                      ui::mojom::ModifierKey::kCapsLock,
                      ui::mojom::ModifierKey::kControl);

  // Press Caps Lock. CapsLock is enabled but we have remapped the key to
  // now be Control. We want to ensure that the CapsLock modifier is still
  // active even after pressing the remapped Capslock key.
  EXPECT_EQ(std::vector({KeyLControl::Pressed(ui::EF_CAPS_LOCK_ON)}),
            SendKeyEvent(KeyCapsLock::Pressed(ui::EF_CAPS_LOCK_ON)));
  EXPECT_TRUE(fake_ime_keyboard_.IsCapsLockEnabled());

  // Release Caps Lock.
  EXPECT_EQ(std::vector({KeyLControl::Released(ui::EF_CAPS_LOCK_ON)}),
            SendKeyEvent(KeyCapsLock::Released(ui::EF_CAPS_LOCK_ON)));
  EXPECT_TRUE(fake_ime_keyboard_.IsCapsLockEnabled());
}

TEST_P(EventRewriterTest, TestRewriteExternalCapsLockWithDifferentScenarios) {
  Preferences::RegisterProfilePrefs(prefs()->registry());

  SetUpKeyboard(kExternalGenericKeyboard);
  EXPECT_FALSE(fake_ime_keyboard_.IsCapsLockEnabled());

  // Turn on CapsLock.
  EXPECT_EQ(std::vector({KeyCapsLock::Pressed(ui::EF_CAPS_LOCK_ON)}),
            SendKeyEvent(KeyCapsLock::Pressed()));
  EXPECT_TRUE(fake_ime_keyboard_.IsCapsLockEnabled());

  EXPECT_EQ(std::vector({KeyCapsLock::Released(ui::EF_CAPS_LOCK_ON)}),
            SendKeyEvent(KeyCapsLock::Released(ui::EF_CAPS_LOCK_ON)));
  EXPECT_TRUE(fake_ime_keyboard_.IsCapsLockEnabled());

  // Remap CapsLock to Search.
  IntegerPrefMember search;
  InitModifierKeyPref(&search, ::prefs::kLanguageRemapCapsLockKeyTo,
                      ui::mojom::ModifierKey::kCapsLock,
                      ui::mojom::ModifierKey::kMeta);

  // Now that CapsLock is enabled, press the remapped CapsLock button again
  // and expect to not disable CapsLock.
  EXPECT_EQ(std::vector({KeyLMeta::Pressed(ui::EF_CAPS_LOCK_ON)}),
            SendKeyEvent(KeyCapsLock::Pressed(ui::EF_CAPS_LOCK_ON)));
  EXPECT_TRUE(fake_ime_keyboard_.IsCapsLockEnabled());

  EXPECT_EQ(std::vector({KeyLMeta::Released(ui::EF_CAPS_LOCK_ON)}),
            SendKeyEvent(KeyCapsLock::Released(ui::EF_CAPS_LOCK_ON)));
  EXPECT_TRUE(fake_ime_keyboard_.IsCapsLockEnabled());

  // Remap CapsLock key back to CapsLock.
  IntegerPrefMember capslock;
  InitModifierKeyPref(&capslock, ::prefs::kLanguageRemapCapsLockKeyTo,
                      ui::mojom::ModifierKey::kCapsLock,
                      ui::mojom::ModifierKey::kCapsLock);

  // Now press CapsLock again and now expect that the CapsLock modifier is
  // removed and the key is disabled.
  EXPECT_EQ(std::vector({KeyCapsLock::Pressed()}),
            SendKeyEvent(KeyCapsLock::Pressed(ui::EF_CAPS_LOCK_ON)));
  EXPECT_FALSE(fake_ime_keyboard_.IsCapsLockEnabled());
}

TEST_P(EventRewriterTest, TestRewriteCapsLockToControl) {
  // Remap CapsLock to Control.
  Preferences::RegisterProfilePrefs(prefs()->registry());
  IntegerPrefMember control;
  InitModifierKeyPref(&control, ::prefs::kLanguageRemapCapsLockKeyTo,
                      ui::mojom::ModifierKey::kCapsLock,
                      ui::mojom::ModifierKey::kControl);

  SetUpKeyboard(kExternalGenericKeyboard);

  // Press CapsLock+a. Confirm that Mod3Mask is rewritten to ControlMask.
  // On Chrome OS, CapsLock works as a Mod3 modifier.
  EXPECT_EQ(KeyA::Typed(ui::EF_CONTROL_DOWN),
            RunRewriter(KeyA::Typed(), ui::EF_MOD3_DOWN));

  // Press Control+CapsLock+a. Confirm that Mod3Mask is rewritten to
  // ControlMask
  EXPECT_EQ(KeyA::Typed(ui::EF_CONTROL_DOWN),
            RunRewriter(KeyA::Typed(), ui::EF_CONTROL_DOWN | ui::EF_MOD3_DOWN));

  // Press Alt+CapsLock+a. Confirm that Mod3Mask is rewritten to
  // ControlMask.
  EXPECT_EQ(KeyA::Typed(ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN),
            RunRewriter(KeyA::Typed(), ui::EF_ALT_DOWN | ui::EF_MOD3_DOWN));
}

TEST_P(EventRewriterTest, TestRewriteCapsLockMod3InUse) {
  // Remap CapsLock to Control.
  Preferences::RegisterProfilePrefs(prefs()->registry());
  IntegerPrefMember control;
  InitModifierKeyPref(&control, ::prefs::kLanguageRemapCapsLockKeyTo,
                      ui::mojom::ModifierKey::kCapsLock,
                      ui::mojom::ModifierKey::kControl);

  SetUpKeyboard(kExternalGenericKeyboard);
  input_method_manager_mock_->set_mod3_used(true);

  // Press CapsLock+a. Confirm that Mod3Mask is NOT rewritten to ControlMask
  // when Mod3Mask is already in use by the current XKB layout.
  EXPECT_EQ(KeyA::Typed(), RunRewriter(KeyA::Typed()));

  input_method_manager_mock_->set_mod3_used(false);
}

TEST_P(EventRewriterTest, TestRewriteToQuickInsert) {
  // Remap QuickInsert to Control
  Preferences::RegisterProfilePrefs(prefs()->registry());
  IntegerPrefMember control;
  InitModifierKeyPref(&control, ::prefs::kLanguageRemapControlKeyTo,
                      ui::mojom::ModifierKey::kControl,
                      ui::mojom::ModifierKey::kQuickInsert);

  IntegerPrefMember search;
  InitModifierKeyPref(&search, ::prefs::kLanguageRemapSearchKeyTo,
                      ui::mojom::ModifierKey::kMeta,
                      ui::mojom::ModifierKey::kQuickInsert);

  for (const auto& keyboard : kChromeKeyboardVariants) {
    SCOPED_TRACE(keyboard.name);
    SetUpKeyboard(keyboard);

    EXPECT_EQ(KeyQuickInsert::Typed(ui::EF_NONE, {kPropertyQuickInsert}),
              RunRewriter(KeyLControl::Typed()));
    EXPECT_EQ(KeyQuickInsert::Typed(ui::EF_NONE, {kPropertyQuickInsert}),
              RunRewriter(KeyLMeta::Typed()));
  }
}

TEST_P(EventRewriterTest, FnAndQuickInsertKeyPressedMetrics) {
  if (!features::IsModifierSplitEnabled()) {
    GTEST_SKIP() << "Test is only valid with the modifier split flag enabled";
  }
  base::HistogramTester histogram_tester;
  scoped_feature_list_.InitAndEnableFeature(
      features::kInputDeviceSettingsSplit);
  SetUpKeyboard(kInternalChromeSplitModifierLayoutKeyboard);
  SendKeyEvent(KeyFunction::Pressed());
  histogram_tester.ExpectBucketCount(
      "ChromeOS.Inputs.Keyboard.ModifierPressed.Internal",
      ui::ModifierKeyUsageMetric::kFunction, 1);
  histogram_tester.ExpectBucketCount(
      "ChromeOS.Inputs.Keyboard.RemappedModifierPressed.Internal",
      ui::ModifierKeyUsageMetric::kFunction, 1);

  SendKeyEvent(KeyQuickInsert::Pressed());
  histogram_tester.ExpectBucketCount(
      "ChromeOS.Inputs.Keyboard.ModifierPressed.Internal",
      ui::ModifierKeyUsageMetric::kQuickInsert, 1);
  histogram_tester.ExpectBucketCount(
      "ChromeOS.Inputs.Keyboard.RemappedModifierPressed.Internal",
      ui::ModifierKeyUsageMetric::kQuickInsert, 1);

  // Remap QuickInsert to Assistant
  InitModifierKeyPref(nullptr, "", ui::mojom::ModifierKey::kQuickInsert,
                      ui::mojom::ModifierKey::kAssistant);

  RunRewriter(KeyQuickInsert::Typed());
  histogram_tester.ExpectBucketCount(
      "ChromeOS.Inputs.Keyboard.ModifierPressed.Internal",
      ui::ModifierKeyUsageMetric::kQuickInsert, 2);
  histogram_tester.ExpectBucketCount(
      "ChromeOS.Inputs.Keyboard.RemappedModifierPressed.Internal",
      ui::ModifierKeyUsageMetric::kQuickInsert, 1);
  histogram_tester.ExpectBucketCount(
      "ChromeOS.Inputs.Keyboard.RemappedModifierPressed.Internal",
      ui::ModifierKeyUsageMetric::kAssistant, 1);
  scoped_feature_list_.Reset();
}

TEST_P(EventRewriterTest, TestRewriteToFunction) {
  if (!features::IsModifierSplitEnabled()) {
    GTEST_SKIP() << "Test is only valid with the modifier split flag enabled";
  }

  SetUpKeyboard(kInternalChromeSplitModifierLayoutKeyboard);

  // Remap QuickInsert to Control
  Preferences::RegisterProfilePrefs(prefs()->registry());
  IntegerPrefMember control;
  InitModifierKeyPref(&control, ::prefs::kLanguageRemapControlKeyTo,
                      ui::mojom::ModifierKey::kControl,
                      ui::mojom::ModifierKey::kFunction);

  IntegerPrefMember search;
  InitModifierKeyPref(&search, ::prefs::kLanguageRemapSearchKeyTo,
                      ui::mojom::ModifierKey::kMeta,
                      ui::mojom::ModifierKey::kFunction);

  // Keys + rewritten modifiers produce rewritten six-pack keys.
  EXPECT_EQ(KeyPageUp::Typed(),
            RunRewriter(KeyArrowUp::Typed(), ui::EF_CONTROL_DOWN));
  EXPECT_EQ(KeyPageDown::Typed(),
            RunRewriter(KeyArrowDown::Typed(), ui::EF_COMMAND_DOWN));

  // After command + control are released, events are not affected.
  EXPECT_EQ(KeyA::Typed(), RunRewriter(KeyA::Typed()));
}

TEST_P(EventRewriterTest, TestRewriteFromFunction) {
  // Function is only available when InputDeviceSettingsSplit is enabled.
  scoped_feature_list_.InitAndEnableFeature(
      features::kInputDeviceSettingsSplit);

  // Remap Function to Control
  InitModifierKeyPref(nullptr, "", ui::mojom::ModifierKey::kFunction,
                      ui::mojom::ModifierKey::kControl);

  for (const auto& keyboard : kChromeKeyboardVariants) {
    SCOPED_TRACE(keyboard.name);
    SetUpKeyboard(keyboard);

    EXPECT_EQ(KeyLControl::Typed(), RunRewriter(KeyFunction::Typed()));

    // A + rewritten modifiers produce events with function flag down.
    EXPECT_EQ(KeyA::Typed(ui::EF_CONTROL_DOWN),
              RunRewriter(KeyA::Typed(), ui::EF_FUNCTION_DOWN));
    // After command + control are released, events are not affected.
    EXPECT_EQ(KeyA::Typed(), RunRewriter(KeyA::Typed()));
  }

  // Remap Function to CapsLock
  InitModifierKeyPref(nullptr, "", ui::mojom::ModifierKey::kFunction,
                      ui::mojom::ModifierKey::kCapsLock);

  for (const auto& keyboard : kChromeKeyboardVariants) {
    SCOPED_TRACE(keyboard.name);
    SetUpKeyboard(keyboard);

    // Toggle CapsLock on
    EXPECT_EQ(KeyCapsLock::Typed(ui::EF_CAPS_LOCK_ON),
              RunRewriter(KeyFunction::Typed(ui::EF_CAPS_LOCK_ON)));

    // Toggle CapsLock off
    EXPECT_EQ(KeyCapsLock::Typed(), RunRewriter(KeyFunction::Typed()));
  }

  // Remap Function to Void
  InitModifierKeyPref(nullptr, "", ui::mojom::ModifierKey::kFunction,
                      ui::mojom::ModifierKey::kVoid);

  for (const auto& keyboard : kChromeKeyboardVariants) {
    SCOPED_TRACE(keyboard.name);
    SetUpKeyboard(keyboard);

    EXPECT_EQ(KeyUnknown::Typed(), RunRewriter(KeyFunction::Typed()));
  }

  scoped_feature_list_.Reset();
}

TEST_P(EventRewriterTest, TestRewriteFromQuickInsert) {
  if (!features::IsModifierSplitEnabled()) {
    GTEST_SKIP() << "Test is only valid with the modifier split flag enabled";
  }

  // QuickInsert is only available when InputDeviceSettingsSplit is enabled.
  scoped_feature_list_.InitAndEnableFeature(
      features::kInputDeviceSettingsSplit);
  SetUpKeyboard(kInternalChromeSplitModifierLayoutKeyboard);

  // Test that identity is working as expected.
  EXPECT_EQ(KeyQuickInsert::Typed(ui::EF_NONE, {kPropertyQuickInsert}),
            RunRewriter(KeyLaunchAssistant::Typed()));

  // Remap QuickInsert to Control
  InitModifierKeyPref(nullptr, "", ui::mojom::ModifierKey::kQuickInsert,
                      ui::mojom::ModifierKey::kControl);

  EXPECT_EQ(KeyLControl::Typed(), RunRewriter(KeyQuickInsert::Typed()));

  // Test QuickInsert remapped to Control properly applies the flag to other
  // events.
  EXPECT_EQ(
      (std::vector<TestKeyEvent>{KeyLControl::Pressed()}),
      (RunRewriter(std::vector<TestKeyEvent>{KeyQuickInsert::Pressed()})));
  EXPECT_EQ(KeyA::Typed(ui::EF_CONTROL_DOWN), RunRewriter(KeyA::Typed()));
  EXPECT_EQ(
      (std::vector<TestKeyEvent>{KeyLControl::Released()}),
      (RunRewriter(std::vector<TestKeyEvent>{KeyQuickInsert::Released()})));

  // Remap QuickInsert to CapsLock
  InitModifierKeyPref(nullptr, "", ui::mojom::ModifierKey::kQuickInsert,
                      ui::mojom::ModifierKey::kCapsLock);
  // Toggle CapsLock on/off
  EXPECT_EQ(KeyCapsLock::Typed(ui::EF_CAPS_LOCK_ON),
            RunRewriter(KeyQuickInsert::Typed(ui::EF_CAPS_LOCK_ON)));
  EXPECT_EQ(KeyCapsLock::Typed(), RunRewriter(KeyQuickInsert::Typed()));

  // Remap QuickInsert to Void
  InitModifierKeyPref(nullptr, "", ui::mojom::ModifierKey::kQuickInsert,
                      ui::mojom::ModifierKey::kVoid);
  EXPECT_EQ(KeyUnknown::Typed(), RunRewriter(KeyQuickInsert::Typed()));

  scoped_feature_list_.Reset();
}

TEST_P(EventRewriterTest, TestRewriteExtendedKeysAltVariants) {
  Preferences::RegisterProfilePrefs(prefs()->registry());
  base::test::ScopedFeatureList scoped_feature_list;
  scoped_feature_list.InitAndDisableFeature(
      features::kAltClickAndSixPackCustomization);
  // All the previously supported Alt based rewrites no longer have any
  // effect. The Search workarounds no longer take effect and the Search+Key
  // portion is rewritten as expected.
  for (const auto keyboard : kNonAppleKeyboardVariants) {
    SCOPED_TRACE(keyboard.name);
    SetUpKeyboard(keyboard);

    // Alt+Backspace -> No Rewrite
    EXPECT_EQ(KeyBackspace::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyBackspace::Typed(), ui::EF_ALT_DOWN));
    EXPECT_EQ(1u, message_center_.NotificationCount());
    ClearNotifications();

    // Control+Alt+Backspace -> No Rewrite
    EXPECT_EQ(KeyBackspace::Typed(ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN),
              RunRewriter(KeyBackspace::Typed(),
                          ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN));
    EXPECT_EQ(1u, message_center_.NotificationCount());
    ClearNotifications();

    // Search+Alt+Backspace -> Alt+Delete
    EXPECT_EQ(KeyDelete::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyBackspace::Typed(),
                          ui::EF_COMMAND_DOWN | ui::EF_ALT_DOWN));

    // Search+Control+Alt+Backspace -> Control+Alt+Delete
    EXPECT_EQ(KeyDelete::Typed(ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN),
              RunRewriter(KeyBackspace::Typed(), ui::EF_COMMAND_DOWN |
                                                     ui::EF_CONTROL_DOWN |
                                                     ui::EF_ALT_DOWN));

    // Alt+Up -> No Rewrite
    EXPECT_EQ(KeyArrowUp::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyArrowUp::Typed(), ui::EF_ALT_DOWN));
    EXPECT_EQ(1u, message_center_.NotificationCount());
    ClearNotifications();

    // Alt+Down -> No Rewrite
    EXPECT_EQ(KeyArrowDown::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyArrowDown::Typed(), ui::EF_ALT_DOWN));
    EXPECT_EQ(1u, message_center_.NotificationCount());
    ClearNotifications();

    // Ctrl+Alt+Up -> No Rewrite
    EXPECT_EQ(KeyArrowUp::Typed(ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN),
              RunRewriter(KeyArrowUp::Typed(),
                          ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN));
    EXPECT_EQ(1u, message_center_.NotificationCount());
    ClearNotifications();

    // Ctrl+Alt+Down -> No Rewrite
    EXPECT_EQ(KeyArrowDown::Typed(ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN),
              RunRewriter(KeyArrowDown::Typed(),
                          ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN));
    EXPECT_EQ(1u, message_center_.NotificationCount());
    ClearNotifications();

    // NOTE: The following were workarounds to avoid rewriting the
    // Alt variants by additionally pressing Search.

    // Search+Ctrl+Alt+Up -> Ctrl+Alt+PageUp(aka Prior)
    EXPECT_EQ(KeyPageUp::Typed(ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN),
              RunRewriter(KeyArrowUp::Typed(), ui::EF_COMMAND_DOWN |
                                                   ui::EF_CONTROL_DOWN |
                                                   ui::EF_ALT_DOWN));
    // Search+Ctrl+Alt+Down -> Ctrl+Alt+PageDown(aka Next)
    EXPECT_EQ(KeyPageDown::Typed(ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN),
              RunRewriter(KeyArrowDown::Typed(), ui::EF_COMMAND_DOWN |
                                                     ui::EF_CONTROL_DOWN |
                                                     ui::EF_ALT_DOWN));
  }
}

TEST_P(EventRewriterTest, TestRewriteExtendedKeyInsertDeprecatedNotification) {
  Preferences::RegisterProfilePrefs(prefs()->registry());
  base::test::ScopedFeatureList scoped_feature_list;
  scoped_feature_list.InitWithFeatures(
      {}, {features::kAltClickAndSixPackCustomization});

  for (const auto keyboard : kNonAppleKeyboardVariants) {
    SCOPED_TRACE(keyboard.name);
    SetUpKeyboard(keyboard);

    // Period -> Period
    EXPECT_EQ(KeyPeriod::Typed(), RunRewriter(KeyPeriod::Typed()));

    // Search+Period -> No rewrite (and shows notification)
    EXPECT_EQ(KeyPeriod::Typed(ui::EF_COMMAND_DOWN),
              RunRewriter(KeyPeriod::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(1u, message_center_.NotificationCount());
    ClearNotifications();

    // Control+Search+Period -> No rewrite (and shows notification)
    EXPECT_EQ(KeyPeriod::Typed(ui::EF_COMMAND_DOWN | ui::EF_CONTROL_DOWN),
              RunRewriter(KeyPeriod::Typed(),
                          ui::EF_COMMAND_DOWN | ui::EF_CONTROL_DOWN));
    EXPECT_EQ(1u, message_center_.NotificationCount());
    ClearNotifications();
  }
}

TEST_P(EventRewriterTest, TestRewriteExtendedKeyInsert) {
  Preferences::RegisterProfilePrefs(prefs()->registry());
  base::test::ScopedFeatureList scoped_feature_list;
  scoped_feature_list.InitWithFeatures(
      {}, {features::kAltClickAndSixPackCustomization});

  for (const auto keyboard : kNonAppleKeyboardVariants) {
    SCOPED_TRACE(keyboard.name);
    SetUpKeyboard(keyboard);

    // Search+Shift+Backspace -> Insert
    EXPECT_EQ(KeyInsert::Typed(),
              RunRewriter(KeyBackspace::Typed(),
                          ui::EF_COMMAND_DOWN | ui::EF_SHIFT_DOWN));

    // Control+Search+Shift+Backspace -> Control+Insert
    EXPECT_EQ(KeyInsert::Typed(ui::EF_CONTROL_DOWN),
              RunRewriter(KeyBackspace::Typed(), ui::EF_COMMAND_DOWN |
                                                     ui::EF_CONTROL_DOWN |
                                                     ui::EF_SHIFT_DOWN));
  }
}

TEST_P(EventRewriterTest, TestRewriteExtendedKeysSearchVariants) {
  base::test::ScopedFeatureList scoped_feature_list;
  scoped_feature_list.InitAndDisableFeature(
      features::kAltClickAndSixPackCustomization);
  Preferences::RegisterProfilePrefs(prefs()->registry());

  for (const auto keyboard : kNonAppleKeyboardVariants) {
    SCOPED_TRACE(keyboard.name);
    SetUpKeyboard(keyboard);

    // Search+Backspace -> Delete
    EXPECT_EQ(KeyDelete::Typed(),
              RunRewriter(KeyBackspace::Typed(), ui::EF_COMMAND_DOWN));

    // Search+Up -> Prior
    EXPECT_EQ(KeyPageUp::Typed(),
              RunRewriter(KeyArrowUp::Typed(), ui::EF_COMMAND_DOWN));

    // Search+Down -> Next
    EXPECT_EQ(KeyPageDown::Typed(),
              RunRewriter(KeyArrowDown::Typed(), ui::EF_COMMAND_DOWN));

    // Search+Left -> Home
    EXPECT_EQ(KeyHome::Typed(),
              RunRewriter(KeyArrowLeft::Typed(), ui::EF_COMMAND_DOWN));

    // Control+Search+Left -> Control+Home
    EXPECT_EQ(KeyHome::Typed(ui::EF_CONTROL_DOWN),
              RunRewriter(KeyArrowLeft::Typed(),
                          ui::EF_COMMAND_DOWN | ui::EF_CONTROL_DOWN));

    // Search+Right -> End
    EXPECT_EQ(KeyEnd::Typed(),
              RunRewriter(KeyArrowRight::Typed(), ui::EF_COMMAND_DOWN));

    // Control+Search+Right -> Control+End
    EXPECT_EQ(KeyEnd::Typed(ui::EF_CONTROL_DOWN),
              RunRewriter(KeyArrowRight::Typed(),
                          ui::EF_COMMAND_DOWN | ui::EF_CONTROL_DOWN));
  }
}

TEST_P(EventRewriterTest, TestNumberRowIsNotRewritten) {
  Preferences::RegisterProfilePrefs(prefs()->registry());
  base::test::ScopedFeatureList scoped_feature_list;
  scoped_feature_list.InitAndDisableFeature(
      features::kAltClickAndSixPackCustomization);
  for (const auto& keyboard : kNonAppleNonCustomLayoutKeyboardVariants) {
    SCOPED_TRACE(keyboard.name);
    SetUpKeyboard(keyboard);

    // The number row should not be rewritten without Search key.
    EXPECT_EQ(KeyDigit1::Typed(), RunRewriter(KeyDigit1::Typed()));
    EXPECT_EQ(KeyDigit2::Typed(), RunRewriter(KeyDigit2::Typed()));
    EXPECT_EQ(KeyDigit3::Typed(), RunRewriter(KeyDigit3::Typed()));
    EXPECT_EQ(KeyDigit4::Typed(), RunRewriter(KeyDigit4::Typed()));
    EXPECT_EQ(KeyDigit5::Typed(), RunRewriter(KeyDigit5::Typed()));
    EXPECT_EQ(KeyDigit6::Typed(), RunRewriter(KeyDigit6::Typed()));
    EXPECT_EQ(KeyDigit7::Typed(), RunRewriter(KeyDigit7::Typed()));
    EXPECT_EQ(KeyDigit8::Typed(), RunRewriter(KeyDigit8::Typed()));
    EXPECT_EQ(KeyDigit9::Typed(), RunRewriter(KeyDigit9::Typed()));
    EXPECT_EQ(KeyDigit0::Typed(), RunRewriter(KeyDigit0::Typed()));
    EXPECT_EQ(KeyMinus::Typed(), RunRewriter(KeyMinus::Typed()));
    EXPECT_EQ(KeyEqual::Typed(), RunRewriter(KeyEqual::Typed()));
  }
}

TEST_P(EventRewriterTest, TestRewriteSearchNumberToFunctionKey) {
  TestShortcutMappingPrefDelegate delegate;
  CHECK(!::features::IsImprovedKeyboardShortcutsEnabled());
  ASSERT_FALSE(::features::IsImprovedKeyboardShortcutsEnabled());
  Preferences::RegisterProfilePrefs(prefs()->registry());

  for (const auto& keyboard : kNonAppleNonCustomLayoutKeyboardVariants) {
    SCOPED_TRACE(keyboard.name);
    SetUpKeyboard(keyboard);

    // The number row should be rewritten as the F<number> row with Search
    // key.
    EXPECT_EQ(KeyF1::Typed(),
              RunRewriter(KeyDigit1::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyF2::Typed(),
              RunRewriter(KeyDigit2::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyF3::Typed(),
              RunRewriter(KeyDigit3::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyF4::Typed(),
              RunRewriter(KeyDigit4::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyF5::Typed(),
              RunRewriter(KeyDigit5::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyF6::Typed(),
              RunRewriter(KeyDigit6::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyF7::Typed(),
              RunRewriter(KeyDigit7::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyF8::Typed(),
              RunRewriter(KeyDigit8::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyF9::Typed(),
              RunRewriter(KeyDigit9::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyF10::Typed(),
              RunRewriter(KeyDigit0::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyF11::Typed(),
              RunRewriter(KeyMinus::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyF12::Typed(),
              RunRewriter(KeyEqual::Typed(), ui::EF_COMMAND_DOWN));
  }
}

TEST_P(EventRewriterTest, TestRewriteSearchNumberToFunctionKeyNoAction) {
  Preferences::RegisterProfilePrefs(prefs()->registry());

  for (const auto& keyboard : kNonAppleNonCustomLayoutKeyboardVariants) {
    SCOPED_TRACE(keyboard.name);
    SetUpKeyboard(keyboard);

    // Search+Number should now have no effect but a notification will
    // be shown the first time F1 to F10 is pressed.
    EXPECT_EQ(KeyDigit1::Typed(ui::EF_COMMAND_DOWN),
              RunRewriter(KeyDigit1::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyDigit2::Typed(ui::EF_COMMAND_DOWN),
              RunRewriter(KeyDigit2::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyDigit3::Typed(ui::EF_COMMAND_DOWN),
              RunRewriter(KeyDigit3::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyDigit4::Typed(ui::EF_COMMAND_DOWN),
              RunRewriter(KeyDigit4::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyDigit5::Typed(ui::EF_COMMAND_DOWN),
              RunRewriter(KeyDigit5::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyDigit6::Typed(ui::EF_COMMAND_DOWN),
              RunRewriter(KeyDigit6::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyDigit7::Typed(ui::EF_COMMAND_DOWN),
              RunRewriter(KeyDigit7::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyDigit8::Typed(ui::EF_COMMAND_DOWN),
              RunRewriter(KeyDigit8::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyDigit9::Typed(ui::EF_COMMAND_DOWN),
              RunRewriter(KeyDigit9::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyDigit0::Typed(ui::EF_COMMAND_DOWN),
              RunRewriter(KeyDigit0::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyMinus::Typed(ui::EF_COMMAND_DOWN),
              RunRewriter(KeyMinus::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyEqual::Typed(ui::EF_COMMAND_DOWN),
              RunRewriter(KeyEqual::Typed(), ui::EF_COMMAND_DOWN));
  }
}

TEST_P(EventRewriterTest, TestFunctionKeysNotRewrittenBySearch) {
  Preferences::RegisterProfilePrefs(prefs()->registry());

  for (const auto& keyboard : kNonAppleNonCustomLayoutKeyboardVariants) {
    SCOPED_TRACE(keyboard.name);
    SetUpKeyboard(keyboard);

    // The function keys should not be rewritten with Search key pressed.
    EXPECT_EQ(KeyF1::Typed(), RunRewriter(KeyF1::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyF2::Typed(), RunRewriter(KeyF2::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyF3::Typed(), RunRewriter(KeyF3::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyF4::Typed(), RunRewriter(KeyF4::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyF5::Typed(), RunRewriter(KeyF5::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyF6::Typed(), RunRewriter(KeyF6::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyF7::Typed(), RunRewriter(KeyF7::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyF8::Typed(), RunRewriter(KeyF8::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyF9::Typed(), RunRewriter(KeyF9::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyF10::Typed(),
              RunRewriter(KeyF10::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyF11::Typed(),
              RunRewriter(KeyF11::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyF12::Typed(),
              RunRewriter(KeyF12::Typed(), ui::EF_COMMAND_DOWN));
  }
}

TEST_P(EventRewriterTest, TestRewriteFunctionKeysNonCustomLayouts) {
  Preferences::RegisterProfilePrefs(prefs()->registry());

  // Old CrOS keyboards that do not have custom layouts send F-Keys by default
  // and are translated by default to Actions based on hardcoded mappings.
  // New CrOS keyboards are not tested here because they do not remap F-Keys.
  for (const auto& keyboard : kNonAppleNonCustomLayoutKeyboardVariants) {
    SCOPED_TRACE(keyboard.name);
    SetUpKeyboard(keyboard);

    // F1 -> Back
    EXPECT_EQ(KeyBrowserBack::Typed(), RunRewriter(KeyF1::Typed()));
    EXPECT_EQ(KeyBrowserBack::Typed(ui::EF_CONTROL_DOWN),
              RunRewriter(KeyF1::Typed(), ui::EF_CONTROL_DOWN));
    EXPECT_EQ(KeyBrowserBack::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyF1::Typed(), ui::EF_ALT_DOWN));

    // F2 -> Forward
    EXPECT_EQ(KeyBrowserForward::Typed(), RunRewriter(KeyF2::Typed()));
    EXPECT_EQ(KeyBrowserForward::Typed(ui::EF_CONTROL_DOWN),
              RunRewriter(KeyF2::Typed(), ui::EF_CONTROL_DOWN));
    EXPECT_EQ(KeyBrowserForward::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyF2::Typed(), ui::EF_ALT_DOWN));

    // F3 -> Refresh
    EXPECT_EQ(KeyBrowserRefresh::Typed(), RunRewriter(KeyF3::Typed()));
    EXPECT_EQ(KeyBrowserRefresh::Typed(ui::EF_CONTROL_DOWN),
              RunRewriter(KeyF3::Typed(), ui::EF_CONTROL_DOWN));
    EXPECT_EQ(KeyBrowserRefresh::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyF3::Typed(), ui::EF_ALT_DOWN));

    // F4 -> Zoom (aka Fullscreen)
    EXPECT_EQ(KeyZoomToggle::Typed(), RunRewriter(KeyF4::Typed()));
    EXPECT_EQ(KeyZoomToggle::Typed(ui::EF_CONTROL_DOWN),
              RunRewriter(KeyF4::Typed(), ui::EF_CONTROL_DOWN));
    EXPECT_EQ(KeyZoomToggle::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyF4::Typed(), ui::EF_ALT_DOWN));

    // F5 -> Launch App 1
    EXPECT_EQ(KeySelectTask::Typed(), RunRewriter(KeyF5::Typed()));
    EXPECT_EQ(KeySelectTask::Typed(ui::EF_CONTROL_DOWN),
              RunRewriter(KeyF5::Typed(), ui::EF_CONTROL_DOWN));
    EXPECT_EQ(KeySelectTask::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyF5::Typed(), ui::EF_ALT_DOWN));

    // F6 -> Brightness down
    EXPECT_EQ(KeyBrightnessDown::Typed(), RunRewriter(KeyF6::Typed()));
    EXPECT_EQ(KeyBrightnessDown::Typed(ui::EF_CONTROL_DOWN),
              RunRewriter(KeyF6::Typed(), ui::EF_CONTROL_DOWN));
    EXPECT_EQ(KeyBrightnessDown::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyF6::Typed(), ui::EF_ALT_DOWN));

    // F7 -> Brightness up
    EXPECT_EQ(KeyBrightnessUp::Typed(), RunRewriter(KeyF7::Typed()));
    EXPECT_EQ(KeyBrightnessUp::Typed(ui::EF_CONTROL_DOWN),
              RunRewriter(KeyF7::Typed(), ui::EF_CONTROL_DOWN));
    EXPECT_EQ(KeyBrightnessUp::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyF7::Typed(), ui::EF_ALT_DOWN));

    // F8 -> Volume Mute
    EXPECT_EQ(KeyVolumeMute::Typed(), RunRewriter(KeyF8::Typed()));
    EXPECT_EQ(KeyVolumeMute::Typed(ui::EF_CONTROL_DOWN),
              RunRewriter(KeyF8::Typed(), ui::EF_CONTROL_DOWN));
    EXPECT_EQ(KeyVolumeMute::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyF8::Typed(), ui::EF_ALT_DOWN));

    // F9 -> Volume Down
    EXPECT_EQ(KeyVolumeDown::Typed(), RunRewriter(KeyF9::Typed()));
    EXPECT_EQ(KeyVolumeDown::Typed(ui::EF_CONTROL_DOWN),
              RunRewriter(KeyF9::Typed(), ui::EF_CONTROL_DOWN));
    EXPECT_EQ(KeyVolumeDown::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyF9::Typed(), ui::EF_ALT_DOWN));

    // F10 -> Volume Up
    EXPECT_EQ(KeyVolumeUp::Typed(), RunRewriter(KeyF10::Typed()));
    EXPECT_EQ(KeyVolumeUp::Typed(ui::EF_CONTROL_DOWN),
              RunRewriter(KeyF10::Typed(), ui::EF_CONTROL_DOWN));
    EXPECT_EQ(KeyVolumeUp::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyF10::Typed(), ui::EF_ALT_DOWN));

    // F11 -> F11
    EXPECT_EQ(KeyF11::Typed(), RunRewriter(KeyF11::Typed()));
    EXPECT_EQ(KeyF11::Typed(ui::EF_CONTROL_DOWN),
              RunRewriter(KeyF11::Typed(), ui::EF_CONTROL_DOWN));
    EXPECT_EQ(KeyF11::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyF11::Typed(), ui::EF_ALT_DOWN));

    // F12 -> F12
    EXPECT_EQ(KeyF12::Typed(), RunRewriter(KeyF12::Typed()));
    EXPECT_EQ(KeyF12::Typed(ui::EF_CONTROL_DOWN),
              RunRewriter(KeyF12::Typed(), ui::EF_CONTROL_DOWN));
    EXPECT_EQ(KeyF12::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyF12::Typed(), ui::EF_ALT_DOWN));
  }
}

TEST_P(EventRewriterTest, TestRewriteFunctionKeysCustomLayoutsFKeyUnchanged) {
  Preferences::RegisterProfilePrefs(prefs()->registry());
  // On devices with custom layouts, the F-Keys are never remapped.
  for (const auto& keyboard : kChromeCustomKeyboardVariants) {
    SCOPED_TRACE(keyboard.name);
    SetUpKeyboard(keyboard);

    for (const auto typed :
         {KeyF1::Typed, KeyF2::Typed, KeyF3::Typed, KeyF4::Typed, KeyF5::Typed,
          KeyF6::Typed, KeyF7::Typed, KeyF8::Typed, KeyF9::Typed, KeyF10::Typed,
          KeyF11::Typed, KeyF12::Typed, KeyF13::Typed, KeyF14::Typed,
          KeyF15::Typed}) {
      EXPECT_EQ(typed(ui::EF_NONE, {}), RunRewriter(typed(ui::EF_NONE, {})));
      EXPECT_EQ(typed(ui::EF_CONTROL_DOWN, {}),
                RunRewriter(typed(ui::EF_NONE, {}), ui::EF_CONTROL_DOWN));
      EXPECT_EQ(typed(ui::EF_ALT_DOWN, {}),
                RunRewriter(typed(ui::EF_NONE, {}), ui::EF_ALT_DOWN));
      EXPECT_EQ(typed(ui::EF_COMMAND_DOWN, {}),
                RunRewriter(typed(ui::EF_NONE, {}), ui::EF_COMMAND_DOWN));
    }
  }
}

TEST_P(EventRewriterTest, TestRewriteFunctionKeysCustomLayoutsActionUnchanged) {
  Preferences::RegisterProfilePrefs(prefs()->registry());

  // An action key on these devices is one where the scan code matches an entry
  // in the layout map. It doesn't matter what the action is, as long the
  // search key isn't pressed it will pass through unchanged.
  SetUpKeyboard({.name = "Internal Custom LayoutKeyboard",
                 .layout = "a1 a2 a3",
                 .type = ui::INPUT_DEVICE_INTERNAL,
                 .has_custom_top_row = true});
  auto browser_refresh = KeyBrowserRefresh::Pressed();
  browser_refresh.scan_code = 0xa1;
  EXPECT_EQ(std::vector({browser_refresh}), SendKeyEvent(browser_refresh));

  auto volume_up = KeyVolumeUp::Pressed();
  volume_up.scan_code = 0xa2;
  EXPECT_EQ(std::vector({volume_up}), SendKeyEvent(volume_up));

  auto volume_down = KeyVolumeDown::Pressed();
  volume_down.scan_code = 0xa3;
  EXPECT_EQ(std::vector({volume_down}), SendKeyEvent(volume_down));
}

TEST_P(EventRewriterTest,
       TestRewriteFunctionKeysCustomLayoutsActionSuppressedUnchanged) {
  // For EF_COMMAND_DOWN modifier.
  SendKeyEvent(KeyLMeta::Pressed());

  Preferences::RegisterProfilePrefs(prefs()->registry());
  delegate_->SuppressMetaTopRowKeyComboRewrites(true);
  keyboard_settings->suppress_meta_fkey_rewrites = true;

  // An action key on these devices is one where the scan code matches an entry
  // in the layout map. With Meta + Top Row Key rewrites being suppressed, the
  // input should be equivalent to the output for all tested keys.
  SetUpKeyboard({.name = "Internal Custom Layout Keyboard",
                 .layout = "a1 a2 a3",
                 .type = ui::INPUT_DEVICE_INTERNAL,
                 .has_custom_top_row = true});

  auto browser_refresh = KeyBrowserRefresh::Pressed(ui::EF_COMMAND_DOWN);
  browser_refresh.scan_code = 0xa1;
  EXPECT_EQ(std::vector({browser_refresh}), SendKeyEvent(browser_refresh));

  auto volume_up = KeyVolumeUp::Pressed(ui::EF_COMMAND_DOWN);
  volume_up.scan_code = 0xa2;
  EXPECT_EQ(std::vector({volume_up}), SendKeyEvent(volume_up));

  auto volume_down = KeyVolumeDown::Pressed(ui::EF_COMMAND_DOWN);
  volume_down.scan_code = 0xa3;
  EXPECT_EQ(std::vector({volume_down}), SendKeyEvent(volume_down));
}

TEST_P(EventRewriterTest,
       TestRewriteFunctionKeysCustomLayoutsActionSuppressedWithTopRowAreFKeys) {
  // For EF_COMMAND_DOWN.
  SendKeyEvent(KeyLMeta::Pressed());

  Preferences::RegisterProfilePrefs(prefs()->registry());
  delegate_->SuppressMetaTopRowKeyComboRewrites(true);
  keyboard_settings->suppress_meta_fkey_rewrites = true;

  BooleanPrefMember send_function_keys_pref;
  send_function_keys_pref.Init(prefs::kSendFunctionKeys, prefs());
  send_function_keys_pref.SetValue(true);
  keyboard_settings->top_row_are_fkeys = true;

  // An action key on these devices is one where the scan code matches an entry
  // in the layout map. With Meta + Top Row Key rewrites being suppressed, the
  // input should be remapped to F-Keys and the Search modifier should not be
  // removed.
  SetUpKeyboard({.name = "Internal Custom Layout Keyboard",
                 .layout = "a1 a2 a3",
                 .type = ui::INPUT_DEVICE_INTERNAL,
                 .has_custom_top_row = true});

  auto browser_refresh = KeyBrowserRefresh::Pressed(ui::EF_COMMAND_DOWN);
  browser_refresh.scan_code = 0xa1;
  auto f1 = KeyF1::Pressed(ui::EF_COMMAND_DOWN);
  f1.scan_code = 0xa1;
  EXPECT_EQ(std::vector({f1}), SendKeyEvent(browser_refresh));

  auto volume_up = KeyVolumeUp::Pressed(ui::EF_COMMAND_DOWN);
  volume_up.scan_code = 0xa2;
  auto f2 = KeyF2::Pressed(ui::EF_COMMAND_DOWN);
  f2.scan_code = 0xa2;
  EXPECT_EQ(std::vector({f2}), SendKeyEvent(volume_up));

  auto volume_down = KeyVolumeDown::Pressed(ui::EF_COMMAND_DOWN);
  volume_down.scan_code = 0xa3;
  auto f3 = KeyF3::Pressed(ui::EF_COMMAND_DOWN);
  f3.scan_code = 0xa3;
  EXPECT_EQ(std::vector({f3}), SendKeyEvent(volume_down));
}

TEST_P(EventRewriterTest, TestRewriteFunctionKeysCustomLayouts) {
  Preferences::RegisterProfilePrefs(prefs()->registry());

  // On devices with custom layouts, scan codes that match the layout
  // map get mapped to F-Keys based only on the scan code. The search
  // key also gets treated as unpressed in the remapped event.
  SetUpKeyboard({.name = "Internal Custom Layout Keyboard",
                 .layout = "a1 a2 a3 a4 a5 a6 a7 a8 a9 aa ab ac ad ae af",
                 .type = ui::INPUT_DEVICE_INTERNAL,
                 .has_custom_top_row = true});

  struct TestCase {
    std::vector<TestKeyEvent> (*pressed)(
        ui::EventFlags,
        std::vector<std::pair<std::string, std::vector<uint8_t>>>);
    uint32_t scan_code;
  };
  // Action -> F1..F15
  for (const auto& [typed, scan_code] :
       std::initializer_list<TestCase>{{KeyF1::Typed, 0xa1},
                                       {KeyF2::Typed, 0xa2},
                                       {KeyF3::Typed, 0xa3},
                                       {KeyF4::Typed, 0xa4},
                                       {KeyF5::Typed, 0xa5},
                                       {KeyF6::Typed, 0xa6},
                                       {KeyF7::Typed, 0xa7},
                                       {KeyF8::Typed, 0xa8},
                                       {KeyF9::Typed, 0xa9},
                                       {KeyF10::Typed, 0xaa},
                                       {KeyF11::Typed, 0xab},
                                       {KeyF12::Typed, 0xac},
                                       {KeyF13::Typed, 0xad},
                                       {KeyF14::Typed, 0xae},
                                       {KeyF15::Typed, 0xaf}}) {
    auto unknowns = KeyUnknown::Typed();
    for (auto& unknown : unknowns) {
      unknown.scan_code = scan_code;
    }
    auto expected_events = typed(ui::EF_NONE, {});
    for (auto& event : expected_events) {
      event.scan_code = scan_code;
    }
    EXPECT_EQ(expected_events, RunRewriter(unknowns, ui::EF_COMMAND_DOWN));

    if (features::IsModifierSplitEnabled()) {
      // With fn down, nothing should change since this keyboard uses Search
      // based rewriting.
      EXPECT_EQ(unknowns, RunRewriter(unknowns, ui::EF_FUNCTION_DOWN));
    }
  }
}

TEST_P(EventRewriterTest, TestRewriteFunctionKeysCustomLayoutsWithFunction) {
  if (!features::IsModifierSplitEnabled()) {
    GTEST_SKIP() << "Test is only valid with the modifier split flag enabled";
  }

  // On devices with custom layouts, scan codes that match the layout
  // map get mapped to F-Keys based only on the scan code. The search
  // key also gets treated as unpressed in the remapped event.
  SetUpKeyboard({.name = "Internal Custom Layout Keyboard",
                 .layout = "a1 a2 a3 a4 a5 a6 a7 a8 a9 aa ab ac ad ae af",
                 .type = ui::INPUT_DEVICE_INTERNAL,
                 .has_custom_top_row = true,
                 .has_assistant_key = true,
                 .has_function_key = true});

  struct TestCase {
    std::vector<TestKeyEvent> (*pressed)(
        ui::EventFlags,
        std::vector<std::pair<std::string, std::vector<uint8_t>>>);
    uint32_t scan_code;
  };
  // Action -> F1..F15
  for (const auto& [typed, scan_code] :
       std::initializer_list<TestCase>{{KeyF1::Typed, 0xa1},
                                       {KeyF2::Typed, 0xa2},
                                       {KeyF3::Typed, 0xa3},
                                       {KeyF4::Typed, 0xa4},
                                       {KeyF5::Typed, 0xa5},
                                       {KeyF6::Typed, 0xa6},
                                       {KeyF7::Typed, 0xa7},
                                       {KeyF8::Typed, 0xa8},
                                       {KeyF9::Typed, 0xa9},
                                       {KeyF10::Typed, 0xaa},
                                       {KeyF11::Typed, 0xab},
                                       {KeyF12::Typed, 0xac},
                                       {KeyF13::Typed, 0xad},
                                       {KeyF14::Typed, 0xae},
                                       {KeyF15::Typed, 0xaf}}) {
    auto unknowns = KeyUnknown::Typed();
    for (auto& unknown : unknowns) {
      unknown.scan_code = scan_code;
    }
    auto unknowns_with_search = KeyUnknown::Typed(ui::EF_COMMAND_DOWN);
    for (auto& unknown : unknowns_with_search) {
      unknown.scan_code = scan_code;
    }
    auto expected_events = typed(ui::EF_NONE, {});
    for (auto& event : expected_events) {
      event.scan_code = scan_code;
    }
    // Do not rewrite when search key is down since the keyboard should use the
    // fn key.
    EXPECT_EQ(unknowns_with_search, RunRewriter(unknowns, ui::EF_COMMAND_DOWN));

    // Rewrite correctly with the fn key down.
    EXPECT_EQ(expected_events, RunRewriter(unknowns, ui::EF_FUNCTION_DOWN));
  }
  scoped_feature_list_.Reset();
}

TEST_P(EventRewriterTest, TestRewriteFunctionKeysLayout2) {
  Preferences::RegisterProfilePrefs(prefs()->registry());
  SetUpKeyboard({.name = "Internal Keyboard",
                 .layout = kKbdTopRowLayout2Tag,
                 .type = ui::INPUT_DEVICE_INTERNAL,
                 .has_custom_top_row = false});

  // F1 -> Back
  EXPECT_EQ(KeyBrowserBack::Typed(), RunRewriter(KeyF1::Typed()));
  EXPECT_EQ(KeyBrowserBack::Typed(ui::EF_CONTROL_DOWN),
            RunRewriter(KeyF1::Typed(), ui::EF_CONTROL_DOWN));
  EXPECT_EQ(KeyBrowserBack::Typed(ui::EF_ALT_DOWN),
            RunRewriter(KeyF1::Typed(), ui::EF_ALT_DOWN));

  // F2 -> Refresh
  EXPECT_EQ(KeyBrowserRefresh::Typed(), RunRewriter(KeyF2::Typed()));
  EXPECT_EQ(KeyBrowserRefresh::Typed(ui::EF_CONTROL_DOWN),
            RunRewriter(KeyF2::Typed(), ui::EF_CONTROL_DOWN));
  EXPECT_EQ(KeyBrowserRefresh::Typed(ui::EF_ALT_DOWN),
            RunRewriter(KeyF2::Typed(), ui::EF_ALT_DOWN));

  // F3 -> Zoom (aka Fullscreen)
  EXPECT_EQ(KeyZoomToggle::Typed(), RunRewriter(KeyF3::Typed()));
  EXPECT_EQ(KeyZoomToggle::Typed(ui::EF_CONTROL_DOWN),
            RunRewriter(KeyF3::Typed(), ui::EF_CONTROL_DOWN));
  EXPECT_EQ(KeyZoomToggle::Typed(ui::EF_ALT_DOWN),
            RunRewriter(KeyF3::Typed(), ui::EF_ALT_DOWN));

  // F4 -> Launch App 1
  EXPECT_EQ(KeySelectTask::Typed(), RunRewriter(KeyF4::Typed()));
  EXPECT_EQ(KeySelectTask::Typed(ui::EF_CONTROL_DOWN),
            RunRewriter(KeyF4::Typed(), ui::EF_CONTROL_DOWN));
  EXPECT_EQ(KeySelectTask::Typed(ui::EF_ALT_DOWN),
            RunRewriter(KeyF4::Typed(), ui::EF_ALT_DOWN));

  // F5 -> Brightness down
  EXPECT_EQ(KeyBrightnessDown::Typed(), RunRewriter(KeyF5::Typed()));
  EXPECT_EQ(KeyBrightnessDown::Typed(ui::EF_CONTROL_DOWN),
            RunRewriter(KeyF5::Typed(), ui::EF_CONTROL_DOWN));
  EXPECT_EQ(KeyBrightnessDown::Typed(ui::EF_ALT_DOWN),
            RunRewriter(KeyF5::Typed(), ui::EF_ALT_DOWN));

  // F6 -> Brightness up
  EXPECT_EQ(KeyBrightnessUp::Typed(), RunRewriter(KeyF6::Typed()));
  EXPECT_EQ(KeyBrightnessUp::Typed(ui::EF_CONTROL_DOWN),
            RunRewriter(KeyF6::Typed(), ui::EF_CONTROL_DOWN));
  EXPECT_EQ(KeyBrightnessUp::Typed(ui::EF_ALT_DOWN),
            RunRewriter(KeyF6::Typed(), ui::EF_ALT_DOWN));

  // F7 -> Media Play/Pause
  EXPECT_EQ(KeyMediaPlayPause::Typed(), RunRewriter(KeyF7::Typed()));
  EXPECT_EQ(KeyMediaPlayPause::Typed(ui::EF_CONTROL_DOWN),
            RunRewriter(KeyF7::Typed(), ui::EF_CONTROL_DOWN));
  EXPECT_EQ(KeyMediaPlayPause::Typed(ui::EF_ALT_DOWN),
            RunRewriter(KeyF7::Typed(), ui::EF_ALT_DOWN));

  // F8 -> Volume Mute
  EXPECT_EQ(KeyVolumeMute::Typed(), RunRewriter(KeyF8::Typed()));
  EXPECT_EQ(KeyVolumeMute::Typed(ui::EF_CONTROL_DOWN),
            RunRewriter(KeyF8::Typed(), ui::EF_CONTROL_DOWN));
  EXPECT_EQ(KeyVolumeMute::Typed(ui::EF_ALT_DOWN),
            RunRewriter(KeyF8::Typed(), ui::EF_ALT_DOWN));

  // F9 -> Volume Down
  EXPECT_EQ(KeyVolumeDown::Typed(), RunRewriter(KeyF9::Typed()));
  EXPECT_EQ(KeyVolumeDown::Typed(ui::EF_CONTROL_DOWN),
            RunRewriter(KeyF9::Typed(), ui::EF_CONTROL_DOWN));
  EXPECT_EQ(KeyVolumeDown::Typed(ui::EF_ALT_DOWN),
            RunRewriter(KeyF9::Typed(), ui::EF_ALT_DOWN));

  // F10 -> Volume Up
  EXPECT_EQ(KeyVolumeUp::Typed(), RunRewriter(KeyF10::Typed()));
  EXPECT_EQ(KeyVolumeUp::Typed(ui::EF_CONTROL_DOWN),
            RunRewriter(KeyF10::Typed(), ui::EF_CONTROL_DOWN));
  EXPECT_EQ(KeyVolumeUp::Typed(ui::EF_ALT_DOWN),
            RunRewriter(KeyF10::Typed(), ui::EF_ALT_DOWN));

  // F11 -> F11
  EXPECT_EQ(KeyF11::Typed(), RunRewriter(KeyF11::Typed()));
  EXPECT_EQ(KeyF11::Typed(ui::EF_CONTROL_DOWN),
            RunRewriter(KeyF11::Typed(), ui::EF_CONTROL_DOWN));
  EXPECT_EQ(KeyF11::Typed(ui::EF_ALT_DOWN),
            RunRewriter(KeyF11::Typed(), ui::EF_ALT_DOWN));

  // F12 -> F12
  EXPECT_EQ(KeyF12::Typed(), RunRewriter(KeyF12::Typed()));
  EXPECT_EQ(KeyF12::Typed(ui::EF_CONTROL_DOWN),
            RunRewriter(KeyF12::Typed(), ui::EF_CONTROL_DOWN));
  EXPECT_EQ(KeyF12::Typed(ui::EF_ALT_DOWN),
            RunRewriter(KeyF12::Typed(), ui::EF_ALT_DOWN));
}

TEST_P(EventRewriterTest,
       TestFunctionKeysLayout2SuppressMetaTopRowKeyRewrites) {
  Preferences::RegisterProfilePrefs(prefs()->registry());
  delegate_->SuppressMetaTopRowKeyComboRewrites(true);
  keyboard_settings->suppress_meta_fkey_rewrites = true;

  // With Meta + Top Row Key rewrites suppressed, F-Keys should be translated to
  // the equivalent action key and not lose the Search modifier.
  SetUpKeyboard({.name = "Internal Keyboard",
                 .layout = kKbdTopRowLayout2Tag,
                 .type = ui::INPUT_DEVICE_INTERNAL,
                 .has_custom_top_row = false});

  // F1 -> Back
  EXPECT_EQ(KeyBrowserBack::Typed(ui::EF_COMMAND_DOWN),
            RunRewriter(KeyF1::Typed(), ui::EF_COMMAND_DOWN));

  // F2 -> Refresh
  EXPECT_EQ(KeyBrowserRefresh::Typed(ui::EF_COMMAND_DOWN),
            RunRewriter(KeyF2::Typed(), ui::EF_COMMAND_DOWN));

  // F3 -> Zoom (aka Fullscreen)
  EXPECT_EQ(KeyZoomToggle::Typed(ui::EF_COMMAND_DOWN),
            RunRewriter(KeyF3::Typed(), ui::EF_COMMAND_DOWN));

  // F4 -> Launch App 1
  EXPECT_EQ(KeySelectTask::Typed(ui::EF_COMMAND_DOWN),
            RunRewriter(KeyF4::Typed(), ui::EF_COMMAND_DOWN));

  // F5 -> Brightness down
  EXPECT_EQ(KeyBrightnessDown::Typed(ui::EF_COMMAND_DOWN),
            RunRewriter(KeyF5::Typed(), ui::EF_COMMAND_DOWN));

  // F6 -> Brightness up
  EXPECT_EQ(KeyBrightnessUp::Typed(ui::EF_COMMAND_DOWN),
            RunRewriter(KeyF6::Typed(), ui::EF_COMMAND_DOWN));

  // F7 -> Media Play/Pause
  EXPECT_EQ(KeyMediaPlayPause::Typed(ui::EF_COMMAND_DOWN),
            RunRewriter(KeyF7::Typed(), ui::EF_COMMAND_DOWN));

  // F8 -> Volume Mute
  EXPECT_EQ(KeyVolumeMute::Typed(ui::EF_COMMAND_DOWN),
            RunRewriter(KeyF8::Typed(), ui::EF_COMMAND_DOWN));

  // F9 -> Volume Down
  EXPECT_EQ(KeyVolumeDown::Typed(ui::EF_COMMAND_DOWN),
            RunRewriter(KeyF9::Typed(), ui::EF_COMMAND_DOWN));

  // F10 -> Volume Up
  EXPECT_EQ(KeyVolumeUp::Typed(ui::EF_COMMAND_DOWN),
            RunRewriter(KeyF10::Typed(), ui::EF_COMMAND_DOWN));

  // F11 -> F11
  EXPECT_EQ(KeyF11::Typed(ui::EF_COMMAND_DOWN),
            RunRewriter(KeyF11::Typed(), ui::EF_COMMAND_DOWN));

  // F12 -> F12
  EXPECT_EQ(KeyF12::Typed(ui::EF_COMMAND_DOWN),
            RunRewriter(KeyF12::Typed(), ui::EF_COMMAND_DOWN));
}

TEST_P(EventRewriterTest, RecordEventRemappedToRightClick) {
  Preferences::RegisterProfilePrefs(prefs()->registry());
  IntegerPrefMember alt_remap_to_right_click;
  IntegerPrefMember search_remap_to_right_click;
  alt_remap_to_right_click.Init(prefs::kAltEventRemappedToRightClick, prefs());
  alt_remap_to_right_click.SetValue(0);
  search_remap_to_right_click.Init(prefs::kSearchEventRemappedToRightClick,
                                   prefs());
  search_remap_to_right_click.SetValue(0);
  delegate_->RecordEventRemappedToRightClick(/*alt_based_right_click=*/false);
  EXPECT_EQ(1, prefs()->GetInteger(prefs::kSearchEventRemappedToRightClick));
  delegate_->RecordEventRemappedToRightClick(/*alt_based_right_click=*/true);
  EXPECT_EQ(1, prefs()->GetInteger(prefs::kAltEventRemappedToRightClick));
}

TEST_P(
    EventRewriterTest,
    TestFunctionKeysLayout2SuppressMetaTopRowKeyRewritesWithTreatTopRowAsFKeys) {
  Preferences::RegisterProfilePrefs(prefs()->registry());
  delegate_->SuppressMetaTopRowKeyComboRewrites(true);
  keyboard_settings->suppress_meta_fkey_rewrites = true;

  // Enable preference treat-top-row-as-function-keys.
  // That causes action keys to be mapped back to Fn keys.
  BooleanPrefMember top_row_as_fn_key;
  top_row_as_fn_key.Init(prefs::kSendFunctionKeys, prefs());
  top_row_as_fn_key.SetValue(true);
  keyboard_settings->top_row_are_fkeys = true;

  // With Meta + Top Row Key rewrites suppressed and TopRowAsFKeys enabled,
  // F-Keys should not be translated and search modifier should be kept.
  SetUpKeyboard({.name = "Internal Keyboard",
                 .layout = kKbdTopRowLayout2Tag,
                 .type = ui::INPUT_DEVICE_INTERNAL,
                 .has_custom_top_row = false});

  EXPECT_EQ(KeyF1::Typed(ui::EF_COMMAND_DOWN),
            RunRewriter(KeyF1::Typed(), ui::EF_COMMAND_DOWN));
  EXPECT_EQ(KeyF2::Typed(ui::EF_COMMAND_DOWN),
            RunRewriter(KeyF2::Typed(), ui::EF_COMMAND_DOWN));
  EXPECT_EQ(KeyF3::Typed(ui::EF_COMMAND_DOWN),
            RunRewriter(KeyF3::Typed(), ui::EF_COMMAND_DOWN));
  EXPECT_EQ(KeyF4::Typed(ui::EF_COMMAND_DOWN),
            RunRewriter(KeyF4::Typed(), ui::EF_COMMAND_DOWN));
  EXPECT_EQ(KeyF5::Typed(ui::EF_COMMAND_DOWN),
            RunRewriter(KeyF5::Typed(), ui::EF_COMMAND_DOWN));
  EXPECT_EQ(KeyF6::Typed(ui::EF_COMMAND_DOWN),
            RunRewriter(KeyF6::Typed(), ui::EF_COMMAND_DOWN));
  EXPECT_EQ(KeyF7::Typed(ui::EF_COMMAND_DOWN),
            RunRewriter(KeyF7::Typed(), ui::EF_COMMAND_DOWN));
  EXPECT_EQ(KeyF8::Typed(ui::EF_COMMAND_DOWN),
            RunRewriter(KeyF8::Typed(), ui::EF_COMMAND_DOWN));
  EXPECT_EQ(KeyF9::Typed(ui::EF_COMMAND_DOWN),
            RunRewriter(KeyF9::Typed(), ui::EF_COMMAND_DOWN));
  EXPECT_EQ(KeyF10::Typed(ui::EF_COMMAND_DOWN),
            RunRewriter(KeyF10::Typed(), ui::EF_COMMAND_DOWN));
  EXPECT_EQ(KeyF11::Typed(ui::EF_COMMAND_DOWN),
            RunRewriter(KeyF11::Typed(), ui::EF_COMMAND_DOWN));
  EXPECT_EQ(KeyF12::Typed(ui::EF_COMMAND_DOWN),
            RunRewriter(KeyF12::Typed(), ui::EF_COMMAND_DOWN));
}

TEST_P(EventRewriterTest, TestRewriteFunctionKeysWilcoLayouts) {
  Preferences::RegisterProfilePrefs(prefs()->registry());

  for (const auto& keyboard : kWilcoKeyboardVariants) {
    SCOPED_TRACE(keyboard.name);
    SetUpKeyboard(keyboard);

    // F1 -> F1, Search + F1 -> Back
    EXPECT_EQ(KeyF1::Typed(), RunRewriter(KeyF1::Typed()));
    EXPECT_EQ(KeyBrowserBack::Typed(),
              RunRewriter(KeyF1::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyF1::Typed(ui::EF_CONTROL_DOWN),
              RunRewriter(KeyF1::Typed(), ui::EF_CONTROL_DOWN));
    EXPECT_EQ(KeyF1::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyF1::Typed(), ui::EF_ALT_DOWN));

    // F2 -> F2, Search + F2 -> Refresh
    EXPECT_EQ(KeyF2::Typed(), RunRewriter(KeyF2::Typed()));
    EXPECT_EQ(KeyBrowserRefresh::Typed(),
              RunRewriter(KeyF2::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyF2::Typed(ui::EF_CONTROL_DOWN),
              RunRewriter(KeyF2::Typed(), ui::EF_CONTROL_DOWN));
    EXPECT_EQ(KeyF2::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyF2::Typed(), ui::EF_ALT_DOWN));

    // F3 -> F3, Search + F3 -> Zoom (aka Fullscreen)
    EXPECT_EQ(KeyF3::Typed(), RunRewriter(KeyF3::Typed()));
    EXPECT_EQ(KeyZoomToggle::Typed(),
              RunRewriter(KeyF3::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyF3::Typed(ui::EF_CONTROL_DOWN),
              RunRewriter(KeyF3::Typed(), ui::EF_CONTROL_DOWN));
    EXPECT_EQ(KeyF3::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyF3::Typed(), ui::EF_ALT_DOWN));

    // F4 -> F4, Search + F4 -> Launch App 1
    EXPECT_EQ(KeyF4::Typed(), RunRewriter(KeyF4::Typed()));
    EXPECT_EQ(
        std::vector({TestKeyEvent{ui::EventType::kKeyPressed, ui::DomCode::F4,
                                  ui::DomKey::F4, ui::VKEY_MEDIA_LAUNCH_APP1,
                                  ui::EF_NONE},
                     TestKeyEvent{ui::EventType::kKeyReleased, ui::DomCode::F4,
                                  ui::DomKey::F4, ui::VKEY_MEDIA_LAUNCH_APP1,
                                  ui::EF_NONE}}),
        RunRewriter(KeyF4::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyF4::Typed(ui::EF_CONTROL_DOWN),
              RunRewriter(KeyF4::Typed(), ui::EF_CONTROL_DOWN));
    EXPECT_EQ(KeyF4::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyF4::Typed(), ui::EF_ALT_DOWN));

    // F5 -> F5, Search + F5 -> Brightness down
    EXPECT_EQ(KeyF5::Typed(), RunRewriter(KeyF5::Typed()));
    EXPECT_EQ(KeyBrightnessDown::Typed(),
              RunRewriter(KeyF5::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyF5::Typed(ui::EF_CONTROL_DOWN),
              RunRewriter(KeyF5::Typed(), ui::EF_CONTROL_DOWN));
    EXPECT_EQ(KeyF5::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyF5::Typed(), ui::EF_ALT_DOWN));

    // F6 -> F6, Search + F6 -> Brightness up
    EXPECT_EQ(KeyF6::Typed(), RunRewriter(KeyF6::Typed()));
    EXPECT_EQ(KeyBrightnessUp::Typed(),
              RunRewriter(KeyF6::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyF6::Typed(ui::EF_CONTROL_DOWN),
              RunRewriter(KeyF6::Typed(), ui::EF_CONTROL_DOWN));
    EXPECT_EQ(KeyF6::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyF6::Typed(), ui::EF_ALT_DOWN));

    // F7 -> F7, Search + F7 -> Volume mute
    EXPECT_EQ(KeyF7::Typed(), RunRewriter(KeyF7::Typed()));
    EXPECT_EQ(KeyVolumeMute::Typed(),
              RunRewriter(KeyF7::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyF7::Typed(ui::EF_CONTROL_DOWN),
              RunRewriter(KeyF7::Typed(), ui::EF_CONTROL_DOWN));
    EXPECT_EQ(KeyF7::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyF7::Typed(), ui::EF_ALT_DOWN));

    // F8 -> F8, Search + F8 -> Volume Down
    EXPECT_EQ(KeyF8::Typed(), RunRewriter(KeyF8::Typed()));
    EXPECT_EQ(KeyVolumeDown::Typed(),
              RunRewriter(KeyF8::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyF8::Typed(ui::EF_CONTROL_DOWN),
              RunRewriter(KeyF8::Typed(), ui::EF_CONTROL_DOWN));
    EXPECT_EQ(KeyF8::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyF8::Typed(), ui::EF_ALT_DOWN));

    // F9 -> F9, Search + F9 -> Volume Up
    EXPECT_EQ(KeyF9::Typed(), RunRewriter(KeyF9::Typed()));
    EXPECT_EQ(KeyVolumeUp::Typed(),
              RunRewriter(KeyF9::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyF9::Typed(ui::EF_CONTROL_DOWN),
              RunRewriter(KeyF9::Typed(), ui::EF_CONTROL_DOWN));
    EXPECT_EQ(KeyF9::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyF9::Typed(), ui::EF_ALT_DOWN));

    // F10 -> F10, Search + F10 -> F10
    EXPECT_EQ(KeyF10::Typed(), RunRewriter(KeyF10::Typed()));
    EXPECT_EQ(KeyF10::Typed(),
              RunRewriter(KeyF10::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyF10::Typed(ui::EF_CONTROL_DOWN),
              RunRewriter(KeyF10::Typed(), ui::EF_CONTROL_DOWN));
    EXPECT_EQ(KeyF10::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyF10::Typed(), ui::EF_ALT_DOWN));

    // F11 -> F11, Search + F11 -> F11
    EXPECT_EQ(KeyF11::Typed(), RunRewriter(KeyF11::Typed()));
    EXPECT_EQ(KeyF11::Typed(),
              RunRewriter(KeyF11::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyF11::Typed(ui::EF_CONTROL_DOWN),
              RunRewriter(KeyF11::Typed(), ui::EF_CONTROL_DOWN));
    EXPECT_EQ(KeyF11::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyF11::Typed(), ui::EF_ALT_DOWN));

    // F12 -> F12
    // Search + F12 differs between Wilco devices so it is tested separately.
    EXPECT_EQ(KeyF12::Typed(), RunRewriter(KeyF12::Typed()));
    EXPECT_EQ(KeyF12::Typed(ui::EF_CONTROL_DOWN),
              RunRewriter(KeyF12::Typed(), ui::EF_CONTROL_DOWN));
    EXPECT_EQ(KeyF12::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyF12::Typed(), ui::EF_ALT_DOWN));

    // The number row should not be rewritten without Search key.
    EXPECT_EQ(KeyDigit1::Typed(), RunRewriter(KeyDigit1::Typed()));
    EXPECT_EQ(KeyDigit2::Typed(), RunRewriter(KeyDigit2::Typed()));
    EXPECT_EQ(KeyDigit3::Typed(), RunRewriter(KeyDigit3::Typed()));
    EXPECT_EQ(KeyDigit4::Typed(), RunRewriter(KeyDigit4::Typed()));
    EXPECT_EQ(KeyDigit5::Typed(), RunRewriter(KeyDigit5::Typed()));
    EXPECT_EQ(KeyDigit6::Typed(), RunRewriter(KeyDigit6::Typed()));
    EXPECT_EQ(KeyDigit7::Typed(), RunRewriter(KeyDigit7::Typed()));
    EXPECT_EQ(KeyDigit8::Typed(), RunRewriter(KeyDigit8::Typed()));
    EXPECT_EQ(KeyDigit9::Typed(), RunRewriter(KeyDigit9::Typed()));
    EXPECT_EQ(KeyDigit0::Typed(), RunRewriter(KeyDigit0::Typed()));
    EXPECT_EQ(KeyMinus::Typed(), RunRewriter(KeyMinus::Typed()));
    EXPECT_EQ(KeyEqual::Typed(), RunRewriter(KeyEqual::Typed()));
  }

  SetUpKeyboard(kWilco1_0Keyboard);
  // Search + F12 -> Ctrl + Zoom (aka Fullscreen) (Display toggle)
  EXPECT_EQ(
      std::vector(
          {TestKeyEvent{ui::EventType::kKeyPressed, ui::DomCode::F12,
                        ui::DomKey::F12, ui::VKEY_ZOOM, ui::EF_CONTROL_DOWN},
           TestKeyEvent{ui::EventType::kKeyReleased, ui::DomCode::F12,
                        ui::DomKey::F12, ui::VKEY_ZOOM, ui::EF_CONTROL_DOWN}}),
      RunRewriter(KeyF12::Typed(), ui::EF_COMMAND_DOWN));

  SetUpKeyboard(kWilco1_5Keyboard);
  // Search + F12 -> F12 (Privacy screen not supported)
  event_rewriter_ash_->set_privacy_screen_for_testing(false);
  EXPECT_EQ(KeyF12::Typed(), RunRewriter(KeyF12::Typed(), ui::EF_COMMAND_DOWN));

  // F12 -> F12, Search + F12 -> Privacy Screen Toggle
  event_rewriter_ash_->set_privacy_screen_for_testing(true);
  EXPECT_EQ(KeyPrivacyScreenToggle::Typed(),
            RunRewriter(KeyF12::Typed(), ui::EF_COMMAND_DOWN));
}

TEST_P(EventRewriterTest, TestRewriteActionKeysWilcoLayouts) {
  Preferences::RegisterProfilePrefs(prefs()->registry());

  for (const auto& keyboard : kWilcoKeyboardVariants) {
    SCOPED_TRACE(keyboard.name);
    SetUpKeyboard(keyboard);

    // Back -> Back, Search + Back -> F1
    EXPECT_EQ(KeyBrowserBack::Typed(), RunRewriter(KeyBrowserBack::Typed()));
    EXPECT_EQ(KeyF1::Typed(),
              RunRewriter(KeyBrowserBack::Typed(), ui::EF_COMMAND_DOWN));

    // Refresh -> Refresh, Search + Refresh -> F2
    EXPECT_EQ(KeyBrowserRefresh::Typed(),
              RunRewriter(KeyBrowserRefresh::Typed()));
    EXPECT_EQ(KeyF2::Typed(),
              RunRewriter(KeyBrowserRefresh::Typed(), ui::EF_COMMAND_DOWN));

    // Full Screen -> Full Screen, Search + Full Screen -> F3
    EXPECT_EQ(KeyZoomToggle::Typed(), RunRewriter(KeyZoomToggle::Typed()));
    EXPECT_EQ(KeyF3::Typed(),
              RunRewriter(KeyZoomToggle::Typed(), ui::EF_COMMAND_DOWN));

    // Launch App 1 -> Launch App 1, Search + Launch App 1 -> F4
    EXPECT_EQ(KeySelectTask::Typed(), RunRewriter(KeySelectTask::Typed()));
    EXPECT_EQ(KeyF4::Typed(),
              RunRewriter(KeySelectTask::Typed(), ui::EF_COMMAND_DOWN));

    // Brightness down -> Brightness Down, Search Brightness Down -> F5
    EXPECT_EQ(KeyBrightnessDown::Typed(),
              RunRewriter(KeyBrightnessDown::Typed()));
    EXPECT_EQ(KeyF5::Typed(),
              RunRewriter(KeyBrightnessDown::Typed(), ui::EF_COMMAND_DOWN));

    // Brightness up -> Brightness Up, Search + Brightness Up -> F6
    EXPECT_EQ(KeyBrightnessUp::Typed(), RunRewriter(KeyBrightnessUp::Typed()));
    EXPECT_EQ(KeyF6::Typed(),
              RunRewriter(KeyBrightnessUp::Typed(), ui::EF_COMMAND_DOWN));

    // Volume mute -> Volume Mute, Search + Volume Mute -> F7
    EXPECT_EQ(KeyVolumeMute::Typed(), RunRewriter(KeyVolumeMute::Typed()));
    EXPECT_EQ(KeyF7::Typed(),
              RunRewriter(KeyVolumeMute::Typed(), ui::EF_COMMAND_DOWN));

    // Volume Down -> Volume Down, Search + Volume Down -> F8
    EXPECT_EQ(KeyVolumeDown::Typed(), RunRewriter(KeyVolumeDown::Typed()));
    EXPECT_EQ(KeyF8::Typed(),
              RunRewriter(KeyVolumeDown::Typed(), ui::EF_COMMAND_DOWN));

    // Volume Up -> Volume Up, Search + Volume Up -> F9
    EXPECT_EQ(KeyVolumeUp::Typed(), RunRewriter(KeyVolumeUp::Typed()));
    EXPECT_EQ(KeyF9::Typed(),
              RunRewriter(KeyVolumeUp::Typed(), ui::EF_COMMAND_DOWN));
  }

  SetUpKeyboard(kWilco1_0Keyboard);
  // Ctrl + Zoom (Display toggle) -> Unchanged
  // Search + Ctrl + Zoom (Display toggle) -> F12
  EXPECT_EQ(KeyZoomToggle::Typed(ui::EF_CONTROL_DOWN),
            RunRewriter(KeyZoomToggle::Typed(), ui::EF_CONTROL_DOWN));
  EXPECT_EQ(KeyF12::Typed(),
            RunRewriter(KeyZoomToggle::Typed(),
                        ui::EF_CONTROL_DOWN | ui::EF_COMMAND_DOWN));

  SetUpKeyboard(kWilco1_5Keyboard);
  {
    // Drallion specific key tests (no privacy screen)
    event_rewriter_ash_->set_privacy_screen_for_testing(false);

    // Privacy Screen Toggle -> F12 (Privacy Screen not supported),
    // Search + Privacy Screen Toggle -> F12
    EXPECT_EQ(KeyF12::Typed(), RunRewriter(KeyPrivacyScreenToggle::Typed()));
    EXPECT_EQ(KeyF12::Typed(), RunRewriter(KeyPrivacyScreenToggle::Typed(),
                                           ui::EF_COMMAND_DOWN));

    // Ctrl + Zoom (Display toggle) -> Unchanged
    // Search + Ctrl + Zoom (Display toggle) -> Unchanged
    EXPECT_EQ(KeyZoomToggle::Typed(ui::EF_CONTROL_DOWN),
              RunRewriter(KeyZoomToggle::Typed(), ui::EF_CONTROL_DOWN));
    EXPECT_EQ(KeyZoomToggle::Typed(ui::EF_CONTROL_DOWN),
              RunRewriter(KeyZoomToggle::Typed(),
                          ui::EF_CONTROL_DOWN | ui::EF_COMMAND_DOWN));
  }

  {
    // Drallion specific key tests (privacy screen supported)
    event_rewriter_ash_->set_privacy_screen_for_testing(true);

    // Privacy Screen Toggle -> Privacy Screen Toggle,
    // Search + Privacy Screen Toggle -> F12
    EXPECT_EQ(KeyPrivacyScreenToggle::Typed(),
              RunRewriter(KeyPrivacyScreenToggle::Typed()));
    EXPECT_EQ(KeyF12::Typed(), RunRewriter(KeyPrivacyScreenToggle::Typed(),
                                           ui::EF_COMMAND_DOWN));

    // Ctrl + Zoom (Display toggle) -> Unchanged
    // Search + Ctrl + Zoom (Display toggle) -> Unchanged
    EXPECT_EQ(KeyZoomToggle::Typed(ui::EF_CONTROL_DOWN),
              RunRewriter(KeyZoomToggle::Typed(), ui::EF_CONTROL_DOWN));
    EXPECT_EQ(KeyZoomToggle::Typed(ui::EF_CONTROL_DOWN),
              RunRewriter(KeyZoomToggle::Typed(),
                          ui::EF_CONTROL_DOWN | ui::EF_COMMAND_DOWN));
  }
}

TEST_P(EventRewriterTest,
       TestRewriteActionKeysWilcoLayoutsSuppressMetaTopRowKeyRewrites) {
  Preferences::RegisterProfilePrefs(prefs()->registry());
  delegate_->SuppressMetaTopRowKeyComboRewrites(true);
  keyboard_settings->suppress_meta_fkey_rewrites = true;

  // With |SuppressMetaTopRowKeyComboRewrites|, all action keys should be
  // unchanged and keep the search modifier.

  for (const auto& keyboard : kWilcoKeyboardVariants) {
    SCOPED_TRACE(keyboard.name);
    SetUpKeyboard(keyboard);

    EXPECT_EQ(KeyBrowserBack::Typed(ui::EF_COMMAND_DOWN),
              RunRewriter(KeyBrowserBack::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyBrowserRefresh::Typed(ui::EF_COMMAND_DOWN),
              RunRewriter(KeyBrowserRefresh::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyZoomToggle::Typed(ui::EF_COMMAND_DOWN),
              RunRewriter(KeyZoomToggle::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeySelectTask::Typed(ui::EF_COMMAND_DOWN),
              RunRewriter(KeySelectTask::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyBrightnessDown::Typed(ui::EF_COMMAND_DOWN),
              RunRewriter(KeyBrightnessDown::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyBrightnessUp::Typed(ui::EF_COMMAND_DOWN),
              RunRewriter(KeyBrightnessUp::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyVolumeMute::Typed(ui::EF_COMMAND_DOWN),
              RunRewriter(KeyVolumeMute::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyVolumeDown::Typed(ui::EF_COMMAND_DOWN),
              RunRewriter(KeyVolumeDown::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyVolumeUp::Typed(ui::EF_COMMAND_DOWN),
              RunRewriter(KeyVolumeUp::Typed(), ui::EF_COMMAND_DOWN));

    // F-Keys do not remove Search when pressed.
    EXPECT_EQ(KeyF10::Typed(ui::EF_COMMAND_DOWN),
              RunRewriter(KeyF10::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyF11::Typed(ui::EF_COMMAND_DOWN),
              RunRewriter(KeyF11::Typed(), ui::EF_COMMAND_DOWN));
  }

  SetUpKeyboard(kWilco1_0Keyboard);
  EXPECT_EQ(KeyZoomToggle::Typed(ui::EF_CONTROL_DOWN | ui::EF_COMMAND_DOWN),
            RunRewriter(KeyZoomToggle::Typed(),
                        ui::EF_CONTROL_DOWN | ui::EF_COMMAND_DOWN));

  SetUpKeyboard(kWilco1_5Keyboard);
  {
    // Drallion specific key tests (no privacy screen)
    event_rewriter_ash_->set_privacy_screen_for_testing(false);

    // Search + Privacy Screen Toggle -> Search + F12
    EXPECT_EQ(
        KeyF12::Typed(ui::EF_COMMAND_DOWN),
        RunRewriter(KeyPrivacyScreenToggle::Typed(), ui::EF_COMMAND_DOWN));
    // Search + Ctrl + Zoom (Display toggle) -> Unchanged
    EXPECT_EQ(KeyZoomToggle::Typed(ui::EF_COMMAND_DOWN | ui::EF_CONTROL_DOWN),
              RunRewriter(KeyZoomToggle::Typed(),
                          ui::EF_COMMAND_DOWN | ui::EF_CONTROL_DOWN));
  }

  {
    // Drallion specific key tests (privacy screen supported)
    event_rewriter_ash_->set_privacy_screen_for_testing(true);

    // Search + Privacy Screen Toggle -> F12  TODO
    EXPECT_EQ(
        KeyPrivacyScreenToggle::Typed(ui::EF_COMMAND_DOWN),
        RunRewriter(KeyPrivacyScreenToggle::Typed(), ui::EF_COMMAND_DOWN));
    // Ctrl + Zoom (Display toggle) -> Unchanged  TODO
    // Search + Ctrl + Zoom (Display toggle) -> Unchanged
    EXPECT_EQ(KeyZoomToggle::Typed(ui::EF_COMMAND_DOWN | ui::EF_CONTROL_DOWN),
              RunRewriter(KeyZoomToggle::Typed(),
                          ui::EF_COMMAND_DOWN | ui::EF_CONTROL_DOWN));
  }
}

TEST_P(
    EventRewriterTest,
    TestRewriteActionKeysWilcoLayoutsSuppressMetaTopRowKeyRewritesWithTopRowAreFkeys) {
  Preferences::RegisterProfilePrefs(prefs()->registry());
  delegate_->SuppressMetaTopRowKeyComboRewrites(true);
  keyboard_settings->suppress_meta_fkey_rewrites = true;

  // Enable preference treat-top-row-as-function-keys.
  // That causes action keys to be mapped back to Fn keys.
  BooleanPrefMember top_row_as_fn_key;
  top_row_as_fn_key.Init(prefs::kSendFunctionKeys, prefs());
  top_row_as_fn_key.SetValue(true);
  keyboard_settings->top_row_are_fkeys = true;

  // With |SuppressMetaTopRowKeyComboRewrites| and TopRowAreFKeys, all action
  // keys should be remapped to F-Keys and keep the Search modifier.
  for (const auto& keyboard : kWilcoKeyboardVariants) {
    SCOPED_TRACE(keyboard.name);
    SetUpKeyboard(keyboard);

    EXPECT_EQ(KeyF1::Typed(ui::EF_COMMAND_DOWN),
              RunRewriter(KeyBrowserBack::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyF2::Typed(ui::EF_COMMAND_DOWN),
              RunRewriter(KeyBrowserRefresh::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyF3::Typed(ui::EF_COMMAND_DOWN),
              RunRewriter(KeyZoomToggle::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyF4::Typed(ui::EF_COMMAND_DOWN),
              RunRewriter(KeySelectTask::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyF5::Typed(ui::EF_COMMAND_DOWN),
              RunRewriter(KeyBrightnessDown::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyF6::Typed(ui::EF_COMMAND_DOWN),
              RunRewriter(KeyBrightnessUp::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyF7::Typed(ui::EF_COMMAND_DOWN),
              RunRewriter(KeyVolumeMute::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyF8::Typed(ui::EF_COMMAND_DOWN),
              RunRewriter(KeyVolumeDown::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyF9::Typed(ui::EF_COMMAND_DOWN),
              RunRewriter(KeyVolumeUp::Typed(), ui::EF_COMMAND_DOWN));

    EXPECT_EQ(KeyF10::Typed(ui::EF_COMMAND_DOWN),
              RunRewriter(KeyF10::Typed(), ui::EF_COMMAND_DOWN));
    EXPECT_EQ(KeyF11::Typed(ui::EF_COMMAND_DOWN),
              RunRewriter(KeyF11::Typed(), ui::EF_COMMAND_DOWN));
  }

  SetUpKeyboard(kWilco1_0Keyboard);
  EXPECT_EQ(KeyF12::Typed(ui::EF_COMMAND_DOWN),
            RunRewriter(KeyZoomToggle::Typed(),
                        ui::EF_CONTROL_DOWN | ui::EF_COMMAND_DOWN));

  SetUpKeyboard(kWilco1_5Keyboard);
  {
    // Drallion specific key tests (no privacy screen)
    event_rewriter_ash_->set_privacy_screen_for_testing(false);

    // Search + Privacy Screen Toggle -> Search + F12
    EXPECT_EQ(
        KeyF12::Typed(ui::EF_COMMAND_DOWN),
        RunRewriter(KeyPrivacyScreenToggle::Typed(), ui::EF_COMMAND_DOWN));
    // Search + Ctrl + Zoom (Display toggle) -> Unchanged
    EXPECT_EQ(KeyZoomToggle::Typed(ui::EF_COMMAND_DOWN | ui::EF_CONTROL_DOWN),
              RunRewriter(KeyZoomToggle::Typed(),
                          ui::EF_COMMAND_DOWN | ui::EF_CONTROL_DOWN));
  }

  {
    // Drallion specific key tests (privacy screen supported)
    event_rewriter_ash_->set_privacy_screen_for_testing(true);

    // Search + Privacy Screen Toggle -> F12
    EXPECT_EQ(
        KeyF12::Typed(ui::EF_COMMAND_DOWN),
        RunRewriter(KeyPrivacyScreenToggle::Typed(), ui::EF_COMMAND_DOWN));
  }
}

TEST_P(EventRewriterTest, TestTopRowAsFnKeysForKeyboardWilcoLayouts) {
  Preferences::RegisterProfilePrefs(prefs()->registry());

  // Enable preference treat-top-row-as-function-keys.
  // That causes action keys to be mapped back to Fn keys, unless the search
  // key is pressed.
  BooleanPrefMember top_row_as_fn_key;
  top_row_as_fn_key.Init(prefs::kSendFunctionKeys, prefs());
  top_row_as_fn_key.SetValue(true);
  keyboard_settings->top_row_are_fkeys = true;

  for (const auto& keyboard : kWilcoKeyboardVariants) {
    SCOPED_TRACE(keyboard.name);
    SetUpKeyboard(keyboard);

    // Back -> F1, Search + Back -> Back
    EXPECT_EQ(KeyF1::Typed(), RunRewriter(KeyBrowserBack::Typed()));
    EXPECT_EQ(KeyBrowserBack::Typed(),
              RunRewriter(KeyBrowserBack::Typed(), ui::EF_COMMAND_DOWN));

    // Refresh -> F2, Search + Refresh -> Refresh
    EXPECT_EQ(KeyF2::Typed(), RunRewriter(KeyBrowserRefresh::Typed()));
    EXPECT_EQ(KeyBrowserRefresh::Typed(),
              RunRewriter(KeyBrowserRefresh::Typed(), ui::EF_COMMAND_DOWN));

    // Full Screen -> F3, Search + Full Screen -> Full Screen
    EXPECT_EQ(KeyF3::Typed(), RunRewriter(KeyZoomToggle::Typed()));
    EXPECT_EQ(KeyZoomToggle::Typed(),
              RunRewriter(KeyZoomToggle::Typed(), ui::EF_COMMAND_DOWN));

    // Launch App 1 -> F4, Search + Launch App 1 -> Launch App 1
    EXPECT_EQ(KeyF4::Typed(), RunRewriter(KeySelectTask::Typed()));
    EXPECT_EQ(KeySelectTask::Typed(),
              RunRewriter(KeySelectTask::Typed(), ui::EF_COMMAND_DOWN));

    // Brightness down -> F5, Search Brightness Down -> Brightness Down
    EXPECT_EQ(KeyF5::Typed(), RunRewriter(KeyBrightnessDown::Typed()));
    EXPECT_EQ(KeyBrightnessDown::Typed(),
              RunRewriter(KeyBrightnessDown::Typed(), ui::EF_COMMAND_DOWN));

    // Brightness up -> F6, Search + Brightness Up -> Brightness Up
    EXPECT_EQ(KeyF6::Typed(), RunRewriter(KeyBrightnessUp::Typed()));
    EXPECT_EQ(KeyBrightnessUp::Typed(),
              RunRewriter(KeyBrightnessUp::Typed(), ui::EF_COMMAND_DOWN));

    // Volume mute -> F7, Search + Volume Mute -> Volume Mute
    EXPECT_EQ(KeyF7::Typed(), RunRewriter(KeyVolumeMute::Typed()));
    EXPECT_EQ(KeyVolumeMute::Typed(),
              RunRewriter(KeyVolumeMute::Typed(), ui::EF_COMMAND_DOWN));

    // Volume Down -> F8, Search + Volume Down -> Volume Down
    EXPECT_EQ(KeyF8::Typed(), RunRewriter(KeyVolumeDown::Typed()));
    EXPECT_EQ(KeyVolumeDown::Typed(),
              RunRewriter(KeyVolumeDown::Typed(), ui::EF_COMMAND_DOWN));

    // Volume Up -> F9, Search + Volume Up -> Volume Up
    EXPECT_EQ(KeyF9::Typed(), RunRewriter(KeyVolumeUp::Typed()));
    EXPECT_EQ(KeyVolumeUp::Typed(),
              RunRewriter(KeyVolumeUp::Typed(), ui::EF_COMMAND_DOWN));

    // F10 -> F10
    EXPECT_EQ(KeyF10::Typed(), RunRewriter(KeyF10::Typed()));
    EXPECT_EQ(KeyF10::Typed(),
              RunRewriter(KeyF10::Typed(), ui::EF_COMMAND_DOWN));

    // F11 -> F11
    EXPECT_EQ(KeyF11::Typed(), RunRewriter(KeyF11::Typed()));
    EXPECT_EQ(KeyF11::Typed(),
              RunRewriter(KeyF11::Typed(), ui::EF_COMMAND_DOWN));
  }

  SetUpKeyboard(kWilco1_0Keyboard);
  // Ctrl + Zoom (Display toggle) -> F12
  // Search + Ctrl + Zoom (Display toggle) -> Search modifier should be removed
  EXPECT_EQ(KeyF12::Typed(),
            RunRewriter(KeyZoomToggle::Typed(), ui::EF_CONTROL_DOWN));
  EXPECT_EQ(KeyZoomToggle::Typed(ui::EF_CONTROL_DOWN),
            RunRewriter(KeyZoomToggle::Typed(),
                        ui::EF_COMMAND_DOWN | ui::EF_CONTROL_DOWN));

  SetUpKeyboard(kWilco1_5Keyboard);
  {
    // Drallion specific key tests (no privacy screen)
    event_rewriter_ash_->set_privacy_screen_for_testing(false);

    // Privacy Screen Toggle -> F12,
    // Search + Privacy Screen Toggle -> F12 (Privacy screen not supported)
    EXPECT_EQ(KeyF12::Typed(), RunRewriter(KeyPrivacyScreenToggle::Typed()));
    EXPECT_EQ(KeyF12::Typed(), RunRewriter(KeyPrivacyScreenToggle::Typed(),
                                           ui::EF_COMMAND_DOWN));

    // Ctrl + Zoom (Display toggle) -> Unchanged
    // Search + Ctrl + Zoom (Display toggle) -> Unchanged
    EXPECT_EQ(KeyZoomToggle::Typed(ui::EF_CONTROL_DOWN),
              RunRewriter(KeyZoomToggle::Typed(), ui::EF_CONTROL_DOWN));
    EXPECT_EQ(KeyZoomToggle::Typed(ui::EF_CONTROL_DOWN),
              RunRewriter(KeyZoomToggle::Typed(),
                          ui::EF_COMMAND_DOWN | ui::EF_CONTROL_DOWN));
  }

  {
    // Drallion specific key tests (privacy screen supported)
    event_rewriter_ash_->set_privacy_screen_for_testing(true);

    // Privacy Screen Toggle -> F12,
    // Search + Privacy Screen Toggle -> Unchanged
    EXPECT_EQ(KeyF12::Typed(), RunRewriter(KeyPrivacyScreenToggle::Typed()));
    EXPECT_EQ(
        KeyPrivacyScreenToggle::Typed(),
        RunRewriter(KeyPrivacyScreenToggle::Typed(), ui::EF_COMMAND_DOWN));
  }
}

TEST_P(EventRewriterTest, TestRewriteFunctionKeysInvalidLayout) {
  Preferences::RegisterProfilePrefs(prefs()->registry());

  // Not adding a keyboard simulates a failure in getting top row layout, which
  // will fallback to Layout1 in which case keys are rewritten to their default
  // values.
  EXPECT_EQ(KeyBrowserForward::Typed(), RunRewriter(KeyF2::Typed()));
  EXPECT_EQ(KeyBrowserRefresh::Typed(), RunRewriter(KeyF3::Typed()));
  EXPECT_EQ(KeyZoomToggle::Typed(), RunRewriter(KeyF4::Typed()));
  EXPECT_EQ(KeyBrightnessUp::Typed(), RunRewriter(KeyF7::Typed()));

  // Adding a keyboard with a valid layout will take effect.
  SetUpKeyboard({.name = "Internal Keyboard",
                 .layout = kKbdTopRowLayout2Tag,
                 .type = ui::INPUT_DEVICE_INTERNAL,
                 .has_custom_top_row = false});
  EXPECT_EQ(KeyBrowserRefresh::Typed(), RunRewriter(KeyF2::Typed()));
  EXPECT_EQ(KeyZoomToggle::Typed(), RunRewriter(KeyF3::Typed()));
  EXPECT_EQ(KeySelectTask::Typed(), RunRewriter(KeyF4::Typed()));
  EXPECT_EQ(KeyMediaPlayPause::Typed(), RunRewriter(KeyF7::Typed()));
}

// Tests that event rewrites still work even if modifiers are remapped.
TEST_P(EventRewriterTest, TestRewriteExtendedKeysWithControlRemapped) {
  // Remap Control to Search.
  Preferences::RegisterProfilePrefs(prefs()->registry());
  base::test::ScopedFeatureList scoped_feature_list;
  scoped_feature_list.InitAndDisableFeature(
      features::kAltClickAndSixPackCustomization);
  IntegerPrefMember search;
  InitModifierKeyPref(&search, ::prefs::kLanguageRemapControlKeyTo,
                      ui::mojom::ModifierKey::kControl,
                      ui::mojom::ModifierKey::kMeta);

  for (const auto& keyboard : kChromeKeyboardVariants) {
    SCOPED_TRACE(keyboard.name);
    SetUpKeyboard(keyboard);

    EXPECT_EQ(KeyEnd::Typed(),
              RunRewriter(KeyArrowRight::Typed(), ui::EF_CONTROL_DOWN));
    EXPECT_EQ(KeyEnd::Typed(ui::EF_SHIFT_DOWN),
              RunRewriter(KeyArrowRight::Typed(),
                          ui::EF_CONTROL_DOWN | ui::EF_SHIFT_DOWN));
  }
}

TEST_P(EventRewriterTest, TestRewriteKeyEventSentByXSendEvent) {
  // Remap Control to Alt.
  Preferences::RegisterProfilePrefs(prefs()->registry());
  IntegerPrefMember control;
  InitModifierKeyPref(&control, ::prefs::kLanguageRemapControlKeyTo,
                      ui::mojom::ModifierKey::kControl,
                      ui::mojom::ModifierKey::kAlt);

  SetUpKeyboard(kInternalChromeKeyboard);

  // Send left control press.
  {
    // Control should NOT be remapped to Alt if EF_FINAL is set.
    EXPECT_EQ(KeyLControl::Typed(ui::EF_FINAL),
              SendKeyEvents(KeyLControl::Typed(ui::EF_FINAL)));
  }
}

TEST_P(EventRewriterTest, TestRewriteNonNativeEvent) {
  // Remap Control to Alt.
  Preferences::RegisterProfilePrefs(prefs()->registry());
  IntegerPrefMember control;
  InitModifierKeyPref(&control, ::prefs::kLanguageRemapControlKeyTo,
                      ui::mojom::ModifierKey::kControl,
                      ui::mojom::ModifierKey::kAlt);

  SetUpKeyboard(kInternalChromeKeyboard);

  // For EF_CONTROL_DOWN modifier.
  SendKeyEvent(KeyLControl::Pressed());

  const int kTouchId = 2;
  gfx::Point location(0, 0);
  ui::TouchEvent press(
      ui::EventType::kTouchPressed, location, base::TimeTicks(),
      ui::PointerDetails(ui::EventPointerType::kTouch, kTouchId));
  press.SetFlags(ui::EF_CONTROL_DOWN);

  source().Send(&press);
  auto events = TakeEvents();
  ASSERT_EQ(1u, events.size());
  // Control should be remapped to Alt.
  EXPECT_EQ(ui::EF_ALT_DOWN,
            events[0]->flags() & (ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN));
}

TEST_P(EventRewriterTest, TopRowKeysAreFunctionKeys) {
  Preferences::RegisterProfilePrefs(prefs()->registry());
  std::unique_ptr<aura::Window> window(CreateTestWindowInShellWithId(1));
  wm::ActivateWindow(window.get());

  // Create a simulated keypress of F1 targetted at the window.
  ui::KeyEvent press_f1(ui::EventType::kKeyPressed, ui::VKEY_F1,
                        ui::DomCode::F1, ui::EF_NONE, ui::DomKey::F1,
                        ui::EventTimeForNow());

  // The event should also not be rewritten if the send-function-keys pref is
  // additionally set, for both apps v2 and regular windows.
  BooleanPrefMember send_function_keys_pref;
  send_function_keys_pref.Init(prefs::kSendFunctionKeys, prefs());
  send_function_keys_pref.SetValue(true);
  keyboard_settings->top_row_are_fkeys = true;
  EXPECT_EQ(KeyF1::Typed(), RunRewriter(KeyF1::Typed()));

  // If the pref isn't set when an event is sent to a regular window, F1 is
  // rewritten to the back key.
  send_function_keys_pref.SetValue(false);
  keyboard_settings->top_row_are_fkeys = false;
  EXPECT_EQ(KeyBrowserBack::Typed(), RunRewriter(KeyF1::Typed()));
}

// Parameterized version of test with the same name that accepts the
// event flags that correspond to a right-click. This will be either
// Alt+Click or Search+Click. After a transition period this will
// default to Search+Click and the Alt+Click logic will be removed.
void EventRewriterTestBase::DontRewriteIfNotRewritten(int right_click_flags) {
  Preferences::RegisterProfilePrefs(prefs()->registry());
  ui::DeviceDataManager* device_data_manager =
      ui::DeviceDataManager::GetInstance();
  std::vector<ui::TouchpadDevice> touchpad_devices(2);
  touchpad_devices[0].id = kTouchpadId1;
  touchpad_devices[1].id = kTouchpadId2;
  static_cast<ui::DeviceHotplugEventObserver*>(device_data_manager)
      ->OnTouchpadDevicesUpdated(touchpad_devices);
  std::vector<ui::InputDevice> mouse_devices(1);
  constexpr int kMouseId = 12;
  touchpad_devices[0].id = kMouseId;
  static_cast<ui::DeviceHotplugEventObserver*>(device_data_manager)
      ->OnMouseDevicesUpdated(mouse_devices);

  // Test (Alt|Search) + Left click.
  {
    ui::MouseEvent press(ui::EventType::kMousePressed, gfx::Point(),
                         gfx::Point(), ui::EventTimeForNow(), right_click_flags,
                         ui::EF_LEFT_MOUSE_BUTTON);
    ui::EventTestApi test_press(&press);
    test_press.set_source_device_id(kTouchpadId1);
    // Sanity check.
    EXPECT_EQ(ui::EventType::kMousePressed, press.type());
    EXPECT_EQ(right_click_flags, press.flags());
    const ui::MouseEvent result = RewriteMouseButtonEvent(press);
    EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & result.flags());
    EXPECT_NE(right_click_flags, right_click_flags & result.flags());
    EXPECT_EQ(ui::EF_RIGHT_MOUSE_BUTTON, result.changed_button_flags());
  }
  {
    ui::MouseEvent release(ui::EventType::kMouseReleased, gfx::Point(),
                           gfx::Point(), ui::EventTimeForNow(),
                           right_click_flags, ui::EF_LEFT_MOUSE_BUTTON);
    ui::EventTestApi test_release(&release);
    test_release.set_source_device_id(kTouchpadId1);
    const ui::MouseEvent result = RewriteMouseButtonEvent(release);
    EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & result.flags());
    EXPECT_NE(right_click_flags, right_click_flags & result.flags());
    EXPECT_EQ(ui::EF_RIGHT_MOUSE_BUTTON, result.changed_button_flags());
  }

  // No (ALT|SEARCH) in first click.
  {
    ui::MouseEvent press(ui::EventType::kMousePressed, gfx::Point(),
                         gfx::Point(), ui::EventTimeForNow(),
                         ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
    ui::EventTestApi test_press(&press);
    test_press.set_source_device_id(kTouchpadId1);
    const ui::MouseEvent result = RewriteMouseButtonEvent(press);
    EXPECT_TRUE(ui::EF_LEFT_MOUSE_BUTTON & result.flags());
    EXPECT_EQ(ui::EF_LEFT_MOUSE_BUTTON, result.changed_button_flags());
  }
  {
    ui::MouseEvent release(ui::EventType::kMouseReleased, gfx::Point(),
                           gfx::Point(), ui::EventTimeForNow(),
                           right_click_flags, ui::EF_LEFT_MOUSE_BUTTON);
    ui::EventTestApi test_release(&release);
    test_release.set_source_device_id(kTouchpadId1);
    const ui::MouseEvent result = RewriteMouseButtonEvent(release);
    EXPECT_EQ(right_click_flags, right_click_flags & result.flags());
    EXPECT_EQ(ui::EF_LEFT_MOUSE_BUTTON, result.changed_button_flags());
  }

  // ALT on different device.
  {
    ui::MouseEvent press(ui::EventType::kMousePressed, gfx::Point(),
                         gfx::Point(), ui::EventTimeForNow(), right_click_flags,
                         ui::EF_LEFT_MOUSE_BUTTON);
    ui::EventTestApi test_press(&press);
    test_press.set_source_device_id(kTouchpadId2);
    const ui::MouseEvent result = RewriteMouseButtonEvent(press);
    EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & result.flags());
    EXPECT_NE(right_click_flags, right_click_flags & result.flags());
    EXPECT_EQ(ui::EF_RIGHT_MOUSE_BUTTON, result.changed_button_flags());
  }
  {
    ui::MouseEvent release(ui::EventType::kMouseReleased, gfx::Point(),
                           gfx::Point(), ui::EventTimeForNow(),
                           right_click_flags, ui::EF_LEFT_MOUSE_BUTTON);
    ui::EventTestApi test_release(&release);
    test_release.set_source_device_id(kTouchpadId1);
    const ui::MouseEvent result = RewriteMouseButtonEvent(release);
    EXPECT_EQ(right_click_flags, right_click_flags & result.flags());
    EXPECT_EQ(ui::EF_LEFT_MOUSE_BUTTON, result.changed_button_flags());
  }
  {
    ui::MouseEvent release(ui::EventType::kMouseReleased, gfx::Point(),
                           gfx::Point(), ui::EventTimeForNow(),
                           right_click_flags, ui::EF_LEFT_MOUSE_BUTTON);
    ui::EventTestApi test_release(&release);
    test_release.set_source_device_id(kTouchpadId2);
    const ui::MouseEvent result = RewriteMouseButtonEvent(release);
    EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & result.flags());
    EXPECT_NE(right_click_flags, right_click_flags & result.flags());
    EXPECT_EQ(ui::EF_RIGHT_MOUSE_BUTTON, result.changed_button_flags());
  }

  // No rewrite for non-touchpad devices.
  {
    ui::MouseEvent press(ui::EventType::kMousePressed, gfx::Point(),
                         gfx::Point(), ui::EventTimeForNow(), right_click_flags,
                         ui::EF_LEFT_MOUSE_BUTTON);
    ui::EventTestApi test_press(&press);
    test_press.set_source_device_id(kMouseId);
    EXPECT_EQ(ui::EventType::kMousePressed, press.type());
    EXPECT_EQ(right_click_flags, press.flags());
    const ui::MouseEvent result = RewriteMouseButtonEvent(press);
    EXPECT_EQ(right_click_flags, right_click_flags & result.flags());
    EXPECT_EQ(ui::EF_LEFT_MOUSE_BUTTON, result.changed_button_flags());
  }
  {
    ui::MouseEvent release(ui::EventType::kMouseReleased, gfx::Point(),
                           gfx::Point(), ui::EventTimeForNow(),
                           right_click_flags, ui::EF_LEFT_MOUSE_BUTTON);
    ui::EventTestApi test_release(&release);
    test_release.set_source_device_id(kMouseId);
    const ui::MouseEvent result = RewriteMouseButtonEvent(release);
    EXPECT_EQ(right_click_flags, right_click_flags & result.flags());
    EXPECT_EQ(ui::EF_LEFT_MOUSE_BUTTON, result.changed_button_flags());
  }

  // Still rewrite to right button, even if the modifier key is already
  // released when the mouse release event happens
  // This is for regressions such as:
  // https://crbug.com/1399284
  // https://crbug.com/1417079
  {
    ui::MouseEvent press(ui::EventType::kMousePressed, gfx::Point(),
                         gfx::Point(), ui::EventTimeForNow(), right_click_flags,
                         ui::EF_LEFT_MOUSE_BUTTON);
    ui::EventTestApi test_press(&press);
    test_press.set_source_device_id(kTouchpadId1);
    // Sanity check.
    EXPECT_EQ(ui::EventType::kMousePressed, press.type());
    EXPECT_EQ(right_click_flags, press.flags());
    const ui::MouseEvent result = RewriteMouseButtonEvent(press);
    EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & result.flags());
    EXPECT_NE(right_click_flags, right_click_flags & result.flags());
    EXPECT_EQ(ui::EF_RIGHT_MOUSE_BUTTON, result.changed_button_flags());
  }
  {
    ui::MouseEvent release(ui::EventType::kMouseReleased, gfx::Point(),
                           gfx::Point(), ui::EventTimeForNow(),
                           ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
    ui::EventTestApi test_release(&release);
    test_release.set_source_device_id(kTouchpadId1);
    const ui::MouseEvent result = RewriteMouseButtonEvent(release);
    EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & result.flags());
    EXPECT_NE(right_click_flags, right_click_flags & result.flags());
    EXPECT_EQ(ui::EF_RIGHT_MOUSE_BUTTON, result.changed_button_flags());
  }
}

TEST_P(EventRewriterTest, DontRewriteIfNotRewritten_AltClickIsRightClick) {
  base::test::ScopedFeatureList scoped_feature_list;
  scoped_feature_list.InitAndDisableFeature(
      features::kAltClickAndSixPackCustomization);
  DontRewriteIfNotRewritten(ui::EF_LEFT_MOUSE_BUTTON | ui::EF_ALT_DOWN);
  EXPECT_EQ(message_center_.NotificationCount(), 0u);
}

TEST_P(EventRewriterTest, DontRewriteIfNotRewritten_AltClickIsRightClick_New) {
  // Enabling the kImprovedKeyboardShortcuts feature does not change alt+click
  // behavior or create a notification.
  base::test::ScopedFeatureList scoped_feature_list;
  scoped_feature_list.InitWithFeatures(
      {}, {features::kAltClickAndSixPackCustomization});
  DontRewriteIfNotRewritten(ui::EF_LEFT_MOUSE_BUTTON | ui::EF_ALT_DOWN);
  EXPECT_EQ(message_center_.NotificationCount(), 0u);
}

TEST_P(EventRewriterTest, DontRewriteIfNotRewritten_SearchClickIsRightClick) {
  base::test::ScopedFeatureList scoped_feature_list;
  scoped_feature_list.InitWithFeatures(
      {features::kUseSearchClickForRightClick},
      {features::kAltClickAndSixPackCustomization});
  DontRewriteIfNotRewritten(ui::EF_LEFT_MOUSE_BUTTON | ui::EF_COMMAND_DOWN);
  EXPECT_EQ(message_center_.NotificationCount(), 0u);
}

TEST_P(EventRewriterTest, DontRewriteIfNotRewritten_AltClickDeprecated) {
  // Pressing search+click with alt+click deprecated works, but does not
  // generate a notification.
  base::test::ScopedFeatureList scoped_feature_list;
  scoped_feature_list.InitWithFeatures(
      {::features::kDeprecateAltClick},
      {features::kAltClickAndSixPackCustomization});
  DontRewriteIfNotRewritten(ui::EF_LEFT_MOUSE_BUTTON | ui::EF_COMMAND_DOWN);
  EXPECT_EQ(message_center_.NotificationCount(), 0u);
}

TEST_P(EventRewriterTest, DeprecatedAltClickGeneratesNotification) {
  base::test::ScopedFeatureList scoped_feature_list;
  scoped_feature_list.InitWithFeatures(
      {::features::kDeprecateAltClick},
      {features::kAltClickAndSixPackCustomization});
  ui::DeviceDataManager* device_data_manager =
      ui::DeviceDataManager::GetInstance();
  std::vector<ui::TouchpadDevice> touchpad_devices(1);
  constexpr int kTouchpadId1 = 10;
  touchpad_devices[0].id = kTouchpadId1;
  static_cast<ui::DeviceHotplugEventObserver*>(device_data_manager)
      ->OnTouchpadDevicesUpdated(touchpad_devices);
  std::vector<ui::InputDevice> mouse_devices(1);
  constexpr int kMouseId = 12;
  touchpad_devices[0].id = kMouseId;
  static_cast<ui::DeviceHotplugEventObserver*>(device_data_manager)
      ->OnMouseDevicesUpdated(mouse_devices);

  const int deprecated_flags = ui::EF_LEFT_MOUSE_BUTTON | ui::EF_ALT_DOWN;

  // Alt + Left click => No rewrite.
  {
    ui::MouseEvent press(ui::EventType::kMousePressed, gfx::Point(),
                         gfx::Point(), ui::EventTimeForNow(), deprecated_flags,
                         ui::EF_LEFT_MOUSE_BUTTON);
    ui::EventTestApi test_press(&press);
    test_press.set_source_device_id(kTouchpadId1);
    // Sanity check.
    EXPECT_EQ(ui::EventType::kMousePressed, press.type());
    EXPECT_EQ(deprecated_flags, press.flags());
    const ui::MouseEvent result = RewriteMouseButtonEvent(press);

    // No rewrite occurred.
    EXPECT_EQ(deprecated_flags, deprecated_flags & result.flags());
    EXPECT_EQ(ui::EF_LEFT_MOUSE_BUTTON, result.changed_button_flags());

    // Expect a deprecation notification.
    EXPECT_EQ(message_center_.NotificationCount(), 1u);
    ClearNotifications();
  }
  {
    ui::MouseEvent release(ui::EventType::kMouseReleased, gfx::Point(),
                           gfx::Point(), ui::EventTimeForNow(),
                           deprecated_flags, ui::EF_LEFT_MOUSE_BUTTON);
    ui::EventTestApi test_release(&release);
    test_release.set_source_device_id(kTouchpadId1);
    const ui::MouseEvent result = RewriteMouseButtonEvent(release);

    // No rewrite occurred.
    EXPECT_EQ(deprecated_flags, deprecated_flags & result.flags());
    EXPECT_EQ(ui::EF_LEFT_MOUSE_BUTTON, result.changed_button_flags());

    // Don't expect a new notification on release.
    EXPECT_EQ(message_center_.NotificationCount(), 0u);
  }

  // No rewrite or notification for non-touchpad devices.
  {
    ui::MouseEvent press(ui::EventType::kMousePressed, gfx::Point(),
                         gfx::Point(), ui::EventTimeForNow(), deprecated_flags,
                         ui::EF_LEFT_MOUSE_BUTTON);
    ui::EventTestApi test_press(&press);
    test_press.set_source_device_id(kMouseId);
    EXPECT_EQ(ui::EventType::kMousePressed, press.type());
    EXPECT_EQ(deprecated_flags, press.flags());
    const ui::MouseEvent result = RewriteMouseButtonEvent(press);
    EXPECT_EQ(deprecated_flags, deprecated_flags & result.flags());
    EXPECT_EQ(ui::EF_LEFT_MOUSE_BUTTON, result.changed_button_flags());

    // No notification expected for this case.
    EXPECT_EQ(message_center_.NotificationCount(), 0u);
  }
  {
    ui::MouseEvent release(ui::EventType::kMouseReleased, gfx::Point(),
                           gfx::Point(), ui::EventTimeForNow(),
                           deprecated_flags, ui::EF_LEFT_MOUSE_BUTTON);
    ui::EventTestApi test_release(&release);
    test_release.set_source_device_id(kMouseId);
    const ui::MouseEvent result = RewriteMouseButtonEvent(release);
    EXPECT_EQ(deprecated_flags, deprecated_flags & result.flags());
    EXPECT_EQ(ui::EF_LEFT_MOUSE_BUTTON, result.changed_button_flags());

    // No notification expected for this case.
    EXPECT_EQ(message_center_.NotificationCount(), 0u);
  }
}

TEST_P(EventRewriterTest, StickyKeyEventDispatchImpl) {
  Shell::Get()->sticky_keys_controller()->Enable(true);
  // Test the actual key event dispatch implementation.
  {
    auto events = SendKeyEvents(KeyLControl::Typed());
    ASSERT_EQ(1u, events.size());
    EXPECT_EQ(KeyLControl::Pressed(), events[0]);
  }

  // Test key press event is correctly modified and modifier release
  // event is sent.
  {
    auto events = SendKeyEvent(KeyC::Pressed());
    ASSERT_EQ(2u, events.size());
    EXPECT_EQ(KeyC::Pressed(ui::EF_CONTROL_DOWN), events[0]);
    EXPECT_EQ(KeyLControl::Released(), events[1]);
  }

  // Test key release event is not modified.
  {
    auto events = SendKeyEvent(KeyC::Released());
    ASSERT_EQ(1u, events.size());
    EXPECT_EQ(KeyC::Released(), events[0]);
  }
}

TEST_P(EventRewriterTest, MouseEventDispatchImpl) {
  Shell::Get()->sticky_keys_controller()->Enable(true);
  SendKeyEvents(KeyLControl::Typed());

  // Test mouse press event is correctly modified.
  gfx::Point location(0, 0);
  ui::MouseEvent press(ui::EventType::kMousePressed, location, location,
                       ui::EventTimeForNow(), ui::EF_LEFT_MOUSE_BUTTON,
                       ui::EF_LEFT_MOUSE_BUTTON);
  ui::EventDispatchDetails details = source().Send(&press);
  ASSERT_FALSE(details.dispatcher_destroyed);
  {
    auto events = TakeEvents();
    ASSERT_EQ(1u, events.size());
    EXPECT_EQ(ui::EventType::kMousePressed, events[0]->type());
    EXPECT_TRUE(events[0]->flags() & ui::EF_CONTROL_DOWN);
  }

  // Test mouse release event is correctly modified and modifier release
  // event is sent. The mouse event should have the correct DIP location.
  ui::MouseEvent release(ui::EventType::kMouseReleased, location, location,
                         ui::EventTimeForNow(), ui::EF_LEFT_MOUSE_BUTTON,
                         ui::EF_LEFT_MOUSE_BUTTON);
  details = source().Send(&release);
  ASSERT_FALSE(details.dispatcher_destroyed);
  {
    auto events = TakeEvents();
    ASSERT_EQ(2u, events.size());
    EXPECT_EQ(ui::EventType::kMouseReleased, events[0]->type());
    EXPECT_TRUE(events[0]->flags() & ui::EF_CONTROL_DOWN);

    ASSERT_EQ(ui::EventType::kKeyReleased, events[1]->type());
    EXPECT_EQ(ui::VKEY_CONTROL, events[1]->AsKeyEvent()->key_code());
  }
}

TEST_P(EventRewriterTest, MouseWheelEventDispatchImpl) {
  Shell::Get()->sticky_keys_controller()->Enable(true);
  // Test positive mouse wheel event is correctly modified and modifier release
  // event is sent.
  SendKeyEvents(KeyLControl::Typed());

  gfx::Point location(0, 0);
  ui::MouseWheelEvent positive(
      gfx::Vector2d(0, ui::MouseWheelEvent::kWheelDelta), location, location,
      ui::EventTimeForNow(), ui::EF_LEFT_MOUSE_BUTTON,
      ui::EF_LEFT_MOUSE_BUTTON);
  ui::EventDispatchDetails details = source().Send(&positive);
  ASSERT_FALSE(details.dispatcher_destroyed);
  {
    auto events = TakeEvents();
    ASSERT_EQ(2u, events.size());
    EXPECT_TRUE(events[0]->IsMouseWheelEvent());
    EXPECT_TRUE(events[0]->flags() & ui::EF_CONTROL_DOWN);

    ASSERT_EQ(ui::EventType::kKeyReleased, events[1]->type());
    EXPECT_EQ(ui::VKEY_CONTROL, events[1]->AsKeyEvent()->key_code());
  }

  // Test negative mouse wheel event is correctly modified and modifier release
  // event is sent.
  SendKeyEvents({KeyLControl::Pressed(), KeyLControl::Released()});

  ui::MouseWheelEvent negative(
      gfx::Vector2d(0, -ui::MouseWheelEvent::kWheelDelta), location, location,
      ui::EventTimeForNow(), ui::EF_LEFT_MOUSE_BUTTON,
      ui::EF_LEFT_MOUSE_BUTTON);
  details = source().Send(&negative);
  ASSERT_FALSE(details.dispatcher_destroyed);
  {
    auto events = TakeEvents();
    ASSERT_EQ(2u, events.size());
    EXPECT_TRUE(events[0]->IsMouseWheelEvent());
    EXPECT_TRUE(events[0]->flags() & ui::EF_CONTROL_DOWN);

    ASSERT_EQ(ui::EventType::kKeyReleased, events[1]->type());
    EXPECT_EQ(ui::VKEY_CONTROL, events[1]->AsKeyEvent()->key_code());
  }
}

// Tests that if modifier keys are remapped, the flags of a mouse wheel event
// will be rewritten properly.
TEST_P(EventRewriterTest, MouseWheelEventModifiersRewritten) {
  Preferences::RegisterProfilePrefs(prefs()->registry());

  // For EF_CONTROL_DOWN modifier.
  SendKeyEvent(KeyLControl::Pressed());

  // Generate a mouse wheel event that has a CONTROL_DOWN modifier flag and
  // expect that no rewriting happens as no modifier remapping is active.
  gfx::Point location(0, 0);
  ui::MouseWheelEvent positive(
      gfx::Vector2d(0, ui::MouseWheelEvent::kWheelDelta), location, location,
      ui::EventTimeForNow(), ui::EF_LEFT_MOUSE_BUTTON | ui::EF_CONTROL_DOWN,
      ui::EF_LEFT_MOUSE_BUTTON);
  ui::EventDispatchDetails details = source().Send(&positive);
  ASSERT_FALSE(details.dispatcher_destroyed);
  {
    auto events = TakeEvents();
    ASSERT_EQ(1u, events.size());
    EXPECT_TRUE(events[0]->IsMouseWheelEvent());
    EXPECT_TRUE(events[0]->flags() & ui::EF_CONTROL_DOWN);
  }

  // Remap Control to Alt.
  IntegerPrefMember control;
  InitModifierKeyPref(&control, ::prefs::kLanguageRemapControlKeyTo,
                      ui::mojom::ModifierKey::kControl,
                      ui::mojom::ModifierKey::kAlt);

  // Sends the same events once again and expect that it will be rewritten to
  // ALT_DOWN in older implementation, or not rewritten (as Control is held)
  // in the new implementation.
  details = source().Send(&positive);
  ASSERT_FALSE(details.dispatcher_destroyed);
  {
    auto events = TakeEvents();
    ASSERT_EQ(1u, events.size());
    EXPECT_TRUE(events[0]->IsMouseWheelEvent());
    if (ash::features::IsKeyboardRewriterFixEnabled()) {
      EXPECT_TRUE(events[0]->flags() & ui::EF_CONTROL_DOWN);
      EXPECT_FALSE(events[0]->flags() & ui::EF_ALT_DOWN);
    } else {
      EXPECT_FALSE(events[0]->flags() & ui::EF_CONTROL_DOWN);
      EXPECT_TRUE(events[0]->flags() & ui::EF_ALT_DOWN);
    }
  }
}

TEST_P(EventRewriterTest, MouseEventMaintainNativeEvent) {
  if (!features::IsKeyboardRewriterFixEnabled()) {
    GTEST_SKIP() << "Test is only valid with keyboard rewriter fix enabled";
  }

  Preferences::RegisterProfilePrefs(prefs()->registry());

  gfx::Point location(0, 0);
  ui::MouseEvent native_event(ui::EventType::kMouseMoved, location, location,
                              /*time_stamp=*/{}, ui::EF_CONTROL_DOWN,
                              ui::EF_NONE);
  ui::MouseEvent mouse_event(&native_event);
  // Remap Control to Alt.
  IntegerPrefMember control;
  InitModifierKeyPref(&control, ::prefs::kLanguageRemapControlKeyTo,
                      ui::mojom::ModifierKey::kControl,
                      ui::mojom::ModifierKey::kAlt);

  SendKeyEvent(KeyLControl::Pressed());

  // Sends the same events once again and expect that it will be rewritten to
  // ALT_DOWN in older implementation, or not rewritten (as Control is held)
  // in the new implementation.
  ui::EventDispatchDetails details = source().Send(&mouse_event);
  ASSERT_FALSE(details.dispatcher_destroyed);
  {
    auto events = TakeEvents();
    ASSERT_EQ(1u, events.size());
    EXPECT_TRUE(events[0]->IsMouseEvent());
    EXPECT_FALSE(events[0]->flags() & ui::EF_CONTROL_DOWN);
    EXPECT_TRUE(events[0]->flags() & ui::EF_ALT_DOWN);
    EXPECT_TRUE(events[0]->HasNativeEvent());
  }
}

// Tests edge cases of key event rewriting (see https://crbug.com/913209).
TEST_P(EventRewriterTest, KeyEventRewritingEdgeCases) {
  Preferences::RegisterProfilePrefs(prefs()->registry());

  base::test::ScopedFeatureList feature_list;
  feature_list.InitAndDisableFeature(
      features::kAltClickAndSixPackCustomization);

  // Edge case 1: Press the Launcher button first. Then press the Up Arrow
  // button.
  {
    auto events = SendKeyEvents(
        {KeyLMeta::Pressed(), KeyArrowUp::Pressed(ui::EF_COMMAND_DOWN)});
    EXPECT_EQ(2u, events.size());
  }

  // When releasing the Launcher button, the rewritten event should be released
  // as well.
  if (features::IsKeyboardRewriterFixEnabled()) {
    EXPECT_EQ(std::vector({KeyLMeta::Released()}),
              SendKeyEvent(KeyLMeta::Released()));
    EXPECT_EQ(std::vector({KeyPageUp::Released(), KeyArrowUp::Pressed()}),
              SendKeyEvent(KeyArrowUp::Pressed()));
  } else {
    auto events = SendKeyEvent(KeyLMeta::Released());
    ASSERT_EQ(2u, events.size());
    EXPECT_EQ(KeyLMeta::Released(), events[0]);
    EXPECT_EQ(KeyPageUp::Released(), events[1]);
  }

  // Edge case 2: Press the Up Arrow button first. Then press the Launch button.
  {
    auto events = SendKeyEvents({KeyArrowUp::Pressed(), KeyLMeta::Pressed()});
    EXPECT_EQ(2u, events.size());
  }

  // When releasing the Up Arrow button, the rewritten event should be blocked.
  {
    auto events = SendKeyEvent(KeyArrowUp::Released(ui::EF_COMMAND_DOWN));
    ASSERT_EQ(1u, events.size());
    EXPECT_EQ(KeyArrowUp::Released(ui::EF_COMMAND_DOWN), events[0]);
  }
}

TEST_P(EventRewriterTest, ScrollEventDispatchImpl) {
  Shell::Get()->sticky_keys_controller()->Enable(true);
  // Test scroll event is correctly modified.
  SendKeyEvents(KeyLControl::Typed());

  gfx::PointF location(0, 0);
  ui::ScrollEvent scroll(ui::EventType::kScroll, location, location,
                         ui::EventTimeForNow(), 0 /* flag */, 0 /* x_offset */,
                         1 /* y_offset */, 0 /* x_offset_ordinal */,
                         1 /* y_offset_ordinal */, 2 /* finger */);
  ui::EventDispatchDetails details = source().Send(&scroll);
  ASSERT_FALSE(details.dispatcher_destroyed);
  {
    auto events = TakeEvents();
    ASSERT_EQ(1u, events.size());
    EXPECT_TRUE(events[0]->IsScrollEvent());
    EXPECT_TRUE(events[0]->flags() & ui::EF_CONTROL_DOWN);
  }

  // Test FLING_START event deactivates the sticky key, but is modified.
  ui::ScrollEvent fling_start(
      ui::EventType::kScrollFlingStart, location, location,
      ui::EventTimeForNow(), 0 /* flag */, 0 /* x_offset */, 0 /* y_offset */,
      0 /* x_offset_ordinal */, 0 /* y_offset_ordinal */, 2 /* finger */);
  details = source().Send(&fling_start);
  {
    auto events = TakeEvents();
    ASSERT_EQ(2u, events.size());
    EXPECT_TRUE(events[0]->IsScrollEvent());
    EXPECT_TRUE(events[0]->flags() & ui::EF_CONTROL_DOWN);

    ASSERT_EQ(ui::EventType::kKeyReleased, events[1]->type());
    EXPECT_EQ(ui::VKEY_CONTROL, events[1]->AsKeyEvent()->key_code());
  }

  // Test scroll direction change causes that modifier release event is sent.
  SendKeyEvents(KeyLControl::Typed());

  details = source().Send(&scroll);
  ASSERT_FALSE(details.dispatcher_destroyed);
  std::ignore = TakeEvents();

  ui::ScrollEvent scroll2(ui::EventType::kScroll, location, location,
                          ui::EventTimeForNow(), 0 /* flag */, 0 /* x_offset */,
                          -1 /* y_offset */, 0 /* x_offset_ordinal */,
                          -1 /* y_offset_ordinal */, 2 /* finger */);
  details = source().Send(&scroll2);
  ASSERT_FALSE(details.dispatcher_destroyed);
  {
    auto events = TakeEvents();
    ASSERT_EQ(2u, events.size());
    EXPECT_TRUE(events[0]->IsScrollEvent());
    EXPECT_FALSE(events[0]->flags() & ui::EF_CONTROL_DOWN);

    ASSERT_EQ(ui::EventType::kKeyReleased, events[1]->type());
    EXPECT_EQ(ui::VKEY_CONTROL, events[1]->AsKeyEvent()->key_code());
  }
}

#if BUILDFLAG(GOOGLE_CHROME_BRANDING)
TEST_P(EventRewriterTest, RemapHangulOnCros1p) {
  Preferences::RegisterProfilePrefs(prefs()->registry());
  IntegerPrefMember alt;
  InitModifierKeyPref(&alt, ::prefs::kLanguageRemapAltKeyTo,
                      ui::mojom::ModifierKey::kAlt,
                      ui::mojom::ModifierKey::kAlt);

  scoped_refptr<input_method::MockInputMethodManagerImpl::State> state =
      base::MakeRefCounted<input_method::MockInputMethodManagerImpl::State>(
          input_method_manager_mock_);
  input_method_manager_mock_->SetState(state);

  for (const auto& keyboard : kAllKeyboardVariants) {
    SCOPED_TRACE(keyboard.name);
    SetUpKeyboard(keyboard);
    state->current_input_method_id =
        base::StrCat({kCros1pInputMethodIdPrefix, "ko-t-i0-und"});
    EXPECT_EQ(KeyHangulMode::Typed(), RunRewriter(KeyHangulMode::Typed()));
    EXPECT_EQ(KeyLAlt::Typed(), RunRewriter(KeyLAlt::Typed()));
    EXPECT_EQ(KeyRAlt::Typed(), RunRewriter(KeyRAlt::Typed()));

    state->current_input_method_id =
        base::StrCat({kCros1pInputMethodIdPrefix, "xkb:us::eng"});
    EXPECT_EQ(KeyRAlt::Typed(), RunRewriter(KeyHangulMode::Typed()));
    EXPECT_EQ(KeyLAlt::Typed(), RunRewriter(KeyLAlt::Typed()));
    EXPECT_EQ(KeyRAlt::Typed(), RunRewriter(KeyRAlt::Typed()));
  }
}
#endif

class EventRewriterInputSettingsSplitDisabledTest : public EventRewriterTest {
 public:
  void SetUp() override {
    settings_split_disable_feature_list_.InitAndDisableFeature(
        features::kInputDeviceSettingsSplit);
    EventRewriterTest::SetUp();
  }

  void TearDown() override {
    EventRewriterTest::TearDown();
    settings_split_disable_feature_list_.Reset();
  }

 private:
  base::test::ScopedFeatureList settings_split_disable_feature_list_;
};

INSTANTIATE_TEST_SUITE_P(All,
                         EventRewriterInputSettingsSplitDisabledTest,
                         testing::Combine(testing::Bool(), testing::Bool()));

TEST_P(EventRewriterInputSettingsSplitDisabledTest,
       TestRewriteCommandToControl) {
  // First, test non Apple keyboards, they should all behave the same.
  for (const auto& keyboard : kNonAppleKeyboardVariants) {
    SCOPED_TRACE(keyboard.name);
    SetUpKeyboard(keyboard);

    // VKEY_A, Alt modifier.
    EXPECT_EQ(KeyA::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyA::Typed(), ui::EF_ALT_DOWN));

    // VKEY_A, Win modifier.
    EXPECT_EQ(KeyA::Typed(ui::EF_COMMAND_DOWN),
              RunRewriter(KeyA::Typed(), ui::EF_COMMAND_DOWN));

    // VKEY_A, Alt+Win modifier.
    EXPECT_EQ(
        KeyA::Typed(ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN),
        RunRewriter(KeyA::Typed(), ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN));

    // VKEY_LWIN (left Windows key), Alt modifier.
    EXPECT_EQ(KeyLMeta::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyLMeta::Typed(), ui::EF_ALT_DOWN));

    // VKEY_RWIN (right Windows key), Alt modifier.
    EXPECT_EQ(KeyRMeta::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyRMeta::Typed(), ui::EF_ALT_DOWN));
  }

  // Simulate the default initialization of the Apple Command key remap pref to
  // Ctrl.
  Preferences::RegisterProfilePrefs(prefs()->registry());
  {
    SCOPED_TRACE(kExternalAppleKeyboard.name);
    SetUpKeyboard(kExternalAppleKeyboard);

    // VKEY_A, Alt modifier.
    EXPECT_EQ(KeyA::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyA::Typed(), ui::EF_ALT_DOWN));

    // VKEY_A, Win modifier.
    EXPECT_EQ(KeyA::Typed(ui::EF_CONTROL_DOWN),
              RunRewriter(KeyA::Typed(), ui::EF_COMMAND_DOWN));

    // VKEY_A, Alt+Win modifier.
    EXPECT_EQ(
        KeyA::Typed(ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN),
        RunRewriter(KeyA::Typed(), ui::EF_COMMAND_DOWN | ui::EF_ALT_DOWN));

    // VKEY_LWIN (left Windows key), Alt modifier.
    EXPECT_EQ(KeyLControl::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyLMeta::Typed(), ui::EF_ALT_DOWN));

    // VKEY_RWIN (right Windows key), Alt modifier.
    EXPECT_EQ(KeyRControl::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyRMeta::Typed(), ui::EF_ALT_DOWN));
  }

  // Now simulate the user remapped the Command key back to Search.
  IntegerPrefMember command;
  InitModifierKeyPref(&command, ::prefs::kLanguageRemapExternalCommandKeyTo,
                      ui::mojom::ModifierKey::kMeta,
                      ui::mojom::ModifierKey::kMeta);
  {
    SCOPED_TRACE(kExternalAppleKeyboard.name);
    SetUpKeyboard(kExternalAppleKeyboard);

    // VKEY_A, Alt modifier.
    EXPECT_EQ(KeyA::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyA::Typed(), ui::EF_ALT_DOWN));

    // VKEY_A, Win modifier.
    EXPECT_EQ(KeyA::Typed(ui::EF_COMMAND_DOWN),
              RunRewriter(KeyA::Typed(), ui::EF_COMMAND_DOWN));

    // VKEY_A, Alt+Win modifier.
    EXPECT_EQ(
        KeyA::Typed(ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN),
        RunRewriter(KeyA::Typed(), ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN));

    // VKEY_LWIN (left Windows key), Alt modifier.
    EXPECT_EQ(KeyLMeta::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyLMeta::Typed(), ui::EF_ALT_DOWN));

    // VKEY_RWIN (right Windows key), Alt modifier.
    EXPECT_EQ(KeyRMeta::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyRMeta::Typed(), ui::EF_ALT_DOWN));
  }
}

TEST_P(EventRewriterInputSettingsSplitDisabledTest,
       TestRewriteExternalMetaKey) {
  // Simulate the default initialization of the Meta key on external keyboards
  // remap pref to Search.
  Preferences::RegisterProfilePrefs(prefs()->registry());

  // By default, the Meta key on all keyboards, internal, external Chrome OS
  // branded keyboards, and Generic keyboards should produce Search.
  for (const auto& keyboard : kNonAppleKeyboardVariants) {
    SCOPED_TRACE(keyboard.name);
    SetUpKeyboard(keyboard);

    // VKEY_A, Win modifier.
    EXPECT_EQ(KeyA::Typed(ui::EF_COMMAND_DOWN),
              RunRewriter(KeyA::Typed(), ui::EF_COMMAND_DOWN));

    // VKEY_A, Alt+Win modifier.
    EXPECT_EQ(
        KeyA::Typed(ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN),
        RunRewriter(KeyA::Typed(), ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN));

    // VKEY_LWIN (left Windows key), Alt modifier.
    EXPECT_EQ(KeyLMeta::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyLMeta::Typed(), ui::EF_ALT_DOWN));

    // VKEY_RWIN (right Windows key), Alt modifier.
    EXPECT_EQ(KeyRMeta::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyRMeta::Typed(), ui::EF_ALT_DOWN));
  }

  // Both preferences for Search on Chrome keyboards, and external Meta on
  // generic external keyboards are independent, even if one or both are
  // modified.

  // Remap Chrome OS Search to Ctrl.
  IntegerPrefMember internal_search;
  InitModifierKeyPref(&internal_search, ::prefs::kLanguageRemapSearchKeyTo,
                      ui::mojom::ModifierKey::kMeta,
                      ui::mojom::ModifierKey::kControl);

  // Remap external Meta to Alt.
  IntegerPrefMember meta;
  InitModifierKeyPref(&meta, ::prefs::kLanguageRemapExternalMetaKeyTo,
                      ui::mojom::ModifierKey::kMeta,
                      ui::mojom::ModifierKey::kAlt);
  for (const auto& keyboard : kChromeKeyboardVariants) {
    SCOPED_TRACE(keyboard.name);
    SetUpKeyboard(keyboard);

    // VKEY_A, Win modifier.
    EXPECT_EQ(KeyA::Typed(ui::EF_CONTROL_DOWN),
              RunRewriter(KeyA::Typed(), ui::EF_COMMAND_DOWN));

    // VKEY_A, Alt+Win modifier.
    EXPECT_EQ(
        KeyA::Typed(ui::EF_ALT_DOWN | ui::EF_CONTROL_DOWN),
        RunRewriter(KeyA::Typed(), ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN));

    // VKEY_LWIN (left Windows key), Alt modifier.
    EXPECT_EQ(KeyLControl::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyLMeta::Typed(), ui::EF_ALT_DOWN));

    // VKEY_RWIN (right Windows key), Alt modifier.
    EXPECT_EQ(KeyRControl::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyRMeta::Typed(), ui::EF_ALT_DOWN));
  }

  SetUpKeyboard(kExternalGenericKeyboard);

  // VKEY_A, Win modifier.
  EXPECT_EQ(KeyA::Typed(ui::EF_ALT_DOWN),
            RunRewriter(KeyA::Typed(), ui::EF_COMMAND_DOWN));

  // VKEY_A, Alt+Win modifier.
  EXPECT_EQ(KeyA::Typed(ui::EF_ALT_DOWN),
            RunRewriter(KeyA::Typed(), ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN));

  if (ash::features::IsKeyboardRewriterFixEnabled()) {
    // VKEY_LWIN (left Windows key), Alt modifier.
    EXPECT_EQ(KeyLAlt::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyLMeta::Typed(), ui::EF_ALT_DOWN));
    // VKEY_RWIN (right Windows key), Alt modifier.
    EXPECT_EQ(KeyRAlt::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyRMeta::Typed(), ui::EF_ALT_DOWN));
  } else {
    // VKEY_LWIN (left Windows key), Alt modifier.
    // Older implementation has an issue that release event is not dispatched.
    EXPECT_EQ(std::vector({KeyLAlt::Pressed()}),
              RunRewriter(KeyLMeta::Typed(), ui::EF_ALT_DOWN));
    // VKEY_RWIN (right Windows key), Alt modifier.
    EXPECT_EQ(KeyRAlt::Typed(),
              RunRewriter(KeyRMeta::Typed(), ui::EF_ALT_DOWN));
  }
}

// For crbug.com/133896.
TEST_P(EventRewriterInputSettingsSplitDisabledTest,
       TestRewriteCommandToControlWithControlRemapped) {
  // Remap Control to Alt.
  Preferences::RegisterProfilePrefs(prefs()->registry());
  IntegerPrefMember control;
  InitModifierKeyPref(&control, ::prefs::kLanguageRemapControlKeyTo,
                      ui::mojom::ModifierKey::kControl,
                      ui::mojom::ModifierKey::kAlt);

  for (const auto& keyboard : kNonAppleKeyboardVariants) {
    SCOPED_TRACE(keyboard.name);
    SetUpKeyboard(keyboard);

    EXPECT_EQ(KeyLAlt::Typed(), RunRewriter(KeyLControl::Typed()));
  }

  // Now verify that remapping does not affect Apple keyboard.
  SetUpKeyboard(kExternalAppleKeyboard);

  // VKEY_LWIN (left Command key) with  Alt modifier. The remapped Command
  // key should never be re-remapped to Alt.
  EXPECT_EQ(KeyLControl::Typed(ui::EF_ALT_DOWN),
            RunRewriter(KeyLMeta::Typed(), ui::EF_ALT_DOWN));

  // VKEY_RWIN (right Command key) with  Alt modifier. The remapped Command
  // key should never be re-remapped to Alt.
  EXPECT_EQ(KeyRControl::Typed(ui::EF_ALT_DOWN),
            RunRewriter(KeyRMeta::Typed(), ui::EF_ALT_DOWN));
}

class StickyKeysOverlayTest
    : public EventRewriterTestBase,
      public testing::WithParamInterface<std::tuple<bool, bool>> {
 public:
  StickyKeysOverlayTest() : overlay_(nullptr) {}

  ~StickyKeysOverlayTest() override = default;

  void SetUp() override {
    auto [enable_keyboard_rewriter_fix, enable_modifier_split] = GetParam();
    if (enable_keyboard_rewriter_fix) {
      fix_feature_list_.InitAndEnableFeature(
          ash::features::kEnableKeyboardRewriterFix);
    } else {
      fix_feature_list_.InitAndDisableFeature(
          ash::features::kEnableKeyboardRewriterFix);
    }

    if (enable_modifier_split) {
      modifier_split_feature_list_.InitAndEnableFeature(
          ash::features::kModifierSplit);
    } else {
      modifier_split_feature_list_.InitAndDisableFeature(
          ash::features::kModifierSplit);
    }

    EventRewriterTestBase::SetUp();
    auto* sticky_keys_controller = Shell::Get()->sticky_keys_controller();
    sticky_keys_controller->Enable(true);
    overlay_ = sticky_keys_controller->GetOverlayForTest();
    ASSERT_TRUE(overlay_);
  }

  raw_ptr<StickyKeysOverlay, DanglingUntriaged> overlay_;

 private:
  base::test::ScopedFeatureList fix_feature_list_;
  base::test::ScopedFeatureList modifier_split_feature_list_;
};

INSTANTIATE_TEST_SUITE_P(All,
                         StickyKeysOverlayTest,
                         testing::Combine(testing::Bool(), testing::Bool()));

TEST_P(StickyKeysOverlayTest, OneModifierEnabled) {
  EXPECT_FALSE(overlay_->is_visible());
  EXPECT_EQ(STICKY_KEY_STATE_DISABLED,
            overlay_->GetModifierKeyState(ui::EF_CONTROL_DOWN));

  // Pressing modifier key should show overlay.
  SendKeyEvents(KeyLControl::Typed());
  EXPECT_TRUE(overlay_->is_visible());
  EXPECT_EQ(STICKY_KEY_STATE_ENABLED,
            overlay_->GetModifierKeyState(ui::EF_CONTROL_DOWN));

  // Pressing a normal key should hide overlay.
  SendKeyEvents(KeyT::Typed());
  EXPECT_FALSE(overlay_->is_visible());
  EXPECT_EQ(STICKY_KEY_STATE_DISABLED,
            overlay_->GetModifierKeyState(ui::EF_CONTROL_DOWN));
}

TEST_P(StickyKeysOverlayTest, TwoModifiersEnabled) {
  EXPECT_FALSE(overlay_->is_visible());
  EXPECT_EQ(STICKY_KEY_STATE_DISABLED,
            overlay_->GetModifierKeyState(ui::EF_CONTROL_DOWN));
  EXPECT_EQ(STICKY_KEY_STATE_DISABLED,
            overlay_->GetModifierKeyState(ui::EF_SHIFT_DOWN));

  // Pressing two modifiers should show overlay.
  SendKeyEvents(KeyLShift::Typed());
  SendKeyEvents(KeyLControl::Typed());
  EXPECT_TRUE(overlay_->is_visible());
  EXPECT_EQ(STICKY_KEY_STATE_ENABLED,
            overlay_->GetModifierKeyState(ui::EF_SHIFT_DOWN));
  EXPECT_EQ(STICKY_KEY_STATE_ENABLED,
            overlay_->GetModifierKeyState(ui::EF_CONTROL_DOWN));

  // Pressing a normal key should hide overlay.
  SendKeyEvents(KeyN::Typed());
  EXPECT_FALSE(overlay_->is_visible());
  EXPECT_EQ(STICKY_KEY_STATE_DISABLED,
            overlay_->GetModifierKeyState(ui::EF_CONTROL_DOWN));
  EXPECT_EQ(STICKY_KEY_STATE_DISABLED,
            overlay_->GetModifierKeyState(ui::EF_SHIFT_DOWN));
}

TEST_P(StickyKeysOverlayTest, LockedModifier) {
  EXPECT_FALSE(overlay_->is_visible());
  EXPECT_EQ(STICKY_KEY_STATE_DISABLED,
            overlay_->GetModifierKeyState(ui::EF_ALT_DOWN));

  // Pressing a modifier key twice should lock modifier and show overlay.
  SendKeyEvents(KeyLAlt::Typed());
  SendKeyEvents(KeyLAlt::Typed());
  EXPECT_TRUE(overlay_->is_visible());
  EXPECT_EQ(STICKY_KEY_STATE_LOCKED,
            overlay_->GetModifierKeyState(ui::EF_ALT_DOWN));

  // Pressing a normal key should not hide overlay.
  SendKeyEvents(KeyD::Typed());
  EXPECT_TRUE(overlay_->is_visible());
  EXPECT_EQ(STICKY_KEY_STATE_LOCKED,
            overlay_->GetModifierKeyState(ui::EF_ALT_DOWN));
}

TEST_P(StickyKeysOverlayTest, LockedAndNormalModifier) {
  EXPECT_FALSE(overlay_->is_visible());
  EXPECT_EQ(STICKY_KEY_STATE_DISABLED,
            overlay_->GetModifierKeyState(ui::EF_CONTROL_DOWN));
  EXPECT_EQ(STICKY_KEY_STATE_DISABLED,
            overlay_->GetModifierKeyState(ui::EF_SHIFT_DOWN));

  // Pressing a modifier key twice should lock modifier and show overlay.
  SendKeyEvents(KeyLControl::Typed());
  SendKeyEvents(KeyLControl::Typed());
  EXPECT_TRUE(overlay_->is_visible());
  EXPECT_EQ(STICKY_KEY_STATE_LOCKED,
            overlay_->GetModifierKeyState(ui::EF_CONTROL_DOWN));

  // Pressing another modifier key should still show overlay.
  SendKeyEvents(KeyLShift::Typed());
  EXPECT_TRUE(overlay_->is_visible());
  EXPECT_EQ(STICKY_KEY_STATE_LOCKED,
            overlay_->GetModifierKeyState(ui::EF_CONTROL_DOWN));
  EXPECT_EQ(STICKY_KEY_STATE_ENABLED,
            overlay_->GetModifierKeyState(ui::EF_SHIFT_DOWN));

  // Pressing a normal key should not hide overlay but disable normal modifier.
  SendKeyEvents(KeyD::Typed());
  EXPECT_TRUE(overlay_->is_visible());
  EXPECT_EQ(STICKY_KEY_STATE_LOCKED,
            overlay_->GetModifierKeyState(ui::EF_CONTROL_DOWN));
  EXPECT_EQ(STICKY_KEY_STATE_DISABLED,
            overlay_->GetModifierKeyState(ui::EF_SHIFT_DOWN));
}

TEST_P(StickyKeysOverlayTest, ModifiersDisabled) {
  EXPECT_FALSE(overlay_->is_visible());
  EXPECT_EQ(STICKY_KEY_STATE_DISABLED,
            overlay_->GetModifierKeyState(ui::EF_CONTROL_DOWN));
  EXPECT_EQ(STICKY_KEY_STATE_DISABLED,
            overlay_->GetModifierKeyState(ui::EF_SHIFT_DOWN));
  EXPECT_EQ(STICKY_KEY_STATE_DISABLED,
            overlay_->GetModifierKeyState(ui::EF_ALT_DOWN));
  EXPECT_EQ(STICKY_KEY_STATE_DISABLED,
            overlay_->GetModifierKeyState(ui::EF_COMMAND_DOWN));

  // Enable modifiers.
  SendKeyEvents(KeyLControl::Typed());
  SendKeyEvents(KeyLShift::Typed());
  SendKeyEvents(KeyLShift::Typed());
  SendKeyEvents(KeyLAlt::Typed());
  SendKeyEvents(KeyLMeta::Typed());
  SendKeyEvents(KeyLMeta::Typed());

  EXPECT_TRUE(overlay_->is_visible());
  EXPECT_EQ(STICKY_KEY_STATE_ENABLED,
            overlay_->GetModifierKeyState(ui::EF_CONTROL_DOWN));
  EXPECT_EQ(STICKY_KEY_STATE_LOCKED,
            overlay_->GetModifierKeyState(ui::EF_SHIFT_DOWN));
  EXPECT_EQ(STICKY_KEY_STATE_ENABLED,
            overlay_->GetModifierKeyState(ui::EF_ALT_DOWN));
  EXPECT_EQ(STICKY_KEY_STATE_LOCKED,
            overlay_->GetModifierKeyState(ui::EF_COMMAND_DOWN));

  // Disable modifiers and overlay should be hidden.
  SendKeyEvents(KeyLControl::Typed());
  SendKeyEvents(KeyLControl::Typed());
  SendKeyEvents(KeyLShift::Typed());
  SendKeyEvents(KeyLAlt::Typed());
  SendKeyEvents(KeyLAlt::Typed());
  SendKeyEvents(KeyLMeta::Typed());

  EXPECT_FALSE(overlay_->is_visible());
  EXPECT_EQ(STICKY_KEY_STATE_DISABLED,
            overlay_->GetModifierKeyState(ui::EF_CONTROL_DOWN));
  EXPECT_EQ(STICKY_KEY_STATE_DISABLED,
            overlay_->GetModifierKeyState(ui::EF_SHIFT_DOWN));
  EXPECT_EQ(STICKY_KEY_STATE_DISABLED,
            overlay_->GetModifierKeyState(ui::EF_ALT_DOWN));
  EXPECT_EQ(STICKY_KEY_STATE_DISABLED,
            overlay_->GetModifierKeyState(ui::EF_COMMAND_DOWN));
}

TEST_P(StickyKeysOverlayTest, ModifierVisibility) {
  // All but AltGr and Mod3 should initially be visible.
  EXPECT_TRUE(overlay_->GetModifierVisible(ui::EF_CONTROL_DOWN));
  EXPECT_TRUE(overlay_->GetModifierVisible(ui::EF_SHIFT_DOWN));
  EXPECT_TRUE(overlay_->GetModifierVisible(ui::EF_ALT_DOWN));
  EXPECT_TRUE(overlay_->GetModifierVisible(ui::EF_COMMAND_DOWN));
  EXPECT_FALSE(overlay_->GetModifierVisible(ui::EF_ALTGR_DOWN));
  EXPECT_FALSE(overlay_->GetModifierVisible(ui::EF_MOD3_DOWN));
  EXPECT_FALSE(overlay_->GetModifierVisible(ui::EF_FUNCTION_DOWN));

  // Turn all modifiers on.
  auto* sticky_keys_controller = Shell::Get()->sticky_keys_controller();
  sticky_keys_controller->SetMod3AndAltGrModifiersEnabled(true, true);
  sticky_keys_controller->SetFnModifierEnabled(true);
  EXPECT_TRUE(overlay_->GetModifierVisible(ui::EF_CONTROL_DOWN));
  EXPECT_TRUE(overlay_->GetModifierVisible(ui::EF_SHIFT_DOWN));
  EXPECT_TRUE(overlay_->GetModifierVisible(ui::EF_ALT_DOWN));
  EXPECT_TRUE(overlay_->GetModifierVisible(ui::EF_COMMAND_DOWN));
  EXPECT_TRUE(overlay_->GetModifierVisible(ui::EF_ALTGR_DOWN));
  EXPECT_TRUE(overlay_->GetModifierVisible(ui::EF_MOD3_DOWN));
  EXPECT_TRUE(overlay_->GetModifierVisible(ui::EF_FUNCTION_DOWN));

  // Turn off Fn.
  sticky_keys_controller->SetFnModifierEnabled(false);
  EXPECT_FALSE(overlay_->GetModifierVisible(ui::EF_FUNCTION_DOWN));

  // Turn off Mod3.
  sticky_keys_controller->SetMod3AndAltGrModifiersEnabled(false, true);
  EXPECT_TRUE(overlay_->GetModifierVisible(ui::EF_ALTGR_DOWN));
  EXPECT_FALSE(overlay_->GetModifierVisible(ui::EF_MOD3_DOWN));

  // Turn off AltGr.
  sticky_keys_controller->SetMod3AndAltGrModifiersEnabled(true, false);
  EXPECT_FALSE(overlay_->GetModifierVisible(ui::EF_ALTGR_DOWN));
  EXPECT_TRUE(overlay_->GetModifierVisible(ui::EF_MOD3_DOWN));

  // Turn off AltGr and Mod3.
  sticky_keys_controller->SetMod3AndAltGrModifiersEnabled(false, false);
  EXPECT_FALSE(overlay_->GetModifierVisible(ui::EF_ALTGR_DOWN));
  EXPECT_FALSE(overlay_->GetModifierVisible(ui::EF_MOD3_DOWN));
}

TEST_P(EventRewriterTest, RewrittenModifier) {
  Preferences::RegisterProfilePrefs(prefs()->registry());

  // Register Control + B as an extension shortcut.
  SetExtensionCommands({{{ui::VKEY_B, ui::EF_CONTROL_DOWN}}});

  // Check that standard extension input has no rewritten modifiers.
  EXPECT_EQ(KeyB::Typed(ui::EF_CONTROL_DOWN),
            RunRewriter(KeyB::Typed(), ui::EF_CONTROL_DOWN));

  // Remap Control -> Alt.
  IntegerPrefMember control;
  InitModifierKeyPref(&control, ::prefs::kLanguageRemapControlKeyTo,
                      ui::mojom::ModifierKey::kControl,
                      ui::mojom::ModifierKey::kAlt);
  // Pressing Control + B should now be remapped to Alt + B.
  EXPECT_EQ(KeyB::Typed(ui::EF_ALT_DOWN),
            RunRewriter(KeyB::Typed(), ui::EF_CONTROL_DOWN));

  // Remap Alt -> Control.
  IntegerPrefMember alt;
  InitModifierKeyPref(&alt, ::prefs::kLanguageRemapAltKeyTo,
                      ui::mojom::ModifierKey::kAlt,
                      ui::mojom::ModifierKey::kControl);
  // Pressing Alt + B should now be remapped to Control + B.
  EXPECT_EQ(KeyB::Typed(ui::EF_CONTROL_DOWN),
            RunRewriter(KeyB::Typed(), ui::EF_ALT_DOWN));

  // Remove all extension shortcuts and still expect the remapping to work.
  SetExtensionCommands(std::nullopt);

  EXPECT_EQ(KeyB::Typed(ui::EF_ALT_DOWN),
            RunRewriter(KeyB::Typed(), ui::EF_CONTROL_DOWN));
  EXPECT_EQ(KeyB::Typed(ui::EF_CONTROL_DOWN),
            RunRewriter(KeyB::Typed(), ui::EF_ALT_DOWN));
}

TEST_P(EventRewriterTest, RewriteNumpadExtensionCommand) {
  // Register Control + NUMPAD1 as an extension shortcut.
  SetExtensionCommands({{{ui::VKEY_NUMPAD1, ui::EF_CONTROL_DOWN}}});
  // Check that extension shortcuts that involve numpads keys are properly
  // rewritten. Note that VKEY_END is associated with NUMPAD1 if Num Lock is
  // disabled. The result should be "NumPad 1 with Control".
  EXPECT_EQ(KeyNumpad1::Typed(ui::EF_CONTROL_DOWN),
            RunRewriter(KeyNumpadEnd::Typed(), ui::EF_CONTROL_DOWN));

  // Remove the extension shortcut and expect the numpad event to still be
  // rewritten.
  SetExtensionCommands(std::nullopt);
  EXPECT_EQ(KeyNumpad1::Typed(ui::EF_CONTROL_DOWN),
            RunRewriter(KeyNumpadEnd::Typed(), ui::EF_CONTROL_DOWN));
}

TEST_P(EventRewriterTest, RecordRewritingToFunctionKeys) {
  TestShortcutMappingPrefDelegate delegate;
  ASSERT_FALSE(::features::IsImprovedKeyboardShortcutsEnabled());

  Preferences::RegisterProfilePrefs(prefs()->registry());
  base::test::ScopedFeatureList scoped_feature_list;
  scoped_feature_list.InitWithFeatures({features::kInputDeviceSettingsSplit},
                                       {});

  base::HistogramTester histogram_tester;
  histogram_tester.ExpectTotalCount("ChromeOS.Inputs.Keyboard.F1Pressed", 0);

  // Search + back -> F1.
  SetUpKeyboard(kWilco1_0Keyboard);
  histogram_tester.ExpectBucketCount(
      "ChromeOS.Inputs.Keyboard.F1Pressed",
      /*SearchTopRowTranslated*/
      static_cast<int>(ui::InputKeyEventToFunctionKey::kSearchTopRowTranslated),
      0);
  EXPECT_EQ(KeyF1::Typed(),
            RunRewriter(KeyBrowserBack::Typed(), ui::EF_COMMAND_DOWN));
  histogram_tester.ExpectBucketCount(
      "ChromeOS.Inputs.Keyboard.F1Pressed",
      /*SearchTopRowTranslated*/
      static_cast<int>(ui::InputKeyEventToFunctionKey::kSearchTopRowTranslated),
      1u);
  histogram_tester.ExpectTotalCount("ChromeOS.Inputs.Keyboard.F1Pressed", 1u);

  mojom::KeyboardSettings settings;
  EXPECT_CALL(*input_device_settings_controller_mock_,
              GetKeyboardSettings(kKeyboardDeviceId))
      .WillRepeatedly(testing::Return(&settings));

  // Back + Search -> F1 + Search. Back was automatically translated to F1,
  // with search key unaffected so it should be mapped to
  // kTopRowAutoTranslated.
  settings.top_row_are_fkeys = true;
  settings.suppress_meta_fkey_rewrites = true;
  histogram_tester.ExpectBucketCount(
      "ChromeOS.Inputs.Keyboard.F1Pressed",
      /*TopRowAutoTranslated*/
      static_cast<int>(ui::InputKeyEventToFunctionKey::kTopRowAutoTranslated),
      0);
  EXPECT_EQ(KeyF1::Typed(ui::EF_COMMAND_DOWN),
            RunRewriter(KeyBrowserBack::Typed(), ui::EF_COMMAND_DOWN));
  histogram_tester.ExpectBucketCount(
      "ChromeOS.Inputs.Keyboard.F1Pressed",
      /*TopRowAutoTranslated*/
      static_cast<int>(ui::InputKeyEventToFunctionKey::kTopRowAutoTranslated),
      1u);
  histogram_tester.ExpectTotalCount("ChromeOS.Inputs.Keyboard.F1Pressed", 2u);

  SetUpKeyboard(kExternalGenericKeyboard);

  // F1 + search -> F1.
  settings.top_row_are_fkeys = false;
  settings.suppress_meta_fkey_rewrites = false;

  histogram_tester.ExpectBucketCount(
      "ChromeOS.Inputs.Keyboard.F1Pressed",
      /*DirectlyWithSearch*/
      static_cast<int>(ui::InputKeyEventToFunctionKey::kDirectlyWithSearch), 0);
  // The keyboard sends F1 + search and the result is F1 only without search so
  // it should be mapped to kDirectlyWithSearch.
  EXPECT_EQ(KeyF1::Typed(), RunRewriter(KeyF1::Typed(), ui::EF_COMMAND_DOWN));
  histogram_tester.ExpectBucketCount(
      "ChromeOS.Inputs.Keyboard.F1Pressed",
      /*DirectlyWithSearch*/
      static_cast<int>(ui::InputKeyEventToFunctionKey::kDirectlyWithSearch),
      1u);
  histogram_tester.ExpectTotalCount("ChromeOS.Inputs.Keyboard.F1Pressed", 3u);

  // No change.
  settings.top_row_are_fkeys = true;
  histogram_tester.ExpectBucketCount(
      "ChromeOS.Inputs.Keyboard.F1Pressed",
      /*DirectlyFromKeyboard*/
      static_cast<int>(ui::InputKeyEventToFunctionKey::kDirectlyFromKeyboard),
      0);
  EXPECT_EQ(KeyF1::Typed(), RunRewriter(KeyF1::Typed()));
  histogram_tester.ExpectBucketCount(
      "ChromeOS.Inputs.Keyboard.F1Pressed",
      /*DirectlyFromKeyboard*/
      static_cast<int>(ui::InputKeyEventToFunctionKey::kDirectlyFromKeyboard),
      1u);
  histogram_tester.ExpectTotalCount("ChromeOS.Inputs.Keyboard.F1Pressed", 4u);

  // Search + number.
  SetUpKeyboard(kInternalChromeKeyboard);
  histogram_tester.ExpectBucketCount(
      "ChromeOS.Inputs.Keyboard.F1Pressed",
      /*SearchDigitTranslated*/
      static_cast<int>(ui::InputKeyEventToFunctionKey::kSearchDigitTranslated),
      0);
  EXPECT_EQ(KeyF1::Typed(),
            RunRewriter(KeyDigit1::Typed(), ui::EF_COMMAND_DOWN));
  histogram_tester.ExpectBucketCount(
      "ChromeOS.Inputs.Keyboard.F1Pressed",
      /*SearchDigitTranslated*/
      static_cast<int>(ui::InputKeyEventToFunctionKey::kSearchDigitTranslated),
      1u);
  histogram_tester.ExpectTotalCount("ChromeOS.Inputs.Keyboard.F1Pressed", 5u);

  // F1 + search to F1 + search
  settings.suppress_meta_fkey_rewrites = true;
  EXPECT_EQ(KeyF1::Typed(ui::EF_COMMAND_DOWN),
            RunRewriter(KeyF1::Typed(), ui::EF_COMMAND_DOWN));
  histogram_tester.ExpectBucketCount(
      "ChromeOS.Inputs.Keyboard.F1Pressed",
      /*DirectlyFromKeyboard*/
      static_cast<int>(ui::InputKeyEventToFunctionKey::kDirectlyFromKeyboard),
      2u);
  histogram_tester.ExpectTotalCount("ChromeOS.Inputs.Keyboard.F1Pressed", 6u);
}

TEST_P(EventRewriterTest, AltgrLatch) {
  // TODO(b/331906341): Consider to use real latvian layout.
  keyboard_layout_engine_->SetCustomLookupTableForTesting({
      {ui::DomCode::QUOTE, ui::DomKey::ALT_GRAPH_LATCH,
       ui::DomKey::FromCharacter(u'"'), ui::VKEY_ALTGR},
  });

  // Use fake latvian quote key.
  using KeyLatvianQuote =
      TestKey<ui::DomCode::QUOTE, ui::DomKey::ALT_GRAPH_LATCH, ui::VKEY_ALTGR,
              ui::EF_ALTGR_DOWN>;
  EXPECT_EQ(std::vector<TestKeyEvent>(
                {{ui::EventType::kKeyPressed, ui::DomCode::QUOTE,
                  ui::DomKey::ALT_GRAPH, ui::VKEY_ALTGR, ui::EF_ALTGR_DOWN},
                 // EF_ALTGR_DOWN is still here, because it's latched.
                 {ui::EventType::kKeyReleased, ui::DomCode::QUOTE,
                  ui::DomKey::ALT_GRAPH, ui::VKEY_ALTGR, ui::EF_ALTGR_DOWN}}),
            SendKeyEvents(KeyLatvianQuote::Typed()));
  EXPECT_EQ(std::vector({KeyA::Pressed(ui::EF_ALTGR_DOWN), KeyA::Released()}),
            SendKeyEvents(KeyA::Typed()));

  // Hold the quote.
  EXPECT_EQ(std::vector<TestKeyEvent>(
                {{ui::EventType::kKeyPressed, ui::DomCode::QUOTE,
                  ui::DomKey::ALT_GRAPH, ui::VKEY_ALTGR, ui::EF_ALTGR_DOWN}}),
            SendKeyEvent(KeyLatvianQuote::Pressed()));

  // Type A followed by C.
  EXPECT_EQ(KeyA::Typed(ui::EF_ALTGR_DOWN),
            SendKeyEvents(KeyA::Typed(ui::EF_ALTGR_DOWN)));
  EXPECT_EQ(KeyC::Typed(ui::EF_ALTGR_DOWN),
            SendKeyEvents(KeyC::Typed(ui::EF_ALTGR_DOWN)));

  // Release the quote, where EF_ALTGR_DOWN should not be set.
  EXPECT_EQ(std::vector<TestKeyEvent>(
                {{ui::EventType::kKeyReleased, ui::DomCode::QUOTE,
                  ui::DomKey::ALT_GRAPH, ui::VKEY_ALTGR}}),
            SendKeyEvent(KeyLatvianQuote::Released()));
}

TEST_P(EventRewriterTest, SixPackRemappingsFnBased) {
  if (!features::IsModifierSplitEnabled()) {
    GTEST_SKIP() << "Test is only valid with the modifier split flag enabled";
  }

  SetUpKeyboard(kInternalChromeSplitModifierLayoutKeyboard);

  // Test each case while applying additional flags to confirm flags get
  // properly applied to rewritten events.
  for (const auto flag : {ui::EF_NONE, ui::EF_COMMAND_DOWN, ui::EF_CONTROL_DOWN,
                          ui::EF_ALT_DOWN, ui::EF_SHIFT_DOWN}) {
    EXPECT_EQ(KeyDelete::Typed(flag),
              RunRewriter(KeyBackspace::Typed(), ui::EF_FUNCTION_DOWN | flag));
    EXPECT_EQ(KeyHome::Typed(flag),
              RunRewriter(KeyArrowLeft::Typed(), ui::EF_FUNCTION_DOWN | flag));
    EXPECT_EQ(KeyEnd::Typed(flag),
              RunRewriter(KeyArrowRight::Typed(), ui::EF_FUNCTION_DOWN | flag));
    EXPECT_EQ(KeyPageUp::Typed(flag),
              RunRewriter(KeyArrowUp::Typed(), ui::EF_FUNCTION_DOWN | flag));
    EXPECT_EQ(KeyPageDown::Typed(flag),
              RunRewriter(KeyArrowDown::Typed(), ui::EF_FUNCTION_DOWN | flag));
  }
}

TEST_P(EventRewriterTest, NotifyShortcutEventRewriteBlockedByFnKey) {
  if (!features::IsModifierSplitEnabled()) {
    GTEST_SKIP() << "Test is only valid with the modifier split flag enabled";
  }

  AnchoredNudgeManagerImpl* nudge_manager =
      Shell::Get()->anchored_nudge_manager();
  ASSERT_TRUE(nudge_manager);
  SetUpKeyboard(kInternalChromeSplitModifierLayoutKeyboard);
  EXPECT_EQ(KeyArrowLeft::Typed(ui::EF_COMMAND_DOWN),
            RunRewriter(KeyArrowLeft::Typed(), ui::EF_COMMAND_DOWN));

  EXPECT_TRUE(nudge_manager->GetNudgeIfShown(kSixPackKeyNoMatchNudgeId));
  nudge_manager->Cancel(kSixPackKeyNoMatchNudgeId);

  // Set the scan code so the key event is recognized as top row key.
  std::vector<TestKeyEvent> key_events;
  for (auto event : KeyF1::Typed()) {
    event.scan_code = 1;
    key_events.push_back(std::move(event));
  }

  std::vector<TestKeyEvent> expected_events;
  for (auto event : KeyF1::Typed(ui::EF_COMMAND_DOWN)) {
    event.scan_code = 1;
    expected_events.push_back(std::move(event));
  }

  EXPECT_EQ(expected_events, RunRewriter(key_events, ui::EF_COMMAND_DOWN));
  EXPECT_TRUE(nudge_manager->GetNudgeIfShown(kTopRowKeyNoMatchNudgeId));
  nudge_manager->Cancel(kTopRowKeyNoMatchNudgeId);
}

TEST_P(EventRewriterTest, CapsLockRemappingFnBased) {
  if (!features::IsModifierSplitEnabled()) {
    GTEST_SKIP() << "Test is only valid with the modifier split flag enabled";
  }

  SetUpKeyboard(kInternalChromeSplitModifierLayoutKeyboard);

  for (const auto flag :
       {ui::EF_NONE, ui::EF_CONTROL_DOWN, ui::EF_SHIFT_DOWN, ui::EF_ALT_DOWN}) {
    EXPECT_EQ(
        KeyCapsLock::Typed(flag | ui::EF_CAPS_LOCK_ON),
        RunRewriter(KeyQuickInsert::Typed(ui::EF_NONE, {kPropertyQuickInsert}),
                    ui::EF_FUNCTION_DOWN | flag));
    EXPECT_TRUE(fake_ime_keyboard_.IsCapsLockEnabled());

    EXPECT_EQ(KeyCapsLock::Typed(flag),
              RunRewriter(KeyQuickInsert::Typed(ui::EF_CAPS_LOCK_ON,
                                                {kPropertyQuickInsert}),
                          ui::EF_FUNCTION_DOWN | flag));
    EXPECT_FALSE(fake_ime_keyboard_.IsCapsLockEnabled());
  }
}

TEST_P(EventRewriterTest, CapsLockRemappingFnBasedJpnLayout) {
  if (!features::IsModifierSplitEnabled()) {
    GTEST_SKIP() << "Test is only valid with the modifier split flag enabled";
  }

  SetUpKeyboard(kInternalChromeSplitModifierLayoutKeyboard);

  EXPECT_EQ(KeyCapsLock::Typed(ui::EF_CAPS_LOCK_ON),
            RunRewriter(
                KeyJpnAlphanumeric::Typed(ui::EF_NONE, {kPropertyQuickInsert}),
                ui::EF_FUNCTION_DOWN));
  EXPECT_TRUE(fake_ime_keyboard_.IsCapsLockEnabled());

  EXPECT_EQ(KeyCapsLock::Typed(),
            RunRewriter(KeyJpnAlphanumeric::Typed(ui::EF_CAPS_LOCK_ON,
                                                  {kPropertyQuickInsert}),
                        ui::EF_FUNCTION_DOWN));
  EXPECT_FALSE(fake_ime_keyboard_.IsCapsLockEnabled());
}

TEST_P(EventRewriterTest, FnDiscarded) {
  if (!features::IsModifierSplitEnabled()) {
    GTEST_SKIP() << "Test is only valid with the modifier split flag enabled";
  }

  SetUpKeyboard(kInternalChromeSplitModifierLayoutKeyboard);

  EXPECT_EQ(KeyA::Typed(), RunRewriter(KeyA::Typed(), ui::EF_FUNCTION_DOWN));
  EXPECT_EQ(
      KeyA::Typed(ui::EF_CONTROL_DOWN),
      RunRewriter(KeyA::Typed(), ui::EF_FUNCTION_DOWN | ui::EF_CONTROL_DOWN));

  EXPECT_EQ(std::vector<TestKeyEvent>(), RunRewriter(KeyFunction::Typed()));
}

// Tests that when you press Fn -> Quick Insert -> Release Fn -> Release Quick
// Insert that the release of Quick Insert is remapped to CapsLock to match the
// remapped press.
TEST_P(EventRewriterTest, CapsLockRemappingFnBasedReleaseOrdering) {
  if (!features::IsModifierSplitEnabled()) {
    GTEST_SKIP() << "Test is only valid with the modifier split flag enabled";
  }

  SetUpKeyboard(kInternalChromeSplitModifierLayoutKeyboard);

  EXPECT_EQ(std::vector<TestKeyEvent>(),
            RunRewriter(std::vector<TestKeyEvent>{KeyFunction::Pressed()}));
  EXPECT_EQ(
      std::vector<TestKeyEvent>({KeyCapsLock::Pressed(ui::EF_CAPS_LOCK_ON)}),
      RunRewriter(std::vector<TestKeyEvent>{KeyQuickInsert::Pressed(
          ui::EF_FUNCTION_DOWN, {kPropertyQuickInsert})}));
  EXPECT_EQ(std::vector<TestKeyEvent>(),
            RunRewriter(std::vector<TestKeyEvent>{
                KeyFunction::Released(ui::EF_CAPS_LOCK_ON)}));
  EXPECT_EQ(
      std::vector<TestKeyEvent>({KeyCapsLock::Released(ui::EF_CAPS_LOCK_ON)}),
      RunRewriter(std::vector<TestKeyEvent>{KeyQuickInsert::Released(
          ui::EF_CAPS_LOCK_ON, {kPropertyQuickInsert})}));
}

class ModifierPressedMetricsTest
    : public EventRewriterTestBase,
      public testing::WithParamInterface<
          std::tuple<bool,
                     std::tuple<TestKeyEvent,
                                ui::ModifierKeyUsageMetric,
                                std::vector<std::string>>>> {
 public:
  void SetUp() override {
    bool fix_enabled;
    auto tuple = std::tie(event_, modifier_key_usage_mapping_, key_pref_names_);
    std::tie(fix_enabled, tuple) = GetParam();
    std::vector<base::test::FeatureRef> enabled_features, disabled_features;
    (fix_enabled ? enabled_features : disabled_features)
        .push_back(ash::features::kEnableKeyboardRewriterFix);
    disabled_features.push_back(features::kInputDeviceSettingsSplit);
    scoped_feature_list_.InitWithFeatures(enabled_features, disabled_features);
    EventRewriterTestBase::SetUp();
  }

 protected:
  TestKeyEvent event_;
  ui::ModifierKeyUsageMetric modifier_key_usage_mapping_;
  std::vector<std::string> key_pref_names_;
};

INSTANTIATE_TEST_SUITE_P(
    All,
    ModifierPressedMetricsTest,
    testing::Combine(
        testing::Bool(),
        testing::ValuesIn(std::vector<std::tuple<TestKeyEvent,
                                                 ui::ModifierKeyUsageMetric,
                                                 std::vector<std::string>>>{
            {KeyLMeta::Pressed(),
             ui::ModifierKeyUsageMetric::kMetaLeft,
             {::prefs::kLanguageRemapSearchKeyTo,
              ::prefs::kLanguageRemapExternalCommandKeyTo,
              ::prefs::kLanguageRemapExternalMetaKeyTo}},
            {KeyRMeta::Pressed(),
             ui::ModifierKeyUsageMetric::kMetaRight,
             {::prefs::kLanguageRemapSearchKeyTo,
              ::prefs::kLanguageRemapExternalCommandKeyTo,
              ::prefs::kLanguageRemapExternalMetaKeyTo}},
            {KeyLControl::Pressed(),
             ui::ModifierKeyUsageMetric::kControlLeft,
             {::prefs::kLanguageRemapControlKeyTo}},
            {KeyRControl::Pressed(),
             ui::ModifierKeyUsageMetric::kControlRight,
             {::prefs::kLanguageRemapControlKeyTo}},
            {KeyLAlt::Pressed(),
             ui::ModifierKeyUsageMetric::kAltLeft,
             {::prefs::kLanguageRemapAltKeyTo}},
            {KeyRAlt::Pressed(),
             ui::ModifierKeyUsageMetric::kAltRight,
             {::prefs::kLanguageRemapAltKeyTo}},
            {KeyLShift::Pressed(),
             ui::ModifierKeyUsageMetric::kShiftLeft,
             // Shift keys cannot be remapped and therefore do not have a real
             // "pref" path.
             {"fakePrefPath"}},
            {KeyRShift::Pressed(),
             ui::ModifierKeyUsageMetric::kShiftRight,
             // Shift keys cannot be remapped and therefore do not have a real
             // "pref" path.
             {"fakePrefPath"}},
            {KeyCapsLock::Pressed(),
             ui::ModifierKeyUsageMetric::kCapsLock,
             {::prefs::kLanguageRemapCapsLockKeyTo}},
            {KeyBackspace::Pressed(),
             ui::ModifierKeyUsageMetric::kBackspace,
             {::prefs::kLanguageRemapBackspaceKeyTo}},
            {KeyEscape::Pressed(),
             ui::ModifierKeyUsageMetric::kEscape,
             {::prefs::kLanguageRemapEscapeKeyTo}},
            {KeyLaunchAssistant::Pressed(),
             ui::ModifierKeyUsageMetric::kAssistant,
             {::prefs::kLanguageRemapAssistantKeyTo}}})));

TEST_P(ModifierPressedMetricsTest, KeyPressedTest) {
  auto expected = event_;
  if (expected.code == ui::DomCode::CAPS_LOCK) {
    expected.flags |= ui::EF_CAPS_LOCK_ON;
  }

  base::HistogramTester histogram_tester;
  SetUpKeyboard(kInternalChromeKeyboard);
  EXPECT_EQ(std::vector({expected}), SendKeyEvent(event_));
  histogram_tester.ExpectUniqueSample(
      "ChromeOS.Inputs.Keyboard.ModifierPressed.Internal",
      modifier_key_usage_mapping_, 1);
  histogram_tester.ExpectUniqueSample(
      "ChromeOS.Inputs.Keyboard.RemappedModifierPressed.Internal",
      modifier_key_usage_mapping_, 1);
  // Unset CapsLock for each press.
  SendKeyEvent(TestKeyEvent{ui::EventType::kKeyReleased, event_.code,
                            event_.key, event_.keycode, event_.flags,
                            event_.scan_code});
  fake_ime_keyboard_.SetCapsLockEnabled(false);

  SetUpKeyboard(kExternalChromeKeyboard);
  EXPECT_EQ(std::vector({expected}), SendKeyEvent(event_));
  histogram_tester.ExpectUniqueSample(
      "ChromeOS.Inputs.Keyboard.ModifierPressed.CrOSExternal",
      modifier_key_usage_mapping_, 1);
  histogram_tester.ExpectUniqueSample(
      "ChromeOS.Inputs.Keyboard.RemappedModifierPressed.CrOSExternal",
      modifier_key_usage_mapping_, 1);
  SendKeyEvent(TestKeyEvent{ui::EventType::kKeyReleased, event_.code,
                            event_.key, event_.keycode, event_.flags,
                            event_.scan_code});
  fake_ime_keyboard_.SetCapsLockEnabled(false);

  SetUpKeyboard(kExternalAppleKeyboard);
  EXPECT_EQ(std::vector({expected}), SendKeyEvent(event_));
  histogram_tester.ExpectUniqueSample(
      "ChromeOS.Inputs.Keyboard.ModifierPressed.AppleExternal",
      modifier_key_usage_mapping_, 1);
  histogram_tester.ExpectUniqueSample(
      "ChromeOS.Inputs.Keyboard.RemappedModifierPressed.AppleExternal",
      modifier_key_usage_mapping_, 1);
  SendKeyEvent(TestKeyEvent{ui::EventType::kKeyReleased, event_.code,
                            event_.key, event_.keycode, event_.flags,
                            event_.scan_code});
  fake_ime_keyboard_.SetCapsLockEnabled(false);

  SetUpKeyboard(kExternalGenericKeyboard);
  EXPECT_EQ(std::vector({expected}), SendKeyEvent(event_));
  histogram_tester.ExpectUniqueSample(
      "ChromeOS.Inputs.Keyboard.ModifierPressed.External",
      modifier_key_usage_mapping_, 1);
  histogram_tester.ExpectUniqueSample(
      "ChromeOS.Inputs.Keyboard.RemappedModifierPressed.External",
      modifier_key_usage_mapping_, 1);
  SendKeyEvent(TestKeyEvent{ui::EventType::kKeyReleased, event_.code,
                            event_.key, event_.keycode, event_.flags,
                            event_.scan_code});
  fake_ime_keyboard_.SetCapsLockEnabled(false);
}

TEST_P(ModifierPressedMetricsTest, KeyPressedWithRemappingToBackspaceTest) {
  if (event_.keycode == ui::VKEY_SHIFT) {
    GTEST_SKIP() << "Shift cannot be remapped";
  }

  Preferences::RegisterProfilePrefs(prefs()->registry());
  base::HistogramTester histogram_tester;
  for (const auto& pref_name : key_pref_names_) {
    IntegerPrefMember pref_member;
    InitModifierKeyPref(&pref_member, pref_name,
                        ui::mojom::ModifierKey::kControl,
                        ui::mojom::ModifierKey::kBackspace);
  }

  SetUpKeyboard(kInternalChromeKeyboard);
  EXPECT_EQ(std::vector({KeyBackspace::Pressed()}), SendKeyEvent(event_));
  histogram_tester.ExpectUniqueSample(
      "ChromeOS.Inputs.Keyboard.ModifierPressed.Internal",
      modifier_key_usage_mapping_, 1);
  histogram_tester.ExpectUniqueSample(
      "ChromeOS.Inputs.Keyboard.RemappedModifierPressed.Internal",
      ui::ModifierKeyUsageMetric::kBackspace, 1);

  SetUpKeyboard(kExternalChromeKeyboard);
  EXPECT_EQ(std::vector({KeyBackspace::Pressed()}), SendKeyEvent(event_));
  histogram_tester.ExpectUniqueSample(
      "ChromeOS.Inputs.Keyboard.ModifierPressed.CrOSExternal",
      modifier_key_usage_mapping_, 1);
  histogram_tester.ExpectUniqueSample(
      "ChromeOS.Inputs.Keyboard.RemappedModifierPressed.CrOSExternal",
      ui::ModifierKeyUsageMetric::kBackspace, 1);

  SetUpKeyboard(kExternalAppleKeyboard);
  EXPECT_EQ(std::vector({KeyBackspace::Pressed()}), SendKeyEvent(event_));
  histogram_tester.ExpectUniqueSample(
      "ChromeOS.Inputs.Keyboard.ModifierPressed.AppleExternal",
      modifier_key_usage_mapping_, 1);
  histogram_tester.ExpectUniqueSample(
      "ChromeOS.Inputs.Keyboard.RemappedModifierPressed.AppleExternal",
      ui::ModifierKeyUsageMetric::kBackspace, 1);

  SetUpKeyboard(kExternalGenericKeyboard);
  EXPECT_EQ(std::vector({KeyBackspace::Pressed()}), SendKeyEvent(event_));
  histogram_tester.ExpectUniqueSample(
      "ChromeOS.Inputs.Keyboard.ModifierPressed.External",
      modifier_key_usage_mapping_, 1);
  histogram_tester.ExpectUniqueSample(
      "ChromeOS.Inputs.Keyboard.RemappedModifierPressed.External",
      ui::ModifierKeyUsageMetric::kBackspace, 1);
}

TEST_P(ModifierPressedMetricsTest, KeyPressedWithRemappingToControlTest) {
  if (event_.keycode == ui::VKEY_SHIFT) {
    GTEST_SKIP() << "Shift cannot be remapped";
  }

  Preferences::RegisterProfilePrefs(prefs()->registry());
  base::HistogramTester histogram_tester;

  const bool right = ui::KeycodeConverter::DomCodeToLocation(event_.code) ==
                     ui::DomKeyLocation::RIGHT;
  const ui::ModifierKeyUsageMetric remapped_modifier_key_usage_mapping =
      right ? ui::ModifierKeyUsageMetric::kControlRight
            : ui::ModifierKeyUsageMetric::kControlLeft;
  const auto control_event =
      right ? KeyRControl::Pressed() : KeyLControl::Pressed();

  for (const auto& pref_name : key_pref_names_) {
    IntegerPrefMember pref_member;
    InitModifierKeyPref(&pref_member, pref_name,
                        ui::mojom::ModifierKey::kControl,
                        ui::mojom::ModifierKey::kControl);
  }

  SetUpKeyboard(kInternalChromeKeyboard);
  EXPECT_EQ(std::vector({control_event}), SendKeyEvent(event_));
  histogram_tester.ExpectUniqueSample(
      "ChromeOS.Inputs.Keyboard.ModifierPressed.Internal",
      modifier_key_usage_mapping_, 1);
  histogram_tester.ExpectUniqueSample(
      "ChromeOS.Inputs.Keyboard.RemappedModifierPressed.Internal",
      remapped_modifier_key_usage_mapping, 1);

  SetUpKeyboard(kExternalChromeKeyboard);
  EXPECT_EQ(std::vector({control_event}), SendKeyEvent(event_));
  histogram_tester.ExpectUniqueSample(
      "ChromeOS.Inputs.Keyboard.ModifierPressed.CrOSExternal",
      modifier_key_usage_mapping_, 1);
  histogram_tester.ExpectUniqueSample(
      "ChromeOS.Inputs.Keyboard.RemappedModifierPressed.CrOSExternal",
      remapped_modifier_key_usage_mapping, 1);

  SetUpKeyboard(kExternalAppleKeyboard);
  EXPECT_EQ(std::vector({control_event}), SendKeyEvent(event_));
  histogram_tester.ExpectUniqueSample(
      "ChromeOS.Inputs.Keyboard.ModifierPressed.AppleExternal",
      modifier_key_usage_mapping_, 1);
  histogram_tester.ExpectUniqueSample(
      "ChromeOS.Inputs.Keyboard.RemappedModifierPressed.AppleExternal",
      remapped_modifier_key_usage_mapping, 1);

  SetUpKeyboard(kExternalGenericKeyboard);
  EXPECT_EQ(std::vector({control_event}), SendKeyEvent(event_));
  histogram_tester.ExpectUniqueSample(
      "ChromeOS.Inputs.Keyboard.ModifierPressed.External",
      modifier_key_usage_mapping_, 1);
  histogram_tester.ExpectUniqueSample(
      "ChromeOS.Inputs.Keyboard.RemappedModifierPressed.External",
      remapped_modifier_key_usage_mapping, 1);
}

TEST_P(ModifierPressedMetricsTest, KeyRepeatTest) {
  if (event_.code == ui::DomCode::CAPS_LOCK) {
    GTEST_SKIP() << "CapsLock Key will not be marked as EF_IS_REPEAT";
  }

  base::HistogramTester histogram_tester;
  // No metrics should be published if it is a repeated key.
  event_.flags |= ui::EF_IS_REPEAT;

  SetUpKeyboard(kInternalChromeKeyboard);
  EXPECT_EQ(std::vector({event_}), SendKeyEvent(event_));
  histogram_tester.ExpectUniqueSample(
      "ChromeOS.Inputs.Keyboard.ModifierPressed.Internal",
      modifier_key_usage_mapping_, 0);
  histogram_tester.ExpectUniqueSample(
      "ChromeOS.Inputs.Keyboard.RemappedModifierPressed.Internal",
      modifier_key_usage_mapping_, 0);

  SetUpKeyboard(kExternalChromeKeyboard);
  EXPECT_EQ(std::vector({event_}), SendKeyEvent(event_));
  histogram_tester.ExpectUniqueSample(
      "ChromeOS.Inputs.Keyboard.ModifierPressed.CrOSExternal",
      modifier_key_usage_mapping_, 0);
  histogram_tester.ExpectUniqueSample(
      "ChromeOS.Inputs.Keyboard.RemappedModifierPressed.CrOSExternal",
      modifier_key_usage_mapping_, 0);

  SetUpKeyboard(kExternalAppleKeyboard);
  EXPECT_EQ(std::vector({event_}), SendKeyEvent(event_));
  histogram_tester.ExpectUniqueSample(
      "ChromeOS.Inputs.Keyboard.ModifierPressed.AppleExternal",
      modifier_key_usage_mapping_, 0);
  histogram_tester.ExpectUniqueSample(
      "ChromeOS.Inputs.Keyboard.RemappedModifierPressed.AppleExternal",
      modifier_key_usage_mapping_, 0);

  SetUpKeyboard(kExternalGenericKeyboard);
  EXPECT_EQ(std::vector({event_}), SendKeyEvent(event_));
  histogram_tester.ExpectUniqueSample(
      "ChromeOS.Inputs.Keyboard.ModifierPressed.External",
      modifier_key_usage_mapping_, 0);
  histogram_tester.ExpectUniqueSample(
      "ChromeOS.Inputs.Keyboard.RemappedModifierPressed.External",
      modifier_key_usage_mapping_, 0);
}

TEST_P(ModifierPressedMetricsTest, KeyReleasedTest) {
  if (event_.code == ui::DomCode::CAPS_LOCK) {
    GTEST_SKIP() << "CapsLock Key will not be marked as EF_IS_REPEAT";
  }

  base::HistogramTester histogram_tester;
  // No metrics should be published if it is a repeated key.
  event_.flags |= ui::EF_IS_REPEAT;

  auto expected = event_;
  if (expected.code == ui::DomCode::CAPS_LOCK) {
    expected.flags |= ui::EF_CAPS_LOCK_ON;
  }

  SetUpKeyboard(kInternalChromeKeyboard);
  EXPECT_EQ(std::vector({expected}), SendKeyEvent(event_));
  histogram_tester.ExpectUniqueSample(
      "ChromeOS.Inputs.Keyboard.ModifierPressed.Internal",
      modifier_key_usage_mapping_, 0);
  histogram_tester.ExpectUniqueSample(
      "ChromeOS.Inputs.Keyboard.RemappedModifierPressed.Internal",
      modifier_key_usage_mapping_, 0);

  SetUpKeyboard(kExternalChromeKeyboard);
  EXPECT_EQ(std::vector({expected}), SendKeyEvent(event_));
  histogram_tester.ExpectUniqueSample(
      "ChromeOS.Inputs.Keyboard.ModifierPressed.CrOSExternal",
      modifier_key_usage_mapping_, 0);
  histogram_tester.ExpectUniqueSample(
      "ChromeOS.Inputs.Keyboard.RemappedModifierPressed.CrOSExternal",
      modifier_key_usage_mapping_, 0);

  SetUpKeyboard(kExternalAppleKeyboard);
  EXPECT_EQ(std::vector({expected}), SendKeyEvent(event_));
  histogram_tester.ExpectUniqueSample(
      "ChromeOS.Inputs.Keyboard.ModifierPressed.AppleExternal",
      modifier_key_usage_mapping_, 0);
  histogram_tester.ExpectUniqueSample(
      "ChromeOS.Inputs.Keyboard.RemappedModifierPressed.AppleExternal",
      modifier_key_usage_mapping_, 0);

  SetUpKeyboard(kExternalGenericKeyboard);
  EXPECT_EQ(std::vector({expected}), SendKeyEvent(event_));
  histogram_tester.ExpectUniqueSample(
      "ChromeOS.Inputs.Keyboard.ModifierPressed.External",
      modifier_key_usage_mapping_, 0);
  histogram_tester.ExpectUniqueSample(
      "ChromeOS.Inputs.Keyboard.RemappedModifierPressed.External",
      modifier_key_usage_mapping_, 0);
}

class EventRewriterSixPackKeysTest
    : public EventRewriterTestBase,
      public testing::WithParamInterface<std::tuple<bool, bool>> {
 public:
  void SetUp() override {
    auto [enable_keyboard_rewriter_fix, enable_modifier_split] = GetParam();

    std::vector<base::test::FeatureRef> enabled_features, disabled_features;
    enabled_features.push_back(features::kInputDeviceSettingsSplit);
    enabled_features.push_back(features::kAltClickAndSixPackCustomization);
    (enable_keyboard_rewriter_fix ? enabled_features : disabled_features)
        .push_back(ash::features::kEnableKeyboardRewriterFix);
    (enable_modifier_split ? enabled_features : disabled_features)
        .push_back(ash::features::kModifierSplit);
    scoped_feature_list_.InitWithFeatures(enabled_features, disabled_features);

    EventRewriterTestBase::SetUp();
  }
};

INSTANTIATE_TEST_SUITE_P(All,
                         EventRewriterSixPackKeysTest,
                         testing::Combine(testing::Bool(), testing::Bool()));

TEST_P(EventRewriterSixPackKeysTest, TestRewriteSixPackKeysSearchVariants) {
  Preferences::RegisterProfilePrefs(prefs()->registry());
  mojom::KeyboardSettings settings;
  settings.six_pack_key_remappings = ash::mojom::SixPackKeyInfo::New();
  EXPECT_CALL(*input_device_settings_controller_mock_,
              GetKeyboardSettings(kKeyboardDeviceId))
      .WillRepeatedly(testing::Return(&settings));
  for (const auto& keyboard : kNonAppleKeyboardVariants) {
    SCOPED_TRACE(keyboard.name);
    SetUpKeyboard(keyboard);

    // Search+Shift+Backspace -> Insert
    EXPECT_EQ(KeyInsert::Typed(),
              RunRewriter(KeyBackspace::Typed(),
                          ui::EF_COMMAND_DOWN | ui::EF_SHIFT_DOWN));
    // Search+Backspace -> Delete
    EXPECT_EQ(KeyDelete::Typed(),
              RunRewriter(KeyBackspace::Typed(), ui::EF_COMMAND_DOWN));
    // Search+Up -> Prior (aka PageUp)
    EXPECT_EQ(KeyPageUp::Typed(),
              RunRewriter(KeyArrowUp::Typed(), ui::EF_COMMAND_DOWN));
    // Search+Down -> Next (aka PageDown)
    EXPECT_EQ(KeyPageDown::Typed(),
              RunRewriter(KeyArrowDown::Typed(), ui::EF_COMMAND_DOWN));
    // Search+Left -> Home
    EXPECT_EQ(KeyHome::Typed(),
              RunRewriter(KeyArrowLeft::Typed(), ui::EF_COMMAND_DOWN));
    // Search+Right -> End
    EXPECT_EQ(KeyEnd::Typed(),
              RunRewriter(KeyArrowRight::Typed(), ui::EF_COMMAND_DOWN));
    // Search+Shift+Down -> Shift+Next (aka PageDown)
    EXPECT_EQ(KeyPageDown::Typed(ui::EF_SHIFT_DOWN),
              RunRewriter(KeyArrowDown::Typed(),
                          ui::EF_COMMAND_DOWN | ui::EF_SHIFT_DOWN));
    // Search+Ctrl+Up -> Ctrl+Prior (aka PageUp)
    EXPECT_EQ(KeyPageUp::Typed(ui::EF_CONTROL_DOWN),
              RunRewriter(KeyArrowUp::Typed(),
                          ui::EF_COMMAND_DOWN | ui::EF_CONTROL_DOWN));
    // Search+Alt+Left -> Alt+Home
    EXPECT_EQ(KeyHome::Typed(ui::EF_ALT_DOWN),
              RunRewriter(KeyArrowLeft::Typed(),
                          ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN));
  }
}

TEST_P(EventRewriterSixPackKeysTest, TestRewriteSixPackKeysAltVariants) {
  Preferences::RegisterProfilePrefs(prefs()->registry());
  mojom::KeyboardSettings settings;
  settings.six_pack_key_remappings = ash::mojom::SixPackKeyInfo::New();
  settings.six_pack_key_remappings->del =
      ui::mojom::SixPackShortcutModifier::kAlt;
  settings.six_pack_key_remappings->end =
      ui::mojom::SixPackShortcutModifier::kAlt;
  settings.six_pack_key_remappings->home =
      ui::mojom::SixPackShortcutModifier::kAlt;
  settings.six_pack_key_remappings->page_down =
      ui::mojom::SixPackShortcutModifier::kAlt;
  settings.six_pack_key_remappings->page_up =
      ui::mojom::SixPackShortcutModifier::kAlt;

  EXPECT_CALL(*input_device_settings_controller_mock_,
              GetKeyboardSettings(kKeyboardDeviceId))
      .WillRepeatedly(testing::Return(&settings));
  for (const auto& keyboard : kNonAppleKeyboardVariants) {
    SCOPED_TRACE(keyboard.name);
    SetUpKeyboard(keyboard);

    // Alt+Backspace -> Delete
    EXPECT_EQ(KeyDelete::Typed(),
              RunRewriter(KeyBackspace::Typed(), ui::EF_ALT_DOWN));
    // Alt+Up -> Prior
    EXPECT_EQ(KeyPageUp::Typed(),
              RunRewriter(KeyArrowUp::Typed(), ui::EF_ALT_DOWN));
    // Alt+Down -> Next
    EXPECT_EQ(KeyPageDown::Typed(),
              RunRewriter(KeyArrowDown::Typed(), ui::EF_ALT_DOWN));
    // Ctrl+Alt+Up -> Home
    EXPECT_EQ(KeyHome::Typed(),
              RunRewriter(KeyArrowUp::Typed(),
                          ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN));
    // Ctrl+Alt+Down -> End
    EXPECT_EQ(KeyEnd::Typed(),
              RunRewriter(KeyArrowDown::Typed(),
                          ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN));
    // Ctrl+Alt+Shift+Up -> Shift+Home
    EXPECT_EQ(
        KeyHome::Typed(ui::EF_SHIFT_DOWN),
        RunRewriter(KeyArrowUp::Typed(),
                    ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN | ui::EF_SHIFT_DOWN));
    // Ctrl+Alt+Search+Down -> Search+End
    EXPECT_EQ(KeyEnd::Typed(ui::EF_COMMAND_DOWN),
              RunRewriter(KeyArrowDown::Typed(), ui::EF_CONTROL_DOWN |
                                                     ui::EF_ALT_DOWN |
                                                     ui::EF_COMMAND_DOWN));
  }
}

TEST_P(EventRewriterSixPackKeysTest, TestRewriteSixPackKeysBlockedBySetting) {
  Preferences::RegisterProfilePrefs(prefs()->registry());
  mojom::KeyboardSettings settings;
  // "six pack" key settings use the search modifier by default.
  settings.six_pack_key_remappings = ash::mojom::SixPackKeyInfo::New();
  EXPECT_CALL(*input_device_settings_controller_mock_,
              GetKeyboardSettings(kKeyboardDeviceId))
      .WillRepeatedly(testing::Return(&settings));
  // No rewrite should occur since the search-based rewrite is the setting for
  // the "Delete" 6-pack key.
  SetUpKeyboard(kInternalChromeKeyboard);
  EXPECT_EQ(KeyBackspace::Typed(ui::EF_ALT_DOWN),
            RunRewriter(KeyBackspace::Typed(), ui::EF_ALT_DOWN));
  EXPECT_EQ(1u, message_center_.NotificationCount());
  ClearNotifications();

  settings.six_pack_key_remappings->del =
      ui::mojom::SixPackShortcutModifier::kAlt;
  // Rewrite should occur now that the alt rewrite is the current setting.
  // Alt+Backspace -> Delete
  EXPECT_EQ(KeyDelete::Typed(),
            RunRewriter(KeyBackspace::Typed(), ui::EF_ALT_DOWN));

  settings.six_pack_key_remappings->del =
      ui::mojom::SixPackShortcutModifier::kNone;
  // No rewrite should occur since remapping a key event to the "Delete"
  // 6-pack key is disabled.
  EXPECT_EQ(KeyBackspace::Typed(ui::EF_ALT_DOWN),
            RunRewriter(KeyBackspace::Typed(), ui::EF_ALT_DOWN));
  EXPECT_EQ(1u, message_center_.NotificationCount());
  ClearNotifications();
}

class EventRewriterExtendedFkeysTest
    : public EventRewriterTestBase,
      public testing::WithParamInterface<std::tuple<bool, bool>> {
 public:
  void SetUp() override {
    auto [enable_keyboard_rewriter_fix, enable_modifier_split] = GetParam();
    std::vector<base::test::FeatureRef> enabled_features, disabled_features;
    enabled_features.push_back(ash::features::kInputDeviceSettingsSplit);
    enabled_features.push_back(::features::kSupportF11AndF12KeyShortcuts);
    (enable_keyboard_rewriter_fix ? enabled_features : disabled_features)
        .push_back(ash::features::kEnableKeyboardRewriterFix);
    (enable_modifier_split ? enabled_features : disabled_features)
        .push_back(ash::features::kModifierSplit);
    scoped_feature_list_.InitWithFeatures(enabled_features, disabled_features);

    EventRewriterTestBase::SetUp();
  }
};

INSTANTIATE_TEST_SUITE_P(All,
                         EventRewriterExtendedFkeysTest,
                         testing::Combine(testing::Bool(), testing::Bool()));

TEST_P(EventRewriterExtendedFkeysTest, TestRewriteExtendedFkeys) {
  Preferences::RegisterProfilePrefs(prefs()->registry());
  mojom::KeyboardSettings settings;
  settings.f11 = ui::mojom::ExtendedFkeysModifier::kAlt;
  settings.f12 = ui::mojom::ExtendedFkeysModifier::kShift;
  settings.top_row_are_fkeys = true;

  EXPECT_CALL(*input_device_settings_controller_mock_,
              GetKeyboardSettings(kKeyboardDeviceId))
      .WillRepeatedly(testing::Return(&settings));

  SetUpKeyboard(kInternalChromeKeyboard);
  EXPECT_EQ(KeyF11::Typed(), RunRewriter(KeyF1::Typed(), ui::EF_ALT_DOWN));
  EXPECT_EQ(KeyF12::Typed(), RunRewriter(KeyF2::Typed(), ui::EF_SHIFT_DOWN));

  settings.f11 = ui::mojom::ExtendedFkeysModifier::kCtrlShift;
  settings.f12 = ui::mojom::ExtendedFkeysModifier::kAlt;

  EXPECT_EQ(
      KeyF11::Typed(),
      RunRewriter(KeyF1::Typed(), ui::EF_CONTROL_DOWN | ui::EF_SHIFT_DOWN));
  EXPECT_EQ(KeyF12::Typed(), RunRewriter(KeyF2::Typed(), ui::EF_ALT_DOWN));
}

TEST_P(EventRewriterExtendedFkeysTest,
       TestRewriteExtendedFkeysBlockedBySetting) {
  Preferences::RegisterProfilePrefs(prefs()->registry());
  mojom::KeyboardSettings settings;
  settings.f11 = ui::mojom::ExtendedFkeysModifier::kDisabled;
  settings.f12 = ui::mojom::ExtendedFkeysModifier::kDisabled;
  settings.top_row_are_fkeys = true;

  EXPECT_CALL(*input_device_settings_controller_mock_,
              GetKeyboardSettings(kKeyboardDeviceId))
      .WillRepeatedly(testing::Return(&settings));
  SetUpKeyboard(kInternalChromeKeyboard);

  EXPECT_EQ(KeyF1::Typed(ui::EF_ALT_DOWN),
            RunRewriter(KeyF1::Typed(), ui::EF_ALT_DOWN));
}

TEST_P(EventRewriterExtendedFkeysTest, TestRewriteExtendedFkeysTopRowAreFkeys) {
  Preferences::RegisterProfilePrefs(prefs()->registry());
  mojom::KeyboardSettings settings;
  settings.f11 = ui::mojom::ExtendedFkeysModifier::kAlt;
  settings.f12 = ui::mojom::ExtendedFkeysModifier::kShift;
  settings.top_row_are_fkeys = true;

  EXPECT_CALL(*input_device_settings_controller_mock_,
              GetKeyboardSettings(kKeyboardDeviceId))
      .WillRepeatedly(testing::Return(&settings));
  SetUpKeyboard(kInternalChromeKeyboard);
  EXPECT_EQ(KeyF11::Typed(), RunRewriter(KeyF1::Typed(), ui::EF_ALT_DOWN));
  EXPECT_EQ(
      KeyF11::Typed(ui::EF_CONTROL_DOWN | ui::EF_SHIFT_DOWN),
      RunRewriter(KeyF1::Typed(),
                  ui::EF_CONTROL_DOWN | ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN));
  EXPECT_EQ(KeyF12::Typed(), RunRewriter(KeyF2::Typed(), ui::EF_SHIFT_DOWN));

  settings.top_row_are_fkeys = false;
  EXPECT_EQ(KeyF11::Typed(),
            RunRewriter(KeyF1::Typed(), ui::EF_COMMAND_DOWN | ui::EF_ALT_DOWN));
  EXPECT_EQ(
      KeyF12::Typed(),
      RunRewriter(KeyF2::Typed(), ui::EF_COMMAND_DOWN | ui::EF_SHIFT_DOWN));
}

class EventRewriterSettingsSplitTest
    : public EventRewriterTestBase,
      public testing::WithParamInterface<std::tuple<bool, bool>> {
 public:
  void SetUp() override {
    auto [enable_keyboard_rewriter_fix, enable_modifier_split] = GetParam();

    std::vector<base::test::FeatureRef> enabled_features, disabled_features;
    enabled_features.push_back(ash::features::kInputDeviceSettingsSplit);
    (enable_keyboard_rewriter_fix ? enabled_features : disabled_features)
        .push_back(ash::features::kEnableKeyboardRewriterFix);
    (enable_modifier_split ? enabled_features : disabled_features)
        .push_back(ash::features::kModifierSplit);
    scoped_feature_list_.InitWithFeatures(enabled_features, disabled_features);

    EventRewriterTestBase::SetUp();
  }
};

INSTANTIATE_TEST_SUITE_P(All,
                         EventRewriterSettingsSplitTest,
                         testing::Combine(testing::Bool(), testing::Bool()));

TEST_P(EventRewriterSettingsSplitTest, TopRowAreFKeys) {
  mojom::KeyboardSettings settings;
  EXPECT_CALL(*input_device_settings_controller_mock_,
              GetKeyboardSettings(kKeyboardDeviceId))
      .WillRepeatedly(testing::Return(&settings));
  SetUpKeyboard(kExternalGenericKeyboard);

  settings.top_row_are_fkeys = false;
  settings.suppress_meta_fkey_rewrites = false;

  EXPECT_EQ(KeyBrowserBack::Typed(), RunRewriter(KeyF1::Typed()));

  settings.top_row_are_fkeys = true;
  EXPECT_EQ(KeyF1::Typed(), RunRewriter(KeyF1::Typed()));
}

TEST_P(EventRewriterSettingsSplitTest,
       TopRowAreFKeys_unknownDeviceRespectsPreference) {
  // Create the preference.
  Preferences::RegisterProfilePrefs(prefs()->registry());
  BooleanPrefMember top_row_as_fn_key_pref;
  top_row_as_fn_key_pref.Init(prefs::kSendFunctionKeys, prefs());

  // Pretend the settings controller doesn't know the keyboard.
  EXPECT_CALL(*input_device_settings_controller_mock_, GetKeyboardSettings)
      .WillRepeatedly(testing::Return(nullptr));

  top_row_as_fn_key_pref.SetValue(true);
  EXPECT_EQ(RunRewriter(KeyF1::Typed()), KeyF1::Typed());

  top_row_as_fn_key_pref.SetValue(false);
  EXPECT_EQ(RunRewriter(KeyF1::Typed()), KeyBrowserBack::Typed());
}

TEST_P(EventRewriterSettingsSplitTest, RewriteMetaTopRowKeyComboEvents) {
  mojom::KeyboardSettings settings;
  settings.top_row_are_fkeys = true;
  EXPECT_CALL(*input_device_settings_controller_mock_,
              GetKeyboardSettings(kKeyboardDeviceId))
      .WillRepeatedly(testing::Return(&settings));
  SetUpKeyboard(kExternalGenericKeyboard);

  settings.suppress_meta_fkey_rewrites = false;
  EXPECT_EQ(KeyBrowserBack::Typed(),
            RunRewriter(KeyF1::Typed(), ui::EF_COMMAND_DOWN));

  settings.suppress_meta_fkey_rewrites = true;
  EXPECT_EQ(KeyF1::Typed(ui::EF_COMMAND_DOWN),
            RunRewriter(KeyF1::Typed(), ui::EF_COMMAND_DOWN));
}

TEST_P(EventRewriterSettingsSplitTest, ModifierRemapping) {
  mojom::KeyboardSettings settings;
  EXPECT_CALL(*input_device_settings_controller_mock_,
              GetKeyboardSettings(kKeyboardDeviceId))
      .WillRepeatedly(testing::Return(&settings));
  SetUpKeyboard(kExternalGenericKeyboard);

  settings.modifier_remappings = {
      {ui::mojom::ModifierKey::kAlt, ui::mojom::ModifierKey::kControl},
      {ui::mojom::ModifierKey::kMeta, ui::mojom::ModifierKey::kBackspace}};

  // Test remapping modifier keys.
  EXPECT_EQ(KeyRControl::Typed(), RunRewriter(KeyRAlt::Typed()));
  EXPECT_EQ(KeyBackspace::Typed(), RunRewriter(KeyLMeta::Typed()));
  EXPECT_EQ(KeyLControl::Typed(), RunRewriter(KeyLControl::Typed()));

  // Test remapping modifier flags.
  EXPECT_EQ(KeyA::Typed(ui::EF_CONTROL_DOWN),
            RunRewriter(KeyA::Typed(), ui::EF_ALT_DOWN));
  EXPECT_EQ(KeyA::Typed(), RunRewriter(KeyA::Typed(), ui::EF_COMMAND_DOWN));
  EXPECT_EQ(KeyA::Typed(ui::EF_CONTROL_DOWN),
            RunRewriter(KeyA::Typed(), ui::EF_CONTROL_DOWN));
}

class KeyEventRemappedToSixPackKeyTest
    : public EventRewriterTestBase,
      public testing::WithParamInterface<
          std::tuple<bool,
                     std::tuple<ui::KeyboardCode, bool, int, const char*>>> {
 public:
  void SetUp() override {
    bool fix_enabled;
    auto tuple =
        std::tie(key_code_, alt_based_, expected_pref_value_, pref_name_);
    std::tie(fix_enabled, tuple) = GetParam();
    if (fix_enabled) {
      scoped_feature_list_.InitAndEnableFeature(
          ash::features::kEnableKeyboardRewriterFix);
    } else {
      scoped_feature_list_.InitAndDisableFeature(
          ash::features::kEnableKeyboardRewriterFix);
    }
    EventRewriterTestBase::SetUp();
  }

 protected:
  ui::KeyboardCode key_code_;
  bool alt_based_;
  int expected_pref_value_;
  const char* pref_name_;
};

INSTANTIATE_TEST_SUITE_P(
    All,
    KeyEventRemappedToSixPackKeyTest,
    testing::Combine(
        testing::Bool(),
        testing::ValuesIn(
            std::vector<std::tuple<ui::KeyboardCode, bool, int, const char*>>{
                {ui::VKEY_DELETE, false, -1,
                 prefs::kKeyEventRemappedToSixPackDelete},
                {ui::VKEY_HOME, true, 1, prefs::kKeyEventRemappedToSixPackHome},
                {ui::VKEY_PRIOR, false, -1,
                 prefs::kKeyEventRemappedToSixPackPageDown},
                {ui::VKEY_END, true, 1, prefs::kKeyEventRemappedToSixPackEnd},
                {ui::VKEY_NEXT, false, -1,
                 prefs::kKeyEventRemappedToSixPackPageUp}})));

TEST_P(KeyEventRemappedToSixPackKeyTest, KeyEventRemappedTest) {
  Preferences::RegisterProfilePrefs(prefs()->registry());
  IntegerPrefMember int_pref;
  int_pref.Init(pref_name_, prefs());
  int_pref.SetValue(0);
  delegate_->RecordSixPackEventRewrite(key_code_, alt_based_);
  EXPECT_EQ(expected_pref_value_, prefs()->GetInteger(pref_name_));
}

class EventRewriterRemapToRightClickTest
    : public EventRewriterTestBase,
      public message_center::MessageCenterObserver,
      public testing::WithParamInterface<std::tuple<bool, bool>> {
 public:
  void SetUp() override {
    auto [enable_keyboard_rewriter_fix, enable_modifier_split] = GetParam();
    std::vector<base::test::FeatureRef> enabled_features, disabled_features;
    enabled_features.push_back(features::kInputDeviceSettingsSplit);
    enabled_features.push_back(features::kAltClickAndSixPackCustomization);
    (enable_keyboard_rewriter_fix ? enabled_features : disabled_features)
        .push_back(ash::features::kEnableKeyboardRewriterFix);
    (enable_modifier_split ? enabled_features : disabled_features)
        .push_back(ash::features::kModifierSplit);
    scoped_feature_list_.InitWithFeatures(enabled_features, disabled_features);

    EventRewriterTestBase::SetUp();

    Preferences::RegisterProfilePrefs(prefs()->registry());
    ui::DeviceDataManager* device_data_manager =
        ui::DeviceDataManager::GetInstance();
    std::vector<ui::TouchpadDevice> touchpad_devices(1);
    touchpad_devices[0].id = kTouchpadId1;
    static_cast<ui::DeviceHotplugEventObserver*>(device_data_manager)
        ->OnTouchpadDevicesUpdated(touchpad_devices);

    EXPECT_CALL(*input_device_settings_controller_mock_,
                GetTouchpadSettings(kTouchpadId1))
        .WillRepeatedly(testing::Return(&settings_));

    observation_.Observe(&message_center_);
  }

  void TearDown() override {
    observation_.Reset();
    EventRewriterTestBase::TearDown();
  }

  // message_center::MessageCenterObserver:
  void OnNotificationAdded(const std::string& notification_id) override {
    ++notification_count_;
  }

  void SetSimulateRightClickSetting(
      ui::mojom::SimulateRightClickModifier modifier) {
    settings_.simulate_right_click = modifier;
  }

  int notification_count() { return notification_count_; }

 private:
  mojom::TouchpadSettings settings_;
  int notification_count_ = 0;
  base::ScopedObservation<message_center::MessageCenter,
                          message_center::MessageCenterObserver>
      observation_{this};
};

INSTANTIATE_TEST_SUITE_P(All,
                         EventRewriterRemapToRightClickTest,
                         testing::Combine(testing::Bool(), testing::Bool()));

TEST_P(EventRewriterRemapToRightClickTest, AltClickRemappedToRightClick) {
  SetSimulateRightClickSetting(ui::mojom::SimulateRightClickModifier::kAlt);
  int flag_masks = ui::EF_ALT_DOWN | ui::EF_LEFT_MOUSE_BUTTON;

  ui::MouseEvent press(ui::EventType::kMousePressed, gfx::Point(), gfx::Point(),
                       ui::EventTimeForNow(), flag_masks,
                       ui::EF_LEFT_MOUSE_BUTTON);
  ui::EventTestApi test_press(&press);
  test_press.set_source_device_id(kTouchpadId1);
  EXPECT_EQ(ui::EventType::kMousePressed, press.type());
  EXPECT_EQ(flag_masks, press.flags());
  const ui::MouseEvent result = RewriteMouseButtonEvent(press);
  EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & result.flags());
  EXPECT_NE(flag_masks, flag_masks & result.flags());
  EXPECT_EQ(ui::EF_RIGHT_MOUSE_BUTTON, result.changed_button_flags());
}

TEST_P(EventRewriterRemapToRightClickTest, SearchClickRemappedToRightClick) {
  SetSimulateRightClickSetting(ui::mojom::SimulateRightClickModifier::kSearch);
  int flag_masks = ui::EF_COMMAND_DOWN | ui::EF_LEFT_MOUSE_BUTTON;

  ui::MouseEvent press(ui::EventType::kMousePressed, gfx::Point(), gfx::Point(),
                       ui::EventTimeForNow(), flag_masks,
                       ui::EF_LEFT_MOUSE_BUTTON);
  ui::EventTestApi test_press(&press);
  test_press.set_source_device_id(kTouchpadId1);
  EXPECT_EQ(ui::EventType::kMousePressed, press.type());
  EXPECT_EQ(flag_masks, press.flags());
  const ui::MouseEvent result = RewriteMouseButtonEvent(press);
  EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & result.flags());
  EXPECT_NE(flag_masks, flag_masks & result.flags());
  EXPECT_EQ(ui::EF_RIGHT_MOUSE_BUTTON, result.changed_button_flags());
}

TEST_P(EventRewriterRemapToRightClickTest, RemapToRightClickBlockedBySetting) {
  ui::DeviceDataManager* device_data_manager =
      ui::DeviceDataManager::GetInstance();
  std::vector<ui::TouchpadDevice> touchpad_devices(1);
  touchpad_devices[0].id = kTouchpadId1;
  static_cast<ui::DeviceHotplugEventObserver*>(device_data_manager)
      ->OnTouchpadDevicesUpdated(touchpad_devices);
  SetSimulateRightClickSetting(ui::mojom::SimulateRightClickModifier::kAlt);

  {
    ui::MouseEvent press(ui::EventType::kMousePressed, gfx::Point(),
                         gfx::Point(), ui::EventTimeForNow(),
                         ui::EF_COMMAND_DOWN | ui::EF_LEFT_MOUSE_BUTTON,
                         ui::EF_LEFT_MOUSE_BUTTON);
    ui::EventTestApi test_press(&press);
    test_press.set_source_device_id(kTouchpadId1);
    const ui::MouseEvent result = RewriteMouseButtonEvent(press);
    EXPECT_TRUE(ui::EF_LEFT_MOUSE_BUTTON & result.flags());
    EXPECT_EQ(ui::EF_LEFT_MOUSE_BUTTON, result.changed_button_flags());
    EXPECT_EQ(notification_count(), 1);
  }
  {
    SetSimulateRightClickSetting(
        ui::mojom::SimulateRightClickModifier::kSearch);
    ui::MouseEvent press(ui::EventType::kMousePressed, gfx::Point(),
                         gfx::Point(), ui::EventTimeForNow(),
                         ui::EF_ALT_DOWN | ui::EF_LEFT_MOUSE_BUTTON,
                         ui::EF_LEFT_MOUSE_BUTTON);
    ui::EventTestApi test_press(&press);
    test_press.set_source_device_id(kTouchpadId1);
    const ui::MouseEvent result = RewriteMouseButtonEvent(press);
    EXPECT_TRUE(ui::EF_LEFT_MOUSE_BUTTON & result.flags());
    EXPECT_EQ(ui::EF_LEFT_MOUSE_BUTTON, result.changed_button_flags());
    EXPECT_EQ(notification_count(), 2);
  }
}

TEST_P(EventRewriterRemapToRightClickTest, RemapToRightClickIsDisabled) {
  ui::DeviceDataManager* device_data_manager =
      ui::DeviceDataManager::GetInstance();
  std::vector<ui::TouchpadDevice> touchpad_devices(1);
  touchpad_devices[0].id = kTouchpadId1;
  static_cast<ui::DeviceHotplugEventObserver*>(device_data_manager)
      ->OnTouchpadDevicesUpdated(touchpad_devices);
  SetSimulateRightClickSetting(ui::mojom::SimulateRightClickModifier::kNone);

  ui::MouseEvent press(ui::EventType::kMousePressed, gfx::Point(), gfx::Point(),
                       ui::EventTimeForNow(),
                       ui::EF_COMMAND_DOWN | ui::EF_LEFT_MOUSE_BUTTON,
                       ui::EF_LEFT_MOUSE_BUTTON);
  ui::EventTestApi test_press(&press);
  test_press.set_source_device_id(kTouchpadId1);
  const ui::MouseEvent result = RewriteMouseButtonEvent(press);
  EXPECT_TRUE(ui::EF_LEFT_MOUSE_BUTTON & result.flags());
  EXPECT_EQ(ui::EF_LEFT_MOUSE_BUTTON, result.changed_button_flags());
  EXPECT_EQ(notification_count(), 1);
}

class FKeysRewritingPeripheralCustomizationTest
    : public EventRewriterTestBase,
      public testing::WithParamInterface<std::tuple<bool, bool>> {
 public:
  void SetUp() override {
    auto [enable_keyboard_rewriter_fix, enable_modifier_split] = GetParam();

    std::vector<base::test::FeatureRef> enabled_features, disabled_features;
    enabled_features.push_back(features::kInputDeviceSettingsSplit);
    enabled_features.push_back(features::kPeripheralCustomization);
    (enable_keyboard_rewriter_fix ? enabled_features : disabled_features)
        .push_back(ash::features::kEnableKeyboardRewriterFix);
    (enable_modifier_split ? enabled_features : disabled_features)
        .push_back(ash::features::kModifierSplit);
    scoped_feature_list_.InitWithFeatures(enabled_features, disabled_features);

    EventRewriterTestBase::SetUp();
  }

 protected:
  mojom::MouseSettings mouse_settings_;
};

INSTANTIATE_TEST_SUITE_P(All,
                         FKeysRewritingPeripheralCustomizationTest,
                         testing::Combine(testing::Bool(), testing::Bool()));

TEST_P(FKeysRewritingPeripheralCustomizationTest, FKeysNotRewritten) {
  EXPECT_CALL(*input_device_settings_controller_mock_,
              GetKeyboardSettings(kMouseDeviceId))
      .WillRepeatedly(testing::Return(nullptr));
  EXPECT_CALL(*input_device_settings_controller_mock_,
              GetMouseSettings(kMouseDeviceId))
      .WillRepeatedly(testing::Return(&mouse_settings_));

  SetUpKeyboard(kExternalGenericKeyboard);

  // Mice that press F-Keys do not get rewritten to actions.
  EXPECT_EQ(KeyF1::Typed(),
            RunRewriter(KeyF1::Typed(), ui::EF_NONE, kMouseDeviceId));
  EXPECT_EQ(KeyF2::Typed(),
            RunRewriter(KeyF2::Typed(), ui::EF_NONE, kMouseDeviceId));
  EXPECT_EQ(KeyF1::Typed(ui::EF_COMMAND_DOWN),
            RunRewriter(KeyF1::Typed(), ui::EF_COMMAND_DOWN, kMouseDeviceId));
  EXPECT_EQ(KeyF2::Typed(ui::EF_COMMAND_DOWN),
            RunRewriter(KeyF2::Typed(), ui::EF_COMMAND_DOWN, kMouseDeviceId));

  // Keyboards that press F-Keys do get rewritten to actions.
  EXPECT_EQ(KeyBrowserBack::Typed(), RunRewriter(KeyF1::Typed()));
  EXPECT_EQ(KeyBrowserForward::Typed(), RunRewriter(KeyF2::Typed()));
  EXPECT_EQ(KeyF1::Typed(), RunRewriter(KeyF1::Typed(), ui::EF_COMMAND_DOWN));
  EXPECT_EQ(KeyF2::Typed(), RunRewriter(KeyF2::Typed(), ui::EF_COMMAND_DOWN));
}

}  // namespace ash