Replaced CriticalSectionWrapper with rtc::CriticalSection in rtp_rtcp module

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 31 matching lines @@
     RtcpPacketTypeCounterObserver* packet_type_counter_observer,
     RtcpBandwidthObserver* rtcp_bandwidth_observer,
     RtcpIntraFrameObserver* rtcp_intra_frame_observer,
     TransportFeedbackObserver* transport_feedback_observer,
     ModuleRtpRtcpImpl* owner)
     : TMMBRHelp(),
       _clock(clock),
       receiver_only_(receiver_only),
       _lastReceived(0),
       _rtpRtcp(*owner),
-      _criticalSectionFeedbacks(
-          CriticalSectionWrapper::CreateCriticalSection()),
       _cbRtcpBandwidthObserver(rtcp_bandwidth_observer),
       _cbRtcpIntraFrameObserver(rtcp_intra_frame_observer),
       _cbTransportFeedbackObserver(transport_feedback_observer),
-      _criticalSectionRTCPReceiver(
-          CriticalSectionWrapper::CreateCriticalSection()),
       main_ssrc_(0),
       _remoteSSRC(0),
       _remoteSenderInfo(),
       _lastReceivedSRNTPsecs(0),
       _lastReceivedSRNTPfrac(0),
       _lastReceivedXRNTPsecs(0),
       _lastReceivedXRNTPfrac(0),
       xr_rrtr_status_(false),
       xr_rr_rtt_ms_(0),
       _receivedInfoMap(),
       _lastReceivedRrMs(0),
       _lastIncreasedSequenceNumberMs(0),
       stats_callback_(NULL),
       packet_type_counter_observer_(packet_type_counter_observer),
       num_skipped_packets_(0),
       last_skipped_packets_warning_(clock->TimeInMilliseconds()) {
   memset(&_remoteSenderInfo, 0, sizeof(_remoteSenderInfo));
 }
 
 RTCPReceiver::~RTCPReceiver() {
-  delete _criticalSectionRTCPReceiver;
-  delete _criticalSectionFeedbacks;
-
   ReportBlockMap::iterator it = _receivedReportBlockMap.begin();
   for (; it != _receivedReportBlockMap.end(); ++it) {
     ReportBlockInfoMap* info_map = &(it->second);
     while (!info_map->empty()) {
       ReportBlockInfoMap::iterator it_info = info_map->begin();
       delete it_info->second;
       info_map->erase(it_info);
     }
   }
   while (!_receivedInfoMap.empty()) {
     std::map<uint32_t, RTCPReceiveInformation*>::iterator first =
         _receivedInfoMap.begin();
     delete first->second;
     _receivedInfoMap.erase(first);
   }
   while (!_receivedCnameMap.empty()) {
     std::map<uint32_t, RTCPCnameInformation*>::iterator first =
         _receivedCnameMap.begin();
     delete first->second;
     _receivedCnameMap.erase(first);
   }
 }
 
 int64_t RTCPReceiver::LastReceived() {
-  CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
+  rtc::CritScope lock(&_criticalSectionRTCPReceiver);
   return _lastReceived;
 }
 
 int64_t RTCPReceiver::LastReceivedReceiverReport() const {
-  CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
+  rtc::CritScope lock(&_criticalSectionRTCPReceiver);
   int64_t last_received_rr = -1;
   for (ReceivedInfoMap::const_iterator it = _receivedInfoMap.begin();
        it != _receivedInfoMap.end(); ++it) {
     if (it->second->lastTimeReceived > last_received_rr) {
       last_received_rr = it->second->lastTimeReceived;
     }
   }
   return last_received_rr;
 }
 
 void RTCPReceiver::SetRemoteSSRC(uint32_t ssrc) {
-  CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
+  rtc::CritScope lock(&_criticalSectionRTCPReceiver);
 
   // new SSRC reset old reports
   memset(&_remoteSenderInfo, 0, sizeof(_remoteSenderInfo));
   _lastReceivedSRNTPsecs = 0;
   _lastReceivedSRNTPfrac = 0;
 
   _remoteSSRC = ssrc;
 }
 
 uint32_t RTCPReceiver::RemoteSSRC() const {
-  CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
+  rtc::CritScope lock(&_criticalSectionRTCPReceiver);
   return _remoteSSRC;
 }
 
 void RTCPReceiver::SetSsrcs(uint32_t main_ssrc,
                             const std::set<uint32_t>& registered_ssrcs) {
   uint32_t old_ssrc = 0;
   {
-    CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
+    rtc::CritScope lock(&_criticalSectionRTCPReceiver);
     old_ssrc = main_ssrc_;
     main_ssrc_ = main_ssrc;
     registered_ssrcs_ = registered_ssrcs;
   }
   {
     if (_cbRtcpIntraFrameObserver && old_ssrc != main_ssrc) {
       _cbRtcpIntraFrameObserver->OnLocalSsrcChanged(old_ssrc, main_ssrc);
     }
   }
 }
 
 int32_t RTCPReceiver::RTT(uint32_t remoteSSRC,
                           int64_t* RTT,
                           int64_t* avgRTT,
                           int64_t* minRTT,
                           int64_t* maxRTT) const {
-  CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
+  rtc::CritScope lock(&_criticalSectionRTCPReceiver);
 
   RTCPReportBlockInformation* reportBlock =
       GetReportBlockInformation(remoteSSRC, main_ssrc_);
 
   if (reportBlock == NULL) {
     return -1;
   }
   if (RTT) {
     *RTT = reportBlock->RTT;
   }
   if (avgRTT) {
     *avgRTT = reportBlock->avgRTT;
   }
   if (minRTT) {
     *minRTT = reportBlock->minRTT;
   }
   if (maxRTT) {
     *maxRTT = reportBlock->maxRTT;
   }
   return 0;
 }
 
 void RTCPReceiver::SetRtcpXrRrtrStatus(bool enable) {
-  CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
+  rtc::CritScope lock(&_criticalSectionRTCPReceiver);
   xr_rrtr_status_ = enable;
 }
 
 bool RTCPReceiver::GetAndResetXrRrRtt(int64_t* rtt_ms) {
   assert(rtt_ms);
-  CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
+  rtc::CritScope lock(&_criticalSectionRTCPReceiver);
   if (xr_rr_rtt_ms_ == 0) {
     return false;
   }
   *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
 {
-    CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
+    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);
-  CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
+  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 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;
 }
 
 int32_t RTCPReceiver::SenderInfoReceived(RTCPSenderInfo* senderInfo) const {
   assert(senderInfo);
-  CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
+  rtc::CritScope lock(&_criticalSectionRTCPReceiver);
   if (_lastReceivedSRNTPsecs == 0) {
     return -1;
   }
   memcpy(senderInfo, &(_remoteSenderInfo), sizeof(RTCPSenderInfo));
   return 0;
 }
 
 // statistics
 // we can get multiple receive reports when we receive the report from a CE
 int32_t RTCPReceiver::StatisticsReceived(
     std::vector<RTCPReportBlock>* receiveBlocks) const {
   assert(receiveBlocks);
-  CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
+  rtc::CritScope lock(&_criticalSectionRTCPReceiver);
   ReportBlockMap::const_iterator it = _receivedReportBlockMap.begin();
   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)
 {
-    CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
+    rtc::CritScope lock(&_criticalSectionRTCPReceiver);
 
     _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
@@ skipping 289 matching lines @@
   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) {
-  CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
+  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 {
-  CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
+  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) {
-  CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
+  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) {
-  CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
+  rtc::CritScope lock(&_criticalSectionRTCPReceiver);
 
   std::map<uint32_t, RTCPReceiveInformation*>::iterator it =
       _receivedInfoMap.find(remoteSSRC);
   if (it == _receivedInfoMap.end()) {
     return NULL;
   }
   return it->second;
 }
 
 void RTCPReceiver::UpdateReceiveInformation(
     RTCPReceiveInformation& receiveInformation) {
   // Update that this remote is alive
   receiveInformation.lastTimeReceived = _clock->TimeInMilliseconds();
 }
 
 bool RTCPReceiver::RtcpRrTimeout(int64_t rtcp_interval_ms) {
-  CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
+  rtc::CritScope lock(&_criticalSectionRTCPReceiver);
   if (_lastReceivedRrMs == 0)
     return false;
 
   int64_t time_out_ms = kRrTimeoutIntervals * rtcp_interval_ms;
   if (_clock->TimeInMilliseconds() > _lastReceivedRrMs + time_out_ms) {
     // Reset the timer to only trigger one log.
     _lastReceivedRrMs = 0;
     return true;
   }
   return false;
 }
 
 bool RTCPReceiver::RtcpRrSequenceNumberTimeout(int64_t rtcp_interval_ms) {
-  CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
+  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) {
     // Reset the timer to only trigger one log.
     _lastIncreasedSequenceNumberMs = 0;
     return true;
   }
   return false;
 }
 
 bool RTCPReceiver::UpdateRTCPReceiveInformationTimers() {
-  CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
+  rtc::CritScope lock(&_criticalSectionRTCPReceiver);
 
   bool updateBoundingSet = false;
   int64_t timeNow = _clock->TimeInMilliseconds();
 
   std::map<uint32_t, RTCPReceiveInformation*>::iterator receiveInfoIt =
       _receivedInfoMap.begin();
 
   while (receiveInfoIt != _receivedInfoMap.end()) {
     RTCPReceiveInformation* receiveInfo = receiveInfoIt->second;
     if (receiveInfo == NULL) {
@@ skipping 23 matching lines @@
       delete receiveInfoItemToBeErased->second;
       _receivedInfoMap.erase(receiveInfoItemToBeErased);
     } else {
       receiveInfoIt++;
     }
   }
   return updateBoundingSet;
 }
 
 int32_t RTCPReceiver::BoundingSet(bool* tmmbrOwner, TMMBRSet* boundingSetRec) {
-  CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
+  rtc::CritScope lock(&_criticalSectionRTCPReceiver);
 
   std::map<uint32_t, RTCPReceiveInformation*>::iterator receiveInfoIt =
       _receivedInfoMap.find(_remoteSSRC);
 
   if (receiveInfoIt == _receivedInfoMap.end()) {
     return -1;
   }
   RTCPReceiveInformation* receiveInfo = receiveInfoIt->second;
   if (receiveInfo == NULL) {
     return -1;
@@ skipping 28 matching lines @@
 
 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);
+    rtc::CritScope lock(&_criticalSectionFeedbacks);
     if (stats_callback_ != NULL) {
       stats_callback_->CNameChanged(rtcpPacket.CName.CName,
                                     rtcpPacket.CName.SenderSSRC);
     }
   }
 }
 
 void RTCPReceiver::HandleNACK(RTCPUtility::RTCPParserV2& rtcpParser,
                               RTCPPacketInformation& rtcpPacketInformation) {
   const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
@@ skipping 489 matching lines @@
     // we have a new bandwidth estimate on this channel
     if (_cbRtcpBandwidthObserver) {
         _cbRtcpBandwidthObserver->OnReceivedEstimatedBitrate(bitrate * 1000);
     }
   }
   return 0;
 }
 
 void RTCPReceiver::RegisterRtcpStatisticsCallback(
     RtcpStatisticsCallback* callback) {
-  CriticalSectionScoped cs(_criticalSectionFeedbacks);
+  rtc::CritScope cs(&_criticalSectionFeedbacks);
   stats_callback_ = callback;
 }
 
 RtcpStatisticsCallback* RTCPReceiver::GetRtcpStatisticsCallback() {
-  CriticalSectionScoped cs(_criticalSectionFeedbacks);
+  rtc::CritScope cs(&_criticalSectionFeedbacks);
   return stats_callback_;
 }
 
 // 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();
   }
   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);
