Swap use of CriticalSectionWrapper with rtc::CriticalSection in voice_engine/

webrtc/voice_engine/channel.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/voice_engine/channel.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "webrtc/base/checks.h"
+#include "webrtc/base/criticalsection.h"
 #include "webrtc/base/format_macros.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/thread_checker.h"
 #include "webrtc/base/timeutils.h"
 #include "webrtc/common.h"
 #include "webrtc/config.h"
 #include "webrtc/modules/audio_device/include/audio_device.h"
 #include "webrtc/modules/audio_processing/include/audio_processing.h"
 #include "webrtc/modules/include/module_common_types.h"
 #include "webrtc/modules/pacing/packet_router.h"
 #include "webrtc/modules/rtp_rtcp/include/receive_statistics.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/source/rtp_receiver_strategy.h"
 #include "webrtc/modules/utility/include/audio_frame_operations.h"
 #include "webrtc/modules/utility/include/process_thread.h"
-#include "webrtc/system_wrappers/include/critical_section_wrapper.h"
 #include "webrtc/system_wrappers/include/trace.h"
 #include "webrtc/voice_engine/include/voe_base.h"
 #include "webrtc/voice_engine/include/voe_external_media.h"
 #include "webrtc/voice_engine/include/voe_rtp_rtcp.h"
 #include "webrtc/voice_engine/output_mixer.h"
 #include "webrtc/voice_engine/statistics.h"
 #include "webrtc/voice_engine/transmit_mixer.h"
 #include "webrtc/voice_engine/utility.h"
 
 #if defined(_WIN32)
@@ skipping 106 matching lines @@
 struct ChannelStatistics : public RtcpStatistics {
   ChannelStatistics() : rtcp(), max_jitter(0) {}
 
   RtcpStatistics rtcp;
   uint32_t max_jitter;
 };
 
 // Statistics callback, called at each generation of a new RTCP report block.
 class StatisticsProxy : public RtcpStatisticsCallback {
  public:
-  StatisticsProxy(uint32_t ssrc)
-   : stats_lock_(CriticalSectionWrapper::CreateCriticalSection()),
-     ssrc_(ssrc) {}
+  StatisticsProxy(uint32_t ssrc) : ssrc_(ssrc) {}
   virtual ~StatisticsProxy() {}
 
   void StatisticsUpdated(const RtcpStatistics& statistics,
                          uint32_t ssrc) override {
     if (ssrc != ssrc_)
       return;
 
-    CriticalSectionScoped cs(stats_lock_.get());
+    rtc::CritScope cs(&stats_lock_);
     stats_.rtcp = statistics;
     if (statistics.jitter > stats_.max_jitter) {
       stats_.max_jitter = statistics.jitter;
     }
   }
 
   void CNameChanged(const char* cname, uint32_t ssrc) override {}
 
   ChannelStatistics GetStats() {
-    CriticalSectionScoped cs(stats_lock_.get());
+    rtc::CritScope cs(&stats_lock_);
     return stats_;
   }
 
  private:
   // StatisticsUpdated calls are triggered from threads in the RTP module,
   // while GetStats calls can be triggered from the public voice engine API,
   // hence synchronization is needed.
-  rtc::scoped_ptr<CriticalSectionWrapper> stats_lock_;
+  rtc::CriticalSection stats_lock_;
   const uint32_t ssrc_;
   ChannelStatistics stats_;
 };
 
 class VoERtcpObserver : public RtcpBandwidthObserver {
  public:
   explicit VoERtcpObserver(Channel* owner) : owner_(owner) {}
   virtual ~VoERtcpObserver() {}
 
   void OnReceivedEstimatedBitrate(uint32_t bitrate) override {
@@ skipping 92 matching lines @@
 
     return 0;
 }
 
 int32_t
 Channel::InFrameType(FrameType frame_type)
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
                  "Channel::InFrameType(frame_type=%d)", frame_type);
 
-    CriticalSectionScoped cs(&_callbackCritSect);
+    rtc::CritScope cs(&_callbackCritSect);
     _sendFrameType = (frame_type == kAudioFrameSpeech);
     return 0;
 }
 
 int32_t
 Channel::OnRxVadDetected(int vadDecision)
 {
-    CriticalSectionScoped cs(&_callbackCritSect);
+    rtc::CritScope cs(&_callbackCritSect);
     if (_rxVadObserverPtr)
     {
         _rxVadObserverPtr->OnRxVad(_channelId, vadDecision);
     }
 
     return 0;
 }
 
 bool Channel::SendRtp(const uint8_t* data,
                       size_t len,
                       const PacketOptions& options) {
     WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId,_channelId),
                  "Channel::SendPacket(channel=%d, len=%" PRIuS ")", len);
 
-    CriticalSectionScoped cs(&_callbackCritSect);
+    rtc::CritScope cs(&_callbackCritSect);
 
     if (_transportPtr == NULL)
     {
         WEBRTC_TRACE(kTraceError, kTraceVoice, VoEId(_instanceId,_channelId),
                      "Channel::SendPacket() failed to send RTP packet due to"
                      " invalid transport object");
         return false;
     }
 
     uint8_t* bufferToSendPtr = (uint8_t*)data;
@@ skipping 10 matching lines @@
     }
     return true;
 }
 
 bool
 Channel::SendRtcp(const uint8_t *data, size_t len)
 {
     WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId,_channelId),
                  "Channel::SendRtcp(len=%" PRIuS ")", len);
 
