Removing assert on null singleton as cases are handled with proper error handling (microsoft#477)

jasonsandlin · web-flow · commit bdb142114e58 · 2019-10-22T13:47:09.000-07:00
* Removing assert on null singleton as cases are handled with proper error handling

* Fixing test
diff --git a/Source/Common/Android/utils_android.cpp b/Source/Common/Android/utils_android.cpp
@@ -9,18 +9,23 @@ NAMESPACE_XBOX_HTTP_CLIENT_BEGIN
 
 JNIEnv* get_jvm_env()
 {
-    auto httpSingleton = xbox::httpclient::get_http_singleton(true);
-    HC_PERFORM_ENV* platformContext = httpSingleton->m_performEnv.get();
-    JavaVM* javaVm = platformContext->GetJavaVm();
+    JNIEnv* jniEnv = nullptr;
+    jint jniResult = JNI_ERR;
 
-    if (javaVm == nullptr)
+    auto httpSingleton = xbox::httpclient::get_http_singleton();
+    if (httpSingleton)
     {
-        HC_TRACE_ERROR(HTTPCLIENT, "javaVm is null");
-        throw std::runtime_error("JavaVm is null");
-    }
+        HC_PERFORM_ENV* platformContext = httpSingleton->m_performEnv.get();
+        JavaVM* javaVm = platformContext->GetJavaVm();
 
-    JNIEnv* jniEnv = nullptr;
-    jint jniResult = javaVm->GetEnv(reinterpret_cast<void**>(&jniEnv), JNI_VERSION_1_6);
+        if (javaVm == nullptr)
+        {
+            HC_TRACE_ERROR(HTTPCLIENT, "javaVm is null");
+            throw std::runtime_error("JavaVm is null");
+        }
+
+        jniResult = javaVm->GetEnv(reinterpret_cast<void**>(&jniEnv), JNI_VERSION_1_6);
+    }
 
     if (jniResult != JNI_OK)
     {
diff --git a/Source/Global/global.cpp b/Source/Global/global.cpp
@@ -41,15 +41,9 @@ http_singleton::~http_singleton()
     m_mocks.clear();
 }
 
-std::shared_ptr<http_singleton> get_http_singleton(bool assertIfNull)
+std::shared_ptr<http_singleton> get_http_singleton()
 {
     auto httpSingleton = std::atomic_load(&g_httpSingleton_atomicReadsOnly);
-    if (assertIfNull && httpSingleton == nullptr)
-    {
-        HC_TRACE_ERROR(HTTPCLIENT, "Call HCInitialize() fist");
-        ASSERT(httpSingleton != nullptr);
-    }
-
     return httpSingleton;
 }
 
diff --git a/Source/Global/global.h b/Source/Global/global.h
@@ -90,7 +90,7 @@ typedef struct http_singleton
 } http_singleton;
 
 
-std::shared_ptr<http_singleton> get_http_singleton(bool assertIfNull);
+std::shared_ptr<http_singleton> get_http_singleton();
 HRESULT init_http_singleton(HCInitArgs* args);
 void cleanup_http_singleton();
 
