[redcode/crythread-2nd-pass] removed or replaced remaining CryMutex/CryLock usage with equivalent AZStd version

Signed-off-by: AMZN-ScottR <24445312+AMZN-ScottR@users.noreply.github.com>

Code/Editor/CryEdit.cpp

@@ -891,7 +891,7 @@ CCrySingleDocTemplate::Confidence CCrySingleDocTemplate::MatchDocType(LPCTSTR lp
 /////////////////////////////////////////////////////////////////////////////
 namespace
 {
-    CryMutex g_splashScreenStateLock;
+    AZStd::mutex g_splashScreenStateLock;
     enum ESplashScreenState
     {
         eSplashScreenState_Init, eSplashScreenState_Started, eSplashScreenState_Destroy
@@ -922,7 +922,7 @@ QString FormatRichTextCopyrightNotice()
 /////////////////////////////////////////////////////////////////////////////
 void CCryEditApp::ShowSplashScreen(CCryEditApp* app)
 {
-    g_splashScreenStateLock.Lock();
+    g_splashScreenStateLock.lock();
 
     CStartupLogoDialog* splashScreen = new CStartupLogoDialog(FormatVersion(app->m_pEditor->GetFileVersion()), FormatRichTextCopyrightNotice());
 
@@ -930,7 +930,7 @@ void CCryEditApp::ShowSplashScreen(CCryEditApp* app)
     g_splashScreen = splashScreen;
     g_splashScreenState = eSplashScreenState_Started;
 
-    g_splashScreenStateLock.Unlock();
+    g_splashScreenStateLock.unlock();
 
     splashScreen->show();
     // Make sure the initial paint of the splash screen occurs so we dont get stuck with a blank window
@@ -938,10 +938,10 @@ void CCryEditApp::ShowSplashScreen(CCryEditApp* app)
 
     QObject::connect(splashScreen, &QObject::destroyed, splashScreen, [=]
     {
-        g_splashScreenStateLock.Lock();
+        g_splashScreenStateLock.lock();
         g_pInitializeUIInfo = nullptr;
         g_splashScreen = nullptr;
-        g_splashScreenStateLock.Unlock();
+        g_splashScreenStateLock.unlock();
     });
 }
 
@@ -971,9 +971,9 @@ void CCryEditApp::CloseSplashScreen()
     if (CStartupLogoDialog::instance())
     {
         delete CStartupLogoDialog::instance();
-        g_splashScreenStateLock.Lock();
+        g_splashScreenStateLock.lock();
         g_splashScreenState = eSplashScreenState_Destroy;
-        g_splashScreenStateLock.Unlock();
+        g_splashScreenStateLock.unlock();
     }
 
     GetIEditor()->Notify(eNotify_OnSplashScreenDestroyed);
@@ -982,12 +982,12 @@ void CCryEditApp::CloseSplashScreen()
 /////////////////////////////////////////////////////////////////////////////
 void CCryEditApp::OutputStartupMessage(QString str)
 {
-    g_splashScreenStateLock.Lock();
+    g_splashScreenStateLock.lock();
     if (g_pInitializeUIInfo)
     {
         g_pInitializeUIInfo->SetInfoText(str.toUtf8().data());
     }
-    g_splashScreenStateLock.Unlock();
+    g_splashScreenStateLock.unlock();
 }
 
 //////////////////////////////////////////////////////////////////////////

Code/Editor/GameEngine.h

@@ -116,11 +116,11 @@ public:
 
     //! mutex used by other threads to lock up the PAK modification,
     //! so only one thread can modify the PAK at once
-    static CryMutex& GetPakModifyMutex()
+    static AZStd::recursive_mutex& GetPakModifyMutex()
     {
         //! mutex used to halt copy process while the export to game
         //! or other pak operation is done in the main thread
-        static CryMutex s_pakModifyMutex;
+        static AZStd::recursive_mutex s_pakModifyMutex;
         return s_pakModifyMutex;
     }
 

Code/Editor/GameExporter.cpp

@@ -136,7 +136,7 @@ bool CGameExporter::Export(unsigned int flags, [[maybe_unused]] EEndian eExportE
             m_settings.SetHiQuality();
         }
 
-        CryAutoLock<CryMutex> autoLock(CGameEngine::GetPakModifyMutex());
+        AZStd::lock_guard<AZStd::recursive_mutex> autoLock(CGameEngine::GetPakModifyMutex());
 
         // Close this pak file.
         if (!CloseLevelPack(m_levelPak, true))

Code/Editor/IEditorImpl.cpp

@@ -251,7 +251,7 @@ void CEditorImpl::Uninitialize()
 
 void CEditorImpl::UnloadPlugins()
 {
-    CryAutoLock<CryMutex> lock(m_pluginMutex);
+    AZStd::lock_guard<AZStd::mutex> lock(m_pluginMutex);
 
     // Flush core buses. We're about to unload DLLs and need to ensure we don't have module-owned functions left behind.
     AZ::Data::AssetBus::ExecuteQueuedEvents();
@@ -272,7 +272,7 @@ void CEditorImpl::UnloadPlugins()
 
 void CEditorImpl::LoadPlugins()
 {
-    CryAutoLock<CryMutex> lock(m_pluginMutex);
+    AZStd::lock_guard<AZStd::mutex> lock(m_pluginMutex);
 
     static const QString editor_plugins_folder("EditorPlugins");
 
@@ -1457,7 +1457,7 @@ void CEditorImpl::UnregisterNotifyListener(IEditorNotifyListener* listener)
 
 ISourceControl* CEditorImpl::GetSourceControl()
 {
-    CryAutoLock<CryMutex> lock(m_pluginMutex);
+    AZStd::lock_guard<AZStd::mutex> lock(m_pluginMutex);
 
     if (m_pSourceControl)
     {

Code/Editor/IEditorImpl.h

@@ -401,7 +401,7 @@ protected:
     IImageUtil* m_pImageUtil;  // Vladimir@conffx
     ILogFile* m_pLogFile;  // Vladimir@conffx
 
-    CryMutex m_pluginMutex; // protect any pointers that come from plugins, such as the source control cached pointer.
+    AZStd::mutex m_pluginMutex; // protect any pointers that come from plugins, such as the source control cached pointer.
     static const char* m_crashLogFileName;
 };
 

Code/Editor/Plugins/PerforcePlugin/PerforceSourceControl.cpp

@@ -22,7 +22,7 @@
 
 namespace
 {
-    CryCriticalSection g_cPerforceValues;
+    AZStd::mutex g_cPerforceValues;
 }
 
 ////////////////////////////////////////////////////////////
@@ -30,9 +30,9 @@ ULONG STDMETHODCALLTYPE CPerforceSourceControl::Release()
 {
     if ((--m_ref) == 0)
     {
-        g_cPerforceValues.Lock();
+        g_cPerforceValues.lock();
         delete this;
-        g_cPerforceValues.Unlock();
+        g_cPerforceValues.unlock();
         return 0;
     }
     else
@@ -56,7 +56,7 @@ void CPerforceSourceControl::ShowSettings()
 
 void CPerforceSourceControl::SetSourceControlState(SourceControlState state)
 {
-    CryAutoLock<CryCriticalSection> lock(g_cPerforceValues);
+    AZStd::lock_guard<AZStd::mutex> lock(g_cPerforceValues);
 
     switch (state)
     {

Code/Legacy/CryCommon/CryAssert_Linux.h

@@ -72,7 +72,7 @@ bool CryAssert(const char* szCondition, const char* szFile, unsigned int line, b
 
     static const int max_len = 4096;
     static char gs_command_str[4096];
-    static CryLockT<CRYLOCK_RECURSIVE> lock;
+    static AZStd::recursive_mutex lock;
 
     gEnv->pSystem->OnAssert(szCondition, gs_szMessage, szFile, line);
 
@@ -80,7 +80,7 @@ bool CryAssert(const char* szCondition, const char* szFile, unsigned int line, b
 
     if (!gEnv->bNoAssertDialog && !gEnv->bIgnoreAllAsserts)
     {
-        CryAutoLock< CryLockT<CRYLOCK_RECURSIVE> > lk (lock);
+        AZStd::lock_guard<AZStd::recursive_mutex> lk (lock);
         snprintf(gs_command_str, max_len, "xterm -geometry 100x20 -n 'Assert Dialog [Linux Launcher]' -T 'Assert Dialog [Linux Launcher]' -e 'BinLinux/assert_term \"%s\" \"%s\" %d \"%s\"; echo \"$?\" > .assert_return'",
             szCondition, (file_len > 60) ? szFile + (file_len - 61) : szFile, line, gs_szMessage);
         int ret = system(gs_command_str);

Code/Legacy/CryCommon/CryAssert_Mac.h

@@ -70,8 +70,6 @@ bool CryAssert(const char* szCondition, const char* szFile, unsigned int line, b
     static const int max_len = 4096;
     static char gs_command_str[4096];
 
-    static CryLockT<CRYLOCK_RECURSIVE> lock;
-
     gEnv->pSystem->OnAssert(szCondition, gs_szMessage, szFile, line);
 
     size_t file_len = strlen(szFile);

Code/Legacy/CryCommon/IMaterial.h

@@ -432,8 +432,6 @@ struct IMaterial
     virtual uint32 GetDccMaterialHash() const = 0;
     virtual void SetDccMaterialHash(uint32 hash) = 0;
 
-    virtual CryCriticalSection& GetSubMaterialResizeLock() = 0;
-
     virtual void UpdateShaderItems() = 0;
 
     // </interfuscator:shuffle>

Code/Legacy/CryCommon/MultiThread_Containers.h

@@ -34,7 +34,7 @@ namespace CryMT
     public:
         typedef T   value_type;
         typedef std::vector<T, Alloc>   container_type;
-        typedef CryAutoCriticalSection AutoLock;
+        typedef AZStd::lock_guard<AZStd::recursive_mutex> AutoLock;
 
         //////////////////////////////////////////////////////////////////////////
         // std::queue interface
@@ -46,7 +46,7 @@ namespace CryMT
         // classic pop function of queue should not be used for thread safety, use try_pop instead
         //void  pop()                           { AutoLock lock(m_cs); return v.erase(v.begin()); };
 
-        CryCriticalSection& get_lock() const { return m_cs; }
+        AZStd::recursive_mutex& get_lock() const { return m_cs; }
 
         bool   empty() const { AutoLock lock(m_cs); return v.empty(); }
         int    size() const  { AutoLock lock(m_cs); return v.size(); }
@@ -92,7 +92,7 @@ namespace CryMT
         }
     private:
         container_type v;
-        mutable CryCriticalSection m_cs;
+        mutable AZStd::recursive_mutex m_cs;
     };
 }; // namespace CryMT
 

Code/Legacy/CrySystem/LocalizedStringManager.h

@@ -309,8 +309,8 @@ private:
     TLocalizationBitfield m_availableLocalizations;
 
     //Lock for
-    mutable CryCriticalSection m_cs;
-    typedef CryAutoCriticalSection AutoLock;
+    mutable AZStd::mutex m_cs;
+    typedef AZStd::lock_guard<AZStd::mutex> AutoLock;
 };
 
 

Code/Legacy/CrySystem/Log.cpp

@@ -32,17 +32,6 @@
 #include <syslog.h>
 #endif
 
-
-// Only accept logging from the main thread.
-#ifdef WIN32
-
-#define THREAD_SAFE_LOG
-//#define THREAD_SAFE_LOG  CryAutoCriticalSection scope_lock(m_logCriticalSection);
-
-#else
-#define THREAD_SAFE_LOG
-#endif //WIN32
-
 #define LOG_BACKUP_PATH "@log@/LogBackups"
 
 #if defined(IOS)
@@ -822,13 +811,13 @@ void CLog::PushAssetScopeName(const char* sAssetType, const char* sName)
     SAssetScopeInfo as;
     as.sType = sAssetType;
     as.sName = sName;
-    CryAutoCriticalSection scope_lock(m_assetScopeQueueLock);
+    AZStd::lock_guard<AZStd::mutex> scope_lock(m_assetScopeQueueLock);
     m_assetScopeQueue.push_back(as);
 }
 
 void CLog::PopAssetScopeName()
 {
-    CryAutoCriticalSection scope_lock(m_assetScopeQueueLock);
+    AZStd::lock_guard<AZStd::mutex> scope_lock(m_assetScopeQueueLock);
     assert(!m_assetScopeQueue.empty());
     if (!m_assetScopeQueue.empty())
     {
@@ -839,7 +828,7 @@ void CLog::PopAssetScopeName()
 //////////////////////////////////////////////////////////////////////////
 const char* CLog::GetAssetScopeString()
 {
-    CryAutoCriticalSection scope_lock(m_assetScopeQueueLock);
+    AZStd::lock_guard<AZStd::mutex> scope_lock(m_assetScopeQueueLock);
 
     m_assetScopeString.clear();
     for (size_t i = 0; i < m_assetScopeQueue.size(); i++)
@@ -1470,7 +1459,7 @@ void CLog::Update()
     {
         if (!m_threadSafeMsgQueue.empty())
         {
-            CryAutoCriticalSection lock(m_threadSafeMsgQueue.get_lock());   // Get the lock and hold onto it until we clear the entire queue (prevents other threads adding more things in while we clear it)
+            AZStd::lock_guard<AZStd::recursive_mutex> lock(m_threadSafeMsgQueue.get_lock());   // Get the lock and hold onto it until we clear the entire queue (prevents other threads adding more things in while we clear it)
             // Must be called from main thread
             SLogMsg msg;
             while (m_threadSafeMsgQueue.try_pop(msg))

Code/Legacy/CrySystem/Log.h

@@ -168,7 +168,7 @@ private: // -------------------------------------------------------------------
     };
 
     std::vector<SAssetScopeInfo> m_assetScopeQueue;
-    CryCriticalSection m_assetScopeQueueLock;
+    AZStd::mutex m_assetScopeQueueLock;
     string m_assetScopeString;
 #endif
 
@@ -176,8 +176,6 @@ private: // -------------------------------------------------------------------
 
     IConsole*          m_pConsole;                                                      //
 
-    CryCriticalSection m_logCriticalSection;
-
     struct SLogHistoryItem
     {
         char str[MAX_WARNING_LENGTH];

Code/Legacy/CrySystem/SystemEventDispatcher.cpp

@@ -17,17 +17,17 @@ CSystemEventDispatcher::CSystemEventDispatcher()
 
 bool CSystemEventDispatcher::RegisterListener(ISystemEventListener* pListener)
 {
-    m_listenerRegistrationLock.Lock();
+    m_listenerRegistrationLock.lock();
     bool ret = m_listeners.Add(pListener);
-    m_listenerRegistrationLock.Unlock();
+    m_listenerRegistrationLock.unlock();
     return ret;
 }
 
 bool CSystemEventDispatcher::RemoveListener(ISystemEventListener* pListener)
 {
-    m_listenerRegistrationLock.Lock();
+    m_listenerRegistrationLock.lock();
     m_listeners.Remove(pListener);
-    m_listenerRegistrationLock.Unlock();
+    m_listenerRegistrationLock.unlock();
     return true;
 }
 
@@ -35,12 +35,12 @@ bool CSystemEventDispatcher::RemoveListener(ISystemEventListener* pListener)
 //////////////////////////////////////////////////////////////////////////
 void CSystemEventDispatcher::OnSystemEventAnyThread(ESystemEvent event, UINT_PTR wparam, UINT_PTR lparam)
 {
-    m_listenerRegistrationLock.Lock();
+    m_listenerRegistrationLock.lock();
     for (TSystemEventListeners::Notifier notifier(m_listeners); notifier.IsValid(); notifier.Next())
     {
         notifier->OnSystemEventAnyThread(event, wparam, lparam);
     }
-    m_listenerRegistrationLock.Unlock();
+    m_listenerRegistrationLock.unlock();
 }
 
 

Code/Legacy/CrySystem/SystemEventDispatcher.h

@@ -46,7 +46,7 @@ private:
 
     typedef CryMT::queue<SEventParams> TSystemEventQueue;
     TSystemEventQueue m_systemEventQueue;
-    CryCriticalSection m_listenerRegistrationLock;
+    AZStd::recursive_mutex m_listenerRegistrationLock;
 };
 
 #endif // CRYINCLUDE_CRYSYSTEM_SYSTEMEVENTDISPATCHER_H