-    CriticalSectionScoped cs(&_callbackCritSect);
+    rtc::CritScope cs(&_callbackCritSect);
     if (_transportPtr == NULL)
     {
         WEBRTC_TRACE(kTraceError, kTraceVoice,
                      VoEId(_instanceId,_channelId),
                      "Channel::SendRtcp() failed to send RTCP packet"
                      " due to invalid transport object");
         return false;
     }
 
     uint8_t* bufferToSendPtr = (uint8_t*)data;
@@ skipping 193 matching lines @@
         LOG(LS_ERROR) << "ProcessStream() error: " << err;
         assert(false);
       }
     }
 
     {
       // Pass the audio buffers to an optional sink callback, before applying
       // scaling/panning, as that applies to the mix operation.
       // External recipients of the audio (e.g. via AudioTrack), will do their
       // own mixing/dynamic processing.
-      CriticalSectionScoped cs(&_callbackCritSect);
+      rtc::CritScope cs(&_callbackCritSect);
       if (audio_sink_) {
         AudioSinkInterface::Data data(
             &audioFrame->data_[0],
             audioFrame->samples_per_channel_, audioFrame->sample_rate_hz_,
             audioFrame->num_channels_, audioFrame->timestamp_);
         audio_sink_->OnData(data);
       }
     }
 
     float output_gain = 1.0f;
     float left_pan =  1.0f;
     float right_pan =  1.0f;
     {
-      CriticalSectionScoped cs(&volume_settings_critsect_);
+      rtc::CritScope cs(&volume_settings_critsect_);
       output_gain = _outputGain;
       left_pan = _panLeft;
       right_pan= _panRight;
     }
 
     // Output volume scaling
     if (output_gain < 0.99f || output_gain > 1.01f)
     {
         AudioFrameOperations::ScaleWithSat(output_gain, *audioFrame);
     }
@@ skipping 19 matching lines @@
 
     // Mix decoded PCM output with file if file mixing is enabled
     if (state.output_file_playing)
     {
         MixAudioWithFile(*audioFrame, audioFrame->sample_rate_hz_);
     }
 
     // External media
     if (_outputExternalMedia)
     {
-        CriticalSectionScoped cs(&_callbackCritSect);
+        rtc::CritScope cs(&_callbackCritSect);
         const bool isStereo = (audioFrame->num_channels_ == 2);
         if (_outputExternalMediaCallbackPtr)
         {
           _outputExternalMediaCallbackPtr->Process(
               _channelId, kPlaybackPerChannel, (int16_t*)audioFrame->data_,
               audioFrame->samples_per_channel_, audioFrame->sample_rate_hz_,
               isStereo);
         }
     }
 
     // Record playout if enabled
     {
-        CriticalSectionScoped cs(&_fileCritSect);
+        rtc::CritScope cs(&_fileCritSect);
 
         if (_outputFileRecording && _outputFileRecorderPtr)
         {
             _outputFileRecorderPtr->RecordAudioToFile(*audioFrame);
         }
     }
 
     // Measure audio level (0-9)
     _outputAudioLevel.ComputeLevel(*audioFrame);
 
     if (capture_start_rtp_time_stamp_ < 0 && audioFrame->timestamp_ != 0) {
       // The first frame with a valid rtp timestamp.
       capture_start_rtp_time_stamp_ = audioFrame->timestamp_;
     }
 
     if (capture_start_rtp_time_stamp_ >= 0) {
       // audioFrame.timestamp_ should be valid from now on.
 
       // Compute elapsed time.
       int64_t unwrap_timestamp =
           rtp_ts_wraparound_handler_->Unwrap(audioFrame->timestamp_);
       audioFrame->elapsed_time_ms_ =
           (unwrap_timestamp - capture_start_rtp_time_stamp_) /
           (GetPlayoutFrequency() / 1000);
 
       {
-        CriticalSectionScoped lock(ts_stats_lock_.get());
+        rtc::CritScope lock(&ts_stats_lock_);
         // Compute ntp time.
         audioFrame->ntp_time_ms_ = ntp_estimator_.Estimate(
             audioFrame->timestamp_);
         // |ntp_time_ms_| won't be valid until at least 2 RTCP SRs are received.
         if (audioFrame->ntp_time_ms_ > 0) {
           // Compute |capture_start_ntp_time_ms_| so that
           // |capture_start_ntp_time_ms_| + |elapsed_time_ms_| == |ntp_time_ms_|
           capture_start_ntp_time_ms_ =
               audioFrame->ntp_time_ms_ - audioFrame->elapsed_time_ms_;
         }
@@ skipping 23 matching lines @@
     {
         highestNeeded = receiveFrequency;
     }
 
     // Special case, if we're playing a file on the playout side
     // we take that frequency into consideration as well
     // This is not needed on sending side, since the codec will
     // limit the spectrum anyway.
     if (channel_state_.Get().output_file_playing)
     {
-        CriticalSectionScoped cs(&_fileCritSect);
+        rtc::CritScope cs(&_fileCritSect);
         if (_outputFilePlayerPtr)
         {
             if(_outputFilePlayerPtr->Frequency()>highestNeeded)
             {
                 highestNeeded=_outputFilePlayerPtr->Frequency();
             }
         }
     }
 
     return(highestNeeded);
@@ skipping 65 matching lines @@
 }
 
 void
 Channel::RecordFileEnded(int32_t id)
 {
     WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId,_channelId),
                  "Channel::RecordFileEnded(id=%d)", id);
 
     assert(id == _outputFileRecorderId);
 
-    CriticalSectionScoped cs(&_fileCritSect);
+    rtc::CritScope cs(&_fileCritSect);
 
     _outputFileRecording = false;
     WEBRTC_TRACE(kTraceStateInfo, kTraceVoice,
                  VoEId(_instanceId,_channelId),
                  "Channel::RecordFileEnded() => output file recorder module is"
                  " shutdown");
 }
 
 Channel::Channel(int32_t channelId,
                  uint32_t instanceId,
                  RtcEventLog* const event_log,
                  const Config& config)
