Style cleanups in RtpSender.

webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #ifndef WEBRTC_MODULES_RTP_RTCP_MOCKS_MOCK_RTP_RTCP_H_
 #define WEBRTC_MODULES_RTP_RTCP_MOCKS_MOCK_RTP_RTCP_H_
 
 #include <set>
 #include <utility>
 #include <vector>
 
 #include "testing/gmock/include/gmock/gmock.h"
 
 #include "webrtc/modules/include/module.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
 
 namespace webrtc {
 
 class MockRtpData : public RtpData {
  public:
   MOCK_METHOD3(OnReceivedPayloadData,
-               int32_t(const uint8_t* payloadData,
-                       size_t payloadSize,
-                       const WebRtcRTPHeader* rtpHeader));
+               int32_t(const uint8_t* payload_data,
+                       size_t payload_size,
+                       const WebRtcRTPHeader* rtp_header));
 
   MOCK_METHOD2(OnRecoveredPacket,
                bool(const uint8_t* packet, size_t packet_length));
 };
 
 class MockRtpRtcp : public RtpRtcp {
  public:
-  MOCK_METHOD1(RegisterDefaultModule,
-      int32_t(RtpRtcp* module));
-  MOCK_METHOD0(DeRegisterDefaultModule,
-      int32_t());
-  MOCK_METHOD0(DefaultModuleRegistered,
-      bool());
-  MOCK_METHOD0(NumberChildModules,
-      uint32_t());
-  MOCK_METHOD1(RegisterSyncModule,
-      int32_t(RtpRtcp* module));
-  MOCK_METHOD0(DeRegisterSyncModule,
-      int32_t());
+  MOCK_METHOD1(RegisterDefaultModule, int32_t(RtpRtcp* module));
+  MOCK_METHOD0(DeRegisterDefaultModule, int32_t());
+  MOCK_METHOD0(DefaultModuleRegistered, bool());
+  MOCK_METHOD0(NumberChildModules, uint32_t());
+  MOCK_METHOD1(RegisterSyncModule, int32_t(RtpRtcp* module));
+  MOCK_METHOD0(DeRegisterSyncModule, int32_t());
   MOCK_METHOD2(IncomingRtcpPacket,
-      int32_t(const uint8_t* incomingPacket, size_t packetLength));
-  MOCK_METHOD1(SetRemoteSSRC, void(const uint32_t ssrc));
+               int32_t(const uint8_t* incoming_packet, size_t packet_length));
+  MOCK_METHOD1(SetRemoteSSRC, void(uint32_t ssrc));
   MOCK_METHOD4(IncomingAudioNTP,
-      int32_t(const uint32_t audioReceivedNTPsecs,
-              const uint32_t audioReceivedNTPfrac,
-              const uint32_t audioRTCPArrivalTimeSecs,
-              const uint32_t audioRTCPArrivalTimeFrac));
-  MOCK_METHOD0(InitSender,
-      int32_t());
-  MOCK_METHOD1(RegisterSendTransport,
-      int32_t(Transport* outgoingTransport));
-  MOCK_METHOD1(SetMaxTransferUnit,
-      int32_t(const uint16_t size));
+               int32_t(uint32_t audio_received_ntp_secs,
+                       uint32_t audio_received_ntp_frac,
+                       uint32_t audio_rtcp_arrival_time_secs,
+                       uint32_t audio_rtcp_arrival_time_frac));
+  MOCK_METHOD0(InitSender, int32_t());
+  MOCK_METHOD1(RegisterSendTransport, int32_t(Transport* outgoing_transport));
+  MOCK_METHOD1(SetMaxTransferUnit, int32_t(uint16_t size));
   MOCK_METHOD3(SetTransportOverhead,
-      int32_t(const bool TCP, const bool IPV6,
-              const uint8_t authenticationOverhead));
-  MOCK_CONST_METHOD0(MaxPayloadLength,
-      uint16_t());
-  MOCK_CONST_METHOD0(MaxDataPayloadLength,
-      uint16_t());
-  MOCK_METHOD1(RegisterSendPayload,
-      int32_t(const CodecInst& voiceCodec));
-  MOCK_METHOD1(RegisterSendPayload,
-      int32_t(const VideoCodec& videoCodec));
+               int32_t(bool tcp, bool ipv6, uint8_t authentication_overhead));
+  MOCK_CONST_METHOD0(MaxPayloadLength, uint16_t());
+  MOCK_CONST_METHOD0(MaxDataPayloadLength, uint16_t());
+  MOCK_METHOD1(RegisterSendPayload, int32_t(const CodecInst& voice_codec));
+  MOCK_METHOD1(RegisterSendPayload, int32_t(const VideoCodec& video_codec));
   MOCK_METHOD2(RegisterVideoSendPayload,
                void(int payload_type, const char* payload_name));
