Style cleanups in RtpSender.

webrtc/modules/rtp_rtcp/include/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.
  */
 
@@ skipping 22 matching lines @@
 
 namespace rtcp {
 class TransportFeedback;
 }
 
 class RtpRtcp : public Module {
  public:
   struct Configuration {
     Configuration();
 
-   /*  id                   - Unique identifier of this RTP/RTCP module object
-    *  audio                - True for a audio version of the RTP/RTCP module
-    *                         object false will create a video version
-    *  clock                - The clock to use to read time. If NULL object
-    *                         will be using the system clock.
-    *  incoming_data        - Callback object that will receive the incoming
-    *                         data. May not be NULL; default callback will do
-    *                         nothing.
-    *  incoming_messages    - Callback object that will receive the incoming
-    *                         RTP messages. May not be NULL; default callback
-    *                         will do nothing.
-    *  outgoing_transport   - Transport object that will be called when packets
-    *                         are ready to be sent out on the network
-    *  intra_frame_callback - Called when the receiver request a intra frame.
-    *  bandwidth_callback   - Called when we receive a changed estimate from
-    *                         the receiver of out stream.
-    *  remote_bitrate_estimator - Estimates the bandwidth available for a set of
-    *                             streams from the same client.
-    *  paced_sender             - Spread any bursts of packets into smaller
-    *                             bursts to minimize packet loss.
-    */
-    bool audio;
-    bool receiver_only;
-    Clock* clock;
+    // True for a audio version of the RTP/RTCP module object false will create
+    // a video version.
+    bool audio = false;
+    bool receiver_only = false;
+
+    // The clock to use to read time. If nullptr then system clock will be used.
+    Clock* clock = nullptr;
+
     ReceiveStatistics* receive_statistics;
-    Transport* outgoing_transport;
-    RtcpIntraFrameObserver* intra_frame_callback;
-    RtcpBandwidthObserver* bandwidth_callback;
-    TransportFeedbackObserver* transport_feedback_callback;
-    RtcpRttStats* rtt_stats;
-    RtcpPacketTypeCounterObserver* rtcp_packet_type_counter_observer;
-    RemoteBitrateEstimator* remote_bitrate_estimator;
-    RtpPacketSender* paced_sender;
-    TransportSequenceNumberAllocator* transport_sequence_number_allocator;
-    BitrateStatisticsObserver* send_bitrate_observer;
-    FrameCountObserver* send_frame_count_observer;
-    SendSideDelayObserver* send_side_delay_observer;
-    RtcEventLog* event_log;
-    SendPacketObserver* send_packet_observer;
+
+    // Transport object that will be called when packets are ready to be sent
+    // out on the network.
+    Transport* outgoing_transport = nullptr;
+
+    // Called when the receiver request a intra frame.
+    RtcpIntraFrameObserver* intra_frame_callback = nullptr;
+
+    // Called when we receive a changed estimate from the receiver of out
+    // stream.
+    RtcpBandwidthObserver* bandwidth_callback = nullptr;
+
+    TransportFeedbackObserver* transport_feedback_callback = nullptr;
+    RtcpRttStats* rtt_stats = nullptr;
+    RtcpPacketTypeCounterObserver* rtcp_packet_type_counter_observer = nullptr;
+
+    // Estimates the bandwidth available for a set of streams from the same
+    // client.
+    RemoteBitrateEstimator* remote_bitrate_estimator = nullptr;
+
+    // Spread any bursts of packets into smaller bursts to minimize packet loss.
+    RtpPacketSender* paced_sender = nullptr;
+
+    TransportSequenceNumberAllocator* transport_sequence_number_allocator =
+        nullptr;
+    BitrateStatisticsObserver* send_bitrate_observer = nullptr;
+    FrameCountObserver* send_frame_count_observer = nullptr;
+    SendSideDelayObserver* send_side_delay_observer = nullptr;
+    RtcEventLog* event_log = nullptr;
+    SendPacketObserver* send_packet_observer = nullptr;
+
+   private:
     RTC_DISALLOW_COPY_AND_ASSIGN(Configuration);
   };
 
   /*
    *   Create a RTP/RTCP module object using the system clock.
    *
    *   configuration  - Configuration of the RTP/RTCP module.
    */
   static RtpRtcp* CreateRtpRtcp(const RtpRtcp::Configuration& configuration);
 
@@ skipping 74 matching lines @@
     */
     virtual int32_t RegisterSendPayload(
         const VideoCodec& videoCodec) = 0;
 
     virtual void RegisterVideoSendPayload(int payload_type,
                                           const char* payload_name) = 0;
 
     /*
     *   Unregister a send payload
     *
-    *   payloadType - payload type of codec
+    *   payload_type - payload type of codec
     *
     *   return -1 on failure else 0
     */
-    virtual int32_t DeRegisterSendPayload(int8_t payloadType) = 0;
+    virtual int32_t DeRegisterSendPayload(int8_t payload_type) = 0;
 
    /*
     *   (De)register RTP header extension type and id.
     *
     *   return -1 on failure else 0
     */
     virtual int32_t RegisterSendRtpHeaderExtension(RTPExtensionType type,
                                                    uint8_t id) = 0;
 
     virtual int32_t DeregisterSendRtpHeaderExtension(RTPExtensionType type) = 0;
@@ skipping 94 matching lines @@
     */
     virtual void BitrateSent(uint32_t* totalRate,
                              uint32_t* videoRate,
                              uint32_t* fecRate,
                              uint32_t* nackRate) const = 0;
 
     /*
     *   Used by the codec module to deliver a video or audio frame for
     *   packetization.
     *
-    *   frameType       - type of frame to send
-    *   payloadType     - payload type of frame to send
+    *   frame_type      - type of frame to send
+    *   payload_type    - payload type of frame to send
     *   timestamp       - timestamp of frame to send
-    *   payloadData     - payload buffer of frame to send
-    *   payloadSize     - size of payload buffer to send
+    *   payload_data    - payload buffer of frame to send
+    *   payload_size    - size of payload buffer to send
     *   fragmentation   - fragmentation offset data for fragmented frames such
     *                     as layers or RED
     *
     *   return -1 on failure else 0
     */
     virtual int32_t SendOutgoingData(
-        FrameType frameType,
-        int8_t payloadType,
+        FrameType frame_type,
+        int8_t payload_type,
         uint32_t timeStamp,
         int64_t capture_time_ms,
-        const uint8_t* payloadData,
-        size_t payloadSize,
+        const uint8_t* payload_data,
+        size_t payload_size,
         const RTPFragmentationHeader* fragmentation = NULL,
         const RTPVideoHeader* rtpVideoHdr = NULL) = 0;
 
     virtual bool TimeToSendPacket(uint32_t ssrc,
                                   uint16_t sequence_number,
                                   int64_t capture_time_ms,
                                   bool retransmission,
                                   int probe_cluster_id) = 0;
 
     virtual size_t TimeToSendPadding(size_t bytes, int probe_cluster_id) = 0;
@@ skipping 27 matching lines @@
     *
     *   return -1 on failure else 0
     */
     virtual int32_t SetCNAME(const char* c_name) = 0;
 
     /*
     *   Get remote CName
     *
     *   return -1 on failure else 0
     */
-    virtual int32_t RemoteCNAME(uint32_t remoteSSRC,
+    virtual int32_t RemoteCNAME(uint32_t remote_ssrc,
                                 char cName[RTCP_CNAME_SIZE]) const = 0;
 
     /*
     *   Get remote NTP
     *
     *   return -1 on failure else 0
     */
     virtual int32_t RemoteNTP(
         uint32_t *ReceivedNTPsecs,
         uint32_t *ReceivedNTPfrac,
@@ skipping 13 matching lines @@
     *
     *   return -1 on failure else 0
     */
     virtual int32_t RemoveMixedCNAME(uint32_t SSRC) = 0;
 
     /*
     *   Get RoundTripTime
     *
     *   return -1 on failure else 0
     */
-    virtual int32_t RTT(uint32_t remoteSSRC,
-                        int64_t* RTT,
-                        int64_t* avgRTT,
-                        int64_t* minRTT,
-                        int64_t* maxRTT) const = 0;
+    virtual int32_t RTT(uint32_t remote_ssrc,
+                        int64_t* rtt,
+                        int64_t* avg_rtt,
+                        int64_t* min_rtt,
+                        int64_t* max_rtt) const = 0;
 
     /*
     *   Force a send of a RTCP packet
     *   periodic SR and RR are triggered via the process function
     *
     *   return -1 on failure else 0
     */
-    virtual int32_t SendRTCP(RTCPPacketType rtcpPacketType) = 0;
+    virtual int32_t SendRTCP(RTCPPacketType rtcp_packet_type) = 0;
 
     /*
     *   Force a send of a RTCP packet with more than one packet type.
     *   periodic SR and RR are triggered via the process function
     *
     *   return -1 on failure else 0
     */
     virtual int32_t SendCompoundRTCP(
-        const std::set<RTCPPacketType>& rtcpPacketTypes) = 0;
+        const std::set<RTCPPacketType>& rtcp_packet_types) = 0;
 
     /*
     *    Good state of RTP receiver inform sender
     */
     virtual int32_t SendRTCPReferencePictureSelection(uint64_t pictureID) = 0;
 
     /*
     *    Send a RTCP Slice Loss Indication (SLI)
     *    6 least significant bits of pictureID
     */
@@ skipping 21 matching lines @@
     virtual void GetRtpPacketLossStats(
         bool outgoing,
         uint32_t ssrc,
         struct RtpPacketLossStats* loss_stats) const = 0;
 
     /*
     *   Get received RTCP sender info
     *
     *   return -1 on failure else 0
     */
-    virtual int32_t RemoteRTCPStat(RTCPSenderInfo* senderInfo) = 0;
+    virtual int32_t RemoteRTCPStat(RTCPSenderInfo* sender_info) = 0;
 
     /*
     *   Get received RTCP report block
     *
     *   return -1 on failure else 0
     */
     virtual int32_t RemoteRTCPStat(
-        std::vector<RTCPReportBlock>* receiveBlocks) const = 0;
+        std::vector<RTCPReportBlock>* receive_blocks) const = 0;
 
     /*
     *   (APP) Application specific data
     *
     *   return -1 on failure else 0
     */
-    virtual int32_t SetRTCPApplicationSpecificData(uint8_t subType,
+    virtual int32_t SetRTCPApplicationSpecificData(uint8_t sub_type,
                                                    uint32_t name,
                                                    const uint8_t* data,
                                                    uint16_t length) = 0;
     /*
     *   (XR) VOIP metric
     *
     *   return -1 on failure else 0
     */
     virtual int32_t SetRTCPVoIPMetrics(
         const RTCPVoIPMetric* VoIPMetric) = 0;
@@ skipping 47 matching lines @@
     virtual int SetSelectiveRetransmissions(uint8_t settings) = 0;
 
     /*
     *   Send a Negative acknowledgement packet
     *
     *   return -1 on failure else 0
     */
     // TODO(philipel): Deprecate this and start using SendNack instead,
     //                 mostly because we want a function that actually send
     //                 NACK for the specified packets.
-    virtual int32_t SendNACK(const uint16_t* nackList, uint16_t size) = 0;
+    virtual int32_t SendNACK(const uint16_t* nack_list, uint16_t size) = 0;
 
     /*
     *   Send NACK for the packets specified.
     *
     *   Note: This assumes the caller keeps track of timing and doesn't rely on
     *   the RTP module to do this.
     */
     virtual void SendNack(const std::vector<uint16_t>& sequence_numbers) = 0;
 
     /*
@@ skipping 18 matching lines @@
     *   Audio
     *
     ***************************************************************************/
 
     /*
     *   set audio packet size, used to determine when it's time to send a DTMF
     *   packet in silence (CNG)
     *
     *   return -1 on failure else 0
     */
-    virtual int32_t SetAudioPacketSize(uint16_t packetSizeSamples) = 0;
+    virtual int32_t SetAudioPacketSize(uint16_t packet_size_samples) = 0;
 
     /*
     *   Send a TelephoneEvent tone using RFC 2833 (4733)
     *
     *   return -1 on failure else 0
     */
     virtual int32_t SendTelephoneEventOutband(uint8_t key,
                                               uint16_t time_ms,
                                               uint8_t level) = 0;
 
     /*
     *   Set payload type for Redundant Audio Data RFC 2198
     *
     *   return -1 on failure else 0
     */
-    virtual int32_t SetSendREDPayloadType(int8_t payloadType) = 0;
+    virtual int32_t SetSendREDPayloadType(int8_t payload_type) = 0;
 
     /*
     *   Get payload type for Redundant Audio Data RFC 2198
     *
     *   return -1 on failure else 0
     */
     virtual int32_t SendREDPayloadType(int8_t* payload_type) const = 0;
      /*
      * Store the audio level in dBov for header-extension-for-audio-level-
      * indication.
@@ skipping 42 matching lines @@
 
     /*
     *   send a request for a keyframe
     *
     *   return -1 on failure else 0
     */
     virtual int32_t RequestKeyFrame() = 0;
 };
 }  // namespace webrtc
 #endif  // WEBRTC_MODULES_RTP_RTCP_INCLUDE_RTP_RTCP_H_