-    : _fileCritSect(*CriticalSectionWrapper::CreateCriticalSection()),
-      _callbackCritSect(*CriticalSectionWrapper::CreateCriticalSection()),
-      volume_settings_critsect_(
-          *CriticalSectionWrapper::CreateCriticalSection()),
-      _instanceId(instanceId),
+    : _instanceId(instanceId),
       _channelId(channelId),
       event_log_(event_log),
       rtp_header_parser_(RtpHeaderParser::Create()),
       rtp_payload_registry_(
           new RTPPayloadRegistry(RTPPayloadStrategy::CreateStrategy(true))),
       rtp_receive_statistics_(
           ReceiveStatistics::Create(Clock::GetRealTimeClock())),
       rtp_receiver_(
           RtpReceiver::CreateAudioReceiver(Clock::GetRealTimeClock(),
                                            this,
@@ skipping 20 matching lines @@
       _timeStamp(0),  // This is just an offset, RTP module will add it's own
                       // random offset
       _sendTelephoneEventPayloadType(106),
       ntp_estimator_(Clock::GetRealTimeClock()),
       jitter_buffer_playout_timestamp_(0),
       playout_timestamp_rtp_(0),
       playout_timestamp_rtcp_(0),
       playout_delay_ms_(0),
       _numberOfDiscardedPackets(0),
       send_sequence_number_(0),
-      ts_stats_lock_(CriticalSectionWrapper::CreateCriticalSection()),
       rtp_ts_wraparound_handler_(new rtc::TimestampWrapAroundHandler()),
       capture_start_rtp_time_stamp_(-1),
       capture_start_ntp_time_ms_(-1),
       _engineStatisticsPtr(NULL),
       _outputMixerPtr(NULL),
       _transmitMixerPtr(NULL),
       _moduleProcessThreadPtr(NULL),
       _audioDeviceModulePtr(NULL),
       _voiceEngineObserverPtr(NULL),
       _callbackCritSectPtr(NULL),
       _transportPtr(NULL),
       _rxVadObserverPtr(NULL),
       _oldVadDecision(-1),
       _sendFrameType(0),
       _externalMixing(false),
       _mixFileWithMicrophone(false),
       _mute(false),
       _panLeft(1.0f),
       _panRight(1.0f),
       _outputGain(1.0f),
       _playOutbandDtmfEvent(false),
       _playInbandDtmfEvent(false),
       _lastLocalTimeStamp(0),
       _lastPayloadType(0),
       _includeAudioLevelIndication(false),
       _outputSpeechType(AudioFrame::kNormalSpeech),
-      video_sync_lock_(CriticalSectionWrapper::CreateCriticalSection()),
       _average_jitter_buffer_delay_us(0),
       _previousTimestamp(0),
       _recPacketDelayMs(20),
       _RxVadDetection(false),
       _rxAgcIsEnabled(false),
       _rxNsIsEnabled(false),
       restored_packet_in_use_(false),
       rtcp_observer_(new VoERtcpObserver(this)),
       network_predictor_(new NetworkPredictor(Clock::GetRealTimeClock())),
-      assoc_send_channel_lock_(CriticalSectionWrapper::CreateCriticalSection()),
       associate_send_channel_(ChannelOwner(nullptr)),
       pacing_enabled_(config.Get<VoicePacing>().enabled),
       feedback_observer_proxy_(pacing_enabled_ ? new TransportFeedbackProxy()
                                                : nullptr),
       seq_num_allocator_proxy_(
           pacing_enabled_ ? new TransportSequenceNumberProxy() : nullptr),
       rtp_packet_sender_proxy_(pacing_enabled_ ? new RtpPacketSenderProxy()
                                                : nullptr) {
     WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(_instanceId,_channelId),
                  "Channel::Channel() - ctor");
@@ skipping 47 matching lines @@
         DeRegisterExternalMediaProcessing(kPlaybackPerChannel);
     }
     if (channel_state_.Get().input_external_media)
     {
         DeRegisterExternalMediaProcessing(kRecordingPerChannel);
     }
     StopSend();
     StopPlayout();
 
     {
-        CriticalSectionScoped cs(&_fileCritSect);
+        rtc::CritScope cs(&_fileCritSect);
         if (_inputFilePlayerPtr)
         {
             _inputFilePlayerPtr->RegisterModuleFileCallback(NULL);
             _inputFilePlayerPtr->StopPlayingFile();
             FilePlayer::DestroyFilePlayer(_inputFilePlayerPtr);
             _inputFilePlayerPtr = NULL;
         }
         if (_outputFilePlayerPtr)
         {
             _outputFilePlayerPtr->RegisterModuleFileCallback(NULL);
@@ skipping 25 matching lines @@
     {
         WEBRTC_TRACE(kTraceWarning, kTraceVoice,
                      VoEId(_instanceId,_channelId),
                      "~Channel() failed to de-register VAD callback"
                      " (Audio coding module)");
     }
     // De-register modules in process thread
     _moduleProcessThreadPtr->DeRegisterModule(_rtpRtcpModule.get());
 
     // End of modules shutdown
-
-    // Delete other objects
-    delete &_callbackCritSect;
-    delete &_fileCritSect;
-    delete &volume_settings_critsect_;
 }
 
 int32_t
 Channel::Init()
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
                  "Channel::Init()");
 
     channel_state_.Reset();
 
@@ skipping 140 matching lines @@
     return 0;
 }
 
 int32_t
 Channel::SetEngineInformation(Statistics& engineStatistics,
                               OutputMixer& outputMixer,
                               voe::TransmitMixer& transmitMixer,
                               ProcessThread& moduleProcessThread,
                               AudioDeviceModule& audioDeviceModule,
                               VoiceEngineObserver* voiceEngineObserver,
-                              CriticalSectionWrapper* callbackCritSect)
+                              rtc::CriticalSection* callbackCritSect)
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
                  "Channel::SetEngineInformation()");
     _engineStatisticsPtr = &engineStatistics;
     _outputMixerPtr = &outputMixer;
     _transmitMixerPtr = &transmitMixer,
     _moduleProcessThreadPtr = &moduleProcessThread;
     _audioDeviceModulePtr = &audioDeviceModule;
     _voiceEngineObserverPtr = voiceEngineObserver;
     _callbackCritSectPtr = callbackCritSect;
     return 0;
 }
 
 int32_t
 Channel::UpdateLocalTimeStamp()
 {
 
     _timeStamp += static_cast<uint32_t>(_audioFrame.samples_per_channel_);
     return 0;
 }
 
 void Channel::SetSink(rtc::scoped_ptr<AudioSinkInterface> sink) {
-  CriticalSectionScoped cs(&_callbackCritSect);
+  rtc::CritScope cs(&_callbackCritSect);
   audio_sink_ = std::move(sink);
 }
 
 int32_t
 Channel::StartPlayout()
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
                  "Channel::StartPlayout()");
     if (channel_state_.Get().playing)
     {
@@ skipping 59 matching lines @@
     {
       return 0;
     }
     channel_state_.SetSending(true);
 
     if (_rtpRtcpModule->SetSendingStatus(true) != 0)
     {
         _engineStatisticsPtr->SetLastError(
             VE_RTP_RTCP_MODULE_ERROR, kTraceError,
             "StartSend() RTP/RTCP failed to start sending");
-        CriticalSectionScoped cs(&_callbackCritSect);
+        rtc::CritScope cs(&_callbackCritSect);
         channel_state_.SetSending(false);
         return -1;
     }
 
     return 0;
 }
 
 int32_t
 Channel::StopSend()
 {
@@ skipping 51 matching lines @@
 
     channel_state_.SetReceiving(false);
     return 0;
 }
 
 int32_t
 Channel::RegisterVoiceEngineObserver(VoiceEngineObserver& observer)
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
                  "Channel::RegisterVoiceEngineObserver()");
