Use perfect forwarding in templates where possible

src/common/communication/vst3.h

@@ -382,7 +382,7 @@ class Vst3Sockets : public Sockets {
     void add_audio_processor_and_listen(
         size_t instance_id,
         std::promise<void>& socket_listening_latch,
-        F cb) {
+        F&& cb) {
         {
             std::lock_guard lock(audio_processor_sockets_mutex);
             audio_processor_sockets.try_emplace(
@@ -400,7 +400,7 @@ class Vst3Sockets : public Sockets {
         // receiving buffers for all calls. This slightly reduces the amount of
         // allocations in the audio processing loop.
         audio_processor_sockets.at(instance_id)
-            .template receive_messages<true>(std::nullopt, cb);
+            .template receive_messages<true>(std::nullopt, std::forward<F>(cb));
     }
 
     /**

src/plugin/bridges/vst3-impls/plug-view-proxy.h

@@ -138,8 +138,8 @@ class Vst3PlugViewProxyImpl : public Vst3PlugViewProxy {
      * @see Vst3HostBridge::send_mutually_recursive_message
      */
     template <typename T, typename F>
-    T run_gui_task(F f) {
-        std::packaged_task<T()> do_call(std::move(f));
+    T run_gui_task(F fn) {
+        std::packaged_task<T()> do_call(std::move(fn));
         std::future<T> do_call_response = do_call.get_future();
 
         // If `Vst3Bridge::send_mutually_recursive_message()` is currently being

src/plugin/bridges/vst3.h

@@ -210,13 +210,13 @@ class Vst3PluginBridge : PluginBridge<Vst3Sockets<std::jthread>> {
      * @see Vst3PlugViewProxyImpl::run_gui_task
      */
     template <typename F>
-    bool maybe_run_on_mutual_recursion_thread(F& cb) {
+    bool maybe_run_on_mutual_recursion_thread(F& fn) {
         // We're handling an `F&` here because we cannot copy a
         // `packged_task()`, and we need to be able to move that actual task
         std::unique_lock mutual_recursion_lock(mutual_recursion_contexts_mutex);
         if (!mutual_recursion_contexts.empty()) {
             boost::asio::dispatch(*mutual_recursion_contexts.back(),
-                                  std::move(cb));
+                                  std::move(fn));
             return true;
         } else {
             return false;

src/wine-host/bridges/vst3.h

@@ -333,8 +333,8 @@ class Vst3Bridge : public HostBridge {
      * @see Vst3Bridge::send_mutually_recursive_message
      */
     template <typename T, typename F>
-    T do_mutual_recursion_on_gui_thread(F f) {
-        std::packaged_task<T()> do_call(std::move(f));
+    T do_mutual_recursion_on_gui_thread(F fn) {
+        std::packaged_task<T()> do_call(std::move(fn));
         std::future<T> do_call_response = do_call.get_future();
 
         // If the above function is currently being called from some thread,
@@ -366,8 +366,8 @@ class Vst3Bridge : public HostBridge {
      * @see Vst3Bridge::do_mutual_recursion_on_gui_thread
      */
     template <typename T, typename F>
-    T do_mutual_recursion_on_off_thread(F f) {
-        std::packaged_task<T()> do_call(std::move(f));
+    T do_mutual_recursion_on_off_thread(F fn) {
+        std::packaged_task<T()> do_call(std::move(fn));
         std::future<T> do_call_response = do_call.get_future();
 
         std::unique_lock lock(mutual_recursion_contexts_mutex);

src/wine-host/utils.h

@@ -80,25 +80,25 @@ class Win32Thread {
      * @param parameter The parameter passed to the entry point function.
      */
     template <typename Function, typename... Args>
-    Win32Thread(Function&& f, Args&&... args)
-        : handle(
-              CreateThread(
-                  nullptr,
-                  0,
-                  reinterpret_cast<LPTHREAD_START_ROUTINE>(
-                      win32_thread_trampoline),
-                  // `std::function` does not support functions with move
-                  // captures the function has to be copy-constructable.
-                  // Function2's unique_function lets us capture and move our
-                  // arguments to the lambda so we don't end up with dangling
-                  // references.
-                  new fu2::unique_function<void()>(
-                      [f = std::move(f), ... args = std::move(args)]() mutable {
-                          f(std::move(args)...);
-                      }),
-                  0,
-                  nullptr),
-              CloseHandle) {}
+    Win32Thread(Function&& fn, Args&&... args)
+        : handle(CreateThread(
+                     nullptr,
+                     0,
+                     reinterpret_cast<LPTHREAD_START_ROUTINE>(
+                         win32_thread_trampoline),
+                     // `std::function` does not support functions with move
+                     // captures the function has to be copy-constructable.
+                     // Function2's unique_function lets us capture and move our
+                     // arguments to the lambda so we don't end up with dangling
+                     // references.
+                     new fu2::unique_function<void()>(
+                         [f = std::forward<Function>(fn),
+                          ... args = std::forward<Args>(args)]() mutable {
+                             f(std::forward<Args>(args)...);
+                         }),
+                     0,
+                     nullptr),
+                 CloseHandle) {}
 
     /**
      * Join (or wait on, since this is WIn32) the thread on shutdown, just like
@@ -254,8 +254,8 @@ class MainContext {
      * soon as possible, and thus we also won't return a future.
      */
     template <typename F>
-    void schedule_task(F fn) {
-        boost::asio::post(context, std::move(fn));
+    void schedule_task(F&& fn) {
+        boost::asio::post(context, std::forward<F>(fn));
     }
 
     /**