fix: fix an issue with an infinite recursion in timer cancellation

Author: beekld

libs/internal/include/launchdarkly/async/promise.hpp

@@ -54,7 +54,9 @@ class Continuation<R(Args...)> {
     // function pointer, or other callable; it need not be copy-constructible.
     // F&& is a forwarding reference: accepts any callable by move or copy,
     // then moves it into Impl<F> so Continuation itself owns the callable.
-    template <typename F>
+    template <typename F,
+              typename = std::enable_if_t<
+                  !std::is_same_v<std::decay_t<F>, Continuation>>>
     Continuation(F&& f)
         : impl_(std::make_unique<Impl<std::decay_t<F>>>(std::forward<F>(f))) {}
     Continuation(Continuation&&) = default;

libs/internal/include/launchdarkly/async/timer.hpp

@@ -51,7 +51,7 @@ Future<bool> Delay(boost::asio::any_io_executor executor,
                 return {};
             },
             [executor](Continuation<void()> f) {
-                boost::asio::post(executor, f);
+                boost::asio::post(executor, std::move(f));
             });
     };
 

libs/internal/tests/cancellation_test.cpp

@@ -1,11 +1,14 @@
 #include <gtest/gtest.h>
 
+#include <boost/asio/io_context.hpp>
+
 #include <condition_variable>
 #include <memory>
 #include <mutex>
 #include <thread>
 
 #include "launchdarkly/async/cancellation.hpp"
+#include "launchdarkly/async/timer.hpp"
 
 using namespace launchdarkly::async;
 
@@ -214,3 +217,25 @@ TEST(Cancellation, SameThreadDeregister_NoDeadlock) {
 
     source.Cancel();  // cb1 fires, destroys cb2 from the same thread
 }
+
+TEST(Cancellation, TimerCancelDoesNotRecurseInContinuationConstructor) {
+    boost::asio::io_context ioc;
+    auto work = boost::asio::make_work_guard(ioc);
+    std::thread t([&] { ioc.run(); });
+
+    CancellationSource cancel;
+
+    auto future =
+        Delay(ioc.get_executor(), std::chrono::seconds(60), cancel.GetToken());
+
+    std::this_thread::sleep_for(std::chrono::milliseconds(50));
+    cancel.Cancel();
+
+    auto const result = future.WaitForResult(std::chrono::seconds(5));
+
+    ASSERT_TRUE(result.has_value());
+    EXPECT_FALSE(*result);
+
+    work.reset();
+    t.join();
+}