-    CriticalSectionScoped cs(&_callbackCritSect);
+    rtc::CritScope cs(&_callbackCritSect);
 
     if (_voiceEngineObserverPtr)
     {
         _engineStatisticsPtr->SetLastError(
             VE_INVALID_OPERATION, kTraceError,
             "RegisterVoiceEngineObserver() observer already enabled");
         return -1;
     }
     _voiceEngineObserverPtr = &observer;
     return 0;
 }
 
 int32_t
 Channel::DeRegisterVoiceEngineObserver()
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
                  "Channel::DeRegisterVoiceEngineObserver()");
-    CriticalSectionScoped cs(&_callbackCritSect);
+    rtc::CritScope cs(&_callbackCritSect);
 
     if (!_voiceEngineObserverPtr)
     {
         _engineStatisticsPtr->SetLastError(
             VE_INVALID_OPERATION, kTraceWarning,
             "DeRegisterVoiceEngineObserver() observer already disabled");
         return 0;
     }
     _voiceEngineObserverPtr = NULL;
     return 0;
@@ skipping 286 matching lines @@
     return -1;
   }
   return 0;
 }
 
 int32_t Channel::RegisterExternalTransport(Transport& transport)
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::RegisterExternalTransport()");
 
-    CriticalSectionScoped cs(&_callbackCritSect);
+    rtc::CritScope cs(&_callbackCritSect);
 
     if (_externalTransport)
     {
         _engineStatisticsPtr->SetLastError(VE_INVALID_OPERATION,
                                            kTraceError,
               "RegisterExternalTransport() external transport already enabled");
        return -1;
     }
     _externalTransport = true;
     _transportPtr = &transport;
     return 0;
 }
 
 int32_t
 Channel::DeRegisterExternalTransport()
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
                  "Channel::DeRegisterExternalTransport()");
 
-    CriticalSectionScoped cs(&_callbackCritSect);
+    rtc::CritScope cs(&_callbackCritSect);
 
     if (!_transportPtr)
     {
         _engineStatisticsPtr->SetLastError(
             VE_INVALID_OPERATION, kTraceWarning,
             "DeRegisterExternalTransport() external transport already "
             "disabled");
         return 0;
     }
     _externalTransport = false;
