Avoid data race in RtcpReceiver.

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 369 matching lines @@
       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;
 }
 
-// no need for critsect we have _criticalSectionRTCPReceiver
 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));
 
@@ skipping 55 matching lines @@
     UpdateReceiveInformation(*ptrReceiveInfo);
 
     rtcpPacketType = rtcpParser.Iterate();
 
     while (rtcpPacketType == RTCPPacketTypes::kReportBlockItem) {
         HandleReportBlock(rtcpPacket, rtcpPacketInformation, remoteSSRC);
         rtcpPacketType = rtcpParser.Iterate();
     }
 }
 
-// no need for critsect we have _criticalSectionRTCPReceiver
 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 291 matching lines @@
       }
       boundingSetRec->SetEntry(i,
                                receiveInfo->TmmbnBoundingSet.Tmmbr(i),
                                receiveInfo->TmmbnBoundingSet.PacketOH(i),
                                receiveInfo->TmmbnBoundingSet.Ssrc(i));
     }
   }
   return receiveInfo->TmmbnBoundingSet.lengthOfSet();
 }
 
-// no need for critsect we have _criticalSectionRTCPReceiver
 void RTCPReceiver::HandleSDES(RTCPUtility::RTCPParserV2& rtcpParser,
                               RTCPPacketInformation& rtcpPacketInformation) {
   RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
   while (pktType == RTCPPacketTypes::kSdesChunk) {
     HandleSDESChunk(rtcpParser);
     pktType = rtcpParser.Iterate();
   }
   rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpSdes;
 }
 
-// no need for critsect we have _criticalSectionRTCPReceiver
 void RTCPReceiver::HandleSDESChunk(RTCPUtility::RTCPParserV2& rtcpParser) {
   const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
   RTCPCnameInformation* cnameInfo =
       CreateCnameInformation(rtcpPacket.CName.SenderSSRC);
   assert(cnameInfo);
 
   cnameInfo->name[RTCP_CNAME_SIZE - 1] = 0;
   strncpy(cnameInfo->name, rtcpPacket.CName.CName, RTCP_CNAME_SIZE - 1);
   {
     CriticalSectionScoped lock(_criticalSectionFeedbacks);
     if (stats_callback_ != NULL) {
       stats_callback_->CNameChanged(rtcpPacket.CName.CName,
                                     rtcpPacket.CName.SenderSSRC);
     }
   }
 }
 
-// no need for critsect we have _criticalSectionRTCPReceiver
 void RTCPReceiver::HandleNACK(RTCPUtility::RTCPParserV2& rtcpParser,
                               RTCPPacketInformation& rtcpPacketInformation) {
   const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
   if (receiver_only_ || main_ssrc_ != rtcpPacket.NACK.MediaSSRC) {
     // Not to us.
     rtcpParser.Iterate();
     return;
   }
   rtcpPacketInformation.ResetNACKPacketIdArray();
 
   RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
   while (pktType == RTCPPacketTypes::kRtpfbNackItem) {
     HandleNACKItem(rtcpPacket, rtcpPacketInformation);
     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();
   }
 }
 
-// no need for critsect we have _criticalSectionRTCPReceiver
 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) {
       if (bitMask & 0x01) {
         rtcpPacketInformation.AddNACKPacket(rtcpPacket.NACKItem.PacketID + i);
         nack_stats_.ReportRequest(rtcpPacket.NACKItem.PacketID + i);
       }
       bitMask = bitMask >>1;
     }
   }
   rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpNack;
 }
 
-// no need for critsect we have _criticalSectionRTCPReceiver
 void RTCPReceiver::HandleBYE(RTCPUtility::RTCPParserV2& rtcpParser) {
   const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
 
   // clear our lists
-  CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
   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);
     if (it_info != info_map->end()) {
       delete it_info->second;
       info_map->erase(it_info);
     }
   }
@@ skipping 90 matching lines @@
       (((packet.XRDLRRReportBlockItem.DelayLastRR & 0x0000ffff) * 1000) >> 16) +
       (((packet.XRDLRRReportBlockItem.DelayLastRR & 0xffff0000) >> 16) * 1000);
 
   int64_t rtt = _clock->CurrentNtpInMilliseconds() - delay_rr_ms - send_time_ms;
 
   xr_rr_rtt_ms_ = std::max<int64_t>(rtt, 1);
 
   rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpXrDlrrReportBlock;
 }
 
