Merge master into DRTVWR-486

5 files changed, 95 insertions, 20 deletions

diff --git a/indra/llcommon/llapp.cpp b/indra/llcommon/llapp.cpp
index df2a066f62..8ddd132793 100644
--- a/indra/llcommon/llapp.cpp
+++ b/indra/llcommon/llapp.cpp
@@ -106,7 +106,8 @@ BOOL LLApp::sDisableCrashlogger = FALSE;
 BOOL LLApp::sLogInSignal = FALSE;
 
 // static
-LLApp::EAppStatus LLApp::sStatus = LLApp::APP_STATUS_STOPPED; // Keeps track of application status
+// Keeps track of application status
+LLScalarCond<LLApp::EAppStatus> LLApp::sStatus{LLApp::APP_STATUS_STOPPED};
 LLAppErrorHandler LLApp::sErrorHandler = NULL;
 BOOL LLApp::sErrorThreadRunning = FALSE;
 
@@ -452,7 +453,8 @@ static std::map<LLApp::EAppStatus, const char*> statusDesc
 // static
 void LLApp::setStatus(EAppStatus status)
 {
-    sStatus = status;
+    // notify everyone waiting on sStatus any time its value changes
+    sStatus.set_all(status);
 
     // This can also happen very late in the application lifecycle -- don't
     // resurrect a deleted LLSingleton
@@ -514,28 +516,28 @@ void LLApp::setStopped()
 // static
 bool LLApp::isStopped()
 {
-	return (APP_STATUS_STOPPED == sStatus);
+	return (APP_STATUS_STOPPED == sStatus.get());
 }
 
 
 // static
 bool LLApp::isRunning()
 {
-	return (APP_STATUS_RUNNING == sStatus);
+	return (APP_STATUS_RUNNING == sStatus.get());
 }
 
 
 // static
 bool LLApp::isError()
 {
-	return (APP_STATUS_ERROR == sStatus);
+	return (APP_STATUS_ERROR == sStatus.get());
 }
 
 
 // static
 bool LLApp::isQuitting()
 {
-	return (APP_STATUS_QUITTING == sStatus);
+	return (APP_STATUS_QUITTING == sStatus.get());
 }
 
 // static
diff --git a/indra/llcommon/llapp.h b/indra/llcommon/llapp.h
index 83f3bf3f93..c65fe21c9c 100644
--- a/indra/llcommon/llapp.h
+++ b/indra/llcommon/llapp.h
@@ -28,9 +28,11 @@
 #define LL_LLAPP_H
 
 #include <map>
+#include "llcond.h"
 #include "llrun.h"
 #include "llsd.h"
 #include <atomic>
+#include <chrono>
 // Forward declarations
 class LLErrorThread;
 class LLLiveFile;
@@ -207,6 +209,36 @@ public:
 	static bool isExiting(); // Either quitting or error (app is exiting, cleanly or not)
 	static int getPid();
 
+	//
+	// Sleep for specified time while still running
+	//
+	// For use by a coroutine or thread that performs some maintenance on a
+	// periodic basis. (See also LLEventTimer.) This method supports the
+	// pattern of an "infinite" loop that sleeps for some time, performs some
+	// action, then sleeps again. The trouble with literally sleeping a worker
+	// thread is that it could potentially sleep right through attempted
+	// application shutdown. This method avoids that by returning false as
+	// soon as the application status changes away from APP_STATUS_RUNNING
+	// (isRunning()).
+	//
+	// sleep() returns true if it sleeps undisturbed for the entire specified
+	// duration. The idea is that you can code 'while sleep(duration) ...',
+	// which will break the loop once shutdown begins.
+	//
+	// Since any time-based LLUnit should be implicitly convertible to
+	// F32Milliseconds, accept that specific type as a proxy.
+	static bool sleep(F32Milliseconds duration);
+	// Allow any duration defined in terms of <chrono>.
+	// One can imagine a wonderfully general bidirectional conversion system
+	// between any type derived from LLUnits::LLUnit<T, LLUnits::Seconds> and
+	// any std::chrono::duration -- but that doesn't yet exist.
+	template <typename Rep, typename Period>
+	bool sleep(const std::chrono::duration<Rep, Period>& duration)
+	{
+		// wait_for_unequal() has the opposite bool return convention
+		return ! sStatus.wait_for_unequal(duration, APP_STATUS_RUNNING);
+	}
+
 	/** @name Error handling methods */
 	//@{
 	/**
@@ -236,8 +268,8 @@ public:
 
 	// Return the Google Breakpad minidump filename after a crash.
 	char *getMiniDumpFilename() { return mMinidumpPath; }
-    std::string* getStaticDebugFile() { return &mStaticDebugFileName; }
-    std::string* getDynamicDebugFile() { return &mDynamicDebugFileName; }
+	std::string* getStaticDebugFile() { return &mStaticDebugFileName; }
+	std::string* getDynamicDebugFile() { return &mDynamicDebugFileName; }
 
 	// Write out a Google Breakpad minidump file.
 	void writeMiniDump();
@@ -265,7 +297,7 @@ public:
 protected:
 
 	static void setStatus(EAppStatus status);		// Use this to change the application status.
-	static EAppStatus sStatus; // Reflects current application status
+	static LLScalarCond<EAppStatus> sStatus; // Reflects current application status
 	static BOOL sErrorThreadRunning; // Set while the error thread is running
 	static BOOL sDisableCrashlogger; // Let the OS handle crashes for us.
 	std::wstring mCrashReportPipeStr;  //Name of pipe to use for crash reporting.
diff --git a/indra/llcommon/llerror.cpp b/indra/llcommon/llerror.cpp
index 51b0fe8be8..3fe8ce5f0e 100644
--- a/indra/llcommon/llerror.cpp
+++ b/indra/llcommon/llerror.cpp
@@ -194,23 +194,64 @@ namespace {
         {
             return LLError::getEnabledLogTypesMask() & 0x04;
         }
-        
+
+        LL_FORCE_INLINE std::string createBoldANSI()
+        {
+            std::string ansi_code;
+            ansi_code += '\033';
+            ansi_code += "[";
+            ansi_code += "1";
+            ansi_code += "m";
+
+            return ansi_code;
+        }
+
+        LL_FORCE_INLINE std::string createResetANSI()
+        {
+            std::string ansi_code;
+            ansi_code += '\033';
+            ansi_code += "[";
+            ansi_code += "0";
+            ansi_code += "m";
+
+            return ansi_code;
+        }
+
         LL_FORCE_INLINE std::string createANSI(const std::string& color)
         {
             std::string ansi_code;
-            ansi_code  += '\033';
-            ansi_code  += "[";
-            ansi_code  += color;
+            ansi_code += '\033';
+            ansi_code += "[";
+            ansi_code += "38;5;";
+            ansi_code += color;
             ansi_code += "m";
+
             return ansi_code;
         }
 
 		virtual void recordMessage(LLError::ELevel level,
 					   const std::string& message) override
 		{
-            static std::string s_ansi_error = createANSI("31"); // red
-            static std::string s_ansi_warn  = createANSI("34"); // blue
-            static std::string s_ansi_debug = createANSI("35"); // magenta
+            // The default colors for error, warn and debug are now a bit more pastel
+            // and easier to read on the default (black) terminal background but you 
+            // now have the option to set the color of each via an environment variables:
+            // LL_ANSI_ERROR_COLOR_CODE (default is red)
+            // LL_ANSI_WARN_COLOR_CODE  (default is blue)
+            // LL_ANSI_DEBUG_COLOR_CODE (default is magenta)
+            // The list of color codes can be found in many places but I used this page:
+            // https://www.lihaoyi.com/post/BuildyourownCommandLinewithANSIescapecodes.html#256-colors
+            // (Note: you may need to restart Visual Studio to pick environment changes)
+            char* val = nullptr;
+            std::string s_ansi_error_code = "160";
+            if ((val = getenv("LL_ANSI_ERROR_COLOR_CODE")) != nullptr) s_ansi_error_code = std::string(val);
+            std::string s_ansi_warn_code = "33";
+            if ((val = getenv("LL_ANSI_WARN_COLOR_CODE")) != nullptr) s_ansi_warn_code = std::string(val);
+            std::string s_ansi_debug_code = "177";
+            if ((val = getenv("LL_ANSI_DEBUG_COLOR_CODE")) != nullptr) s_ansi_debug_code = std::string(val);
+
+            static std::string s_ansi_error = createANSI(s_ansi_error_code); // default is red
+            static std::string s_ansi_warn  = createANSI(s_ansi_warn_code); // default is blue
+            static std::string s_ansi_debug = createANSI(s_ansi_debug_code); // default is magenta
 
 			if (mUseANSI)
 			{
@@ -229,11 +270,11 @@ namespace {
 
         LL_FORCE_INLINE void writeANSI(const std::string& ansi_code, const std::string& message)
 		{
-            static std::string s_ansi_bold  = createANSI("1");  // bold
-            static std::string s_ansi_reset = createANSI("0");  // reset
+            static std::string s_ansi_bold = createBoldANSI();  // bold text
+            static std::string s_ansi_reset = createResetANSI();  // reset
 			// ANSI color code escape sequence, message, and reset in one fprintf call
             // Default all message levels to bold so we can distinguish our own messages from those dumped by subprocesses and libraries.
-			fprintf(stderr, "%s%s%s\n%s", s_ansi_bold.c_str(), ansi_code.c_str(), message.c_str(), s_ansi_reset.c_str() );
+			fprintf(stderr, "%s%s\n%s", ansi_code.c_str(), message.c_str(), s_ansi_reset.c_str() );
 		}
 
 		static bool checkANSI(void)
diff --git a/indra/llcommon/llthread.h b/indra/llcommon/llthread.h
index 5cd0731f6c..50202631e7 100644
--- a/indra/llcommon/llthread.h
+++ b/indra/llcommon/llthread.h
@@ -27,7 +27,6 @@
 #ifndef LL_LLTHREAD_H
 #define LL_LLTHREAD_H
 
-#include "llapp.h"
 #include "llapr.h"
 #include "boost/intrusive_ptr.hpp"
 #include "llrefcount.h"
diff --git a/indra/llcommon/lluuid.cpp b/indra/llcommon/lluuid.cpp
index e3b293e465..acce8366ea 100644
--- a/indra/llcommon/lluuid.cpp
+++ b/indra/llcommon/lluuid.cpp
@@ -33,6 +33,7 @@
 #include <iphlpapi.h>
 #endif
 
+#include "llapp.h"
 #include "lldefs.h"
 #include "llerror.h"