@@ skipping 123 matching lines @@
   uint32_t ntp_secs = 0;
   uint32_t ntp_frac = 0;
   uint32_t rtp_timestamp = 0;
   if (0 != _rtpRtcpModule->RemoteNTP(&ntp_secs, &ntp_frac, NULL, NULL,
                                      &rtp_timestamp)) {
     // Waiting for RTCP.
     return 0;
   }
 
   {
-    CriticalSectionScoped lock(ts_stats_lock_.get());
+    rtc::CritScope lock(&ts_stats_lock_);
     ntp_estimator_.UpdateRtcpTimestamp(rtt, ntp_secs, ntp_frac, rtp_timestamp);
   }
   return 0;
 }
 
 int Channel::StartPlayingFileLocally(const char* fileName,
                                      bool loop,
                                      FileFormats format,
                                      int startPosition,
                                      float volumeScaling,
                                      int stopPosition,
                                      const CodecInst* codecInst)
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
                  "Channel::StartPlayingFileLocally(fileNameUTF8[]=%s, loop=%d,"
                  " format=%d, volumeScaling=%5.3f, startPosition=%d, "
                  "stopPosition=%d)", fileName, loop, format, volumeScaling,
                  startPosition, stopPosition);
 
     if (channel_state_.Get().output_file_playing)
     {
         _engineStatisticsPtr->SetLastError(
             VE_ALREADY_PLAYING, kTraceError,
             "StartPlayingFileLocally() is already playing");
         return -1;
     }
 
     {
-        CriticalSectionScoped cs(&_fileCritSect);
+        rtc::CritScope cs(&_fileCritSect);
 
         if (_outputFilePlayerPtr)
         {
             _outputFilePlayerPtr->RegisterModuleFileCallback(NULL);
             FilePlayer::DestroyFilePlayer(_outputFilePlayerPtr);
             _outputFilePlayerPtr = NULL;
         }
 
         _outputFilePlayerPtr = FilePlayer::CreateFilePlayer(
             _outputFilePlayerId, (const FileFormats)format);
@@ skipping 58 matching lines @@
 
     if (channel_state_.Get().output_file_playing)
     {
         _engineStatisticsPtr->SetLastError(
             VE_ALREADY_PLAYING, kTraceError,
             "StartPlayingFileLocally() is already playing");
         return -1;
     }
 
     {
-      CriticalSectionScoped cs(&_fileCritSect);
+      rtc::CritScope cs(&_fileCritSect);
 
       // Destroy the old instance
       if (_outputFilePlayerPtr)
       {
           _outputFilePlayerPtr->RegisterModuleFileCallback(NULL);
           FilePlayer::DestroyFilePlayer(_outputFilePlayerPtr);
           _outputFilePlayerPtr = NULL;
       }
 
       // Create the instance
@@ skipping 38 matching lines @@
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
                  "Channel::StopPlayingFileLocally()");
 
     if (!channel_state_.Get().output_file_playing)
     {
         return 0;
     }
 
     {
-        CriticalSectionScoped cs(&_fileCritSect);
+        rtc::CritScope cs(&_fileCritSect);
 
         if (_outputFilePlayerPtr->StopPlayingFile() != 0)
         {
             _engineStatisticsPtr->SetLastError(
                 VE_STOP_RECORDING_FAILED, kTraceError,
                 "StopPlayingFile() could not stop playing");
             return -1;
         }
         _outputFilePlayerPtr->RegisterModuleFileCallback(NULL);
         FilePlayer::DestroyFilePlayer(_outputFilePlayerPtr);
@@ skipping 31 matching lines @@
         return 0;
     }
 
     // |_fileCritSect| cannot be taken while calling
     // SetAnonymousMixabilityStatus() since as soon as the participant is added
     // frames can be pulled by the mixer. Since the frames are generated from
     // the file, _fileCritSect will be taken. This would result in a deadlock.
     if (_outputMixerPtr->SetAnonymousMixabilityStatus(*this, true) != 0)
     {
         channel_state_.SetOutputFilePlaying(false);
-        CriticalSectionScoped cs(&_fileCritSect);
+        rtc::CritScope cs(&_fileCritSect);
         _engineStatisticsPtr->SetLastError(
             VE_AUDIO_CONF_MIX_MODULE_ERROR, kTraceError,
             "StartPlayingFile() failed to add participant as file to mixer");
         _outputFilePlayerPtr->StopPlayingFile();
         FilePlayer::DestroyFilePlayer(_outputFilePlayerPtr);
         _outputFilePlayerPtr = NULL;
         return -1;
     }
 
     return 0;
 }
 
 int Channel::StartPlayingFileAsMicrophone(const char* fileName,
                                           bool loop,
                                           FileFormats format,
                                           int startPosition,
                                           float volumeScaling,
                                           int stopPosition,
                                           const CodecInst* codecInst)
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
                  "Channel::StartPlayingFileAsMicrophone(fileNameUTF8[]=%s, "
                  "loop=%d, format=%d, volumeScaling=%5.3f, startPosition=%d, "
                  "stopPosition=%d)", fileName, loop, format, volumeScaling,
                  startPosition, stopPosition);
 
-    CriticalSectionScoped cs(&_fileCritSect);
+    rtc::CritScope cs(&_fileCritSect);
 
     if (channel_state_.Get().input_file_playing)
     {
         _engineStatisticsPtr->SetLastError(
             VE_ALREADY_PLAYING, kTraceWarning,
             "StartPlayingFileAsMicrophone() filePlayer is playing");
         return 0;
     }
 
     // Destroy the old instance
@@ skipping 54 matching lines @@
                  format, volumeScaling, startPosition, stopPosition);
 
     if(stream == NULL)
     {
         _engineStatisticsPtr->SetLastError(
             VE_BAD_FILE, kTraceError,
             "StartPlayingFileAsMicrophone NULL as input stream");
         return -1;
     }
 
-    CriticalSectionScoped cs(&_fileCritSect);
+    rtc::CritScope cs(&_fileCritSect);
 
     if (channel_state_.Get().input_file_playing)
     {
         _engineStatisticsPtr->SetLastError(
             VE_ALREADY_PLAYING, kTraceWarning,
             "StartPlayingFileAsMicrophone() is playing");
         return 0;
     }
 
     // Destroy the old instance
@@ skipping 35 matching lines @@
     channel_state_.SetInputFilePlaying(true);
 
     return 0;
 }
 
 int Channel::StopPlayingFileAsMicrophone()
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
                  "Channel::StopPlayingFileAsMicrophone()");
 
