CriticalSection: Use types+methods from base/platform_thread*.*.

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
@@ skipping 24 matching lines @@
 #endif
 #endif
 }
 
 void CriticalSection::Enter() const EXCLUSIVE_LOCK_FUNCTION() {
 #if defined(WEBRTC_WIN)
   EnterCriticalSection(&crit_);
 #else
 #if defined(WEBRTC_MAC) && !USE_NATIVE_MUTEX_ON_MAC
   int spin = 3000;
-  pthread_t self = pthread_self();
+  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 (owning_thread_ != self) {
+    if (!IsThreadRefEqual(owning_thread_, self)) {
       if (AtomicOps::AcquireLoad(&lock_queue_) == 0) {
         if (AtomicOps::CompareAndSwap(&lock_queue_, 0, 1) == 0) {
           have_lock = true;
           break;
         }
       }
     } else {
       AtomicOps::Increment(&lock_queue_);
       have_lock = true;
       break;
     }
 
     sched_yield();
   } while (--spin);
 
   if (!have_lock && AtomicOps::Increment(&lock_queue_) > 1) {
     // Owning thread cannot be the current thread since TryEnter() would
     // have succeeded.
-    RTC_DCHECK(owning_thread_ != self);
+    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
   pthread_mutex_lock(&mutex_);
 #endif
 
 #if CS_DEBUG_CHECKS
   if (!recursion_count_) {
     RTC_DCHECK(!thread_);
-    thread_ = pthread_self();
+    thread_ = CurrentThreadRef();
   } else {
     RTC_DCHECK(CurrentThreadIsOwner());
   }
   ++recursion_count_;
 #endif
 #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
-  if (owning_thread_ != pthread_self()) {
+  if (!IsThreadRefEqual(owning_thread_, CurrentThreadRef())) {
     if (AtomicOps::CompareAndSwap(&lock_queue_, 0, 1) != 0)
       return false;
-    owning_thread_ = pthread_self();
+    owning_thread_ = CurrentThreadRef();
     RTC_DCHECK(!recursion_);
   } else {
     AtomicOps::Increment(&lock_queue_);
   }
   ++recursion_;
 #else
   if (pthread_mutex_trylock(&mutex_) != 0)
     return false;
 #endif
 #if CS_DEBUG_CHECKS
   if (!recursion_count_) {
     RTC_DCHECK(!thread_);
-    thread_ = pthread_self();
+    thread_ = CurrentThreadRef();
   } else {
     RTC_DCHECK(CurrentThreadIsOwner());
   }
   ++recursion_count_;
 #endif
   return true;
 #endif
 }
 void CriticalSection::Leave() const UNLOCK_FUNCTION() {
   RTC_DCHECK(CurrentThreadIsOwner());
 #if defined(WEBRTC_WIN)
   LeaveCriticalSection(&crit_);
 #else
 #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
-  RTC_DCHECK_EQ(owning_thread_, pthread_self());
+  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
   pthread_mutex_unlock(&mutex_);
 #endif
 #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
-  return pthread_equal(thread_, pthread_self());
+  return IsThreadRefEqual(thread_, CurrentThreadRef());
 #else
   return true;
 #endif  // CS_DEBUG_CHECKS
 #endif
 }
 
 bool CriticalSection::IsLocked() const {
 #if defined(WEBRTC_WIN)
   return crit_.LockCount != -1;
 #else
@@ skipping 52 matching lines @@
 GlobalLockScope::GlobalLockScope(GlobalLockPod* lock)
     : lock_(lock) {
   lock_->Lock();
 }
 
 GlobalLockScope::~GlobalLockScope() {
   lock_->Unlock();
 }
 
 }  // namespace rtc