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

webrtc/voice_engine/output_mixer.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/output_mixer.h"
 
 #include "webrtc/base/format_macros.h"
 #include "webrtc/modules/audio_processing/include/audio_processing.h"
 #include "webrtc/modules/utility/include/audio_frame_operations.h"
-#include "webrtc/system_wrappers/include/critical_section_wrapper.h"
 #include "webrtc/system_wrappers/include/file_wrapper.h"
 #include "webrtc/system_wrappers/include/trace.h"
 #include "webrtc/voice_engine/include/voe_external_media.h"
 #include "webrtc/voice_engine/statistics.h"
 #include "webrtc/voice_engine/utility.h"
 
 namespace webrtc {
 namespace voe {
 
 void
@@ skipping 34 matching lines @@
 
     // not needed
 }
 
 void OutputMixer::RecordFileEnded(int32_t id)
 {
     WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId,-1),
                  "OutputMixer::RecordFileEnded(id=%d)", id);
     assert(id == _instanceId);
 
-    CriticalSectionScoped cs(&_fileCritSect);
+    rtc::CritScope cs(&_fileCritSect);
     _outputFileRecording = false;
     WEBRTC_TRACE(kTraceStateInfo, kTraceVoice, VoEId(_instanceId,-1),
                  "OutputMixer::RecordFileEnded() =>"
                  "output file recorder module is shutdown");
 }
 
 int32_t
 OutputMixer::Create(OutputMixer*& mixer, uint32_t instanceId)
 {
     WEBRTC_TRACE(kTraceMemory, kTraceVoice, instanceId,
                  "OutputMixer::Create(instanceId=%d)", instanceId);
     mixer = new OutputMixer(instanceId);
     if (mixer == NULL)
     {
         WEBRTC_TRACE(kTraceMemory, kTraceVoice, instanceId,
                      "OutputMixer::Create() unable to allocate memory for"
                      "mixer");
         return -1;
     }
     return 0;
 }
 
 OutputMixer::OutputMixer(uint32_t instanceId) :
-    _callbackCritSect(*CriticalSectionWrapper::CreateCriticalSection()),
-    _fileCritSect(*CriticalSectionWrapper::CreateCriticalSection()),
     _mixerModule(*AudioConferenceMixer::Create(instanceId)),
     _audioLevel(),
     _dtmfGenerator(instanceId),
     _instanceId(instanceId),
     _externalMediaCallbackPtr(NULL),
     _externalMedia(false),
     _panLeft(1.0f),
     _panRight(1.0f),
     _mixingFrequencyHz(8000),
     _outputFileRecorderPtr(NULL),
@@ skipping 24 matching lines @@
 
 OutputMixer::~OutputMixer()
 {
     WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(_instanceId,-1),
                  "OutputMixer::~OutputMixer() - dtor");
     if (_externalMedia)
     {
         DeRegisterExternalMediaProcessing();
     }
     {
-        CriticalSectionScoped cs(&_fileCritSect);
+        rtc::CritScope cs(&_fileCritSect);
         if (_outputFileRecorderPtr)
         {
             _outputFileRecorderPtr->RegisterModuleFileCallback(NULL);
             _outputFileRecorderPtr->StopRecording();
             FileRecorder::DestroyFileRecorder(_outputFileRecorderPtr);
             _outputFileRecorderPtr = NULL;
         }
     }
     _mixerModule.UnRegisterMixedStreamCallback();
     delete &_mixerModule;
-    delete &_callbackCritSect;
-    delete &_fileCritSect;
 }
 
 int32_t
 OutputMixer::SetEngineInformation(voe::Statistics& engineStatistics)
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,-1),
                  "OutputMixer::SetEngineInformation()");
     _engineStatisticsPtr = &engineStatistics;
     return 0;
 }
 
 int32_t
 OutputMixer::SetAudioProcessingModule(AudioProcessing* audioProcessingModule)
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,-1),
                  "OutputMixer::SetAudioProcessingModule("
                  "audioProcessingModule=0x%x)", audioProcessingModule);
     _audioProcessingModulePtr = audioProcessingModule;
     return 0;
 }
 
 int OutputMixer::RegisterExternalMediaProcessing(
     VoEMediaProcess& proccess_object)
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,-1),
                "OutputMixer::RegisterExternalMediaProcessing()");
 
-    CriticalSectionScoped cs(&_callbackCritSect);
+    rtc::CritScope cs(&_callbackCritSect);
     _externalMediaCallbackPtr = &proccess_object;
     _externalMedia = true;
 
     return 0;
 }
 
 int OutputMixer::DeRegisterExternalMediaProcessing()
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,-1),
                  "OutputMixer::DeRegisterExternalMediaProcessing()");
 
-    CriticalSectionScoped cs(&_callbackCritSect);
+    rtc::CritScope cs(&_callbackCritSect);
     _externalMedia = false;
     _externalMediaCallbackPtr = NULL;
 
     return 0;
 }
 
 int OutputMixer::PlayDtmfTone(uint8_t eventCode, int lengthMs,
                               int attenuationDb)
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
@@ skipping 103 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 59 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 @@
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,-1),
                  "OutputMixer::StopRecordingPlayout()");
 
     if (!_outputFileRecording)
     {
         WEBRTC_TRACE(kTraceError, kTraceVoice, VoEId(_instanceId,-1),
                      "StopRecordingPlayout() file 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;
 }
 
 int OutputMixer::GetMixedAudio(int sample_rate_hz,
                                size_t num_channels,
                                AudioFrame* frame) {
   WEBRTC_TRACE(
       kTraceStream, kTraceVoice, VoEId(_instanceId,-1),
       "OutputMixer::GetMixedAudio(sample_rate_hz=%d, num_channels=%" PRIuS ")",
       sample_rate_hz, num_channels);
 
   // --- Record playout if enabled
   {
-    CriticalSectionScoped cs(&_fileCritSect);
+    rtc::CritScope cs(&_fileCritSect);
     if (_outputFileRecording && _outputFileRecorderPtr)
       _outputFileRecorderPtr->RecordAudioToFile(_audioFrame);
   }
 
   frame->num_channels_ = num_channels;
   frame->sample_rate_hz_ = sample_rate_hz;
   // TODO(andrew): Ideally the downmixing would occur much earlier, in
   // AudioCodingModule.
   RemixAndResample(_audioFrame, &resampler_, frame);
   return 0;
@@ skipping 43 matching lines @@
 
       if (_audioProcessingModulePtr->AnalyzeReverseStream(&frame) != 0) {
         WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, -1),
                      "AudioProcessingModule::AnalyzeReverseStream() => error");
         RTC_DCHECK(false);
       }
     }
 
     // --- External media processing
     {
-        CriticalSectionScoped cs(&_callbackCritSect);
+        rtc::CritScope cs(&_callbackCritSect);
         if (_externalMedia)
         {
             const bool is_stereo = (_audioFrame.num_channels_ == 2);
             if (_externalMediaCallbackPtr)
             {
                 _externalMediaCallbackPtr->Process(
                     -1,
                     kPlaybackAllChannelsMixed,
                     (int16_t*)_audioFrame.data_,
                     _audioFrame.samples_per_channel_,
@@ skipping 52 matching lines @@
             _audioFrame.data_[2 * i + 1] = 0;
         }
     }
     assert(_audioFrame.samples_per_channel_ == toneSamples);
 
     return 0;
 }
 
 }  // namespace voe
 }  // namespace webrtc