Merge branch 'develop' into marchcat/xcode-16

1 files changed, 26 insertions, 7 deletions

diff --git a/indra/llcommon/workqueue.h b/indra/llcommon/workqueue.h
index 9d7bbfbf7a..eb6923df0b 100644
--- a/indra/llcommon/workqueue.h
+++ b/indra/llcommon/workqueue.h
@@ -13,6 +13,7 @@
 #define LL_WORKQUEUE_H
 
 #include "llcoros.h"
+#include "llevents.h"
 #include "llexception.h"
 #include "llinstancetracker.h"
 #include "llinstancetrackersubclass.h"
@@ -116,16 +117,29 @@ namespace LL
                     ARGS&&... args);
 
         /**
-         * Post work to another WorkQueue, blocking the calling coroutine
-         * until then, returning the result to caller on completion. Optional
-         * final argument is TimePoint for WorkSchedule.
+         * Post work, blocking the calling coroutine, returning the result to
+         * caller on completion. Optional final argument is TimePoint for
+         * WorkSchedule.
          *
          * In general, we assume that each thread's default coroutine is busy
          * servicing its WorkQueue or whatever. To try to prevent mistakes, we
          * forbid calling waitForResult() from a thread's default coroutine.
          */
         template <typename CALLABLE, typename... ARGS>
-        auto waitForResult(CALLABLE&& callable, ARGS&&... args);
+        auto waitForResult(CALLABLE&& callable, ARGS&&... args)
+        {
+            checkCoroutine("waitForResult()");
+            return waitForResult_(std::forward<CALLABLE>(callable),
+                                  std::forward<ARGS>(args)...);
+        }
+
+        /**
+         * Post work, blocking the calling coroutine, returning the result to
+         * caller on completion. Optional final argument is TimePoint for
+         * WorkSchedule.
+         */
+        template <typename CALLABLE, typename... ARGS>
+        auto waitForResult_(CALLABLE&& callable, ARGS&&... args);
 
         /*--------------------------- worker API ---------------------------*/
 
@@ -194,6 +208,8 @@ namespace LL
         static std::string makeName(const std::string& name);
         void callWork(const Work& work);
 
+        LLTempBoundListener mStopListener;
+
     private:
         virtual Work pop_() = 0;
         virtual bool tryPop_(Work&) = 0;
@@ -359,6 +375,10 @@ namespace LL
      * CALLABLE that returns bool, a TimePoint and an interval at which to
      * relaunch it. As long as the callable continues returning true, BackJack
      * keeps resubmitting it to the target WorkQueue.
+     *
+     * "You go back, Jack, and do it again -- wheel turnin' round and round..."
+     * --Steely Dan, from "Can't Buy a Thrill" (1972)
+     * https://www.youtube.com/watch?v=yCgHTmv4YU8
      */
     // Why is BackJack a class and not a lambda? Because, unlike a lambda, a
     // class method gets its own 'this' pointer -- which we need to resubmit
@@ -525,7 +545,7 @@ namespace LL
                         reply,
                         // Bind the current exception to transport back to the
                         // originating WorkQueue. Once there, rethrow it.
-                        [exc = std::current_exception()](){ std::rethrow_exception(exc); });
+                        [exc = std::current_exception()]{ std::rethrow_exception(exc); });
                 }
             },
             // if caller passed a TimePoint, pass it along to post()
@@ -618,9 +638,8 @@ namespace LL
     };
 
     template <typename CALLABLE, typename... ARGS>
-    auto WorkQueueBase::waitForResult(CALLABLE&& callable, ARGS&&... args)
+    auto WorkQueueBase::waitForResult_(CALLABLE&& callable, ARGS&&... args)
     {
-        checkCoroutine("waitForResult()");
         // derive callable's return type so we can specialize for void
         return WaitForResult<CALLABLE, decltype(std::forward<CALLABLE>(callable)())>()
             (this, std::forward<CALLABLE>(callable), std::forward<ARGS>(args)...);