Remove more CriticalSectionWrappers.

webrtc/modules/audio_device/linux/audio_device_pulse_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 12 matching lines @@
 // directly. This way we don't have to link to libpulse, which means our binary
 // will work on systems that don't have it.
 #define LATE(sym) \
   LATESYM_GET(webrtc_adm_linux_pulse::PulseAudioSymbolTable, &PaSymbolTable, sym)
 
 namespace webrtc
 {
 
 AudioDeviceLinuxPulse::AudioDeviceLinuxPulse(const int32_t id) :
     _ptrAudioBuffer(NULL),
-    _critSect(*CriticalSectionWrapper::CreateCriticalSection()),
     _timeEventRec(*EventWrapper::Create()),
     _timeEventPlay(*EventWrapper::Create()),
     _recStartEvent(*EventWrapper::Create()),
     _playStartEvent(*EventWrapper::Create()),
     _id(id),
     _mixerManager(id),
     _inputDeviceIndex(0),
     _outputDeviceIndex(0),
     _inputDeviceIsSpecified(false),
     _outputDeviceIsSpecified(false),
@@ skipping 82 matching lines @@
     if (_recDeviceName)
     {
         delete [] _recDeviceName;
         _recDeviceName = NULL;
     }
 
     delete &_recStartEvent;
     delete &_playStartEvent;
     delete &_timeEventRec;
     delete &_timeEventPlay;
-    delete &_critSect;
 }
 
 void AudioDeviceLinuxPulse::AttachAudioBuffer(AudioDeviceBuffer* audioBuffer)
 {
     RTC_DCHECK(thread_checker_.CalledOnValidThread());
 
     _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
@@ skipping 597 matching lines @@
     if (_playChannels == 2)
         enabled = true;
     else
         enabled = false;
 
     return 0;
 }
 
 int32_t AudioDeviceLinuxPulse::SetAGC(bool enable)
 {
-    CriticalSectionScoped lock(&_critSect);
+    rtc::CritScope lock(&_critSect);
     _AGC = enable;
 
     return 0;
 }
 
 bool AudioDeviceLinuxPulse::AGC() const
 {
-    CriticalSectionScoped lock(&_critSect);
+    rtc::CritScope lock(&_critSect);
     return _AGC;
 }
 
 int32_t AudioDeviceLinuxPulse::MicrophoneVolumeIsAvailable(
     bool& available)
 {
     RTC_DCHECK(thread_checker_.CalledOnValidThread());
     bool wasInitialized = _mixerManager.MicrophoneIsInitialized();
 
     // Make an attempt to open up the
@@ skipping 566 matching lines @@
     }
 
     // Set state to ensure that the recording starts from the audio thread.
     _startRec = true;
 
     // The audio thread will signal when recording has started.
     _timeEventRec.Set();
     if (kEventTimeout == _recStartEvent.Wait(10000))
     {
         {
-            CriticalSectionScoped lock(&_critSect);
+            rtc::CritScope lock(&_critSect);
             _startRec = false;
         }
         StopRecording();
         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                      "  failed to activate recording");
         return -1;
     }
 
     {
-        CriticalSectionScoped lock(&_critSect);
+        rtc::CritScope lock(&_critSect);
         if (_recording)
         {
             // The recording state is set by the audio thread after recording
             // has started.
         } else
         {
             WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                          "  failed to activate recording");
             return -1;
         }
     }
 
     return 0;
 }
 
 int32_t AudioDeviceLinuxPulse::StopRecording()
 {
     RTC_DCHECK(thread_checker_.CalledOnValidThread());
-    CriticalSectionScoped lock(&_critSect);
+    rtc::CritScope lock(&_critSect);
 
     if (!_recIsInitialized)
     {
         return 0;
     }
 
     if (_recStream == NULL)
     {
         return -1;
     }
@@ skipping 73 matching lines @@
         return -1;
     }
 
     if (_playing)
     {
         return 0;
     }
 
     // Set state to ensure that playout starts from the audio thread.
     {
-        CriticalSectionScoped lock(&_critSect);
+        rtc::CritScope lock(&_critSect);
         _startPlay = true;
     }
 
     // Both |_startPlay| and |_playing| needs protction since they are also
     // accessed on the playout thread.
 
     // The audio thread will signal when playout has started.
     _timeEventPlay.Set();
     if (kEventTimeout == _playStartEvent.Wait(10000))
     {
         {
-            CriticalSectionScoped lock(&_critSect);
+            rtc::CritScope lock(&_critSect);
             _startPlay = false;
         }
         StopPlayout();
         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                      "  failed to activate playout");
         return -1;
     }
 
     {
-        CriticalSectionScoped lock(&_critSect);
+        rtc::CritScope lock(&_critSect);
         if (_playing)
         {
             // The playing state is set by the audio thread after playout
             // has started.
         } else
         {
             WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                          "  failed to activate playing");
             return -1;
         }
     }
 
     return 0;
 }
 
 int32_t AudioDeviceLinuxPulse::StopPlayout()
 {
     RTC_DCHECK(thread_checker_.CalledOnValidThread());
-    CriticalSectionScoped lock(&_critSect);
+    rtc::CritScope lock(&_critSect);
 
     if (!_playIsInitialized)
     {
         return 0;
     }
 
     if (_playStream == NULL)
     {
         return -1;
     }
@@ skipping 43 matching lines @@
     {
         delete [] _playBuffer;
         _playBuffer = NULL;
     }
 
     return 0;
 }
 
 int32_t AudioDeviceLinuxPulse::PlayoutDelay(uint16_t& delayMS) const
 {
-    CriticalSectionScoped lock(&_critSect);
+    rtc::CritScope lock(&_critSect);
     delayMS = (uint16_t) _sndCardPlayDelay;
     return 0;
 }
 
 int32_t AudioDeviceLinuxPulse::RecordingDelay(uint16_t& delayMS) const
 {
     RTC_DCHECK(thread_checker_.CalledOnValidThread());
     delayMS = (uint16_t) _sndCardRecDelay;
     return 0;
 }