-    CriticalSectionScoped cs(&_fileCritSect);
+    rtc::CritScope cs(&_fileCritSect);
 
     if (!channel_state_.Get().input_file_playing)
     {
         return 0;
     }
 
     if (_inputFilePlayerPtr->StopPlayingFile() != 0)
     {
         _engineStatisticsPtr->SetLastError(
             VE_STOP_RECORDING_FAILED, kTraceError,
@@ skipping 47 matching lines @@
         (STR_CASE_CMP(codecInst->plname,"PCMU") == 0) ||
         (STR_CASE_CMP(codecInst->plname,"PCMA") == 0))
     {
         format = kFileFormatWavFile;
     }
     else
     {
         format = kFileFormatCompressedFile;
     }
 
-    CriticalSectionScoped cs(&_fileCritSect);
+    rtc::CritScope cs(&_fileCritSect);
 
     // Destroy the old instance
     if (_outputFileRecorderPtr)
     {
         _outputFileRecorderPtr->RegisterModuleFileCallback(NULL);
         FileRecorder::DestroyFileRecorder(_outputFileRecorderPtr);
         _outputFileRecorderPtr = NULL;
     }
 
     _outputFileRecorderPtr = FileRecorder::CreateFileRecorder(
@@ skipping 56 matching lines @@
         (STR_CASE_CMP(codecInst->plname,"PCMU") == 0) ||
         (STR_CASE_CMP(codecInst->plname,"PCMA") == 0))
     {
         format = kFileFormatWavFile;
     }
     else
     {
         format = kFileFormatCompressedFile;
     }
 
-    CriticalSectionScoped cs(&_fileCritSect);
+    rtc::CritScope cs(&_fileCritSect);
 
     // Destroy the old instance
     if (_outputFileRecorderPtr)
     {
         _outputFileRecorderPtr->RegisterModuleFileCallback(NULL);
         FileRecorder::DestroyFileRecorder(_outputFileRecorderPtr);
         _outputFileRecorderPtr = NULL;
     }
 
     _outputFileRecorderPtr = FileRecorder::CreateFileRecorder(
@@ skipping 30 matching lines @@
                  "Channel::StopRecordingPlayout()");
 
     if (!_outputFileRecording)
     {
         WEBRTC_TRACE(kTraceError, kTraceVoice, VoEId(_instanceId,-1),
                      "StopRecordingPlayout() isnot recording");
         return -1;
     }
 
 
-    CriticalSectionScoped cs(&_fileCritSect);
+    rtc::CritScope cs(&_fileCritSect);
 
     if (_outputFileRecorderPtr->StopRecording() != 0)
     {
         _engineStatisticsPtr->SetLastError(
             VE_STOP_RECORDING_FAILED, kTraceError,
             "StopRecording() could not stop recording");
         return(-1);
     }
     _outputFileRecorderPtr->RegisterModuleFileCallback(NULL);
     FileRecorder::DestroyFileRecorder(_outputFileRecorderPtr);
     _outputFileRecorderPtr = NULL;
     _outputFileRecording = false;
 
     return 0;
 }
 
 void
 Channel::SetMixWithMicStatus(bool mix)
 {
-    CriticalSectionScoped cs(&_fileCritSect);
+    rtc::CritScope cs(&_fileCritSect);
     _mixFileWithMicrophone=mix;
 }
 
 int
 Channel::GetSpeechOutputLevel(uint32_t& level) const
 {
     int8_t currentLevel = _outputAudioLevel.Level();
     level = static_cast<int32_t> (currentLevel);
     return 0;
 }
 
 int
 Channel::GetSpeechOutputLevelFullRange(uint32_t& level) const
 {
     int16_t currentLevel = _outputAudioLevel.LevelFullRange();
     level = static_cast<int32_t> (currentLevel);
     return 0;
 }
 
 int
 Channel::SetMute(bool enable)
 {
-    CriticalSectionScoped cs(&volume_settings_critsect_);
+    rtc::CritScope cs(&volume_settings_critsect_);
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
                "Channel::SetMute(enable=%d)", enable);
     _mute = enable;
     return 0;
 }
 
 bool
 Channel::Mute() const
 {
-    CriticalSectionScoped cs(&volume_settings_critsect_);
+    rtc::CritScope cs(&volume_settings_critsect_);
     return _mute;
 }
 
 int
 Channel::SetOutputVolumePan(float left, float right)
 {
-    CriticalSectionScoped cs(&volume_settings_critsect_);
+    rtc::CritScope cs(&volume_settings_critsect_);
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
                "Channel::SetOutputVolumePan()");
     _panLeft = left;
     _panRight = right;
     return 0;
 }
 
 int
 Channel::GetOutputVolumePan(float& left, float& right) const
 {
-    CriticalSectionScoped cs(&volume_settings_critsect_);
+    rtc::CritScope cs(&volume_settings_critsect_);
     left = _panLeft;
     right = _panRight;
     return 0;
 }
 
 int
 Channel::SetChannelOutputVolumeScaling(float scaling)
 {
-    CriticalSectionScoped cs(&volume_settings_critsect_);
+    rtc::CritScope cs(&volume_settings_critsect_);
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
                "Channel::SetChannelOutputVolumeScaling()");
     _outputGain = scaling;
     return 0;
 }
 
 int
 Channel::GetChannelOutputVolumeScaling(float& scaling) const
 {
-    CriticalSectionScoped cs(&volume_settings_critsect_);
+    rtc::CritScope cs(&volume_settings_critsect_);
     scaling = _outputGain;
     return 0;
 }
 
 int Channel::SendTelephoneEventOutband(unsigned char eventCode,
                                        int lengthMs, int attenuationDb,
                                        bool playDtmfEvent)
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::SendTelephoneEventOutband(..., playDtmfEvent=%d)",
@@ skipping 89 matching lines @@
                  "Channel::UpdateRxVadDetection() => vadDecision=%d",
                  vadDecision);
     return 0;
 }
 
 int
 Channel::RegisterRxVadObserver(VoERxVadCallback &observer)
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
                  "Channel::RegisterRxVadObserver()");
