diff --git a/api/statstypes.h b/api/statstypes.h
index 378b014..6391ff5 100644
--- a/api/statstypes.h
+++ b/api/statstypes.h
@@ -335,7 +335,7 @@
 
    private:
     rtc::ThreadChecker thread_checker_;
-    mutable int ref_count_ ACCESS_ON(thread_checker_) = 0;
+    mutable int ref_count_ RTC_ACCESS_ON(thread_checker_) = 0;
 
     const Type type_;
     // TODO(tommi): Use C++ 11 union and make value_ const.
diff --git a/audio/audio_receive_stream.h b/audio/audio_receive_stream.h
index dc7992f..0615dc1 100644
--- a/audio/audio_receive_stream.h
+++ b/audio/audio_receive_stream.h
@@ -90,7 +90,7 @@
   rtc::scoped_refptr<webrtc::AudioState> audio_state_;
   std::unique_ptr<voe::ChannelProxy> channel_proxy_;
 
-  bool playing_ ACCESS_ON(worker_thread_checker_) = false;
+  bool playing_ RTC_ACCESS_ON(worker_thread_checker_) = false;
 
   std::unique_ptr<RtpStreamReceiverInterface> rtp_stream_receiver_;
 
diff --git a/audio/audio_send_stream.h b/audio/audio_send_stream.h
index f46608d..cf36c13 100644
--- a/audio/audio_send_stream.h
+++ b/audio/audio_send_stream.h
@@ -115,7 +115,7 @@
 
   rtc::CriticalSection packet_loss_tracker_cs_;
   TransportFeedbackPacketLossTracker packet_loss_tracker_
-      GUARDED_BY(&packet_loss_tracker_cs_);
+      RTC_GUARDED_BY(&packet_loss_tracker_cs_);
 
   RtpRtcp* rtp_rtcp_module_;
   rtc::Optional<RtpState> const suspended_rtp_state_;
diff --git a/audio/audio_state.h b/audio/audio_state.h
index c8ce44b..893c1f9 100644
--- a/audio/audio_state.h
+++ b/audio/audio_state.h
@@ -55,7 +55,7 @@
   // The critical section isn't strictly needed in this case, but xSAN bots may
   // trigger on unprotected cross-thread access.
   rtc::CriticalSection crit_sect_;
-  bool typing_noise_detected_ GUARDED_BY(crit_sect_) = false;
+  bool typing_noise_detected_ RTC_GUARDED_BY(crit_sect_) = false;
 
   // Reference count; implementation copied from rtc::RefCountedObject.
   mutable volatile int ref_count_ = 0;
diff --git a/call/bitrate_allocator.h b/call/bitrate_allocator.h
index b36d38e..b9bbc93 100644
--- a/call/bitrate_allocator.h
+++ b/call/bitrate_allocator.h
@@ -153,20 +153,20 @@
                                     uint32_t sum_min_bitrates);
 
   rtc::SequencedTaskChecker sequenced_checker_;
-  LimitObserver* const limit_observer_ GUARDED_BY(&sequenced_checker_);
+  LimitObserver* const limit_observer_ RTC_GUARDED_BY(&sequenced_checker_);
   // Stored in a list to keep track of the insertion order.
-  ObserverConfigs bitrate_observer_configs_ GUARDED_BY(&sequenced_checker_);
-  uint32_t last_bitrate_bps_ GUARDED_BY(&sequenced_checker_);
-  uint32_t last_non_zero_bitrate_bps_ GUARDED_BY(&sequenced_checker_);
-  uint8_t last_fraction_loss_ GUARDED_BY(&sequenced_checker_);
-  int64_t last_rtt_ GUARDED_BY(&sequenced_checker_);
-  int64_t last_bwe_period_ms_ GUARDED_BY(&sequenced_checker_);
+  ObserverConfigs bitrate_observer_configs_ RTC_GUARDED_BY(&sequenced_checker_);
+  uint32_t last_bitrate_bps_ RTC_GUARDED_BY(&sequenced_checker_);
+  uint32_t last_non_zero_bitrate_bps_ RTC_GUARDED_BY(&sequenced_checker_);
+  uint8_t last_fraction_loss_ RTC_GUARDED_BY(&sequenced_checker_);
+  int64_t last_rtt_ RTC_GUARDED_BY(&sequenced_checker_);
+  int64_t last_bwe_period_ms_ RTC_GUARDED_BY(&sequenced_checker_);
   // Number of mute events based on too low BWE, not network up/down.
-  int num_pause_events_ GUARDED_BY(&sequenced_checker_);
-  Clock* const clock_ GUARDED_BY(&sequenced_checker_);
-  int64_t last_bwe_log_time_ GUARDED_BY(&sequenced_checker_);
-  uint32_t total_requested_padding_bitrate_ GUARDED_BY(&sequenced_checker_);
-  uint32_t total_requested_min_bitrate_ GUARDED_BY(&sequenced_checker_);
+  int num_pause_events_ RTC_GUARDED_BY(&sequenced_checker_);
+  Clock* const clock_ RTC_GUARDED_BY(&sequenced_checker_);
+  int64_t last_bwe_log_time_ RTC_GUARDED_BY(&sequenced_checker_);
+  uint32_t total_requested_padding_bitrate_ RTC_GUARDED_BY(&sequenced_checker_);
+  uint32_t total_requested_min_bitrate_ RTC_GUARDED_BY(&sequenced_checker_);
 };
 }  // namespace webrtc
 #endif  // WEBRTC_CALL_BITRATE_ALLOCATOR_H_
diff --git a/call/bitrate_estimator_tests.cc b/call/bitrate_estimator_tests.cc
index 5d4acbb..49f149b 100644
--- a/call/bitrate_estimator_tests.cc
+++ b/call/bitrate_estimator_tests.cc
@@ -83,8 +83,8 @@
    private:
     typedef std::list<std::string> Strings;
     rtc::CriticalSection crit_sect_;
-    Strings received_log_lines_ GUARDED_BY(crit_sect_);
-    Strings expected_log_lines_ GUARDED_BY(crit_sect_);
+    Strings received_log_lines_ RTC_GUARDED_BY(crit_sect_);
+    Strings expected_log_lines_ RTC_GUARDED_BY(crit_sect_);
     rtc::Event done_;
   };
 
diff --git a/call/call.cc b/call/call.cc
index e8b51f9..b7cd059 100644
--- a/call/call.cc
+++ b/call/call.cc
@@ -236,11 +236,11 @@
                             size_t length,
                             const PacketTime& packet_time);
   void ConfigureSync(const std::string& sync_group)
-      EXCLUSIVE_LOCKS_REQUIRED(receive_crit_);
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(receive_crit_);
 
   void NotifyBweOfReceivedPacket(const RtpPacketReceived& packet,
                                  MediaType media_type)
-      SHARED_LOCKS_REQUIRED(receive_crit_);
+      RTC_SHARED_LOCKS_REQUIRED(receive_crit_);
 
   rtc::Optional<RtpPacketReceived> ParseRtpPacket(
       const uint8_t* packet,
@@ -248,7 +248,7 @@
       const PacketTime* packet_time) const;
 
   void UpdateSendHistograms(int64_t first_sent_packet_ms)
-      EXCLUSIVE_LOCKS_REQUIRED(&bitrate_crit_);
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(&bitrate_crit_);
   void UpdateReceiveHistograms();
   void UpdateHistograms();
   void UpdateAggregateNetworkState();
@@ -274,12 +274,12 @@
   // Audio, Video, and FlexFEC receive streams are owned by the client that
   // creates them.
   std::set<AudioReceiveStream*> audio_receive_streams_
-      GUARDED_BY(receive_crit_);
+      RTC_GUARDED_BY(receive_crit_);
   std::set<VideoReceiveStream*> video_receive_streams_
-      GUARDED_BY(receive_crit_);
+      RTC_GUARDED_BY(receive_crit_);
 
   std::map<std::string, AudioReceiveStream*> sync_stream_mapping_
-      GUARDED_BY(receive_crit_);
+      RTC_GUARDED_BY(receive_crit_);
 
   // TODO(nisse): Should eventually be injected at creation,
   // with a single object in the bundled case.
@@ -308,19 +308,21 @@
     bool use_send_side_bwe = false;
   };
   std::map<uint32_t, ReceiveRtpConfig> receive_rtp_config_
-      GUARDED_BY(receive_crit_);
+      RTC_GUARDED_BY(receive_crit_);
 
   std::unique_ptr<RWLockWrapper> send_crit_;
   // Audio and Video send streams are owned by the client that creates them.
-  std::map<uint32_t, AudioSendStream*> audio_send_ssrcs_ GUARDED_BY(send_crit_);
-  std::map<uint32_t, VideoSendStream*> video_send_ssrcs_ GUARDED_BY(send_crit_);
-  std::set<VideoSendStream*> video_send_streams_ GUARDED_BY(send_crit_);
+  std::map<uint32_t, AudioSendStream*> audio_send_ssrcs_
+      RTC_GUARDED_BY(send_crit_);
+  std::map<uint32_t, VideoSendStream*> video_send_ssrcs_
+      RTC_GUARDED_BY(send_crit_);
+  std::set<VideoSendStream*> video_send_streams_ RTC_GUARDED_BY(send_crit_);
 
   using RtpStateMap = std::map<uint32_t, RtpState>;
   RtpStateMap suspended_audio_send_ssrcs_
-      GUARDED_BY(configuration_sequence_checker_);
+      RTC_GUARDED_BY(configuration_sequence_checker_);
   RtpStateMap suspended_video_send_ssrcs_
-      GUARDED_BY(configuration_sequence_checker_);
+      RTC_GUARDED_BY(configuration_sequence_checker_);
 
   webrtc::RtcEventLog* event_log_;
 
@@ -340,10 +342,11 @@
   // TODO(holmer): Remove this lock once BitrateController no longer calls
   // OnNetworkChanged from multiple threads.
   rtc::CriticalSection bitrate_crit_;
-  uint32_t min_allocated_send_bitrate_bps_ GUARDED_BY(&bitrate_crit_);
-  uint32_t configured_max_padding_bitrate_bps_ GUARDED_BY(&bitrate_crit_);
-  AvgCounter estimated_send_bitrate_kbps_counter_ GUARDED_BY(&bitrate_crit_);
-  AvgCounter pacer_bitrate_kbps_counter_ GUARDED_BY(&bitrate_crit_);
+  uint32_t min_allocated_send_bitrate_bps_ RTC_GUARDED_BY(&bitrate_crit_);
+  uint32_t configured_max_padding_bitrate_bps_ RTC_GUARDED_BY(&bitrate_crit_);
+  AvgCounter estimated_send_bitrate_kbps_counter_
+      RTC_GUARDED_BY(&bitrate_crit_);
+  AvgCounter pacer_bitrate_kbps_counter_ RTC_GUARDED_BY(&bitrate_crit_);
 
   std::map<std::string, rtc::NetworkRoute> network_routes_;
 
diff --git a/call/call_perf_tests.cc b/call/call_perf_tests.cc
index 29dd0e4..46611a1 100644
--- a/call/call_perf_tests.cc
+++ b/call/call_perf_tests.cc
@@ -131,7 +131,7 @@
   const int64_t creation_time_ms_;
   int64_t first_time_in_sync_;
   rtc::CriticalSection crit_;
-  VideoReceiveStream* receive_stream_ GUARDED_BY(crit_);
+  VideoReceiveStream* receive_stream_ RTC_GUARDED_BY(crit_);
   std::vector<int> sync_offset_ms_list_;
 };
 
@@ -463,7 +463,7 @@
     bool rtp_start_timestamp_set_;
     uint32_t rtp_start_timestamp_;
     typedef std::map<uint32_t, uint32_t> FrameCaptureTimeList;
-    FrameCaptureTimeList capture_time_list_ GUARDED_BY(&crit_);
+    FrameCaptureTimeList capture_time_list_ RTC_GUARDED_BY(&crit_);
     std::vector<int> time_offset_ms_list_;
   } test(net_config, threshold_ms, start_time_ms, run_time_ms);
 
diff --git a/call/rtp_stream_receiver_controller.h b/call/rtp_stream_receiver_controller.h
index 4583b9d..feec5e4 100644
--- a/call/rtp_stream_receiver_controller.h
+++ b/call/rtp_stream_receiver_controller.h
@@ -64,7 +64,7 @@
   // by a single, but possibly distinct, thread. But applications not
   // using Call may have use threads differently.
   rtc::CriticalSection lock_;
-  RtpDemuxer demuxer_ GUARDED_BY(&lock_);
+  RtpDemuxer demuxer_ RTC_GUARDED_BY(&lock_);
 };
 
 }  // namespace webrtc
diff --git a/common_video/include/bitrate_adjuster.h b/common_video/include/bitrate_adjuster.h
index 1b70ebd..d04486c 100644
--- a/common_video/include/bitrate_adjuster.h
+++ b/common_video/include/bitrate_adjuster.h
@@ -59,29 +59,30 @@
   bool IsWithinTolerance(uint32_t bitrate_bps, uint32_t target_bitrate_bps);
 
   // Returns smallest possible adjusted value.
-  uint32_t GetMinAdjustedBitrateBps() const EXCLUSIVE_LOCKS_REQUIRED(crit_);
+  uint32_t GetMinAdjustedBitrateBps() const RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_);
   // Returns largest possible adjusted value.
-  uint32_t GetMaxAdjustedBitrateBps() const EXCLUSIVE_LOCKS_REQUIRED(crit_);
+  uint32_t GetMaxAdjustedBitrateBps() const RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_);
 
   void Reset();
-  void UpdateBitrate(uint32_t current_time_ms) EXCLUSIVE_LOCKS_REQUIRED(crit_);
+  void UpdateBitrate(uint32_t current_time_ms)
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_);
 
   rtc::CriticalSection crit_;
   Clock* const clock_;
   const float min_adjusted_bitrate_pct_;
   const float max_adjusted_bitrate_pct_;
   // The bitrate we want.
-  volatile uint32_t target_bitrate_bps_ GUARDED_BY(crit_);
+  volatile uint32_t target_bitrate_bps_ RTC_GUARDED_BY(crit_);
   // The bitrate we use to get what we want.
-  volatile uint32_t adjusted_bitrate_bps_ GUARDED_BY(crit_);
+  volatile uint32_t adjusted_bitrate_bps_ RTC_GUARDED_BY(crit_);
   // The target bitrate that the adjusted bitrate was computed from.
-  volatile uint32_t last_adjusted_target_bitrate_bps_ GUARDED_BY(crit_);
+  volatile uint32_t last_adjusted_target_bitrate_bps_ RTC_GUARDED_BY(crit_);
   // Used to estimate bitrate.
-  RateStatistics bitrate_tracker_ GUARDED_BY(crit_);
+  RateStatistics bitrate_tracker_ RTC_GUARDED_BY(crit_);
   // The last time we tried to adjust the bitrate.
-  uint32_t last_bitrate_update_time_ms_ GUARDED_BY(crit_);
+  uint32_t last_bitrate_update_time_ms_ RTC_GUARDED_BY(crit_);
   // The number of frames since the last time we tried to adjust the bitrate.
-  uint32_t frames_since_last_update_ GUARDED_BY(crit_);
+  uint32_t frames_since_last_update_ RTC_GUARDED_BY(crit_);
 };
 
 }  // namespace webrtc
