Add repro for HTTP cleanup callback race

Add a unit-test-only NetworkState hook that reports whether cleanup can still cancel a request while the client's HTTP completion callback is running.

Add TestHttpCallCompletionCallbackIsNotCleanupCancelable in GlobalTests to capture the current behavior with a mocked HTTP call. The test asserts that the request should no longer be cleanup-cancelable once the client callback is executing, which reproduces the lifetime bug that will be addressed in a follow-up fix commit.

Author: jhugard

Source/Global/NetworkState.cpp

@@ -101,6 +101,21 @@ HRESULT NetworkState::HttpCallPerformAsync(HCCallHandle call, XAsyncBlock* async
     return S_OK;
 }
 
+#ifdef HC_UNITTEST_API
+bool NetworkState::CanCleanupCancelHttpRequest(XAsyncBlock* async) noexcept
+{
+    std::unique_lock<std::mutex> lock{ m_mutex };
+    for (auto activeRequest : m_activeHttpRequests)
+    {
+        if (activeRequest == async)
+        {
+            return true;
+        }
+    }
+    return false;
+}
+#endif
+
 HRESULT CALLBACK NetworkState::HttpCallPerformAsyncProvider(XAsyncOp op, const XAsyncProviderData* data)
 {
     HttpPerformContext* performContext{ static_cast<HttpPerformContext*>(data->context) };

Source/Global/NetworkState.h

@@ -48,6 +48,10 @@ class NetworkState
         XAsyncBlock* async
     ) noexcept;
 
+    #ifdef HC_UNITTEST_API
+        bool CanCleanupCancelHttpRequest(XAsyncBlock* async) noexcept;
+    #endif
+
 #ifndef HC_NOWEBSOCKETS
 public: // WebSocket
     IWebSocketProvider& WebSocketProvider() noexcept;

Tests/UnitTests/Tests/GlobalTests.cpp

@@ -159,6 +159,43 @@ DEFINE_TEST_CLASS(GlobalTests)
         VERIFY_ARE_EQUAL((DWORD)WAIT_OBJECT_0, WaitForSingleObject(cleanupCompleteEvent, INFINITE));
         CloseHandle(cleanupCompleteEvent);
     }
+
+    DEFINE_TEST_CASE(TestHttpCallCompletionCallbackIsNotCleanupCancelable)
+    {
+        VERIFY_SUCCEEDED(HCInitialize(nullptr));
+        PumpedTaskQueue pumpedQueue;
+
+        constexpr char mockUrl[]{ "www.bing.com" };
+
+        HCMockCallHandle mock{ nullptr };
+        VERIFY_SUCCEEDED(HCMockCallCreate(&mock));
+        VERIFY_SUCCEEDED(HCMockResponseSetStatusCode(mock, 200));
+        VERIFY_SUCCEEDED(HCMockAddMock(mock, "GET", mockUrl, nullptr, 0));
+
+        HCCallHandle call{ nullptr };
+        VERIFY_SUCCEEDED(HCHttpCallCreate(&call));
+        VERIFY_SUCCEEDED(HCHttpCallRequestSetUrl(call, "GET", mockUrl));
+
+        bool callbackSawCleanupCancelableRequest{ false };
+        HANDLE httpCallCompleteEvent = CreateEvent(nullptr, FALSE, FALSE, nullptr);
+
+        XAsyncThunk httpPerformThunk{ [&](XAsyncBlock* async)
+        {
+            auto httpSingleton = get_http_singleton();
+            VERIFY_IS_NOT_NULL(httpSingleton.get());
+            callbackSawCleanupCancelableRequest = httpSingleton->m_networkState->CanCleanupCancelHttpRequest(async);
+            SetEvent(httpCallCompleteEvent);
+        }, pumpedQueue.queue };
+
+        VERIFY_SUCCEEDED(HCHttpCallPerformAsync(call, &httpPerformThunk.asyncBlock));
+        VERIFY_ARE_EQUAL((DWORD)WAIT_OBJECT_0, WaitForSingleObject(httpCallCompleteEvent, INFINITE));
+
+        VERIFY_IS_FALSE(callbackSawCleanupCancelableRequest);
+
+        CloseHandle(httpCallCompleteEvent);
+        VERIFY_SUCCEEDED(HCHttpCallCloseHandle(call));
+        HCCleanup();
+    }
 };
 
 NAMESPACE_XBOX_HTTP_CLIENT_TEST_END