Merge remote-tracking branch 'origin/DRTVWR-600-maint-A' into brad/merge-maint-a-to-dev

1 files changed, 50 insertions, 50 deletions

diff --git a/indra/llcommon/llmutex.h b/indra/llcommon/llmutex.h
index 2b2435da4d..6e8cf9643b 100644
--- a/indra/llcommon/llmutex.h
+++ b/indra/llcommon/llmutex.h
@@ -1,25 +1,25 @@
-/** 
+/**
  * @file llmutex.h
  * @brief Base classes for mutex and condition handling.
  *
  * $LicenseInfo:firstyear=2004&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2012, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -48,23 +48,23 @@
 class LL_COMMON_API LLMutex
 {
 public:
-	LLMutex();
-	virtual ~LLMutex();
-	
-	void lock();		// blocks
-	bool trylock();		// non-blocking, returns true if lock held.
-	void unlock();		// undefined behavior when called on mutex not being held
-	bool isLocked(); 	// non-blocking, but does do a lock/unlock so not free
-	bool isSelfLocked(); //return true if locked in a same thread
-	LLThread::id_t lockingThread() const; //get ID of locking thread
+    LLMutex();
+    virtual ~LLMutex();
+
+    void lock();        // blocks
+    bool trylock();     // non-blocking, returns true if lock held.
+    void unlock();      // undefined behavior when called on mutex not being held
+    bool isLocked();    // non-blocking, but does do a lock/unlock so not free
+    bool isSelfLocked(); //return true if locked in a same thread
+    LLThread::id_t lockingThread() const; //get ID of locking thread
 
 protected:
-	std::mutex			mMutex;
-	mutable U32			mCount;
-	mutable LLThread::id_t	mLockingThread;
-	
+    std::mutex          mMutex;
+    mutable U32         mCount;
+    mutable LLThread::id_t  mLockingThread;
+
 #if MUTEX_DEBUG
-	std::unordered_map<LLThread::id_t, bool> mIsLocked;
+    std::unordered_map<LLThread::id_t, bool> mIsLocked;
 #endif
 };
 
@@ -141,15 +141,15 @@ inline void LLSharedMutex::unlock<false>()
 class LL_COMMON_API LLCondition : public LLMutex
 {
 public:
-	LLCondition();
-	~LLCondition();
-	
-	void wait();		// blocks
-	void signal();
-	void broadcast();
-	
+    LLCondition();
+    ~LLCondition();
+
+    void wait();        // blocks
+    void signal();
+    void broadcast();
+
 protected:
-	std::condition_variable mCond;
+    std::condition_variable mCond;
 };
 
 //============================================================================
@@ -157,22 +157,22 @@ protected:
 class LLMutexLock
 {
 public:
-	LLMutexLock(LLMutex* mutex)
-	{
-		mMutex = mutex;
+    LLMutexLock(LLMutex* mutex)
+    {
+        mMutex = mutex;
 
-		if (mMutex)
-			mMutex->lock();
-	}
+        if (mMutex)
+            mMutex->lock();
+    }
 
-	~LLMutexLock()
-	{
-		if (mMutex)
-			mMutex->unlock();
-	}
+    ~LLMutexLock()
+    {
+        if (mMutex)
+            mMutex->unlock();
+    }
 
 private:
-	LLMutex* mMutex;
+    LLMutex* mMutex;
 };
 
 //============================================================================
@@ -214,18 +214,18 @@ using LLExclusiveMutexLock = LLSharedMutexLockTemplate<false>;
 class LLMutexTrylock
 {
 public:
-	LLMutexTrylock(LLMutex* mutex);
-	LLMutexTrylock(LLMutex* mutex, U32 aTries, U32 delay_ms = 10);
-	~LLMutexTrylock();
-
-	bool isLocked() const
-	{
-		return mLocked;
-	}
-	
+    LLMutexTrylock(LLMutex* mutex);
+    LLMutexTrylock(LLMutex* mutex, U32 aTries, U32 delay_ms = 10);
+    ~LLMutexTrylock();
+
+    bool isLocked() const
+    {
+        return mLocked;
+    }
+
 private:
-	LLMutex*	mMutex;
-	bool		mLocked;
+    LLMutex*    mMutex;
+    bool        mLocked;
 };
 
 //============================================================================