-// no need for critsect we have _criticalSectionRTCPReceiver
 void
 RTCPReceiver::HandleXRVOIPMetric(RTCPUtility::RTCPParserV2& rtcpParser,
                                  RTCPPacketInformation& rtcpPacketInformation)
 {
     const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
 
-    CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
-
     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;
@@ skipping 15 matching lines @@
         receivedVoIPMetrics.RXconfig = rtcpPacket.XRVOIPMetricItem.RXconfig;
         receivedVoIPMetrics.signalLevel = rtcpPacket.XRVOIPMetricItem.signalLevel;
 
         rtcpPacketInformation.AddVoIPMetric(&receivedVoIPMetrics);
 
         rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpXrVoipMetric; // received signal
     }
     rtcpParser.Iterate();
 }
 
-// no need for critsect we have _criticalSectionRTCPReceiver
 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.
     rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpPli;
   }
   rtcpParser.Iterate();
 }
 
-// no need for critsect we have _criticalSectionRTCPReceiver
 void RTCPReceiver::HandleTMMBR(RTCPUtility::RTCPParserV2& rtcpParser,
                                RTCPPacketInformation& rtcpPacketInformation) {
   const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
 
   uint32_t senderSSRC = rtcpPacket.TMMBR.SenderSSRC;
   RTCPReceiveInformation* ptrReceiveInfo = GetReceiveInformation(senderSSRC);
   if (ptrReceiveInfo == NULL) {
     // This remote SSRC must be saved before.
     rtcpParser.Iterate();
     return;
@@ skipping 16 matching lines @@
   }
   ptrReceiveInfo->VerifyAndAllocateTMMBRSet((uint32_t)maxNumOfTMMBRBlocks);
 
   RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
   while (pktType == RTCPPacketTypes::kRtpfbTmmbrItem) {
     HandleTMMBRItem(*ptrReceiveInfo, rtcpPacket, rtcpPacketInformation, senderSSRC);
     pktType = rtcpParser.Iterate();
   }
 }
 
-// no need for critsect we have _criticalSectionRTCPReceiver
 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, rtcpPacket.TMMBRItem,
                                 _clock->TimeInMilliseconds());
     rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpTmmbr;
   }
 }
 
-// no need for critsect we have _criticalSectionRTCPReceiver
 void RTCPReceiver::HandleTMMBN(RTCPUtility::RTCPParserV2& rtcpParser,
                                RTCPPacketInformation& rtcpPacketInformation) {
   const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
   RTCPReceiveInformation* ptrReceiveInfo = GetReceiveInformation(
       rtcpPacket.TMMBN.SenderSSRC);
   if (ptrReceiveInfo == NULL) {
     // This remote SSRC must be saved before.
     rtcpParser.Iterate();
     return;
   }
@@ skipping 11 matching lines @@
 
   ptrReceiveInfo->VerifyAndAllocateBoundingSet((uint32_t)maxNumOfTMMBNBlocks);
 
   RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
   while (pktType == RTCPPacketTypes::kRtpfbTmmbnItem) {
     HandleTMMBNItem(*ptrReceiveInfo, rtcpPacket);
     pktType = rtcpParser.Iterate();
   }
 }
 
-// no need for critsect we have _criticalSectionRTCPReceiver
 void RTCPReceiver::HandleSR_REQ(RTCPUtility::RTCPParserV2& rtcpParser,
                                 RTCPPacketInformation& rtcpPacketInformation) {
   rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpSrReq;
   rtcpParser.Iterate();
 }
 
-// no need for critsect we have _criticalSectionRTCPReceiver
 void RTCPReceiver::HandleTMMBNItem(RTCPReceiveInformation& receiveInfo,
                                    const RTCPUtility::RTCPPacket& rtcpPacket) {
   receiveInfo.TmmbnBoundingSet.AddEntry(
       rtcpPacket.TMMBNItem.MaxTotalMediaBitRate,
       rtcpPacket.TMMBNItem.MeasuredOverhead,
       rtcpPacket.TMMBNItem.SSRC);
 }
 
-// no need for critsect we have _criticalSectionRTCPReceiver
 void RTCPReceiver::HandleSLI(RTCPUtility::RTCPParserV2& rtcpParser,
                              RTCPPacketInformation& rtcpPacketInformation) {
   const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
   RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
   while (pktType == RTCPPacketTypes::kPsfbSliItem) {
     HandleSLIItem(rtcpPacket, rtcpPacketInformation);
     pktType = rtcpParser.Iterate();
   }
 }
 
