0

Settings Split: Add per device settings methods to input controller

Adds optional value for mouse/pointing stick/touchpad settings functions
to enable settings to be applied per-device.

Bug: b/241965700
Change-Id: Ia2180c4515489e2665ba67161c625fc3e81d49e0
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/4237624
Commit-Queue: David Padlipsky <dpad@google.com>
Reviewed-by: Scott Violet <sky@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1112507}
This commit is contained in:
David Padlipsky
2023-03-02 23:13:37 +00:00
committed by Chromium LUCI CQ
parent f9376d21b9
commit c5afc05673
12 changed files with 439 additions and 249 deletions

@ -54,30 +54,44 @@ class TestInputController : public ui::InputController {
void SetTouchEventLoggingEnabled(bool enabled) override {
NOTIMPLEMENTED_LOG_ONCE();
}
void SetTouchpadSensitivity(int value) override {}
void SetTouchpadScrollSensitivity(int value) override {}
void SetTouchpadHapticFeedback(bool enabled) override {}
void SetTouchpadHapticClickSensitivity(int value) override {}
void SetTapToClick(bool enabled) override {}
void SetThreeFingerClick(bool enabled) override {}
void SetTapDragging(bool enabled) override {}
void SetNaturalScroll(bool enabled) override {}
void SetMouseSensitivity(int value) override {}
void SetMouseScrollSensitivity(int value) override {}
void SetPrimaryButtonRight(bool right) override {}
void SetMouseReverseScroll(bool enabled) override {}
void SetMouseAcceleration(bool enabled) override {}
void SetMouseScrollAcceleration(bool enabled) override {}
void SetPointingStickSensitivity(int value) override {}
void SetPointingStickPrimaryButtonRight(bool right) override {}
void SetPointingStickAcceleration(bool enabled) override {}
void SetTouchpadSensitivity(absl::optional<int> device_id,
int value) override {}
void SetTouchpadScrollSensitivity(absl::optional<int> device_id,
int value) override {}
void SetTapToClick(absl::optional<int> device_id, bool enabled) override {}
void SetTapDragging(absl::optional<int> device_id, bool enabled) override {}
void SetNaturalScroll(absl::optional<int> device_id, bool enabled) override {}
void SetTouchpadAcceleration(absl::optional<int> device_id,
bool enabled) override {}
void SetTouchpadScrollAcceleration(absl::optional<int> device_id,
bool enabled) override {}
void SetTouchpadHapticFeedback(absl::optional<int> device_id,
bool enabled) override {}
void SetTouchpadHapticClickSensitivity(absl::optional<int> device_id,
int value) override {}
void SetMouseSensitivity(absl::optional<int> device_id, int value) override {}
void SetMouseScrollSensitivity(absl::optional<int> device_id,
int value) override {}
void SetPrimaryButtonRight(absl::optional<int> device_id,
bool right) override {}
void SetMouseReverseScroll(absl::optional<int> device_id,
bool enabled) override {}
void SetMouseAcceleration(absl::optional<int> device_id,
bool enabled) override {}
void SetMouseScrollAcceleration(absl::optional<int> device_id,
bool enabled) override {}
void SetPointingStickSensitivity(absl::optional<int> device_id,
int value) override {}
void SetPointingStickPrimaryButtonRight(absl::optional<int> device_id,
bool right) override {}
void SetPointingStickAcceleration(absl::optional<int> device_id,
bool enabled) override {}
void SetGamepadKeyBitsMapping(
base::flat_map<int, std::vector<uint64_t>> key_bits_mapping) override {}
std::vector<uint64_t> GetGamepadKeyBits(int id) override {
return std::vector<uint64_t>();
}
void SetTouchpadAcceleration(bool enabled) override {}
void SetTouchpadScrollAcceleration(bool enabled) override {}
void SetTapToClickPaused(bool state) override {}
void GetStylusSwitchState(GetStylusSwitchStateReply reply) override {
// Return that there is no stylus in the garage; this test class

@ -168,7 +168,7 @@ void TouchDevicesController::UpdateTapDraggingEnabled() {
UMA_HISTOGRAM_BOOLEAN("Touchpad.TapDragging.Changed", enabled);
ui::OzonePlatform::GetInstance()->GetInputController()->SetTapDragging(
enabled);
absl::nullopt, enabled);
}
void TouchDevicesController::UpdateTouchpadEnabled() {

@ -68,57 +68,84 @@ std::vector<uint64_t> HapticsTrackingTestInputController::GetKeyboardKeyBits(
return std::vector<uint64_t>();
}
void HapticsTrackingTestInputController::SetTouchpadSensitivity(int value) {}
void HapticsTrackingTestInputController::SetTouchpadScrollSensitivity(
int value) {}
void HapticsTrackingTestInputController::SetTapToClick(bool enabled) {}
void HapticsTrackingTestInputController::SetThreeFingerClick(bool enabled) {}
void HapticsTrackingTestInputController::SetTapDragging(bool enabled) {}
void HapticsTrackingTestInputController::SetTouchpadSensitivity(
absl::optional<int> device_id,
int value) {}
void HapticsTrackingTestInputController::SetNaturalScroll(bool enabled) {}
void HapticsTrackingTestInputController::SetTouchpadAcceleration(bool enabled) {
}
void HapticsTrackingTestInputController::SetTouchpadScrollAcceleration(
bool enabled) {}
void HapticsTrackingTestInputController::SetTouchpadScrollSensitivity(
absl::optional<int> device_id,
int value) {}
void HapticsTrackingTestInputController::SetTouchpadHapticFeedback(
absl::optional<int> device_id,
bool enabled) {}
void HapticsTrackingTestInputController::SetTouchpadHapticClickSensitivity(
absl::optional<int> device_id,
int value) {}
void HapticsTrackingTestInputController::SetMouseSensitivity(int value) {}
void HapticsTrackingTestInputController::SetTapToClick(
absl::optional<int> device_id,
bool enabled) {}
void HapticsTrackingTestInputController::SetMouseScrollSensitivity(int value) {}
void HapticsTrackingTestInputController::SetTapDragging(
absl::optional<int> device_id,
bool enabled) {}
void HapticsTrackingTestInputController::SetPrimaryButtonRight(bool right) {}
void HapticsTrackingTestInputController::SetNaturalScroll(
absl::optional<int> device_id,
bool enabled) {}
void HapticsTrackingTestInputController::SetMouseReverseScroll(bool enabled) {}
void HapticsTrackingTestInputController::SetMouseSensitivity(
absl::optional<int> device_id,
int value) {}
void HapticsTrackingTestInputController::SetMouseAcceleration(bool enabled) {}
void HapticsTrackingTestInputController::SetMouseScrollSensitivity(
absl::optional<int> device_id,
int value) {}
void HapticsTrackingTestInputController::SetMouseReverseScroll(
absl::optional<int> device_id,
bool enabled) {}
void HapticsTrackingTestInputController::SetMouseAcceleration(
absl::optional<int> device_id,
bool enabled) {}
void HapticsTrackingTestInputController::SetMouseScrollAcceleration(
absl::optional<int> device_id,
bool enabled) {}
void HapticsTrackingTestInputController::SetPointingStickSensitivity(
absl::optional<int> device_id,
int value) {}
void HapticsTrackingTestInputController::SetPointingStickAcceleration(
absl::optional<int> device_id,
bool enabled) {}
void HapticsTrackingTestInputController::SetTouchpadAcceleration(
absl::optional<int> device_id,
bool enabled) {}
void HapticsTrackingTestInputController::SetTouchpadScrollAcceleration(
absl::optional<int> device_id,
bool enabled) {}
void HapticsTrackingTestInputController::SetPrimaryButtonRight(
absl::optional<int> device_id,
bool right) {}
void HapticsTrackingTestInputController::SetPointingStickPrimaryButtonRight(
absl::optional<int> device_id,
bool right) {}
void HapticsTrackingTestInputController::SuspendMouseAcceleration() {}
void HapticsTrackingTestInputController::EndMouseAccelerationSuspension() {}
void HapticsTrackingTestInputController::SetMouseScrollAcceleration(
bool enabled) {}
void HapticsTrackingTestInputController::SetPointingStickSensitivity(
int value) {}
void HapticsTrackingTestInputController::SetPointingStickPrimaryButtonRight(
bool right) {}
void HapticsTrackingTestInputController::SetPointingStickAcceleration(
bool enabled) {}
void HapticsTrackingTestInputController::SetGamepadKeyBitsMapping(
base::flat_map<int, std::vector<uint64_t>> key_bits_mapping) {}

@ -42,27 +42,41 @@ class HapticsTrackingTestInputController : public ui::InputController {
void SetKeyboardKeyBitsMapping(
base::flat_map<int, std::vector<uint64_t>> key_bits_mapping) override;
std::vector<uint64_t> GetKeyboardKeyBits(int id) override;
void SetTouchpadSensitivity(int value) override;
void SetTouchpadScrollSensitivity(int value) override;
void SetTapToClick(bool enabled) override;
void SetThreeFingerClick(bool enabled) override;
void SetTapDragging(bool enabled) override;
void SetNaturalScroll(bool enabled) override;
void SetTouchpadAcceleration(bool enabled) override;
void SetTouchpadScrollAcceleration(bool enabled) override;
void SetTouchpadHapticFeedback(bool enabled) override;
void SetTouchpadHapticClickSensitivity(int value) override;
void SetMouseSensitivity(int value) override;
void SetMouseScrollSensitivity(int value) override;
void SetPrimaryButtonRight(bool right) override;
void SetMouseReverseScroll(bool enabled) override;
void SetMouseAcceleration(bool enabled) override;
void SetTouchpadSensitivity(absl::optional<int> device_id,
int value) override;
void SetTouchpadScrollSensitivity(absl::optional<int> device_id,
int value) override;
void SetTapToClick(absl::optional<int> device_id, bool enabled) override;
void SetTapDragging(absl::optional<int> device_id, bool enabled) override;
void SetNaturalScroll(absl::optional<int> device_id, bool enabled) override;
void SetTouchpadAcceleration(absl::optional<int> device_id,
bool enabled) override;
void SetTouchpadScrollAcceleration(absl::optional<int> device_id,
bool enabled) override;
void SetTouchpadHapticFeedback(absl::optional<int> device_id,
bool enabled) override;
void SetTouchpadHapticClickSensitivity(absl::optional<int> device_id,
int value) override;
void SetMouseSensitivity(absl::optional<int> device_id, int value) override;
void SetMouseScrollSensitivity(absl::optional<int> device_id,
int value) override;
void SetPrimaryButtonRight(absl::optional<int> device_id,
bool right) override;
void SetMouseReverseScroll(absl::optional<int> device_id,
bool enabled) override;
void SetMouseAcceleration(absl::optional<int> device_id,
bool enabled) override;
void SetMouseScrollAcceleration(absl::optional<int> device_id,
bool enabled) override;
void SetPointingStickSensitivity(absl::optional<int> device_id,
int value) override;
void SetPointingStickPrimaryButtonRight(absl::optional<int> device_id,
bool right) override;
void SetPointingStickAcceleration(absl::optional<int> device_id,
bool enabled) override;
void SuspendMouseAcceleration() override;
void EndMouseAccelerationSuspension() override;
void SetMouseScrollAcceleration(bool enabled) override;
void SetPointingStickSensitivity(int value) override;
void SetPointingStickPrimaryButtonRight(bool right) override;
void SetPointingStickAcceleration(bool enabled) override;
void SetGamepadKeyBitsMapping(
base::flat_map<int, std::vector<uint64_t>> key_bits_mapping) override;
std::vector<uint64_t> GetGamepadKeyBits(int id) override;

@ -95,14 +95,14 @@ void InputDeviceSettingsImplOzone::SetTouchpadSensitivity(int value) {
DCHECK_GE(value, static_cast<int>(PointerSensitivity::kLowest));
DCHECK_LE(value, static_cast<int>(PointerSensitivity::kHighest));
current_touchpad_settings_.SetSensitivity(value);
input_controller()->SetTouchpadSensitivity(value);
input_controller()->SetTouchpadSensitivity(absl::nullopt, value);
}
void InputDeviceSettingsImplOzone::SetTouchpadScrollSensitivity(int value) {
DCHECK_GE(value, static_cast<int>(PointerSensitivity::kLowest));
DCHECK_LE(value, static_cast<int>(PointerSensitivity::kHighest));
current_touchpad_settings_.SetScrollSensitivity(value);
input_controller()->SetTouchpadScrollSensitivity(value);
input_controller()->SetTouchpadScrollSensitivity(absl::nullopt, value);
}
void InputDeviceSettingsImplOzone::HapticTouchpadExists(
@ -113,23 +113,23 @@ void InputDeviceSettingsImplOzone::HapticTouchpadExists(
void InputDeviceSettingsImplOzone::SetTouchpadHapticFeedback(bool enabled) {
current_touchpad_settings_.SetHapticFeedback(enabled);
input_controller()->SetTouchpadHapticFeedback(enabled);
input_controller()->SetTouchpadHapticFeedback(absl::nullopt, enabled);
}
void InputDeviceSettingsImplOzone::SetTouchpadHapticClickSensitivity(
int value) {
current_touchpad_settings_.SetHapticClickSensitivity(value);
input_controller()->SetTouchpadHapticClickSensitivity(value);
input_controller()->SetTouchpadHapticClickSensitivity(absl::nullopt, value);
}
void InputDeviceSettingsImplOzone::SetNaturalScroll(bool enabled) {
current_touchpad_settings_.SetNaturalScroll(enabled);
input_controller()->SetNaturalScroll(enabled);
input_controller()->SetNaturalScroll(absl::nullopt, enabled);
}
void InputDeviceSettingsImplOzone::SetTapToClick(bool enabled) {
current_touchpad_settings_.SetTapToClick(enabled);
input_controller()->SetTapToClick(enabled);
input_controller()->SetTapToClick(absl::nullopt, enabled);
}
void InputDeviceSettingsImplOzone::SetThreeFingerClick(bool enabled) {
@ -140,7 +140,7 @@ void InputDeviceSettingsImplOzone::SetThreeFingerClick(bool enabled) {
void InputDeviceSettingsImplOzone::SetTapDragging(bool enabled) {
current_touchpad_settings_.SetTapDragging(enabled);
input_controller()->SetTapDragging(enabled);
input_controller()->SetTapDragging(absl::nullopt, enabled);
}
void InputDeviceSettingsImplOzone::MouseExists(DeviceExistsCallback callback) {
@ -158,34 +158,34 @@ void InputDeviceSettingsImplOzone::SetMouseSensitivity(int value) {
DCHECK_GE(value, static_cast<int>(PointerSensitivity::kLowest));
DCHECK_LE(value, static_cast<int>(PointerSensitivity::kHighest));
current_mouse_settings_.SetSensitivity(value);
input_controller()->SetMouseSensitivity(value);
input_controller()->SetMouseSensitivity(absl::nullopt, value);
}
void InputDeviceSettingsImplOzone::SetMouseScrollSensitivity(int value) {
DCHECK_GE(value, static_cast<int>(PointerSensitivity::kLowest));
DCHECK_LE(value, static_cast<int>(PointerSensitivity::kHighest));
current_mouse_settings_.SetScrollSensitivity(value);
input_controller()->SetMouseScrollSensitivity(value);
input_controller()->SetMouseScrollSensitivity(absl::nullopt, value);
}
void InputDeviceSettingsImplOzone::SetPrimaryButtonRight(bool right) {
current_mouse_settings_.SetPrimaryButtonRight(right);
input_controller()->SetPrimaryButtonRight(right);
input_controller()->SetPrimaryButtonRight(absl::nullopt, right);
}
void InputDeviceSettingsImplOzone::SetMouseReverseScroll(bool enabled) {
current_mouse_settings_.SetReverseScroll(enabled);
input_controller()->SetMouseReverseScroll(enabled);
input_controller()->SetMouseReverseScroll(absl::nullopt, enabled);
}
void InputDeviceSettingsImplOzone::SetMouseAcceleration(bool enabled) {
current_mouse_settings_.SetAcceleration(enabled);
input_controller()->SetMouseAcceleration(enabled);
input_controller()->SetMouseAcceleration(absl::nullopt, enabled);
}
void InputDeviceSettingsImplOzone::SetMouseScrollAcceleration(bool enabled) {
current_mouse_settings_.SetScrollAcceleration(enabled);
input_controller()->SetMouseScrollAcceleration(enabled);
input_controller()->SetMouseScrollAcceleration(absl::nullopt, enabled);
}
void InputDeviceSettingsImplOzone::PointingStickExists(
@ -204,18 +204,18 @@ void InputDeviceSettingsImplOzone::SetPointingStickSensitivity(int value) {
DCHECK_GE(value, static_cast<int>(PointerSensitivity::kLowest));
DCHECK_LE(value, static_cast<int>(PointerSensitivity::kHighest));
current_pointing_stick_settings_.SetSensitivity(value);
input_controller()->SetPointingStickSensitivity(value);
input_controller()->SetPointingStickSensitivity(absl::nullopt, value);
}
void InputDeviceSettingsImplOzone::SetPointingStickPrimaryButtonRight(
bool right) {
current_pointing_stick_settings_.SetPrimaryButtonRight(right);
input_controller()->SetPointingStickPrimaryButtonRight(right);
input_controller()->SetPointingStickPrimaryButtonRight(absl::nullopt, right);
}
void InputDeviceSettingsImplOzone::SetPointingStickAcceleration(bool enabled) {
current_pointing_stick_settings_.SetAcceleration(enabled);
input_controller()->SetPointingStickAcceleration(enabled);
input_controller()->SetPointingStickAcceleration(absl::nullopt, enabled);
}
void InputDeviceSettingsImplOzone::ReapplyPointingStickSettings() {
@ -224,12 +224,12 @@ void InputDeviceSettingsImplOzone::ReapplyPointingStickSettings() {
void InputDeviceSettingsImplOzone::SetTouchpadAcceleration(bool enabled) {
current_touchpad_settings_.SetAcceleration(enabled);
input_controller()->SetTouchpadAcceleration(enabled);
input_controller()->SetTouchpadAcceleration(absl::nullopt, enabled);
}
void InputDeviceSettingsImplOzone::SetTouchpadScrollAcceleration(bool enabled) {
current_touchpad_settings_.SetScrollAcceleration(enabled);
input_controller()->SetTouchpadScrollAcceleration(enabled);
input_controller()->SetTouchpadScrollAcceleration(absl::nullopt, enabled);
}
void InputDeviceSettingsImplOzone::ReapplyTouchpadSettings() {

@ -708,7 +708,7 @@ TEST_F(EventConverterEvdevImplTest, ShouldSwapMouseButtonsFromUserPreference) {
SetTestNowSeconds(1510019415);
ClearDispatchedEvents();
GetInputController()->SetPrimaryButtonRight(false);
GetInputController()->SetPrimaryButtonRight(absl::nullopt, false);
dev->ProcessEvents(mock_kernel_queue, std::size(mock_kernel_queue));
EXPECT_EQ(4u, size());
@ -748,7 +748,7 @@ TEST_F(EventConverterEvdevImplTest, ShouldSwapMouseButtonsFromUserPreference) {
SetTestNowSeconds(1510019417);
ClearDispatchedEvents();
GetInputController()->SetPrimaryButtonRight(true);
GetInputController()->SetPrimaryButtonRight(absl::nullopt, true);
dev->ProcessEvents(mock_kernel_queue2, std::size(mock_kernel_queue2));
EXPECT_EQ(4u, size());

@ -21,6 +21,34 @@
#include "ui/events/ozone/evdev/mouse_button_map_evdev.h"
namespace ui {
namespace {
TouchpadSettingsEvdev& GetTouchpadSettings(InputDeviceSettingsEvdev& settings,
absl::optional<int> device_id) {
if (!device_id.has_value()) {
return settings.GetTouchpadSettings();
}
return settings.GetTouchpadSettings(device_id.value());
}
MouseSettingsEvdev& GetMouseSettings(InputDeviceSettingsEvdev& settings,
absl::optional<int> device_id) {
if (!device_id.has_value()) {
return settings.GetMouseSettings();
}
return settings.GetMouseSettings(device_id.value());
}
PointingStickSettingsEvdev& GetPointingStickSettings(
InputDeviceSettingsEvdev& settings,
absl::optional<int> device_id) {
if (!device_id.has_value()) {
return settings.GetPointingStickSettings();
}
return settings.GetPointingStickSettings(device_id.value());
}
} // namespace
InputControllerEvdev::InputControllerEvdev(
KeyboardEvdev* keyboard,
@ -154,72 +182,153 @@ void InputControllerEvdev::SetInternalKeyboardFilter(
ScheduleUpdateDeviceSettings();
}
void InputControllerEvdev::SetTouchpadSensitivity(int value) {
input_device_settings_.GetTouchpadSettings().sensitivity = value;
ScheduleUpdateDeviceSettings();
}
void InputControllerEvdev::SetTouchpadScrollSensitivity(int value) {
input_device_settings_.GetTouchpadSettings().scroll_sensitivity = value;
ScheduleUpdateDeviceSettings();
}
void InputControllerEvdev::SetTouchpadHapticFeedback(bool enabled) {
input_device_settings_.GetTouchpadSettings().haptic_feedback_enabled =
enabled;
ScheduleUpdateDeviceSettings();
}
void InputControllerEvdev::SetTouchpadHapticClickSensitivity(int value) {
input_device_settings_.GetTouchpadSettings().haptic_click_sensitivity = value;
ScheduleUpdateDeviceSettings();
}
void InputControllerEvdev::SetTapToClick(bool enabled) {
input_device_settings_.GetTouchpadSettings().tap_to_click_enabled = enabled;
ScheduleUpdateDeviceSettings();
}
void InputControllerEvdev::SetThreeFingerClick(bool enabled) {
input_device_settings_.three_finger_click_enabled = enabled;
ScheduleUpdateDeviceSettings();
}
void InputControllerEvdev::SetTapDragging(bool enabled) {
input_device_settings_.GetTouchpadSettings().tap_dragging_enabled = enabled;
void InputControllerEvdev::SetTouchpadSensitivity(absl::optional<int> device_id,
int value) {
GetTouchpadSettings(input_device_settings_, device_id).sensitivity = value;
ScheduleUpdateDeviceSettings();
}
void InputControllerEvdev::SetNaturalScroll(bool enabled) {
input_device_settings_.GetTouchpadSettings().natural_scroll_enabled = enabled;
void InputControllerEvdev::SetTouchpadAcceleration(
absl::optional<int> device_id,
bool enabled) {
GetTouchpadSettings(input_device_settings_, device_id).acceleration_enabled =
enabled;
ScheduleUpdateDeviceSettings();
}
void InputControllerEvdev::SetMouseSensitivity(int value) {
input_device_settings_.GetMouseSettings().sensitivity = value;
void InputControllerEvdev::SetTouchpadScrollAcceleration(
absl::optional<int> device_id,
bool enabled) {
GetTouchpadSettings(input_device_settings_, device_id)
.scroll_acceleration_enabled = enabled;
ScheduleUpdateDeviceSettings();
}
void InputControllerEvdev::SetMouseScrollSensitivity(int value) {
input_device_settings_.GetMouseSettings().scroll_sensitivity = value;
void InputControllerEvdev::SetTouchpadScrollSensitivity(
absl::optional<int> device_id,
int value) {
GetTouchpadSettings(input_device_settings_, device_id).scroll_sensitivity =
value;
ScheduleUpdateDeviceSettings();
}
void InputControllerEvdev::SetPointingStickSensitivity(int value) {
input_device_settings_.GetPointingStickSettings().sensitivity = value;
void InputControllerEvdev::SetTouchpadHapticFeedback(
absl::optional<int> device_id,
bool enabled) {
GetTouchpadSettings(input_device_settings_, device_id)
.haptic_feedback_enabled = enabled;
ScheduleUpdateDeviceSettings();
}
void InputControllerEvdev::SetPointingStickAcceleration(bool enabled) {
void InputControllerEvdev::SetTouchpadHapticClickSensitivity(
absl::optional<int> device_id,
int value) {
GetTouchpadSettings(input_device_settings_, device_id)
.haptic_click_sensitivity = value;
ScheduleUpdateDeviceSettings();
}
void InputControllerEvdev::SetTapToClick(absl::optional<int> device_id,
bool enabled) {
GetTouchpadSettings(input_device_settings_, device_id).tap_to_click_enabled =
enabled;
ScheduleUpdateDeviceSettings();
}
void InputControllerEvdev::SetTapDragging(absl::optional<int> device_id,
bool enabled) {
GetTouchpadSettings(input_device_settings_, device_id).tap_dragging_enabled =
enabled;
ScheduleUpdateDeviceSettings();
}
void InputControllerEvdev::SetNaturalScroll(absl::optional<int> device_id,
bool enabled) {
GetTouchpadSettings(input_device_settings_, device_id)
.natural_scroll_enabled = enabled;
ScheduleUpdateDeviceSettings();
}
void InputControllerEvdev::SetMouseSensitivity(absl::optional<int> device_id,
int value) {
GetMouseSettings(input_device_settings_, device_id).sensitivity = value;
ScheduleUpdateDeviceSettings();
}
void InputControllerEvdev::SetMouseScrollSensitivity(
absl::optional<int> device_id,
int value) {
GetMouseSettings(input_device_settings_, device_id).scroll_sensitivity =
value;
ScheduleUpdateDeviceSettings();
}
void InputControllerEvdev::SetMouseScrollAcceleration(
absl::optional<int> device_id,
bool enabled) {
GetMouseSettings(input_device_settings_, device_id)
.scroll_acceleration_enabled = enabled;
ScheduleUpdateDeviceSettings();
}
void InputControllerEvdev::SetPointingStickSensitivity(
absl::optional<int> device_id,
int value) {
GetPointingStickSettings(input_device_settings_, device_id).sensitivity =
value;
ScheduleUpdateDeviceSettings();
}
void InputControllerEvdev::SetMouseReverseScroll(absl::optional<int> device_id,
bool enabled) {
GetMouseSettings(input_device_settings_, device_id).reverse_scroll_enabled =
enabled;
ScheduleUpdateDeviceSettings();
}
void InputControllerEvdev::SetPointingStickAcceleration(
absl::optional<int> device_id,
bool enabled) {
// TODO(dpad): Implement acceleration suspending with multiple devices.
if (is_mouse_acceleration_suspended()) {
stored_acceleration_settings_->pointing_stick = enabled;
return;
}
input_device_settings_.GetPointingStickSettings().acceleration_enabled =
GetPointingStickSettings(input_device_settings_, device_id)
.acceleration_enabled = enabled;
ScheduleUpdateDeviceSettings();
}
void InputControllerEvdev::SetMouseAcceleration(absl::optional<int> device_id,
bool enabled) {
// TODO(dpad): Implement acceleration suspending with multiple devices.
if (is_mouse_acceleration_suspended()) {
stored_acceleration_settings_->mouse = enabled;
return;
}
GetMouseSettings(input_device_settings_, device_id).acceleration_enabled =
enabled;
ScheduleUpdateDeviceSettings();
}
void InputControllerEvdev::SetPrimaryButtonRight(absl::optional<int> device_id,
bool right) {
// TODO(dpad): Implement button remapping per-device.
mouse_button_map_->SetPrimaryButtonRight(right);
}
void InputControllerEvdev::SetPointingStickPrimaryButtonRight(
absl::optional<int> device_id,
bool right) {
// TODO(dpad): Implement button remapping per-device.
pointing_stick_button_map_->SetPrimaryButtonRight(right);
}
void InputControllerEvdev::SetGamepadKeyBitsMapping(
base::flat_map<int, std::vector<uint64_t>> key_bits_mapping) {
gamepad_key_bits_mapping_ = std::move(key_bits_mapping);
@ -232,28 +341,6 @@ std::vector<uint64_t> InputControllerEvdev::GetGamepadKeyBits(int id) {
: gamepad_key_bits_iter->second;
}
void InputControllerEvdev::SetPrimaryButtonRight(bool right) {
mouse_button_map_->SetPrimaryButtonRight(right);
}
void InputControllerEvdev::SetPointingStickPrimaryButtonRight(bool right) {
pointing_stick_button_map_->SetPrimaryButtonRight(right);
}
void InputControllerEvdev::SetMouseReverseScroll(bool enabled) {
input_device_settings_.GetMouseSettings().reverse_scroll_enabled = enabled;
ScheduleUpdateDeviceSettings();
}
void InputControllerEvdev::SetMouseAcceleration(bool enabled) {
if (is_mouse_acceleration_suspended()) {
stored_acceleration_settings_->mouse = enabled;
return;
}
input_device_settings_.GetMouseSettings().acceleration_enabled = enabled;
ScheduleUpdateDeviceSettings();
}
void InputControllerEvdev::SuspendMouseAcceleration() {
// multiple calls to suspend are currently not supported.
DCHECK(!is_mouse_acceleration_suspended());
@ -271,25 +358,8 @@ void InputControllerEvdev::SuspendMouseAcceleration() {
void InputControllerEvdev::EndMouseAccelerationSuspension() {
auto stored_settings = std::move(stored_acceleration_settings_);
SetMouseAcceleration(stored_settings->mouse);
SetPointingStickAcceleration(stored_settings->pointing_stick);
}
void InputControllerEvdev::SetMouseScrollAcceleration(bool enabled) {
input_device_settings_.GetMouseSettings().scroll_acceleration_enabled =
enabled;
ScheduleUpdateDeviceSettings();
}
void InputControllerEvdev::SetTouchpadAcceleration(bool enabled) {
input_device_settings_.GetTouchpadSettings().acceleration_enabled = enabled;
ScheduleUpdateDeviceSettings();
}
void InputControllerEvdev::SetTouchpadScrollAcceleration(bool enabled) {
input_device_settings_.GetTouchpadSettings().scroll_acceleration_enabled =
enabled;
ScheduleUpdateDeviceSettings();
SetMouseAcceleration(absl::nullopt, stored_settings->mouse);
SetPointingStickAcceleration(absl::nullopt, stored_settings->pointing_stick);
}
void InputControllerEvdev::SetTapToClickPaused(bool state) {

@ -66,30 +66,44 @@ class COMPONENT_EXPORT(EVDEV) InputControllerEvdev : public InputController {
base::flat_map<int, std::vector<uint64_t>> key_bits_mapping) override;
std::vector<uint64_t> GetKeyboardKeyBits(int id) override;
void SetTouchEventLoggingEnabled(bool enabled) override;
void SetTouchpadSensitivity(int value) override;
void SetTouchpadScrollSensitivity(int value) override;
void SetTouchpadHapticFeedback(bool enabled) override;
void SetTouchpadHapticClickSensitivity(int value) override;
void SetTapToClick(bool enabled) override;
void SetThreeFingerClick(bool enabled) override;
void SetTapDragging(bool enabled) override;
void SetNaturalScroll(bool enabled) override;
void SetMouseSensitivity(int value) override;
void SetMouseScrollSensitivity(int value) override;
void SetPrimaryButtonRight(bool right) override;
void SetMouseReverseScroll(bool enabled) override;
void SetMouseAcceleration(bool enabled) override;
void SetTouchpadSensitivity(absl::optional<int> device_id,
int value) override;
void SetTouchpadScrollSensitivity(absl::optional<int> device_id,
int value) override;
void SetTouchpadHapticFeedback(absl::optional<int> device_id,
bool enabled) override;
void SetTouchpadHapticClickSensitivity(absl::optional<int> device_id,
int value) override;
void SetTapToClick(absl::optional<int> device_id, bool enabled) override;
void SetTapDragging(absl::optional<int> device_id, bool enabled) override;
void SetNaturalScroll(absl::optional<int> device_id, bool enabled) override;
void SetMouseSensitivity(absl::optional<int> device_id, int value) override;
void SetMouseScrollSensitivity(absl::optional<int> device_id,
int value) override;
void SetMouseReverseScroll(absl::optional<int> device_id,
bool enabled) override;
void SetMouseAcceleration(absl::optional<int> device_id,
bool enabled) override;
void SetMouseScrollAcceleration(absl::optional<int> device_id,
bool enabled) override;
void SetPointingStickSensitivity(absl::optional<int> device_id,
int value) override;
void SetPointingStickAcceleration(absl::optional<int> device_id,
bool enabled) override;
void SetTouchpadAcceleration(absl::optional<int> device_id,
bool enabled) override;
void SetTouchpadScrollAcceleration(absl::optional<int> device_id,
bool enabled) override;
void SetPrimaryButtonRight(absl::optional<int> device_id,
bool right) override;
void SetPointingStickPrimaryButtonRight(absl::optional<int> device_id,
bool right) override;
void SuspendMouseAcceleration() override;
void EndMouseAccelerationSuspension() override;
void SetMouseScrollAcceleration(bool enabled) override;
void SetPointingStickSensitivity(int value) override;
void SetPointingStickPrimaryButtonRight(bool right) override;
void SetPointingStickAcceleration(bool enabled) override;
void SetGamepadKeyBitsMapping(
base::flat_map<int, std::vector<uint64_t>> key_bits_mapping) override;
std::vector<uint64_t> GetGamepadKeyBits(int id) override;
void SetTouchpadAcceleration(bool enabled) override;
void SetTouchpadScrollAcceleration(bool enabled) override;
void SetTapToClickPaused(bool state) override;
void GetTouchDeviceStatus(GetTouchDeviceStatusReply reply) override;
void GetTouchEventLog(const base::FilePath& out_dir,

@ -11,8 +11,8 @@ namespace ui {
TEST(InputControllerEvdevTest, AccelerationSuspension) {
InputControllerEvdev controller(nullptr, nullptr, nullptr);
controller.SetMouseAcceleration(true);
controller.SetPointingStickAcceleration(true);
controller.SetMouseAcceleration(absl::nullopt, true);
controller.SetPointingStickAcceleration(absl::nullopt, true);
EXPECT_TRUE(controller.input_device_settings_.GetMouseSettings()
.acceleration_enabled);
@ -36,8 +36,8 @@ TEST(InputControllerEvdevTest, AccelerationSuspension) {
TEST(InputControllerEvdevTest, AccelerationChangeDuringSuspension) {
InputControllerEvdev controller(nullptr, nullptr, nullptr);
controller.SetMouseAcceleration(true);
controller.SetPointingStickAcceleration(true);
controller.SetMouseAcceleration(absl::nullopt, true);
controller.SetPointingStickAcceleration(absl::nullopt, true);
// Suspending should disable the acceleration temporarily.
controller.SuspendMouseAcceleration();
@ -47,16 +47,16 @@ TEST(InputControllerEvdevTest, AccelerationChangeDuringSuspension) {
.acceleration_enabled);
// Settings changes while suspended should not take effect immediately...
controller.SetMouseAcceleration(true);
controller.SetPointingStickAcceleration(true);
controller.SetMouseAcceleration(absl::nullopt, true);
controller.SetPointingStickAcceleration(absl::nullopt, true);
EXPECT_FALSE(controller.input_device_settings_.GetMouseSettings()
.acceleration_enabled);
EXPECT_FALSE(controller.input_device_settings_.GetPointingStickSettings()
.acceleration_enabled);
// ...instead being applied when the suspension ends.
controller.SetMouseAcceleration(false);
controller.SetPointingStickAcceleration(false);
controller.SetMouseAcceleration(absl::nullopt, false);
controller.SetPointingStickAcceleration(absl::nullopt, false);
controller.EndMouseAccelerationSuspension();
EXPECT_FALSE(controller.input_device_settings_.GetMouseSettings()
.acceleration_enabled);

@ -49,32 +49,46 @@ class WaylandInputController : public InputController {
void SetTouchEventLoggingEnabled(bool enabled) override {
NOTIMPLEMENTED_LOG_ONCE();
}
void SetTouchpadSensitivity(int value) override {}
void SetTouchpadScrollSensitivity(int value) override {}
void SetTapToClick(bool enabled) override {}
void SetTouchpadSensitivity(absl::optional<int> device_id,
int value) override {}
void SetTouchpadScrollSensitivity(absl::optional<int> device_id,
int value) override {}
void SetTapToClick(absl::optional<int> device_id, bool enabled) override {}
void SetThreeFingerClick(bool enabled) override {}
void SetTapDragging(bool enabled) override {}
void SetNaturalScroll(bool enabled) override {}
void SetMouseSensitivity(int value) override {}
void SetMouseScrollSensitivity(int value) override {}
void SetPrimaryButtonRight(bool right) override {}
void SetMouseReverseScroll(bool enabled) override {}
void SetMouseAcceleration(bool enabled) override {}
void SetTapDragging(absl::optional<int> device_id, bool enabled) override {}
void SetNaturalScroll(absl::optional<int> device_id, bool enabled) override {}
void SetMouseSensitivity(absl::optional<int> device_id, int value) override {}
void SetMouseScrollSensitivity(absl::optional<int> device_id,
int value) override {}
void SetPrimaryButtonRight(absl::optional<int> device_id,
bool right) override {}
void SetMouseReverseScroll(absl::optional<int> device_id,
bool enabled) override {}
void SetMouseAcceleration(absl::optional<int> device_id,
bool enabled) override {}
void SuspendMouseAcceleration() override {}
void EndMouseAccelerationSuspension() override {}
void SetMouseScrollAcceleration(bool enabled) override {}
void SetPointingStickSensitivity(int value) override {}
void SetPointingStickPrimaryButtonRight(bool right) override {}
void SetPointingStickAcceleration(bool enabled) override {}
void SetMouseScrollAcceleration(absl::optional<int> device_id,
bool enabled) override {}
void SetPointingStickSensitivity(absl::optional<int> device_id,
int value) override {}
void SetPointingStickPrimaryButtonRight(absl::optional<int> device_id,
bool right) override {}
void SetPointingStickAcceleration(absl::optional<int> device_id,
bool enabled) override {}
void SetGamepadKeyBitsMapping(
base::flat_map<int, std::vector<uint64_t>> key_bits_mapping) override {}
std::vector<uint64_t> GetGamepadKeyBits(int id) override {
return std::vector<uint64_t>();
}
void SetTouchpadAcceleration(bool enabled) override {}
void SetTouchpadScrollAcceleration(bool enabled) override {}
void SetTouchpadHapticFeedback(bool enabled) override {}
void SetTouchpadHapticClickSensitivity(int value) override {}
void SetTouchpadAcceleration(absl::optional<int> device_id,
bool enabled) override {}
void SetTouchpadScrollAcceleration(absl::optional<int> device_id,
bool enabled) override {}
void SetTouchpadHapticFeedback(absl::optional<int> device_id,
bool enabled) override {}
void SetTouchpadHapticClickSensitivity(absl::optional<int> device_id,
int value) override {}
void SetTapToClickPaused(bool state) override {}
void GetTouchDeviceStatus(GetTouchDeviceStatusReply reply) override {
std::move(reply).Run(std::string());

@ -47,32 +47,46 @@ class StubInputController : public InputController {
void SetTouchEventLoggingEnabled(bool enabled) override {
NOTIMPLEMENTED_LOG_ONCE();
}
void SetTouchpadSensitivity(int value) override {}
void SetTouchpadScrollSensitivity(int value) override {}
void SetTapToClick(bool enabled) override {}
void SetThreeFingerClick(bool enabled) override {}
void SetTapDragging(bool enabled) override {}
void SetNaturalScroll(bool enabled) override {}
void SetMouseSensitivity(int value) override {}
void SetMouseScrollSensitivity(int value) override {}
void SetPrimaryButtonRight(bool right) override {}
void SetMouseReverseScroll(bool enabled) override {}
void SetMouseAcceleration(bool enabled) override {}
void SuspendMouseAcceleration() override {}
void EndMouseAccelerationSuspension() override {}
void SetMouseScrollAcceleration(bool enabled) override {}
void SetPointingStickSensitivity(int value) override {}
void SetPointingStickPrimaryButtonRight(bool right) override {}
void SetPointingStickAcceleration(bool enabled) override {}
void SetThreeFingerClick(bool enabled) override {}
void SetTouchpadSensitivity(absl::optional<int> device_id,
int value) override {}
void SetTouchpadScrollSensitivity(absl::optional<int> device_id,
int value) override {}
void SetTouchpadHapticFeedback(absl::optional<int> device_id,
bool enabled) override {}
void SetTouchpadHapticClickSensitivity(absl::optional<int> device_id,
int value) override {}
void SetTapToClick(absl::optional<int> device_id, bool enabled) override {}
void SetTapDragging(absl::optional<int> device_id, bool enabled) override {}
void SetNaturalScroll(absl::optional<int> device_id, bool enabled) override {}
void SetMouseSensitivity(absl::optional<int> device_id, int value) override {}
void SetMouseScrollSensitivity(absl::optional<int> device_id,
int value) override {}
void SetMouseReverseScroll(absl::optional<int> device_id,
bool enabled) override {}
void SetMouseAcceleration(absl::optional<int> device_id,
bool enabled) override {}
void SetMouseScrollAcceleration(absl::optional<int> device_id,
bool enabled) override {}
void SetPointingStickSensitivity(absl::optional<int> device_id,
int value) override {}
void SetPointingStickAcceleration(absl::optional<int> device_id,
bool enabled) override {}
void SetTouchpadAcceleration(absl::optional<int> device_id,
bool enabled) override {}
void SetTouchpadScrollAcceleration(absl::optional<int> device_id,
bool enabled) override {}
void SetPrimaryButtonRight(absl::optional<int> device_id,
bool right) override {}
void SetPointingStickPrimaryButtonRight(absl::optional<int> device_id,
bool right) override {}
void SetGamepadKeyBitsMapping(
base::flat_map<int, std::vector<uint64_t>> key_bits_mapping) override {}
std::vector<uint64_t> GetGamepadKeyBits(int id) override {
return std::vector<uint64_t>();
}
void SetTouchpadAcceleration(bool enabled) override {}
void SetTouchpadScrollAcceleration(bool enabled) override {}
void SetTouchpadHapticFeedback(bool enabled) override {}
void SetTouchpadHapticClickSensitivity(int value) override {}
void SetTapToClickPaused(bool state) override {}
void GetTouchDeviceStatus(GetTouchDeviceStatusReply reply) override {
std::move(reply).Run(std::string());

@ -14,6 +14,7 @@
#include "base/files/file_path.h"
#include "base/functional/callback_forward.h"
#include "mojo/public/cpp/bindings/pending_receiver.h"
#include "third_party/abseil-cpp/absl/types/optional.h"
#include "ui/ozone/public/mojom/gesture_properties_service.mojom.h"
namespace base {
@ -73,37 +74,59 @@ class COMPONENT_EXPORT(OZONE_BASE) InputController {
virtual std::vector<uint64_t> GetKeyboardKeyBits(int id) = 0;
// Touchpad settings.
virtual void SetTouchpadSensitivity(int value) = 0;
virtual void SetTouchpadScrollSensitivity(int value) = 0;
virtual void SetTapToClick(bool enabled) = 0;
// If `nullopt` is passed instead of a `device_id`, settings will be applied
// to all touchpads instead of per-device.
virtual void SetThreeFingerClick(bool enabled) = 0;
virtual void SetTapDragging(bool enabled) = 0;
virtual void SetNaturalScroll(bool enabled) = 0;
virtual void SetTouchpadAcceleration(bool enabled) = 0;
virtual void SetTouchpadScrollAcceleration(bool enabled) = 0;
virtual void SetTouchpadHapticFeedback(bool enabled) = 0;
virtual void SetTouchpadHapticClickSensitivity(int value) = 0;
virtual void SetTouchpadSensitivity(absl::optional<int> device_id,
int value) = 0;
virtual void SetTouchpadScrollSensitivity(absl::optional<int> device_id,
int value) = 0;
virtual void SetTapToClick(absl::optional<int> device_id, bool enabled) = 0;
virtual void SetTapDragging(absl::optional<int> device_id, bool enabled) = 0;
virtual void SetNaturalScroll(absl::optional<int> device_id,
bool enabled) = 0;
virtual void SetTouchpadAcceleration(absl::optional<int> device_id,
bool enabled) = 0;
virtual void SetTouchpadScrollAcceleration(absl::optional<int> device_id,
bool enabled) = 0;
virtual void SetTouchpadHapticFeedback(absl::optional<int> device_id,
bool enabled) = 0;
virtual void SetTouchpadHapticClickSensitivity(absl::optional<int> device_id,
int value) = 0;
// Mouse settings.
virtual void SetMouseSensitivity(int value) = 0;
virtual void SetMouseScrollSensitivity(int value) = 0;
// If `nullopt` is passed instead of a `device_id`, settings will be applied
// to all mice instead of per-device.
virtual void SetMouseSensitivity(absl::optional<int> device_id,
int value) = 0;
virtual void SetMouseScrollSensitivity(absl::optional<int> device_id,
int value) = 0;
// Sets the primary button for the mouse. Passing true sets the right button
// as primary, while false (the default) sets the left as primary.
virtual void SetPrimaryButtonRight(bool right) = 0;
virtual void SetMouseReverseScroll(bool enabled) = 0;
virtual void SetMouseAcceleration(bool enabled) = 0;
virtual void SetPrimaryButtonRight(absl::optional<int> device_id,
bool right) = 0;
virtual void SetMouseReverseScroll(absl::optional<int> device_id,
bool enabled) = 0;
virtual void SetMouseAcceleration(absl::optional<int> device_id,
bool enabled) = 0;
virtual void SetMouseScrollAcceleration(absl::optional<int> device_id,
bool enabled) = 0;
virtual void SuspendMouseAcceleration() = 0;
virtual void EndMouseAccelerationSuspension() = 0;
virtual void SetMouseScrollAcceleration(bool enabled) = 0;
// Pointing stick settings.
virtual void SetPointingStickSensitivity(int value) = 0;
// If `nullopt` is passed instead of a `device_id`, settings will be applied
// to all pointing sticks instead of per-device.
virtual void SetPointingStickSensitivity(absl::optional<int> device_id,
int value) = 0;
// Sets the primary button for the pointing stick. Passing true sets the right
// button as primary, while false (the default) sets the left as primary.
virtual void SetPointingStickPrimaryButtonRight(bool right) = 0;
virtual void SetPointingStickAcceleration(bool enabled) = 0;
virtual void SetPointingStickPrimaryButtonRight(absl::optional<int> device_id,
bool right) = 0;
virtual void SetPointingStickAcceleration(absl::optional<int> device_id,
bool enabled) = 0;
// Gamepad settings.
virtual void SetGamepadKeyBitsMapping(