common/input: Avoid numerous large copies of CallbackStatus

CallbackStatus instances aren't the cheapest things to copy around
(relative to everything else), given that they're currently 520 bytes in
size and are currently copied numerous times when callbacks are invoked.

Instead, we can pass the status by const reference to avoid all the
copying.

6 files changed, 118 insertions, 92 deletions

diff --git a/src/core/hid/emulated_console.cpp b/src/core/hid/emulated_console.cpp
index 80db8e9c6d..685ec080ce 100644
--- a/src/core/hid/emulated_console.cpp
+++ b/src/core/hid/emulated_console.cpp
@@ -66,9 +66,10 @@ void EmulatedConsole::ReloadInput() {
 
     motion_devices = Common::Input::CreateDevice<Common::Input::InputDevice>(motion_params);
     if (motion_devices) {
-        Common::Input::InputCallback motion_callback{
-            [this](Common::Input::CallbackStatus callback) { SetMotion(callback); }};
-        motion_devices->SetCallback(motion_callback);
+        motion_devices->SetCallback({
+            .on_change =
+                [this](const Common::Input::CallbackStatus& callback) { SetMotion(callback); },
+        });
     }
 
     // Unique index for identifying touch device source
@@ -78,9 +79,12 @@ void EmulatedConsole::ReloadInput() {
         if (!touch_device) {
             continue;
         }
-        Common::Input::InputCallback touch_callback{
-            [this, index](Common::Input::CallbackStatus callback) { SetTouch(callback, index); }};
-        touch_device->SetCallback(touch_callback);
+        touch_device->SetCallback({
+            .on_change =
+                [this, index](const Common::Input::CallbackStatus& callback) {
+                    SetTouch(callback, index);
+                },
+        });
         index++;
     }
 }
@@ -127,7 +131,7 @@ void EmulatedConsole::SetMotionParam(Common::ParamPackage param) {
     ReloadInput();
 }
 