@@ skipping 36 matching lines @@
 int32_t AudioDeviceLinuxPulse::CPULoad(uint16_t& /*load*/) const
 {
 
     WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                  "  API call not supported on this platform");
     return -1;
 }
 
 bool AudioDeviceLinuxPulse::PlayoutWarning() const
 {
-  CriticalSectionScoped lock(&_critSect);
+  rtc::CritScope lock(&_critSect);
   return (_playWarning > 0);
 }
 
 bool AudioDeviceLinuxPulse::PlayoutError() const
 {
-  CriticalSectionScoped lock(&_critSect);
+  rtc::CritScope lock(&_critSect);
   return (_playError > 0);
 }
 
 bool AudioDeviceLinuxPulse::RecordingWarning() const
 {
-  CriticalSectionScoped lock(&_critSect);
+  rtc::CritScope lock(&_critSect);
   return (_recWarning > 0);
 }
 
 bool AudioDeviceLinuxPulse::RecordingError() const
 {
-  CriticalSectionScoped lock(&_critSect);
+  rtc::CritScope lock(&_critSect);
   return (_recError > 0);
 }
 
 void AudioDeviceLinuxPulse::ClearPlayoutWarning()
 {
-  CriticalSectionScoped lock(&_critSect);
+  rtc::CritScope lock(&_critSect);
   _playWarning = 0;
 }
 
 void AudioDeviceLinuxPulse::ClearPlayoutError()
 {
-  CriticalSectionScoped lock(&_critSect);
+  rtc::CritScope lock(&_critSect);
   _playError = 0;
 }
 
 void AudioDeviceLinuxPulse::ClearRecordingWarning()
 {
-  CriticalSectionScoped lock(&_critSect);
+  rtc::CritScope lock(&_critSect);
   _recWarning = 0;
 }
 
 void AudioDeviceLinuxPulse::ClearRecordingError()
 {
-  CriticalSectionScoped lock(&_critSect);
+  rtc::CritScope lock(&_critSect);
   _recError = 0;
 }
 
 // ============================================================================
 //                                 Private Methods
 // ============================================================================
 
 void AudioDeviceLinuxPulse::PaContextStateCallback(pa_context *c, void *pThis)
 {
     static_cast<AudioDeviceLinuxPulse*> (pThis)->
@@ skipping 908 matching lines @@
         case kEventSignaled:
             break;
         case kEventError:
             WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                          "EventWrapper::Wait() failed");
             return true;
         case kEventTimeout:
             return true;
     }
 
-    CriticalSectionScoped lock(&_critSect);
+    rtc::CritScope lock(&_critSect);
 
     if (_startPlay)
     {
         WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                      "_startPlay true, performing initial actions");
 
         _startPlay = false;
         _playDeviceName = NULL;
 
         // Set if not default device
@@ skipping 220 matching lines @@
         case kEventSignaled:
             break;
         case kEventError:
             WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                          "EventWrapper::Wait() failed");
             return true;
         case kEventTimeout:
             return true;
     }
 
-    CriticalSectionScoped lock(&_critSect);
+    rtc::CritScope lock(&_critSect);
 
     if (_startRec)
     {
         WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                      "_startRec true, performing initial actions");
 
         _recDeviceName = NULL;
 
         // Set if not default device
         if (_inputDeviceIndex > 0)
@@ skipping 130 matching lines @@
 
   // A bit change in keymap means a key is pressed
   for (i = 0; i < sizeof(szKey); i++)
     state |= (szKey[i] ^ _oldKeyState[i]) & szKey[i];
 
   // Save old state
   memcpy((char*)_oldKeyState, (char*)szKey, sizeof(_oldKeyState));
   return (state != 0);
 }
 }