Reformat rtcp_receiver

webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc

Index: webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc b/webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc
index 75c7eec47553604b513927044dd15d0c20ec22a6..d57432cea469365fa6b989725ced3ec23e6a8782 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc
@@ -195,29 +195,27 @@ bool RTCPReceiver::NTP(uint32_t* ReceivedNTPsecs,
                        uint32_t* ReceivedNTPfrac,
                        uint32_t* RTCPArrivalTimeSecs,
                        uint32_t* RTCPArrivalTimeFrac,
-                       uint32_t* rtcp_timestamp) const
-{
-    rtc::CritScope lock(&_criticalSectionRTCPReceiver);
-    if(ReceivedNTPsecs)
-    {
-        *ReceivedNTPsecs = _remoteSenderInfo.NTPseconds; // NTP from incoming SendReport
-    }
-    if(ReceivedNTPfrac)
-    {
-        *ReceivedNTPfrac = _remoteSenderInfo.NTPfraction;
-    }
-    if(RTCPArrivalTimeFrac)
-    {
-        *RTCPArrivalTimeFrac = _lastReceivedSRNTPfrac; // local NTP time when we received a RTCP packet with a send block
-    }
-    if(RTCPArrivalTimeSecs)
-    {
-        *RTCPArrivalTimeSecs = _lastReceivedSRNTPsecs;
-    }
-    if (rtcp_timestamp) {
-      *rtcp_timestamp = _remoteSenderInfo.RTPtimeStamp;
-    }
-    return true;
+                       uint32_t* rtcp_timestamp) const {
+  rtc::CritScope lock(&_criticalSectionRTCPReceiver);
+  if (ReceivedNTPsecs) {
+    *ReceivedNTPsecs =
+        _remoteSenderInfo.NTPseconds;  // NTP from incoming SendReport
+  }
+  if (ReceivedNTPfrac) {
+    *ReceivedNTPfrac = _remoteSenderInfo.NTPfraction;
+  }
+  if (RTCPArrivalTimeFrac) {
+    *RTCPArrivalTimeFrac = _lastReceivedSRNTPfrac;  // local NTP time when we
+                                                    // received a RTCP packet
+                                                    // with a send block
+  }
+  if (RTCPArrivalTimeSecs) {
+    *RTCPArrivalTimeSecs = _lastReceivedSRNTPsecs;
+  }
+  if (rtcp_timestamp) {
+    *rtcp_timestamp = _remoteSenderInfo.RTPtimeStamp;
+  }
+  return true;
 }
 
 bool RTCPReceiver::LastReceivedXrReferenceTimeInfo(
@@ -232,8 +230,8 @@ bool RTCPReceiver::LastReceivedXrReferenceTimeInfo(
   info->lastRR = _remoteXRReceiveTimeInfo.lastRR;
 
   // Get the delay since last received report (RFC 3611).
-  uint32_t receive_time = RTCPUtility::MidNtp(_lastReceivedXRNTPsecs,
-                                              _lastReceivedXRNTPfrac);
+  uint32_t receive_time =
+      RTCPUtility::MidNtp(_lastReceivedXRNTPsecs, _lastReceivedXRNTPfrac);
 
   uint32_t ntp_sec = 0;
   uint32_t ntp_frac = 0;
@@ -271,189 +269,182 @@ int32_t RTCPReceiver::StatisticsReceived(
   return 0;
 }
 
-int32_t
-RTCPReceiver::IncomingRTCPPacket(RTCPPacketInformation& rtcpPacketInformation,
-                                 RTCPUtility::RTCPParserV2* rtcpParser)
-{
-    rtc::CritScope lock(&_criticalSectionRTCPReceiver);
-
-    _lastReceived = _clock->TimeInMilliseconds();
+int32_t RTCPReceiver::IncomingRTCPPacket(
+    RTCPPacketInformation& rtcpPacketInformation,
+    RTCPUtility::RTCPParserV2* rtcpParser) {
+  rtc::CritScope lock(&_criticalSectionRTCPReceiver);
 
-    if (packet_type_counter_.first_packet_time_ms == -1) {
-      packet_type_counter_.first_packet_time_ms = _lastReceived;
+  _lastReceived = _clock->TimeInMilliseconds();
+
+  if (packet_type_counter_.first_packet_time_ms == -1) {
+    packet_type_counter_.first_packet_time_ms = _lastReceived;
+  }
+
+  RTCPUtility::RTCPPacketTypes pktType = rtcpParser->Begin();
+  while (pktType != RTCPPacketTypes::kInvalid) {
+    // Each "case" is responsible for iterate the parser to the
+    // next top level packet.
+    switch (pktType) {
+      case RTCPPacketTypes::kSr:
+      case RTCPPacketTypes::kRr:
+        HandleSenderReceiverReport(*rtcpParser, rtcpPacketInformation);
+        break;
+      case RTCPPacketTypes::kSdes:
+        HandleSDES(*rtcpParser, rtcpPacketInformation);
+        break;
+      case RTCPPacketTypes::kXrHeader:
+        HandleXrHeader(*rtcpParser, rtcpPacketInformation);
+        break;
+      case RTCPPacketTypes::kXrReceiverReferenceTime:
+        HandleXrReceiveReferenceTime(*rtcpParser, rtcpPacketInformation);
+        break;
+      case RTCPPacketTypes::kXrDlrrReportBlock:
+        HandleXrDlrrReportBlock(*rtcpParser, rtcpPacketInformation);
+        break;
+      case RTCPPacketTypes::kXrVoipMetric:
+        HandleXRVOIPMetric(*rtcpParser, rtcpPacketInformation);
+        break;
+      case RTCPPacketTypes::kBye:
+        HandleBYE(*rtcpParser);
+        break;
+      case RTCPPacketTypes::kRtpfbNack:
+        HandleNACK(*rtcpParser, rtcpPacketInformation);
+        break;
+      case RTCPPacketTypes::kRtpfbTmmbr:
+        HandleTMMBR(*rtcpParser, rtcpPacketInformation);
+        break;
+      case RTCPPacketTypes::kRtpfbTmmbn:
+        HandleTMMBN(*rtcpParser, rtcpPacketInformation);
+        break;
+      case RTCPPacketTypes::kRtpfbSrReq:
+        HandleSR_REQ(*rtcpParser, rtcpPacketInformation);
+        break;
+      case RTCPPacketTypes::kPsfbPli:
+        HandlePLI(*rtcpParser, rtcpPacketInformation);
+        break;
+      case RTCPPacketTypes::kPsfbSli:
+        HandleSLI(*rtcpParser, rtcpPacketInformation);
+        break;
+      case RTCPPacketTypes::kPsfbRpsi:
+        HandleRPSI(*rtcpParser, rtcpPacketInformation);
+        break;
+      case RTCPPacketTypes::kExtendedIj:
+        HandleIJ(*rtcpParser, rtcpPacketInformation);
+        break;
+      case RTCPPacketTypes::kPsfbFir:
+        HandleFIR(*rtcpParser, rtcpPacketInformation);
+        break;
+      case RTCPPacketTypes::kPsfbApp:
+        HandlePsfbApp(*rtcpParser, rtcpPacketInformation);
+        break;
+      case RTCPPacketTypes::kApp:
+        // generic application messages
+        HandleAPP(*rtcpParser, rtcpPacketInformation);
+        break;
+      case RTCPPacketTypes::kAppItem:
+        // generic application messages
+        HandleAPPItem(*rtcpParser, rtcpPacketInformation);
+        break;
+      case RTCPPacketTypes::kTransportFeedback:
+        HandleTransportFeedback(rtcpParser, &rtcpPacketInformation);
+        break;
+      default:
+        rtcpParser->Iterate();
+        break;
     }
+    pktType = rtcpParser->PacketType();
+  }
 
-    RTCPUtility::RTCPPacketTypes pktType = rtcpParser->Begin();
-    while (pktType != RTCPPacketTypes::kInvalid) {
-        // Each "case" is responsible for iterate the parser to the
-        // next top level packet.
-        switch (pktType)
-        {
-          case RTCPPacketTypes::kSr:
-          case RTCPPacketTypes::kRr:
-            HandleSenderReceiverReport(*rtcpParser, rtcpPacketInformation);
-            break;
-          case RTCPPacketTypes::kSdes:
-            HandleSDES(*rtcpParser, rtcpPacketInformation);
-            break;
-          case RTCPPacketTypes::kXrHeader:
-            HandleXrHeader(*rtcpParser, rtcpPacketInformation);
-            break;
-          case RTCPPacketTypes::kXrReceiverReferenceTime:
-            HandleXrReceiveReferenceTime(*rtcpParser, rtcpPacketInformation);
-            break;
-          case RTCPPacketTypes::kXrDlrrReportBlock:
-            HandleXrDlrrReportBlock(*rtcpParser, rtcpPacketInformation);
-            break;
-          case RTCPPacketTypes::kXrVoipMetric:
-            HandleXRVOIPMetric(*rtcpParser, rtcpPacketInformation);
-            break;
-          case RTCPPacketTypes::kBye:
-            HandleBYE(*rtcpParser);
-            break;
-          case RTCPPacketTypes::kRtpfbNack:
-            HandleNACK(*rtcpParser, rtcpPacketInformation);
-            break;
-          case RTCPPacketTypes::kRtpfbTmmbr:
-            HandleTMMBR(*rtcpParser, rtcpPacketInformation);
-            break;
-          case RTCPPacketTypes::kRtpfbTmmbn:
-            HandleTMMBN(*rtcpParser, rtcpPacketInformation);
-            break;
-          case RTCPPacketTypes::kRtpfbSrReq:
-            HandleSR_REQ(*rtcpParser, rtcpPacketInformation);
-            break;
-          case RTCPPacketTypes::kPsfbPli:
-            HandlePLI(*rtcpParser, rtcpPacketInformation);
-            break;
-          case RTCPPacketTypes::kPsfbSli:
-            HandleSLI(*rtcpParser, rtcpPacketInformation);
-            break;
-          case RTCPPacketTypes::kPsfbRpsi:
-            HandleRPSI(*rtcpParser, rtcpPacketInformation);
-            break;
-          case RTCPPacketTypes::kExtendedIj:
-            HandleIJ(*rtcpParser, rtcpPacketInformation);
-            break;
-          case RTCPPacketTypes::kPsfbFir:
-            HandleFIR(*rtcpParser, rtcpPacketInformation);
-            break;
-          case RTCPPacketTypes::kPsfbApp:
-            HandlePsfbApp(*rtcpParser, rtcpPacketInformation);
-            break;
-          case RTCPPacketTypes::kApp:
-            // generic application messages
-            HandleAPP(*rtcpParser, rtcpPacketInformation);
-            break;
-          case RTCPPacketTypes::kAppItem:
-            // generic application messages
-            HandleAPPItem(*rtcpParser, rtcpPacketInformation);
-            break;
-          case RTCPPacketTypes::kTransportFeedback:
-            HandleTransportFeedback(rtcpParser, &rtcpPacketInformation);
-            break;
-        default:
-            rtcpParser->Iterate();
-            break;
-        }
-        pktType = rtcpParser->PacketType();
-    }
+  if (packet_type_counter_observer_ != NULL) {
+    packet_type_counter_observer_->RtcpPacketTypesCounterUpdated(
+        main_ssrc_, packet_type_counter_);
+  }
 
-    if (packet_type_counter_observer_ != NULL) {
-      packet_type_counter_observer_->RtcpPacketTypesCounterUpdated(
-          main_ssrc_, packet_type_counter_);
-    }
+  num_skipped_packets_ += rtcpParser->NumSkippedBlocks();
 
-    num_skipped_packets_ += rtcpParser->NumSkippedBlocks();
-
-    int64_t now = _clock->TimeInMilliseconds();
-    if (now - last_skipped_packets_warning_ >= kMaxWarningLogIntervalMs &&
-        num_skipped_packets_ > 0) {
-      last_skipped_packets_warning_ = now;
-      LOG(LS_WARNING)
-          << num_skipped_packets_
-          << " RTCP blocks were skipped due to being malformed or of "
-             "unrecognized/unsupported type, during the past "
-          << (kMaxWarningLogIntervalMs / 1000) << " second period.";
-    }
+  int64_t now = _clock->TimeInMilliseconds();
+  if (now - last_skipped_packets_warning_ >= kMaxWarningLogIntervalMs &&
+      num_skipped_packets_ > 0) {
+    last_skipped_packets_warning_ = now;
+    LOG(LS_WARNING) << num_skipped_packets_
+                    << " RTCP blocks were skipped due to being malformed or of "
+                       "unrecognized/unsupported type, during the past "
+                    << (kMaxWarningLogIntervalMs / 1000) << " second period.";
+  }
 
-    return 0;
+  return 0;
 }
 
-void
-RTCPReceiver::HandleSenderReceiverReport(RTCPUtility::RTCPParserV2& rtcpParser,
-                                         RTCPPacketInformation& rtcpPacketInformation)
-{
-    RTCPUtility::RTCPPacketTypes rtcpPacketType = rtcpParser.PacketType();
-    const RTCPUtility::RTCPPacket& rtcpPacket   = rtcpParser.Packet();
-
-    assert((rtcpPacketType == RTCPPacketTypes::kRr) ||
-           (rtcpPacketType == RTCPPacketTypes::kSr));
+void RTCPReceiver::HandleSenderReceiverReport(
+    RTCPUtility::RTCPParserV2& rtcpParser,
+    RTCPPacketInformation& rtcpPacketInformation) {
+  RTCPUtility::RTCPPacketTypes rtcpPacketType = rtcpParser.PacketType();
+  const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
 
-    // SR.SenderSSRC
-    // The synchronization source identifier for the originator of this SR packet
+  assert((rtcpPacketType == RTCPPacketTypes::kRr) ||
+         (rtcpPacketType == RTCPPacketTypes::kSr));
 
-    // rtcpPacket.RR.SenderSSRC
-    // The source of the packet sender, same as of SR? or is this a CE?
+  // SR.SenderSSRC
+  // The synchronization source identifier for the originator of this SR packet
 
-    const uint32_t remoteSSRC = (rtcpPacketType == RTCPPacketTypes::kRr)
-                                    ? rtcpPacket.RR.SenderSSRC
-                                    : rtcpPacket.SR.SenderSSRC;
+  // rtcpPacket.RR.SenderSSRC
+  // The source of the packet sender, same as of SR? or is this a CE?
 
-    rtcpPacketInformation.remoteSSRC = remoteSSRC;
+  const uint32_t remoteSSRC = (rtcpPacketType == RTCPPacketTypes::kRr)
+                                  ? rtcpPacket.RR.SenderSSRC
+                                  : rtcpPacket.SR.SenderSSRC;
 
-    RTCPReceiveInformation* ptrReceiveInfo = CreateReceiveInformation(remoteSSRC);
-    if (!ptrReceiveInfo)
-    {
-        rtcpParser.Iterate();
-        return;
-    }
+  rtcpPacketInformation.remoteSSRC = remoteSSRC;
 
-    if (rtcpPacketType == RTCPPacketTypes::kSr) {
-      TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "SR",
-                           "remote_ssrc", remoteSSRC, "ssrc", main_ssrc_);
+  RTCPReceiveInformation* ptrReceiveInfo = CreateReceiveInformation(remoteSSRC);
+  if (!ptrReceiveInfo) {
+    rtcpParser.Iterate();
+    return;
+  }
 
-        if (_remoteSSRC == remoteSSRC) // have I received RTP packets from this party
-        {
-            // only signal that we have received a SR when we accept one
-            rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpSr;
+  if (rtcpPacketType == RTCPPacketTypes::kSr) {
+    TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "SR",
+                         "remote_ssrc", remoteSSRC, "ssrc", main_ssrc_);
 
-            rtcpPacketInformation.ntp_secs = rtcpPacket.SR.NTPMostSignificant;
-            rtcpPacketInformation.ntp_frac = rtcpPacket.SR.NTPLeastSignificant;
-            rtcpPacketInformation.rtp_timestamp = rtcpPacket.SR.RTPTimestamp;
+    if (_remoteSSRC ==
+        remoteSSRC)  // have I received RTP packets from this party
+    {
+      // only signal that we have received a SR when we accept one
+      rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpSr;
 
-            // We will only store the send report from one source, but
-            // we will store all the receive block
+      rtcpPacketInformation.ntp_secs = rtcpPacket.SR.NTPMostSignificant;
+      rtcpPacketInformation.ntp_frac = rtcpPacket.SR.NTPLeastSignificant;
+      rtcpPacketInformation.rtp_timestamp = rtcpPacket.SR.RTPTimestamp;
 
-            // Save the NTP time of this report
-            _remoteSenderInfo.NTPseconds = rtcpPacket.SR.NTPMostSignificant;
-            _remoteSenderInfo.NTPfraction = rtcpPacket.SR.NTPLeastSignificant;
-            _remoteSenderInfo.RTPtimeStamp = rtcpPacket.SR.RTPTimestamp;
-            _remoteSenderInfo.sendPacketCount = rtcpPacket.SR.SenderPacketCount;
-            _remoteSenderInfo.sendOctetCount = rtcpPacket.SR.SenderOctetCount;
+      // We will only store the send report from one source, but
+      // we will store all the receive block
 
-            _clock->CurrentNtp(_lastReceivedSRNTPsecs, _lastReceivedSRNTPfrac);
-        }
-        else
-        {
-            rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpRr;
-        }
-    } else
-    {
-      TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "RR",
-                           "remote_ssrc", remoteSSRC, "ssrc", main_ssrc_);
+      // Save the NTP time of this report
+      _remoteSenderInfo.NTPseconds = rtcpPacket.SR.NTPMostSignificant;
+      _remoteSenderInfo.NTPfraction = rtcpPacket.SR.NTPLeastSignificant;
+      _remoteSenderInfo.RTPtimeStamp = rtcpPacket.SR.RTPTimestamp;
+      _remoteSenderInfo.sendPacketCount = rtcpPacket.SR.SenderPacketCount;
+      _remoteSenderInfo.sendOctetCount = rtcpPacket.SR.SenderOctetCount;
 
-        rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpRr;
+      _clock->CurrentNtp(_lastReceivedSRNTPsecs, _lastReceivedSRNTPfrac);
+    } else {
+      rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpRr;
     }
-    // Update that this remote is alive.
-    ptrReceiveInfo->last_time_received_ms = _clock->TimeInMilliseconds();
+  } else {
+    TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "RR",
+                         "remote_ssrc", remoteSSRC, "ssrc", main_ssrc_);
 
-    rtcpPacketType = rtcpParser.Iterate();
+    rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpRr;
+  }
+  // Update that this remote is alive.
+  ptrReceiveInfo->last_time_received_ms = _clock->TimeInMilliseconds();
 
-    while (rtcpPacketType == RTCPPacketTypes::kReportBlockItem) {
-        HandleReportBlock(rtcpPacket, rtcpPacketInformation, remoteSSRC);
-        rtcpPacketType = rtcpParser.Iterate();
-    }
+  rtcpPacketType = rtcpParser.Iterate();
+
+  while (rtcpPacketType == RTCPPacketTypes::kReportBlockItem) {
+    HandleReportBlock(rtcpPacket, rtcpPacketInformation, remoteSSRC);
+    rtcpPacketType = rtcpParser.Iterate();
+  }
 }
 
 void RTCPReceiver::HandleReportBlock(
@@ -477,12 +468,11 @@ void RTCPReceiver::HandleReportBlock(
     return;
   }
 
-  RTCPReportBlockInformation* reportBlock =
-      CreateOrGetReportBlockInformation(remoteSSRC,
-                                        rtcpPacket.ReportBlockItem.SSRC);
+  RTCPReportBlockInformation* reportBlock = CreateOrGetReportBlockInformation(
+      remoteSSRC, rtcpPacket.ReportBlockItem.SSRC);
   if (reportBlock == NULL) {
-    LOG(LS_WARNING) << "Failed to CreateReportBlockInformation("
-                    << remoteSSRC << ")";
+    LOG(LS_WARNING) << "Failed to CreateReportBlockInformation(" << remoteSSRC
+                    << ")";
     return;
   }
 
@@ -584,8 +574,8 @@ RTCPReportBlockInformation* RTCPReceiver::GetReportBlockInformation(
   return it_info->second;
 }
 
-RTCPCnameInformation*
-RTCPReceiver::CreateCnameInformation(uint32_t remoteSSRC) {
+RTCPCnameInformation* RTCPReceiver::CreateCnameInformation(
+    uint32_t remoteSSRC) {
   rtc::CritScope lock(&_criticalSectionRTCPReceiver);
 
   std::map<uint32_t, RTCPCnameInformation*>::iterator it =
@@ -600,8 +590,8 @@ RTCPReceiver::CreateCnameInformation(uint32_t remoteSSRC) {
   return cnameInfo;
 }
 
-RTCPCnameInformation*
-RTCPReceiver::GetCnameInformation(uint32_t remoteSSRC) const {
+RTCPCnameInformation* RTCPReceiver::GetCnameInformation(
+    uint32_t remoteSSRC) const {
   rtc::CritScope lock(&_criticalSectionRTCPReceiver);
 
   std::map<uint32_t, RTCPCnameInformation*>::const_iterator it =
@@ -613,8 +603,8 @@ RTCPReceiver::GetCnameInformation(uint32_t remoteSSRC) const {
   return it->second;
 }
 
-RTCPReceiveInformation*
-RTCPReceiver::CreateReceiveInformation(uint32_t remoteSSRC) {
+RTCPReceiveInformation* RTCPReceiver::CreateReceiveInformation(
+    uint32_t remoteSSRC) {
   rtc::CritScope lock(&_criticalSectionRTCPReceiver);
 
   std::map<uint32_t, RTCPReceiveInformation*>::iterator it =
@@ -628,8 +618,8 @@ RTCPReceiver::CreateReceiveInformation(uint32_t remoteSSRC) {
   return receiveInfo;
 }
 
-RTCPReceiveInformation*
-RTCPReceiver::GetReceiveInformation(uint32_t remoteSSRC) {
+RTCPReceiveInformation* RTCPReceiver::GetReceiveInformation(
+    uint32_t remoteSSRC) {
   rtc::CritScope lock(&_criticalSectionRTCPReceiver);
 
   std::map<uint32_t, RTCPReceiveInformation*>::iterator it =
@@ -660,8 +650,8 @@ bool RTCPReceiver::RtcpRrSequenceNumberTimeout(int64_t rtcp_interval_ms) {
     return false;
 
   int64_t time_out_ms = kRrTimeoutIntervals * rtcp_interval_ms;
-  if (_clock->TimeInMilliseconds() > _lastIncreasedSequenceNumberMs +
-      time_out_ms) {
+  if (_clock->TimeInMilliseconds() >
+      _lastIncreasedSequenceNumberMs + time_out_ms) {
     // Reset the timer to only trigger one log.
     _lastIncreasedSequenceNumberMs = 0;
     return true;
@@ -702,7 +692,7 @@ bool RTCPReceiver::UpdateRTCPReceiveInformationTimers() {
     } else if (receiveInfo->ready_for_delete) {
       // store our current receiveInfoItem
       std::map<uint32_t, RTCPReceiveInformation*>::iterator
-      receiveInfoItemToBeErased = receiveInfoIt;
+          receiveInfoItemToBeErased = receiveInfoIt;
       receiveInfoIt++;
       delete receiveInfoItemToBeErased->second;
       _receivedInfoMap.erase(receiveInfoItemToBeErased);
@@ -779,20 +769,20 @@ void RTCPReceiver::HandleNACK(RTCPUtility::RTCPParserV2& rtcpParser,
   }
 }
 
-void
-RTCPReceiver::HandleNACKItem(const RTCPUtility::RTCPPacket& rtcpPacket,
-                             RTCPPacketInformation& rtcpPacketInformation) {
+void RTCPReceiver::HandleNACKItem(
+    const RTCPUtility::RTCPPacket& rtcpPacket,
+    RTCPPacketInformation& rtcpPacketInformation) {
   rtcpPacketInformation.AddNACKPacket(rtcpPacket.NACKItem.PacketID);
   nack_stats_.ReportRequest(rtcpPacket.NACKItem.PacketID);
 
   uint16_t bitMask = rtcpPacket.NACKItem.BitMask;
   if (bitMask) {
-    for (int i=1; i <= 16; ++i) {
+    for (int i = 1; i <= 16; ++i) {
       if (bitMask & 0x01) {
         rtcpPacketInformation.AddNACKPacket(rtcpPacket.NACKItem.PacketID + i);
         nack_stats_.ReportRequest(rtcpPacket.NACKItem.PacketID + i);
       }
-      bitMask = bitMask >>1;
+      bitMask = bitMask >> 1;
     }
   }
   rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpNack;
@@ -805,8 +795,8 @@ void RTCPReceiver::HandleBYE(RTCPUtility::RTCPParserV2& rtcpParser) {
   ReportBlockMap::iterator it = _receivedReportBlockMap.begin();
   for (; it != _receivedReportBlockMap.end(); ++it) {
     ReportBlockInfoMap* info_map = &(it->second);
-    ReportBlockInfoMap::iterator it_info = info_map->find(
-        rtcpPacket.BYE.SenderSSRC);
+    ReportBlockInfoMap::iterator it_info =
+        info_map->find(rtcpPacket.BYE.SenderSSRC);
     if (it_info != info_map->end()) {
       delete it_info->second;
       info_map->erase(it_info);
@@ -906,45 +896,47 @@ void RTCPReceiver::HandleXrDlrrReportBlockItem(
   rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpXrDlrrReportBlock;
 }
 
-void
-RTCPReceiver::HandleXRVOIPMetric(RTCPUtility::RTCPParserV2& rtcpParser,
-                                 RTCPPacketInformation& rtcpPacketInformation)
-{
-    const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
+void RTCPReceiver::HandleXRVOIPMetric(
+    RTCPUtility::RTCPParserV2& rtcpParser,
+    RTCPPacketInformation& rtcpPacketInformation) {
+  const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
 
-    if(rtcpPacket.XRVOIPMetricItem.SSRC == main_ssrc_)
-    {
-        // Store VoIP metrics block if it's about me
-        // from OriginatorSSRC do we filter it?
-        // rtcpPacket.XR.OriginatorSSRC;
-
-        RTCPVoIPMetric receivedVoIPMetrics;
-        receivedVoIPMetrics.burstDensity = rtcpPacket.XRVOIPMetricItem.burstDensity;
-        receivedVoIPMetrics.burstDuration = rtcpPacket.XRVOIPMetricItem.burstDuration;
-        receivedVoIPMetrics.discardRate = rtcpPacket.XRVOIPMetricItem.discardRate;
-        receivedVoIPMetrics.endSystemDelay = rtcpPacket.XRVOIPMetricItem.endSystemDelay;
-        receivedVoIPMetrics.extRfactor = rtcpPacket.XRVOIPMetricItem.extRfactor;
-        receivedVoIPMetrics.gapDensity = rtcpPacket.XRVOIPMetricItem.gapDensity;
-        receivedVoIPMetrics.gapDuration = rtcpPacket.XRVOIPMetricItem.gapDuration;
-        receivedVoIPMetrics.Gmin = rtcpPacket.XRVOIPMetricItem.Gmin;
-        receivedVoIPMetrics.JBabsMax = rtcpPacket.XRVOIPMetricItem.JBabsMax;
-        receivedVoIPMetrics.JBmax = rtcpPacket.XRVOIPMetricItem.JBmax;
-        receivedVoIPMetrics.JBnominal = rtcpPacket.XRVOIPMetricItem.JBnominal;
-        receivedVoIPMetrics.lossRate = rtcpPacket.XRVOIPMetricItem.lossRate;
-        receivedVoIPMetrics.MOSCQ = rtcpPacket.XRVOIPMetricItem.MOSCQ;
-        receivedVoIPMetrics.MOSLQ = rtcpPacket.XRVOIPMetricItem.MOSLQ;
-        receivedVoIPMetrics.noiseLevel = rtcpPacket.XRVOIPMetricItem.noiseLevel;
-        receivedVoIPMetrics.RERL = rtcpPacket.XRVOIPMetricItem.RERL;
-        receivedVoIPMetrics.Rfactor = rtcpPacket.XRVOIPMetricItem.Rfactor;
-        receivedVoIPMetrics.roundTripDelay = rtcpPacket.XRVOIPMetricItem.roundTripDelay;
-        receivedVoIPMetrics.RXconfig = rtcpPacket.XRVOIPMetricItem.RXconfig;
-        receivedVoIPMetrics.signalLevel = rtcpPacket.XRVOIPMetricItem.signalLevel;
-
-        rtcpPacketInformation.AddVoIPMetric(&receivedVoIPMetrics);
-
-        rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpXrVoipMetric; // received signal
-    }
-    rtcpParser.Iterate();
+  if (rtcpPacket.XRVOIPMetricItem.SSRC == main_ssrc_) {
+    // Store VoIP metrics block if it's about me
+    // from OriginatorSSRC do we filter it?
+    // rtcpPacket.XR.OriginatorSSRC;
+
+    RTCPVoIPMetric receivedVoIPMetrics;
+    receivedVoIPMetrics.burstDensity = rtcpPacket.XRVOIPMetricItem.burstDensity;
+    receivedVoIPMetrics.burstDuration =
+        rtcpPacket.XRVOIPMetricItem.burstDuration;
+    receivedVoIPMetrics.discardRate = rtcpPacket.XRVOIPMetricItem.discardRate;
+    receivedVoIPMetrics.endSystemDelay =
+        rtcpPacket.XRVOIPMetricItem.endSystemDelay;
+    receivedVoIPMetrics.extRfactor = rtcpPacket.XRVOIPMetricItem.extRfactor;
+    receivedVoIPMetrics.gapDensity = rtcpPacket.XRVOIPMetricItem.gapDensity;
+    receivedVoIPMetrics.gapDuration = rtcpPacket.XRVOIPMetricItem.gapDuration;
+    receivedVoIPMetrics.Gmin = rtcpPacket.XRVOIPMetricItem.Gmin;
+    receivedVoIPMetrics.JBabsMax = rtcpPacket.XRVOIPMetricItem.JBabsMax;
+    receivedVoIPMetrics.JBmax = rtcpPacket.XRVOIPMetricItem.JBmax;
+    receivedVoIPMetrics.JBnominal = rtcpPacket.XRVOIPMetricItem.JBnominal;
+    receivedVoIPMetrics.lossRate = rtcpPacket.XRVOIPMetricItem.lossRate;
+    receivedVoIPMetrics.MOSCQ = rtcpPacket.XRVOIPMetricItem.MOSCQ;
+    receivedVoIPMetrics.MOSLQ = rtcpPacket.XRVOIPMetricItem.MOSLQ;
+    receivedVoIPMetrics.noiseLevel = rtcpPacket.XRVOIPMetricItem.noiseLevel;
+    receivedVoIPMetrics.RERL = rtcpPacket.XRVOIPMetricItem.RERL;
+    receivedVoIPMetrics.Rfactor = rtcpPacket.XRVOIPMetricItem.Rfactor;
+    receivedVoIPMetrics.roundTripDelay =
+        rtcpPacket.XRVOIPMetricItem.roundTripDelay;
+    receivedVoIPMetrics.RXconfig = rtcpPacket.XRVOIPMetricItem.RXconfig;
+    receivedVoIPMetrics.signalLevel = rtcpPacket.XRVOIPMetricItem.signalLevel;
+
+    rtcpPacketInformation.AddVoIPMetric(&receivedVoIPMetrics);
+
+    rtcpPacketInformation.rtcpPacketTypeFlags |=
+        kRtcpXrVoipMetric;  // received signal
+  }
+  rtcpParser.Iterate();
 }
 
 void RTCPReceiver::HandlePLI(RTCPUtility::RTCPParserV2& rtcpParser,
@@ -990,7 +982,8 @@ void RTCPReceiver::HandleTMMBR(RTCPUtility::RTCPParserV2& rtcpParser,
 
   RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
   while (pktType == RTCPPacketTypes::kRtpfbTmmbrItem) {
-    HandleTMMBRItem(*ptrReceiveInfo, rtcpPacket, rtcpPacketInformation, senderSSRC);
+    HandleTMMBRItem(*ptrReceiveInfo, rtcpPacket, rtcpPacketInformation,
+                    senderSSRC);
     pktType = rtcpParser.Iterate();
   }
 }
@@ -1014,8 +1007,8 @@ void RTCPReceiver::HandleTMMBRItem(RTCPReceiveInformation& receiveInfo,
 void RTCPReceiver::HandleTMMBN(RTCPUtility::RTCPParserV2& rtcpParser,
                                RTCPPacketInformation& rtcpPacketInformation) {
   const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
-  RTCPReceiveInformation* ptrReceiveInfo = GetReceiveInformation(
-      rtcpPacket.TMMBN.SenderSSRC);
+  RTCPReceiveInformation* ptrReceiveInfo =
+      GetReceiveInformation(rtcpPacket.TMMBN.SenderSSRC);
   if (ptrReceiveInfo == NULL) {
     // This remote SSRC must be saved before.
     rtcpParser.Iterate();
@@ -1067,37 +1060,37 @@ void RTCPReceiver::HandleSLI(RTCPUtility::RTCPParserV2& rtcpParser,
 void RTCPReceiver::HandleSLIItem(const RTCPUtility::RTCPPacket& rtcpPacket,
                                  RTCPPacketInformation& rtcpPacketInformation) {
   // in theory there could be multiple slices lost
-  rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpSli; // received signal that we need to refresh a slice
+  rtcpPacketInformation.rtcpPacketTypeFlags |=
+      kRtcpSli;  // received signal that we need to refresh a slice
   rtcpPacketInformation.sliPictureId = rtcpPacket.SLIItem.PictureId;
 }
 
-void
-RTCPReceiver::HandleRPSI(RTCPUtility::RTCPParserV2& rtcpParser,
-                         RTCPHelp::RTCPPacketInformation& rtcpPacketInformation)
-{
-    const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
-    RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
-    if (pktType == RTCPPacketTypes::kPsfbRpsiItem) {
-        if(rtcpPacket.RPSI.NumberOfValidBits%8 != 0)
-        {
-            // to us unknown
-            // continue
-            rtcpParser.Iterate();
-            return;
-        }
-        // Received signal that we have a confirmed reference picture.
-        rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpRpsi;
-        rtcpPacketInformation.rpsiPictureId = 0;
-
-        // convert NativeBitString to rpsiPictureId
-        uint8_t numberOfBytes = rtcpPacket.RPSI.NumberOfValidBits /8;
-        for(uint8_t n = 0; n < (numberOfBytes-1); n++)
-        {
-            rtcpPacketInformation.rpsiPictureId += (rtcpPacket.RPSI.NativeBitString[n] & 0x7f);
-            rtcpPacketInformation.rpsiPictureId <<= 7; // prepare next
-        }
-        rtcpPacketInformation.rpsiPictureId += (rtcpPacket.RPSI.NativeBitString[numberOfBytes-1] & 0x7f);
+void RTCPReceiver::HandleRPSI(
+    RTCPUtility::RTCPParserV2& rtcpParser,
+    RTCPHelp::RTCPPacketInformation& rtcpPacketInformation) {
+  const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
+  RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
+  if (pktType == RTCPPacketTypes::kPsfbRpsiItem) {
+    if (rtcpPacket.RPSI.NumberOfValidBits % 8 != 0) {
+      // to us unknown
+      // continue
+      rtcpParser.Iterate();
+      return;
     }
+    // Received signal that we have a confirmed reference picture.
+    rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpRpsi;
+    rtcpPacketInformation.rpsiPictureId = 0;
+
+    // convert NativeBitString to rpsiPictureId
+    uint8_t numberOfBytes = rtcpPacket.RPSI.NumberOfValidBits / 8;
+    for (uint8_t n = 0; n < (numberOfBytes - 1); n++) {
+      rtcpPacketInformation.rpsiPictureId +=
+          (rtcpPacket.RPSI.NativeBitString[n] & 0x7f);
+      rtcpPacketInformation.rpsiPictureId <<= 7;  // prepare next
+    }
+    rtcpPacketInformation.rpsiPictureId +=
+        (rtcpPacket.RPSI.NativeBitString[numberOfBytes - 1] & 0x7f);
+  }
 }
 
 void RTCPReceiver::HandlePsfbApp(RTCPUtility::RTCPParserV2& rtcpParser,
@@ -1127,7 +1120,7 @@ void RTCPReceiver::HandleIJItem(const RTCPUtility::RTCPPacket& rtcpPacket,
                                 RTCPPacketInformation& rtcpPacketInformation) {
   rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpTransmissionTimeOffset;
   rtcpPacketInformation.interArrivalJitter =
-  rtcpPacket.ExtendedJitterReportItem.Jitter;
+      rtcpPacket.ExtendedJitterReportItem.Jitter;
 }
 
 void RTCPReceiver::HandleREMBItem(
@@ -1199,7 +1192,8 @@ void RTCPReceiver::HandleAPPItem(RTCPUtility::RTCPParserV2& rtcpParser,
                                  RTCPPacketInformation& rtcpPacketInformation) {
   const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
 
-  rtcpPacketInformation.AddApplicationData(rtcpPacket.APP.Data, rtcpPacket.APP.Size);
+  rtcpPacketInformation.AddApplicationData(rtcpPacket.APP.Data,
+                                           rtcpPacket.APP.Size);
 
   rtcpParser.Iterate();
 }
@@ -1276,7 +1270,7 @@ void RTCPReceiver::TriggerCallbacksFromRTCPPacket(
       (rtcpPacketInformation.rtcpPacketTypeFlags & kRtcpNack)) {
     if (rtcpPacketInformation.nackSequenceNumbers.size() > 0) {
       LOG(LS_VERBOSE) << "Incoming NACK length: "
-                   << rtcpPacketInformation.nackSequenceNumbers.size();
+                      << rtcpPacketInformation.nackSequenceNumbers.size();
       _rtpRtcp.OnReceivedNACK(rtcpPacketInformation.nackSequenceNumbers);
     }
   }
@@ -1319,8 +1313,7 @@ void RTCPReceiver::TriggerCallbacksFromRTCPPacket(
           (rtcpPacketInformation.rtcpPacketTypeFlags & kRtcpRr)) {
         int64_t now = _clock->TimeInMilliseconds();
         _cbRtcpBandwidthObserver->OnReceivedRtcpReceiverReport(
-            rtcpPacketInformation.report_blocks,
-            rtcpPacketInformation.rtt,
+            rtcpPacketInformation.report_blocks, rtcpPacketInformation.rtt,
             now);
       }
     }
@@ -1345,9 +1338,8 @@ void RTCPReceiver::TriggerCallbacksFromRTCPPacket(
     rtc::CritScope cs(&_criticalSectionFeedbacks);
     if (stats_callback_) {
       for (ReportBlockList::const_iterator it =
-          rtcpPacketInformation.report_blocks.begin();
-          it != rtcpPacketInformation.report_blocks.end();
-          ++it) {
+               rtcpPacketInformation.report_blocks.begin();
+           it != rtcpPacketInformation.report_blocks.end(); ++it) {
         RtcpStatistics stats;
         stats.cumulative_lost = it->cumulativeLost;
         stats.extended_max_sequence_number = it->extendedHighSeqNum;