-void EmulatedConsole::SetMotion(Common::Input::CallbackStatus callback) {
+void EmulatedConsole::SetMotion(const Common::Input::CallbackStatus& callback) {
     std::lock_guard lock{mutex};
     auto& raw_status = console.motion_values.raw_status;
     auto& emulated = console.motion_values.emulated;
@@ -162,8 +166,7 @@ void EmulatedConsole::SetMotion(Common::Input::CallbackStatus callback) {
     TriggerOnChange(ConsoleTriggerType::Motion);
 }
 
-void EmulatedConsole::SetTouch(Common::Input::CallbackStatus callback,
-                               [[maybe_unused]] std::size_t index) {
+void EmulatedConsole::SetTouch(const Common::Input::CallbackStatus& callback, std::size_t index) {
     if (index >= console.touch_values.size()) {
         return;
     }
diff --git a/src/core/hid/emulated_console.h b/src/core/hid/emulated_console.h
index bb3d7ab907..3afd284d5b 100644
--- a/src/core/hid/emulated_console.h
+++ b/src/core/hid/emulated_console.h
@@ -155,14 +155,14 @@ private:
      * Updates the motion status of the console
      * @param callback A CallbackStatus containing gyro and accelerometer data
      */
-    void SetMotion(Common::Input::CallbackStatus callback);
+    void SetMotion(const Common::Input::CallbackStatus& callback);
 
     /**
      * Updates the touch status of the console
      * @param callback A CallbackStatus containing the touch position
      * @param index Finger ID to be updated
      */
-    void SetTouch(Common::Input::CallbackStatus callback, std::size_t index);
+    void SetTouch(const Common::Input::CallbackStatus& callback, std::size_t index);
 
     /**
      * Triggers a callback that something has changed on the console status
diff --git a/src/core/hid/emulated_controller.cpp b/src/core/hid/emulated_controller.cpp
index fbb19f2300..eb2e0ab4f9 100644
--- a/src/core/hid/emulated_controller.cpp
+++ b/src/core/hid/emulated_controller.cpp
@@ -205,11 +205,12 @@ void EmulatedController::ReloadInput() {
             continue;
         }
         const auto uuid = Common::UUID{button_params[index].Get("guid", "")};
-        Common::Input::InputCallback button_callback{
-            [this, index, uuid](Common::Input::CallbackStatus callback) {
-                SetButton(callback, index, uuid);
-            }};
-        button_devices[index]->SetCallback(button_callback);
+        button_devices[index]->SetCallback({
+            .on_change =
+                [this, index, uuid](const Common::Input::CallbackStatus& callback) {
+                    SetButton(callback, index, uuid);
+                },
+        });
         button_devices[index]->ForceUpdate();
     }
 
@@ -218,11 +219,12 @@ void EmulatedController::ReloadInput() {
             continue;
         }
         const auto uuid = Common::UUID{stick_params[index].Get("guid", "")};
-        Common::Input::InputCallback stick_callback{
-            [this, index, uuid](Common::Input::CallbackStatus callback) {
-                SetStick(callback, index, uuid);
-            }};
-        stick_devices[index]->SetCallback(stick_callback);
+        stick_devices[index]->SetCallback({
+            .on_change =
+                [this, index, uuid](const Common::Input::CallbackStatus& callback) {
+                    SetStick(callback, index, uuid);
+                },
+        });
         stick_devices[index]->ForceUpdate();
     }
 
@@ -231,11 +233,12 @@ void EmulatedController::ReloadInput() {
             continue;
         }
         const auto uuid = Common::UUID{trigger_params[index].Get("guid", "")};
-        Common::Input::InputCallback trigger_callback{
-            [this, index, uuid](Common::Input::CallbackStatus callback) {
-                SetTrigger(callback, index, uuid);
-            }};
-        trigger_devices[index]->SetCallback(trigger_callback);
+        trigger_devices[index]->SetCallback({
+            .on_change =
+                [this, index, uuid](const Common::Input::CallbackStatus& callback) {
+                    SetTrigger(callback, index, uuid);
+                },
+        });
         trigger_devices[index]->ForceUpdate();
     }
 
@@ -243,9 +246,12 @@ void EmulatedController::ReloadInput() {
         if (!battery_devices[index]) {
             continue;
         }
-        Common::Input::InputCallback battery_callback{
-            [this, index](Common::Input::CallbackStatus callback) { SetBattery(callback, index); }};
-        battery_devices[index]->SetCallback(battery_callback);
+        battery_devices[index]->SetCallback({
+            .on_change =
+                [this, index](const Common::Input::CallbackStatus& callback) {
+                    SetBattery(callback, index);
+                },
+        });
         battery_devices[index]->ForceUpdate();
     }
 
@@ -253,9 +259,12 @@ void EmulatedController::ReloadInput() {
         if (!motion_devices[index]) {
             continue;
         }
-        Common::Input::InputCallback motion_callback{
-            [this, index](Common::Input::CallbackStatus callback) { SetMotion(callback, index); }};
-        motion_devices[index]->SetCallback(motion_callback);
+        motion_devices[index]->SetCallback({
+            .on_change =
+                [this, index](const Common::Input::CallbackStatus& callback) {
+                    SetMotion(callback, index);
+                },
+        });
         motion_devices[index]->ForceUpdate();
     }
 
@@ -267,22 +276,24 @@ void EmulatedController::ReloadInput() {
         if (!tas_button_devices[index]) {
             continue;
         }
-        Common::Input::InputCallback button_callback{
-            [this, index, tas_uuid](Common::Input::CallbackStatus callback) {
-                SetButton(callback, index, tas_uuid);
-            }};
-        tas_button_devices[index]->SetCallback(button_callback);
+        tas_button_devices[index]->SetCallback({
+            .on_change =
+                [this, index, tas_uuid](const Common::Input::CallbackStatus& callback) {
+                    SetButton(callback, index, tas_uuid);
+                },
+        });
     }
 
     for (std::size_t index = 0; index < tas_stick_devices.size(); ++index) {
         if (!tas_stick_devices[index]) {
             continue;
         }
-        Common::Input::InputCallback stick_callback{
-            [this, index, tas_uuid](Common::Input::CallbackStatus callback) {
-                SetStick(callback, index, tas_uuid);
-            }};
-        tas_stick_devices[index]->SetCallback(stick_callback);
+        tas_stick_devices[index]->SetCallback({
+            .on_change =
+                [this, index, tas_uuid](const Common::Input::CallbackStatus& callback) {
+                    SetStick(callback, index, tas_uuid);
+                },
+        });
     }
 }
 
@@ -440,7 +451,7 @@ void EmulatedController::SetButtonParam(std::size_t index, Common::ParamPackage
     if (index >= button_params.size()) {
         return;
     }
-    button_params[index] = param;
+    button_params[index] = std::move(param);
     ReloadInput();
 }
 
@@ -448,7 +459,7 @@ void EmulatedController::SetStickParam(std::size_t index, Common::ParamPackage p
     if (index >= stick_params.size()) {
         return;
     }
-    stick_params[index] = param;
+    stick_params[index] = std::move(param);
     ReloadInput();
 }
 
@@ -456,11 +467,11 @@ void EmulatedController::SetMotionParam(std::size_t index, Common::ParamPackage
     if (index >= motion_params.size()) {
         return;
     }
-    motion_params[index] = param;
+    motion_params[index] = std::move(param);
     ReloadInput();
 }
 
-void EmulatedController::SetButton(Common::Input::CallbackStatus callback, std::size_t index,
+void EmulatedController::SetButton(const Common::Input::CallbackStatus& callback, std::size_t index,
                                    Common::UUID uuid) {
     if (index >= controller.button_values.size()) {
         return;
@@ -600,7 +611,7 @@ void EmulatedController::SetButton(Common::Input::CallbackStatus callback, std::
     TriggerOnChange(ControllerTriggerType::Button, true);
 }
 
-void EmulatedController::SetStick(Common::Input::CallbackStatus callback, std::size_t index,
+void EmulatedController::SetStick(const Common::Input::CallbackStatus& callback, std::size_t index,
                                   Common::UUID uuid) {
     if (index >= controller.stick_values.size()) {
         return;
@@ -650,8 +661,8 @@ void EmulatedController::SetStick(Common::Input::CallbackStatus callback, std::s
     TriggerOnChange(ControllerTriggerType::Stick, true);
 }
 
-void EmulatedController::SetTrigger(Common::Input::CallbackStatus callback, std::size_t index,
-                                    Common::UUID uuid) {
+void EmulatedController::SetTrigger(const Common::Input::CallbackStatus& callback,
+                                    std::size_t index, Common::UUID uuid) {
     if (index >= controller.trigger_values.size()) {
         return;
     }
@@ -692,7 +703,8 @@ void EmulatedController::SetTrigger(Common::Input::CallbackStatus callback, std:
     TriggerOnChange(ControllerTriggerType::Trigger, true);
 }
 
-void EmulatedController::SetMotion(Common::Input::CallbackStatus callback, std::size_t index) {
+void EmulatedController::SetMotion(const Common::Input::CallbackStatus& callback,
+                                   std::size_t index) {
     if (index >= controller.motion_values.size()) {
         return;
     }
@@ -730,7 +742,8 @@ void EmulatedController::SetMotion(Common::Input::CallbackStatus callback, std::
     TriggerOnChange(ControllerTriggerType::Motion, true);
 }
 
-void EmulatedController::SetBattery(Common::Input::CallbackStatus callback, std::size_t index) {
+void EmulatedController::SetBattery(const Common::Input::CallbackStatus& callback,
+                                    std::size_t index) {
     if (index >= controller.battery_values.size()) {
         return;
     }
@@ -1110,7 +1123,7 @@ void EmulatedController::TriggerOnChange(ControllerTriggerType type, bool is_npa
 
 int EmulatedController::SetCallback(ControllerUpdateCallback update_callback) {
     std::lock_guard lock{mutex};
-    callback_list.insert_or_assign(last_callback_key, update_callback);
+    callback_list.insert_or_assign(last_callback_key, std::move(update_callback));
     return last_callback_key++;
 }
 
diff --git a/src/core/hid/emulated_controller.h b/src/core/hid/emulated_controller.h
index 425b3e7c47..e42aafebc4 100644
--- a/src/core/hid/emulated_controller.h
+++ b/src/core/hid/emulated_controller.h
@@ -328,35 +328,38 @@ private:
      * @param callback A CallbackStatus containing the button status
      * @param index Button ID of the to be updated
      */
-    void SetButton(Common::Input::CallbackStatus callback, std::size_t index, Common::UUID uuid);
+    void SetButton(const Common::Input::CallbackStatus& callback, std::size_t index,
+                   Common::UUID uuid);
 
     /**
      * Updates the analog stick status of the controller
      * @param callback A CallbackStatus containing the analog stick status
      * @param index stick ID of the to be updated
      */
-    void SetStick(Common::Input::CallbackStatus callback, std::size_t index, Common::UUID uuid);
+    void SetStick(const Common::Input::CallbackStatus& callback, std::size_t index,
+                  Common::UUID uuid);
 
     /**
      * Updates the trigger status of the controller
      * @param callback A CallbackStatus containing the trigger status
      * @param index trigger ID of the to be updated
      */
-    void SetTrigger(Common::Input::CallbackStatus callback, std::size_t index, Common::UUID uuid);
+    void SetTrigger(const Common::Input::CallbackStatus& callback, std::size_t index,
+                    Common::UUID uuid);
 
     /**
      * Updates the motion status of the controller
      * @param callback A CallbackStatus containing gyro and accelerometer data
      * @param index motion ID of the to be updated
      */
-    void SetMotion(Common::Input::CallbackStatus callback, std::size_t index);
+    void SetMotion(const Common::Input::CallbackStatus& callback, std::size_t index);
 
     /**
      * Updates the battery status of the controller
      * @param callback A CallbackStatus containing the battery status
      * @param index Button ID of the to be updated
      */
-    void SetBattery(Common::Input::CallbackStatus callback, std::size_t index);
+    void SetBattery(const Common::Input::CallbackStatus& callback, std::size_t index);
 
     /**
      * Triggers a callback that something has changed on the controller status
diff --git a/src/core/hid/emulated_devices.cpp b/src/core/hid/emulated_devices.cpp
index 874780ec28..708480f2d8 100644
--- a/src/core/hid/emulated_devices.cpp
+++ b/src/core/hid/emulated_devices.cpp
@@ -70,50 +70,55 @@ void EmulatedDevices::ReloadInput() {
         if (!mouse_button_devices[index]) {
             continue;
         }
-        Common::Input::InputCallback button_callback{
-            [this, index](Common::Input::CallbackStatus callback) {
-                SetMouseButton(callback, index);
-            }};
-        mouse_button_devices[index]->SetCallback(button_callback);
+        mouse_button_devices[index]->SetCallback({
+            .on_change =
+                [this, index](const Common::Input::CallbackStatus& callback) {
+                    SetMouseButton(callback, index);
+                },
+        });
     }
 
     for (std::size_t index = 0; index < mouse_analog_devices.size(); ++index) {
         if (!mouse_analog_devices[index]) {
             continue;
         }
-        Common::Input::InputCallback button_callback{
-            [this, index](Common::Input::CallbackStatus callback) {
-                SetMouseAnalog(callback, index);
-            }};
-        mouse_analog_devices[index]->SetCallback(button_callback);
+        mouse_analog_devices[index]->SetCallback({
+            .on_change =
+                [this, index](const Common::Input::CallbackStatus& callback) {
+                    SetMouseAnalog(callback, index);
+                },
+        });
     }
 
     if (mouse_stick_device) {
-        Common::Input::InputCallback button_callback{
-            [this](Common::Input::CallbackStatus callback) { SetMouseStick(callback); }};
-        mouse_stick_device->SetCallback(button_callback);
+        mouse_stick_device->SetCallback({
+            .on_change =
+                [this](const Common::Input::CallbackStatus& callback) { SetMouseStick(callback); },
+        });
     }
 
     for (std::size_t index = 0; index < keyboard_devices.size(); ++index) {
         if (!keyboard_devices[index]) {
             continue;
         }
-        Common::Input::InputCallback button_callback{
-            [this, index](Common::Input::CallbackStatus callback) {
-                SetKeyboardButton(callback, index);
-            }};
-        keyboard_devices[index]->SetCallback(button_callback);
+        keyboard_devices[index]->SetCallback({
+            .on_change =
+                [this, index](const Common::Input::CallbackStatus& callback) {
+                    SetKeyboardButton(callback, index);
+                },
+        });
     }
 
     for (std::size_t index = 0; index < keyboard_modifier_devices.size(); ++index) {
         if (!keyboard_modifier_devices[index]) {
             continue;
         }
-        Common::Input::InputCallback button_callback{
-            [this, index](Common::Input::CallbackStatus callback) {
-                SetKeyboardModifier(callback, index);
-            }};
-        keyboard_modifier_devices[index]->SetCallback(button_callback);
+        keyboard_modifier_devices[index]->SetCallback({
+            .on_change =
+                [this, index](const Common::Input::CallbackStatus& callback) {
+                    SetKeyboardModifier(callback, index);
+                },
+        });
     }
 }
 
@@ -159,7 +164,8 @@ void EmulatedDevices::RestoreConfig() {
     ReloadFromSettings();
 }
 
-void EmulatedDevices::SetKeyboardButton(Common::Input::CallbackStatus callback, std::size_t index) {
+void EmulatedDevices::SetKeyboardButton(const Common::Input::CallbackStatus& callback,
+                                        std::size_t index) {
     if (index >= device_status.keyboard_values.size()) {
         return;
     }
@@ -216,7 +222,7 @@ void EmulatedDevices::UpdateKey(std::size_t key_index, bool status) {
     }
 }
 
-void EmulatedDevices::SetKeyboardModifier(Common::Input::CallbackStatus callback,
+void EmulatedDevices::SetKeyboardModifier(const Common::Input::CallbackStatus& callback,
                                           std::size_t index) {
     if (index >= device_status.keyboard_moddifier_values.size()) {
         return;
@@ -286,7 +292,8 @@ void EmulatedDevices::SetKeyboardModifier(Common::Input::CallbackStatus callback
     TriggerOnChange(DeviceTriggerType::KeyboardModdifier);
 }
 
-void EmulatedDevices::SetMouseButton(Common::Input::CallbackStatus callback, std::size_t index) {
+void EmulatedDevices::SetMouseButton(const Common::Input::CallbackStatus& callback,
+                                     std::size_t index) {
     if (index >= device_status.mouse_button_values.size()) {
         return;
     }
@@ -347,7 +354,8 @@ void EmulatedDevices::SetMouseButton(Common::Input::CallbackStatus callback, std
     TriggerOnChange(DeviceTriggerType::Mouse);
 }
 
-void EmulatedDevices::SetMouseAnalog(Common::Input::CallbackStatus callback, std::size_t index) {
+void EmulatedDevices::SetMouseAnalog(const Common::Input::CallbackStatus& callback,
+                                     std::size_t index) {
     if (index >= device_status.mouse_analog_values.size()) {
         return;
     }
@@ -374,7 +382,7 @@ void EmulatedDevices::SetMouseAnalog(Common::Input::CallbackStatus callback, std
     TriggerOnChange(DeviceTriggerType::Mouse);
 }
 
-void EmulatedDevices::SetMouseStick(Common::Input::CallbackStatus callback) {
+void EmulatedDevices::SetMouseStick(const Common::Input::CallbackStatus& callback) {
     std::lock_guard lock{mutex};
     const auto touch_value = TransformToTouch(callback);
 
@@ -435,7 +443,7 @@ void EmulatedDevices::TriggerOnChange(DeviceTriggerType type) {
 
 int EmulatedDevices::SetCallback(InterfaceUpdateCallback update_callback) {
     std::lock_guard lock{mutex};
-    callback_list.insert_or_assign(last_callback_key, update_callback);
+    callback_list.insert_or_assign(last_callback_key, std::move(update_callback));
     return last_callback_key++;
 }
 
diff --git a/src/core/hid/emulated_devices.h b/src/core/hid/emulated_devices.h
index c723276812..790d3b411e 100644
--- a/src/core/hid/emulated_devices.h
+++ b/src/core/hid/emulated_devices.h
@@ -156,35 +156,34 @@ private:
      * @param callback A CallbackStatus containing the key status
      * @param index key ID to be updated
      */
-    void SetKeyboardButton(Common::Input::CallbackStatus callback, std::size_t index);
+    void SetKeyboardButton(const Common::Input::CallbackStatus& callback, std::size_t index);
 
     /**
      * Updates the keyboard status of the keyboard device
      * @param callback A CallbackStatus containing the modifier key status
      * @param index modifier key ID to be updated
      */
-    void SetKeyboardModifier(Common::Input::CallbackStatus callback, std::size_t index);
+    void SetKeyboardModifier(const Common::Input::CallbackStatus& callback, std::size_t index);
 
     /**
      * Updates the mouse button status of the mouse device
      * @param callback A CallbackStatus containing the button status
      * @param index Button ID to be updated
      */
-    void SetMouseButton(Common::Input::CallbackStatus callback, std::size_t index);
+    void SetMouseButton(const Common::Input::CallbackStatus& callback, std::size_t index);
 
     /**
      * Updates the mouse wheel status of the mouse device
      * @param callback A CallbackStatus containing the wheel status
      * @param index wheel ID to be updated
      */
-    void SetMouseAnalog(Common::Input::CallbackStatus callback, std::size_t index);
+    void SetMouseAnalog(const Common::Input::CallbackStatus& callback, std::size_t index);
 
     /**
      * Updates the mouse position status of the mouse device
      * @param callback A CallbackStatus containing the position status
-     * @param index stick ID to be updated
      */
-    void SetMouseStick(Common::Input::CallbackStatus callback);
+    void SetMouseStick(const Common::Input::CallbackStatus& callback);
 
     /**
      * Triggers a callback that something has changed on the device status