+    rtc::CritScope 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) {
@@ skipping 52 matching lines @@
           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_) {
-    CriticalSectionScoped cs(_criticalSectionFeedbacks);
+    rtc::CritScope cs(&_criticalSectionFeedbacks);
     if (stats_callback_) {
       for (ReportBlockList::const_iterator 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);
       }
     }
   }
 }
 
 int32_t RTCPReceiver::CNAME(uint32_t remoteSSRC,
                             char cName[RTCP_CNAME_SIZE]) const {
   assert(cName);
 
-  CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
+  rtc::CritScope lock(&_criticalSectionRTCPReceiver);
   RTCPCnameInformation* cnameInfo = GetCnameInformation(remoteSSRC);
   if (cnameInfo == NULL) {
     return -1;
   }
   cName[RTCP_CNAME_SIZE - 1] = 0;
   strncpy(cName, cnameInfo->name, RTCP_CNAME_SIZE - 1);
   return 0;
 }
 
 // no callbacks allowed inside this function
 int32_t RTCPReceiver::TMMBRReceived(uint32_t size,
                                     uint32_t accNumCandidates,
                                     TMMBRSet* candidateSet) const {
-  CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
+  rtc::CritScope lock(&_criticalSectionRTCPReceiver);
 
   std::map<uint32_t, RTCPReceiveInformation*>::const_iterator
       receiveInfoIt = _receivedInfoMap.begin();
   if (receiveInfoIt == _receivedInfoMap.end()) {
     return -1;
   }
   uint32_t num = accNumCandidates;
   if (candidateSet) {
     while( num < size && receiveInfoIt != _receivedInfoMap.end()) {
       RTCPReceiveInformation* receiveInfo = receiveInfoIt->second;
@@ skipping 16 matching lines @@
         return -1;
       }
       num += receiveInfo->TmmbrSet.lengthOfSet();
       receiveInfoIt++;
     }
   }
   return num;
 }
 
 }  // namespace webrtc