modules/rtp_rtcp/include folder cleared of lint warnings

webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.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 15 matching lines @@
 namespace webrtc {
 namespace rtcp {
 class TransportFeedback;
 }
 
 const int kVideoPayloadTypeFrequency = 90000;
 
 // Minimum RTP header size in bytes.
 const uint8_t kRtpHeaderSize = 12;
 
-struct AudioPayload
-{
+struct AudioPayload {
     uint32_t    frequency;
     uint8_t     channels;
     uint32_t    rate;
 };
 
-struct VideoPayload
-{
+struct VideoPayload {
     RtpVideoCodecTypes   videoCodecType;
     uint32_t       maxRate;
 };
 
-union PayloadUnion
-{
+union PayloadUnion {
     AudioPayload Audio;
     VideoPayload Video;
 };
 
-enum RTPAliveType
-{
-    kRtpDead   = 0,
-    kRtpNoRtp = 1,
-    kRtpAlive  = 2
-};
+enum RTPAliveType { kRtpDead = 0, kRtpNoRtp = 1, kRtpAlive = 2 };
 
 enum ProtectionType {
   kUnprotectedPacket,
   kProtectedPacket
 };
 
 enum StorageType {
   kDontRetransmit,
   kAllowRetransmission
 };
 
 enum RTPExtensionType {
   kRtpExtensionNone,
   kRtpExtensionTransmissionTimeOffset,
   kRtpExtensionAudioLevel,
   kRtpExtensionAbsoluteSendTime,
   kRtpExtensionVideoRotation,
   kRtpExtensionTransportSequenceNumber,
 };
 
-enum RTCPAppSubTypes
-{
-    kAppSubtypeBwe     = 0x00
-};
+enum RTCPAppSubTypes { kAppSubtypeBwe = 0x00 };
 
 // TODO(sprang): Make this an enum class once rtcp_receiver has been cleaned up.
 enum RTCPPacketType : uint32_t {
   kRtcpReport = 0x0001,
   kRtcpSr = 0x0002,
   kRtcpRr = 0x0004,
   kRtcpSdes = 0x0008,
   kRtcpBye = 0x0010,
   kRtcpPli = 0x0020,
   kRtcpNack = 0x0040,
   kRtcpFir = 0x0080,
   kRtcpTmmbr = 0x0100,
   kRtcpTmmbn = 0x0200,
   kRtcpSrReq = 0x0400,
   kRtcpXrVoipMetric = 0x0800,
   kRtcpApp = 0x1000,
   kRtcpSli = 0x4000,
   kRtcpRpsi = 0x8000,
   kRtcpRemb = 0x10000,
   kRtcpTransmissionTimeOffset = 0x20000,
   kRtcpXrReceiverReferenceTime = 0x40000,
   kRtcpXrDlrrReportBlock = 0x80000,
   kRtcpTransportFeedback = 0x100000,
 };
 
 enum KeyFrameRequestMethod { kKeyFrameReqPliRtcp, kKeyFrameReqFirRtcp };
 
-enum RtpRtcpPacketType
-{
-    kPacketRtp        = 0,
-    kPacketKeepAlive = 1
-};
+enum RtpRtcpPacketType { kPacketRtp = 0, kPacketKeepAlive = 1 };
 
-enum NACKMethod
-{
-    kNackOff      = 0,
-    kNackRtcp     = 2
-};
+enum NACKMethod { kNackOff = 0, kNackRtcp = 2 };
 
 enum RetransmissionMode : uint8_t {
   kRetransmitOff = 0x0,
   kRetransmitFECPackets = 0x1,
   kRetransmitBaseLayer = 0x2,
   kRetransmitHigherLayers = 0x4,
   kRetransmitAllPackets = 0xFF
 };
 
 enum RtxMode {
   kRtxOff                 = 0x0,
   kRtxRetransmitted       = 0x1,  // Only send retransmissions over RTX.
   kRtxRedundantPayloads   = 0x2   // Preventively send redundant payloads
                                   // instead of padding.
 };
 
 const size_t kRtxHeaderSize = 2;
 
-struct RTCPSenderInfo
-{
+struct RTCPSenderInfo {
     uint32_t NTPseconds;
     uint32_t NTPfraction;
     uint32_t RTPtimeStamp;
     uint32_t sendPacketCount;
     uint32_t sendOctetCount;
 };
 
 struct RTCPReportBlock {
   RTCPReportBlock()
       : remoteSSRC(0), sourceSSRC(0), fractionLost(0), cumulativeLost(0),
@@ skipping 46 matching lines @@
         last_timestamp_time_ms(-1),
         media_has_been_sent(false) {}
   uint16_t sequence_number;
   uint32_t start_timestamp;
   uint32_t timestamp;
   int64_t capture_time_ms;
   int64_t last_timestamp_time_ms;
   bool media_has_been_sent;
 };
 
-class RtpData
-{
-public:
-    virtual ~RtpData() {}
+class RtpData {
+ public:
+  virtual ~RtpData() {}
 
-    virtual int32_t OnReceivedPayloadData(
-        const uint8_t* payloadData,
-        const size_t payloadSize,
-        const WebRtcRTPHeader* rtpHeader) = 0;
+  virtual int32_t OnReceivedPayloadData(const uint8_t* payloadData,
+                                        const size_t payloadSize,
+                                        const WebRtcRTPHeader* rtpHeader) = 0;
 
-    virtual bool OnRecoveredPacket(const uint8_t* packet,
-                                   size_t packet_length) = 0;
+  virtual bool OnRecoveredPacket(const uint8_t* packet,
+                                 size_t packet_length) = 0;
 };
 
-class RtpFeedback
-{
-public:
-    virtual ~RtpFeedback() {}
+class RtpFeedback {
+ public:
+  virtual ~RtpFeedback() {}
 
-    // Receiving payload change or SSRC change. (return success!)
-    /*
-    *   channels    - number of channels in codec (1 = mono, 2 = stereo)
-    */
-    virtual int32_t OnInitializeDecoder(
-        const int8_t payloadType,
-        const char payloadName[RTP_PAYLOAD_NAME_SIZE],
-        const int frequency,
-        const uint8_t channels,
-        const uint32_t rate) = 0;
+  // Receiving payload change or SSRC change. (return success!)
+  /*
+  *   channels    - number of channels in codec (1 = mono, 2 = stereo)
+  */
+  virtual int32_t OnInitializeDecoder(
+      const int8_t payloadType,
+      const char payloadName[RTP_PAYLOAD_NAME_SIZE],
+      const int frequency,
+      const uint8_t channels,
+      const uint32_t rate) = 0;
 
-    virtual void OnIncomingSSRCChanged(const uint32_t ssrc) = 0;
+  virtual void OnIncomingSSRCChanged(const uint32_t ssrc) = 0;
 
-    virtual void OnIncomingCSRCChanged(const uint32_t CSRC,
-                                       const bool added) = 0;
+  virtual void OnIncomingCSRCChanged(const uint32_t CSRC, const bool added) = 0;
 };
 
 class RtpAudioFeedback {
  public:
   virtual void OnPlayTelephoneEvent(const uint8_t event,
                                     const uint16_t lengthMs,
                                     const uint8_t volume) = 0;
 
  protected:
   virtual ~RtpAudioFeedback() {}
@@ skipping 86 matching lines @@
 
   virtual void OnTransportFeedback(const rtcp::TransportFeedback& feedback) = 0;
 };
 
 class RtcpRttStats {
  public:
   virtual void OnRttUpdate(int64_t rtt) = 0;
 
   virtual int64_t LastProcessedRtt() const = 0;
 
-  virtual ~RtcpRttStats() {};
+  virtual ~RtcpRttStats() {}
 };
 
 // Null object version of RtpFeedback.
 class NullRtpFeedback : public RtpFeedback {
  public:
   virtual ~NullRtpFeedback() {}
 
   int32_t OnInitializeDecoder(const int8_t payloadType,
                               const char payloadName[RTP_PAYLOAD_NAME_SIZE],
                               const int frequency,
@@ skipping 70 matching lines @@
 
 class TransportSequenceNumberAllocator {
  public:
   TransportSequenceNumberAllocator() {}
   virtual ~TransportSequenceNumberAllocator() {}
 
   virtual uint16_t AllocateSequenceNumber() = 0;
 };
 
 }  // namespace webrtc
-#endif // WEBRTC_MODULES_RTP_RTCP_INCLUDE_RTP_RTCP_DEFINES_H_
+#endif  // WEBRTC_MODULES_RTP_RTCP_INCLUDE_RTP_RTCP_DEFINES_H_