Remove #if ENABLE(ASSERT) in bool MutexBase::locked().

third_party/WebKit/Source/wtf/ThreadingPthreads.cpp

 /*
  * Copyright (C) 2007, 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Justin Haygood (jhaygood@reaktix.com)
  * Copyright (C) 2011 Research In Motion Limited. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
@@ skipping 92 matching lines @@
 }
 
 MutexBase::MutexBase(bool recursive)
 {
     pthread_mutexattr_t attr;
     pthread_mutexattr_init(&attr);
     pthread_mutexattr_settype(&attr, recursive ? PTHREAD_MUTEX_RECURSIVE : PTHREAD_MUTEX_NORMAL);
 
     int result = pthread_mutex_init(&m_mutex.m_internalMutex, &attr);
     ASSERT_UNUSED(result, !result);
-#if ENABLE(ASSERT)
     m_mutex.m_recursionCount = 0;
-#endif
 
     pthread_mutexattr_destroy(&attr);
 }
 
 MutexBase::~MutexBase()
 {
     int result = pthread_mutex_destroy(&m_mutex.m_internalMutex);
     ASSERT_UNUSED(result, !result);
 }
 
 void MutexBase::lock()
 {
     int result = pthread_mutex_lock(&m_mutex.m_internalMutex);
     ASSERT_UNUSED(result, !result);
-#if ENABLE(ASSERT)
     ++m_mutex.m_recursionCount;
-#endif
 }
 
 void MutexBase::unlock()
 {
-#if ENABLE(ASSERT)
     ASSERT(m_mutex.m_recursionCount);
     --m_mutex.m_recursionCount;
-#endif
     int result = pthread_mutex_unlock(&m_mutex.m_internalMutex);
     ASSERT_UNUSED(result, !result);
 }
 
 // There is a separate tryLock implementation for the Mutex and the
 // RecursiveMutex since on Windows we need to manually check if tryLock should
 // succeed or not for the non-recursive mutex. On Linux the two implementations
 // are equal except we can assert the recursion count is always zero for the
 // non-recursive mutex.
 bool Mutex::tryLock()
 {
     int result = pthread_mutex_trylock(&m_mutex.m_internalMutex);
     if (result == 0) {
-#if ENABLE(ASSERT)
         // The Mutex class is not recursive, so the recursionCount should be
         // zero after getting the lock.
         ASSERT(!m_mutex.m_recursionCount);
         ++m_mutex.m_recursionCount;
-#endif
         return true;
     }
     if (result == EBUSY)
         return false;
 
     ASSERT_NOT_REACHED();
     return false;
 }
 
 bool RecursiveMutex::tryLock()
 {
     int result = pthread_mutex_trylock(&m_mutex.m_internalMutex);
     if (result == 0) {
-#if ENABLE(ASSERT)
         ++m_mutex.m_recursionCount;
-#endif
         return true;
     }
     if (result == EBUSY)
         return false;
 
     ASSERT_NOT_REACHED();
     return false;
 }
 
 ThreadCondition::ThreadCondition()
 {
     pthread_cond_init(&m_condition, nullptr);
 }
 
 ThreadCondition::~ThreadCondition()
 {
     pthread_cond_destroy(&m_condition);
 }
 
 void ThreadCondition::wait(MutexBase& mutex)
 {
     PlatformMutex& platformMutex = mutex.impl();
     int result = pthread_cond_wait(&m_condition, &platformMutex.m_internalMutex);
     ASSERT_UNUSED(result, !result);
-#if ENABLE(ASSERT)
     ++platformMutex.m_recursionCount;
-#endif
 }
 
 bool ThreadCondition::timedWait(MutexBase& mutex, double absoluteTime)
 {
     if (absoluteTime < currentTime())
         return false;
 
     if (absoluteTime > INT_MAX) {
         wait(mutex);
         return true;
     }
 
     int timeSeconds = static_cast<int>(absoluteTime);
     int timeNanoseconds = static_cast<int>((absoluteTime - timeSeconds) * 1E9);
 
     timespec targetTime;
     targetTime.tv_sec = timeSeconds;
     targetTime.tv_nsec = timeNanoseconds;
 
     PlatformMutex& platformMutex = mutex.impl();
     int result = pthread_cond_timedwait(&m_condition, &platformMutex.m_internalMutex, &targetTime);
-#if ENABLE(ASSERT)
     ++platformMutex.m_recursionCount;
-#endif
     return result == 0;
 }
 
 void ThreadCondition::signal()
 {
     int result = pthread_cond_signal(&m_condition);
     ASSERT_UNUSED(result, !result);
 }
 
 void ThreadCondition::broadcast()
@@ skipping 17 matching lines @@
 
 void willCreateThread()
 {
     s_threadCreated = true;
 }
 #endif
 
 } // namespace WTF
 
 #endif // OS(POSIX)