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

webrtc/voice_engine/channel.h

 /*
  *  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 29 matching lines @@
 
 namespace rtc {
 
 class TimestampWrapAroundHandler;
 }
 
 namespace webrtc {
 
 class AudioDeviceModule;
 class Config;
-class CriticalSectionWrapper;
 class FileWrapper;
 class PacketRouter;
 class ProcessThread;
 class ReceiveStatistics;
 class RemoteNtpTimeEstimator;
 class RtcEventLog;
 class RTPPayloadRegistry;
 class RtpReceiver;
 class RTPReceiverAudio;
 class RtpRtcp;
@@ skipping 35 matching lines @@
 
         bool rx_apm_is_enabled;
         bool input_external_media;
         bool output_file_playing;
         bool input_file_playing;
         bool playing;
         bool sending;
         bool receiving;
     };
 
-    ChannelState() : lock_(CriticalSectionWrapper::CreateCriticalSection()) {
-    }
+    ChannelState() {}
     virtual ~ChannelState() {}
 
     void Reset() {
-        CriticalSectionScoped lock(lock_.get());
+        rtc::CritScope lock(&lock_);
         state_ = State();
     }
 
     State Get() const {
-        CriticalSectionScoped lock(lock_.get());
+        rtc::CritScope lock(&lock_);
         return state_;
     }
 
     void SetRxApmIsEnabled(bool enable) {
-        CriticalSectionScoped lock(lock_.get());
+        rtc::CritScope lock(&lock_);
         state_.rx_apm_is_enabled = enable;
     }
 
     void SetInputExternalMedia(bool enable) {
-        CriticalSectionScoped lock(lock_.get());
+        rtc::CritScope lock(&lock_);
         state_.input_external_media = enable;
     }
 
     void SetOutputFilePlaying(bool enable) {
-        CriticalSectionScoped lock(lock_.get());
+        rtc::CritScope lock(&lock_);
         state_.output_file_playing = enable;
     }
 
     void SetInputFilePlaying(bool enable) {
-        CriticalSectionScoped lock(lock_.get());
+        rtc::CritScope lock(&lock_);
         state_.input_file_playing = enable;
     }
 
     void SetPlaying(bool enable) {
-        CriticalSectionScoped lock(lock_.get());
+        rtc::CritScope lock(&lock_);
         state_.playing = enable;
     }
 
     void SetSending(bool enable) {
-        CriticalSectionScoped lock(lock_.get());
+        rtc::CritScope lock(&lock_);
         state_.sending = enable;
     }
 
     void SetReceiving(bool enable) {
-        CriticalSectionScoped lock(lock_.get());
+        rtc::CritScope lock(&lock_);
         state_.receiving = enable;
     }
 
 private:
- rtc::scoped_ptr<CriticalSectionWrapper> lock_;
+    mutable rtc::CriticalSection lock_;
     State state_;
 };
 
 class Channel:
     public RtpData,
     public RtpFeedback,
     public FileCallback, // receiving notification from file player & recorder
     public Transport,
     public RtpAudioFeedback,
     public AudioPacketizationCallback, // receive encoded packets from the ACM
@@ skipping 16 matching lines @@
             RtcEventLog* const event_log,
             const Config& config);
     int32_t Init();
     int32_t SetEngineInformation(
         Statistics& engineStatistics,
         OutputMixer& outputMixer,
         TransmitMixer& transmitMixer,
         ProcessThread& moduleProcessThread,
         AudioDeviceModule& audioDeviceModule,
         VoiceEngineObserver* voiceEngineObserver,
-        CriticalSectionWrapper* callbackCritSect);
+        rtc::CriticalSection* callbackCritSect);
     int32_t UpdateLocalTimeStamp();
 
     void SetSink(rtc::scoped_ptr<AudioSinkInterface> sink);
 
     // API methods
 
     // VoEBase
     int32_t StartPlayout();
     int32_t StopPlayout();
     int32_t StartSend();
@@ skipping 219 matching lines @@
     bool Sending() const
     {
         return channel_state_.Get().sending;
     }
     bool Receiving() const
     {
         return channel_state_.Get().receiving;
     }
     bool ExternalTransport() const
     {
-        CriticalSectionScoped cs(&_callbackCritSect);
+        rtc::CritScope cs(&_callbackCritSect);
         return _externalTransport;
     }
     bool ExternalMixing() const
     {
         return _externalMixing;
     }
     RtpRtcp* RtpRtcpModulePtr() const
     {
         return _rtpRtcpModule.get();
     }
     int8_t OutputEnergyLevel() const
     {
         return _outputAudioLevel.Level();
     }
     uint32_t Demultiplex(const AudioFrame& audioFrame);
     // Demultiplex the data to the channel's |_audioFrame|. The difference
     // between this method and the overloaded method above is that |audio_data|
     // does not go through transmit_mixer and APM.
     void Demultiplex(const int16_t* audio_data,
                      int sample_rate,
                      size_t number_of_frames,
                      size_t number_of_channels);
     uint32_t PrepareEncodeAndSend(int mixingFrequency);
     uint32_t EncodeAndSend();
 
     // Associate to a send channel.
     // Used for obtaining RTT for a receive-only channel.
     void set_associate_send_channel(const ChannelOwner& channel) {
       assert(_channelId != channel.channel()->ChannelId());
-      CriticalSectionScoped lock(assoc_send_channel_lock_.get());
+      rtc::CritScope lock(&assoc_send_channel_lock_);
       associate_send_channel_ = channel;
     }
 
     // Disassociate a send channel if it was associated.
     void DisassociateSendChannel(int channel_id);
 
 protected:
     void OnIncomingFractionLoss(int fraction_lost);
 
 private:
@@ skipping 13 matching lines @@
                            uint16_t sequenceNumber);
     void RegisterReceiveCodecsToRTPModule();
 
     int SetRedPayloadType(int red_payload_type);
     int SetSendRtpHeaderExtension(bool enable, RTPExtensionType type,
                                   unsigned char id);
 
     int32_t GetPlayoutFrequency();
     int64_t GetRTT(bool allow_associate_channel) const;
 
-    CriticalSectionWrapper& _fileCritSect;
-    CriticalSectionWrapper& _callbackCritSect;
-    CriticalSectionWrapper& volume_settings_critsect_;
+    mutable rtc::CriticalSection _fileCritSect;
+    mutable rtc::CriticalSection _callbackCritSect;
+    mutable rtc::CriticalSection volume_settings_critsect_;
     uint32_t _instanceId;
     int32_t _channelId;
 
     ChannelState channel_state_;
 
     RtcEventLog* const event_log_;
 
     rtc::scoped_ptr<RtpHeaderParser> rtp_header_parser_;
     rtc::scoped_ptr<RTPPayloadRegistry> rtp_payload_registry_;
     rtc::scoped_ptr<ReceiveStatistics> rtp_receive_statistics_;
@@ skipping 27 matching lines @@
 
     // Timestamp of the audio pulled from NetEq.
     uint32_t jitter_buffer_playout_timestamp_;
     uint32_t playout_timestamp_rtp_ GUARDED_BY(video_sync_lock_);
     uint32_t playout_timestamp_rtcp_;
     uint32_t playout_delay_ms_ GUARDED_BY(video_sync_lock_);
     uint32_t _numberOfDiscardedPackets;
     uint16_t send_sequence_number_;
     uint8_t restored_packet_[kVoiceEngineMaxIpPacketSizeBytes];
 
-    rtc::scoped_ptr<CriticalSectionWrapper> ts_stats_lock_;
+    mutable rtc::CriticalSection ts_stats_lock_;
 
     rtc::scoped_ptr<rtc::TimestampWrapAroundHandler> rtp_ts_wraparound_handler_;
     // The rtp timestamp of the first played out audio frame.
     int64_t capture_start_rtp_time_stamp_;
     // The capture ntp time (in local timebase) of the first played out audio
     // frame.
     int64_t capture_start_ntp_time_ms_ GUARDED_BY(ts_stats_lock_);
 
     // uses
     Statistics* _engineStatisticsPtr;
     OutputMixer* _outputMixerPtr;
     TransmitMixer* _transmitMixerPtr;
     ProcessThread* _moduleProcessThreadPtr;
     AudioDeviceModule* _audioDeviceModulePtr;
     VoiceEngineObserver* _voiceEngineObserverPtr; // owned by base
-    CriticalSectionWrapper* _callbackCritSectPtr; // owned by base
+    rtc::CriticalSection* _callbackCritSectPtr; // owned by base
     Transport* _transportPtr; // WebRtc socket or external transport
     RMSLevel rms_level_;
     rtc::scoped_ptr<AudioProcessing> rx_audioproc_;  // far end AudioProcessing
     VoERxVadCallback* _rxVadObserverPtr;
     int32_t _oldVadDecision;
     int32_t _sendFrameType; // Send data is voice, 1-voice, 0-otherwise
     // VoEBase
     bool _externalMixing;
     bool _mixFileWithMicrophone;
     // VoEVolumeControl
     bool _mute;
     float _panLeft;
     float _panRight;
     float _outputGain;
     // VoEDtmf
     bool _playOutbandDtmfEvent;
     bool _playInbandDtmfEvent;
     // VoeRTP_RTCP
     uint32_t _lastLocalTimeStamp;
     int8_t _lastPayloadType;
     bool _includeAudioLevelIndication;
     // VoENetwork
     AudioFrame::SpeechType _outputSpeechType;
     // VoEVideoSync
-    rtc::scoped_ptr<CriticalSectionWrapper> video_sync_lock_;
+    mutable rtc::CriticalSection video_sync_lock_;
     uint32_t _average_jitter_buffer_delay_us GUARDED_BY(video_sync_lock_);
     uint32_t _previousTimestamp;
     uint16_t _recPacketDelayMs GUARDED_BY(video_sync_lock_);
     // VoEAudioProcessing
     bool _RxVadDetection;
     bool _rxAgcIsEnabled;
     bool _rxNsIsEnabled;
     bool restored_packet_in_use_;
     // RtcpBandwidthObserver
     rtc::scoped_ptr<VoERtcpObserver> rtcp_observer_;
     rtc::scoped_ptr<NetworkPredictor> network_predictor_;
     // An associated send channel.
-    rtc::scoped_ptr<CriticalSectionWrapper> assoc_send_channel_lock_;
+    mutable rtc::CriticalSection assoc_send_channel_lock_;
     ChannelOwner associate_send_channel_ GUARDED_BY(assoc_send_channel_lock_);
 
     bool pacing_enabled_;
     PacketRouter* packet_router_ = nullptr;
     rtc::scoped_ptr<TransportFeedbackProxy> feedback_observer_proxy_;
     rtc::scoped_ptr<TransportSequenceNumberProxy> seq_num_allocator_proxy_;
     rtc::scoped_ptr<RtpPacketSenderProxy> rtp_packet_sender_proxy_;
 };
 
 }  // namespace voe
 }  // namespace webrtc
 
 #endif  // WEBRTC_VOICE_ENGINE_CHANNEL_H_