diff --git a/logging/rtc_event_log/rtc_event_log.cc b/logging/rtc_event_log/rtc_event_log.cc
index d1cad89..7c295aa 100644
--- a/logging/rtc_event_log/rtc_event_log.cc
+++ b/logging/rtc_event_log/rtc_event_log.cc
@@ -168,15 +168,16 @@
 
   // History containing all past configuration events.
   std::vector<std::unique_ptr<rtclog::Event>> config_history_
-      ACCESS_ON(task_queue_);
+      RTC_ACCESS_ON(task_queue_);
 
   // History containing the most recent (non-configuration) events (~10s).
-  std::deque<std::unique_ptr<rtclog::Event>> history_ ACCESS_ON(task_queue_);
+  std::deque<std::unique_ptr<rtclog::Event>> history_
+      RTC_ACCESS_ON(task_queue_);
 
-  std::unique_ptr<FileWrapper> file_ ACCESS_ON(task_queue_);
+  std::unique_ptr<FileWrapper> file_ RTC_ACCESS_ON(task_queue_);
 
-  size_t max_size_bytes_ ACCESS_ON(task_queue_);
-  size_t written_bytes_ ACCESS_ON(task_queue_);
+  size_t max_size_bytes_ RTC_ACCESS_ON(task_queue_);
+  size_t written_bytes_ RTC_ACCESS_ON(task_queue_);
 
   // Keep this last to ensure it destructs first, or else tasks living on the
   // queue might access other members after they've been torn down.
diff --git a/media/base/adaptedvideotracksource.h b/media/base/adaptedvideotracksource.h
index 9d51c69..7189996 100644
--- a/media/base/adaptedvideotracksource.h
+++ b/media/base/adaptedvideotracksource.h
@@ -74,7 +74,7 @@
   cricket::VideoAdapter video_adapter_;
 
   rtc::CriticalSection stats_crit_;
-  rtc::Optional<Stats> stats_ GUARDED_BY(stats_crit_);
+  rtc::Optional<Stats> stats_ RTC_GUARDED_BY(stats_crit_);
 
   VideoBroadcaster broadcaster_;
 };
diff --git a/media/base/videoadapter.h b/media/base/videoadapter.h
index 61de4b5..aa786af 100644
--- a/media/base/videoadapter.h
+++ b/media/base/videoadapter.h
@@ -75,15 +75,17 @@
   // Resolution must be divisible by this factor.
   const int required_resolution_alignment_;
   // The target timestamp for the next frame based on requested format.
-  rtc::Optional<int64_t> next_frame_timestamp_ns_ GUARDED_BY(critical_section_);
+  rtc::Optional<int64_t> next_frame_timestamp_ns_
+      RTC_GUARDED_BY(critical_section_);
 
   // Max number of pixels requested via calls to OnOutputFormatRequest,
   // OnResolutionRequest respectively.
   // The adapted output format is the minimum of these.
-  rtc::Optional<VideoFormat> requested_format_ GUARDED_BY(critical_section_);
-  int resolution_request_target_pixel_count_ GUARDED_BY(critical_section_);
-  int resolution_request_max_pixel_count_ GUARDED_BY(critical_section_);
-  int max_framerate_request_ GUARDED_BY(critical_section_);
+  rtc::Optional<VideoFormat> requested_format_
+      RTC_GUARDED_BY(critical_section_);
+  int resolution_request_target_pixel_count_ RTC_GUARDED_BY(critical_section_);
+  int resolution_request_max_pixel_count_ RTC_GUARDED_BY(critical_section_);
+  int max_framerate_request_ RTC_GUARDED_BY(critical_section_);
 
   // The critical section to protect the above variables.
   rtc::CriticalSection critical_section_;
diff --git a/media/base/videobroadcaster.h b/media/base/videobroadcaster.h
index 312ec7b..32fefdd 100644
--- a/media/base/videobroadcaster.h
+++ b/media/base/videobroadcaster.h
@@ -51,15 +51,15 @@
   void OnFrame(const webrtc::VideoFrame& frame) override;
 
  protected:
-  void UpdateWants() EXCLUSIVE_LOCKS_REQUIRED(sinks_and_wants_lock_);
+  void UpdateWants() RTC_EXCLUSIVE_LOCKS_REQUIRED(sinks_and_wants_lock_);
   const rtc::scoped_refptr<webrtc::VideoFrameBuffer>& GetBlackFrameBuffer(
-      int width, int height)
-      EXCLUSIVE_LOCKS_REQUIRED(sinks_and_wants_lock_);
+      int width,
+      int height) RTC_EXCLUSIVE_LOCKS_REQUIRED(sinks_and_wants_lock_);
 
   ThreadChecker thread_checker_;
   rtc::CriticalSection sinks_and_wants_lock_;
 
-  VideoSinkWants current_wants_ GUARDED_BY(sinks_and_wants_lock_);
+  VideoSinkWants current_wants_ RTC_GUARDED_BY(sinks_and_wants_lock_);
   rtc::scoped_refptr<webrtc::VideoFrameBuffer> black_frame_buffer_;
 };
 
diff --git a/media/base/videocapturer.h b/media/base/videocapturer.h
index a65d40e..10c5df9 100644
--- a/media/base/videocapturer.h
+++ b/media/base/videocapturer.h
@@ -271,9 +271,9 @@
 
   rtc::CriticalSection frame_stats_crit_;
   // The captured frame size before potential adapation.
-  bool input_size_valid_ GUARDED_BY(frame_stats_crit_) = false;
-  int input_width_ GUARDED_BY(frame_stats_crit_);
-  int input_height_ GUARDED_BY(frame_stats_crit_);
+  bool input_size_valid_ RTC_GUARDED_BY(frame_stats_crit_) = false;
+  int input_width_ RTC_GUARDED_BY(frame_stats_crit_);
+  int input_height_ RTC_GUARDED_BY(frame_stats_crit_);
 
   // Whether capturer should apply rotation to the frame before
   // passing it on to the registered sinks.
diff --git a/media/engine/fakewebrtcvideoengine.h b/media/engine/fakewebrtcvideoengine.h
index 604728c..e9afc76 100644
--- a/media/engine/fakewebrtcvideoengine.h
+++ b/media/engine/fakewebrtcvideoengine.h
@@ -172,8 +172,8 @@
  private:
   rtc::CriticalSection crit_;
   rtc::Event init_encode_event_;
-  int num_frames_encoded_ GUARDED_BY(crit_);
-  webrtc::VideoCodec codec_settings_ GUARDED_BY(crit_);
+  int num_frames_encoded_ RTC_GUARDED_BY(crit_);
+  webrtc::VideoCodec codec_settings_ RTC_GUARDED_BY(crit_);
 };
 
 // Fake class for mocking out WebRtcVideoEncoderFactory.
@@ -250,8 +250,8 @@
   rtc::CriticalSection crit_;
   rtc::Event created_video_encoder_event_;
   std::vector<cricket::VideoCodec> codecs_;
-  std::vector<FakeWebRtcVideoEncoder*> encoders_ GUARDED_BY(crit_);
-  int num_created_encoders_ GUARDED_BY(crit_);
+  std::vector<FakeWebRtcVideoEncoder*> encoders_ RTC_GUARDED_BY(crit_);
+  int num_created_encoders_ RTC_GUARDED_BY(crit_);
   bool encoders_have_internal_sources_;
 };
 
diff --git a/media/engine/webrtcvideoengine.h b/media/engine/webrtcvideoengine.h
index 7710c04..81a85c8 100644
--- a/media/engine/webrtcvideoengine.h
+++ b/media/engine/webrtcvideoengine.h
@@ -241,11 +241,11 @@
       webrtc::FlexfecReceiveStream::Config* flexfec_config,
       const StreamParams& sp) const;
   bool ValidateSendSsrcAvailability(const StreamParams& sp) const
-      EXCLUSIVE_LOCKS_REQUIRED(stream_crit_);
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(stream_crit_);
   bool ValidateReceiveSsrcAvailability(const StreamParams& sp) const
-      EXCLUSIVE_LOCKS_REQUIRED(stream_crit_);
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(stream_crit_);
   void DeleteReceiveStream(WebRtcVideoReceiveStream* stream)
-      EXCLUSIVE_LOCKS_REQUIRED(stream_crit_);
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(stream_crit_);
 
   static std::string CodecSettingsVectorToString(
       const std::vector<VideoCodecSettings>& codecs);
@@ -326,38 +326,38 @@
     void UpdateSendState();
 
     webrtc::VideoSendStream::DegradationPreference GetDegradationPreference()
-        const EXCLUSIVE_LOCKS_REQUIRED(&thread_checker_);
+        const RTC_EXCLUSIVE_LOCKS_REQUIRED(&thread_checker_);
 
     rtc::ThreadChecker thread_checker_;
     rtc::AsyncInvoker invoker_;
     rtc::Thread* worker_thread_;
-    const std::vector<uint32_t> ssrcs_ ACCESS_ON(&thread_checker_);
-    const std::vector<SsrcGroup> ssrc_groups_ ACCESS_ON(&thread_checker_);
+    const std::vector<uint32_t> ssrcs_ RTC_ACCESS_ON(&thread_checker_);
+    const std::vector<SsrcGroup> ssrc_groups_ RTC_ACCESS_ON(&thread_checker_);
     webrtc::Call* const call_;
     const bool enable_cpu_overuse_detection_;
     rtc::VideoSourceInterface<webrtc::VideoFrame>* source_
-        ACCESS_ON(&thread_checker_);
+        RTC_ACCESS_ON(&thread_checker_);
     std::unique_ptr<EncoderFactoryAdapter> encoder_factory_
-        ACCESS_ON(&thread_checker_);
+        RTC_ACCESS_ON(&thread_checker_);
 
-    webrtc::VideoSendStream* stream_ ACCESS_ON(&thread_checker_);
+    webrtc::VideoSendStream* stream_ RTC_ACCESS_ON(&thread_checker_);
     rtc::VideoSinkInterface<webrtc::VideoFrame>* encoder_sink_
-        ACCESS_ON(&thread_checker_);
+        RTC_ACCESS_ON(&thread_checker_);
     // Contains settings that are the same for all streams in the MediaChannel,
     // such as codecs, header extensions, and the global bitrate limit for the
     // entire channel.
-    VideoSendStreamParameters parameters_ ACCESS_ON(&thread_checker_);
+    VideoSendStreamParameters parameters_ RTC_ACCESS_ON(&thread_checker_);
     // Contains settings that are unique for each stream, such as max_bitrate.
     // Does *not* contain codecs, however.
     // TODO(skvlad): Move ssrcs_ and ssrc_groups_ into rtp_parameters_.
     // TODO(skvlad): Combine parameters_ and rtp_parameters_ once we have only
     // one stream per MediaChannel.
-    webrtc::RtpParameters rtp_parameters_ ACCESS_ON(&thread_checker_);
+    webrtc::RtpParameters rtp_parameters_ RTC_ACCESS_ON(&thread_checker_);
     std::unique_ptr<webrtc::VideoEncoder> allocated_encoder_
-        ACCESS_ON(&thread_checker_);
-    VideoCodec allocated_codec_ ACCESS_ON(&thread_checker_);
+        RTC_ACCESS_ON(&thread_checker_);
+    VideoCodec allocated_codec_ RTC_ACCESS_ON(&thread_checker_);
 
-    bool sending_ ACCESS_ON(&thread_checker_);
+    bool sending_ RTC_ACCESS_ON(&thread_checker_);
   };
 
   // Wrapper for the receiver part, contains configs etc. that are needed to
@@ -437,15 +437,16 @@
     std::vector<AllocatedDecoder> allocated_decoders_;
 
     rtc::CriticalSection sink_lock_;
-    rtc::VideoSinkInterface<webrtc::VideoFrame>* sink_ GUARDED_BY(sink_lock_);
+    rtc::VideoSinkInterface<webrtc::VideoFrame>* sink_
+        RTC_GUARDED_BY(sink_lock_);
     // Expands remote RTP timestamps to int64_t to be able to estimate how long
     // the stream has been running.
     rtc::TimestampWrapAroundHandler timestamp_wraparound_handler_
-        GUARDED_BY(sink_lock_);
-    int64_t first_frame_timestamp_ GUARDED_BY(sink_lock_);
+        RTC_GUARDED_BY(sink_lock_);
+    int64_t first_frame_timestamp_ RTC_GUARDED_BY(sink_lock_);
     // Start NTP time is estimated as current remote NTP time (estimated from
     // RTCP) minus the elapsed time, as soon as remote NTP time is available.
-    int64_t estimated_remote_start_ntp_time_ms_ GUARDED_BY(sink_lock_);
+    int64_t estimated_remote_start_ntp_time_ms_ RTC_GUARDED_BY(sink_lock_);
   };
 
   void Construct(webrtc::Call* call, WebRtcVideoEngine* engine);
@@ -487,11 +488,11 @@
   rtc::CriticalSection stream_crit_;
   // Using primary-ssrc (first ssrc) as key.
   std::map<uint32_t, WebRtcVideoSendStream*> send_streams_
-      GUARDED_BY(stream_crit_);
+      RTC_GUARDED_BY(stream_crit_);
   std::map<uint32_t, WebRtcVideoReceiveStream*> receive_streams_
-      GUARDED_BY(stream_crit_);
-  std::set<uint32_t> send_ssrcs_ GUARDED_BY(stream_crit_);
-  std::set<uint32_t> receive_ssrcs_ GUARDED_BY(stream_crit_);
+      RTC_GUARDED_BY(stream_crit_);
+  std::set<uint32_t> send_ssrcs_ RTC_GUARDED_BY(stream_crit_);
+  std::set<uint32_t> receive_ssrcs_ RTC_GUARDED_BY(stream_crit_);
 
   rtc::Optional<VideoCodecSettings> send_codec_;
   rtc::Optional<std::vector<webrtc::RtpExtension>> send_rtp_extensions_;
diff --git a/pc/mediamonitor.h b/pc/mediamonitor.h
index 5f2a1e2..b4efefb 100644
--- a/pc/mediamonitor.h
+++ b/pc/mediamonitor.h
@@ -61,7 +61,7 @@
     media_info_.Clear();
     media_channel_->GetStats(&media_info_);
   }
-  virtual void Update() EXCLUSIVE_LOCKS_REQUIRED(crit_) {
+  virtual void Update() RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_) {
     MI stats(media_info_);
     crit_.Leave();
     SignalUpdate(media_channel_, stats);
diff --git a/pc/videotrack.h b/pc/videotrack.h
index 6e20e97..d0f0618 100644
--- a/pc/videotrack.h
+++ b/pc/videotrack.h
@@ -55,7 +55,7 @@
   rtc::Thread* const worker_thread_;
   rtc::ThreadChecker signaling_thread_checker_;
   rtc::scoped_refptr<VideoTrackSourceInterface> video_source_;
-  ContentHint content_hint_ GUARDED_BY(signaling_thread_checker_);
+  ContentHint content_hint_ RTC_GUARDED_BY(signaling_thread_checker_);
 };
 
 }  // namespace webrtc
diff --git a/rtc_base/task_queue_win.cc b/rtc_base/task_queue_win.cc
index 00a8c79..6ff64c0 100644
--- a/rtc_base/task_queue_win.cc
+++ b/rtc_base/task_queue_win.cc
@@ -236,7 +236,8 @@
   TaskQueue* const queue_;
   WorkerThread thread_;
   rtc::CriticalSection pending_lock_;
