Style renames in RTCPReceiver implementation

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 8d1e2c23300e4bdf8deef5624978bcf83933d551..b67d07fa9909b73f3587c9fde1538231790ac487 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_receiver.h
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_receiver.h
@@ -67,14 +67,14 @@ class RTCPReceiver {
   void SetRemoteSSRC(uint32_t ssrc);
   uint32_t RemoteSSRC() const;
 
-  // get received cname
-  int32_t CNAME(uint32_t remoteSSRC, char cName[RTCP_CNAME_SIZE]) const;
-
-  // get received NTP
-  bool NTP(uint32_t* ReceivedNTPsecs,
-           uint32_t* ReceivedNTPfrac,
-           uint32_t* RTCPArrivalTimeSecs,
-           uint32_t* RTCPArrivalTimeFrac,
+  // Get received cname.
+  int32_t CNAME(uint32_t remote_ssrc, char cname[RTCP_CNAME_SIZE]) const;
+
+  // Get received NTP.
+  bool NTP(uint32_t* received_ntp_secs,
+           uint32_t* received_ntp_frac,
+           uint32_t* rtcp_arrival_time_secs,
+           uint32_t* rtcp_arrival_time_frac,
            uint32_t* rtcp_timestamp) const;
 
   bool LastReceivedXrReferenceTimeInfo(rtcp::ReceiveTimeInfo* info) const;
@@ -86,12 +86,12 @@ class RTCPReceiver {
               int64_t* min_rtt_ms,
               int64_t* max_rtt_ms) const;
 
-  int32_t SenderInfoReceived(RTCPSenderInfo* senderInfo) const;
+  int32_t SenderInfoReceived(RTCPSenderInfo* sender_info) const;
 
   void SetRtcpXrRrtrStatus(bool enable);
   bool GetAndResetXrRrRtt(int64_t* rtt_ms);
 
-  // get statistics
+  // Get statistics.
   int32_t StatisticsReceived(std::vector<RTCPReportBlock>* receiveBlocks) const;
 
   // Returns true if we haven't received an RTCP RR for several RTCP
@@ -130,92 +130,92 @@ class RTCPReceiver {
                            const uint8_t* packet_end,
                            PacketInformation* packet_information);
 
-  void TriggerCallbacksFromRTCPPacket(
+  void TriggerCallbacksFromRtcpPacket(
       const PacketInformation& packet_information);
 
   void CreateReceiveInformation(uint32_t remote_ssrc)
-      EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
+      EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
   ReceiveInformation* GetReceiveInformation(uint32_t remote_ssrc)
-      EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
+      EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
 
   void HandleSenderReport(const rtcp::CommonHeader& rtcp_block,
                           PacketInformation* packet_information)
-      EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
+      EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
 
   void HandleReceiverReport(const rtcp::CommonHeader& rtcp_block,
                             PacketInformation* packet_information)
-      EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
+      EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
 
   void HandleReportBlock(const rtcp::ReportBlock& report_block,
                          PacketInformation* packet_information,
-                         uint32_t remoteSSRC)
-      EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
+                         uint32_t remote_ssrc)
+      EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
 
-  void HandleSDES(const rtcp::CommonHeader& rtcp_block,
+  void HandleSdes(const rtcp::CommonHeader& rtcp_block,
                   PacketInformation* packet_information)
-      EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
+      EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
 
   void HandleXr(const rtcp::CommonHeader& rtcp_block,
                 PacketInformation* packet_information)
-      EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
+      EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
 
   void HandleXrReceiveReferenceTime(uint32_t sender_ssrc,
                                     const rtcp::Rrtr& rrtr)
-      EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
+      EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
 
   void HandleXrDlrrReportBlock(const rtcp::ReceiveTimeInfo& rti)
-      EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
+      EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
 
   void HandleXrTargetBitrate(const rtcp::TargetBitrate& target_bitrate,
                              PacketInformation* packet_information)
-      EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
+      EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
 
-  void HandleNACK(const rtcp::CommonHeader& rtcp_block,
+  void HandleNack(const rtcp::CommonHeader& rtcp_block,
                   PacketInformation* packet_information)
-      EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
+      EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
 
-  void HandleBYE(const rtcp::CommonHeader& rtcp_block)
-      EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
+  void HandleBye(const rtcp::CommonHeader& rtcp_block)
+      EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
 
-  void HandlePLI(const rtcp::CommonHeader& rtcp_block,
+  void HandlePli(const rtcp::CommonHeader& rtcp_block,
                  PacketInformation* packet_information)
-      EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
+      EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
 
-  void HandleSLI(const rtcp::CommonHeader& rtcp_block,
+  void HandleSli(const rtcp::CommonHeader& rtcp_block,
                  PacketInformation* packet_information)
-      EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
+      EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
 
-  void HandleRPSI(const rtcp::CommonHeader& rtcp_block,
+  void HandleRpsi(const rtcp::CommonHeader& rtcp_block,
                   PacketInformation* packet_information)
-      EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
+      EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
 
   void HandlePsfbApp(const rtcp::CommonHeader& rtcp_block,
                      PacketInformation* packet_information)
-      EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
+      EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
 
-  void HandleTMMBR(const rtcp::CommonHeader& rtcp_block,
+  void HandleTmmbr(const rtcp::CommonHeader& rtcp_block,
                    PacketInformation* packet_information)
-      EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
+      EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
 
-  void HandleTMMBN(const rtcp::CommonHeader& rtcp_block,
+  void HandleTmmbn(const rtcp::CommonHeader& rtcp_block,
                    PacketInformation* packet_information)
-      EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
+      EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
 
-  void HandleSR_REQ(const rtcp::CommonHeader& rtcp_block,
-                    PacketInformation* packet_information)
-      EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
+  void HandleSrReq(const rtcp::CommonHeader& rtcp_block,
+                   PacketInformation* packet_information)
+      EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
 
-  void HandleFIR(const rtcp::CommonHeader& rtcp_block,
+  void HandleFir(const rtcp::CommonHeader& rtcp_block,
                  PacketInformation* packet_information)
-      EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
+      EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
 
   void HandleTransportFeedback(const rtcp::CommonHeader& rtcp_block,
                                PacketInformation* packet_information)
-      EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
+      EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
 
-  Clock* const _clock;
+  Clock* const clock_;
   const bool receiver_only_;
-  ModuleRtpRtcp& _rtpRtcp;
+  ModuleRtpRtcp* const rtp_rtcp_;
 
   rtc::CriticalSection feedbacks_lock_;
   RtcpBandwidthObserver* const rtcp_bandwidth_observer_;
@@ -223,13 +223,13 @@ class RTCPReceiver {
   TransportFeedbackObserver* const transport_feedback_observer_;
   VideoBitrateAllocationObserver* const bitrate_allocation_observer_;
 
-  rtc::CriticalSection _criticalSectionRTCPReceiver;
-  uint32_t main_ssrc_ GUARDED_BY(_criticalSectionRTCPReceiver);
-  uint32_t _remoteSSRC GUARDED_BY(_criticalSectionRTCPReceiver);
-  std::set<uint32_t> registered_ssrcs_ GUARDED_BY(_criticalSectionRTCPReceiver);
+  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_);
 
-  // Received send report
-  RTCPSenderInfo _remoteSenderInfo;
+  // Received sender report.
+  RTCPSenderInfo remote_sender_info_;
   // When did we receive the last send report.
   NtpTime last_received_sr_ntp_;
 
@@ -238,22 +238,21 @@ class RTCPReceiver {
   // 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(_criticalSectionRTCPReceiver);
+  bool xr_rrtr_status_ GUARDED_BY(rtcp_receiver_lock_);
   int64_t xr_rr_rtt_ms_;
 
   // Received report blocks.
-  ReportBlockMap received_report_blocks_
-      GUARDED_BY(_criticalSectionRTCPReceiver);
-  ReceivedInfoMap received_infos_ GUARDED_BY(_criticalSectionRTCPReceiver);
+  ReportBlockMap received_report_blocks_ GUARDED_BY(rtcp_receiver_lock_);
+  ReceivedInfoMap received_infos_ GUARDED_BY(rtcp_receiver_lock_);
   std::map<uint32_t, std::string> received_cnames_
-      GUARDED_BY(_criticalSectionRTCPReceiver);
+      GUARDED_BY(rtcp_receiver_lock_);
 
   // The last time we received an RTCP RR.
-  int64_t _lastReceivedRrMs;
+  int64_t last_received_rr_ms_;
 
   // The time we last received an RTCP RR telling we have successfully
   // delivered RTP packet to the remote side.
-  int64_t _lastIncreasedSequenceNumberMs;
+  int64_t last_increased_sequence_number_ms_;
 
   RtcpStatisticsCallback* stats_callback_ GUARDED_BY(feedbacks_lock_);
 
@@ -263,7 +262,7 @@ class RTCPReceiver {
   RTCPUtility::NackStats nack_stats_;
 
   size_t num_skipped_packets_;
-  int64_t last_skipped_packets_warning_;
+  int64_t last_skipped_packets_warning_ms_;
 };
 }  // namespace webrtc
 #endif  // WEBRTC_MODULES_RTP_RTCP_SOURCE_RTCP_RECEIVER_H_