-  MOCK_METHOD1(DeRegisterSendPayload,
-      int32_t(const int8_t payloadType));
+  MOCK_METHOD1(DeRegisterSendPayload, int32_t(int8_t payload_type));
   MOCK_METHOD2(RegisterSendRtpHeaderExtension,
-      int32_t(const RTPExtensionType type, const uint8_t id));
+               int32_t(RTPExtensionType type, uint8_t id));
   MOCK_METHOD1(DeregisterSendRtpHeaderExtension,
-      int32_t(const RTPExtensionType type));
-  MOCK_CONST_METHOD0(StartTimestamp,
-      uint32_t());
-  MOCK_METHOD1(SetStartTimestamp, void(const uint32_t timestamp));
+               int32_t(RTPExtensionType type));
+  MOCK_CONST_METHOD0(StartTimestamp, uint32_t());
+  MOCK_METHOD1(SetStartTimestamp, void(uint32_t timestamp));
   MOCK_CONST_METHOD0(SequenceNumber, uint16_t());
-  MOCK_METHOD1(SetSequenceNumber, void(const uint16_t seq));
+  MOCK_METHOD1(SetSequenceNumber, void(uint16_t seq));
   MOCK_METHOD1(SetRtpState, void(const RtpState& rtp_state));
   MOCK_METHOD1(SetRtxState, void(const RtpState& rtp_state));
   MOCK_CONST_METHOD0(GetRtpState, RtpState());
   MOCK_CONST_METHOD0(GetRtxState, RtpState());
-  MOCK_CONST_METHOD0(SSRC,
-      uint32_t());
-  MOCK_METHOD1(SetSSRC,
-      void(const uint32_t ssrc));
-  MOCK_CONST_METHOD1(CSRCs,
-      int32_t(uint32_t arrOfCSRC[kRtpCsrcSize]));
+  MOCK_CONST_METHOD0(SSRC, uint32_t());
+  MOCK_METHOD1(SetSSRC, void(uint32_t ssrc));
+  MOCK_CONST_METHOD1(CSRCs, int32_t(uint32_t csrcs[kRtpCsrcSize]));
   MOCK_METHOD1(SetCsrcs, void(const std::vector<uint32_t>& csrcs));
-  MOCK_METHOD1(SetCSRCStatus,
-      int32_t(const bool include));
+  MOCK_METHOD1(SetCSRCStatus, int32_t(bool include));
   MOCK_METHOD1(SetRtxSendStatus, void(int modes));
   MOCK_CONST_METHOD0(RtxSendStatus, int());
-  MOCK_METHOD1(SetRtxSsrc,
-      void(uint32_t));
+  MOCK_METHOD1(SetRtxSsrc, void(uint32_t));
   MOCK_METHOD2(SetRtxSendPayloadType, void(int, int));
   MOCK_CONST_METHOD0(RtxSendPayloadType, std::pair<int, int>());