-  std::queue<std::unique_ptr<QueuedTask>> pending_ GUARDED_BY(pending_lock_);
+  std::queue<std::unique_ptr<QueuedTask>> pending_
+      RTC_GUARDED_BY(pending_lock_);
   HANDLE in_queue_;
 };
 
diff --git a/rtc_tools/network_tester/packet_sender.h b/rtc_tools/network_tester/packet_sender.h
index d47543d..78c3ab8 100644
--- a/rtc_tools/network_tester/packet_sender.h
+++ b/rtc_tools/network_tester/packet_sender.h
@@ -49,10 +49,10 @@
 
  private:
   rtc::SequencedTaskChecker worker_queue_checker_;
-  size_t packet_size_ ACCESS_ON(worker_queue_checker_);
-  int64_t send_interval_ms_ ACCESS_ON(worker_queue_checker_);
-  int64_t sequence_number_ ACCESS_ON(worker_queue_checker_);
-  bool sending_ ACCESS_ON(worker_queue_checker_);
+  size_t packet_size_ RTC_ACCESS_ON(worker_queue_checker_);
+  int64_t send_interval_ms_ RTC_ACCESS_ON(worker_queue_checker_);
+  int64_t sequence_number_ RTC_ACCESS_ON(worker_queue_checker_);
+  bool sending_ RTC_ACCESS_ON(worker_queue_checker_);
   const std::string config_file_path_;
   TestController* const test_controller_;
   rtc::TaskQueue worker_queue_;
diff --git a/rtc_tools/network_tester/test_controller.h b/rtc_tools/network_tester/test_controller.h
index 14ee0c4..870ca47 100644
--- a/rtc_tools/network_tester/test_controller.h
+++ b/rtc_tools/network_tester/test_controller.h
@@ -67,7 +67,7 @@
   const std::string config_file_path_;
   PacketLogger packet_logger_;
   rtc::CriticalSection local_test_done_lock_;
-  bool local_test_done_ GUARDED_BY(local_test_done_lock_);
+  bool local_test_done_ RTC_GUARDED_BY(local_test_done_lock_);
   bool remote_test_done_;
   std::array<char, kEthernetMtu> send_data_;
   std::unique_ptr<cricket::UdpTransport> udp_transport_;
diff --git a/system_wrappers/include/rw_lock_wrapper.h b/system_wrappers/include/rw_lock_wrapper.h
index 855ecff..62e75b4 100644
--- a/system_wrappers/include/rw_lock_wrapper.h
+++ b/system_wrappers/include/rw_lock_wrapper.h
@@ -19,45 +19,41 @@
 
 namespace webrtc {
 
-class LOCKABLE RWLockWrapper {
+class RTC_LOCKABLE RWLockWrapper {
  public:
   static RWLockWrapper* CreateRWLock();
   virtual ~RWLockWrapper() {}
 
-  virtual void AcquireLockExclusive() EXCLUSIVE_LOCK_FUNCTION() = 0;
-  virtual void ReleaseLockExclusive() UNLOCK_FUNCTION() = 0;
+  virtual void AcquireLockExclusive() RTC_EXCLUSIVE_LOCK_FUNCTION() = 0;
+  virtual void ReleaseLockExclusive() RTC_UNLOCK_FUNCTION() = 0;
 
-  virtual void AcquireLockShared() SHARED_LOCK_FUNCTION() = 0;
-  virtual void ReleaseLockShared() UNLOCK_FUNCTION() = 0;
+  virtual void AcquireLockShared() RTC_SHARED_LOCK_FUNCTION() = 0;
+  virtual void ReleaseLockShared() RTC_UNLOCK_FUNCTION() = 0;
 };
 
 // RAII extensions of the RW lock. Prevents Acquire/Release missmatches and
 // provides more compact locking syntax.
-class SCOPED_LOCKABLE ReadLockScoped {
+class RTC_SCOPED_LOCKABLE ReadLockScoped {
  public:
-  ReadLockScoped(RWLockWrapper& rw_lock) SHARED_LOCK_FUNCTION(rw_lock)
+  ReadLockScoped(RWLockWrapper& rw_lock) RTC_SHARED_LOCK_FUNCTION(rw_lock)
       : rw_lock_(rw_lock) {
     rw_lock_.AcquireLockShared();
   }
 
-  ~ReadLockScoped() UNLOCK_FUNCTION() {
-    rw_lock_.ReleaseLockShared();
-  }
+  ~ReadLockScoped() RTC_UNLOCK_FUNCTION() { rw_lock_.ReleaseLockShared(); }
 
  private:
   RWLockWrapper& rw_lock_;
 };
 
-class SCOPED_LOCKABLE WriteLockScoped {
+class RTC_SCOPED_LOCKABLE WriteLockScoped {
  public:
-  WriteLockScoped(RWLockWrapper& rw_lock) EXCLUSIVE_LOCK_FUNCTION(rw_lock)
+  WriteLockScoped(RWLockWrapper& rw_lock) RTC_EXCLUSIVE_LOCK_FUNCTION(rw_lock)
       : rw_lock_(rw_lock) {
     rw_lock_.AcquireLockExclusive();
   }
 
-  ~WriteLockScoped() UNLOCK_FUNCTION() {
-    rw_lock_.ReleaseLockExclusive();
-  }
+  ~WriteLockScoped() RTC_UNLOCK_FUNCTION() { rw_lock_.ReleaseLockExclusive(); }
 
  private:
   RWLockWrapper& rw_lock_;
diff --git a/system_wrappers/source/metrics_default.cc b/system_wrappers/source/metrics_default.cc
index f9a6f6a..6e5715e 100644
--- a/system_wrappers/source/metrics_default.cc
+++ b/system_wrappers/source/metrics_default.cc
@@ -93,7 +93,7 @@
   rtc::CriticalSection crit_;
   const int min_;
   const int max_;
-  SampleInfo info_ GUARDED_BY(crit_);
+  SampleInfo info_ RTC_GUARDED_BY(crit_);
 
   RTC_DISALLOW_COPY_AND_ASSIGN(RtcHistogram);
 };
@@ -165,7 +165,8 @@
 
  private:
   rtc::CriticalSection crit_;
-  std::map<std::string, std::unique_ptr<RtcHistogram>> map_ GUARDED_BY(crit_);
+  std::map<std::string, std::unique_ptr<RtcHistogram>> map_
+      RTC_GUARDED_BY(crit_);
 
   RTC_DISALLOW_COPY_AND_ASSIGN(RtcHistogramMap);
 };
diff --git a/system_wrappers/source/trace_impl.h b/system_wrappers/source/trace_impl.h
index 90e4a3a..0e36aff 100644
--- a/system_wrappers/source/trace_impl.h
+++ b/system_wrappers/source/trace_impl.h
@@ -81,7 +81,7 @@
 
   bool UpdateFileName(
       char file_name_with_counter_utf8[FileWrapper::kMaxFileNameSize],
-      const uint32_t new_count) const EXCLUSIVE_LOCKS_REQUIRED(crit_);
+      const uint32_t new_count) const RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_);
 
   bool CreateFileName(
     const char file_name_utf8[FileWrapper::kMaxFileNameSize],
@@ -89,14 +89,14 @@
     const uint32_t new_count) const;
 
   void WriteToFile(const char* msg, uint16_t length)
-      EXCLUSIVE_LOCKS_REQUIRED(crit_);
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_);
 
-  TraceCallback* callback_ GUARDED_BY(crit_);
-  uint32_t row_count_text_ GUARDED_BY(crit_);
-  uint32_t file_count_text_ GUARDED_BY(crit_);
+  TraceCallback* callback_ RTC_GUARDED_BY(crit_);
+  uint32_t row_count_text_ RTC_GUARDED_BY(crit_);
+  uint32_t file_count_text_ RTC_GUARDED_BY(crit_);
 
-  const std::unique_ptr<FileWrapper> trace_file_ GUARDED_BY(crit_);
-  std::string trace_file_path_ GUARDED_BY(crit_);
+  const std::unique_ptr<FileWrapper> trace_file_ RTC_GUARDED_BY(crit_);
+  std::string trace_file_path_ RTC_GUARDED_BY(crit_);
   rtc::CriticalSection crit_;
 };
 
diff --git a/test/direct_transport.h b/test/direct_transport.h
index 11b086d..c60157d 100644
--- a/test/direct_transport.h
+++ b/test/direct_transport.h
@@ -70,7 +70,7 @@
 
   SingleThreadedTaskQueueForTesting* const task_queue_;
   SingleThreadedTaskQueueForTesting::TaskId next_scheduled_task_
-      GUARDED_BY(&sequence_checker_);
+      RTC_GUARDED_BY(&sequence_checker_);
 
   FakeNetworkPipe fake_network_;
 
diff --git a/test/fake_audio_device.h b/test/fake_audio_device.h
index db56c74..939d16a 100644
--- a/test/fake_audio_device.h
+++ b/test/fake_audio_device.h
@@ -121,19 +121,19 @@
   static bool Run(void* obj);
   void ProcessAudio();
 
-  const std::unique_ptr<Capturer> capturer_ GUARDED_BY(lock_);
-  const std::unique_ptr<Renderer> renderer_ GUARDED_BY(lock_);
+  const std::unique_ptr<Capturer> capturer_ RTC_GUARDED_BY(lock_);
+  const std::unique_ptr<Renderer> renderer_ RTC_GUARDED_BY(lock_);
   const float speed_;
 
   rtc::CriticalSection lock_;
-  AudioTransport* audio_callback_ GUARDED_BY(lock_);
-  bool rendering_ GUARDED_BY(lock_);
-  bool capturing_ GUARDED_BY(lock_);
+  AudioTransport* audio_callback_ RTC_GUARDED_BY(lock_);
+  bool rendering_ RTC_GUARDED_BY(lock_);
+  bool capturing_ RTC_GUARDED_BY(lock_);
   rtc::Event done_rendering_;
   rtc::Event done_capturing_;
 
-  std::vector<int16_t> playout_buffer_ GUARDED_BY(lock_);
-  rtc::BufferT<int16_t> recording_buffer_ GUARDED_BY(lock_);
+  std::vector<int16_t> playout_buffer_ RTC_GUARDED_BY(lock_);
+  rtc::BufferT<int16_t> recording_buffer_ RTC_GUARDED_BY(lock_);
 
   std::unique_ptr<EventTimerWrapper> tick_;
   rtc::PlatformThread thread_;
diff --git a/test/fake_encoder.h b/test/fake_encoder.h
index 96218e5..c8912a1 100644
--- a/test/fake_encoder.h
+++ b/test/fake_encoder.h
@@ -51,12 +51,12 @@
 
  protected:
   Clock* const clock_;
-  VideoCodec config_ GUARDED_BY(crit_sect_);
-  EncodedImageCallback* callback_ GUARDED_BY(crit_sect_);
-  BitrateAllocation target_bitrate_ GUARDED_BY(crit_sect_);
-  int configured_input_framerate_ GUARDED_BY(crit_sect_);
-  int max_target_bitrate_kbps_ GUARDED_BY(crit_sect_);
-  bool pending_keyframe_ GUARDED_BY(crit_sect_);
+  VideoCodec config_ RTC_GUARDED_BY(crit_sect_);
+  EncodedImageCallback* callback_ RTC_GUARDED_BY(crit_sect_);
+  BitrateAllocation target_bitrate_ RTC_GUARDED_BY(crit_sect_);
+  int configured_input_framerate_ RTC_GUARDED_BY(crit_sect_);
+  int max_target_bitrate_kbps_ RTC_GUARDED_BY(crit_sect_);
+  bool pending_keyframe_ RTC_GUARDED_BY(crit_sect_);
   rtc::CriticalSection crit_sect_;
 
   uint8_t encoded_buffer_[100000];
@@ -79,8 +79,8 @@
                         const RTPFragmentationHeader* fragments) override;
 
  private:
-  EncodedImageCallback* callback_ GUARDED_BY(local_crit_sect_);
-  int idr_counter_ GUARDED_BY(local_crit_sect_);
+  EncodedImageCallback* callback_ RTC_GUARDED_BY(local_crit_sect_);
+  int idr_counter_ RTC_GUARDED_BY(local_crit_sect_);
   rtc::CriticalSection local_crit_sect_;
 };
 
@@ -95,7 +95,7 @@
                  const std::vector<FrameType>* frame_types) override;
 
  private:
-  int delay_ms_ ACCESS_ON(sequence_checker_);
+  int delay_ms_ RTC_ACCESS_ON(sequence_checker_);
   rtc::SequencedTaskChecker sequence_checker_;
 };
 
@@ -125,9 +125,9 @@
  protected:
   class EncodeTask;
 
-  int current_queue_ ACCESS_ON(sequence_checker_);
-  std::unique_ptr<rtc::TaskQueue> queue1_ ACCESS_ON(sequence_checker_);
-  std::unique_ptr<rtc::TaskQueue> queue2_ ACCESS_ON(sequence_checker_);
+  int current_queue_ RTC_ACCESS_ON(sequence_checker_);
+  std::unique_ptr<rtc::TaskQueue> queue1_ RTC_ACCESS_ON(sequence_checker_);
+  std::unique_ptr<rtc::TaskQueue> queue2_ RTC_ACCESS_ON(sequence_checker_);
   rtc::SequencedTaskChecker sequence_checker_;
 };
 
diff --git a/test/frame_generator.cc b/test/frame_generator.cc
index 1956cdb..eff2ec2 100644
--- a/test/frame_generator.cc
+++ b/test/frame_generator.cc
@@ -108,10 +108,10 @@
   };
 
   rtc::CriticalSection crit_;
