DRTVWR-494: Use std::thread::id for LLThread::currentID().

LLThread::currentID() used to return a U32, a distinct unsigned value
incremented by explicitly constructing LLThread or by calling LLThread::
registerThreadID() early in a thread launched by other means. The latter
imposed an unobvious requirement on new code based on std::thread. Using
std::thread::id instead delegates to the compiler/library the problem of
distinguishing threads launched by any means.

Change lots of explicit U32 declarations. Introduce LLThread::id_t typedef to
avoid having to run around fixing uses again if we later revisit this decision.

LLMutex, which stores an LLThread::id_t, wants a distinguished value meaning
NO_THREAD, and had an enum with that name. But as std::thread::id promises
that the default-constructed value is distinct from every valid value,
NO_THREAD becomes unnecessary and goes away.

Because LLMutex now stores LLThread::id_t instead of U32, make llmutex.h
#include "llthread.h" instead of the other way around. This makes LLMutex an
incomplete type within llthread.h, so move LLThread::lockData() and
unlockData() to the .cpp file. Similarly, remove llrefcount.h's #include
"llmutex.h" to break circularity; instead forward-declare LLMutex.

It turns out that a number of source files assumed that #include "llthread.h"
would get the definition for LLMutex. Sprinkle #include "llmutex.h" as needed.

In the SAFE_SSL code in llcorehttp/httpcommon.cpp, there's an ssl_thread_id()
callback that returns an unsigned long to the SSL library. When LLThread::
currentID() was U32, we could simply return that. But std::thread::id is very
deliberately opaque, and can't be reinterpret_cast to unsigned long.
Fortunately it can be hashed because std::hash is specialized with that type.

1 files changed, 6 insertions, 7 deletions

diff --git a/indra/llcommon/llmutex.cpp b/indra/llcommon/llmutex.cpp
index 75f43a4704..4d73c04d07 100644
--- a/indra/llcommon/llmutex.cpp
+++ b/indra/llcommon/llmutex.cpp
@@ -32,8 +32,7 @@
 //============================================================================
 
 LLMutex::LLMutex() :
- mCount(0),
- mLockingThread(NO_THREAD)
+ mCount(0)
 {
 }
 
@@ -55,7 +54,7 @@ void LLMutex::lock()
 	
 #if MUTEX_DEBUG
 	// Have to have the lock before we can access the debug info
-	U32 id = LLThread::currentID();
+	auto id = LLThread::currentID();
 	if (mIsLocked[id] != FALSE)
 		LL_ERRS() << "Already locked in Thread: " << id << LL_ENDL;
 	mIsLocked[id] = TRUE;
@@ -74,13 +73,13 @@ void LLMutex::unlock()
 	
 #if MUTEX_DEBUG
 	// Access the debug info while we have the lock
-	U32 id = LLThread::currentID();
+	auto id = LLThread::currentID();
 	if (mIsLocked[id] != TRUE)
 		LL_ERRS() << "Not locked in Thread: " << id << LL_ENDL;	
 	mIsLocked[id] = FALSE;
 #endif
 
-	mLockingThread = NO_THREAD;
+	mLockingThread = LLThread::id_t();
 	mMutex.unlock();
 }
 
@@ -102,7 +101,7 @@ bool LLMutex::isSelfLocked()
 	return mLockingThread == LLThread::currentID();
 }
 
-U32 LLMutex::lockingThread() const
+LLThread::id_t LLMutex::lockingThread() const
 {
 	return mLockingThread;
 }
@@ -122,7 +121,7 @@ bool LLMutex::trylock()
 	
 #if MUTEX_DEBUG
 	// Have to have the lock before we can access the debug info
-	U32 id = LLThread::currentID();
+	auto id = LLThread::currentID();
 	if (mIsLocked[id] != FALSE)
 		LL_ERRS() << "Already locked in Thread: " << id << LL_ENDL;
 	mIsLocked[id] = TRUE;