-    CriticalSectionScoped cs(&_callbackCritSect);
+    rtc::CritScope cs(&_callbackCritSect);
 
     if (_rxVadObserverPtr)
     {
         _engineStatisticsPtr->SetLastError(
             VE_INVALID_OPERATION, kTraceError,
             "RegisterRxVadObserver() observer already enabled");
         return -1;
     }
     _rxVadObserverPtr = &observer;
     _RxVadDetection = true;
     return 0;
 }
 
 int
 Channel::DeRegisterRxVadObserver()
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
                  "Channel::DeRegisterRxVadObserver()");
-    CriticalSectionScoped cs(&_callbackCritSect);
+    rtc::CritScope cs(&_callbackCritSect);
 
     if (!_rxVadObserverPtr)
     {
         _engineStatisticsPtr->SetLastError(
             VE_INVALID_OPERATION, kTraceWarning,
             "DeRegisterRxVadObserver() observer already disabled");
         return 0;
     }
     _rxVadObserverPtr = NULL;
     _RxVadDetection = false;
@@ skipping 619 matching lines @@
                      " output will not be complete");
     }
 
     stats.bytesSent = bytesSent;
     stats.packetsSent = packetsSent;
     stats.bytesReceived = bytesReceived;
     stats.packetsReceived = packetsReceived;
 
     // --- Timestamps
     {
-      CriticalSectionScoped lock(ts_stats_lock_.get());
+      rtc::CritScope lock(&ts_stats_lock_);
       stats.capture_start_ntp_time_ms_ = capture_start_ntp_time_ms_;
     }
     return 0;
 }
 
 int Channel::SetREDStatus(bool enable, int redPayloadtype) {
   WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::SetREDStatus()");
 
   if (enable) {
@@ skipping 120 matching lines @@
         MixOrReplaceAudioWithFile(mixingFrequency);
     }
 
     bool is_muted = Mute();  // Cache locally as Mute() takes a lock.
     if (is_muted) {
       AudioFrameOperations::Mute(_audioFrame);
     }
 
     if (channel_state_.Get().input_external_media)
     {
-        CriticalSectionScoped cs(&_callbackCritSect);
+        rtc::CritScope cs(&_callbackCritSect);
         const bool isStereo = (_audioFrame.num_channels_ == 2);
         if (_inputExternalMediaCallbackPtr)
         {
             _inputExternalMediaCallbackPtr->Process(
                 _channelId,
                 kRecordingPerChannel,
                (int16_t*)_audioFrame.data_,
                 _audioFrame.samples_per_channel_,
                 _audioFrame.sample_rate_hz_,
                 isStereo);
@@ skipping 43 matching lines @@
         WEBRTC_TRACE(kTraceError, kTraceVoice, VoEId(_instanceId,_channelId),
                      "Channel::EncodeAndSend() ACM encoding failed");
         return 0xFFFFFFFF;
     }
 
     _timeStamp += static_cast<uint32_t>(_audioFrame.samples_per_channel_);
     return 0;
 }
 
 void Channel::DisassociateSendChannel(int channel_id) {
-  CriticalSectionScoped lock(assoc_send_channel_lock_.get());
+  rtc::CritScope lock(&assoc_send_channel_lock_);
   Channel* channel = associate_send_channel_.channel();
   if (channel && channel->ChannelId() == channel_id) {
     // If this channel is associated with a send channel of the specified
     // Channel ID, disassociate with it.
     ChannelOwner ref(NULL);
     associate_send_channel_ = ref;
   }
 }
 
 int Channel::RegisterExternalMediaProcessing(
     ProcessingTypes type,
     VoEMediaProcess& processObject)
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
                  "Channel::RegisterExternalMediaProcessing()");
 
-    CriticalSectionScoped cs(&_callbackCritSect);
+    rtc::CritScope cs(&_callbackCritSect);
 
     if (kPlaybackPerChannel == type)
     {
         if (_outputExternalMediaCallbackPtr)
         {
             _engineStatisticsPtr->SetLastError(
                 VE_INVALID_OPERATION, kTraceError,
                 "Channel::RegisterExternalMediaProcessing() "
                 "output external media already enabled");
             return -1;
@@ skipping 15 matching lines @@
         channel_state_.SetInputExternalMedia(true);
     }
     return 0;
 }
 
 int Channel::DeRegisterExternalMediaProcessing(ProcessingTypes type)
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
                  "Channel::DeRegisterExternalMediaProcessing()");
 