-  int width_ GUARDED_BY(&crit_);
-  int height_ GUARDED_BY(&crit_);
-  std::vector<std::unique_ptr<Square>> squares_ GUARDED_BY(&crit_);
-  std::unique_ptr<VideoFrame> frame_ GUARDED_BY(&crit_);
+  int width_ RTC_GUARDED_BY(&crit_);
+  int height_ RTC_GUARDED_BY(&crit_);
+  std::vector<std::unique_ptr<Square>> squares_ RTC_GUARDED_BY(&crit_);
+  std::unique_ptr<VideoFrame> frame_ RTC_GUARDED_BY(&crit_);
 };
 
 class YuvFileGenerator : public FrameGenerator {
diff --git a/test/frame_generator.h b/test/frame_generator.h
index dfe35b8..d42f226 100644
--- a/test/frame_generator.h
+++ b/test/frame_generator.h
@@ -42,8 +42,8 @@
   void RemoveSink(rtc::VideoSinkInterface<VideoFrame>* sink) override;
 
   rtc::CriticalSection crit_;
-  rtc::VideoSinkInterface<VideoFrame>* sink_ GUARDED_BY(crit_);
-  rtc::VideoSinkWants sink_wants_ GUARDED_BY(crit_);
+  rtc::VideoSinkInterface<VideoFrame>* sink_ RTC_GUARDED_BY(crit_);
+  rtc::VideoSinkWants sink_wants_ RTC_GUARDED_BY(crit_);
 };
 
 class FrameGenerator {
diff --git a/test/frame_generator_capturer.h b/test/frame_generator_capturer.h
index 4425121..8f3232c 100644
--- a/test/frame_generator_capturer.h
+++ b/test/frame_generator_capturer.h
@@ -87,14 +87,14 @@
 
   Clock* const clock_;
   bool sending_;
-  rtc::VideoSinkInterface<VideoFrame>* sink_ GUARDED_BY(&lock_);
-  SinkWantsObserver* sink_wants_observer_ GUARDED_BY(&lock_);
+  rtc::VideoSinkInterface<VideoFrame>* sink_ RTC_GUARDED_BY(&lock_);
+  SinkWantsObserver* sink_wants_observer_ RTC_GUARDED_BY(&lock_);
 
   rtc::CriticalSection lock_;
   std::unique_ptr<FrameGenerator> frame_generator_;
 
-  int target_fps_ GUARDED_BY(&lock_);
-  rtc::Optional<int> wanted_fps_ GUARDED_BY(&lock_);
+  int target_fps_ RTC_GUARDED_BY(&lock_);
+  rtc::Optional<int> wanted_fps_ RTC_GUARDED_BY(&lock_);
   VideoRotation fake_rotation_ = kVideoRotation_0;
 
   int64_t first_frame_capture_time_;
diff --git a/test/single_threaded_task_queue.h b/test/single_threaded_task_queue.h
index ecb22b3..c078bdd 100644
--- a/test/single_threaded_task_queue.h
+++ b/test/single_threaded_task_queue.h
@@ -71,10 +71,10 @@
   void RunLoop();
 
   rtc::CriticalSection cs_;
-  std::list<std::unique_ptr<QueuedTask>> tasks_ GUARDED_BY(cs_);
+  std::list<std::unique_ptr<QueuedTask>> tasks_ RTC_GUARDED_BY(cs_);
   rtc::ThreadChecker owner_thread_checker_;
   rtc::PlatformThread thread_;
-  bool running_ GUARDED_BY(cs_);
+  bool running_ RTC_GUARDED_BY(cs_);
 
   TaskId next_task_id_;
 
diff --git a/test/vcm_capturer.h b/test/vcm_capturer.h
index fdb594b..2b4323c 100644
--- a/test/vcm_capturer.h
+++ b/test/vcm_capturer.h
@@ -49,8 +49,8 @@
   void Destroy();
 
   rtc::CriticalSection crit_;
-  bool started_ GUARDED_BY(crit_);
-  rtc::VideoSinkInterface<VideoFrame>* sink_ GUARDED_BY(crit_);
+  bool started_ RTC_GUARDED_BY(crit_);
+  rtc::VideoSinkInterface<VideoFrame>* sink_ RTC_GUARDED_BY(crit_);
   rtc::scoped_refptr<VideoCaptureModule> vcm_;
   VideoCaptureCapability capability_;
 };
diff --git a/video/call_stats.h b/video/call_stats.h
index a9b4280..efa98ad 100644
--- a/video/call_stats.h
+++ b/video/call_stats.h
@@ -70,9 +70,9 @@
   // The last RTT in the statistics update (zero if there is no valid estimate).
   int64_t max_rtt_ms_;
   int64_t avg_rtt_ms_;
-  int64_t sum_avg_rtt_ms_ GUARDED_BY(crit_);
-  int64_t num_avg_rtt_ GUARDED_BY(crit_);
-  int64_t time_of_first_rtt_ms_ GUARDED_BY(crit_);
+  int64_t sum_avg_rtt_ms_ RTC_GUARDED_BY(crit_);
+  int64_t num_avg_rtt_ RTC_GUARDED_BY(crit_);
+  int64_t time_of_first_rtt_ms_ RTC_GUARDED_BY(crit_);
 
   // All Rtt reports within valid time interval, oldest first.
   std::list<RttTime> reports_;
diff --git a/video/encoder_rtcp_feedback.h b/video/encoder_rtcp_feedback.h
index 2f24e31..0e5b13b 100644
--- a/video/encoder_rtcp_feedback.h
+++ b/video/encoder_rtcp_feedback.h
@@ -37,7 +37,7 @@
   VideoStreamEncoder* const video_stream_encoder_;
 
   rtc::CriticalSection crit_;
-  std::vector<int64_t> time_last_intra_request_ms_ GUARDED_BY(crit_);
+  std::vector<int64_t> time_last_intra_request_ms_ RTC_GUARDED_BY(crit_);
 };
 
 }  // namespace webrtc
diff --git a/video/end_to_end_tests.cc b/video/end_to_end_tests.cc
index 644319c..ffd52fd 100644
--- a/video/end_to_end_tests.cc
+++ b/video/end_to_end_tests.cc
@@ -540,7 +540,7 @@
     std::set<uint16_t> retransmitted_packets_;
     uint64_t sent_rtp_packets_;
     int packets_left_to_drop_;
-    int nacks_left_ GUARDED_BY(&crit_);
+    int nacks_left_ RTC_GUARDED_BY(&crit_);
   } test;
 
   RunBaseTest(&test);
@@ -710,11 +710,11 @@
     rtc::CriticalSection crit_;
     std::unique_ptr<VideoEncoder> encoder_;
     std::unique_ptr<VideoDecoder> decoder_;
-    std::set<uint32_t> dropped_sequence_numbers_ GUARDED_BY(crit_);
+    std::set<uint32_t> dropped_sequence_numbers_ RTC_GUARDED_BY(crit_);
     // Several packets can have the same timestamp.
-    std::multiset<uint32_t> dropped_timestamps_ GUARDED_BY(crit_);
+    std::multiset<uint32_t> dropped_timestamps_ RTC_GUARDED_BY(crit_);
     Random random_;
-    int num_packets_sent_ GUARDED_BY(crit_);
+    int num_packets_sent_ RTC_GUARDED_BY(crit_);
   } test;
 
   RunBaseTest(&test);
@@ -887,12 +887,12 @@
   }
 
   rtc::CriticalSection crit_;
-  std::set<uint32_t> dropped_sequence_numbers_ GUARDED_BY(crit_);
+  std::set<uint32_t> dropped_sequence_numbers_ RTC_GUARDED_BY(crit_);
   // Several packets can have the same timestamp.
-  std::multiset<uint32_t> dropped_timestamps_ GUARDED_BY(crit_);
+  std::multiset<uint32_t> dropped_timestamps_ RTC_GUARDED_BY(crit_);
   const bool enable_nack_;
   const bool expect_flexfec_rtcp_;
-  bool received_flexfec_rtcp_ GUARDED_BY(crit_);
+  bool received_flexfec_rtcp_ RTC_GUARDED_BY(crit_);
   Random random_;
   int num_packets_sent_;
 };
@@ -1069,7 +1069,7 @@
     } state_;
 
     rtc::CriticalSection crit_;
-    uint16_t ulpfec_sequence_number_ GUARDED_BY(&crit_);
+    uint16_t ulpfec_sequence_number_ RTC_GUARDED_BY(&crit_);
     bool has_last_sequence_number_;
     uint16_t last_sequence_number_;
     std::unique_ptr<webrtc::VideoEncoder> encoder_;
@@ -1224,8 +1224,8 @@
     std::unique_ptr<VideoEncoder> encoder_;
     const std::string payload_name_;
     int marker_bits_observed_;
-    uint32_t retransmitted_timestamp_ GUARDED_BY(&crit_);
-    std::vector<uint32_t> rendered_timestamps_ GUARDED_BY(&crit_);
+    uint32_t retransmitted_timestamp_ RTC_GUARDED_BY(&crit_);
+    std::vector<uint32_t> rendered_timestamps_ RTC_GUARDED_BY(&crit_);
   } test(enable_rtx, enable_red);
 
   RunBaseTest(&test);
@@ -1319,9 +1319,9 @@
     rtc::CriticalSection crit_;
     int rtp_history_ms_;
     bool nack_enabled_;
-    uint32_t highest_dropped_timestamp_ GUARDED_BY(&crit_);
-    int frames_to_drop_ GUARDED_BY(&crit_);
-    bool received_pli_ GUARDED_BY(&crit_);
+    uint32_t highest_dropped_timestamp_ RTC_GUARDED_BY(&crit_);
+    int frames_to_drop_ RTC_GUARDED_BY(&crit_);
+    bool received_pli_ RTC_GUARDED_BY(&crit_);
   } test(rtp_history_ms);
 
   RunBaseTest(&test);
@@ -1479,8 +1479,8 @@
     rtc::CriticalSection crit_;
     // Must be protected since RTCP can be sent by both the process thread
     // and the pacer thread.
-    int sent_rtp_ GUARDED_BY(&crit_);
-    int sent_rtcp_ GUARDED_BY(&crit_);
+    int sent_rtp_ RTC_GUARDED_BY(&crit_);
+    int sent_rtcp_ RTC_GUARDED_BY(&crit_);
   } test(rtcp_mode);
 
   RunBaseTest(&test);
@@ -2075,8 +2075,8 @@
     const size_t num_video_streams_;
     const size_t num_audio_streams_;
     rtc::CriticalSection crit_;
-    int media_sent_ GUARDED_BY(crit_);
-    int padding_sent_ GUARDED_BY(crit_);
+    int media_sent_ RTC_GUARDED_BY(crit_);
+    int padding_sent_ RTC_GUARDED_BY(crit_);
   } test(1, 0);
   RunBaseTest(&test);
 }
@@ -2623,7 +2623,7 @@
       return SEND_PACKET;
     }
 
-    void VerifyStats() EXCLUSIVE_LOCKS_REQUIRED(&crit_) {
+    void VerifyStats() RTC_EXCLUSIVE_LOCKS_REQUIRED(&crit_) {
       if (!dropped_rtp_packet_requested_)
         return;
       int send_stream_nack_packets = 0;
@@ -2680,8 +2680,8 @@
     test::FakeVideoRenderer fake_renderer_;
     rtc::CriticalSection crit_;
     uint64_t sent_rtp_packets_;
-    uint16_t dropped_rtp_packet_ GUARDED_BY(&crit_);
-    bool dropped_rtp_packet_requested_ GUARDED_BY(&crit_);
+    uint16_t dropped_rtp_packet_ RTC_GUARDED_BY(&crit_);
+    bool dropped_rtp_packet_requested_ RTC_GUARDED_BY(&crit_);
     std::vector<VideoReceiveStream*> receive_streams_;
     VideoSendStream* send_stream_;
     int64_t start_runtime_ms_;
@@ -2803,7 +2803,7 @@
     Call* sender_call_;
     Call* receiver_call_;
     int64_t start_runtime_ms_;
-    int num_frames_received_ GUARDED_BY(&crit_);
+    int num_frames_received_ RTC_GUARDED_BY(&crit_);
   } test(use_rtx, use_red, screenshare);
 
   metrics::Reset();
@@ -2973,7 +2973,7 @@
     }
 
     rtc::CriticalSection crit_;
-    int num_frames_received_ GUARDED_BY(&crit_);
+    int num_frames_received_ RTC_GUARDED_BY(&crit_);
   } test;
 
   metrics::Reset();
@@ -3277,7 +3277,7 @@
     test::SingleThreadedTaskQueueForTesting* const task_queue_;
     rtc::CriticalSection crit_;
     VideoSendStream* send_stream_;
-    uint32_t bitrate_kbps_ GUARDED_BY(crit_);
+    uint32_t bitrate_kbps_ RTC_GUARDED_BY(crit_);
   } test(&task_queue_);
 
   RunBaseTest(&test);
@@ -3762,9 +3762,9 @@
   const bool enable_rrtr_;
   const bool enable_target_bitrate_;
   int sent_rtcp_sr_;
-  int sent_rtcp_rr_ GUARDED_BY(&crit_);
-  int sent_rtcp_rrtr_ GUARDED_BY(&crit_);
-  bool sent_rtcp_target_bitrate_ GUARDED_BY(&crit_);
+  int sent_rtcp_rr_ RTC_GUARDED_BY(&crit_);
+  int sent_rtcp_rrtr_ RTC_GUARDED_BY(&crit_);
+  bool sent_rtcp_target_bitrate_ RTC_GUARDED_BY(&crit_);
   int sent_rtcp_dlrr_;
 };
 
@@ -3994,7 +3994,7 @@
     void ValidateTimestampGap(uint32_t ssrc,
                               uint32_t timestamp,
                               bool only_padding)
-        EXCLUSIVE_LOCKS_REQUIRED(crit_) {
+        RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_) {
       static const int32_t kMaxTimestampGap = kDefaultTimeoutMs * 90;
       auto timestamp_it = last_observed_timestamp_.find(ssrc);
       if (timestamp_it == last_observed_timestamp_.end()) {
@@ -4083,8 +4083,8 @@
     std::map<uint32_t, bool> ssrc_is_rtx_;
 
     rtc::CriticalSection crit_;
-    size_t ssrcs_to_observe_ GUARDED_BY(crit_);
-    std::map<uint32_t, bool> ssrc_observed_ GUARDED_BY(crit_);
+    size_t ssrcs_to_observe_ RTC_GUARDED_BY(crit_);
+    std::map<uint32_t, bool> ssrc_observed_ RTC_GUARDED_BY(crit_);
   } observer(use_rtx);
 
   std::unique_ptr<test::PacketTransport> send_transport;
@@ -4276,9 +4276,10 @@
       return SEND_PACKET;
     }
 
-    rtc::Optional<uint16_t> last_observed_sequence_number_ GUARDED_BY(crit_);
-    rtc::Optional<uint32_t> last_observed_timestamp_ GUARDED_BY(crit_);
-    size_t num_flexfec_packets_sent_ GUARDED_BY(crit_);
+    rtc::Optional<uint16_t> last_observed_sequence_number_
+        RTC_GUARDED_BY(crit_);
+    rtc::Optional<uint32_t> last_observed_timestamp_ RTC_GUARDED_BY(crit_);
+    size_t num_flexfec_packets_sent_ RTC_GUARDED_BY(crit_);
     rtc::CriticalSection crit_;
   } observer;
 
@@ -4595,12 +4596,12 @@
     rtc::Event packet_event_;
     Call* sender_call_;
     Call* receiver_call_;
-    NetworkState sender_state_ GUARDED_BY(test_crit_);
-    int sender_rtp_ GUARDED_BY(test_crit_);
-    int sender_padding_ GUARDED_BY(test_crit_);
-    int sender_rtcp_ GUARDED_BY(test_crit_);
-    int receiver_rtcp_ GUARDED_BY(test_crit_);
-    int down_frames_ GUARDED_BY(test_crit_);
+    NetworkState sender_state_ RTC_GUARDED_BY(test_crit_);
+    int sender_rtp_ RTC_GUARDED_BY(test_crit_);
+    int sender_padding_ RTC_GUARDED_BY(test_crit_);
+    int sender_rtcp_ RTC_GUARDED_BY(test_crit_);
+    int receiver_rtcp_ RTC_GUARDED_BY(test_crit_);
+    int down_frames_ RTC_GUARDED_BY(test_crit_);
   } test(&task_queue_);
 
   RunBaseTest(&test);
@@ -5016,7 +5017,7 @@
     std::unique_ptr<VideoEncoder> encoder_;
     std::unique_ptr<VideoDecoder> decoder_;
     rtc::CriticalSection crit_;
-    int recorded_frames_ GUARDED_BY(crit_);
+    int recorded_frames_ RTC_GUARDED_BY(crit_);
   } test(this);
 
   RunBaseTest(&test);
diff --git a/video/overuse_frame_detector.h b/video/overuse_frame_detector.h
index a5eef51..a4f4588 100644
--- a/video/overuse_frame_detector.h
+++ b/video/overuse_frame_detector.h
@@ -133,27 +133,28 @@
 
   // Stats metrics.
   CpuOveruseMetricsObserver* const metrics_observer_;
