Split RtcpReceiver::HandleSenderReceiverReport into two functions

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 281 matching lines @@
   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:
+        HandleSenderReport(*rtcpParser, rtcpPacketInformation);
+        break;
       case RTCPPacketTypes::kRr:
-        HandleSenderReceiverReport(*rtcpParser, rtcpPacketInformation);
+        HandleReceiverReport(*rtcpParser, rtcpPacketInformation);
         break;
       case RTCPPacketTypes::kSdes:
         HandleSDES(*rtcpParser, rtcpPacketInformation);
         break;
       case RTCPPacketTypes::kXrHeader:
         HandleXrHeader(*rtcpParser, rtcpPacketInformation);
         break;
       case RTCPPacketTypes::kXrReceiverReferenceTime:
         HandleXrReceiveReferenceTime(*rtcpParser, rtcpPacketInformation);
         break;
@@ skipping 53 matching lines @@
     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;
 }
 
-void RTCPReceiver::HandleSenderReceiverReport(
+void RTCPReceiver::HandleSenderReport(
     RTCPUtility::RTCPParserV2& rtcpParser,
     RTCPPacketInformation& rtcpPacketInformation) {
   RTCPUtility::RTCPPacketTypes rtcpPacketType = rtcpParser.PacketType();
   const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
 
-  assert((rtcpPacketType == RTCPPacketTypes::kRr) ||
-         (rtcpPacketType == RTCPPacketTypes::kSr));
+  RTC_DCHECK(rtcpPacketType == RTCPPacketTypes::kSr);
 
   // 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?
-
-  const uint32_t remoteSSRC = (rtcpPacketType == RTCPPacketTypes::kRr)
-                                  ? rtcpPacket.RR.SenderSSRC
-                                  : rtcpPacket.SR.SenderSSRC;
+  const uint32_t remoteSSRC = rtcpPacket.SR.SenderSSRC;
 
   rtcpPacketInformation.remoteSSRC = remoteSSRC;
 
   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_);
+  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
-    {
-      // only signal that we have received a SR when we accept one
-      rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpSr;
+  if (_remoteSSRC ==
+      remoteSSRC)  // have I received RTP packets from this party

[philipel, 2016/09/15 11:58:19]

format

[danilchap, 2016/09/15 12:17:30]

Done.

+  {
+    // 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;
+    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
+    // 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;
+    // 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;
-    }
+    _clock->CurrentNtp(_lastReceivedSRNTPsecs, _lastReceivedSRNTPfrac);
   } else {
-    TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "RR",
-                         "remote_ssrc", remoteSSRC, "ssrc", main_ssrc_);
-
     rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpRr;

[philipel, 2016/09/15 11:58:19]

This line look suspicious, do we say that this rtcp packet contains a receiver
report or whats going on? 

[danilchap, 2016/09/15 12:17:30]

This behavior is unchanged.
Treat sender report as receiver report if it come from unexpected ssrc.
Means still collect report blocks and notify interested observes about them.
Comment about it moved closer to this line.

   }
   // Update that this remote is alive.
   ptrReceiveInfo->last_time_received_ms = _clock->TimeInMilliseconds();
 
   rtcpPacketType = rtcpParser.Iterate();
 
   while (rtcpPacketType == RTCPPacketTypes::kReportBlockItem) {
     HandleReportBlock(rtcpPacket, rtcpPacketInformation, remoteSSRC);
     rtcpPacketType = rtcpParser.Iterate();
   }
 }
 
+void RTCPReceiver::HandleReceiverReport(
+    RTCPUtility::RTCPParserV2& rtcpParser,
+    RTCPPacketInformation& rtcpPacketInformation) {
+  RTCPUtility::RTCPPacketTypes rtcpPacketType = rtcpParser.PacketType();
+  const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
+
+  RTC_DCHECK(rtcpPacketType == RTCPPacketTypes::kRr);
+
+  // rtcpPacket.RR.SenderSSRC
+  // The source of the packet sender, same as of SR? or is this a CE?
+
+  const uint32_t remoteSSRC = rtcpPacket.RR.SenderSSRC;
+
+  rtcpPacketInformation.remoteSSRC = remoteSSRC;
+
+  RTCPReceiveInformation* ptrReceiveInfo = CreateReceiveInformation(remoteSSRC);
+  if (!ptrReceiveInfo) {
+    rtcpParser.Iterate();
+    return;
+  }
+
+  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();
+
+  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.
@@ skipping 824 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