diff --git a/media/engine/webrtcvideoengine.h b/media/engine/webrtcvideoengine.h
index 8c8aefb..063d80b 100644
--- a/media/engine/webrtcvideoengine.h
+++ b/media/engine/webrtcvideoengine.h
@@ -327,9 +327,9 @@
     webrtc::Call* const call_;
     const bool enable_cpu_overuse_detection_;
     rtc::VideoSourceInterface<webrtc::VideoFrame>* source_
-        ACCESS_ON(&thread_checker_);
+        RTC_ACCESS_ON(&thread_checker_);
     const EncoderFactoryAdapter* const encoder_factory_
-        ACCESS_ON(&thread_checker_);
+        RTC_ACCESS_ON(&thread_checker_);
 
     webrtc::VideoSendStream* stream_ RTC_ACCESS_ON(&thread_checker_);
     rtc::VideoSinkInterface<webrtc::VideoFrame>* encoder_sink_
diff --git a/rtc_base/thread_annotations.h b/rtc_base/thread_annotations.h
index b07a75e..bbd2c71 100644
--- a/rtc_base/thread_annotations.h
+++ b/rtc_base/thread_annotations.h
@@ -30,13 +30,7 @@
 // held when accessing the annotated variable, while GUARDED_VAR only
 // 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) 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 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
@@ -47,13 +41,7 @@
 // q, which is guarded by mu1, points to a shared memory location that is
 // 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) 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 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
@@ -61,14 +49,8 @@
 // to establish an acquisition order, only one of them needs the annotation.
 // (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) 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) RTC_THREAD_ANNOTATION_ATTRIBUTE__(acquired_before(x))
-#endif
 #define RTC_ACQUIRED_BEFORE(x) \
   RTC_THREAD_ANNOTATION_ATTRIBUTE__(acquired_before(x))
 
@@ -76,88 +58,43 @@
 // functions/methods.
 
 // Document if a function expects certain locks to be held before it is called
-#if !defined(EXCLUSIVE_LOCKS_REQUIRED)
-#define EXCLUSIVE_LOCKS_REQUIRED(...) \
-  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(...) \
-  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(...) \
-  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) 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 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 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(...) \
-  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(...) \
-  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(...) \
-  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(...) \
-  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(...) \
-  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 \
-  RTC_THREAD_ANNOTATION_ATTRIBUTE__(no_thread_safety_analysis)
-#endif
 #define RTC_NO_THREAD_SAFETY_ANALYSIS \
   RTC_THREAD_ANNOTATION_ATTRIBUTE__(no_thread_safety_analysis)
 
diff --git a/rtc_base/thread_checker.h b/rtc_base/thread_checker.h
index 769b7f0..89428fd 100644
--- a/rtc_base/thread_checker.h
+++ b/rtc_base/thread_checker.h
@@ -17,7 +17,7 @@
 // builds with RTC_DCHECK_IS_ON so that trybots and waterfall bots
 // with this define will get the same level of thread checking as
 // debug bots.
-#define ENABLE_THREAD_CHECKER RTC_DCHECK_IS_ON
+#define RTC_ENABLE_THREAD_CHECKER RTC_DCHECK_IS_ON
 
 #include "webrtc/rtc_base/checks.h"
 #include "webrtc/rtc_base/constructormagic.h"
@@ -70,13 +70,13 @@
 // }
 //
 // In Release mode, CalledOnValidThread will always return true.
-#if ENABLE_THREAD_CHECKER
+#if RTC_ENABLE_THREAD_CHECKER
 class RTC_LOCKABLE ThreadChecker : public ThreadCheckerImpl {};
 #else
 class RTC_LOCKABLE ThreadChecker : public ThreadCheckerDoNothing {};
-#endif  // ENABLE_THREAD_CHECKER
+#endif  // RTC_ENABLE_THREAD_CHECKER
 
-#undef ENABLE_THREAD_CHECKER
+#undef RTC_ENABLE_THREAD_CHECKER
 
 namespace internal {
 class RTC_SCOPED_LOCKABLE AnnounceOnThread {
@@ -164,11 +164,9 @@
 
 // Document if a variable/field is not shared and should be accessed from
 // same thread/task queue.
-#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) 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) \