-  rtc::Optional<CpuOveruseMetrics> metrics_ GUARDED_BY(task_checker_);
+  rtc::Optional<CpuOveruseMetrics> metrics_ RTC_GUARDED_BY(task_checker_);
 
-  int64_t num_process_times_ GUARDED_BY(task_checker_);
+  int64_t num_process_times_ RTC_GUARDED_BY(task_checker_);
 
-  int64_t last_capture_time_us_ GUARDED_BY(task_checker_);
-  int64_t last_processed_capture_time_us_ GUARDED_BY(task_checker_);
+  int64_t last_capture_time_us_ RTC_GUARDED_BY(task_checker_);
+  int64_t last_processed_capture_time_us_ RTC_GUARDED_BY(task_checker_);
 
   // Number of pixels of last captured frame.
-  int num_pixels_ GUARDED_BY(task_checker_);
-  int max_framerate_ GUARDED_BY(task_checker_);
-  int64_t last_overuse_time_ms_ GUARDED_BY(task_checker_);
-  int checks_above_threshold_ GUARDED_BY(task_checker_);
-  int num_overuse_detections_ GUARDED_BY(task_checker_);
-  int64_t last_rampup_time_ms_ GUARDED_BY(task_checker_);
-  bool in_quick_rampup_ GUARDED_BY(task_checker_);
-  int current_rampup_delay_ms_ GUARDED_BY(task_checker_);
+  int num_pixels_ RTC_GUARDED_BY(task_checker_);
+  int max_framerate_ RTC_GUARDED_BY(task_checker_);
+  int64_t last_overuse_time_ms_ RTC_GUARDED_BY(task_checker_);
+  int checks_above_threshold_ RTC_GUARDED_BY(task_checker_);
+  int num_overuse_detections_ RTC_GUARDED_BY(task_checker_);
+  int64_t last_rampup_time_ms_ RTC_GUARDED_BY(task_checker_);
+  bool in_quick_rampup_ RTC_GUARDED_BY(task_checker_);
+  int current_rampup_delay_ms_ RTC_GUARDED_BY(task_checker_);
 
   // TODO(asapersson): Can these be regular members (avoid separate heap
   // allocs)?
-  const std::unique_ptr<SendProcessingUsage> usage_ GUARDED_BY(task_checker_);
-  std::list<FrameTiming> frame_timing_ GUARDED_BY(task_checker_);
+  const std::unique_ptr<SendProcessingUsage> usage_
+      RTC_GUARDED_BY(task_checker_);
+  std::list<FrameTiming> frame_timing_ RTC_GUARDED_BY(task_checker_);
 
   RTC_DISALLOW_COPY_AND_ASSIGN(OveruseFrameDetector);
 };
diff --git a/video/payload_router.h b/video/payload_router.h
index bfd4b8e..082ba36 100644
--- a/video/payload_router.h
+++ b/video/payload_router.h
@@ -49,10 +49,10 @@
   void OnBitrateAllocationUpdated(const BitrateAllocation& bitrate);
 
  private:
-  void UpdateModuleSendingState() EXCLUSIVE_LOCKS_REQUIRED(crit_);
+  void UpdateModuleSendingState() RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_);
 
   rtc::CriticalSection crit_;
-  bool active_ GUARDED_BY(crit_);
+  bool active_ RTC_GUARDED_BY(crit_);
 
   // Rtp modules are assumed to be sorted in simulcast index order. Not owned.
   const std::vector<RtpRtcp*> rtp_modules_;
diff --git a/video/picture_id_tests.cc b/video/picture_id_tests.cc
index 13574b8..0c83796 100644
--- a/video/picture_id_tests.cc
+++ b/video/picture_id_tests.cc
@@ -124,12 +124,12 @@
   }
 
   rtc::CriticalSection crit_;
-  std::map<uint32_t, uint32_t> last_observed_timestamp_ GUARDED_BY(crit_);
-  std::map<uint32_t, uint16_t> last_observed_picture_id_ GUARDED_BY(crit_);
-  std::map<uint32_t, size_t> num_packets_sent_ GUARDED_BY(crit_);
-  int max_expected_picture_id_gap_ GUARDED_BY(crit_);
-  size_t num_ssrcs_to_observe_ GUARDED_BY(crit_);
-  std::set<uint32_t> observed_ssrcs_ GUARDED_BY(crit_);
+  std::map<uint32_t, uint32_t> last_observed_timestamp_ RTC_GUARDED_BY(crit_);
+  std::map<uint32_t, uint16_t> last_observed_picture_id_ RTC_GUARDED_BY(crit_);
+  std::map<uint32_t, size_t> num_packets_sent_ RTC_GUARDED_BY(crit_);
+  int max_expected_picture_id_gap_ RTC_GUARDED_BY(crit_);
+  size_t num_ssrcs_to_observe_ RTC_GUARDED_BY(crit_);
+  std::set<uint32_t> observed_ssrcs_ RTC_GUARDED_BY(crit_);
 };
 
 class PictureIdTest : public test::CallTest {
diff --git a/video/receive_statistics_proxy.h b/video/receive_statistics_proxy.h
index 45424d9..262be64 100644
--- a/video/receive_statistics_proxy.h
+++ b/video/receive_statistics_proxy.h
@@ -126,12 +126,13 @@
     FrameCounts frame_counts;
   };
 
-  void UpdateHistograms() EXCLUSIVE_LOCKS_REQUIRED(crit_);
+  void UpdateHistograms() RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_);
 
-  void QualitySample() EXCLUSIVE_LOCKS_REQUIRED(crit_);
+  void QualitySample() RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_);
 
   // Removes info about old frames and then updates the framerate.
-  void UpdateFramerate(int64_t now_ms) const EXCLUSIVE_LOCKS_REQUIRED(crit_);
+  void UpdateFramerate(int64_t now_ms) const
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_);
 
   Clock* const clock_;
   // Ownership of this object lies with the owner of the ReceiveStatisticsProxy
@@ -145,42 +146,42 @@
   const int64_t start_ms_;
 
   rtc::CriticalSection crit_;
-  int64_t last_sample_time_ GUARDED_BY(crit_);
-  QualityThreshold fps_threshold_ GUARDED_BY(crit_);
-  QualityThreshold qp_threshold_ GUARDED_BY(crit_);
-  QualityThreshold variance_threshold_ GUARDED_BY(crit_);
-  SampleCounter qp_sample_ GUARDED_BY(crit_);
-  int num_bad_states_ GUARDED_BY(crit_);
-  int num_certain_states_ GUARDED_BY(crit_);
-  mutable VideoReceiveStream::Stats stats_ GUARDED_BY(crit_);
-  RateStatistics decode_fps_estimator_ GUARDED_BY(crit_);
-  RateStatistics renders_fps_estimator_ GUARDED_BY(crit_);
-  rtc::RateTracker render_fps_tracker_ GUARDED_BY(crit_);
-  rtc::RateTracker render_pixel_tracker_ GUARDED_BY(crit_);
-  rtc::RateTracker total_byte_tracker_ GUARDED_BY(crit_);
-  SampleCounter sync_offset_counter_ GUARDED_BY(crit_);
-  SampleCounter decode_time_counter_ GUARDED_BY(crit_);
-  SampleCounter jitter_buffer_delay_counter_ GUARDED_BY(crit_);
-  SampleCounter target_delay_counter_ GUARDED_BY(crit_);
-  SampleCounter current_delay_counter_ GUARDED_BY(crit_);
-  SampleCounter delay_counter_ GUARDED_BY(crit_);
+  int64_t last_sample_time_ RTC_GUARDED_BY(crit_);
+  QualityThreshold fps_threshold_ RTC_GUARDED_BY(crit_);
+  QualityThreshold qp_threshold_ RTC_GUARDED_BY(crit_);
+  QualityThreshold variance_threshold_ RTC_GUARDED_BY(crit_);
+  SampleCounter qp_sample_ RTC_GUARDED_BY(crit_);
+  int num_bad_states_ RTC_GUARDED_BY(crit_);
+  int num_certain_states_ RTC_GUARDED_BY(crit_);
+  mutable VideoReceiveStream::Stats stats_ RTC_GUARDED_BY(crit_);
+  RateStatistics decode_fps_estimator_ RTC_GUARDED_BY(crit_);
+  RateStatistics renders_fps_estimator_ RTC_GUARDED_BY(crit_);
+  rtc::RateTracker render_fps_tracker_ RTC_GUARDED_BY(crit_);
+  rtc::RateTracker render_pixel_tracker_ RTC_GUARDED_BY(crit_);
+  rtc::RateTracker total_byte_tracker_ RTC_GUARDED_BY(crit_);
+  SampleCounter sync_offset_counter_ RTC_GUARDED_BY(crit_);
+  SampleCounter decode_time_counter_ RTC_GUARDED_BY(crit_);
+  SampleCounter jitter_buffer_delay_counter_ RTC_GUARDED_BY(crit_);
+  SampleCounter target_delay_counter_ RTC_GUARDED_BY(crit_);
+  SampleCounter current_delay_counter_ RTC_GUARDED_BY(crit_);
+  SampleCounter delay_counter_ RTC_GUARDED_BY(crit_);
   mutable rtc::MovingMaxCounter<int> interframe_delay_max_moving_
-      GUARDED_BY(crit_);
+      RTC_GUARDED_BY(crit_);
   std::map<VideoContentType, ContentSpecificStats> content_specific_stats_
-      GUARDED_BY(crit_);
-  MaxCounter freq_offset_counter_ GUARDED_BY(crit_);
-  int64_t first_report_block_time_ms_ GUARDED_BY(crit_);
-  ReportBlockStats report_block_stats_ GUARDED_BY(crit_);
+      RTC_GUARDED_BY(crit_);
+  MaxCounter freq_offset_counter_ RTC_GUARDED_BY(crit_);
+  int64_t first_report_block_time_ms_ RTC_GUARDED_BY(crit_);
+  ReportBlockStats report_block_stats_ RTC_GUARDED_BY(crit_);
   QpCounters qp_counters_;  // Only accessed on the decoding thread.
-  std::map<uint32_t, StreamDataCounters> rtx_stats_ GUARDED_BY(crit_);
-  int64_t avg_rtt_ms_ GUARDED_BY(crit_);
-  mutable std::map<int64_t, size_t> frame_window_ GUARDED_BY(&crit_);
-  VideoContentType last_content_type_ GUARDED_BY(&crit_);
-  rtc::Optional<int64_t> last_decoded_frame_time_ms_ GUARDED_BY(&crit_);
+  std::map<uint32_t, StreamDataCounters> rtx_stats_ RTC_GUARDED_BY(crit_);
+  int64_t avg_rtt_ms_ RTC_GUARDED_BY(crit_);
+  mutable std::map<int64_t, size_t> frame_window_ RTC_GUARDED_BY(&crit_);
+  VideoContentType last_content_type_ RTC_GUARDED_BY(&crit_);
+  rtc::Optional<int64_t> last_decoded_frame_time_ms_ RTC_GUARDED_BY(&crit_);
   // Mutable because calling Max() on MovingMaxCounter is not const. Yet it is
   // called from const GetStats().
   mutable rtc::MovingMaxCounter<TimingFrameInfo> timing_frame_info_counter_
-      GUARDED_BY(&crit_);
+      RTC_GUARDED_BY(&crit_);
 };
 
 }  // namespace webrtc
diff --git a/video/rtp_streams_synchronizer.h b/video/rtp_streams_synchronizer.h
index dfc0ddb..c8f2d2a 100644
--- a/video/rtp_streams_synchronizer.h
+++ b/video/rtp_streams_synchronizer.h
@@ -52,13 +52,13 @@
   Syncable* syncable_video_;
 
   rtc::CriticalSection crit_;
-  Syncable* syncable_audio_ GUARDED_BY(crit_);
-  std::unique_ptr<StreamSynchronization> sync_ GUARDED_BY(crit_);
-  StreamSynchronization::Measurements audio_measurement_ GUARDED_BY(crit_);
-  StreamSynchronization::Measurements video_measurement_ GUARDED_BY(crit_);
+  Syncable* syncable_audio_ RTC_GUARDED_BY(crit_);
+  std::unique_ptr<StreamSynchronization> sync_ RTC_GUARDED_BY(crit_);
+  StreamSynchronization::Measurements audio_measurement_ RTC_GUARDED_BY(crit_);
+  StreamSynchronization::Measurements video_measurement_ RTC_GUARDED_BY(crit_);
 
   rtc::ThreadChecker process_thread_checker_;
-  int64_t last_sync_time_ ACCESS_ON(&process_thread_checker_);
+  int64_t last_sync_time_ RTC_ACCESS_ON(&process_thread_checker_);
 };
 
 }  // namespace webrtc
diff --git a/video/rtp_video_stream_receiver.h b/video/rtp_video_stream_receiver.h
index f65280e..3c8b2aa 100644
--- a/video/rtp_video_stream_receiver.h
+++ b/video/rtp_video_stream_receiver.h
@@ -184,10 +184,10 @@
   std::unique_ptr<UlpfecReceiver> ulpfec_receiver_;
 
   rtc::SequencedTaskChecker worker_task_checker_;
-  bool receiving_ GUARDED_BY(worker_task_checker_);
-  uint8_t restored_packet_[IP_PACKET_SIZE] GUARDED_BY(worker_task_checker_);
-  bool restored_packet_in_use_ GUARDED_BY(worker_task_checker_);
-  int64_t last_packet_log_ms_ GUARDED_BY(worker_task_checker_);
+  bool receiving_ RTC_GUARDED_BY(worker_task_checker_);
+  uint8_t restored_packet_[IP_PACKET_SIZE] RTC_GUARDED_BY(worker_task_checker_);
+  bool restored_packet_in_use_ RTC_GUARDED_BY(worker_task_checker_);
+  int64_t last_packet_log_ms_ RTC_GUARDED_BY(worker_task_checker_);
 
   const std::unique_ptr<RtpRtcp> rtp_rtcp_;
 
@@ -200,7 +200,7 @@
   std::unique_ptr<video_coding::RtpFrameReferenceFinder> reference_finder_;
   rtc::CriticalSection last_seq_num_cs_;
   std::map<int64_t, uint16_t> last_seq_num_for_pic_id_
-      GUARDED_BY(last_seq_num_cs_);
+      RTC_GUARDED_BY(last_seq_num_cs_);
   video_coding::H264SpsPpsTracker tracker_;
   // TODO(johan): Remove pt_codec_params_ once
   // https://bugs.chromium.org/p/webrtc/issues/detail?id=6883 is resolved.
@@ -211,7 +211,7 @@
   bool has_received_frame_;
 
   std::vector<RtpPacketSinkInterface*> secondary_sinks_
-      GUARDED_BY(worker_task_checker_);
+      RTC_GUARDED_BY(worker_task_checker_);
 };
 
 }  // namespace webrtc
diff --git a/video/send_delay_stats.h b/video/send_delay_stats.h
index 5d8538e..230fa9d 100644
--- a/video/send_delay_stats.h
+++ b/video/send_delay_stats.h
@@ -64,22 +64,22 @@
 
   void UpdateHistograms();
   void RemoveOld(int64_t now, PacketMap* packets)
-      EXCLUSIVE_LOCKS_REQUIRED(crit_);
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_);
   AvgCounter* GetSendDelayCounter(uint32_t ssrc)
