Remove more CriticalSectionWrappers.

webrtc/modules/audio_device/linux/audio_device_alsa_linux.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 44 matching lines @@
 static const unsigned int ALSA_CAPTURE_CH = 2;
 static const unsigned int ALSA_CAPTURE_LATENCY = 40*1000; // in us
 static const unsigned int ALSA_CAPTURE_WAIT_TIMEOUT = 5; // in ms
 
 #define FUNC_GET_NUM_OF_DEVICE 0
 #define FUNC_GET_DEVICE_NAME 1
 #define FUNC_GET_DEVICE_NAME_FOR_AN_ENUM 2
 
 AudioDeviceLinuxALSA::AudioDeviceLinuxALSA(const int32_t id) :
     _ptrAudioBuffer(NULL),
-    _critSect(*CriticalSectionWrapper::CreateCriticalSection()),
     _id(id),
     _mixerManager(id),
     _inputDeviceIndex(0),
     _outputDeviceIndex(0),
     _inputDeviceIsSpecified(false),
     _outputDeviceIsSpecified(false),
     _handleRecord(NULL),
     _handlePlayout(NULL),
     _recordingBuffersizeInFrame(0),
     _recordingPeriodSizeInFrame(0),
@@ skipping 47 matching lines @@
     if (_recordingBuffer)
     {
         delete [] _recordingBuffer;
         _recordingBuffer = NULL;
     }
     if (_playoutBuffer)
     {
         delete [] _playoutBuffer;
         _playoutBuffer = NULL;
     }
