Remove ALL usage of CriticalSectionWrapper.

webrtc/modules/audio_device/mac/audio_device_mac.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 75 matching lines @@
   WEBRTC_TRACE(level, module, id, "%s: %.4s", msg, err);
 #else
   // We need to flip the characters in this case.
   WEBRTC_TRACE(level, module, id, "%s: %.1s%.1s%.1s%.1s", msg, err + 3, err + 2,
                err + 1, err);
 #endif
 }
 
 AudioDeviceMac::AudioDeviceMac(const int32_t id)
     : _ptrAudioBuffer(NULL),
-      _critSect(*CriticalSectionWrapper::CreateCriticalSection()),
       _stopEventRec(*EventWrapper::Create()),
       _stopEvent(*EventWrapper::Create()),
       _id(id),
       _mixerManager(id),
       _inputDeviceIndex(0),
       _outputDeviceIndex(0),
       _inputDeviceID(kAudioObjectUnknown),
       _outputDeviceID(kAudioObjectUnknown),
       _inputDeviceIsSpecified(false),
       _outputDeviceIsSpecified(false),
@@ skipping 83 matching lines @@
   }
 
   kernErr = semaphore_destroy(mach_task_self(), _captureSemaphore);
   if (kernErr != KERN_SUCCESS) {
     WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                  " semaphore_destroy() error: %d", kernErr);
   }
 
   delete &_stopEvent;
   delete &_stopEventRec;