-      EXCLUSIVE_LOCKS_REQUIRED(crit_);
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_);
 
   Clock* const clock_;
   rtc::CriticalSection crit_;
 
-  PacketMap packets_ GUARDED_BY(crit_);
-  size_t num_old_packets_ GUARDED_BY(crit_);
-  size_t num_skipped_packets_ GUARDED_BY(crit_);
+  PacketMap packets_ RTC_GUARDED_BY(crit_);
+  size_t num_old_packets_ RTC_GUARDED_BY(crit_);
+  size_t num_skipped_packets_ RTC_GUARDED_BY(crit_);
 
-  std::set<uint32_t> ssrcs_ GUARDED_BY(crit_);
+  std::set<uint32_t> ssrcs_ RTC_GUARDED_BY(crit_);
 
   // Mapped by SSRC.
   std::map<uint32_t, std::unique_ptr<AvgCounter>> send_delay_counters_
-      GUARDED_BY(crit_);
+      RTC_GUARDED_BY(crit_);
 };
 
 }  // namespace webrtc
diff --git a/video/send_statistics_proxy.h b/video/send_statistics_proxy.h
index fead848..d6e91d7 100644
--- a/video/send_statistics_proxy.h
+++ b/video/send_statistics_proxy.h
@@ -162,30 +162,29 @@
     SampleCounter vp9;   // QP range: 0-255.
     SampleCounter h264;  // QP range: 0-51.
   };
-  void PurgeOldStats() EXCLUSIVE_LOCKS_REQUIRED(crit_);
+  void PurgeOldStats() RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_);
   VideoSendStream::StreamStats* GetStatsEntry(uint32_t ssrc)
-      EXCLUSIVE_LOCKS_REQUIRED(crit_);
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_);
 
   void SetAdaptTimer(const VideoStreamEncoder::AdaptCounts& counts,
-                     StatsTimer* timer)
-      EXCLUSIVE_LOCKS_REQUIRED(crit_);
+                     StatsTimer* timer) RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_);
   void UpdateAdaptationStats(
       const VideoStreamEncoder::AdaptCounts& cpu_counts,
       const VideoStreamEncoder::AdaptCounts& quality_counts)
-      EXCLUSIVE_LOCKS_REQUIRED(crit_);
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_);
 
   Clock* const clock_;
   const std::string payload_name_;
   const VideoSendStream::Config::Rtp rtp_config_;
   rtc::CriticalSection crit_;
-  VideoEncoderConfig::ContentType content_type_ GUARDED_BY(crit_);
+  VideoEncoderConfig::ContentType content_type_ RTC_GUARDED_BY(crit_);
   const int64_t start_ms_;
-  VideoSendStream::Stats stats_ GUARDED_BY(crit_);
-  uint32_t last_sent_frame_timestamp_ GUARDED_BY(crit_);
-  std::map<uint32_t, StatsUpdateTimes> update_times_ GUARDED_BY(crit_);
-  rtc::ExpFilter encode_time_ GUARDED_BY(crit_);
-  int quality_downscales_ GUARDED_BY(crit_);
-  int cpu_downscales_ GUARDED_BY(crit_);
+  VideoSendStream::Stats stats_ RTC_GUARDED_BY(crit_);
+  uint32_t last_sent_frame_timestamp_ RTC_GUARDED_BY(crit_);
+  std::map<uint32_t, StatsUpdateTimes> update_times_ RTC_GUARDED_BY(crit_);
+  rtc::ExpFilter encode_time_ RTC_GUARDED_BY(crit_);
+  int quality_downscales_ RTC_GUARDED_BY(crit_);
+  int cpu_downscales_ RTC_GUARDED_BY(crit_);
 
   // Contains stats used for UMA histograms. These stats will be reset if
   // content type changes between real-time video and screenshare, since these
@@ -240,7 +239,7 @@
         qp_counters_;  // QP counters mapped by spatial idx.
   };
 
-  std::unique_ptr<UmaSamplesContainer> uma_container_ GUARDED_BY(crit_);
+  std::unique_ptr<UmaSamplesContainer> uma_container_ RTC_GUARDED_BY(crit_);
 };
 
 }  // namespace webrtc
diff --git a/video/video_quality_test.cc b/video/video_quality_test.cc
index 92d7968..11e0605 100644
--- a/video/video_quality_test.cc
+++ b/video/video_quality_test.cc
@@ -649,7 +649,7 @@
                           const VideoFrame& render,
                           bool dropped,
                           int64_t render_time_ms)
-      EXCLUSIVE_LOCKS_REQUIRED(crit_) {
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_) {
     int64_t reference_timestamp = wrap_handler_.Unwrap(reference.timestamp());
     int64_t send_time_ms = send_times_[reference_timestamp];
     send_times_.erase(reference_timestamp);
@@ -1032,7 +1032,8 @@
 
     VideoAnalyzer* const analyzer_;
     rtc::CriticalSection crit_;
-    rtc::VideoSinkInterface<VideoFrame>* send_stream_input_ GUARDED_BY(crit_);
+    rtc::VideoSinkInterface<VideoFrame>* send_stream_input_
+        RTC_GUARDED_BY(crit_);
     test::VideoCapturer* video_capturer_;
     Clock* clock_;
   };
@@ -1056,24 +1057,25 @@
   const int selected_tl_;
   PreEncodeProxy pre_encode_proxy_;
   OnEncodeTimingProxy encode_timing_proxy_;
-  std::vector<Sample> samples_ GUARDED_BY(comparison_lock_);
-  std::map<int64_t, int> samples_encode_time_ms_ GUARDED_BY(comparison_lock_);
-  test::Statistics sender_time_ GUARDED_BY(comparison_lock_);
-  test::Statistics receiver_time_ GUARDED_BY(comparison_lock_);
-  test::Statistics psnr_ GUARDED_BY(comparison_lock_);
-  test::Statistics ssim_ GUARDED_BY(comparison_lock_);
-  test::Statistics end_to_end_ GUARDED_BY(comparison_lock_);
-  test::Statistics rendered_delta_ GUARDED_BY(comparison_lock_);
-  test::Statistics encoded_frame_size_ GUARDED_BY(comparison_lock_);
-  test::Statistics encode_frame_rate_ GUARDED_BY(comparison_lock_);
-  test::Statistics encode_time_ms_ GUARDED_BY(comparison_lock_);
-  test::Statistics encode_usage_percent_ GUARDED_BY(comparison_lock_);
-  test::Statistics decode_time_ms_ GUARDED_BY(comparison_lock_);
-  test::Statistics decode_time_max_ms_ GUARDED_BY(comparison_lock_);
-  test::Statistics media_bitrate_bps_ GUARDED_BY(comparison_lock_);
-  test::Statistics fec_bitrate_bps_ GUARDED_BY(comparison_lock_);
-  test::Statistics send_bandwidth_bps_ GUARDED_BY(comparison_lock_);
-  test::Statistics memory_usage_ GUARDED_BY(comparison_lock_);
+  std::vector<Sample> samples_ RTC_GUARDED_BY(comparison_lock_);
+  std::map<int64_t, int> samples_encode_time_ms_
+      RTC_GUARDED_BY(comparison_lock_);
+  test::Statistics sender_time_ RTC_GUARDED_BY(comparison_lock_);
+  test::Statistics receiver_time_ RTC_GUARDED_BY(comparison_lock_);
+  test::Statistics psnr_ RTC_GUARDED_BY(comparison_lock_);
+  test::Statistics ssim_ RTC_GUARDED_BY(comparison_lock_);
+  test::Statistics end_to_end_ RTC_GUARDED_BY(comparison_lock_);
+  test::Statistics rendered_delta_ RTC_GUARDED_BY(comparison_lock_);
+  test::Statistics encoded_frame_size_ RTC_GUARDED_BY(comparison_lock_);
+  test::Statistics encode_frame_rate_ RTC_GUARDED_BY(comparison_lock_);
+  test::Statistics encode_time_ms_ RTC_GUARDED_BY(comparison_lock_);
+  test::Statistics encode_usage_percent_ RTC_GUARDED_BY(comparison_lock_);
+  test::Statistics decode_time_ms_ RTC_GUARDED_BY(comparison_lock_);
+  test::Statistics decode_time_max_ms_ RTC_GUARDED_BY(comparison_lock_);
+  test::Statistics media_bitrate_bps_ RTC_GUARDED_BY(comparison_lock_);
+  test::Statistics fec_bitrate_bps_ RTC_GUARDED_BY(comparison_lock_);
+  test::Statistics send_bandwidth_bps_ RTC_GUARDED_BY(comparison_lock_);
+  test::Statistics memory_usage_ RTC_GUARDED_BY(comparison_lock_);
 
   struct FrameWithPsnr {
     double psnr;
@@ -1081,7 +1083,7 @@
   };
 
   // Rendered frame with worst PSNR is saved for further analysis.
-  rtc::Optional<FrameWithPsnr> worst_frame_ GUARDED_BY(comparison_lock_);
+  rtc::Optional<FrameWithPsnr> worst_frame_ RTC_GUARDED_BY(comparison_lock_);
 
   size_t last_fec_bytes_;
 
@@ -1097,19 +1099,19 @@
   int64_t first_sending_time_;
   int64_t last_sending_time_;
 
-  int64_t cpu_time_ GUARDED_BY(cpu_measurement_lock_);
-  int64_t wallclock_time_ GUARDED_BY(cpu_measurement_lock_);
+  int64_t cpu_time_ RTC_GUARDED_BY(cpu_measurement_lock_);
+  int64_t wallclock_time_ RTC_GUARDED_BY(cpu_measurement_lock_);
   rtc::CriticalSection cpu_measurement_lock_;
 
   rtc::CriticalSection crit_;
-  std::deque<VideoFrame> frames_ GUARDED_BY(crit_);
-  rtc::Optional<VideoFrame> last_rendered_frame_ GUARDED_BY(crit_);
-  rtc::TimestampWrapAroundHandler wrap_handler_ GUARDED_BY(crit_);
-  std::map<int64_t, int64_t> send_times_ GUARDED_BY(crit_);
-  std::map<int64_t, int64_t> recv_times_ GUARDED_BY(crit_);
-  std::map<int64_t, size_t> encoded_frame_sizes_ GUARDED_BY(crit_);
-  rtc::Optional<uint32_t> first_encoded_timestamp_ GUARDED_BY(crit_);
-  rtc::Optional<uint32_t> first_sent_timestamp_ GUARDED_BY(crit_);
+  std::deque<VideoFrame> frames_ RTC_GUARDED_BY(crit_);
+  rtc::Optional<VideoFrame> last_rendered_frame_ RTC_GUARDED_BY(crit_);
+  rtc::TimestampWrapAroundHandler wrap_handler_ RTC_GUARDED_BY(crit_);
+  std::map<int64_t, int64_t> send_times_ RTC_GUARDED_BY(crit_);
+  std::map<int64_t, int64_t> recv_times_ RTC_GUARDED_BY(crit_);
+  std::map<int64_t, size_t> encoded_frame_sizes_ RTC_GUARDED_BY(crit_);
+  rtc::Optional<uint32_t> first_encoded_timestamp_ RTC_GUARDED_BY(crit_);
+  rtc::Optional<uint32_t> first_sent_timestamp_ RTC_GUARDED_BY(crit_);
   const double avg_psnr_threshold_;
   const double avg_ssim_threshold_;
   bool is_quick_test_enabled_;
@@ -1118,7 +1120,7 @@
   std::vector<rtc::PlatformThread*> comparison_thread_pool_;
   rtc::PlatformThread stats_polling_thread_;
   rtc::Event comparison_available_event_;
-  std::deque<FrameComparison> comparisons_ GUARDED_BY(comparison_lock_);
+  std::deque<FrameComparison> comparisons_ RTC_GUARDED_BY(comparison_lock_);
   rtc::Event done_;
 
   std::unique_ptr<test::RtpFileWriter> rtp_file_writer_;
diff --git a/video/video_receive_stream.h b/video/video_receive_stream.h
index 833e189..32ce812 100644
--- a/video/video_receive_stream.h
+++ b/video/video_receive_stream.h
@@ -134,7 +134,7 @@
   RtpStreamsSynchronizer rtp_stream_sync_;
 
   rtc::CriticalSection ivf_writer_lock_;
-  std::unique_ptr<IvfFileWriter> ivf_writer_ GUARDED_BY(ivf_writer_lock_);
+  std::unique_ptr<IvfFileWriter> ivf_writer_ RTC_GUARDED_BY(ivf_writer_lock_);
 
   // Members for the new jitter buffer experiment.
   std::unique_ptr<VCMJitterEstimator> jitter_estimator_;
diff --git a/video/video_send_stream.cc b/video/video_send_stream.cc
index f2b8d4a..61884ca 100644
--- a/video/video_send_stream.cc
+++ b/video/video_send_stream.cc
@@ -293,7 +293,7 @@
 
   rtc::CriticalSection encoder_activity_crit_sect_;
   CheckEncoderActivityTask* check_encoder_activity_task_
-      GUARDED_BY(encoder_activity_crit_sect_);
+      RTC_GUARDED_BY(encoder_activity_crit_sect_);
 
   CallStats* const call_stats_;
   RtpTransportControllerSendInterface* const transport_;
@@ -303,8 +303,8 @@
   std::unique_ptr<FlexfecSender> flexfec_sender_;
 
   rtc::CriticalSection ivf_writers_crit_;
-  std::unique_ptr<IvfFileWriter> file_writers_[kMaxSimulcastStreams] GUARDED_BY(
-      ivf_writers_crit_);
+  std::unique_ptr<IvfFileWriter>
+      file_writers_[kMaxSimulcastStreams] RTC_GUARDED_BY(ivf_writers_crit_);
 
   int max_padding_bitrate_;
   int encoder_min_bitrate_bps_;
@@ -329,7 +329,8 @@
   rtc::WeakPtrFactory<VideoSendStreamImpl> weak_ptr_factory_;
 
   rtc::CriticalSection overhead_bytes_per_packet_crit_;
-  size_t overhead_bytes_per_packet_ GUARDED_BY(overhead_bytes_per_packet_crit_);
+  size_t overhead_bytes_per_packet_
+      RTC_GUARDED_BY(overhead_bytes_per_packet_crit_);
   size_t transport_overhead_bytes_per_packet_;
 };
 
diff --git a/video/video_send_stream_tests.cc b/video/video_send_stream_tests.cc
index ce7a0ee..422b983 100644
--- a/video/video_send_stream_tests.cc
+++ b/video/video_send_stream_tests.cc
@@ -1223,7 +1223,7 @@
     };
 
     virtual void SendRtcpFeedback(int remb_value)