-  MOCK_METHOD1(SetSendingStatus,
-      int32_t(const bool sending));
-  MOCK_CONST_METHOD0(Sending,
-      bool());
-  MOCK_METHOD1(SetSendingMediaStatus, void(const bool sending));
-  MOCK_CONST_METHOD0(SendingMedia,
-      bool());
+  MOCK_METHOD1(SetSendingStatus, int32_t(bool sending));
+  MOCK_CONST_METHOD0(Sending, bool());
+  MOCK_METHOD1(SetSendingMediaStatus, void(bool sending));
+  MOCK_CONST_METHOD0(SendingMedia, bool());
   MOCK_CONST_METHOD4(BitrateSent,
-                     void(uint32_t* totalRate,
-                          uint32_t* videoRate,
-                          uint32_t* fecRate,
-                          uint32_t* nackRate));
+                     void(uint32_t* total_rate,
+                          uint32_t* video_rate,
+                          uint32_t* fec_rate,
+                          uint32_t* nack_rate));
   MOCK_METHOD1(RegisterVideoBitrateObserver, void(BitrateStatisticsObserver*));
   MOCK_CONST_METHOD0(GetVideoBitrateObserver, BitrateStatisticsObserver*(void));
   MOCK_CONST_METHOD1(EstimatedReceiveBandwidth,
-      int(uint32_t* available_bandwidth));
+                     int(uint32_t* available_bandwidth));
   MOCK_METHOD8(SendOutgoingData,
-      int32_t(const FrameType frameType,
-              const int8_t payloadType,
-              const uint32_t timeStamp,
-              int64_t capture_time_ms,
-              const uint8_t* payloadData,
-              const size_t payloadSize,
-              const RTPFragmentationHeader* fragmentation,
-              const RTPVideoHeader* rtpVideoHdr));
+               int32_t(FrameType frame_type,
+                       int8_t payload_type,
+                       uint32_t timestamp,
+                       int64_t capture_time_ms,
+                       const uint8_t* payload_data,
+                       size_t payload_size,
+                       const RTPFragmentationHeader* fragmentation,
+                       const RTPVideoHeader* rtp_video_header));
   MOCK_METHOD5(TimeToSendPacket,
                bool(uint32_t ssrc,
                     uint16_t sequence_number,
                     int64_t capture_time_ms,
                     bool retransmission,
                     int probe_cluster_id));
   MOCK_METHOD2(TimeToSendPadding, size_t(size_t bytes, int probe_cluster_id));
   MOCK_METHOD2(RegisterRtcpObservers,
-      void(RtcpIntraFrameObserver* intraFrameCallback,
-           RtcpBandwidthObserver* bandwidthCallback));
+               void(RtcpIntraFrameObserver* intra_frame_callback,
+                    RtcpBandwidthObserver* bandwidth_callback));
   MOCK_CONST_METHOD0(RTCP, RtcpMode());