-  delete &_critSect;
 }
 
 // ============================================================================
 //                                     API
 // ============================================================================
 
 void AudioDeviceMac::AttachAudioBuffer(AudioDeviceBuffer* audioBuffer) {
-  CriticalSectionScoped lock(&_critSect);
+  rtc::CritScope lock(&_critSect);
 
   _ptrAudioBuffer = audioBuffer;
 
   // inform the AudioBuffer about default settings for this implementation
   _ptrAudioBuffer->SetRecordingSampleRate(N_REC_SAMPLES_PER_SEC);
   _ptrAudioBuffer->SetPlayoutSampleRate(N_PLAY_SAMPLES_PER_SEC);
   _ptrAudioBuffer->SetRecordingChannels(N_REC_CHANNELS);
   _ptrAudioBuffer->SetPlayoutChannels(N_PLAY_CHANNELS);
 }
 
 int32_t AudioDeviceMac::ActiveAudioLayer(
     AudioDeviceModule::AudioLayer& audioLayer) const {
   audioLayer = AudioDeviceModule::kPlatformDefaultAudio;
   return 0;
 }
 
 AudioDeviceGeneric::InitStatus AudioDeviceMac::Init() {
-  CriticalSectionScoped lock(&_critSect);
+  rtc::CritScope lock(&_critSect);
 
   if (_initialized) {
     return InitStatus::OK;
   }
 
   OSStatus err = noErr;
 
   _isShutDown = false;
 
   // PortAudio ring buffers require an elementCount which is a power of two.
@@ skipping 179 matching lines @@
   // Close the initialized output mixer
   //
   if (!wasInitialized) {
     _mixerManager.CloseSpeaker();
   }
 
   return 0;
 }
 
 int32_t AudioDeviceMac::InitSpeaker() {
-  CriticalSectionScoped lock(&_critSect);
+  rtc::CritScope lock(&_critSect);
 
   if (_playing) {
     return -1;
   }
 
   if (InitDevice(_outputDeviceIndex, _outputDeviceID, false) == -1) {
     return -1;
   }
 
   if (_inputDeviceID == _outputDeviceID) {
@@ skipping 27 matching lines @@
   // Close the initialized input mixer
   //
   if (!wasInitialized) {
     _mixerManager.CloseMicrophone();
   }
 
   return 0;
 }
 
 int32_t AudioDeviceMac::InitMicrophone() {
-  CriticalSectionScoped lock(&_critSect);
+  rtc::CritScope lock(&_critSect);
 
   if (_recording) {
     return -1;
   }
 
   if (InitDevice(_inputDeviceIndex, _inputDeviceID, true) == -1) {
     return -1;
   }
 
   if (_inputDeviceID == _outputDeviceID) {
@@ skipping 409 matching lines @@
   return 0;
 }
 
 int16_t AudioDeviceMac::PlayoutDevices() {
   AudioDeviceID playDevices[MaxNumberDevices];
   return GetNumberDevices(kAudioDevicePropertyScopeOutput, playDevices,
                           MaxNumberDevices);
 }
 
 int32_t AudioDeviceMac::SetPlayoutDevice(uint16_t index) {
-  CriticalSectionScoped lock(&_critSect);
+  rtc::CritScope lock(&_critSect);
 
   if (_playIsInitialized) {
     return -1;
   }
 
   AudioDeviceID playDevices[MaxNumberDevices];
   uint32_t nDevices = GetNumberDevices(kAudioDevicePropertyScopeOutput,
                                        playDevices, MaxNumberDevices);
   WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                "  number of availiable waveform-audio output devices is %u",
@@ skipping 131 matching lines @@
 
   // Cancel effect of initialization
   if (StopRecording() == -1) {
     available = false;
   }
 
   return 0;
 }
 
 int32_t AudioDeviceMac::InitPlayout() {
-  CriticalSectionScoped lock(&_critSect);
+  rtc::CritScope lock(&_critSect);
 
   if (_playing) {
     return -1;
   }
 
   if (!_outputDeviceIsSpecified) {
     return -1;
   }
 
   if (_playIsInitialized) {
@@ skipping 126 matching lines @@
     WEBRTC_CA_RETURN_ON_ERR(AudioDeviceCreateIOProcID(
         _outputDeviceID, deviceIOProc, this, &_deviceIOProcID));
   }
 
   _playIsInitialized = true;
 
   return 0;
 }
 
 int32_t AudioDeviceMac::InitRecording() {
-  CriticalSectionScoped lock(&_critSect);
+  rtc::CritScope lock(&_critSect);
 
   if (_recording) {
     return -1;
   }
 
   if (!_inputDeviceIsSpecified) {
     return -1;
   }
 
   if (_recIsInitialized) {
@@ skipping 181 matching lines @@
         _inputDeviceID, deviceIOProc, this, &_deviceIOProcID));
   }
 
   // Mark recording side as initialized
   _recIsInitialized = true;
 
   return 0;
 }
 
 int32_t AudioDeviceMac::StartRecording() {
-  CriticalSectionScoped lock(&_critSect);
+  rtc::CritScope lock(&_critSect);
 
   if (!_recIsInitialized) {
     return -1;
   }
 
   if (_recording) {
     return 0;
   }
 
   if (!_initialized) {
@@ skipping 16 matching lines @@
   } else if (!_playing) {
     WEBRTC_CA_RETURN_ON_ERR(AudioDeviceStart(_inputDeviceID, _deviceIOProcID));
   }
 
   _recording = true;
 
   return 0;
 }
 
 int32_t AudioDeviceMac::StopRecording() {
-  CriticalSectionScoped lock(&_critSect);
+  rtc::CritScope lock(&_critSect);
 
   if (!_recIsInitialized) {
     return 0;
   }
 
   OSStatus err = noErr;
 
   // Stop device
   int32_t captureDeviceIsAlive = AtomicGet32(&_captureDeviceIsAlive);
   if (_twoDevices) {
     if (_recording && captureDeviceIsAlive == 1) {
       _recording = false;
       _doStopRec = true;  // Signal to io proc to stop audio device
       _critSect.Leave();  // Cannot be under lock, risk of deadlock
       if (kEventTimeout == _stopEventRec.Wait(2000)) {
-        CriticalSectionScoped critScoped(&_critSect);
+        rtc::CritScope critScoped(&_critSect);
         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                      " Timed out stopping the capture IOProc. "
                      "We may have failed to detect a device removal.");
 
         WEBRTC_CA_LOG_WARN(AudioDeviceStop(_inputDeviceID, _inDeviceIOProcID));
         WEBRTC_CA_LOG_WARN(
             AudioDeviceDestroyIOProcID(_inputDeviceID, _inDeviceIOProcID));
       }
       _critSect.Enter();
       _doStopRec = false;
       WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, " Recording stopped");
     }
   } else {
     // We signal a stop for a shared device even when rendering has
     // not yet ended. This is to ensure the IOProc will return early as
     // intended (by checking |_recording|) before accessing
     // resources we free below (e.g. the capture converter).
     //
     // In the case of a shared devcie, the IOProc will verify
     // rendering has ended before stopping itself.
     if (_recording && captureDeviceIsAlive == 1) {
       _recording = false;
       _doStop = true;     // Signal to io proc to stop audio device
       _critSect.Leave();  // Cannot be under lock, risk of deadlock
       if (kEventTimeout == _stopEvent.Wait(2000)) {
-        CriticalSectionScoped critScoped(&_critSect);
+        rtc::CritScope critScoped(&_critSect);
         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                      " Timed out stopping the shared IOProc. "
                      "We may have failed to detect a device removal.");
 
         // We assume rendering on a shared device has stopped as well if
         // the IOProc times out.
         WEBRTC_CA_LOG_WARN(AudioDeviceStop(_outputDeviceID, _deviceIOProcID));
         WEBRTC_CA_LOG_WARN(
             AudioDeviceDestroyIOProcID(_outputDeviceID, _deviceIOProcID));
       }
@@ skipping 38 matching lines @@
 
 bool AudioDeviceMac::Recording() const {
   return (_recording);
 }
 
 bool AudioDeviceMac::PlayoutIsInitialized() const {
   return (_playIsInitialized);
 }
 
 int32_t AudioDeviceMac::StartPlayout() {
-  CriticalSectionScoped lock(&_critSect);
+  rtc::CritScope lock(&_critSect);
 
   if (!_playIsInitialized) {
     return -1;
   }
 
   if (_playing) {
     return 0;
   }
 
   RTC_DCHECK(!render_worker_thread_.get());
   render_worker_thread_.reset(
       new rtc::PlatformThread(RunRender, this, "RenderWorkerThread"));
   render_worker_thread_->Start();
   render_worker_thread_->SetPriority(rtc::kRealtimePriority);
 
   if (_twoDevices || !_recording) {
     OSStatus err = noErr;
     WEBRTC_CA_RETURN_ON_ERR(AudioDeviceStart(_outputDeviceID, _deviceIOProcID));
   }
   _playing = true;
 
   return 0;
 }
 
 int32_t AudioDeviceMac::StopPlayout() {
-  CriticalSectionScoped lock(&_critSect);
+  rtc::CritScope lock(&_critSect);
 
   if (!_playIsInitialized) {
     return 0;
   }
 
   OSStatus err = noErr;
 
   int32_t renderDeviceIsAlive = AtomicGet32(&_renderDeviceIsAlive);
   if (_playing && renderDeviceIsAlive == 1) {
     // We signal a stop for a shared device even when capturing has not
     // yet ended. This is to ensure the IOProc will return early as
     // intended (by checking |_playing|) before accessing resources we
     // free below (e.g. the render converter).
     //
     // In the case of a shared device, the IOProc will verify capturing
     // has ended before stopping itself.
     _playing = false;
     _doStop = true;     // Signal to io proc to stop audio device
     _critSect.Leave();  // Cannot be under lock, risk of deadlock
     if (kEventTimeout == _stopEvent.Wait(2000)) {
-      CriticalSectionScoped critScoped(&_critSect);
+      rtc::CritScope critScoped(&_critSect);
       WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                    " Timed out stopping the render IOProc. "
                    "We may have failed to detect a device removal.");
 
       // We assume capturing on a shared device has stopped as well if the
       // IOProc times out.
       WEBRTC_CA_LOG_WARN(AudioDeviceStop(_outputDeviceID, _deviceIOProcID));
       WEBRTC_CA_LOG_WARN(
           AudioDeviceDestroyIOProcID(_outputDeviceID, _deviceIOProcID));
     }
@@ skipping 1168 matching lines @@
     bool keyState =
         CGEventSourceKeyState(kCGEventSourceStateHIDSystemState, key_index);
     // A false -> true change in keymap means a key is pressed.
     key_down |= (keyState && !prev_key_state_[key_index]);
     // Save current state.
     prev_key_state_[key_index] = keyState;
   }
   return key_down;
 }
 }  // namespace webrtc