-        EXCLUSIVE_LOCKS_REQUIRED(crit_) {
+        RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_) {
       FakeReceiveStatistics receive_stats(kVideoSendSsrcs[0],
                                           last_sequence_number_, rtp_count_, 0);
       RTCPSender rtcp_sender(false, clock_, &receive_stats, nullptr, nullptr,
@@ -1244,12 +1244,12 @@
     VideoSendStream* stream_;
 
     rtc::CriticalSection crit_;
-    TestState test_state_ GUARDED_BY(crit_);
-    int rtp_count_ GUARDED_BY(crit_);
-    int last_sequence_number_ GUARDED_BY(crit_);
-    int suspended_frame_count_ GUARDED_BY(crit_);
-    int low_remb_bps_ GUARDED_BY(crit_);
-    int high_remb_bps_ GUARDED_BY(crit_);
+    TestState test_state_ RTC_GUARDED_BY(crit_);
+    int rtp_count_ RTC_GUARDED_BY(crit_);
+    int last_sequence_number_ RTC_GUARDED_BY(crit_);
+    int suspended_frame_count_ RTC_GUARDED_BY(crit_);
+    int low_remb_bps_ RTC_GUARDED_BY(crit_);
+    int high_remb_bps_ RTC_GUARDED_BY(crit_);
   } test;
 
   RunBaseTest(&test);
@@ -1326,8 +1326,8 @@
     Clock* const clock_;
     std::unique_ptr<internal::TransportAdapter> transport_adapter_;
     rtc::CriticalSection crit_;
-    int64_t last_packet_time_ms_ GUARDED_BY(crit_);
-    test::FrameGeneratorCapturer* capturer_ GUARDED_BY(crit_);
+    int64_t last_packet_time_ms_ RTC_GUARDED_BY(crit_);
+    test::FrameGeneratorCapturer* capturer_ RTC_GUARDED_BY(crit_);
   } test;
 
   RunBaseTest(&test);
@@ -1395,8 +1395,8 @@
 
     rtc::CriticalSection crit_;
     Clock* const clock_;
-    size_t padding_length_ GUARDED_BY(crit_);
-    size_t total_length_ GUARDED_BY(crit_);
+    size_t padding_length_ RTC_GUARDED_BY(crit_);
+    size_t total_length_ RTC_GUARDED_BY(crit_);
     Call* call_;
   } test;
 
@@ -1634,7 +1634,7 @@
     test::SingleThreadedTaskQueueForTesting* const task_queue_;
     Call* call_;
     rtc::CriticalSection lock_;
-    int packets_sent_ GUARDED_BY(lock_);
+    int packets_sent_ RTC_GUARDED_BY(lock_);
     int transport_overhead_;
     const size_t kMaxRtpPacketSize = 1000;
   } test(&task_queue_);
@@ -1742,10 +1742,10 @@
   rtc::CriticalSection crit_;
   rtc::Event content_switch_event_;
   Call* call_;
-  VideoSendStream* send_stream_ GUARDED_BY(crit_);
+  VideoSendStream* send_stream_ RTC_GUARDED_BY(crit_);
   VideoSendStream::Config send_stream_config_;
   VideoEncoderConfig encoder_config_;
-  uint32_t packets_sent_ GUARDED_BY(crit_);
+  uint32_t packets_sent_ RTC_GUARDED_BY(crit_);
   bool running_without_padding_;
   T* const stream_resetter_;
 };
@@ -1833,9 +1833,9 @@
 
     rtc::CriticalSection crit_;
     rtc::Event init_encode_called_;
-    size_t number_of_initializations_ GUARDED_BY(&crit_);
-    int last_initialized_frame_width_ GUARDED_BY(&crit_);
-    int last_initialized_frame_height_ GUARDED_BY(&crit_);
+    size_t number_of_initializations_ RTC_GUARDED_BY(&crit_);
+    int last_initialized_frame_width_ RTC_GUARDED_BY(&crit_);
+    int last_initialized_frame_height_ RTC_GUARDED_BY(&crit_);
   };
 
   test::NullTransport transport;
@@ -1902,7 +1902,7 @@
    private:
     rtc::CriticalSection crit_;
     rtc::Event start_bitrate_changed_;
-    int start_bitrate_kbps_ GUARDED_BY(crit_);
+    int start_bitrate_kbps_ RTC_GUARDED_BY(crit_);
   };
 
   CreateSenderCall(Call::Config(event_log_.get()));
@@ -1992,7 +1992,7 @@
     rtc::CriticalSection crit_;
     rtc::Event encoder_init_;
     rtc::Event bitrate_changed_;
-    rtc::Optional<int> bitrate_kbps_ GUARDED_BY(crit_);
+    rtc::Optional<int> bitrate_kbps_ RTC_GUARDED_BY(crit_);
   };
 
   test::NullTransport transport;
@@ -2244,10 +2244,10 @@
     test::SingleThreadedTaskQueueForTesting* const task_queue_;
     rtc::CriticalSection crit_;
     VideoSendStream* stream_;
-    bool initialized_ GUARDED_BY(crit_);
-    bool callback_registered_ GUARDED_BY(crit_);
-    size_t num_releases_ GUARDED_BY(crit_);
-    bool released_ GUARDED_BY(crit_);
+    bool initialized_ RTC_GUARDED_BY(crit_);
+    bool callback_registered_ RTC_GUARDED_BY(crit_);
+    size_t num_releases_ RTC_GUARDED_BY(crit_);
+    bool released_ RTC_GUARDED_BY(crit_);
     VideoEncoderConfig encoder_config_;
   } test_encoder(&task_queue_);
 
@@ -2557,8 +2557,8 @@
     }
 
     rtc::CriticalSection crit_;
-    size_t rtp_packets_sent_ GUARDED_BY(&crit_);
-    size_t media_bytes_sent_ GUARDED_BY(&crit_);
+    size_t rtp_packets_sent_ RTC_GUARDED_BY(&crit_);
+    size_t media_bytes_sent_ RTC_GUARDED_BY(&crit_);
   } test;
 
   RunBaseTest(&test);
@@ -2792,7 +2792,7 @@
     rtc::Event init_encode_event_;
     rtc::Event bitrate_changed_event_;
     rtc::CriticalSection crit_;
-    uint32_t target_bitrate_ GUARDED_BY(&crit_);
+    uint32_t target_bitrate_ RTC_GUARDED_BY(&crit_);
 
     int num_initializations_;
     webrtc::Call* call_;
@@ -3457,8 +3457,8 @@
     test::SingleThreadedTaskQueueForTesting* const task_queue_;
     Call* call_;
     rtc::CriticalSection crit_;
-    uint32_t max_bitrate_bps_ GUARDED_BY(&crit_);
-    bool first_packet_sent_ GUARDED_BY(&crit_);
+    uint32_t max_bitrate_bps_ RTC_GUARDED_BY(&crit_);
+    bool first_packet_sent_ RTC_GUARDED_BY(&crit_);
     rtc::Event bitrate_changed_event_;
   } test(&task_queue_);
   RunBaseTest(&test);
diff --git a/video/video_stream_decoder.h b/video/video_stream_decoder.h
index 6ea722c..88cff97 100644
--- a/video/video_stream_decoder.h
+++ b/video/video_stream_decoder.h
@@ -97,7 +97,7 @@
   ReceiveStatisticsProxy* const receive_stats_callback_;
   rtc::VideoSinkInterface<VideoFrame>* const incoming_video_stream_;
 
-  int64_t last_rtt_ms_ GUARDED_BY(crit_);
+  int64_t last_rtt_ms_ RTC_GUARDED_BY(crit_);
 };
 
 }  // namespace webrtc
diff --git a/video/video_stream_encoder.cc b/video/video_stream_encoder.cc
index 52dcbf0..ccd2854 100644
--- a/video/video_stream_encoder.cc
+++ b/video/video_stream_encoder.cc
@@ -342,7 +342,7 @@
 
  private:
   rtc::VideoSinkWants GetActiveSinkWantsInternal()
-      EXCLUSIVE_LOCKS_REQUIRED(&crit_) {
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(&crit_) {
     rtc::VideoSinkWants wants = sink_wants_;
     // Clear any constraints from the current sink wants that don't apply to
     // the used degradation_preference.
@@ -367,10 +367,10 @@
   rtc::CriticalSection crit_;
   rtc::SequencedTaskChecker main_checker_;
   VideoStreamEncoder* const video_stream_encoder_;
-  rtc::VideoSinkWants sink_wants_ GUARDED_BY(&crit_);
+  rtc::VideoSinkWants sink_wants_ RTC_GUARDED_BY(&crit_);
   VideoSendStream::DegradationPreference degradation_preference_
-      GUARDED_BY(&crit_);
-  rtc::VideoSourceInterface<VideoFrame>* source_ GUARDED_BY(&crit_);
+      RTC_GUARDED_BY(&crit_);
+  rtc::VideoSourceInterface<VideoFrame>* source_ RTC_GUARDED_BY(&crit_);
 
   RTC_DISALLOW_COPY_AND_ASSIGN(VideoSourceProxy);
 };
diff --git a/video/video_stream_encoder.h b/video/video_stream_encoder.h
index 8f6cb07..a0fa2df 100644
--- a/video/video_stream_encoder.h
+++ b/video/video_stream_encoder.h
@@ -217,10 +217,10 @@
     std::vector<int> resolution_counters_;
   };
 
-  AdaptCounter& GetAdaptCounter() RUN_ON(&encoder_queue_);
-  const AdaptCounter& GetConstAdaptCounter() RUN_ON(&encoder_queue_);
-  void UpdateAdaptationStats(AdaptReason reason) RUN_ON(&encoder_queue_);
-  AdaptCounts GetActiveCounts(AdaptReason reason) RUN_ON(&encoder_queue_);
+  AdaptCounter& GetAdaptCounter() RTC_RUN_ON(&encoder_queue_);
+  const AdaptCounter& GetConstAdaptCounter() RTC_RUN_ON(&encoder_queue_);
+  void UpdateAdaptationStats(AdaptReason reason) RTC_RUN_ON(&encoder_queue_);
+  AdaptCounts GetActiveCounts(AdaptReason reason) RTC_RUN_ON(&encoder_queue_);
 
   rtc::Event shutdown_event_;
 
@@ -233,10 +233,10 @@
   const VideoSendStream::Config::EncoderSettings settings_;
   const VideoCodecType codec_type_;
 
-  vcm::VideoSender video_sender_ ACCESS_ON(&encoder_queue_);
+  vcm::VideoSender video_sender_ RTC_ACCESS_ON(&encoder_queue_);
   std::unique_ptr<OveruseFrameDetector> overuse_detector_
-      ACCESS_ON(&encoder_queue_);
-  std::unique_ptr<QualityScaler> quality_scaler_ ACCESS_ON(&encoder_queue_);
+      RTC_ACCESS_ON(&encoder_queue_);
+  std::unique_ptr<QualityScaler> quality_scaler_ RTC_ACCESS_ON(&encoder_queue_);
 
   SendStatisticsProxy* const stats_proxy_;
   rtc::VideoSinkInterface<VideoFrame>* const pre_encode_callback_;
@@ -246,24 +246,24 @@
   // of VideoStreamEncoder are called on the same thread.
   rtc::ThreadChecker thread_checker_;
 
-  VideoEncoderConfig encoder_config_ ACCESS_ON(&encoder_queue_);
+  VideoEncoderConfig encoder_config_ RTC_ACCESS_ON(&encoder_queue_);
   std::unique_ptr<VideoBitrateAllocator> rate_allocator_
-      ACCESS_ON(&encoder_queue_);
+      RTC_ACCESS_ON(&encoder_queue_);
   // The maximum frame rate of the current codec configuration, as determined
   // at the last ReconfigureEncoder() call.
-  int max_framerate_ ACCESS_ON(&encoder_queue_);
+  int max_framerate_ RTC_ACCESS_ON(&encoder_queue_);
 
   // Set when ConfigureEncoder has been called in order to lazy reconfigure the
   // encoder on the next frame.
-  bool pending_encoder_reconfiguration_ ACCESS_ON(&encoder_queue_);
-  rtc::Optional<VideoFrameInfo> last_frame_info_ ACCESS_ON(&encoder_queue_);
-  int crop_width_ ACCESS_ON(&encoder_queue_);
-  int crop_height_ ACCESS_ON(&encoder_queue_);
-  uint32_t encoder_start_bitrate_bps_ ACCESS_ON(&encoder_queue_);
-  size_t max_data_payload_length_ ACCESS_ON(&encoder_queue_);
-  bool nack_enabled_ ACCESS_ON(&encoder_queue_);
-  uint32_t last_observed_bitrate_bps_ ACCESS_ON(&encoder_queue_);
-  bool encoder_paused_and_dropped_frame_ ACCESS_ON(&encoder_queue_);
+  bool pending_encoder_reconfiguration_ RTC_ACCESS_ON(&encoder_queue_);
+  rtc::Optional<VideoFrameInfo> last_frame_info_ RTC_ACCESS_ON(&encoder_queue_);
+  int crop_width_ RTC_ACCESS_ON(&encoder_queue_);
+  int crop_height_ RTC_ACCESS_ON(&encoder_queue_);
+  uint32_t encoder_start_bitrate_bps_ RTC_ACCESS_ON(&encoder_queue_);
+  size_t max_data_payload_length_ RTC_ACCESS_ON(&encoder_queue_);
+  bool nack_enabled_ RTC_ACCESS_ON(&encoder_queue_);
+  uint32_t last_observed_bitrate_bps_ RTC_ACCESS_ON(&encoder_queue_);
+  bool encoder_paused_and_dropped_frame_ RTC_ACCESS_ON(&encoder_queue_);
   Clock* const clock_;
   // Counters used for deciding if the video resolution or framerate is
   // currently restricted, and if so, why, on a per degradation preference
@@ -271,10 +271,10 @@
   // TODO(sprang): Replace this with a state holding a relative overuse measure
   // instead, that can be translated into suitable down-scale or fps limit.
   std::map<const VideoSendStream::DegradationPreference, AdaptCounter>
-      adapt_counters_ ACCESS_ON(&encoder_queue_);
+      adapt_counters_ RTC_ACCESS_ON(&encoder_queue_);
   // Set depending on degradation preferences.
   VideoSendStream::DegradationPreference degradation_preference_
-      ACCESS_ON(&encoder_queue_);
+      RTC_ACCESS_ON(&encoder_queue_);
 
   struct AdaptationRequest {
     // The pixel count produced by the source at the time of the adaptation.
@@ -287,22 +287,25 @@
   // Stores a snapshot of the last adaptation request triggered by an AdaptUp
   // or AdaptDown signal.
   rtc::Optional<AdaptationRequest> last_adaptation_request_
-      ACCESS_ON(&encoder_queue_);
+      RTC_ACCESS_ON(&encoder_queue_);
 
   rtc::RaceChecker incoming_frame_race_checker_
-      GUARDED_BY(incoming_frame_race_checker_);
+      RTC_GUARDED_BY(incoming_frame_race_checker_);
   Atomic32 posted_frames_waiting_for_encode_;
   // Used to make sure incoming time stamp is increasing for every frame.
-  int64_t last_captured_timestamp_ GUARDED_BY(incoming_frame_race_checker_);
+  int64_t last_captured_timestamp_ RTC_GUARDED_BY(incoming_frame_race_checker_);
   // Delta used for translating between NTP and internal timestamps.
-  const int64_t delta_ntp_internal_ms_ GUARDED_BY(incoming_frame_race_checker_);
+  const int64_t delta_ntp_internal_ms_
+      RTC_GUARDED_BY(incoming_frame_race_checker_);
 
-  int64_t last_frame_log_ms_ GUARDED_BY(incoming_frame_race_checker_);
-  int captured_frame_count_ ACCESS_ON(&encoder_queue_);
-  int dropped_frame_count_ ACCESS_ON(&encoder_queue_);
+  int64_t last_frame_log_ms_ RTC_GUARDED_BY(incoming_frame_race_checker_);
+  int captured_frame_count_ RTC_ACCESS_ON(&encoder_queue_);
+  int dropped_frame_count_ RTC_ACCESS_ON(&encoder_queue_);
 
-  VideoBitrateAllocationObserver* bitrate_observer_ ACCESS_ON(&encoder_queue_);
-  rtc::Optional<int64_t> last_parameters_update_ms_ ACCESS_ON(&encoder_queue_);
+  VideoBitrateAllocationObserver* bitrate_observer_
+      RTC_ACCESS_ON(&encoder_queue_);
+  rtc::Optional<int64_t> last_parameters_update_ms_
+      RTC_ACCESS_ON(&encoder_queue_);
 
   // All public methods are proxied to |encoder_queue_|. It must must be
   // destroyed first to make sure no tasks are run that use other members.
diff --git a/video/video_stream_encoder_unittest.cc b/video/video_stream_encoder_unittest.cc
index 9e7fa77..488486c 100644
--- a/video/video_stream_encoder_unittest.cc
+++ b/video/video_stream_encoder_unittest.cc
@@ -89,7 +89,7 @@
 
  private:
   rtc::CriticalSection lock_;
-  int last_target_framerate_fps_ GUARDED_BY(lock_);
+  int last_target_framerate_fps_ RTC_GUARDED_BY(lock_);
 };
 
 class VideoStreamEncoderUnderTest : public VideoStreamEncoder {
@@ -218,8 +218,8 @@
     test::FrameForwarder::AddOrUpdateSink(sink, wants);
   }
   cricket::VideoAdapter adapter_;