-  MOCK_METHOD1(SetRTCPStatus, void(const RtcpMode method));
-  MOCK_METHOD1(SetCNAME,
-      int32_t(const char cName[RTCP_CNAME_SIZE]));
+  MOCK_METHOD1(SetRTCPStatus, void(RtcpMode method));
+  MOCK_METHOD1(SetCNAME, int32_t(const char cname[RTCP_CNAME_SIZE]));
   MOCK_CONST_METHOD2(RemoteCNAME,
-      int32_t(const uint32_t remoteSSRC,
-              char cName[RTCP_CNAME_SIZE]));
+                     int32_t(uint32_t remote_ssrc,
+                             char cname[RTCP_CNAME_SIZE]));
   MOCK_CONST_METHOD5(RemoteNTP,
-      int32_t(uint32_t *ReceivedNTPsecs,
-              uint32_t *ReceivedNTPfrac,
-              uint32_t *RTCPArrivalTimeSecs,
-              uint32_t *RTCPArrivalTimeFrac,
-              uint32_t *rtcp_timestamp));
+                     int32_t(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));
   MOCK_METHOD2(AddMixedCNAME,
-      int32_t(const uint32_t SSRC,
-              const char cName[RTCP_CNAME_SIZE]));
-  MOCK_METHOD1(RemoveMixedCNAME,
-      int32_t(const uint32_t SSRC));
+               int32_t(uint32_t ssrc, const char cname[RTCP_CNAME_SIZE]));
+  MOCK_METHOD1(RemoveMixedCNAME, int32_t(uint32_t ssrc));
   MOCK_CONST_METHOD5(RTT,
-      int32_t(const uint32_t remoteSSRC,
-              int64_t* RTT,
-              int64_t* avgRTT,
-              int64_t* minRTT,
-              int64_t* maxRTT));
-  MOCK_METHOD1(SendRTCP, int32_t(RTCPPacketType packetType));
+                     int32_t(uint32_t remote_ssrc,
+                             int64_t* rtt,
+                             int64_t* avg_rtt,
+                             int64_t* min_rtt,
+                             int64_t* max_rtt));
+  MOCK_METHOD1(SendRTCP, int32_t(RTCPPacketType packet_type));
   MOCK_METHOD1(SendCompoundRTCP,
-               int32_t(const std::set<RTCPPacketType>& packetTypes));
-  MOCK_METHOD1(SendRTCPReferencePictureSelection, int32_t(uint64_t pictureID));
-  MOCK_METHOD1(SendRTCPSliceLossIndication,
-      int32_t(const uint8_t pictureID));
+               int32_t(const std::set<RTCPPacketType>& packet_types));
+  MOCK_METHOD1(SendRTCPReferencePictureSelection, int32_t(uint64_t picture_id));
+  MOCK_METHOD1(SendRTCPSliceLossIndication, int32_t(uint8_t picture_id));
   MOCK_CONST_METHOD2(DataCountersRTP,
-      int32_t(size_t *bytesSent, uint32_t *packetsSent));
+                     int32_t(size_t* bytes_sent, uint32_t* packets_sent));
   MOCK_CONST_METHOD2(GetSendStreamDataCounters,
-      void(StreamDataCounters*, StreamDataCounters*));
+                     void(StreamDataCounters*, StreamDataCounters*));
   MOCK_CONST_METHOD3(GetRtpPacketLossStats,
-      void(bool, uint32_t, struct RtpPacketLossStats*));
-  MOCK_METHOD1(RemoteRTCPStat,
-      int32_t(RTCPSenderInfo* senderInfo));
+                     void(bool, uint32_t, struct RtpPacketLossStats*));
+  MOCK_METHOD1(RemoteRTCPStat, int32_t(RTCPSenderInfo* sender_info));
   MOCK_CONST_METHOD1(RemoteRTCPStat,
-      int32_t(std::vector<RTCPReportBlock>* receiveBlocks));
+                     int32_t(std::vector<RTCPReportBlock>* receive_blocks));
   MOCK_METHOD4(SetRTCPApplicationSpecificData,
-               int32_t(const uint8_t subType,
-                       const uint32_t name,
+               int32_t(uint8_t sub_type,
+                       uint32_t name,
                        const uint8_t* data,
-                       const uint16_t length));
-  MOCK_METHOD1(SetRTCPVoIPMetrics,
-      int32_t(const RTCPVoIPMetric* VoIPMetric));
-  MOCK_METHOD1(SetRtcpXrRrtrStatus,
-      void(bool enable));
-  MOCK_CONST_METHOD0(RtcpXrRrtrStatus,
-      bool());
-  MOCK_CONST_METHOD0(REMB,
-      bool());
-  MOCK_METHOD1(SetREMBStatus, void(const bool enable));
+                       uint16_t length));
+  MOCK_METHOD1(SetRTCPVoIPMetrics, int32_t(const RTCPVoIPMetric* voip_metric));
+  MOCK_METHOD1(SetRtcpXrRrtrStatus, void(bool enable));
+  MOCK_CONST_METHOD0(RtcpXrRrtrStatus, bool());
+  MOCK_CONST_METHOD0(REMB, bool());
+  MOCK_METHOD1(SetREMBStatus, void(bool enable));
   MOCK_METHOD2(SetREMBData,
-               void(const uint32_t bitrate,
-                    const std::vector<uint32_t>& ssrcs));
-  MOCK_CONST_METHOD0(TMMBR,
-      bool());
-  MOCK_METHOD1(SetTMMBRStatus, void(const bool enable));
-  MOCK_METHOD1(OnBandwidthEstimateUpdate,
-      void(uint16_t bandWidthKbit));
-  MOCK_CONST_METHOD0(SelectiveRetransmissions,
-      int());
-  MOCK_METHOD1(SetSelectiveRetransmissions,
-      int(uint8_t settings));
-  MOCK_METHOD2(SendNACK,
-      int32_t(const uint16_t* nackList, const uint16_t size));
+               void(uint32_t bitrate, const std::vector<uint32_t>& ssrcs));
+  MOCK_CONST_METHOD0(TMMBR, bool());
+  MOCK_METHOD1(SetTMMBRStatus, void(bool enable));
+  MOCK_METHOD1(OnBandwidthEstimateUpdate, void(uint16_t bandwidth_kbit));
+  MOCK_CONST_METHOD0(SelectiveRetransmissions, int());
+  MOCK_METHOD1(SetSelectiveRetransmissions, int(uint8_t settings));
+  MOCK_METHOD2(SendNACK, int32_t(const uint16_t* nack_list, uint16_t size));
   MOCK_METHOD1(SendNack, void(const std::vector<uint16_t>& sequence_numbers));
   MOCK_METHOD2(SetStorePacketsStatus,
-               void(const bool enable, const uint16_t numberToStore));
+               void(bool enable, uint16_t number_to_store));
   MOCK_CONST_METHOD0(StorePackets, bool());
   MOCK_METHOD1(RegisterRtcpStatisticsCallback, void(RtcpStatisticsCallback*));
   MOCK_METHOD0(GetRtcpStatisticsCallback, RtcpStatisticsCallback*());
   MOCK_METHOD1(SendFeedbackPacket, bool(const rtcp::TransportFeedback& packet));
