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

webrtc/voice_engine/voe_base_impl.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/voe_base_impl.h"
 
 #include "webrtc/base/format_macros.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/common.h"
 #include "webrtc/common_audio/signal_processing/include/signal_processing_library.h"
 #include "webrtc/modules/audio_coding/include/audio_coding_module.h"
 #include "webrtc/modules/audio_device/audio_device_impl.h"
 #include "webrtc/modules/audio_processing/include/audio_processing.h"
-#include "webrtc/system_wrappers/include/critical_section_wrapper.h"
 #include "webrtc/system_wrappers/include/file_wrapper.h"
 #include "webrtc/voice_engine/channel.h"
 #include "webrtc/voice_engine/include/voe_errors.h"
 #include "webrtc/voice_engine/output_mixer.h"
 #include "webrtc/voice_engine/transmit_mixer.h"
 #include "webrtc/voice_engine/utility.h"
 #include "webrtc/voice_engine/voice_engine_impl.h"
 
 namespace webrtc {
 
 VoEBase* VoEBase::GetInterface(VoiceEngine* voiceEngine) {
   if (nullptr == voiceEngine) {
     return nullptr;
   }
   VoiceEngineImpl* s = static_cast<VoiceEngineImpl*>(voiceEngine);
   s->AddRef();
   return s;
 }
 
 VoEBaseImpl::VoEBaseImpl(voe::SharedData* shared)
     : voiceEngineObserverPtr_(nullptr),
-      callbackCritSect_(*CriticalSectionWrapper::CreateCriticalSection()),
       shared_(shared) {}
 
 VoEBaseImpl::~VoEBaseImpl() {
   TerminateInternal();
-  delete &callbackCritSect_;
 }
 
 void VoEBaseImpl::OnErrorIsReported(const ErrorCode error) {
-  CriticalSectionScoped cs(&callbackCritSect_);
+  rtc::CritScope cs(&callbackCritSect_);
   int errCode = 0;
   if (error == AudioDeviceObserver::kRecordingError) {
     errCode = VE_RUNTIME_REC_ERROR;
     LOG_F(LS_ERROR) << "VE_RUNTIME_REC_ERROR";
   } else if (error == AudioDeviceObserver::kPlayoutError) {
     errCode = VE_RUNTIME_PLAY_ERROR;
     LOG_F(LS_ERROR) << "VE_RUNTIME_PLAY_ERROR";
   }
   if (voiceEngineObserverPtr_) {
     // Deliver callback (-1 <=> no channel dependency)
     voiceEngineObserverPtr_->CallbackOnError(-1, errCode);
   }
 }
 
 void VoEBaseImpl::OnWarningIsReported(const WarningCode warning) {
-  CriticalSectionScoped cs(&callbackCritSect_);
+  rtc::CritScope cs(&callbackCritSect_);
   int warningCode = 0;
   if (warning == AudioDeviceObserver::kRecordingWarning) {
     warningCode = VE_RUNTIME_REC_WARNING;
     LOG_F(LS_WARNING) << "VE_RUNTIME_REC_WARNING";
   } else if (warning == AudioDeviceObserver::kPlayoutWarning) {
     warningCode = VE_RUNTIME_PLAY_WARNING;
     LOG_F(LS_WARNING) << "VE_RUNTIME_PLAY_WARNING";
   }
   if (voiceEngineObserverPtr_) {
     // Deliver callback (-1 <=> no channel dependency)
@@ skipping 91 matching lines @@
                                  void* audio_data, int64_t* elapsed_time_ms,
                                  int64_t* ntp_time_ms) {
   assert(bits_per_sample == 16);
   assert(number_of_frames == static_cast<size_t>(sample_rate / 100));
 
   GetPlayoutData(sample_rate, number_of_channels, number_of_frames, false,
                  audio_data, elapsed_time_ms, ntp_time_ms);
 }
 
 int VoEBaseImpl::RegisterVoiceEngineObserver(VoiceEngineObserver& observer) {
-  CriticalSectionScoped cs(&callbackCritSect_);
+  rtc::CritScope cs(&callbackCritSect_);
   if (voiceEngineObserverPtr_) {
     shared_->SetLastError(
         VE_INVALID_OPERATION, kTraceError,
         "RegisterVoiceEngineObserver() observer already enabled");
     return -1;
   }
 
   // Register the observer in all active channels
   for (voe::ChannelManager::Iterator it(&shared_->channel_manager());
        it.IsValid(); it.Increment()) {
     it.GetChannel()->RegisterVoiceEngineObserver(observer);
   }
 
   shared_->transmit_mixer()->RegisterVoiceEngineObserver(observer);
   voiceEngineObserverPtr_ = &observer;
   return 0;
 }
 
 int VoEBaseImpl::DeRegisterVoiceEngineObserver() {
-  CriticalSectionScoped cs(&callbackCritSect_);
+  rtc::CritScope cs(&callbackCritSect_);
   if (!voiceEngineObserverPtr_) {
     shared_->SetLastError(
         VE_INVALID_OPERATION, kTraceError,
         "DeRegisterVoiceEngineObserver() observer already disabled");
     return 0;
   }
   voiceEngineObserverPtr_ = nullptr;
 
   // Deregister the observer in all active channels
   for (voe::ChannelManager::Iterator it(&shared_->channel_manager());
        it.IsValid(); it.Increment()) {
     it.GetChannel()->DeRegisterVoiceEngineObserver();
   }
 
   return 0;
 }
 
 int VoEBaseImpl::Init(AudioDeviceModule* external_adm,
                       AudioProcessing* audioproc) {
-  CriticalSectionScoped cs(shared_->crit_sec());
+  rtc::CritScope cs(shared_->crit_sec());
   WebRtcSpl_Init();
   if (shared_->statistics().Initialized()) {
     return 0;
   }
   if (shared_->process_thread()) {
     shared_->process_thread()->Start();
   }
 
   // Create an internal ADM if the user has not added an external
   // ADM implementation as input to Init().
@@ skipping 145 matching lines @@
     shared_->SetLastError(VE_AUDIO_DEVICE_MODULE_ERROR);
     // TODO(ajm): No error return here due to
     // https://code.google.com/p/webrtc/issues/detail?id=1464
   }
 #endif
 
   return shared_->statistics().SetInitialized();
 }
 
 int VoEBaseImpl::Terminate() {
-  CriticalSectionScoped cs(shared_->crit_sec());
+  rtc::CritScope cs(shared_->crit_sec());
   return TerminateInternal();
 }
 
 int VoEBaseImpl::CreateChannel() {
-  CriticalSectionScoped cs(shared_->crit_sec());
+  rtc::CritScope cs(shared_->crit_sec());
   if (!shared_->statistics().Initialized()) {
     shared_->SetLastError(VE_NOT_INITED, kTraceError);
     return -1;
   }
 
   voe::ChannelOwner channel_owner = shared_->channel_manager().CreateChannel();
   return InitializeChannel(&channel_owner);
 }
 
 int VoEBaseImpl::CreateChannel(const Config& config) {
-  CriticalSectionScoped cs(shared_->crit_sec());
+  rtc::CritScope cs(shared_->crit_sec());
   if (!shared_->statistics().Initialized()) {
     shared_->SetLastError(VE_NOT_INITED, kTraceError);
     return -1;
   }
   voe::ChannelOwner channel_owner =
       shared_->channel_manager().CreateChannel(config);
   return InitializeChannel(&channel_owner);
 }
 
 int VoEBaseImpl::InitializeChannel(voe::ChannelOwner* channel_owner) {
@@ skipping 15 matching lines @@
         "CreateChannel() failed to initialize channel. Destroying"
         " channel.");
     shared_->channel_manager().DestroyChannel(
         channel_owner->channel()->ChannelId());
     return -1;
   }
   return channel_owner->channel()->ChannelId();
 }
 
 int VoEBaseImpl::DeleteChannel(int channel) {
-  CriticalSectionScoped cs(shared_->crit_sec());
+  rtc::CritScope cs(shared_->crit_sec());
   if (!shared_->statistics().Initialized()) {
     shared_->SetLastError(VE_NOT_INITED, kTraceError);
     return -1;
   }
 
   {
     voe::ChannelOwner ch = shared_->channel_manager().GetChannel(channel);
     voe::Channel* channelPtr = ch.channel();
     if (channelPtr == nullptr) {
       shared_->SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
                             "DeleteChannel() failed to locate channel");
       return -1;
     }
   }
 
   shared_->channel_manager().DestroyChannel(channel);
   if (StopSend() != 0) {
     return -1;
   }
   if (StopPlayout() != 0) {
     return -1;
   }
   return 0;
 }
 
 int VoEBaseImpl::StartReceive(int channel) {
-  CriticalSectionScoped cs(shared_->crit_sec());
+  rtc::CritScope cs(shared_->crit_sec());
   if (!shared_->statistics().Initialized()) {
     shared_->SetLastError(VE_NOT_INITED, kTraceError);
     return -1;
   }
   voe::ChannelOwner ch = shared_->channel_manager().GetChannel(channel);
   voe::Channel* channelPtr = ch.channel();
   if (channelPtr == nullptr) {
     shared_->SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
                           "StartReceive() failed to locate channel");
     return -1;
   }
   return channelPtr->StartReceiving();
 }
 
 int VoEBaseImpl::StopReceive(int channel) {
-  CriticalSectionScoped cs(shared_->crit_sec());
+  rtc::CritScope cs(shared_->crit_sec());
   if (!shared_->statistics().Initialized()) {
     shared_->SetLastError(VE_NOT_INITED, kTraceError);
     return -1;
   }
   voe::ChannelOwner ch = shared_->channel_manager().GetChannel(channel);
   voe::Channel* channelPtr = ch.channel();
   if (channelPtr == nullptr) {
     shared_->SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
                           "SetLocalReceiver() failed to locate channel");
     return -1;
   }
   return channelPtr->StopReceiving();
 }
 
 int VoEBaseImpl::StartPlayout(int channel) {
-  CriticalSectionScoped cs(shared_->crit_sec());
+  rtc::CritScope cs(shared_->crit_sec());
   if (!shared_->statistics().Initialized()) {
     shared_->SetLastError(VE_NOT_INITED, kTraceError);
     return -1;
   }
   voe::ChannelOwner ch = shared_->channel_manager().GetChannel(channel);
   voe::Channel* channelPtr = ch.channel();
   if (channelPtr == nullptr) {
     shared_->SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
                           "StartPlayout() failed to locate channel");
     return -1;
   }
   if (channelPtr->Playing()) {
     return 0;
   }
   if (StartPlayout() != 0) {
     shared_->SetLastError(VE_AUDIO_DEVICE_MODULE_ERROR, kTraceError,
                           "StartPlayout() failed to start playout");
     return -1;
   }
   return channelPtr->StartPlayout();
 }
 
 int VoEBaseImpl::StopPlayout(int channel) {
-  CriticalSectionScoped cs(shared_->crit_sec());
+  rtc::CritScope cs(shared_->crit_sec());
   if (!shared_->statistics().Initialized()) {
     shared_->SetLastError(VE_NOT_INITED, kTraceError);
     return -1;
   }
   voe::ChannelOwner ch = shared_->channel_manager().GetChannel(channel);
   voe::Channel* channelPtr = ch.channel();
   if (channelPtr == nullptr) {
     shared_->SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
                           "StopPlayout() failed to locate channel");
     return -1;
   }
   if (channelPtr->StopPlayout() != 0) {
     LOG_F(LS_WARNING) << "StopPlayout() failed to stop playout for channel "
                       << channel;
   }
   return StopPlayout();
 }
 
 int VoEBaseImpl::StartSend(int channel) {
-  CriticalSectionScoped cs(shared_->crit_sec());
+  rtc::CritScope cs(shared_->crit_sec());
   if (!shared_->statistics().Initialized()) {
     shared_->SetLastError(VE_NOT_INITED, kTraceError);
     return -1;
   }
   voe::ChannelOwner ch = shared_->channel_manager().GetChannel(channel);
   voe::Channel* channelPtr = ch.channel();
   if (channelPtr == nullptr) {
     shared_->SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
                           "StartSend() failed to locate channel");
     return -1;
   }
   if (channelPtr->Sending()) {
     return 0;
   }
   if (StartSend() != 0) {
     shared_->SetLastError(VE_AUDIO_DEVICE_MODULE_ERROR, kTraceError,
                           "StartSend() failed to start recording");
     return -1;
   }
   return channelPtr->StartSend();
 }
 
 int VoEBaseImpl::StopSend(int channel) {
-  CriticalSectionScoped cs(shared_->crit_sec());
+  rtc::CritScope cs(shared_->crit_sec());
   if (!shared_->statistics().Initialized()) {
     shared_->SetLastError(VE_NOT_INITED, kTraceError);
     return -1;
   }
   voe::ChannelOwner ch = shared_->channel_manager().GetChannel(channel);
   voe::Channel* channelPtr = ch.channel();
   if (channelPtr == nullptr) {
     shared_->SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
                           "StopSend() failed to locate channel");
     return -1;
@@ skipping 213 matching lines @@
   // Deliver audio (PCM) samples to the ADM
   memcpy(audio_data, audioFrame_.data_,
          sizeof(int16_t) * number_of_frames * number_of_channels);
 
   *elapsed_time_ms = audioFrame_.elapsed_time_ms_;
   *ntp_time_ms = audioFrame_.ntp_time_ms_;
 }
 
 int VoEBaseImpl::AssociateSendChannel(int channel,
                                       int accociate_send_channel) {
-  CriticalSectionScoped cs(shared_->crit_sec());
+  rtc::CritScope cs(shared_->crit_sec());
 
   if (!shared_->statistics().Initialized()) {
       shared_->SetLastError(VE_NOT_INITED, kTraceError);
       return -1;
   }
 
   voe::ChannelOwner ch = shared_->channel_manager().GetChannel(channel);
   voe::Channel* channel_ptr = ch.channel();
   if (channel_ptr == NULL) {
     shared_->SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
         "AssociateSendChannel() failed to locate channel");
     return -1;
   }
 
   ch = shared_->channel_manager().GetChannel(accociate_send_channel);
   voe::Channel* accociate_send_channel_ptr = ch.channel();
   if (accociate_send_channel_ptr == NULL) {
     shared_->SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
         "AssociateSendChannel() failed to locate accociate_send_channel");
     return -1;
   }
 
   channel_ptr->set_associate_send_channel(ch);
   return 0;
 }
 
 }  // namespace webrtc