-// no need for critsect we have _criticalSectionRTCPReceiver
 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.sliPictureId = rtcpPacket.SLIItem.PictureId;
 }
 
 void
 RTCPReceiver::HandleRPSI(RTCPUtility::RTCPParserV2& rtcpParser,
                          RTCPHelp::RTCPPacketInformation& rtcpPacketInformation)
@@ skipping 15 matching lines @@
         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);
     }
 }
 
-// no need for critsect we have _criticalSectionRTCPReceiver
 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();
     }
   }
 }
 
-// no need for critsect we have _criticalSectionRTCPReceiver
 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;
 }
 
 void RTCPReceiver::HandleREMBItem(
     RTCPUtility::RTCPParserV2& rtcpParser,
     RTCPPacketInformation& rtcpPacketInformation) {
   const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
   rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpRemb;
   rtcpPacketInformation.receiverEstimatedMaxBitrate =
       rtcpPacket.REMBItem.BitRate;
 }
 
-// no need for critsect we have _criticalSectionRTCPReceiver
 void RTCPReceiver::HandleFIR(RTCPUtility::RTCPParserV2& rtcpParser,
                              RTCPPacketInformation& rtcpPacketInformation) {
   const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
   RTCPReceiveInformation* ptrReceiveInfo =
       GetReceiveInformation(rtcpPacket.FIR.SenderSSRC);
 
   RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
   while (pktType == RTCPPacketTypes::kPsfbFirItem) {
     HandleFIRItem(ptrReceiveInfo, rtcpPacket, rtcpPacketInformation);
     pktType = rtcpParser.Iterate();
   }
 }
 
-// no need for critsect we have _criticalSectionRTCPReceiver
 void RTCPReceiver::HandleFIRItem(RTCPReceiveInformation* receiveInfo,
                                  const RTCPUtility::RTCPPacket& rtcpPacket,
                                  RTCPPacketInformation& rtcpPacketInformation) {
   // Is it our sender that is requested to generate a new keyframe
   if (main_ssrc_ != rtcpPacket.FIRItem.SSRC) {
     return;
   }
 
   ++packet_type_counter_.fir_packets;
 
@@ skipping 105 matching lines @@
 
 // Holding no Critical section
 void RTCPReceiver::TriggerCallbacksFromRTCPPacket(
     RTCPPacketInformation& rtcpPacketInformation) {
   // Process TMMBR and REMB first to avoid multiple callbacks
   // to OnNetworkChanged.
   if (rtcpPacketInformation.rtcpPacketTypeFlags & kRtcpTmmbr) {
     // Might trigger a OnReceivedBandwidthEstimateUpdate.
     UpdateTMMBR();
   }
-  unsigned int local_ssrc;
+  uint32_t local_ssrc;
+  std::set<uint32_t> registered_ssrcs;
   {
     // We don't want to hold this critsect when triggering the callbacks below.
     CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
     local_ssrc = main_ssrc_;
+    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();
@@ skipping 41 matching lines @@
         _cbRtcpBandwidthObserver->OnReceivedRtcpReceiverReport(
             rtcpPacketInformation.report_blocks,
             rtcpPacketInformation.rtt,
             now);
       }
     }
     if (_cbTransportFeedbackObserver &&
         (rtcpPacketInformation.rtcpPacketTypeFlags & kRtcpTransportFeedback)) {
       uint32_t media_source_ssrc =
           rtcpPacketInformation.transport_feedback_->GetMediaSourceSsrc();
-      if (media_source_ssrc == main_ssrc_ ||
-          registered_ssrcs_.find(media_source_ssrc) !=
-              registered_ssrcs_.end()) {
+      if (media_source_ssrc == local_ssrc ||
+          registered_ssrcs.find(media_source_ssrc) != registered_ssrcs.end()) {
         _cbTransportFeedbackObserver->OnTransportFeedback(
             *rtcpPacketInformation.transport_feedback_.get());
       }
     }
   }
 
   if (!receiver_only_) {
     CriticalSectionScoped cs(_criticalSectionFeedbacks);
     if (stats_callback_) {
       for (ReportBlockList::const_iterator it =
@@ skipping 60 matching lines @@
         return -1;
       }
       num += receiveInfo->TmmbrSet.lengthOfSet();
       receiveInfoIt++;
     }
   }
   return num;
 }
 
 }  // namespace webrtc