-  MOCK_METHOD1(SetAudioPacketSize,
-      int32_t(const uint16_t packetSizeSamples));
+  MOCK_METHOD1(SetAudioPacketSize, int32_t(uint16_t packet_size_samples));
   MOCK_METHOD3(SendTelephoneEventOutband,
-      int32_t(const uint8_t key, const uint16_t time_ms, const uint8_t level));
-  MOCK_METHOD1(SetSendREDPayloadType,
-      int32_t(const int8_t payloadType));
-  MOCK_CONST_METHOD1(SendREDPayloadType, int32_t(int8_t* payloadType));
+               int32_t(uint8_t key, uint16_t time_ms, uint8_t level));
+  MOCK_METHOD1(SetSendREDPayloadType, int32_t(int8_t payload_type));
+  MOCK_CONST_METHOD1(SendREDPayloadType, int32_t(int8_t* payload_type));
   MOCK_METHOD2(SetRTPAudioLevelIndicationStatus,
-      int32_t(const bool enable, const uint8_t ID));
-  MOCK_METHOD1(SetAudioLevel,
-      int32_t(const uint8_t level_dBov));
-  MOCK_METHOD1(SetTargetSendBitrate,
-      void(uint32_t bitrate_bps));
+               int32_t(bool enable, uint8_t id));
+  MOCK_METHOD1(SetAudioLevel, int32_t(uint8_t level_dbov));
+  MOCK_METHOD1(SetTargetSendBitrate, void(uint32_t bitrate_bps));
   MOCK_METHOD3(SetGenericFECStatus,
-               void(const bool enable,
-                    const uint8_t payload_type_red,
-                    const uint8_t payload_type_fec));
+               void(bool enable,
+                    uint8_t payload_type_red,
+                    uint8_t payload_type_fec));
   MOCK_METHOD3(GenericFECStatus,
                void(bool* enable,
-                    uint8_t* payloadTypeRED,
-                    uint8_t* payloadTypeFEC));
+                    uint8_t* payload_type_red,
+                    uint8_t* payload_type_fec));
   MOCK_METHOD2(SetFecParameters,
-      int32_t(const FecProtectionParams* delta_params,
-              const FecProtectionParams* key_params));
-  MOCK_METHOD1(SetKeyFrameRequestMethod,
-      int32_t(const KeyFrameRequestMethod method));
-  MOCK_METHOD0(RequestKeyFrame,
-      int32_t());
-  MOCK_METHOD0(TimeUntilNextProcess,
-        int64_t());
-  MOCK_METHOD0(Process,
-        void());
-  MOCK_METHOD1(RegisterSendFrameCountObserver,
-      void(FrameCountObserver*));
-  MOCK_CONST_METHOD0(GetSendFrameCountObserver,
-      FrameCountObserver*(void));
+               int32_t(const FecProtectionParams* delta_params,
+                       const FecProtectionParams* key_params));
+  MOCK_METHOD1(SetKeyFrameRequestMethod, int32_t(KeyFrameRequestMethod method));
+  MOCK_METHOD0(RequestKeyFrame, int32_t());
+  MOCK_METHOD0(TimeUntilNextProcess, int64_t());
+  MOCK_METHOD0(Process, void());
+  MOCK_METHOD1(RegisterSendFrameCountObserver, void(FrameCountObserver*));
+  MOCK_CONST_METHOD0(GetSendFrameCountObserver, FrameCountObserver*(void));
   MOCK_METHOD1(RegisterSendChannelRtpStatisticsCallback,
-      void(StreamDataCountersCallback*));
+               void(StreamDataCountersCallback*));
   MOCK_CONST_METHOD0(GetSendChannelRtpStatisticsCallback,
-      StreamDataCountersCallback*(void));
+                     StreamDataCountersCallback*(void));
   // Members.
   unsigned int remote_ssrc_;
 };
 
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_RTP_RTCP_MOCKS_MOCK_RTP_RTCP_H_