Add stale delayed callback repro

Author: jhugard

Source/Task/TaskQueue.cpp

@@ -2363,4 +2363,20 @@ STDAPI XTaskQueueSetTestHooks(
     aq->SetTestHooks(hooks);
     return S_OK;
 }
+
+STDAPI XTaskQueueSubmitPendingCallbackForTests(
+    _In_ XTaskQueueHandle queue,
+    _In_ XTaskQueuePort port
+    ) noexcept
+{
+    referenced_ptr<ITaskQueue> aq(GetQueue(queue));
+    RETURN_HR_IF(E_GAMERUNTIME_INVALID_HANDLE, aq == nullptr);
+
+    referenced_ptr<ITaskQueuePortContext> portContext;
+    RETURN_IF_FAILED(aq->GetPortContext(port, portContext.address_of()));
+
+    auto* portImpl = static_cast<TaskQueuePortImpl*>(portContext->GetPort());
+    portImpl->SubmitPendingCallbackForTests();
+    return S_OK;
+}
 #endif

Source/Task/TaskQueueImpl.h

@@ -215,6 +215,13 @@ class TaskQueuePortImpl: public Api<ApiId::TaskQueuePort, ITaskQueuePort>
     void __stdcall SuspendPort();
     void __stdcall ResumePort();
 
+#ifdef HC_UNITTEST_API
+    void __stdcall SubmitPendingCallbackForTests()
+    {
+        SubmitPendingCallback();
+    }
+#endif
+
 private:
 
     struct WaitRegistration;

Source/Task/XTaskQueuePriv.h

@@ -74,6 +74,16 @@ STDAPI XTaskQueueSetTestHooks(
     _In_ XTaskQueueHandle queue,
     _In_ XTaskQueueTestHooks* hooks
     ) noexcept;
+
+/// <summary>
+/// Directly invokes the delayed-callback notification path for unit tests.
+/// This is used to model stale threadpool timer callbacks that were already
+/// queued before the timer was retargeted.
+/// </summary>
+STDAPI XTaskQueueSubmitPendingCallbackForTests(
+    _In_ XTaskQueueHandle queue,
+    _In_ XTaskQueuePort port
+    ) noexcept;
 #endif
 
 //----------------------------------------------------------------//

Tests/UnitTests/Tests/TaskQueueTests.cpp

@@ -2191,4 +2191,74 @@ DEFINE_TEST_CLASS(TaskQueueTests)
         {
         }
     }
+
+    DEFINE_TEST_CASE(VerifyStaleDelayedCallbackDoesNotEarlyPromoteNextPendingEntry)
+    {
+        struct CallbackState
+        {
+            std::atomic<bool> invoked{ false };
+            std::atomic<bool> canceled{ false };
+            std::atomic<uint64_t> firedAtTicks{ 0 };
+
+            static void CALLBACK Invoke(void* ctx, bool canceled)
+            {
+                auto* self = static_cast<CallbackState*>(ctx);
+                self->canceled.store(canceled, std::memory_order_release);
+                self->firedAtTicks.store(GetTickCount64(), std::memory_order_release);
+                self->invoked.store(true, std::memory_order_release);
+            }
+        };
+
+        AutoQueueHandle queue;
+        VERIFY_SUCCEEDED(XTaskQueueCreate(
+            XTaskQueueDispatchMode::Manual,
+            XTaskQueueDispatchMode::Manual,
+            &queue));
+
+        CallbackState firstState;
+        CallbackState secondState;
+
+        constexpr uint32_t firstDelayMs = 10;
+        constexpr uint32_t secondDelayMs = 1000;
+        const uint64_t submittedAt = GetTickCount64();
+
+        VERIFY_SUCCEEDED(XTaskQueueSubmitDelayedCallback(
+            queue,
+            XTaskQueuePort::Work,
+            firstDelayMs,
+            &firstState,
+            &CallbackState::Invoke));
+
+        VERIFY_SUCCEEDED(XTaskQueueSubmitDelayedCallback(
+            queue,
+            XTaskQueuePort::Work,
+            secondDelayMs,
+            &secondState,
+            &CallbackState::Invoke));
+
+        // Dispatch the first callback. The timer callback that promoted it has
+        // already re-armed the shared delayed-callback timer for secondState.
+        VERIFY_IS_TRUE(XTaskQueueDispatch(queue, XTaskQueuePort::Work, 5000));
+
+        VERIFY_IS_TRUE(firstState.invoked.load(std::memory_order_acquire));
+        VERIFY_IS_FALSE(firstState.canceled.load(std::memory_order_acquire));
+        VERIFY_IS_FALSE(secondState.invoked.load(std::memory_order_acquire));
+        VERIFY_IS_LESS_THAN(GetTickCount64() - submittedAt, static_cast<uint64_t>(500));
+
+        // Simulate a stale delayed-callback notification that was already
+        // queued before the timer was re-armed for secondState. This must not
+        // promote the later pending entry before its own deadline.
+        VERIFY_SUCCEEDED(XTaskQueueSubmitPendingCallbackForTests(queue, XTaskQueuePort::Work));
+
+        VERIFY_IS_FALSE(XTaskQueueDispatch(queue, XTaskQueuePort::Work, 0));
+        VERIFY_IS_FALSE(XTaskQueueDispatch(queue, XTaskQueuePort::Work, 200));
+        VERIFY_IS_FALSE(secondState.invoked.load(std::memory_order_acquire));
+
+        VERIFY_IS_TRUE(XTaskQueueDispatch(queue, XTaskQueuePort::Work, 2000));
+        VERIFY_IS_TRUE(secondState.invoked.load(std::memory_order_acquire));
+        VERIFY_IS_FALSE(secondState.canceled.load(std::memory_order_acquire));
+        VERIFY_IS_GREATER_THAN_OR_EQUAL(
+            secondState.firedAtTicks.load(std::memory_order_acquire) - submittedAt,
+            static_cast<uint64_t>(600));
+    }
 };