Update thread annotiation macros in modules to use RTC_ prefix

webrtc/modules/rtp_rtcp/source/rtcp_receiver.h

Index: webrtc/modules/rtp_rtcp/source/rtcp_receiver.h
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_receiver.h b/webrtc/modules/rtp_rtcp/source/rtcp_receiver.h
index a167c135b0ca1bf686cb1fbde344cc1098e6b5e2..28d892795c7b2c4e580f00c52a4bb82333213d9e 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_receiver.h
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_receiver.h
@@ -130,80 +130,80 @@ class RTCPReceiver {
       const PacketInformation& packet_information);
 
   TmmbrInformation* FindOrCreateTmmbrInfo(uint32_t remote_ssrc)
-      EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
   // Update TmmbrInformation (if present) is alive.
   void UpdateTmmbrRemoteIsAlive(uint32_t remote_ssrc)
-      EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
   TmmbrInformation* GetTmmbrInformation(uint32_t remote_ssrc)
-      EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
 
   void HandleSenderReport(const rtcp::CommonHeader& rtcp_block,
                           PacketInformation* packet_information)
-      EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
 
   void HandleReceiverReport(const rtcp::CommonHeader& rtcp_block,
                             PacketInformation* packet_information)
-      EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
 
   void HandleReportBlock(const rtcp::ReportBlock& report_block,
                          PacketInformation* packet_information,
                          uint32_t remote_ssrc)
-      EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
 
   void HandleSdes(const rtcp::CommonHeader& rtcp_block,
                   PacketInformation* packet_information)
-      EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
 
   void HandleXr(const rtcp::CommonHeader& rtcp_block,
                 PacketInformation* packet_information)
-      EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
 
   void HandleXrReceiveReferenceTime(uint32_t sender_ssrc,
                                     const rtcp::Rrtr& rrtr)
-      EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
 
   void HandleXrDlrrReportBlock(const rtcp::ReceiveTimeInfo& rti)
-      EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
 
   void HandleXrTargetBitrate(uint32_t ssrc,
                              const rtcp::TargetBitrate& target_bitrate,
                              PacketInformation* packet_information)
-      EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
 
   void HandleNack(const rtcp::CommonHeader& rtcp_block,
                   PacketInformation* packet_information)
-      EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
 
   void HandleBye(const rtcp::CommonHeader& rtcp_block)
-      EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
 
   void HandlePli(const rtcp::CommonHeader& rtcp_block,
                  PacketInformation* packet_information)
-      EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
 
   void HandlePsfbApp(const rtcp::CommonHeader& rtcp_block,
                      PacketInformation* packet_information)
-      EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
 
   void HandleTmmbr(const rtcp::CommonHeader& rtcp_block,
                    PacketInformation* packet_information)
-      EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
 
   void HandleTmmbn(const rtcp::CommonHeader& rtcp_block,
                    PacketInformation* packet_information)
-      EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
 
   void HandleSrReq(const rtcp::CommonHeader& rtcp_block,
                    PacketInformation* packet_information)
-      EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
 
   void HandleFir(const rtcp::CommonHeader& rtcp_block,
                  PacketInformation* packet_information)
-      EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
 
   void HandleTransportFeedback(const rtcp::CommonHeader& rtcp_block,
                                PacketInformation* packet_information)
-      EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
 
   Clock* const clock_;
   const bool receiver_only_;
@@ -216,42 +216,43 @@ class RTCPReceiver {
   VideoBitrateAllocationObserver* const bitrate_allocation_observer_;
 
   rtc::CriticalSection rtcp_receiver_lock_;
-  uint32_t main_ssrc_ GUARDED_BY(rtcp_receiver_lock_);
-  uint32_t remote_ssrc_ GUARDED_BY(rtcp_receiver_lock_);
-  std::set<uint32_t> registered_ssrcs_ GUARDED_BY(rtcp_receiver_lock_);
+  uint32_t main_ssrc_ RTC_GUARDED_BY(rtcp_receiver_lock_);
+  uint32_t remote_ssrc_ RTC_GUARDED_BY(rtcp_receiver_lock_);
+  std::set<uint32_t> registered_ssrcs_ RTC_GUARDED_BY(rtcp_receiver_lock_);
 
   // Received sender report.
-  NtpTime remote_sender_ntp_time_ GUARDED_BY(rtcp_receiver_lock_);
-  uint32_t remote_sender_rtp_time_ GUARDED_BY(rtcp_receiver_lock_);
+  NtpTime remote_sender_ntp_time_ RTC_GUARDED_BY(rtcp_receiver_lock_);
+  uint32_t remote_sender_rtp_time_ RTC_GUARDED_BY(rtcp_receiver_lock_);
   // When did we receive the last send report.
-  NtpTime last_received_sr_ntp_ GUARDED_BY(rtcp_receiver_lock_);
+  NtpTime last_received_sr_ntp_ RTC_GUARDED_BY(rtcp_receiver_lock_);
 
   // Received XR receive time report.
   rtcp::ReceiveTimeInfo remote_time_info_;
   // Time when the report was received.
   NtpTime last_received_xr_ntp_;
   // Estimated rtt, zero when there is no valid estimate.
-  bool xr_rrtr_status_ GUARDED_BY(rtcp_receiver_lock_);
+  bool xr_rrtr_status_ RTC_GUARDED_BY(rtcp_receiver_lock_);
   int64_t xr_rr_rtt_ms_;
 
-  int64_t oldest_tmmbr_info_ms_ GUARDED_BY(rtcp_receiver_lock_);
+  int64_t oldest_tmmbr_info_ms_ RTC_GUARDED_BY(rtcp_receiver_lock_);
   // Mapped by remote ssrc.
   std::map<uint32_t, TmmbrInformation> tmmbr_infos_
-      GUARDED_BY(rtcp_receiver_lock_);
+      RTC_GUARDED_BY(rtcp_receiver_lock_);
 
-  ReportBlockMap received_report_blocks_ GUARDED_BY(rtcp_receiver_lock_);
-  std::map<uint32_t, LastFirStatus> last_fir_ GUARDED_BY(rtcp_receiver_lock_);
+  ReportBlockMap received_report_blocks_ RTC_GUARDED_BY(rtcp_receiver_lock_);
+  std::map<uint32_t, LastFirStatus> last_fir_
+      RTC_GUARDED_BY(rtcp_receiver_lock_);
   std::map<uint32_t, std::string> received_cnames_
-      GUARDED_BY(rtcp_receiver_lock_);
+      RTC_GUARDED_BY(rtcp_receiver_lock_);
 
   // The last time we received an RTCP RR.
-  int64_t last_received_rr_ms_ GUARDED_BY(rtcp_receiver_lock_);
+  int64_t last_received_rr_ms_ RTC_GUARDED_BY(rtcp_receiver_lock_);
 
   // The time we last received an RTCP RR telling we have successfully
   // delivered RTP packet to the remote side.
   int64_t last_increased_sequence_number_ms_;
 
-  RtcpStatisticsCallback* stats_callback_ GUARDED_BY(feedbacks_lock_);
+  RtcpStatisticsCallback* stats_callback_ RTC_GUARDED_BY(feedbacks_lock_);
 
   RtcpPacketTypeCounterObserver* const packet_type_counter_observer_;
   RtcpPacketTypeCounter packet_type_counter_;