-    CriticalSectionScoped cs(&_callbackCritSect);
+    rtc::CritScope cs(&_callbackCritSect);
 
     if (kPlaybackPerChannel == type)
     {
         if (!_outputExternalMediaCallbackPtr)
         {
             _engineStatisticsPtr->SetLastError(
                 VE_INVALID_OPERATION, kTraceWarning,
                 "Channel::DeRegisterExternalMediaProcessing() "
                 "output external media already disabled");
             return 0;
@@ skipping 41 matching lines @@
 {
     return audio_coding_->GetNetworkStatistics(&stats);
 }
 
 void Channel::GetDecodingCallStatistics(AudioDecodingCallStats* stats) const {
   audio_coding_->GetDecodingCallStatistics(stats);
 }
 
 bool Channel::GetDelayEstimate(int* jitter_buffer_delay_ms,
                                int* playout_buffer_delay_ms) const {
-  CriticalSectionScoped cs(video_sync_lock_.get());
+  rtc::CritScope lock(&video_sync_lock_);
   if (_average_jitter_buffer_delay_us == 0) {
     return false;
   }
   *jitter_buffer_delay_ms = (_average_jitter_buffer_delay_us + 500) / 1000 +
       _recPacketDelayMs;
   *playout_buffer_delay_ms = playout_delay_ms_;
   return true;
 }
 
 uint32_t Channel::GetDelayEstimate() const {
@@ skipping 26 matching lines @@
             VE_AUDIO_CODING_MODULE_ERROR, kTraceError,
             "SetMinimumPlayoutDelay() failed to set min playout delay");
         return -1;
     }
     return 0;
 }
 
 int Channel::GetPlayoutTimestamp(unsigned int& timestamp) {
   uint32_t playout_timestamp_rtp = 0;
   {
-    CriticalSectionScoped cs(video_sync_lock_.get());
+    rtc::CritScope lock(&video_sync_lock_);
     playout_timestamp_rtp = playout_timestamp_rtp_;
   }
   if (playout_timestamp_rtp == 0)  {
     _engineStatisticsPtr->SetLastError(
         VE_CANNOT_RETRIEVE_VALUE, kTraceError,
         "GetPlayoutTimestamp() failed to retrieve timestamp");
     return -1;
   }
   timestamp = playout_timestamp_rtp;
   return 0;
@@ skipping 33 matching lines @@
 
 // TODO(andrew): refactor Mix functions here and in transmit_mixer.cc to use
 // a shared helper.
 int32_t
 Channel::MixOrReplaceAudioWithFile(int mixingFrequency)
 {
   rtc::scoped_ptr<int16_t[]> fileBuffer(new int16_t[640]);
     size_t fileSamples(0);
 
     {
-        CriticalSectionScoped cs(&_fileCritSect);
+        rtc::CritScope cs(&_fileCritSect);
 
         if (_inputFilePlayerPtr == NULL)
         {
             WEBRTC_TRACE(kTraceWarning, kTraceVoice,
                          VoEId(_instanceId, _channelId),
                          "Channel::MixOrReplaceAudioWithFile() fileplayer"
                              " doesnt exist");
             return -1;
         }
 
@@ skipping 49 matching lines @@
 int32_t
 Channel::MixAudioWithFile(AudioFrame& audioFrame,
                           int mixingFrequency)
 {
     assert(mixingFrequency <= 48000);
 
     rtc::scoped_ptr<int16_t[]> fileBuffer(new int16_t[960]);
     size_t fileSamples(0);
 
     {
-        CriticalSectionScoped cs(&_fileCritSect);
+        rtc::CritScope cs(&_fileCritSect);
 
         if (_outputFilePlayerPtr == NULL)
         {
             WEBRTC_TRACE(kTraceWarning, kTraceVoice,
                          VoEId(_instanceId, _channelId),
                          "Channel::MixAudioWithFile() file mixing failed");
             return -1;
         }
 
         // We should get the frequency we ask for.
@@ skipping 128 matching lines @@
   jitter_buffer_playout_timestamp_ = playout_timestamp;
 
   // Remove the playout delay.
   playout_timestamp -= (delay_ms * (GetPlayoutFrequency() / 1000));
 
   WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId,_channelId),
                "Channel::UpdatePlayoutTimestamp() => playoutTimestamp = %lu",
                playout_timestamp);
 
   {
-    CriticalSectionScoped cs(video_sync_lock_.get());
+    rtc::CritScope lock(&video_sync_lock_);
     if (rtcp) {
       playout_timestamp_rtcp_ = playout_timestamp;
     } else {
       playout_timestamp_rtp_ = playout_timestamp;
     }
     playout_delay_ms_ = delay_ms;
   }
 }
 
 // Called for incoming RTP packets after successful RTP header parsing.
@@ skipping 20 matching lines @@
   }
 
   uint16_t packet_delay_ms = (rtp_timestamp - _previousTimestamp) /
       (rtp_receive_frequency / 1000);
 
   _previousTimestamp = rtp_timestamp;
 
   if (timestamp_diff_ms == 0) return;
 
   {
-    CriticalSectionScoped cs(video_sync_lock_.get());
+    rtc::CritScope lock(&video_sync_lock_);
 
     if (packet_delay_ms >= 10 && packet_delay_ms <= 60) {
       _recPacketDelayMs = packet_delay_ms;
     }
 
     if (_average_jitter_buffer_delay_us == 0) {
       _average_jitter_buffer_delay_us = timestamp_diff_ms * 1000;
       return;
     }
 
@@ skipping 123 matching lines @@
   RtcpMode method = _rtpRtcpModule->RTCP();
   if (method == RtcpMode::kOff) {
     return 0;
   }
   std::vector<RTCPReportBlock> report_blocks;
   _rtpRtcpModule->RemoteRTCPStat(&report_blocks);
 
   int64_t rtt = 0;
   if (report_blocks.empty()) {
     if (allow_associate_channel) {
-      CriticalSectionScoped lock(assoc_send_channel_lock_.get());
+      rtc::CritScope lock(&assoc_send_channel_lock_);
       Channel* channel = associate_send_channel_.channel();
       // Tries to get RTT from an associated channel. This is important for
       // receive-only channels.
       if (channel) {
         // To prevent infinite recursion and deadlock, calling GetRTT of
         // associate channel should always use "false" for argument:
         // |allow_associate_channel|.
         rtt = channel->GetRTT(false);
       }
     }
@@ skipping 19 matching lines @@
   int64_t min_rtt = 0;
   if (_rtpRtcpModule->RTT(remoteSSRC, &rtt, &avg_rtt, &min_rtt, &max_rtt)
       != 0) {
     return 0;
   }
   return rtt;
 }
 
 }  // namespace voe
 }  // namespace webrtc