-  bool adaptation_enabled_ GUARDED_BY(crit_);
-  rtc::VideoSinkWants last_wants_ GUARDED_BY(crit_);
+  bool adaptation_enabled_ RTC_GUARDED_BY(crit_);
+  rtc::VideoSinkWants last_wants_ RTC_GUARDED_BY(crit_);
 };
 
 class MockableSendStatisticsProxy : public SendStatisticsProxy {
@@ -248,7 +248,7 @@
 
  private:
   rtc::CriticalSection lock_;
-  rtc::Optional<VideoSendStream::Stats> mock_stats_ GUARDED_BY(lock_);
+  rtc::Optional<VideoSendStream::Stats> mock_stats_ RTC_GUARDED_BY(lock_);
 };
 
 class MockBitrateObserver : public VideoBitrateAllocationObserver {
@@ -551,16 +551,16 @@
     }
 
     rtc::CriticalSection local_crit_sect_;
-    bool block_next_encode_ GUARDED_BY(local_crit_sect_) = false;
+    bool block_next_encode_ RTC_GUARDED_BY(local_crit_sect_) = false;
     rtc::Event continue_encode_event_;
-    uint32_t timestamp_ GUARDED_BY(local_crit_sect_) = 0;
-    int64_t ntp_time_ms_ GUARDED_BY(local_crit_sect_) = 0;
-    int last_input_width_ GUARDED_BY(local_crit_sect_) = 0;
-    int last_input_height_ GUARDED_BY(local_crit_sect_) = 0;
-    bool quality_scaling_ GUARDED_BY(local_crit_sect_) = true;
+    uint32_t timestamp_ RTC_GUARDED_BY(local_crit_sect_) = 0;
+    int64_t ntp_time_ms_ RTC_GUARDED_BY(local_crit_sect_) = 0;
+    int last_input_width_ RTC_GUARDED_BY(local_crit_sect_) = 0;
+    int last_input_height_ RTC_GUARDED_BY(local_crit_sect_) = 0;
+    bool quality_scaling_ RTC_GUARDED_BY(local_crit_sect_) = true;
     std::vector<std::unique_ptr<TemporalLayers>> allocated_temporal_layers_
-        GUARDED_BY(local_crit_sect_);
-    bool force_init_encode_failed_ GUARDED_BY(local_crit_sect_) = false;
+        RTC_GUARDED_BY(local_crit_sect_);
+    bool force_init_encode_failed_ RTC_GUARDED_BY(local_crit_sect_) = false;
   };
 
   class TestSink : public VideoStreamEncoder::EncoderSink {
diff --git a/voice_engine/audio_level.h b/voice_engine/audio_level.h
index d69365a..33f8fe2 100644
--- a/voice_engine/audio_level.h
+++ b/voice_engine/audio_level.h
@@ -45,13 +45,13 @@
 
   rtc::CriticalSection crit_sect_;
 
-  int16_t abs_max_ GUARDED_BY(crit_sect_);
-  int16_t count_ GUARDED_BY(crit_sect_);
-  int8_t current_level_ GUARDED_BY(crit_sect_);
-  int16_t current_level_full_range_ GUARDED_BY(crit_sect_);
+  int16_t abs_max_ RTC_GUARDED_BY(crit_sect_);
+  int16_t count_ RTC_GUARDED_BY(crit_sect_);
+  int8_t current_level_ RTC_GUARDED_BY(crit_sect_);
+  int16_t current_level_full_range_ RTC_GUARDED_BY(crit_sect_);
 
-  double total_energy_ GUARDED_BY(crit_sect_) = 0.0;
-  double total_duration_ GUARDED_BY(crit_sect_) = 0.0;
+  double total_energy_ RTC_GUARDED_BY(crit_sect_) = 0.0;
+  double total_duration_ RTC_GUARDED_BY(crit_sect_) = 0.0;
 };
 
 }  // namespace voe
diff --git a/voice_engine/channel.cc b/voice_engine/channel.cc
index 0e83989..746db81 100644
--- a/voice_engine/channel.cc
+++ b/voice_engine/channel.cc
@@ -192,7 +192,7 @@
 
  private:
   rtc::CriticalSection crit_;
-  RtcEventLog* event_log_ GUARDED_BY(crit_);
+  RtcEventLog* event_log_ RTC_GUARDED_BY(crit_);
   RTC_DISALLOW_COPY_AND_ASSIGN(RtcEventLogProxy);
 };
 
@@ -220,7 +220,7 @@
 
  private:
   rtc::CriticalSection crit_;
-  RtcpRttStats* rtcp_rtt_stats_ GUARDED_BY(crit_);
+  RtcpRttStats* rtcp_rtt_stats_ RTC_GUARDED_BY(crit_);
   RTC_DISALLOW_COPY_AND_ASSIGN(RtcpRttStatsProxy);
 };
 
@@ -265,7 +265,7 @@
   rtc::ThreadChecker thread_checker_;
   rtc::ThreadChecker pacer_thread_;
   rtc::ThreadChecker network_thread_;
-  TransportFeedbackObserver* feedback_observer_ GUARDED_BY(&crit_);
+  TransportFeedbackObserver* feedback_observer_ RTC_GUARDED_BY(&crit_);
 };
 
 class TransportSequenceNumberProxy : public TransportSequenceNumberAllocator {
@@ -294,7 +294,7 @@
   rtc::CriticalSection crit_;
   rtc::ThreadChecker thread_checker_;
   rtc::ThreadChecker pacer_thread_;
-  TransportSequenceNumberAllocator* seq_num_allocator_ GUARDED_BY(&crit_);
+  TransportSequenceNumberAllocator* seq_num_allocator_ RTC_GUARDED_BY(&crit_);
 };
 
 class RtpPacketSenderProxy : public RtpPacketSender {
@@ -324,7 +324,7 @@
  private:
   rtc::ThreadChecker thread_checker_;
   rtc::CriticalSection crit_;
-  RtpPacketSender* rtp_packet_sender_ GUARDED_BY(&crit_);
+  RtpPacketSender* rtp_packet_sender_ RTC_GUARDED_BY(&crit_);
 };
 
 class VoERtcpObserver : public RtcpBandwidthObserver {
@@ -398,7 +398,7 @@
   // Maps remote side ssrc to extended highest sequence number received.
   std::map<uint32_t, uint32_t> extended_max_sequence_number_;
   rtc::CriticalSection crit_;
-  RtcpBandwidthObserver* bandwidth_observer_ GUARDED_BY(crit_);
+  RtcpBandwidthObserver* bandwidth_observer_ RTC_GUARDED_BY(crit_);
 };
 
 class Channel::ProcessAndEncodeAudioTask : public rtc::QueuedTask {
diff --git a/voice_engine/channel.h b/voice_engine/channel.h
index 89c2b43..e5209f5 100644
--- a/voice_engine/channel.h
+++ b/voice_engine/channel.h
@@ -440,7 +440,7 @@
                                 unsigned char id);
 
   void UpdateOverheadForEncoder()
-      EXCLUSIVE_LOCKS_REQUIRED(overhead_per_packet_lock_);
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(overhead_per_packet_lock_);
 
   int GetRtpTimestampRateHz() const;
   int64_t GetRTT(bool allow_associate_channel) const;
@@ -482,16 +482,16 @@
   int _outputFilePlayerId;
   int _outputFileRecorderId;
   bool _outputFileRecording;
-  uint32_t _timeStamp ACCESS_ON(encoder_queue_);
+  uint32_t _timeStamp RTC_ACCESS_ON(encoder_queue_);
 
-  RemoteNtpTimeEstimator ntp_estimator_ GUARDED_BY(ts_stats_lock_);
+  RemoteNtpTimeEstimator ntp_estimator_ RTC_GUARDED_BY(ts_stats_lock_);
 
   // Timestamp of the audio pulled from NetEq.
   rtc::Optional<uint32_t> jitter_buffer_playout_timestamp_;
 
   rtc::CriticalSection video_sync_lock_;
-  uint32_t playout_timestamp_rtp_ GUARDED_BY(video_sync_lock_);
-  uint32_t playout_delay_ms_ GUARDED_BY(video_sync_lock_);
+  uint32_t playout_timestamp_rtp_ RTC_GUARDED_BY(video_sync_lock_);
+  uint32_t playout_delay_ms_ RTC_GUARDED_BY(video_sync_lock_);
   uint16_t send_sequence_number_;
 
   rtc::CriticalSection ts_stats_lock_;
@@ -501,7 +501,7 @@
   int64_t capture_start_rtp_time_stamp_;
   // The capture ntp time (in local timebase) of the first played out audio
   // frame.
-  int64_t capture_start_ntp_time_ms_ GUARDED_BY(ts_stats_lock_);
+  int64_t capture_start_ntp_time_ms_ RTC_GUARDED_BY(ts_stats_lock_);
 
   // uses
   Statistics* _engineStatisticsPtr;
@@ -511,18 +511,19 @@
   VoiceEngineObserver* _voiceEngineObserverPtr;  // owned by base
   rtc::CriticalSection* _callbackCritSectPtr;    // owned by base
   Transport* _transportPtr;  // WebRtc socket or external transport
-  RmsLevel rms_level_ ACCESS_ON(encoder_queue_);
-  bool input_mute_ GUARDED_BY(volume_settings_critsect_);
-  bool previous_frame_muted_ ACCESS_ON(encoder_queue_);
-  float _outputGain GUARDED_BY(volume_settings_critsect_);
+  RmsLevel rms_level_ RTC_ACCESS_ON(encoder_queue_);
+  bool input_mute_ RTC_GUARDED_BY(volume_settings_critsect_);
+  bool previous_frame_muted_ RTC_ACCESS_ON(encoder_queue_);
+  float _outputGain RTC_GUARDED_BY(volume_settings_critsect_);
   // VoEBase
   bool _mixFileWithMicrophone;
   // VoeRTP_RTCP
   // TODO(henrika): can today be accessed on the main thread and on the
   // task queue; hence potential race.
   bool _includeAudioLevelIndication;
-  size_t transport_overhead_per_packet_ GUARDED_BY(overhead_per_packet_lock_);
-  size_t rtp_overhead_per_packet_ GUARDED_BY(overhead_per_packet_lock_);
+  size_t transport_overhead_per_packet_
+      RTC_GUARDED_BY(overhead_per_packet_lock_);
+  size_t rtp_overhead_per_packet_ RTC_GUARDED_BY(overhead_per_packet_lock_);
   rtc::CriticalSection overhead_per_packet_lock_;
   // VoENetwork
   AudioFrame::SpeechType _outputSpeechType;
@@ -530,7 +531,7 @@
   std::unique_ptr<VoERtcpObserver> rtcp_observer_;
   // An associated send channel.
   rtc::CriticalSection assoc_send_channel_lock_;
-  ChannelOwner associate_send_channel_ GUARDED_BY(assoc_send_channel_lock_);
+  ChannelOwner associate_send_channel_ RTC_GUARDED_BY(assoc_send_channel_lock_);
 
   bool pacing_enabled_;
   PacketRouter* packet_router_ = nullptr;
@@ -550,7 +551,7 @@
 
   rtc::CriticalSection encoder_queue_lock_;
 
-  bool encoder_queue_is_active_ GUARDED_BY(encoder_queue_lock_) = false;
+  bool encoder_queue_is_active_ RTC_GUARDED_BY(encoder_queue_lock_) = false;
 
   rtc::TaskQueue* encoder_queue_ = nullptr;
 };
diff --git a/voice_engine/shared_data.h b/voice_engine/shared_data.h
index 971d7d7..7251c6a 100644
--- a/voice_engine/shared_data.h
+++ b/voice_engine/shared_data.h
@@ -71,7 +71,7 @@
  std::unique_ptr<ProcessThread> _moduleProcessThreadPtr;
  // |encoder_queue| is defined last to ensure all pending tasks are cancelled
  // and deleted before any other members.
- rtc::TaskQueue encoder_queue_ ACCESS_ON(construction_thread_);
+ rtc::TaskQueue encoder_queue_ RTC_ACCESS_ON(construction_thread_);
 
  SharedData();
  virtual ~SharedData();
diff --git a/voice_engine/test/auto_test/fakes/conference_transport.h b/voice_engine/test/auto_test/fakes/conference_transport.h
index 22711bd..a0acd9e 100644
--- a/voice_engine/test/auto_test/fakes/conference_transport.h
+++ b/voice_engine/test/auto_test/fakes/conference_transport.h
@@ -137,8 +137,9 @@
   unsigned int rtt_ms_;
   unsigned int stream_count_;
 
-  std::map<unsigned int, std::pair<int, int>> streams_ GUARDED_BY(stream_crit_);
-  std::deque<Packet> packet_queue_ GUARDED_BY(pq_crit_);
+  std::map<unsigned int, std::pair<int, int>> streams_
+      RTC_GUARDED_BY(stream_crit_);
+  std::deque<Packet> packet_queue_ RTC_GUARDED_BY(pq_crit_);
 
   int local_sender_;  // Channel Id of local sender
   int reflector_;
diff --git a/voice_engine/test/auto_test/fixtures/after_initialization_fixture.h b/voice_engine/test/auto_test/fixtures/after_initialization_fixture.h
index 1404fa5..cb36f61 100644
--- a/voice_engine/test/auto_test/fixtures/after_initialization_fixture.h
+++ b/voice_engine/test/auto_test/fixtures/after_initialization_fixture.h
@@ -145,9 +145,9 @@
   rtc::CriticalSection crit_;
   const std::unique_ptr<webrtc::EventWrapper> packet_event_;
   rtc::PlatformThread thread_;
-  std::deque<Packet> packet_queue_ GUARDED_BY(crit_);
+  std::deque<Packet> packet_queue_ RTC_GUARDED_BY(crit_);
   const int channel_;
-  std::map<uint32_t, int> channels_ GUARDED_BY(crit_);
+  std::map<uint32_t, int> channels_ RTC_GUARDED_BY(crit_);
   webrtc::VoENetwork* const voe_network_;
   webrtc::Atomic32 transmitted_packets_;
 };