Swap use of CriticalSectionWrapper for rtc::CriticalSection in webrtc/video.

webrtc/video/vie_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.
  */
 
 #include "webrtc/video/vie_receiver.h"
 
 #include <vector>
 
 #include "webrtc/base/logging.h"
 #include "webrtc/modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h"
 #include "webrtc/modules/rtp_rtcp/include/fec_receiver.h"
 #include "webrtc/modules/rtp_rtcp/include/receive_statistics.h"
 #include "webrtc/modules/rtp_rtcp/include/remote_ntp_time_estimator.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_cvo.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_payload_registry.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_receiver.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h"
 #include "webrtc/modules/video_coding/include/video_coding.h"
-#include "webrtc/system_wrappers/include/critical_section_wrapper.h"
 #include "webrtc/system_wrappers/include/metrics.h"
 #include "webrtc/system_wrappers/include/tick_util.h"
 #include "webrtc/system_wrappers/include/timestamp_extrapolator.h"
 #include "webrtc/system_wrappers/include/trace.h"
 
 namespace webrtc {
 
 static const int kPacketLogIntervalMs = 10000;
 
 ViEReceiver::ViEReceiver(VideoCodingModule* module_vcm,
                          RemoteBitrateEstimator* remote_bitrate_estimator,
                          RtpFeedback* rtp_feedback)
-    : receive_cs_(CriticalSectionWrapper::CreateCriticalSection()),
-      clock_(Clock::GetRealTimeClock()),
+    : clock_(Clock::GetRealTimeClock()),
       rtp_header_parser_(RtpHeaderParser::Create()),
       rtp_payload_registry_(
           new RTPPayloadRegistry(RTPPayloadStrategy::CreateStrategy(false))),
       rtp_receiver_(
           RtpReceiver::CreateVideoReceiver(clock_,
                                            this,
                                            rtp_feedback,
                                            rtp_payload_registry_.get())),
       rtp_receive_statistics_(ReceiveStatistics::Create(clock_)),
       fec_receiver_(FecReceiver::Create(this)),
@@ skipping 95 matching lines @@
 void ViEReceiver::SetRtpRtcpModule(RtpRtcp* module) {
   rtp_rtcp_ = module;
 }
 
 RtpReceiver* ViEReceiver::GetRtpReceiver() const {
   return rtp_receiver_.get();
 }
 
 void ViEReceiver::RegisterRtpRtcpModules(
     const std::vector<RtpRtcp*>& rtp_modules) {
-  CriticalSectionScoped cs(receive_cs_.get());
+  rtc::CritScope lock(&receive_cs_);
   // Only change the "simulcast" modules, the base module can be accessed
   // without a lock whereas the simulcast modules require locking as they can be
   // changed in runtime.
   rtp_rtcp_simulcast_ =
       std::vector<RtpRtcp*>(rtp_modules.begin() + 1, rtp_modules.end());
 }
 
 bool ViEReceiver::SetReceiveTimestampOffsetStatus(bool enable, int id) {
   if (enable) {
     return rtp_header_parser_->RegisterRtpHeaderExtension(
@@ skipping 88 matching lines @@
   }
   header.payload_type_frequency = kVideoPayloadTypeFrequency;
   bool in_order = IsPacketInOrder(header);
   return ReceivePacket(rtp_packet, rtp_packet_length, header, in_order);
 }
 
 int ViEReceiver::InsertRTPPacket(const uint8_t* rtp_packet,
                                  size_t rtp_packet_length,
                                  const PacketTime& packet_time) {
   {
-    CriticalSectionScoped cs(receive_cs_.get());
+    rtc::CritScope lock(&receive_cs_);
     if (!receiving_) {
       return -1;
     }
   }
 
   RTPHeader header;
   if (!rtp_header_parser_->Parse(rtp_packet, rtp_packet_length,
                                  &header)) {
     return -1;
   }
   size_t payload_length = rtp_packet_length - header.headerLength;
   int64_t arrival_time_ms;
   int64_t now_ms = clock_->TimeInMilliseconds();
   if (packet_time.timestamp != -1)
     arrival_time_ms = (packet_time.timestamp + 500) / 1000;
   else
     arrival_time_ms = now_ms;
 
   {
     // Periodically log the RTP header of incoming packets.
-    CriticalSectionScoped cs(receive_cs_.get());
+    rtc::CritScope lock(&receive_cs_);
     if (now_ms - last_packet_log_ms_ > kPacketLogIntervalMs) {
       std::stringstream ss;
       ss << "Packet received on SSRC: " << header.ssrc << " with payload type: "
          << static_cast<int>(header.payloadType) << ", timestamp: "
          << header.timestamp << ", sequence number: " << header.sequenceNumber
          << ", arrival time: " << arrival_time_ms;
       if (header.extension.hasTransmissionTimeOffset)
         ss << ", toffset: " << header.extension.transmissionTimeOffset;
       if (header.extension.hasAbsoluteSendTime)
         ss << ", abs send time: " << header.extension.absoluteSendTime;
@@ skipping 57 matching lines @@
     if (header.headerLength + header.paddingLength == packet_length) {
       // This is an empty packet and should be silently dropped before trying to
       // parse the RTX header.
       return true;
     }
     // Remove the RTX header and parse the original RTP header.
     if (packet_length < header.headerLength)
       return false;
     if (packet_length > sizeof(restored_packet_))
       return false;
-    CriticalSectionScoped cs(receive_cs_.get());
+    rtc::CritScope lock(&receive_cs_);
     if (restored_packet_in_use_) {
       LOG(LS_WARNING) << "Multiple RTX headers detected, dropping packet.";
       return false;
     }
     if (!rtp_payload_registry_->RestoreOriginalPacket(
             restored_packet_, packet, &packet_length, rtp_receiver_->SSRC(),
             header)) {
       LOG(LS_WARNING) << "Incoming RTX packet: Invalid RTP header";
       return false;
     }
@@ skipping 28 matching lines @@
   if (header.extension.hasVideoRotation) {
     rtp_header.type.Video.rotation =
         ConvertCVOByteToVideoRotation(header.extension.videoRotation);
   }
   OnReceivedPayloadData(NULL, 0, &rtp_header);
 }
 
 int ViEReceiver::InsertRTCPPacket(const uint8_t* rtcp_packet,
                                   size_t rtcp_packet_length) {
   {
-    CriticalSectionScoped cs(receive_cs_.get());
+    rtc::CritScope lock(&receive_cs_);
     if (!receiving_) {
       return -1;
     }
 
     for (RtpRtcp* rtp_rtcp : rtp_rtcp_simulcast_)
       rtp_rtcp->IncomingRtcpPacket(rtcp_packet, rtcp_packet_length);
   }
   assert(rtp_rtcp_);  // Should be set by owner at construction time.
   int ret = rtp_rtcp_->IncomingRtcpPacket(rtcp_packet, rtcp_packet_length);
   if (ret != 0) {
@@ skipping 13 matching lines @@
                                 &rtp_timestamp)) {
     // Waiting for RTCP.
     return 0;
   }
   ntp_estimator_->UpdateRtcpTimestamp(rtt, ntp_secs, ntp_frac, rtp_timestamp);
 
   return 0;
 }
 
 void ViEReceiver::StartReceive() {
-  CriticalSectionScoped cs(receive_cs_.get());
+  rtc::CritScope lock(&receive_cs_);
   receiving_ = true;
 }
 
 void ViEReceiver::StopReceive() {
-  CriticalSectionScoped cs(receive_cs_.get());
+  rtc::CritScope lock(&receive_cs_);
   receiving_ = false;
 }
 
 ReceiveStatistics* ViEReceiver::GetReceiveStatistics() const {
   return rtp_receive_statistics_.get();
 }
 
 bool ViEReceiver::IsPacketInOrder(const RTPHeader& header) const {
   StreamStatistician* statistician =
       rtp_receive_statistics_->GetStatistician(header.ssrc);
@@ skipping 11 matching lines @@
       rtp_receive_statistics_->GetStatistician(header.ssrc);
   if (!statistician)
     return false;
   // Check if this is a retransmission.
   int64_t min_rtt = 0;
   rtp_rtcp_->RTT(rtp_receiver_->SSRC(), NULL, NULL, &min_rtt, NULL);
   return !in_order &&
       statistician->IsRetransmitOfOldPacket(header, min_rtt);
 }
 }  // namespace webrtc