Add thread annotation macros with RTC_ prefix.
Update samples unittests to use RTC_ versions.
BUG=webrtc:8198
Review-Url: https://codereview.webrtc.org/3011973002
Cr-Original-Commit-Position: refs/heads/master@{#19708}
Cr-Mirrored-From: https://chromium.googlesource.com/external/webrtc
Cr-Mirrored-Commit: 5301e3c3db996feb4fd622d4449f740da1064477
diff --git a/rtc_base/thread_annotations.h b/rtc_base/thread_annotations.h
index 175b6b6..b07a75e 100644
--- a/rtc_base/thread_annotations.h
+++ b/rtc_base/thread_annotations.h
@@ -20,9 +20,9 @@
#define WEBRTC_RTC_BASE_THREAD_ANNOTATIONS_H_
#if defined(__clang__) && (!defined(SWIG))
-#define THREAD_ANNOTATION_ATTRIBUTE__(x) __attribute__((x))
+#define RTC_THREAD_ANNOTATION_ATTRIBUTE__(x) __attribute__((x))
#else
-#define THREAD_ANNOTATION_ATTRIBUTE__(x) // no-op
+#define RTC_THREAD_ANNOTATION_ATTRIBUTE__(x) // no-op
#endif
// Document if a shared variable/field needs to be protected by a lock.
@@ -31,11 +31,13 @@
// indicates a shared variable should be guarded (by any lock). GUARDED_VAR
// is primarily used when the client cannot express the name of the lock.
#if !defined(GUARDED_BY)
-#define GUARDED_BY(x) THREAD_ANNOTATION_ATTRIBUTE__(guarded_by(x))
+#define GUARDED_BY(x) RTC_THREAD_ANNOTATION_ATTRIBUTE__(guarded_by(x))
#endif
+#define RTC_GUARDED_BY(x) RTC_THREAD_ANNOTATION_ATTRIBUTE__(guarded_by(x))
#if !defined(GUARDED_VAR)
-#define GUARDED_VAR THREAD_ANNOTATION_ATTRIBUTE__(guarded_var)
+#define GUARDED_VAR RTC_THREAD_ANNOTATION_ATTRIBUTE__(guarded_var)
#endif
+#define RTC_GUARDED_VAR RTC_THREAD_ANNOTATION_ATTRIBUTE__(guarded_var)
// Document if the memory location pointed to by a pointer should be guarded
// by a lock when dereferencing the pointer. Similar to GUARDED_VAR,
@@ -46,11 +48,13 @@
// guarded by mu2, q should be annotated as follows:
// int *q GUARDED_BY(mu1) PT_GUARDED_BY(mu2);
#if !defined(PT_GUARDED_BY)
-#define PT_GUARDED_BY(x) THREAD_ANNOTATION_ATTRIBUTE__(pt_guarded_by(x))
+#define PT_GUARDED_BY(x) RTC_THREAD_ANNOTATION_ATTRIBUTE__(pt_guarded_by(x))
#endif
+#define RTC_PT_GUARDED_BY(x) RTC_THREAD_ANNOTATION_ATTRIBUTE__(pt_guarded_by(x))
#if !defined(PT_GUARDED_VAR)
-#define PT_GUARDED_VAR THREAD_ANNOTATION_ATTRIBUTE__(pt_guarded_var)
+#define PT_GUARDED_VAR RTC_THREAD_ANNOTATION_ATTRIBUTE__(pt_guarded_var)
#endif
+#define RTC_PT_GUARDED_VAR RTC_THREAD_ANNOTATION_ATTRIBUTE__(pt_guarded_var)
// Document the acquisition order between locks that can be held
// simultaneously by a thread. For any two locks that need to be annotated
@@ -58,11 +62,15 @@
// (i.e. You don't have to annotate both locks with both ACQUIRED_AFTER
// and ACQUIRED_BEFORE.)
#if !defined(ACQUIRED_AFTER)
-#define ACQUIRED_AFTER(x) THREAD_ANNOTATION_ATTRIBUTE__(acquired_after(x))
+#define ACQUIRED_AFTER(x) RTC_THREAD_ANNOTATION_ATTRIBUTE__(acquired_after(x))
#endif
+#define RTC_ACQUIRED_AFTER(x) \
+ RTC_THREAD_ANNOTATION_ATTRIBUTE__(acquired_after(x))
#if !defined(ACQUIRED_BEFORE)
-#define ACQUIRED_BEFORE(x) THREAD_ANNOTATION_ATTRIBUTE__(acquired_before(x))
+#define ACQUIRED_BEFORE(x) RTC_THREAD_ANNOTATION_ATTRIBUTE__(acquired_before(x))
#endif
+#define RTC_ACQUIRED_BEFORE(x) \
+ RTC_THREAD_ANNOTATION_ATTRIBUTE__(acquired_before(x))
// The following three annotations document the lock requirements for
// functions/methods.
@@ -70,67 +78,87 @@
// Document if a function expects certain locks to be held before it is called
#if !defined(EXCLUSIVE_LOCKS_REQUIRED)
#define EXCLUSIVE_LOCKS_REQUIRED(...) \
- THREAD_ANNOTATION_ATTRIBUTE__(exclusive_locks_required(__VA_ARGS__))
+ RTC_THREAD_ANNOTATION_ATTRIBUTE__(exclusive_locks_required(__VA_ARGS__))
#endif
-
+#define RTC_EXCLUSIVE_LOCKS_REQUIRED(...) \
+ RTC_THREAD_ANNOTATION_ATTRIBUTE__(exclusive_locks_required(__VA_ARGS__))
#if !defined(SHARED_LOCKS_REQUIRED)
#define SHARED_LOCKS_REQUIRED(...) \
- THREAD_ANNOTATION_ATTRIBUTE__(shared_locks_required(__VA_ARGS__))
+ RTC_THREAD_ANNOTATION_ATTRIBUTE__(shared_locks_required(__VA_ARGS__))
#endif
+#define RTC_SHARED_LOCKS_REQUIRED(...) \
+ RTC_THREAD_ANNOTATION_ATTRIBUTE__(shared_locks_required(__VA_ARGS__))
// Document the locks acquired in the body of the function. These locks
// cannot be held when calling this function (as google3's Mutex locks are
// non-reentrant).
#if !defined(LOCKS_EXCLUDED)
#define LOCKS_EXCLUDED(...) \
- THREAD_ANNOTATION_ATTRIBUTE__(locks_excluded(__VA_ARGS__))
+ RTC_THREAD_ANNOTATION_ATTRIBUTE__(locks_excluded(__VA_ARGS__))
#endif
+#define RTC_LOCKS_EXCLUDED(...) \
+ RTC_THREAD_ANNOTATION_ATTRIBUTE__(locks_excluded(__VA_ARGS__))
// Document the lock the annotated function returns without acquiring it.
#if !defined(LOCK_RETURNED)
-#define LOCK_RETURNED(x) THREAD_ANNOTATION_ATTRIBUTE__(lock_returned(x))
+#define LOCK_RETURNED(x) RTC_THREAD_ANNOTATION_ATTRIBUTE__(lock_returned(x))
#endif
+#define RTC_LOCK_RETURNED(x) RTC_THREAD_ANNOTATION_ATTRIBUTE__(lock_returned(x))
// Document if a class/type is a lockable type (such as the Mutex class).
#if !defined(LOCKABLE)
-#define LOCKABLE THREAD_ANNOTATION_ATTRIBUTE__(lockable)
+#define LOCKABLE RTC_THREAD_ANNOTATION_ATTRIBUTE__(lockable)
#endif
+#define RTC_LOCKABLE RTC_THREAD_ANNOTATION_ATTRIBUTE__(lockable)
// Document if a class is a scoped lockable type (such as the MutexLock class).
#if !defined(SCOPED_LOCKABLE)
-#define SCOPED_LOCKABLE THREAD_ANNOTATION_ATTRIBUTE__(scoped_lockable)
+#define SCOPED_LOCKABLE RTC_THREAD_ANNOTATION_ATTRIBUTE__(scoped_lockable)
#endif
+#define RTC_SCOPED_LOCKABLE RTC_THREAD_ANNOTATION_ATTRIBUTE__(scoped_lockable)
// The following annotations specify lock and unlock primitives.
#if !defined(EXCLUSIVE_LOCK_FUNCTION)
#define EXCLUSIVE_LOCK_FUNCTION(...) \
- THREAD_ANNOTATION_ATTRIBUTE__(exclusive_lock_function(__VA_ARGS__))
+ RTC_THREAD_ANNOTATION_ATTRIBUTE__(exclusive_lock_function(__VA_ARGS__))
#endif
+#define RTC_EXCLUSIVE_LOCK_FUNCTION(...) \
+ RTC_THREAD_ANNOTATION_ATTRIBUTE__(exclusive_lock_function(__VA_ARGS__))
#if !defined(SHARED_LOCK_FUNCTION)
#define SHARED_LOCK_FUNCTION(...) \
- THREAD_ANNOTATION_ATTRIBUTE__(shared_lock_function(__VA_ARGS__))
+ RTC_THREAD_ANNOTATION_ATTRIBUTE__(shared_lock_function(__VA_ARGS__))
#endif
+#define RTC_SHARED_LOCK_FUNCTION(...) \
+ RTC_THREAD_ANNOTATION_ATTRIBUTE__(shared_lock_function(__VA_ARGS__))
#if !defined(EXCLUSIVE_TRYLOCK_FUNCTION)
#define EXCLUSIVE_TRYLOCK_FUNCTION(...) \
- THREAD_ANNOTATION_ATTRIBUTE__(exclusive_trylock_function(__VA_ARGS__))
+ RTC_THREAD_ANNOTATION_ATTRIBUTE__(exclusive_trylock_function(__VA_ARGS__))
#endif
+#define RTC_EXCLUSIVE_TRYLOCK_FUNCTION(...) \
+ RTC_THREAD_ANNOTATION_ATTRIBUTE__(exclusive_trylock_function(__VA_ARGS__))
#if !defined(SHARED_TRYLOCK_FUNCTION)
#define SHARED_TRYLOCK_FUNCTION(...) \
- THREAD_ANNOTATION_ATTRIBUTE__(shared_trylock_function(__VA_ARGS__))
+ RTC_THREAD_ANNOTATION_ATTRIBUTE__(shared_trylock_function(__VA_ARGS__))
#endif
+#define RTC_SHARED_TRYLOCK_FUNCTION(...) \
+ RTC_THREAD_ANNOTATION_ATTRIBUTE__(shared_trylock_function(__VA_ARGS__))
#if !defined(UNLOCK_FUNCTION)
#define UNLOCK_FUNCTION(...) \
- THREAD_ANNOTATION_ATTRIBUTE__(unlock_function(__VA_ARGS__))
+ RTC_THREAD_ANNOTATION_ATTRIBUTE__(unlock_function(__VA_ARGS__))
#endif
+#define RTC_UNLOCK_FUNCTION(...) \
+ RTC_THREAD_ANNOTATION_ATTRIBUTE__(unlock_function(__VA_ARGS__))
// An escape hatch for thread safety analysis to ignore the annotated function.
#if !defined(NO_THREAD_SAFETY_ANALYSIS)
#define NO_THREAD_SAFETY_ANALYSIS \
- THREAD_ANNOTATION_ATTRIBUTE__(no_thread_safety_analysis)
+ RTC_THREAD_ANNOTATION_ATTRIBUTE__(no_thread_safety_analysis)
#endif
+#define RTC_NO_THREAD_SAFETY_ANALYSIS \
+ RTC_THREAD_ANNOTATION_ATTRIBUTE__(no_thread_safety_analysis)
#endif // WEBRTC_RTC_BASE_THREAD_ANNOTATIONS_H_
diff --git a/rtc_base/thread_annotations_unittest.cc b/rtc_base/thread_annotations_unittest.cc
index a8ff014..c8c3c37 100644
--- a/rtc_base/thread_annotations_unittest.cc
+++ b/rtc_base/thread_annotations_unittest.cc
@@ -13,19 +13,21 @@
namespace {
-class LOCKABLE Lock {
+class RTC_LOCKABLE Lock {
public:
- void EnterWrite() const EXCLUSIVE_LOCK_FUNCTION() {}
- void EnterRead() const SHARED_LOCK_FUNCTION() {}
- bool TryEnterWrite() const EXCLUSIVE_TRYLOCK_FUNCTION(true) { return true; }
- bool TryEnterRead() const SHARED_TRYLOCK_FUNCTION(true) { return true; }
- void Leave() const UNLOCK_FUNCTION() {}
+ void EnterWrite() const RTC_EXCLUSIVE_LOCK_FUNCTION() {}
+ void EnterRead() const RTC_SHARED_LOCK_FUNCTION() {}
+ bool TryEnterWrite() const RTC_EXCLUSIVE_TRYLOCK_FUNCTION(true) {
+ return true;
+ }
+ bool TryEnterRead() const RTC_SHARED_TRYLOCK_FUNCTION(true) { return true; }
+ void Leave() const RTC_UNLOCK_FUNCTION() {}
};
-class SCOPED_LOCKABLE ScopeLock {
+class RTC_SCOPED_LOCKABLE ScopeLock {
public:
- explicit ScopeLock(const Lock& lock) EXCLUSIVE_LOCK_FUNCTION(lock) {}
- ~ScopeLock() UNLOCK_FUNCTION() {}
+ explicit ScopeLock(const Lock& lock) RTC_EXCLUSIVE_LOCK_FUNCTION(lock) {}
+ ~ScopeLock() RTC_UNLOCK_FUNCTION() {}
};
class ThreadSafe {
@@ -50,7 +52,7 @@
anylock_.Leave();
}
- void UnprotectedFunction() LOCKS_EXCLUDED(anylock_, lock_, pt_lock_) {
+ void UnprotectedFunction() RTC_LOCKS_EXCLUDED(anylock_, lock_, pt_lock_) {
// Can access unprotected Value.
unprotected_ = 15;
// Can access pointers themself, but not data they point to.
@@ -110,30 +112,30 @@
}
private:
- void ReadProtectedFunction() SHARED_LOCKS_REQUIRED(lock_, pt_lock_) {
+ void ReadProtectedFunction() RTC_SHARED_LOCKS_REQUIRED(lock_, pt_lock_) {
unprotected_ = protected_by_lock_;
unprotected_ = *pt_protected_by_lock_;
}
- void WriteProtectedFunction() EXCLUSIVE_LOCKS_REQUIRED(lock_, pt_lock_) {
+ void WriteProtectedFunction() RTC_EXCLUSIVE_LOCKS_REQUIRED(lock_, pt_lock_) {
int x = protected_by_lock_;
*pt_protected_by_lock_ = x;
protected_by_lock_ = unprotected_;
}
- const Lock& GetLock() LOCK_RETURNED(lock_) { return lock_; }
+ const Lock& GetLock() RTC_LOCK_RETURNED(lock_) { return lock_; }
- Lock anylock_ ACQUIRED_BEFORE(lock_);
+ Lock anylock_ RTC_ACQUIRED_BEFORE(lock_);
Lock lock_;
- Lock pt_lock_ ACQUIRED_AFTER(lock_);
+ Lock pt_lock_ RTC_ACQUIRED_AFTER(lock_);
int unprotected_ = 0;
- int protected_by_lock_ GUARDED_BY(lock_) = 0;
- int protected_by_anything_ GUARDED_VAR = 0;
+ int protected_by_lock_ RTC_GUARDED_BY(lock_) = 0;
+ int protected_by_anything_ RTC_GUARDED_VAR = 0;
- int* pt_protected_by_lock_ PT_GUARDED_BY(pt_lock_);
- int* pt_protected_by_anything_ PT_GUARDED_VAR;
+ int* pt_protected_by_lock_ RTC_PT_GUARDED_BY(pt_lock_);
+ int* pt_protected_by_anything_ RTC_PT_GUARDED_VAR;
};
} // namespace
diff --git a/rtc_base/thread_checker.h b/rtc_base/thread_checker.h
index b6ce017..70daf5a 100644
--- a/rtc_base/thread_checker.h
+++ b/rtc_base/thread_checker.h
@@ -103,8 +103,8 @@
} // namespace internal
} // namespace rtc
-// RUN_ON/ACCESS_ON/RTC_DCHECK_RUN_ON macros allows to annotate variables are
-// accessed from same thread/task queue.
+// RTC_RUN_ON/RTC_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.
//
@@ -117,12 +117,12 @@
//
// private:
// rtc::Thread* network_thread_;
-// int transport_ ACCESS_ON(network_thread_);
+// int transport_ RTC_ACCESS_ON(network_thread_);
// };
//
// class ExampleThreadChecker {
// public:
-// int CalledFromPacer() RUN_ON(pacer_thread_checker_) {
+// int CalledFromPacer() RTC_RUN_ON(pacer_thread_checker_) {
// return var2_;
// }
//
@@ -133,7 +133,7 @@
// }
//
// private:
-// int pacer_var_ ACCESS_ON(pacer_thread_checker_);
+// int pacer_var_ RTC_ACCESS_ON(pacer_thread_checker_);
// rtc::ThreadChecker pacer_thread_checker_;
// };
//
@@ -149,7 +149,7 @@
//
// private:
// rtc::TaskQueue* const encoder_queue_;
-// Frame var_ ACCESS_ON(encoder_queue_);
+// Frame var_ RTC_ACCESS_ON(encoder_queue_);
// };
//
// void Encode() {
@@ -166,10 +166,12 @@
// Document if a variable/field is not shared and should be accessed from
// same thread/task queue.
-#define ACCESS_ON(x) THREAD_ANNOTATION_ATTRIBUTE__(guarded_by(x))
+#define ACCESS_ON(x) RTC_THREAD_ANNOTATION_ATTRIBUTE__(guarded_by(x))
+#define RTC_ACCESS_ON(x) RTC_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 RUN_ON(x) RTC_THREAD_ANNOTATION_ATTRIBUTE__(exclusive_locks_required(x))
+#define RTC_RUN_ON(x) RTC_THREAD_ANNOTATION_ATTRIBUTE__(exclusive_locks_required(x))
#define RTC_DCHECK_RUN_ON(thread_like_object) \
rtc::internal::AnnounceOnThread thread_announcer(thread_like_object); \
diff --git a/rtc_base/thread_checker_unittest.cc b/rtc_base/thread_checker_unittest.cc
index d8ad830..ba5c695 100644
--- a/rtc_base/thread_checker_unittest.cc
+++ b/rtc_base/thread_checker_unittest.cc
@@ -241,16 +241,16 @@
}
private:
- void function() RUN_ON(thread_) {}
- void fun_acccess_var() RUN_ON(thread_) { var_thread_ = 13; }
+ void function() RTC_RUN_ON(thread_) {}
+ void fun_acccess_var() RTC_RUN_ON(thread_) { var_thread_ = 13; }
rtc::Thread* thread_;
rtc::ThreadChecker checker_;
rtc::TaskQueue* queue_;
- int var_thread_ ACCESS_ON(thread_);
- int var_checker_ GUARDED_BY(checker_);
- int var_queue_ ACCESS_ON(queue_);
+ int var_thread_ RTC_ACCESS_ON(thread_);
+ int var_checker_ RTC_GUARDED_BY(checker_);
+ int var_queue_ RTC_ACCESS_ON(queue_);
};
// Just in case we ever get lumped together with other compilation units.