-    delete &_critSect;
 }
 
 void AudioDeviceLinuxALSA::AttachAudioBuffer(AudioDeviceBuffer* audioBuffer)
 {
 
-    CriticalSectionScoped lock(&_critSect);
+    rtc::CritScope lock(&_critSect);
 
     _ptrAudioBuffer = audioBuffer;
 
     // Inform the AudioBuffer about default settings for this implementation.
     // Set all values to zero here since the actual settings will be done by
     // InitPlayout and InitRecording later.
     _ptrAudioBuffer->SetRecordingSampleRate(0);
     _ptrAudioBuffer->SetPlayoutSampleRate(0);
     _ptrAudioBuffer->SetRecordingChannels(0);
     _ptrAudioBuffer->SetPlayoutChannels(0);
 }
 
 int32_t AudioDeviceLinuxALSA::ActiveAudioLayer(
     AudioDeviceModule::AudioLayer& audioLayer) const
 {
     audioLayer = AudioDeviceModule::kLinuxAlsaAudio;
     return 0;
 }
 
 AudioDeviceGeneric::InitStatus AudioDeviceLinuxALSA::Init() {
-  CriticalSectionScoped lock(&_critSect);
+  rtc::CritScope lock(&_critSect);
 
   // Load libasound
   if (!AlsaSymbolTable.Load()) {
     // Alsa is not installed on this system
     LOG(LS_ERROR) << "failed to load symbol table";
     return InitStatus::OTHER_ERROR;
   }
 
   if (_initialized) {
     return InitStatus::OK;
@@ skipping 16 matching lines @@
     return InitStatus::OK;
 }
 
 int32_t AudioDeviceLinuxALSA::Terminate()
 {
     if (!_initialized)
     {
         return 0;
     }
 
-    CriticalSectionScoped lock(&_critSect);
+    rtc::CritScope lock(&_critSect);
 
     _mixerManager.Close();
 
     // RECORDING
     if (_ptrThreadRec)
     {
         rtc::PlatformThread* tmpThread = _ptrThreadRec.release();
         _critSect.Leave();
 
         tmpThread->Stop();
@@ skipping 28 matching lines @@
 }
 
 bool AudioDeviceLinuxALSA::Initialized() const
 {
     return (_initialized);
 }
 
 int32_t AudioDeviceLinuxALSA::InitSpeaker()
 {
 
-    CriticalSectionScoped lock(&_critSect);
+    rtc::CritScope lock(&_critSect);
 
     if (_playing)
     {
         return -1;
     }
 
     char devName[kAdmMaxDeviceNameSize] = {0};
     GetDevicesInfo(2, true, _outputDeviceIndex, devName, kAdmMaxDeviceNameSize);
     return _mixerManager.OpenSpeaker(devName);
 }
 
 int32_t AudioDeviceLinuxALSA::InitMicrophone()
 {
 
-    CriticalSectionScoped lock(&_critSect);
+    rtc::CritScope lock(&_critSect);
 
     if (_recording)
     {
         return -1;
     }
 
     char devName[kAdmMaxDeviceNameSize] = {0};
     GetDevicesInfo(2, false, _inputDeviceIndex, devName, kAdmMaxDeviceNameSize);
     return _mixerManager.OpenMicrophone(devName);
 }
@@ skipping 281 matching lines @@
     }
 
     enabled = onOff;
 
     return 0;
 }
 
 int32_t AudioDeviceLinuxALSA::StereoRecordingIsAvailable(bool& available)
 {
 
-    CriticalSectionScoped lock(&_critSect);
+    rtc::CritScope lock(&_critSect);
 
     // If we already have initialized in stereo it's obviously available
     if (_recIsInitialized && (2 == _recChannels))
     {
         available = true;
         return 0;
     }
 
     // Save rec states and the number of rec channels
     bool recIsInitialized = _recIsInitialized;
@@ skipping 50 matching lines @@
         enabled = true;
     else
         enabled = false;
 
     return 0;
 }
 
 int32_t AudioDeviceLinuxALSA::StereoPlayoutIsAvailable(bool& available)
 {
 
-    CriticalSectionScoped lock(&_critSect);
+    rtc::CritScope lock(&_critSect);
 
     // If we already have initialized in stereo it's obviously available
     if (_playIsInitialized && (2 == _playChannels))
     {
         available = true;
         return 0;
     }
 
     // Save rec states and the number of rec channels
     bool playIsInitialized = _playIsInitialized;
@@ skipping 357 matching lines @@
     }
 
     return res;
 }
 
 int32_t AudioDeviceLinuxALSA::InitPlayout()
 {
 
     int errVal = 0;
 
-    CriticalSectionScoped lock(&_critSect);
+    rtc::CritScope lock(&_critSect);
     if (_playing)
     {
         return -1;
     }
 
     if (!_outputDeviceIsSpecified)
     {
         return -1;
     }
 
@@ skipping 132 matching lines @@
     }
 
     return 0;
 }
 
 int32_t AudioDeviceLinuxALSA::InitRecording()
 {
 
     int errVal = 0;
 
-    CriticalSectionScoped lock(&_critSect);
+    rtc::CritScope lock(&_critSect);
 
     if (_recording)
     {
         return -1;
     }
 
     if (!_inputDeviceIsSpecified)
     {
         return -1;
     }
@@ skipping 214 matching lines @@
         }
     }
 
     return 0;
 }
 
 int32_t AudioDeviceLinuxALSA::StopRecording()
 {
 
     {
-      CriticalSectionScoped lock(&_critSect);
+      rtc::CritScope lock(&_critSect);
 
       if (!_recIsInitialized)
       {
           return 0;
       }
 
       if (_handleRecord == NULL)
       {
           return -1;
       }
 
       // Make sure we don't start recording (it's asynchronous).
       _recIsInitialized = false;
       _recording = false;
     }
 
     if (_ptrThreadRec)
     {
         _ptrThreadRec->Stop();
         _ptrThreadRec.reset();
     }
 
-    CriticalSectionScoped lock(&_critSect);
+    rtc::CritScope lock(&_critSect);
     _recordingFramesLeft = 0;
     if (_recordingBuffer)
     {
         delete [] _recordingBuffer;
         _recordingBuffer = NULL;
     }
 
     // Stop and close pcm recording device.
     int errVal = LATE(snd_pcm_drop)(_handleRecord);
     if (errVal < 0)
@@ skipping 82 matching lines @@
         // if snd_pcm_open fails will return -1
     }
 
     return 0;
 }
 
 int32_t AudioDeviceLinuxALSA::StopPlayout()
 {
 
     {
-        CriticalSectionScoped lock(&_critSect);
+        rtc::CritScope lock(&_critSect);
 
         if (!_playIsInitialized)
         {
             return 0;
         }
 
         if (_handlePlayout == NULL)
         {
             return -1;
         }
 
         _playing = false;
     }
 
     // stop playout thread first
     if (_ptrThreadPlay)
     {
         _ptrThreadPlay->Stop();
         _ptrThreadPlay.reset();
     }
 
-    CriticalSectionScoped lock(&_critSect);
+    rtc::CritScope lock(&_critSect);
 
     _playoutFramesLeft = 0;
     delete [] _playoutBuffer;
     _playoutBuffer = NULL;
 
     // stop and close pcm playout device
     int errVal = LATE(snd_pcm_drop)(_handlePlayout);
     if (errVal < 0)
     {
         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
@@ skipping 69 matching lines @@
 int32_t AudioDeviceLinuxALSA::CPULoad(uint16_t& load) const
 {
 
     WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                "  API call not supported on this platform");
     return -1;
 }
 
 bool AudioDeviceLinuxALSA::PlayoutWarning() const
 {
-    CriticalSectionScoped lock(&_critSect);
+    rtc::CritScope lock(&_critSect);
     return (_playWarning > 0);
 }
 
 bool AudioDeviceLinuxALSA::PlayoutError() const
 {
-    CriticalSectionScoped lock(&_critSect);
+    rtc::CritScope lock(&_critSect);
     return (_playError > 0);
 }
 
 bool AudioDeviceLinuxALSA::RecordingWarning() const
 {
-    CriticalSectionScoped lock(&_critSect);
+    rtc::CritScope lock(&_critSect);
     return (_recWarning > 0);
 }
 
 bool AudioDeviceLinuxALSA::RecordingError() const
 {
-    CriticalSectionScoped lock(&_critSect);
+    rtc::CritScope lock(&_critSect);
     return (_recError > 0);
 }
 
 void AudioDeviceLinuxALSA::ClearPlayoutWarning()
 {
-    CriticalSectionScoped lock(&_critSect);
+    rtc::CritScope lock(&_critSect);
     _playWarning = 0;
 }
 
 void AudioDeviceLinuxALSA::ClearPlayoutError()
 {
-    CriticalSectionScoped lock(&_critSect);
+    rtc::CritScope lock(&_critSect);
     _playError = 0;
 }
 
 void AudioDeviceLinuxALSA::ClearRecordingWarning()
 {
-    CriticalSectionScoped lock(&_critSect);
+    rtc::CritScope lock(&_critSect);
     _recWarning = 0;
 }
 
 void AudioDeviceLinuxALSA::ClearRecordingError()
 {
-    CriticalSectionScoped lock(&_critSect);
+    rtc::CritScope lock(&_critSect);
     _recError = 0;
 }
 
 // ============================================================================
 //                                 Private Methods
 // ============================================================================
 
 int32_t AudioDeviceLinuxALSA::GetDevicesInfo(
     const int32_t function,
     const bool playback,
@@ skipping 521 matching lines @@
     state |= (szKey[i] ^ _oldKeyState[i]) & szKey[i];
 
   // Save old state
   memcpy((char*)_oldKeyState, (char*)szKey, sizeof(_oldKeyState));
   return (state != 0);
 #else
   return false;
 #endif
 }
 }  // namespace webrtc