@@ -101,7 +101,7 @@ class shared_ptr_cache
     template<typename T>
     static void* store(std::shared_ptr<T> contextSharedPtr)
     {
-        auto httpSingleton = get_http_singleton(false);
+        auto httpSingleton = get_http_singleton();
         if (nullptr == httpSingleton)
             return nullptr;
         std::lock_guard<std::recursive_mutex> lock(httpSingleton->m_sharedPtrsLock);
@@ -115,7 +115,7 @@ class shared_ptr_cache
     template<typename T>
     static std::shared_ptr<T> fetch(void *rawContextPtr)
     {
-        auto httpSingleton = get_http_singleton(false);
+        auto httpSingleton = get_http_singleton();
         if (nullptr == httpSingleton)
             return nullptr;
 
@@ -133,7 +133,7 @@ class shared_ptr_cache
 
     static void remove(void *rawContextPtr)
     {
-        auto httpSingleton = get_http_singleton(false);
+        auto httpSingleton = get_http_singleton();
         if (nullptr == httpSingleton)
             return;
 
diff --git a/Source/Global/global_publics.cpp b/Source/Global/global_publics.cpp
@@ -44,7 +44,7 @@ STDAPI
 HCSetGlobalProxy(_In_ const char* proxyUri) noexcept
 try
 {
-    auto httpSingleton = get_http_singleton(false);
+    auto httpSingleton = get_http_singleton();
     if (nullptr == httpSingleton)
     {
         return E_HC_NOT_INITIALISED;
@@ -65,7 +65,7 @@ HCSetHttpCallPerformFunction(
         return E_INVALIDARG;
     }
 
-    auto httpSingleton = get_http_singleton(false);
+    auto httpSingleton = get_http_singleton();
     if (httpSingleton)
     {
         return E_HC_ALREADY_INITIALISED;
@@ -106,7 +106,7 @@ STDAPI_(int32_t) HCAddCallRoutedHandler(
         return -1;
     }
 
-    auto httpSingleton = get_http_singleton(true);
+    auto httpSingleton = get_http_singleton();
     if (nullptr == httpSingleton)
         return E_HC_NOT_INITIALISED;
 
@@ -120,7 +120,7 @@ STDAPI_(void) HCRemoveCallRoutedHandler(
     _In_ int32_t handlerContext
     ) noexcept
 {
-    auto httpSingleton = get_http_singleton(true);
+    auto httpSingleton = get_http_singleton();
     if (nullptr != httpSingleton)
     {
         std::lock_guard<std::recursive_mutex> lock(httpSingleton->m_callRoutedHandlersLock);
diff --git a/Source/Global/mem.cpp b/Source/Global/mem.cpp
@@ -33,7 +33,7 @@ HCMemSetFunctions(
     _In_opt_ HCMemFreeFunction memFreeFunc
     ) noexcept
 {
-    if (xbox::httpclient::get_http_singleton(false) != nullptr)
+    if (xbox::httpclient::get_http_singleton() != nullptr)
     {
         return E_HC_ALREADY_INITIALISED;
     }
diff --git a/Source/HTTP/Android/http_android.cpp b/Source/HTTP/Android/http_android.cpp
@@ -53,7 +53,14 @@ void Internal_HCHttpCallPerformAsync(
     _In_ HCPerformEnv env
 ) noexcept
 {
-    auto httpSingleton = xbox::httpclient::get_http_singleton(true);
+    auto httpSingleton = xbox::httpclient::get_http_singleton();
+    if (httpSingleton == nullptr)
+    {
+        HCHttpCallResponseSetNetworkErrorCode(call, E_HC_NOT_INITIALISED, 0);
+        XAsyncComplete(asyncBlock, E_HC_NOT_INITIALISED, 0);
+        return;
+    }
+
     std::unique_ptr<HttpRequest> httpRequest{
         new HttpRequest(
             asyncBlock,
diff --git a/Source/HTTP/WinHttp/winhttp_http_task.cpp b/Source/HTTP/WinHttp/winhttp_http_task.cpp
@@ -1053,7 +1053,7 @@ static void NetworkConnectivityHintChangedCallback(
 {
     UNREFERENCED_PARAMETER(context);
 
-    auto singleton = get_http_singleton(false);
+    auto singleton = get_http_singleton();
 
     if (singleton != nullptr)
     {
@@ -1076,7 +1076,7 @@ HRESULT Internal_InitializeHttpPlatform(HCInitArgs* args, PerformEnv& performEnv
 void Internal_CleanupHttpPlatform(HC_PERFORM_ENV* performEnv) noexcept
 {
 #if HC_PLATFORM == HC_PLATFORM_GSDK
-    auto singleton = get_http_singleton(false);
+    auto singleton = get_http_singleton();
     if (singleton != nullptr && singleton->m_networkModule != nullptr)
     {
         FreeLibrary(singleton->m_networkModule);
@@ -1159,7 +1159,7 @@ void CALLBACK Internal_HCHttpCallPerformAsync(
 #if HC_PLATFORM == HC_PLATFORM_GSDK 
     if (XGameRuntimeIsFeatureAvailable(XGameRuntimeFeature::XNetworking))
     {
-        auto singleton = get_http_singleton(true);
+        auto singleton = get_http_singleton();
         if (singleton != nullptr)
         {
             if (singleton->m_networkModule == nullptr)
diff --git a/Source/HTTP/httpcall.cpp b/Source/HTTP/httpcall.cpp
@@ -33,7 +33,7 @@ try
         return E_INVALIDARG;
     }
 
-    auto httpSingleton = get_http_singleton(true);
+    auto httpSingleton = get_http_singleton();
     if (nullptr == httpSingleton)
         return E_HC_NOT_INITIALISED;
 
@@ -105,7 +105,7 @@ HRESULT perform_http_call(
     HRESULT hr = XAsyncBegin(asyncBlock, call, reinterpret_cast<void*>(perform_http_call), __FUNCTION__,
         [](XAsyncOp opCode, const XAsyncProviderData* data)
     {
-        auto httpSingleton = get_http_singleton(false);
+        auto httpSingleton = get_http_singleton();
         if (nullptr == httpSingleton)
         {
             return E_HC_NOT_INITIALISED;
@@ -259,7 +259,7 @@ bool http_call_should_retry(
         {
             auto retryAfterTime = retryAfter + responseReceivedTime;
             http_retry_after_api_state state(retryAfterTime, httpStatus);
-            auto httpSingleton = get_http_singleton(false);
+            auto httpSingleton = get_http_singleton();
             if (httpSingleton)
             {
                 httpSingleton->set_retry_state(call->retryAfterCacheId, state);
@@ -371,7 +371,7 @@ void retry_http_call_until_done(
     _In_ HC_UNIQUE_PTR<retry_context> retryContext
     )
 {
-    auto httpSingleton = get_http_singleton(false);
+    auto httpSingleton = get_http_singleton();
     if (nullptr == httpSingleton)
     {
         HC_TRACE_WARNING(HTTPCLIENT, "Http call after HCCleanup was called. Aborting call.");
@@ -426,7 +426,7 @@ void retry_http_call_until_done(
         HC_UNIQUE_PTR<XAsyncBlock> nestedAsyncPtr{ nestedAsyncBlock };
         HC_UNIQUE_PTR<retry_context> retryContext{ static_cast<retry_context*>(nestedAsyncBlock->context) };
 
-        auto httpSingleton = get_http_singleton(false);
+        auto httpSingleton = get_http_singleton();
         if (httpSingleton == nullptr)
         {
             HC_TRACE_WARNING(HTTPCLIENT, "Http completed after HCCleanup was called. Aborting call.");
@@ -507,7 +507,7 @@ try
     HRESULT hr = XAsyncBegin(asyncBlock, retryContext.get(), reinterpret_cast<void*>(HCHttpCallPerformAsync), __FUNCTION__,
         [](_In_ XAsyncOp op, _In_ const XAsyncProviderData* data)
     {
-        auto httpSingleton = get_http_singleton(false);
+        auto httpSingleton = get_http_singleton();
         if (nullptr == httpSingleton)
         {
             return E_HC_NOT_INITIALISED;
diff --git a/Source/HTTP/httpcall_request.cpp b/Source/HTTP/httpcall_request.cpp
@@ -20,7 +20,7 @@ try
     }
     RETURN_IF_PERFORM_CALLED(call);
 
-    auto httpSingleton = get_http_singleton(true);
+    auto httpSingleton = get_http_singleton();
     if (nullptr == httpSingleton)
         return E_HC_NOT_INITIALISED;
 
@@ -46,7 +46,7 @@ try
         return E_INVALIDARG;
     }
 
-    auto httpSingleton = get_http_singleton(true);
+    auto httpSingleton = get_http_singleton();
     if (nullptr == httpSingleton)
         return E_HC_NOT_INITIALISED;
 
@@ -70,7 +70,7 @@ try
     }
     RETURN_IF_PERFORM_CALLED(call);
 
-    auto httpSingleton = get_http_singleton(true);
+    auto httpSingleton = get_http_singleton();
     if (nullptr == httpSingleton)
         return E_HC_NOT_INITIALISED;
 
@@ -278,7 +278,7 @@ try
 {
     if (call == nullptr)
     {
-        auto httpSingleton = get_http_singleton(true);
+        auto httpSingleton = get_http_singleton();
         if (nullptr == httpSingleton)
             return E_HC_NOT_INITIALISED;
 
@@ -309,7 +309,7 @@ try
 
     if (call == nullptr)
     {
-        auto httpSingleton = get_http_singleton(true);
+        auto httpSingleton = get_http_singleton();
         if (nullptr == httpSingleton)
             return E_HC_NOT_INITIALISED;
 
@@ -351,7 +351,7 @@ try
 {
     if (call == nullptr)
     {
-        auto httpSingleton = get_http_singleton(true);
+        auto httpSingleton = get_http_singleton();
         if (nullptr == httpSingleton)
             return E_HC_NOT_INITIALISED;
 
@@ -383,7 +383,7 @@ try
 
     if (call == nullptr)
     {
-        auto httpSingleton = get_http_singleton(true);
+        auto httpSingleton = get_http_singleton();
         if (nullptr == httpSingleton)
             return E_HC_NOT_INITIALISED;
 
@@ -407,7 +407,7 @@ try
 {
     if (call == nullptr)
     {
-        auto httpSingleton = get_http_singleton(true);
+        auto httpSingleton = get_http_singleton();
         if (nullptr == httpSingleton)
             return E_HC_NOT_INITIALISED;
 
@@ -439,7 +439,7 @@ try
 
     if (call == nullptr)
     {
-        auto httpSingleton = get_http_singleton(true);
+        auto httpSingleton = get_http_singleton();
         if (nullptr == httpSingleton)
             return E_HC_NOT_INITIALISED;
 
@@ -467,7 +467,7 @@ try
 
     if (call == nullptr)
     {
-        auto httpSingleton = get_http_singleton(true);
+        auto httpSingleton = get_http_singleton();
         if (nullptr == httpSingleton)
             return E_HC_NOT_INITIALISED;
 
@@ -490,7 +490,7 @@ try
 {
     if (call == nullptr)
     {
-        auto httpSingleton = get_http_singleton(true);
+        auto httpSingleton = get_http_singleton();
         if (nullptr == httpSingleton)
             return E_HC_NOT_INITIALISED;
 
diff --git a/Source/Mock/lhc_mock.cpp b/Source/Mock/lhc_mock.cpp
@@ -38,7 +38,7 @@ bool Mock_Internal_HCHttpCallPerformAsync(
     _In_ HCCallHandle originalCall
     )
 {
-    auto httpSingleton = get_http_singleton(false);
+    auto httpSingleton = get_http_singleton();
     if (nullptr == httpSingleton)
     {
         return false;
diff --git a/Source/Mock/mock_publics.cpp b/Source/Mock/mock_publics.cpp
@@ -16,7 +16,7 @@ STDAPI HCMockCallCreate(
         return E_INVALIDARG;
     }
 
-    auto httpSingleton = get_http_singleton(true);
+    auto httpSingleton = get_http_singleton();
     if (nullptr == httpSingleton)
     {
         return E_HC_NOT_INITIALISED;
@@ -46,7 +46,7 @@ try
         return E_INVALIDARG;
     }
 
-    auto httpSingleton = get_http_singleton(true);
+    auto httpSingleton = get_http_singleton();
     if (nullptr == httpSingleton)
     {
         return E_HC_NOT_INITIALISED;
@@ -99,7 +99,7 @@ STDAPI HCMockRemoveMock(
 )
 try
 {
-    auto httpSingleton = get_http_singleton(false);
+    auto httpSingleton = get_http_singleton();
     if (nullptr == httpSingleton)
     {
         return E_HC_NOT_INITIALISED;
@@ -126,7 +126,7 @@ STDAPI
 HCMockClearMocks() noexcept
 try 
 {
-    auto httpSingleton = get_http_singleton(true);
+    auto httpSingleton = get_http_singleton();
     if (nullptr == httpSingleton)
         return E_HC_NOT_INITIALISED;
 
diff --git a/Source/WebSocket/Websocketpp/websocketpp_websocket.cpp b/Source/WebSocket/Websocketpp/websocketpp_websocket.cpp
diff --git a/Source/WebSocket/WinHTTP/winhttp_websocket.cpp b/Source/WebSocket/WinHTTP/winhttp_websocket.cpp
diff --git a/Source/WebSocket/WinRT/winrt_websocket.cpp b/Source/WebSocket/WinRT/winrt_websocket.cpp
diff --git a/Source/WebSocket/hcwebsocket.cpp b/Source/WebSocket/hcwebsocket.cpp
diff --git a/Tests/UnitTests/Tests/HttpTests.cpp b/Tests/UnitTests/Tests/HttpTests.cpp

Original file line number	Diff line number	Diff line change
`@@ -41,15 +41,9 @@ http_singleton::~http_singleton()`
`41`	`41`	`m_mocks.clear();`
`42`	`42`	`}`
`43`	`43`
`44`		`-std::shared_ptr<http_singleton> get_http_singleton(bool assertIfNull)`
	`44`	`+std::shared_ptr<http_singleton> get_http_singleton()`
`45`	`45`	`{`
`46`	`46`	`auto httpSingleton = std::atomic_load(&g_httpSingleton_atomicReadsOnly);`
`47`		`- if (assertIfNull && httpSingleton == nullptr)`
`48`		`- {`
`49`		`- HC_TRACE_ERROR(HTTPCLIENT, "Call HCInitialize() fist");`
`50`		`- ASSERT(httpSingleton != nullptr);`
`51`		`- }`
`52`		`-`
`53`	`47`	`return httpSingleton;`
`54`	`48`	`}`
`55`	`49`
Original file line number	Diff line number	Diff line change
`@@ -44,7 +44,7 @@ STDAPI`
`44`	`44`	`HCSetGlobalProxy(_In_ const char* proxyUri) noexcept`
`45`	`45`	`try`
`46`	`46`	`{`
`47`		`- auto httpSingleton = get_http_singleton(false);`
	`47`	`+ auto httpSingleton = get_http_singleton();`
`48`	`48`	`if (nullptr == httpSingleton)`
`49`	`49`	`{`
`50`	`50`	`return E_HC_NOT_INITIALISED;`
`@@ -65,7 +65,7 @@ HCSetHttpCallPerformFunction(`
`65`	`65`	`return E_INVALIDARG;`
`66`	`66`	`}`
`67`	`67`
`68`		`- auto httpSingleton = get_http_singleton(false);`
	`68`	`+ auto httpSingleton = get_http_singleton();`
`69`	`69`	`if (httpSingleton)`
`70`	`70`	`{`
`71`	`71`	`return E_HC_ALREADY_INITIALISED;`
`@@ -106,7 +106,7 @@ STDAPI_(int32_t) HCAddCallRoutedHandler(`
`106`	`106`	`return -1;`
`107`	`107`	`}`
`108`	`108`
`109`		`- auto httpSingleton = get_http_singleton(true);`
	`109`	`+ auto httpSingleton = get_http_singleton();`
`110`	`110`	`if (nullptr == httpSingleton)`
`111`	`111`	`return E_HC_NOT_INITIALISED;`
`112`	`112`
`@@ -120,7 +120,7 @@ STDAPI_(void) HCRemoveCallRoutedHandler(`
`120`	`120`	`_In_ int32_t handlerContext`
`121`	`121`	`) noexcept`
`122`	`122`	`{`
`123`		`- auto httpSingleton = get_http_singleton(true);`
	`123`	`+ auto httpSingleton = get_http_singleton();`
`124`	`124`	`if (nullptr != httpSingleton)`
`125`	`125`	`{`
`126`	`126`	`std::lock_guard<std::recursive_mutex> lock(httpSingleton->m_callRoutedHandlersLock);`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ HCMemSetFunctions(`
`33`	`33`	`_In_opt_ HCMemFreeFunction memFreeFunc`
`34`	`34`	`) noexcept`
`35`	`35`	`{`
`36`		`- if (xbox::httpclient::get_http_singleton(false) != nullptr)`
	`36`	`+ if (xbox::httpclient::get_http_singleton() != nullptr)`
`37`	`37`	`{`
`38`	`38`	`return E_HC_ALREADY_INITIALISED;`
`39`	`39`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1053,7 +1053,7 @@ static void NetworkConnectivityHintChangedCallback(`
`1053`	`1053`	`{`
`1054`	`1054`	`UNREFERENCED_PARAMETER(context);`
`1055`	`1055`
`1056`		`- auto singleton = get_http_singleton(false);`
	`1056`	`+ auto singleton = get_http_singleton();`
`1057`	`1057`
`1058`	`1058`	`if (singleton != nullptr)`
`1059`	`1059`	`{`
`@@ -1076,7 +1076,7 @@ HRESULT Internal_InitializeHttpPlatform(HCInitArgs* args, PerformEnv& performEnv`
`1076`	`1076`	`void Internal_CleanupHttpPlatform(HC_PERFORM_ENV* performEnv) noexcept`
`1077`	`1077`	`{`
`1078`	`1078`	`#if HC_PLATFORM == HC_PLATFORM_GSDK`
`1079`		`- auto singleton = get_http_singleton(false);`
	`1079`	`+ auto singleton = get_http_singleton();`
`1080`	`1080`	`if (singleton != nullptr && singleton->m_networkModule != nullptr)`
`1081`	`1081`	`{`
`1082`	`1082`	`FreeLibrary(singleton->m_networkModule);`
`@@ -1159,7 +1159,7 @@ void CALLBACK Internal_HCHttpCallPerformAsync(`
`1159`	`1159`	`#if HC_PLATFORM == HC_PLATFORM_GSDK`
`1160`	`1160`	`if (XGameRuntimeIsFeatureAvailable(XGameRuntimeFeature::XNetworking))`
`1161`	`1161`	`{`
`1162`		`- auto singleton = get_http_singleton(true);`
	`1162`	`+ auto singleton = get_http_singleton();`
`1163`	`1163`	`if (singleton != nullptr)`
`1164`	`1164`	`{`
`1165`	`1165`	`if (singleton->m_networkModule == nullptr)`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ try`
`33`	`33`	`return E_INVALIDARG;`
`34`	`34`	`}`
`35`	`35`
`36`		`- auto httpSingleton = get_http_singleton(true);`
	`36`	`+ auto httpSingleton = get_http_singleton();`
`37`	`37`	`if (nullptr == httpSingleton)`
`38`	`38`	`return E_HC_NOT_INITIALISED;`
`39`	`39`
`@@ -105,7 +105,7 @@ HRESULT perform_http_call(`
`105`	`105`	`HRESULT hr = XAsyncBegin(asyncBlock, call, reinterpret_cast<void*>(perform_http_call), __FUNCTION__,`
`106`	`106`	`[](XAsyncOp opCode, const XAsyncProviderData* data)`
`107`	`107`	`{`
`108`		`- auto httpSingleton = get_http_singleton(false);`
	`108`	`+ auto httpSingleton = get_http_singleton();`
`109`	`109`	`if (nullptr == httpSingleton)`
`110`	`110`	`{`
`111`	`111`	`return E_HC_NOT_INITIALISED;`
`@@ -259,7 +259,7 @@ bool http_call_should_retry(`
`259`	`259`	`{`
`260`	`260`	`auto retryAfterTime = retryAfter + responseReceivedTime;`
`261`	`261`	`http_retry_after_api_state state(retryAfterTime, httpStatus);`
`262`		`- auto httpSingleton = get_http_singleton(false);`
	`262`	`+ auto httpSingleton = get_http_singleton();`
`263`	`263`	`if (httpSingleton)`
`264`	`264`	`{`
`265`	`265`	`httpSingleton->set_retry_state(call->retryAfterCacheId, state);`
`@@ -371,7 +371,7 @@ void retry_http_call_until_done(`
`371`	`371`	`_In_ HC_UNIQUE_PTR<retry_context> retryContext`
`372`	`372`	`)`
`373`	`373`	`{`
`374`		`- auto httpSingleton = get_http_singleton(false);`
	`374`	`+ auto httpSingleton = get_http_singleton();`
`375`	`375`	`if (nullptr == httpSingleton)`
`376`	`376`	`{`
`377`	`377`	`HC_TRACE_WARNING(HTTPCLIENT, "Http call after HCCleanup was called. Aborting call.");`
`@@ -426,7 +426,7 @@ void retry_http_call_until_done(`
`426`	`426`	`HC_UNIQUE_PTR<XAsyncBlock> nestedAsyncPtr{ nestedAsyncBlock };`
`427`	`427`	`HC_UNIQUE_PTR<retry_context> retryContext{ static_cast<retry_context*>(nestedAsyncBlock->context) };`
`428`	`428`
`429`		`- auto httpSingleton = get_http_singleton(false);`
	`429`	`+ auto httpSingleton = get_http_singleton();`
`430`	`430`	`if (httpSingleton == nullptr)`
`431`	`431`	`{`
`432`	`432`	`HC_TRACE_WARNING(HTTPCLIENT, "Http completed after HCCleanup was called. Aborting call.");`
`@@ -507,7 +507,7 @@ try`
`507`	`507`	`HRESULT hr = XAsyncBegin(asyncBlock, retryContext.get(), reinterpret_cast<void*>(HCHttpCallPerformAsync), __FUNCTION__,`
`508`	`508`	`[](_In_ XAsyncOp op, _In_ const XAsyncProviderData* data)`
`509`	`509`	`{`
`510`		`- auto httpSingleton = get_http_singleton(false);`
	`510`	`+ auto httpSingleton = get_http_singleton();`
`511`	`511`	`if (nullptr == httpSingleton)`
`512`	`512`	`{`
`513`	`513`	`return E_HC_NOT_INITIALISED;`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ try`
`20`	`20`	`}`
`21`	`21`	`RETURN_IF_PERFORM_CALLED(call);`
`22`	`22`
`23`		`- auto httpSingleton = get_http_singleton(true);`
	`23`	`+ auto httpSingleton = get_http_singleton();`
`24`	`24`	`if (nullptr == httpSingleton)`
`25`	`25`	`return E_HC_NOT_INITIALISED;`
`26`	`26`
`@@ -46,7 +46,7 @@ try`
`46`	`46`	`return E_INVALIDARG;`
`47`	`47`	`}`
`48`	`48`
`49`		`- auto httpSingleton = get_http_singleton(true);`
	`49`	`+ auto httpSingleton = get_http_singleton();`
`50`	`50`	`if (nullptr == httpSingleton)`
`51`	`51`	`return E_HC_NOT_INITIALISED;`
`52`	`52`
`@@ -70,7 +70,7 @@ try`
`70`	`70`	`}`
`71`	`71`	`RETURN_IF_PERFORM_CALLED(call);`
`72`	`72`
`73`		`- auto httpSingleton = get_http_singleton(true);`
	`73`	`+ auto httpSingleton = get_http_singleton();`
`74`	`74`	`if (nullptr == httpSingleton)`
`75`	`75`	`return E_HC_NOT_INITIALISED;`
`76`	`76`
`@@ -278,7 +278,7 @@ try`
`278`	`278`	`{`
`279`	`279`	`if (call == nullptr)`
`280`	`280`	`{`
`281`		`- auto httpSingleton = get_http_singleton(true);`
	`281`	`+ auto httpSingleton = get_http_singleton();`
`282`	`282`	`if (nullptr == httpSingleton)`
`283`	`283`	`return E_HC_NOT_INITIALISED;`
`284`	`284`
`@@ -309,7 +309,7 @@ try`
`309`	`309`
`310`	`310`	`if (call == nullptr)`
`311`	`311`	`{`
`312`		`- auto httpSingleton = get_http_singleton(true);`
	`312`	`+ auto httpSingleton = get_http_singleton();`
`313`	`313`	`if (nullptr == httpSingleton)`
`314`	`314`	`return E_HC_NOT_INITIALISED;`
`315`	`315`
`@@ -351,7 +351,7 @@ try`
`351`	`351`	`{`
`352`	`352`	`if (call == nullptr)`
`353`	`353`	`{`
`354`		`- auto httpSingleton = get_http_singleton(true);`
	`354`	`+ auto httpSingleton = get_http_singleton();`
`355`	`355`	`if (nullptr == httpSingleton)`
`356`	`356`	`return E_HC_NOT_INITIALISED;`
`357`	`357`
`@@ -383,7 +383,7 @@ try`
`383`	`383`
`384`	`384`	`if (call == nullptr)`
`385`	`385`	`{`
`386`		`- auto httpSingleton = get_http_singleton(true);`
	`386`	`+ auto httpSingleton = get_http_singleton();`
`387`	`387`	`if (nullptr == httpSingleton)`
`388`	`388`	`return E_HC_NOT_INITIALISED;`
`389`	`389`
`@@ -407,7 +407,7 @@ try`
`407`	`407`	`{`
`408`	`408`	`if (call == nullptr)`
`409`	`409`	`{`
`410`		`- auto httpSingleton = get_http_singleton(true);`
	`410`	`+ auto httpSingleton = get_http_singleton();`
`411`	`411`	`if (nullptr == httpSingleton)`
`412`	`412`	`return E_HC_NOT_INITIALISED;`
`413`	`413`
`@@ -439,7 +439,7 @@ try`
`439`	`439`
`440`	`440`	`if (call == nullptr)`
`441`	`441`	`{`
`442`		`- auto httpSingleton = get_http_singleton(true);`
	`442`	`+ auto httpSingleton = get_http_singleton();`
`443`	`443`	`if (nullptr == httpSingleton)`
`444`	`444`	`return E_HC_NOT_INITIALISED;`
`445`	`445`
`@@ -467,7 +467,7 @@ try`
`467`	`467`
`468`	`468`	`if (call == nullptr)`
`469`	`469`	`{`
`470`		`- auto httpSingleton = get_http_singleton(true);`
	`470`	`+ auto httpSingleton = get_http_singleton();`
`471`	`471`	`if (nullptr == httpSingleton)`
`472`	`472`	`return E_HC_NOT_INITIALISED;`
`473`	`473`
`@@ -490,7 +490,7 @@ try`
`490`	`490`	`{`
`491`	`491`	`if (call == nullptr)`
`492`	`492`	`{`
`493`		`- auto httpSingleton = get_http_singleton(true);`
	`493`	`+ auto httpSingleton = get_http_singleton();`
`494`	`494`	`if (nullptr == httpSingleton)`
`495`	`495`	`return E_HC_NOT_INITIALISED;`
`496`	`496`
Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,7 @@ bool Mock_Internal_HCHttpCallPerformAsync(`
`38`	`38`	`_In_ HCCallHandle originalCall`
`39`	`39`	`)`
`40`	`40`	`{`
`41`		`- auto httpSingleton = get_http_singleton(false);`
	`41`	`+ auto httpSingleton = get_http_singleton();`
`42`	`42`	`if (nullptr == httpSingleton)`
`43`	`43`	`{`
`44`	`44`	`return false;`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ STDAPI HCMockCallCreate(`
`16`	`16`	`return E_INVALIDARG;`
`17`	`17`	`}`
`18`	`18`
`19`		`- auto httpSingleton = get_http_singleton(true);`
	`19`	`+ auto httpSingleton = get_http_singleton();`
`20`	`20`	`if (nullptr == httpSingleton)`
`21`	`21`	`{`
`22`	`22`	`return E_HC_NOT_INITIALISED;`
`@@ -46,7 +46,7 @@ try`
`46`	`46`	`return E_INVALIDARG;`
`47`	`47`	`}`
`48`	`48`
`49`		`- auto httpSingleton = get_http_singleton(true);`
	`49`	`+ auto httpSingleton = get_http_singleton();`
`50`	`50`	`if (nullptr == httpSingleton)`
`51`	`51`	`{`
`52`	`52`	`return E_HC_NOT_INITIALISED;`
`@@ -99,7 +99,7 @@ STDAPI HCMockRemoveMock(`
`99`	`99`	`)`
`100`	`100`	`try`
`101`	`101`	`{`
`102`		`- auto httpSingleton = get_http_singleton(false);`
	`102`	`+ auto httpSingleton = get_http_singleton();`
`103`	`103`	`if (nullptr == httpSingleton)`
`104`	`104`	`{`
`105`	`105`	`return E_HC_NOT_INITIALISED;`
`@@ -126,7 +126,7 @@ STDAPI`
`126`	`126`	`HCMockClearMocks() noexcept`
`127`	`127`	`try`
`128`	`128`	`{`
`129`		`- auto httpSingleton = get_http_singleton(true);`
	`129`	`+ auto httpSingleton = get_http_singleton();`
`130`	`130`	`if (nullptr == httpSingleton)`
`131`	`131`	`return E_HC_NOT_INITIALISED;`
`132`	`132`