Switch CriticalSectionWrapper->rtc::CriticalSection in modules/audio_coding.

webrtc/modules/audio_coding/acm2/acm_receiver.cc

 /*
  *  Copyright (c) 2013 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/modules/audio_coding/acm2/acm_receiver.h"
 
 #include <stdlib.h>  // malloc
 
 #include <algorithm>  // sort
 #include <vector>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/format_macros.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/common_audio/signal_processing/include/signal_processing_library.h"
 #include "webrtc/common_types.h"
 #include "webrtc/modules/audio_coding/codecs/audio_decoder.h"
 #include "webrtc/modules/audio_coding/acm2/acm_resampler.h"
 #include "webrtc/modules/audio_coding/acm2/call_statistics.h"
 #include "webrtc/modules/audio_coding/neteq/include/neteq.h"
 #include "webrtc/system_wrappers/include/clock.h"
-#include "webrtc/system_wrappers/include/critical_section_wrapper.h"
 #include "webrtc/system_wrappers/include/tick_util.h"
 #include "webrtc/system_wrappers/include/trace.h"
 
 namespace webrtc {
 
 namespace acm2 {
 
 namespace {
 
 // |vad_activity_| field of |audio_frame| is set to |previous_audio_activity_|
@@ skipping 73 matching lines @@
   auto i = RentACodec::CodecIdFromIndex(codec_id);
   return (i && (*i == RentACodec::CodecId::kCNNB ||
                 *i == RentACodec::CodecId::kCNWB ||
                 *i == RentACodec::CodecId::kCNSWB ||
                 *i == RentACodec::CodecId::kCNFB));
 }
 
 }  // namespace
 
 AcmReceiver::AcmReceiver(const AudioCodingModule::Config& config)
-    : crit_sect_(CriticalSectionWrapper::CreateCriticalSection()),
-      id_(config.id),
+    : id_(config.id),
       last_audio_decoder_(nullptr),
       previous_audio_activity_(AudioFrame::kVadPassive),
       audio_buffer_(new int16_t[AudioFrame::kMaxDataSizeSamples]),
       last_audio_buffer_(new int16_t[AudioFrame::kMaxDataSizeSamples]),
       neteq_(NetEq::Create(config.neteq_config)),
       vad_enabled_(config.neteq_config.enable_post_decode_vad),
       clock_(config.clock),
       resampled_last_output_frame_(true) {
   assert(clock_);
   memset(audio_buffer_.get(), 0, AudioFrame::kMaxDataSizeSamples);
@@ skipping 16 matching lines @@
     return 0;
   LOG(LERROR) << "AcmReceiver::SetExtraDelay " << delay_ms;
   return -1;
 }
 
 int AcmReceiver::LeastRequiredDelayMs() const {
   return neteq_->LeastRequiredDelayMs();
 }
 
 rtc::Optional<int> AcmReceiver::last_packet_sample_rate_hz() const {
-  CriticalSectionScoped lock(crit_sect_.get());
+  rtc::CritScope lock(&crit_sect_);
   return last_packet_sample_rate_hz_;
 }
 
 int AcmReceiver::last_output_sample_rate_hz() const {
   return neteq_->last_output_sample_rate_hz();
 }
 
 int AcmReceiver::InsertPacket(const WebRtcRTPHeader& rtp_header,
                               rtc::ArrayView<const uint8_t> incoming_payload) {
   uint32_t receive_timestamp = 0;
   const RTPHeader* header = &rtp_header.header;  // Just a shorthand.
 
   {
-    CriticalSectionScoped lock(crit_sect_.get());
+    rtc::CritScope lock(&crit_sect_);
 
     const Decoder* decoder = RtpHeaderToDecoder(*header, incoming_payload[0]);
     if (!decoder) {
       LOG_F(LS_ERROR) << "Payload-type "
                       << static_cast<int>(header->payloadType)
                       << " is not registered.";
       return -1;
     }
     const int sample_rate_hz = [&decoder] {
       const auto ci = RentACodec::CodecIdFromIndex(decoder->acm_codec_id);
@@ skipping 24 matching lines @@
   }
   return 0;
 }
 
 int AcmReceiver::GetAudio(int desired_freq_hz, AudioFrame* audio_frame) {
   enum NetEqOutputType type;
   size_t samples_per_channel;
   size_t num_channels;
 
   // Accessing members, take the lock.
-  CriticalSectionScoped lock(crit_sect_.get());
+  rtc::CritScope lock(&crit_sect_);
 
   // Always write the output to |audio_buffer_| first.
   if (neteq_->GetAudio(AudioFrame::kMaxDataSizeSamples,
                        audio_buffer_.get(),
                        &samples_per_channel,
                        &num_channels,
                        &type) != NetEq::kOK) {
     LOG(LERROR) << "AcmReceiver::GetAudio - NetEq Failed.";
     return -1;
   }
@@ skipping 80 matching lines @@
       return NetEqDecoder::kDecoderArbitrary;  // External decoder.
     const rtc::Optional<RentACodec::CodecId> cid =
         RentACodec::CodecIdFromIndex(acm_codec_id);
     RTC_DCHECK(cid) << "Invalid codec index: " << acm_codec_id;
     const rtc::Optional<NetEqDecoder> ned =
         RentACodec::NetEqDecoderFromCodecId(*cid, channels);
     RTC_DCHECK(ned) << "Invalid codec ID: " << static_cast<int>(*cid);
     return *ned;
   }();
 
-  CriticalSectionScoped lock(crit_sect_.get());
+  rtc::CritScope lock(&crit_sect_);
 
   // The corresponding NetEq decoder ID.
   // If this codec has been registered before.
   auto it = decoders_.find(payload_type);
   if (it != decoders_.end()) {
     const Decoder& decoder = it->second;
     if (acm_codec_id != -1 && decoder.acm_codec_id == acm_codec_id &&
         decoder.channels == channels &&
         decoder.sample_rate_hz == sample_rate_hz) {
       // Re-registering the same codec. Do nothing and return.
@@ skipping 28 matching lines @@
   decoder.acm_codec_id = acm_codec_id;
   decoder.payload_type = payload_type;
   decoder.channels = channels;
   decoder.sample_rate_hz = sample_rate_hz;
   decoders_[payload_type] = decoder;
   return 0;
 }
 
 void AcmReceiver::EnableVad() {
   neteq_->EnableVad();
-  CriticalSectionScoped lock(crit_sect_.get());
+  rtc::CritScope lock(&crit_sect_);
   vad_enabled_ = true;
 }
 
 void AcmReceiver::DisableVad() {
   neteq_->DisableVad();
-  CriticalSectionScoped lock(crit_sect_.get());
+  rtc::CritScope lock(&crit_sect_);
   vad_enabled_ = false;
 }
 
 void AcmReceiver::FlushBuffers() {
   neteq_->FlushBuffers();
 }
 
 // If failed in removing one of the codecs, this method continues to remove as
 // many as it can.
 int AcmReceiver::RemoveAllCodecs() {
   int ret_val = 0;
-  CriticalSectionScoped lock(crit_sect_.get());
+  rtc::CritScope lock(&crit_sect_);
   for (auto it = decoders_.begin(); it != decoders_.end(); ) {
     auto cur = it;
     ++it;  // it will be valid even if we erase cur
     if (neteq_->RemovePayloadType(cur->second.payload_type) == 0) {
       decoders_.erase(cur);
     } else {
       LOG_F(LS_ERROR) << "Cannot remove payload "
                       << static_cast<int>(cur->second.payload_type);
       ret_val = -1;
     }
   }
 
   // No codec is registered, invalidate last audio decoder.
   last_audio_decoder_ = nullptr;
   last_packet_sample_rate_hz_ = rtc::Optional<int>();
   return ret_val;
 }
 
 int AcmReceiver::RemoveCodec(uint8_t payload_type) {
-  CriticalSectionScoped lock(crit_sect_.get());
+  rtc::CritScope lock(&crit_sect_);
   auto it = decoders_.find(payload_type);
   if (it == decoders_.end()) {  // Such a payload-type is not registered.
     return 0;
   }
   if (neteq_->RemovePayloadType(payload_type) != NetEq::kOK) {
     LOG(LERROR) << "AcmReceiver::RemoveCodec" << static_cast<int>(payload_type);
     return -1;
   }
   if (last_audio_decoder_ == &it->second) {
     last_audio_decoder_ = nullptr;
     last_packet_sample_rate_hz_ = rtc::Optional<int>();
   }
   decoders_.erase(it);
   return 0;
 }
 
 void AcmReceiver::set_id(int id) {
-  CriticalSectionScoped lock(crit_sect_.get());
+  rtc::CritScope lock(&crit_sect_);
   id_ = id;
 }
 
 bool AcmReceiver::GetPlayoutTimestamp(uint32_t* timestamp) {
   return neteq_->GetPlayoutTimestamp(timestamp);
 }
 
 int AcmReceiver::LastAudioCodec(CodecInst* codec) const {
-  CriticalSectionScoped lock(crit_sect_.get());
+  rtc::CritScope lock(&crit_sect_);
   if (!last_audio_decoder_) {
     return -1;
   }
   *codec = *RentACodec::CodecInstById(
       *RentACodec::CodecIdFromIndex(last_audio_decoder_->acm_codec_id));
   codec->pltype = last_audio_decoder_->payload_type;
   codec->channels = last_audio_decoder_->channels;
   codec->plfreq = last_audio_decoder_->sample_rate_hz;
   return 0;
 }
@@ skipping 16 matching lines @@
   acm_stat->clockDriftPPM = neteq_stat.clockdrift_ppm;
   acm_stat->addedSamples = neteq_stat.added_zero_samples;
   acm_stat->meanWaitingTimeMs = neteq_stat.mean_waiting_time_ms;
   acm_stat->medianWaitingTimeMs = neteq_stat.median_waiting_time_ms;
   acm_stat->minWaitingTimeMs = neteq_stat.min_waiting_time_ms;
   acm_stat->maxWaitingTimeMs = neteq_stat.max_waiting_time_ms;
 }
 
 int AcmReceiver::DecoderByPayloadType(uint8_t payload_type,
                                       CodecInst* codec) const {
-  CriticalSectionScoped lock(crit_sect_.get());
+  rtc::CritScope lock(&crit_sect_);
   auto it = decoders_.find(payload_type);
   if (it == decoders_.end()) {
     LOG(LERROR) << "AcmReceiver::DecoderByPayloadType "
                 << static_cast<int>(payload_type);
     return -1;
   }
   const Decoder& decoder = it->second;
   *codec = *RentACodec::CodecInstById(
       *RentACodec::CodecIdFromIndex(decoder.acm_codec_id));
   codec->pltype = decoder.payload_type;
@@ skipping 43 matching lines @@
   // We masked 6 most significant bits of 32-bit so there is no overflow in
   // the conversion from milliseconds to timestamp.
   const uint32_t now_in_ms = static_cast<uint32_t>(
       clock_->TimeInMilliseconds() & 0x03ffffff);
   return static_cast<uint32_t>(
       (decoder_sampling_rate / 1000) * now_in_ms);
 }
 
 void AcmReceiver::GetDecodingCallStatistics(
     AudioDecodingCallStats* stats) const {
-  CriticalSectionScoped lock(crit_sect_.get());
+  rtc::CritScope lock(&crit_sect_);
   *stats = call_stats_.GetDecodingStatistics();
 }
 
 }  // namespace acm2
 
 }  // namespace webrtc