Merge 04a2ed2 into f308a0d

michaelDCurran · web-flow · commit 5809d3a675f6 · 2020-07-30T19:28:56.000+10:00
diff --git a/nvdaHelper/remote/injection.cpp b/nvdaHelper/remote/injection.cpp
@@ -162,6 +162,8 @@ DWORD WINAPI inprocMgrThreadFunc(LPVOID data) {
 		return 0;
 	}
 	nhAssert(dllHandle==tempHandle);
+	// Flush any log messages from other threads queued before the manager thread was started. 
+	log_flushQueue();
 	//Register for all winEvents in this process.
 	inprocWinEventHookID=SetWinEventHook(EVENT_MIN,EVENT_MAX,dllHandle,inproc_winEventCallback,GetCurrentProcessId(),0,WINEVENT_INCONTEXT);
 	if(inprocWinEventHookID==0) {
@@ -240,6 +242,8 @@ DWORD WINAPI inprocMgrThreadFunc(LPVOID data) {
 	// Unregister inproc winEvent callback
 	UnhookWinEvent(inprocWinEventHookID);
 	inprocWinEventHookID=0;
+	// Flush any remaining log messages to NVDA
+	log_flushQueue();
 	//Release and close the thread mutex
 	ReleaseMutex(threadMutex);
 	CloseHandle(threadMutex);
diff --git a/nvdaHelper/remote/log.cpp b/nvdaHelper/remote/log.cpp
@@ -12,13 +12,68 @@ This license can be found at:
 http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
 */
 
+#include <string>
+#include <queue>
+#include <mutex>
 #include <crtdbg.h>
 #include "nvdaControllerInternal.h"
+#include "nvdaHelperRemote.h"
 #include <common/log.h>
 
+std::deque<std::tuple<int, std::wstring>> logQueue;
+std::mutex logQueueLock;
+
+// Fetch all available messages from the queue
+// and send them onto NvDA via rpc.
+void log_flushQueue() {
+	// Ensure this is never called from outside the manager thread.
+	if(
+		!inprocMgrThreadHandle
+		|| GetCurrentThreadId() != GetThreadId(inprocMgrThreadHandle)
+	) {
+		QueueUserAPC(log_flushQueue_apcFunc, inprocMgrThreadHandle, 0);
+		return;
+	}
+	std::deque<std::tuple<int, std::wstring>> tempQueue;
+	{
+		std::lock_guard lock{logQueueLock};
+		tempQueue.swap(logQueue);
+	}
+	for(auto& [level, msg] : tempQueue) {
+		nvdaControllerInternal_logMessage(level, GetCurrentProcessId(), msg.c_str());
+	}
+
+}
+
+void __stdcall log_flushQueue_apcFunc(ULONG_PTR data) {
+	log_flushQueue();
+}
+
 void logMessage(int level, const wchar_t* msg) {
-	if(level>LOGLEVEL_DEBUG) nvdaControllerInternal_logMessage(level,GetCurrentProcessId(),msg);
+	// Always log to any connected debugger 
 	OutputDebugString(msg);
+	if(
+		!inprocMgrThreadHandle
+		|| GetCurrentThreadId() != GetThreadId(inprocMgrThreadHandle)
+	) {
+		// either the NVDA inproc manager thread is not yet running,
+		// Or this message is being logged from outside NVDA's inproc manager thread.
+		// So as to not block any app threads,
+		// The message is queued for later fetching by  NVDA's inproc manager thread
+		{
+			std::lock_guard lock{logQueueLock};
+			logQueue.emplace_back(level, msg);
+		}
+		if(inprocMgrThreadHandle) {
+			QueueUserAPC(log_flushQueue_apcFunc, inprocMgrThreadHandle, 0);
+		}
+	} else {
+		// The message is being logged from NVDA's inproc manager thread.
+		// Log to NVDA via rpc directly.
+		// But first flush any pending log messages from other threads to ensure they are kept in the right order
+		log_flushQueue();
+		nvdaControllerInternal_logMessage(level,GetCurrentProcessId(),msg);
+	}
 }
 
 int NVDALogCrtReportHook(int reportType,const wchar_t *message,int *returnValue) {
@@ -38,4 +93,3 @@ int NVDALogCrtReportHook(int reportType,const wchar_t *message,int *returnValue)
 	*returnValue=0;
 	return true;
 }
-
diff --git a/nvdaHelper/remote/nvdaHelperRemote.h b/nvdaHelper/remote/nvdaHelperRemote.h
@@ -69,4 +69,8 @@ bool unregisterWindowsHook(int hookType, HOOKPROC hookProc);
 // The handle for NVDA's inproc manager thread
 extern HANDLE inprocMgrThreadHandle;
 
+// Flushes any remaining log messages to NVDA.
+// This should only be called from the NVDA inproc manager thread as it blocks while sending to NVDA.
+void log_flushQueue();
+
 #endif
