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.