No compliation-flag-dependent members in CriticalSection

webrtc/base/criticalsection.cc

 /*
  *  Copyright 2015 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include "webrtc/base/criticalsection.h"
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/platform_thread.h"
 
 // TODO(tommi): Split this file up to per-platform implementation files.
 
 namespace rtc {
 
 CriticalSection::CriticalSection() {
 #if defined(WEBRTC_WIN)
   InitializeCriticalSection(&crit_);
-#else
-#if defined(WEBRTC_MAC) && !USE_NATIVE_MUTEX_ON_MAC
+#elif defined(WEBRTC_POSIX)
+# if defined(WEBRTC_MAC) && !USE_NATIVE_MUTEX_ON_MAC
   lock_queue_ = 0;
   owning_thread_ = 0;
   recursion_ = 0;
   semaphore_ = dispatch_semaphore_create(0);
-#else
+# else
   pthread_mutexattr_t mutex_attribute;
   pthread_mutexattr_init(&mutex_attribute);
   pthread_mutexattr_settype(&mutex_attribute, PTHREAD_MUTEX_RECURSIVE);
   pthread_mutex_init(&mutex_, &mutex_attribute);
   pthread_mutexattr_destroy(&mutex_attribute);
-#endif
+# endif
   CS_DEBUG_CODE(thread_ = 0);
   CS_DEBUG_CODE(recursion_count_ = 0);
+  RTC_UNUSED(thread_);
+  RTC_UNUSED(recursion_count_);
+#else  // !defined(WEBRTC_WIN) && !defined(WEBRTC_POSIX)

[nisse-webrtc, 2017/06/26 13:49:46]

I'd prefer dropping this comment, it adds litte information to the error message
on the line below, and there are no comments on the other (more interesting)
#elses and #endifs in the file.

[eladalon, 2017/06/26 14:22:32]

I've removed, though my own preference would have been to keep.

+#error Unsupported platform.
 #endif
 }
 
 CriticalSection::~CriticalSection() {
 #if defined(WEBRTC_WIN)
   DeleteCriticalSection(&crit_);
-#else
-#if defined(WEBRTC_MAC) && !USE_NATIVE_MUTEX_ON_MAC
+#elif defined(WEBRTC_POSIX)
+# if defined(WEBRTC_MAC) && !USE_NATIVE_MUTEX_ON_MAC
   dispatch_release(semaphore_);
-#else
+# else
   pthread_mutex_destroy(&mutex_);
-#endif
+# endif
+#else  // !defined(WEBRTC_WIN) && !defined(WEBRTC_POSIX)
+#error Unsupported platform.
 #endif
 }
 
 void CriticalSection::Enter() const EXCLUSIVE_LOCK_FUNCTION() {
 #if defined(WEBRTC_WIN)
   EnterCriticalSection(&crit_);
-#else
-#if defined(WEBRTC_MAC) && !USE_NATIVE_MUTEX_ON_MAC
+#elif defined(WEBRTC_POSIX)
+# if defined(WEBRTC_MAC) && !USE_NATIVE_MUTEX_ON_MAC
   int spin = 3000;
   PlatformThreadRef self = CurrentThreadRef();
   bool have_lock = false;
   do {
     // Instead of calling TryEnter() in this loop, we do two interlocked
     // operations, first a read-only one in order to avoid affecting the lock
     // cache-line while spinning, in case another thread is using the lock.
     if (!IsThreadRefEqual(owning_thread_, self)) {
       if (AtomicOps::AcquireLoad(&lock_queue_) == 0) {
         if (AtomicOps::CompareAndSwap(&lock_queue_, 0, 1) == 0) {
@@ skipping 16 matching lines @@
     RTC_DCHECK(!IsThreadRefEqual(owning_thread_, self));
     // Wait for the lock to become available.
     dispatch_semaphore_wait(semaphore_, DISPATCH_TIME_FOREVER);
     RTC_DCHECK(owning_thread_ == 0);
     RTC_DCHECK(!recursion_);
   }
 
   owning_thread_ = self;
   ++recursion_;
 
-#else
+# else
   pthread_mutex_lock(&mutex_);
-#endif
+# endif
 
-#if CS_DEBUG_CHECKS
+# if CS_DEBUG_CHECKS
   if (!recursion_count_) {
     RTC_DCHECK(!thread_);
     thread_ = CurrentThreadRef();
   } else {
     RTC_DCHECK(CurrentThreadIsOwner());
   }
   ++recursion_count_;
-#endif
+# endif
+#else  // !defined(WEBRTC_WIN) && !defined(WEBRTC_POSIX)
+#error Unsupported platform.
 #endif
 }
 
 bool CriticalSection::TryEnter() const EXCLUSIVE_TRYLOCK_FUNCTION(true) {
 #if defined(WEBRTC_WIN)
   return TryEnterCriticalSection(&crit_) != FALSE;
-#else
-#if defined(WEBRTC_MAC) && !USE_NATIVE_MUTEX_ON_MAC
+#elif defined(WEBRTC_POSIX)
+# if defined(WEBRTC_MAC) && !USE_NATIVE_MUTEX_ON_MAC
   if (!IsThreadRefEqual(owning_thread_, CurrentThreadRef())) {
     if (AtomicOps::CompareAndSwap(&lock_queue_, 0, 1) != 0)
       return false;
     owning_thread_ = CurrentThreadRef();
     RTC_DCHECK(!recursion_);
   } else {
     AtomicOps::Increment(&lock_queue_);
   }
   ++recursion_;
-#else
+# else
   if (pthread_mutex_trylock(&mutex_) != 0)
     return false;
-#endif
-#if CS_DEBUG_CHECKS
+# endif
+# if CS_DEBUG_CHECKS
   if (!recursion_count_) {
     RTC_DCHECK(!thread_);
     thread_ = CurrentThreadRef();
   } else {
     RTC_DCHECK(CurrentThreadIsOwner());
   }
   ++recursion_count_;
-#endif
+# endif
   return true;
+#else  // !defined(WEBRTC_WIN) && !defined(WEBRTC_POSIX)
+#error Unsupported platform.
 #endif
 }
+
 void CriticalSection::Leave() const UNLOCK_FUNCTION() {
   RTC_DCHECK(CurrentThreadIsOwner());
 #if defined(WEBRTC_WIN)
   LeaveCriticalSection(&crit_);
-#else
-#if CS_DEBUG_CHECKS
+#elif defined(WEBRTC_POSIX)
+# if CS_DEBUG_CHECKS
   --recursion_count_;
   RTC_DCHECK(recursion_count_ >= 0);
   if (!recursion_count_)
     thread_ = 0;
-#endif
-#if defined(WEBRTC_MAC) && !USE_NATIVE_MUTEX_ON_MAC
+# endif
+# if defined(WEBRTC_MAC) && !USE_NATIVE_MUTEX_ON_MAC
   RTC_DCHECK(IsThreadRefEqual(owning_thread_, CurrentThreadRef()));
   RTC_DCHECK_GE(recursion_, 0);
   --recursion_;
   if (!recursion_)
     owning_thread_ = 0;
 
   if (AtomicOps::Decrement(&lock_queue_) > 0 && !recursion_)
     dispatch_semaphore_signal(semaphore_);
-#else
+# else
   pthread_mutex_unlock(&mutex_);
-#endif
+# endif
+#else  // !defined(WEBRTC_WIN) && !defined(WEBRTC_POSIX)
+#error Unsupported platform.
 #endif
 }
 
 bool CriticalSection::CurrentThreadIsOwner() const {
 #if defined(WEBRTC_WIN)
   // OwningThread has type HANDLE but actually contains the Thread ID:
   // http://stackoverflow.com/questions/12675301/why-is-the-owningthread-member-of-critical-section-of-type-handle-when-it-is-de
   // Converting through size_t avoids the VS 2015 warning C4312: conversion from
   // 'type1' to 'type2' of greater size
   return crit_.OwningThread ==
          reinterpret_cast<HANDLE>(static_cast<size_t>(GetCurrentThreadId()));
-#else
-#if CS_DEBUG_CHECKS
+#elif defined(WEBRTC_POSIX)
+# if CS_DEBUG_CHECKS
   return IsThreadRefEqual(thread_, CurrentThreadRef());
-#else
+# else
   return true;
-#endif  // CS_DEBUG_CHECKS
+# endif  // CS_DEBUG_CHECKS
+#else  // !defined(WEBRTC_WIN) && !defined(WEBRTC_POSIX)
+#error Unsupported platform.
 #endif
 }
 
 CritScope::CritScope(const CriticalSection* cs) : cs_(cs) { cs_->Enter(); }
 CritScope::~CritScope() { cs_->Leave(); }
 
 TryCritScope::TryCritScope(const CriticalSection* cs)
     : cs_(cs), locked_(cs->TryEnter()) {
   CS_DEBUG_CODE(lock_was_called_ = false);
+  RTC_UNUSED(lock_was_called_);
 }
 
 TryCritScope::~TryCritScope() {
   CS_DEBUG_CODE(RTC_DCHECK(lock_was_called_));
   if (locked_)
     cs_->Leave();
 }
 
 bool TryCritScope::locked() const {
   CS_DEBUG_CODE(lock_was_called_ = true);
@@ skipping 28 matching lines @@
 GlobalLockScope::GlobalLockScope(GlobalLockPod* lock)
     : lock_(lock) {
   lock_->Lock();
 }
 
 GlobalLockScope::~GlobalLockScope() {
   lock_->Unlock();
 }
 
 }  // namespace rtc