Change thread check to race check

webrtc/base/thread_checker.h

 /*
  *  Copyright (c) 2014 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.
  */
 
@@ skipping 69 matching lines @@
 //
 // In Release mode, CalledOnValidThread will always return true.
 #if ENABLE_THREAD_CHECKER
 class LOCKABLE ThreadChecker : public ThreadCheckerImpl {
 };
 #else
 class LOCKABLE ThreadChecker : public ThreadCheckerDoNothing {
 };
 #endif  // ENABLE_THREAD_CHECKER
 
-#undef ENABLE_THREAD_CHECKER
+// TODO(solenberg): Comment!
+#if ENABLE_THREAD_CHECKER
+class LOCKABLE NonReentrantChecker : public CriticalSection {
+};
+#else
+class LOCKABLE NonReentrantChecker {
+};
+#endif  // ENABLE_THREAD_CHECKER
 
 namespace internal {
 class SCOPED_LOCKABLE AnnounceOnThread {
  public:
   template<typename ThreadLikeObject>
   explicit AnnounceOnThread(const ThreadLikeObject* thread_like_object)
       EXCLUSIVE_LOCK_FUNCTION(thread_like_object) {}
   ~AnnounceOnThread() UNLOCK_FUNCTION() {}
 
   template<typename ThreadLikeObject>
   static bool IsCurrent(const ThreadLikeObject* thread_like_object) {
     return thread_like_object->IsCurrent();
   }
   static bool IsCurrent(const rtc::ThreadChecker* checker) {
     return checker->CalledOnValidThread();
   }
 
  private:
   RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(AnnounceOnThread);
 };
 
+class SCOPED_LOCKABLE NonReentrantCheckerScope {
+ public:
+  explicit NonReentrantCheckerScope(const NonReentrantChecker& checker)
+      : try_lock_(&checker) {
+    RTC_DCHECK(try_lock_.locked());
+  }
+  ~NonReentrantCheckerScope() {}
+ private:
+  rtc::TryCritScope try_lock_;
+  RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(NonReentrantCheckerScope);
+};
 }  // namespace internal
 }  // namespace rtc
 
 // RUN_ON/ACCESS_ON/RTC_DCHECK_RUN_ON macros allows to annotate variables are
 // accessed from same thread/task queue.
 // Using tools designed to check mutexes, it checks at compile time everywhere
 // variable is access, there is a run-time dcheck thread/task queue is correct.
 //
 // class ExampleThread {
 //  public:
@@ skipping 55 matching lines @@
 // same thread/task queue.
 #define ACCESS_ON(x) THREAD_ANNOTATION_ATTRIBUTE__(guarded_by(x))
 
 // Document if a function expected to be called from same thread/task queue.
 #define RUN_ON(x) THREAD_ANNOTATION_ATTRIBUTE__(exclusive_locks_required(x))
 
 #define RTC_DCHECK_RUN_ON(thread_like_object) \
   rtc::internal::AnnounceOnThread thread_announcer(thread_like_object); \
   RTC_DCHECK(rtc::internal::AnnounceOnThread::IsCurrent(thread_like_object))
 
+// TODO(solenberg): COMMENT COMMENT COMMENT.
+#if ENABLE_THREAD_CHECKER
+#define __RTC_DCHECK_NON_REENTRANT_NAME(base, line) base ## line
+
+#define RTC_DCHECK_NON_REENTRANT(checker) \
+    rtc::internal::NonReentrantCheckerScope \
+        __RTC_DCHECK_NON_REENTRANT_NAME(checker, __LINE__)(checker);

[kwiberg-webrtc, 2016/09/20 10:55:21]

The semicolon shouldn't be here.

+#else
+#define RTC_DCHECK_NON_REENTRANT(checker)
+#endif
+
+#undef ENABLE_THREAD_CHECKER
+
 #endif  // WEBRTC_BASE_THREAD_CHECKER_H_