Reformat rtcp_receiver

webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc

 /*
  *  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 177 matching lines @@
   *rtt_ms = xr_rr_rtt_ms_;
   xr_rr_rtt_ms_ = 0;
   return true;
 }
 
 // TODO(pbos): Make this fail when we haven't received NTP.
 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(
     RtcpReceiveTimeInfo* info) const {
   assert(info);
   rtc::CritScope lock(&_criticalSectionRTCPReceiver);
   if (_lastReceivedXRNTPsecs == 0 && _lastReceivedXRNTPfrac == 0) {
     return false;
   }
 
   info->sourceSSRC = _remoteXRReceiveTimeInfo.sourceSSRC;
   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;
   _clock->CurrentNtp(ntp_sec, ntp_frac);
   uint32_t now = RTCPUtility::MidNtp(ntp_sec, ntp_frac);
 
   info->delaySinceLastRR = now - receive_time;
   return true;
 }
 
@@ skipping 17 matching lines @@
   for (; it != _receivedReportBlockMap.end(); ++it) {
     const ReportBlockInfoMap* info_map = &(it->second);
     ReportBlockInfoMap::const_iterator it_info = info_map->begin();
     for (; it_info != info_map->end(); ++it_info) {
       receiveBlocks->push_back(it_info->second->remoteReceiveBlock);
     }
   }
   return 0;
 }
 
-int32_t
-RTCPReceiver::IncomingRTCPPacket(RTCPPacketInformation& rtcpPacketInformation,
-                                 RTCPUtility::RTCPParserV2* rtcpParser)
-{
-    rtc::CritScope lock(&_criticalSectionRTCPReceiver);
+int32_t RTCPReceiver::IncomingRTCPPacket(
+    RTCPPacketInformation& rtcpPacketInformation,
+    RTCPUtility::RTCPParserV2* rtcpParser) {
+  rtc::CritScope lock(&_criticalSectionRTCPReceiver);
 
-    _lastReceived = _clock->TimeInMilliseconds();
+  _lastReceived = _clock->TimeInMilliseconds();
 
-    if (packet_type_counter_.first_packet_time_ms == -1) {
-      packet_type_counter_.first_packet_time_ms = _lastReceived;
+  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();
+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));
+  assert((rtcpPacketType == RTCPPacketTypes::kRr) ||
+         (rtcpPacketType == RTCPPacketTypes::kSr));
 
-    // SR.SenderSSRC
-    // The synchronization source identifier for the originator of this SR packet
+  // SR.SenderSSRC
+  // The synchronization source identifier for the originator of this SR packet
 
-    // rtcpPacket.RR.SenderSSRC
-    // The source of the packet sender, same as of SR? or is this a CE?
+  // rtcpPacket.RR.SenderSSRC
+  // The source of the packet sender, same as of SR? or is this a CE?
 
-    const uint32_t remoteSSRC = (rtcpPacketType == RTCPPacketTypes::kRr)
-                                    ? rtcpPacket.RR.SenderSSRC
-                                    : rtcpPacket.SR.SenderSSRC;
+  const uint32_t remoteSSRC = (rtcpPacketType == RTCPPacketTypes::kRr)
+                                  ? rtcpPacket.RR.SenderSSRC
+                                  : rtcpPacket.SR.SenderSSRC;
 
-    rtcpPacketInformation.remoteSSRC = remoteSSRC;
+  rtcpPacketInformation.remoteSSRC = remoteSSRC;
 
-    RTCPReceiveInformation* ptrReceiveInfo = CreateReceiveInformation(remoteSSRC);
-    if (!ptrReceiveInfo)
+  RTCPReceiveInformation* ptrReceiveInfo = CreateReceiveInformation(remoteSSRC);
+  if (!ptrReceiveInfo) {
+    rtcpParser.Iterate();
+    return;
+  }
+
+  if (rtcpPacketType == RTCPPacketTypes::kSr) {
+    TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "SR",
+                         "remote_ssrc", remoteSSRC, "ssrc", main_ssrc_);
+
+    if (_remoteSSRC ==
+        remoteSSRC)  // have I received RTP packets from this party
     {
-        rtcpParser.Iterate();
-        return;
+      // only signal that we have received a SR when we accept one
+      rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpSr;
+
+      rtcpPacketInformation.ntp_secs = rtcpPacket.SR.NTPMostSignificant;
+      rtcpPacketInformation.ntp_frac = rtcpPacket.SR.NTPLeastSignificant;
+      rtcpPacketInformation.rtp_timestamp = rtcpPacket.SR.RTPTimestamp;
+
+      // We will only store the send report from one source, but
+      // we will store all the receive block
+
+      // 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;
+
+      _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_);
 
-    if (rtcpPacketType == RTCPPacketTypes::kSr) {
-      TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "SR",
-                           "remote_ssrc", remoteSSRC, "ssrc", main_ssrc_);
+    rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpRr;
+  }
+  // Update that this remote is alive.
+  ptrReceiveInfo->last_time_received_ms = _clock->TimeInMilliseconds();
 
-        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;
+  rtcpPacketType = rtcpParser.Iterate();
 
-            rtcpPacketInformation.ntp_secs = rtcpPacket.SR.NTPMostSignificant;
-            rtcpPacketInformation.ntp_frac = rtcpPacket.SR.NTPLeastSignificant;
-            rtcpPacketInformation.rtp_timestamp = rtcpPacket.SR.RTPTimestamp;
-
-            // We will only store the send report from one source, but
-            // we will store all the receive block
-
-            // 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;
-
-            _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_);
-
-        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();
-
-    while (rtcpPacketType == RTCPPacketTypes::kReportBlockItem) {
-        HandleReportBlock(rtcpPacket, rtcpPacketInformation, remoteSSRC);
-        rtcpPacketType = rtcpParser.Iterate();
-    }
+  }
 }
 
 void RTCPReceiver::HandleReportBlock(
     const RTCPUtility::RTCPPacket& rtcpPacket,
     RTCPPacketInformation& rtcpPacketInformation,
     uint32_t remoteSSRC)
     EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver) {
   // This will be called once per report block in the RTCP packet.
   // We filter out all report blocks that are not for us.
   // Each packet has max 31 RR blocks.
   //
   // We can calc RTT if we send a send report and get a report block back.
 
   // |rtcpPacket.ReportBlockItem.SSRC| is the SSRC identifier of the source to
   // which the information in this reception report block pertains.
 
   // Filter out all report blocks that are not for us.
   if (registered_ssrcs_.find(rtcpPacket.ReportBlockItem.SSRC) ==
       registered_ssrcs_.end()) {
     // This block is not for us ignore it.
     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;
   }
 
   _lastReceivedRrMs = _clock->TimeInMilliseconds();
   const RTCPPacketReportBlockItem& rb = rtcpPacket.ReportBlockItem;
   reportBlock->remoteReceiveBlock.remoteSSRC = remoteSSRC;
   reportBlock->remoteReceiveBlock.sourceSSRC = rb.SSRC;
   reportBlock->remoteReceiveBlock.fractionLost = rb.FractionLost;
   reportBlock->remoteReceiveBlock.cumulativeLost =
       rb.CumulativeNumOfPacketsLost;
@@ skipping 81 matching lines @@
     return NULL;
   }
   const ReportBlockInfoMap* info_map = &(it->second);
   ReportBlockInfoMap::const_iterator it_info = info_map->find(remote_ssrc);
   if (it_info == info_map->end()) {
     return NULL;
   }
   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 =
       _receivedCnameMap.find(remoteSSRC);
 
   if (it != _receivedCnameMap.end()) {
     return it->second;
   }
   RTCPCnameInformation* cnameInfo = new RTCPCnameInformation;
   memset(cnameInfo->name, 0, RTCP_CNAME_SIZE);
   _receivedCnameMap[remoteSSRC] = cnameInfo;
   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 =
       _receivedCnameMap.find(remoteSSRC);
 
   if (it == _receivedCnameMap.end()) {
     return NULL;
   }
   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 =
       _receivedInfoMap.find(remoteSSRC);
 
   if (it != _receivedInfoMap.end()) {
     return it->second;
   }
   RTCPReceiveInformation* receiveInfo = new RTCPReceiveInformation;
   _receivedInfoMap[remoteSSRC] = receiveInfo;
   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 =
       _receivedInfoMap.find(remoteSSRC);
   if (it == _receivedInfoMap.end()) {
     return NULL;
   }
   return it->second;
 }
 
@@ skipping 10 matching lines @@
   }
   return false;
 }
 
 bool RTCPReceiver::RtcpRrSequenceNumberTimeout(int64_t rtcp_interval_ms) {
   rtc::CritScope lock(&_criticalSectionRTCPReceiver);
   if (_lastIncreasedSequenceNumberMs == 0)
     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;
   }
   return false;
 }
 
 bool RTCPReceiver::UpdateRTCPReceiveInformationTimers() {
   rtc::CritScope lock(&_criticalSectionRTCPReceiver);
 
@@ skipping 20 matching lines @@
         receiveInfo->ClearTmmbr();
         // prevent that we call this over and over again
         receiveInfo->last_time_received_ms = 0;
         // send new TMMBN to all channels using the default codec
         updateBoundingSet = true;
       }
       receiveInfoIt++;
     } 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);
     } else {
       receiveInfoIt++;
     }
   }
   return updateBoundingSet;
 }
 
@@ skipping 56 matching lines @@
     pktType = rtcpParser.Iterate();
   }
 
   if (rtcpPacketInformation.rtcpPacketTypeFlags & kRtcpNack) {
     ++packet_type_counter_.nack_packets;
     packet_type_counter_.nack_requests = nack_stats_.requests();
     packet_type_counter_.unique_nack_requests = nack_stats_.unique_requests();
   }
 }
 
-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;
 }
 
 void RTCPReceiver::HandleBYE(RTCPUtility::RTCPParserV2& rtcpParser) {
   const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
 
   // clear our lists
   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);
     }
   }
 
   //  we can't delete it due to TMMBR
   std::map<uint32_t, RTCPReceiveInformation*>::iterator receiveInfoIt =
       _receivedInfoMap.find(rtcpPacket.BYE.SenderSSRC);
 
@@ skipping 79 matching lines @@
 
   uint32_t delay_rr = packet.XRDLRRReportBlockItem.DelayLastRR;
   uint32_t now = CompactNtp(NtpTime(*_clock));
 
   uint32_t rtt_ntp = now - delay_rr - send_time;
   xr_rr_rtt_ms_ = CompactNtpRttToMs(rtt_ntp);
 
   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;
+  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;
+    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.AddVoIPMetric(&receivedVoIPMetrics);
 
-        rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpXrVoipMetric; // received signal
-    }
-    rtcpParser.Iterate();
+    rtcpPacketInformation.rtcpPacketTypeFlags |=
+        kRtcpXrVoipMetric;  // received signal
+  }
+  rtcpParser.Iterate();
 }
 
 void RTCPReceiver::HandlePLI(RTCPUtility::RTCPParserV2& rtcpParser,
                              RTCPPacketInformation& rtcpPacketInformation) {
   const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
   if (main_ssrc_ == rtcpPacket.PLI.MediaSSRC) {
     TRACE_EVENT_INSTANT0(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "PLI");
 
     ++packet_type_counter_.pli_packets;
     // Received a signal that we need to send a new key frame.
@@ skipping 25 matching lines @@
 
   // sanity, we can't have more than what's in one packet
   if (maxNumOfTMMBRBlocks > 200) {
     assert(false);
     rtcpParser.Iterate();
     return;
   }
 
   RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
   while (pktType == RTCPPacketTypes::kRtpfbTmmbrItem) {
-    HandleTMMBRItem(*ptrReceiveInfo, rtcpPacket, rtcpPacketInformation, senderSSRC);
+    HandleTMMBRItem(*ptrReceiveInfo, rtcpPacket, rtcpPacketInformation,
+                    senderSSRC);
     pktType = rtcpParser.Iterate();
   }
 }
 
 void RTCPReceiver::HandleTMMBRItem(RTCPReceiveInformation& receiveInfo,
                                    const RTCPUtility::RTCPPacket& rtcpPacket,
                                    RTCPPacketInformation& rtcpPacketInformation,
                                    uint32_t senderSSRC) {
   if (main_ssrc_ == rtcpPacket.TMMBRItem.SSRC &&
       rtcpPacket.TMMBRItem.MaxTotalMediaBitRate > 0) {
     receiveInfo.InsertTmmbrItem(
         senderSSRC,
         rtcp::TmmbItem(rtcpPacket.TMMBRItem.SSRC,
                        rtcpPacket.TMMBRItem.MaxTotalMediaBitRate * 1000,
                        rtcpPacket.TMMBRItem.MeasuredOverhead),
         _clock->TimeInMilliseconds());
     rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpTmmbr;
   }
 }
 
 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();
     return;
   }
   rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpTmmbn;
   // Use packet length to calc max number of TMMBN blocks
   // each TMMBN block is 8 bytes
   ptrdiff_t maxNumOfTMMBNBlocks = rtcpParser.LengthLeft() / 8;
 
@@ skipping 31 matching lines @@
   RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
   while (pktType == RTCPPacketTypes::kPsfbSliItem) {
     HandleSLIItem(rtcpPacket, rtcpPacketInformation);
     pktType = rtcpParser.Iterate();
   }
 }
 
 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;
+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);
+    // 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,
                                  RTCPPacketInformation& rtcpPacketInformation) {
   RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
   if (pktType == RTCPPacketTypes::kPsfbRemb) {
     pktType = rtcpParser.Iterate();
     if (pktType == RTCPPacketTypes::kPsfbRembItem) {
       HandleREMBItem(rtcpParser, rtcpPacketInformation);
       rtcpParser.Iterate();
     }
   }
 }
 
 void RTCPReceiver::HandleIJ(RTCPUtility::RTCPParserV2& rtcpParser,
                             RTCPPacketInformation& rtcpPacketInformation) {
   const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
 
   RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
   while (pktType == RTCPPacketTypes::kExtendedIjItem) {
     HandleIJItem(rtcpPacket, rtcpPacketInformation);
     pktType = rtcpParser.Iterate();
   }
 }
 
 void RTCPReceiver::HandleIJItem(const RTCPUtility::RTCPPacket& rtcpPacket,
                                 RTCPPacketInformation& rtcpPacketInformation) {
   rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpTransmissionTimeOffset;
   rtcpPacketInformation.interArrivalJitter =
-  rtcpPacket.ExtendedJitterReportItem.Jitter;
+      rtcpPacket.ExtendedJitterReportItem.Jitter;
 }
 
 void RTCPReceiver::HandleREMBItem(
     RTCPUtility::RTCPParserV2& rtcpParser,
     RTCPPacketInformation& rtcpPacketInformation) {
   const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
   rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpRemb;
   rtcpPacketInformation.receiverEstimatedMaxBitrate =
       rtcpPacket.REMBItem.BitRate;
 }
@@ skipping 51 matching lines @@
   rtcpPacketInformation.applicationSubType = rtcpPacket.APP.SubType;
   rtcpPacketInformation.applicationName = rtcpPacket.APP.Name;
 
   rtcpParser.Iterate();
 }
 
 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();
 }
 
 void RTCPReceiver::HandleTransportFeedback(
     RTCPUtility::RTCPParserV2* rtcp_parser,
     RTCPHelp::RTCPPacketInformation* rtcp_packet_information) {
   rtcp::RtcpPacket* packet = rtcp_parser->ReleaseRtcpPacket();
   RTC_DCHECK(packet != nullptr);
   rtcp_packet_information->rtcpPacketTypeFlags |= kRtcpTransportFeedback;
@@ skipping 56 matching lines @@
     registered_ssrcs = registered_ssrcs_;
   }
   if (!receiver_only_ &&
       (rtcpPacketInformation.rtcpPacketTypeFlags & kRtcpSrReq)) {
     _rtpRtcp.OnRequestSendReport();
   }
   if (!receiver_only_ &&
       (rtcpPacketInformation.rtcpPacketTypeFlags & kRtcpNack)) {
     if (rtcpPacketInformation.nackSequenceNumbers.size() > 0) {
       LOG(LS_VERBOSE) << "Incoming NACK length: "
-                   << rtcpPacketInformation.nackSequenceNumbers.size();
+                      << rtcpPacketInformation.nackSequenceNumbers.size();
       _rtpRtcp.OnReceivedNACK(rtcpPacketInformation.nackSequenceNumbers);
     }
   }
   {
     // We need feedback that we have received a report block(s) so that we
     // can generate a new packet in a conference relay scenario, one received
     // report can generate several RTCP packets, based on number relayed/mixed
     // a send report block should go out to all receivers.
     if (_cbRtcpIntraFrameObserver) {
       RTC_DCHECK(!receiver_only_);
@@ skipping 22 matching lines @@
       if (rtcpPacketInformation.rtcpPacketTypeFlags & kRtcpRemb) {
         LOG(LS_VERBOSE) << "Incoming REMB: "
                         << rtcpPacketInformation.receiverEstimatedMaxBitrate;
         _cbRtcpBandwidthObserver->OnReceivedEstimatedBitrate(
             rtcpPacketInformation.receiverEstimatedMaxBitrate);
       }
       if ((rtcpPacketInformation.rtcpPacketTypeFlags & kRtcpSr) ||
           (rtcpPacketInformation.rtcpPacketTypeFlags & kRtcpRr)) {
         int64_t now = _clock->TimeInMilliseconds();
         _cbRtcpBandwidthObserver->OnReceivedRtcpReceiverReport(
-            rtcpPacketInformation.report_blocks,
-            rtcpPacketInformation.rtt,
+            rtcpPacketInformation.report_blocks, rtcpPacketInformation.rtt,
             now);
       }
     }
     if ((rtcpPacketInformation.rtcpPacketTypeFlags & kRtcpSr) ||
         (rtcpPacketInformation.rtcpPacketTypeFlags & kRtcpRr)) {
       _rtpRtcp.OnReceivedRtcpReportBlocks(rtcpPacketInformation.report_blocks);
     }
 
     if (_cbTransportFeedbackObserver &&
         (rtcpPacketInformation.rtcpPacketTypeFlags & kRtcpTransportFeedback)) {
       uint32_t media_source_ssrc =
           rtcpPacketInformation.transport_feedback_->GetMediaSourceSsrc();
       if (media_source_ssrc == local_ssrc ||
           registered_ssrcs.find(media_source_ssrc) != registered_ssrcs.end()) {
         _cbTransportFeedbackObserver->OnTransportFeedback(
             *rtcpPacketInformation.transport_feedback_.get());
       }
     }
   }
 
   if (!receiver_only_) {
     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;
         stats.fraction_lost = it->fractionLost;
         stats.jitter = it->jitter;
 
         stats_callback_->StatisticsUpdated(stats, it->sourceSSRC);
       }
     }
   }
@@ skipping 21 matching lines @@
 
   for (const auto& kv : _receivedInfoMap) {
     RTCPReceiveInformation* receive_info = kv.second;
     RTC_DCHECK(receive_info);
     receive_info->GetTmmbrSet(now_ms, &candidates);
   }
   return candidates;
 }
 
 }  // namespace webrtc