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

webrtc/voice_engine/transmit_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/transmit_mixer.h"
 
 #include "webrtc/base/format_macros.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/modules/utility/include/audio_frame_operations.h"
-#include "webrtc/system_wrappers/include/critical_section_wrapper.h"
 #include "webrtc/system_wrappers/include/event_wrapper.h"
 #include "webrtc/system_wrappers/include/trace.h"
 #include "webrtc/voice_engine/channel.h"
 #include "webrtc/voice_engine/channel_manager.h"
 #include "webrtc/voice_engine/include/voe_external_media.h"
 #include "webrtc/voice_engine/statistics.h"
 #include "webrtc/voice_engine/utility.h"
 #include "webrtc/voice_engine/voe_base_impl.h"
 
 namespace webrtc {
 namespace voe {
 
 // TODO(ajm): The thread safety of this is dubious...
 void
 TransmitMixer::OnPeriodicProcess()
 {
     WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId, -1),
                  "TransmitMixer::OnPeriodicProcess()");
 
 #if defined(WEBRTC_VOICE_ENGINE_TYPING_DETECTION)
     bool send_typing_noise_warning = false;
     bool typing_noise_detected = false;
     {
-      CriticalSectionScoped cs(&_critSect);
+      rtc::CritScope cs(&_critSect);

[the sun, 2016/01/21 13:07:28]

suuuper nit: "lock" or "cs"?

[tommi, 2016/01/21 15:29:23]

both are used throughout the code, so here I guess I just kept the original. 
Once all of this is done, doing a global |s/CritScope cs/CritScope lock| should
be possible.

       if (_typingNoiseWarningPending) {
         send_typing_noise_warning = true;
         typing_noise_detected = _typingNoiseDetected;
         _typingNoiseWarningPending = false;
       }
     }
     if (send_typing_noise_warning) {
-        CriticalSectionScoped cs(&_callbackCritSect);
+        rtc::CritScope cs(&_callbackCritSect);
         if (_voiceEngineObserverPtr) {
             if (typing_noise_detected) {
                 WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
                              "TransmitMixer::OnPeriodicProcess() => "
                              "CallbackOnError(VE_TYPING_NOISE_WARNING)");
                 _voiceEngineObserverPtr->CallbackOnError(
                     -1,
                     VE_TYPING_NOISE_WARNING);
             } else {
                 WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
                              "TransmitMixer::OnPeriodicProcess() => "
                              "CallbackOnError(VE_TYPING_NOISE_OFF_WARNING)");
                 _voiceEngineObserverPtr->CallbackOnError(
                     -1,
                     VE_TYPING_NOISE_OFF_WARNING);
             }
         }
     }
 #endif
 
     bool saturationWarning = false;
     {
       // Modify |_saturationWarning| under lock to avoid conflict with write op
       // in ProcessAudio and also ensure that we don't hold the lock during the
       // callback.
-      CriticalSectionScoped cs(&_critSect);
+      rtc::CritScope cs(&_critSect);
       saturationWarning = _saturationWarning;
       if (_saturationWarning)
         _saturationWarning = false;
     }
 
     if (saturationWarning)
     {
-        CriticalSectionScoped cs(&_callbackCritSect);
+        rtc::CritScope cs(&_callbackCritSect);
         if (_voiceEngineObserverPtr)
         {
             WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
                          "TransmitMixer::OnPeriodicProcess() =>"
                          " CallbackOnError(VE_SATURATION_WARNING)");
             _voiceEngineObserverPtr->CallbackOnError(-1, VE_SATURATION_WARNING);
         }
     }
 }
 
@@ skipping 18 matching lines @@
     // Not implement yet
 }
 
 void TransmitMixer::PlayFileEnded(int32_t id)
 {
     WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId, -1),
                  "TransmitMixer::PlayFileEnded(id=%d)", id);
 
     assert(id == _filePlayerId);
 
-    CriticalSectionScoped cs(&_critSect);
+    rtc::CritScope cs(&_critSect);
 
     _filePlaying = false;
     WEBRTC_TRACE(kTraceStateInfo, kTraceVoice, VoEId(_instanceId, -1),
                  "TransmitMixer::PlayFileEnded() =>"
                  "file player module is shutdown");
 }
 
 void
 TransmitMixer::RecordFileEnded(int32_t id)
 {
     WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId, -1),
                  "TransmitMixer::RecordFileEnded(id=%d)", id);
 
     if (id == _fileRecorderId)
     {
-        CriticalSectionScoped cs(&_critSect);
+        rtc::CritScope cs(&_critSect);
         _fileRecording = false;
         WEBRTC_TRACE(kTraceStateInfo, kTraceVoice, VoEId(_instanceId, -1),
                      "TransmitMixer::RecordFileEnded() => fileRecorder module"
                      "is shutdown");
     } else if (id == _fileCallRecorderId)
     {
-        CriticalSectionScoped cs(&_critSect);
+        rtc::CritScope cs(&_critSect);
         _fileCallRecording = false;
         WEBRTC_TRACE(kTraceStateInfo, kTraceVoice, VoEId(_instanceId, -1),
                      "TransmitMixer::RecordFileEnded() => fileCallRecorder"
                      "module is shutdown");
     }
 }
 
 int32_t
 TransmitMixer::Create(TransmitMixer*& mixer, uint32_t instanceId)
 {
@@ skipping 31 matching lines @@
     _fileCallRecorderPtr(NULL),
     // Avoid conflict with other channels by adding 1024 - 1026,
     // won't use as much as 1024 channels.
     _filePlayerId(instanceId + 1024),
     _fileRecorderId(instanceId + 1025),
     _fileCallRecorderId(instanceId + 1026),
     _filePlaying(false),
     _fileRecording(false),
     _fileCallRecording(false),
     _audioLevel(),
-    _critSect(*CriticalSectionWrapper::CreateCriticalSection()),
-    _callbackCritSect(*CriticalSectionWrapper::CreateCriticalSection()),
 #ifdef WEBRTC_VOICE_ENGINE_TYPING_DETECTION
     _typingNoiseWarningPending(false),
     _typingNoiseDetected(false),
 #endif
     _saturationWarning(false),
     _instanceId(instanceId),
     _mixFileWithMicrophone(false),
     _captureLevel(0),
     external_postproc_ptr_(NULL),
     external_preproc_ptr_(NULL),
@@ skipping 11 matching lines @@
     WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(_instanceId, -1),
                  "TransmitMixer::~TransmitMixer() - dtor");
     _monitorModule.DeRegisterObserver();
     if (_processThreadPtr)
     {
         _processThreadPtr->DeRegisterModule(&_monitorModule);
     }
     DeRegisterExternalMediaProcessing(kRecordingAllChannelsMixed);
     DeRegisterExternalMediaProcessing(kRecordingPreprocessing);
     {
-        CriticalSectionScoped cs(&_critSect);
+        rtc::CritScope cs(&_critSect);
         if (_fileRecorderPtr)
         {
             _fileRecorderPtr->RegisterModuleFileCallback(NULL);
             _fileRecorderPtr->StopRecording();
             FileRecorder::DestroyFileRecorder(_fileRecorderPtr);
             _fileRecorderPtr = NULL;
         }
         if (_fileCallRecorderPtr)
         {
             _fileCallRecorderPtr->RegisterModuleFileCallback(NULL);
             _fileCallRecorderPtr->StopRecording();
             FileRecorder::DestroyFileRecorder(_fileCallRecorderPtr);
             _fileCallRecorderPtr = NULL;
         }
         if (_filePlayerPtr)
         {
             _filePlayerPtr->RegisterModuleFileCallback(NULL);
             _filePlayerPtr->StopPlayingFile();
             FilePlayer::DestroyFilePlayer(_filePlayerPtr);
             _filePlayerPtr = NULL;
         }
     }
-    delete &_critSect;
-    delete &_callbackCritSect;
 }
 
 int32_t
 TransmitMixer::SetEngineInformation(ProcessThread& processThread,
                                     Statistics& engineStatistics,
                                     ChannelManager& channelManager)
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
                  "TransmitMixer::SetEngineInformation()");
 
     _processThreadPtr = &processThread;
     _engineStatisticsPtr = &engineStatistics;
     _channelManagerPtr = &channelManager;
 
     _processThreadPtr->RegisterModule(&_monitorModule);
     _monitorModule.RegisterObserver(*this);
 
     return 0;
 }
 
 int32_t
 TransmitMixer::RegisterVoiceEngineObserver(VoiceEngineObserver& observer)
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
                  "TransmitMixer::RegisterVoiceEngineObserver()");
-    CriticalSectionScoped cs(&_callbackCritSect);
+    rtc::CritScope cs(&_callbackCritSect);
 
     if (_voiceEngineObserverPtr)
     {
         _engineStatisticsPtr->SetLastError(
             VE_INVALID_OPERATION, kTraceError,
             "RegisterVoiceEngineObserver() observer already enabled");
         return -1;
     }
     _voiceEngineObserverPtr = &observer;
     return 0;
@@ skipping 43 matching lines @@
                  nSamples, nChannels, samplesPerSec, totalDelayMS, clockDrift,
                  currentMicLevel);
 
     // --- Resample input audio and create/store the initial audio frame
     GenerateAudioFrame(static_cast<const int16_t*>(audioSamples),
                        nSamples,
                        nChannels,
                        samplesPerSec);
 
     {
-      CriticalSectionScoped cs(&_callbackCritSect);
+      rtc::CritScope cs(&_callbackCritSect);
       if (external_preproc_ptr_) {
         external_preproc_ptr_->Process(-1, kRecordingPreprocessing,
                                        _audioFrame.data_,
                                        _audioFrame.samples_per_channel_,
                                        _audioFrame.sample_rate_hz_,
                                        _audioFrame.num_channels_ == 2);
       }
     }
 
     // --- Near-end audio processing.
@@ skipping 27 matching lines @@
 
     // --- Mix with file (does not affect the mixing frequency)
     if (_filePlaying)
     {
         MixOrReplaceAudioWithFile(_audioFrame.sample_rate_hz_);
     }
 
     // --- Record to file
     bool file_recording = false;
     {
-        CriticalSectionScoped cs(&_critSect);
+        rtc::CritScope cs(&_critSect);
         file_recording =  _fileRecording;
     }
     if (file_recording)
     {
         RecordAudioToFile(_audioFrame.sample_rate_hz_);
     }
 
     {
-      CriticalSectionScoped cs(&_callbackCritSect);
+      rtc::CritScope cs(&_callbackCritSect);
       if (external_postproc_ptr_) {
         external_postproc_ptr_->Process(-1, kRecordingAllChannelsMixed,
                                         _audioFrame.data_,
                                         _audioFrame.samples_per_channel_,
                                         _audioFrame.sample_rate_hz_,
                                         _audioFrame.num_channels_ == 2);
       }
     }
 
     // --- Measure audio level of speech after all processing.
@@ skipping 102 matching lines @@
                  format, volumeScaling, startPosition, stopPosition);
 
     if (_filePlaying)
     {
         _engineStatisticsPtr->SetLastError(
             VE_ALREADY_PLAYING, kTraceWarning,
             "StartPlayingFileAsMicrophone() is already playing");
         return 0;
     }
 
-    CriticalSectionScoped cs(&_critSect);
+    rtc::CritScope cs(&_critSect);
 
     // Destroy the old instance
     if (_filePlayerPtr)
     {
         _filePlayerPtr->RegisterModuleFileCallback(NULL);
         FilePlayer::DestroyFilePlayer(_filePlayerPtr);
         _filePlayerPtr = NULL;
     }
 
     // Dynamically create the instance
@@ skipping 56 matching lines @@
     }
 
     if (_filePlaying)
     {
         _engineStatisticsPtr->SetLastError(
             VE_ALREADY_PLAYING, kTraceWarning,
             "StartPlayingFileAsMicrophone() is already playing");
         return 0;
     }
 
-    CriticalSectionScoped cs(&_critSect);
+    rtc::CritScope cs(&_critSect);
 
     // Destroy the old instance
     if (_filePlayerPtr)
     {
         _filePlayerPtr->RegisterModuleFileCallback(NULL);
         FilePlayer::DestroyFilePlayer(_filePlayerPtr);
         _filePlayerPtr = NULL;
     }
 
     // Dynamically create the instance
@@ skipping 36 matching lines @@
 int TransmitMixer::StopPlayingFileAsMicrophone()
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,-1),
                  "TransmitMixer::StopPlayingFileAsMicrophone()");
 
     if (!_filePlaying)
     {
         return 0;
     }
 
-    CriticalSectionScoped cs(&_critSect);
+    rtc::CritScope cs(&_critSect);
 
     if (_filePlayerPtr->StopPlayingFile() != 0)
     {
         _engineStatisticsPtr->SetLastError(
             VE_CANNOT_STOP_PLAYOUT, kTraceError,
             "StopPlayingFile() couldnot stop playing file");
         return -1;
     }
 
     _filePlayerPtr->RegisterModuleFileCallback(NULL);
@@ skipping 11 matching lines @@
     return _filePlaying;
 }
 
 int TransmitMixer::StartRecordingMicrophone(const char* fileName,
                                             const CodecInst* codecInst)
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
                  "TransmitMixer::StartRecordingMicrophone(fileName=%s)",
                  fileName);
 
-    CriticalSectionScoped cs(&_critSect);
+    rtc::CritScope cs(&_critSect);
 
     if (_fileRecording)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, -1),
                      "StartRecordingMicrophone() is already recording");
         return 0;
     }
 
     FileFormats format;
     const uint32_t notificationTime(0); // Not supported in VoE
@@ skipping 57 matching lines @@
 
     return 0;
 }
 
 int TransmitMixer::StartRecordingMicrophone(OutStream* stream,
                                             const CodecInst* codecInst)
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
                "TransmitMixer::StartRecordingMicrophone()");
 
-    CriticalSectionScoped cs(&_critSect);
+    rtc::CritScope cs(&_critSect);
 
     if (_fileRecording)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, -1),
                    "StartRecordingMicrophone() is already recording");
         return 0;
     }
 
     FileFormats format;
     const uint32_t notificationTime(0); // Not supported in VoE
@@ skipping 56 matching lines @@
 
     return 0;
 }
 
 
 int TransmitMixer::StopRecordingMicrophone()
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
                  "TransmitMixer::StopRecordingMicrophone()");
 
-    CriticalSectionScoped cs(&_critSect);
+    rtc::CritScope cs(&_critSect);
 
     if (!_fileRecording)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, -1),
                    "StopRecordingMicrophone() isnot recording");
         return 0;
     }
 
     if (_fileRecorderPtr->StopRecording() != 0)
     {
@@ skipping 41 matching lines @@
     } else if ((STR_CASE_CMP(codecInst->plname,"L16") == 0) ||
         (STR_CASE_CMP(codecInst->plname,"PCMU") == 0) ||
         (STR_CASE_CMP(codecInst->plname,"PCMA") == 0))
     {
         format = kFileFormatWavFile;
     } else
     {
         format = kFileFormatCompressedFile;
     }
 
-    CriticalSectionScoped cs(&_critSect);
+    rtc::CritScope cs(&_critSect);
 
     // Destroy the old instance
     if (_fileCallRecorderPtr)
     {
         _fileCallRecorderPtr->RegisterModuleFileCallback(NULL);
         FileRecorder::DestroyFileRecorder(_fileCallRecorderPtr);
         _fileCallRecorderPtr = NULL;
     }
 
     _fileCallRecorderPtr
@@ skipping 57 matching lines @@
     } else if ((STR_CASE_CMP(codecInst->plname,"L16") == 0) ||
         (STR_CASE_CMP(codecInst->plname,"PCMU") == 0) ||
         (STR_CASE_CMP(codecInst->plname,"PCMA") == 0))
     {
         format = kFileFormatWavFile;
     } else
     {
         format = kFileFormatCompressedFile;
     }
 
-    CriticalSectionScoped cs(&_critSect);
+    rtc::CritScope cs(&_critSect);
 
     // Destroy the old instance
     if (_fileCallRecorderPtr)
     {
         _fileCallRecorderPtr->RegisterModuleFileCallback(NULL);
         FileRecorder::DestroyFileRecorder(_fileCallRecorderPtr);
         _fileCallRecorderPtr = NULL;
     }
 
     _fileCallRecorderPtr =
@@ skipping 30 matching lines @@
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
                  "TransmitMixer::StopRecordingCall()");
 
     if (!_fileCallRecording)
     {
         WEBRTC_TRACE(kTraceError, kTraceVoice, VoEId(_instanceId, -1),
                      "StopRecordingCall() file isnot recording");
         return -1;
     }
 
-    CriticalSectionScoped cs(&_critSect);
+    rtc::CritScope cs(&_critSect);
 
     if (_fileCallRecorderPtr->StopRecording() != 0)
     {
         _engineStatisticsPtr->SetLastError(
             VE_STOP_RECORDING_FAILED, kTraceError,
             "StopRecording(), could not stop recording");
         return -1;
     }
 
     _fileCallRecorderPtr->RegisterModuleFileCallback(NULL);
     FileRecorder::DestroyFileRecorder(_fileCallRecorderPtr);
     _fileCallRecorderPtr = NULL;
     _fileCallRecording = false;
 
     return 0;
 }
 
 void
 TransmitMixer::SetMixWithMicStatus(bool mix)
 {
     _mixFileWithMicrophone = mix;
 }
 
 int TransmitMixer::RegisterExternalMediaProcessing(
     VoEMediaProcess* object,
     ProcessingTypes type) {
   WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
                "TransmitMixer::RegisterExternalMediaProcessing()");
 
-  CriticalSectionScoped cs(&_callbackCritSect);
+  rtc::CritScope cs(&_callbackCritSect);
   if (!object) {
     return -1;
   }
 
   // Store the callback object according to the processing type.
   if (type == kRecordingAllChannelsMixed) {
     external_postproc_ptr_ = object;
   } else if (type == kRecordingPreprocessing) {
     external_preproc_ptr_ = object;
   } else {
     return -1;
   }
   return 0;
 }
 
 int TransmitMixer::DeRegisterExternalMediaProcessing(ProcessingTypes type) {
   WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
                "TransmitMixer::DeRegisterExternalMediaProcessing()");
 
-  CriticalSectionScoped cs(&_callbackCritSect);
+  rtc::CritScope cs(&_callbackCritSect);
   if (type == kRecordingAllChannelsMixed) {
     external_postproc_ptr_ = NULL;
   } else if (type == kRecordingPreprocessing) {
     external_preproc_ptr_ = NULL;
   } else {
     return -1;
   }
   return 0;
 }
 
@@ skipping 24 matching lines @@
     return _audioLevel.LevelFullRange();
 }
 
 bool TransmitMixer::IsRecordingCall()
 {
     return _fileCallRecording;
 }
 
 bool TransmitMixer::IsRecordingMic()
 {
-    CriticalSectionScoped cs(&_critSect);
+    rtc::CritScope cs(&_critSect);
     return _fileRecording;
 }
 
 void TransmitMixer::GenerateAudioFrame(const int16_t* audio,
                                        size_t samples_per_channel,
                                        size_t num_channels,
                                        int sample_rate_hz) {
   int codec_rate;
   size_t num_codec_channels;
   GetSendCodecInfo(&codec_rate, &num_codec_channels);
@@ skipping 14 matching lines @@
         _audioFrame.sample_rate_hz_, AudioProcessing::kMaxAECMSampleRateHz);
   }
   _audioFrame.num_channels_ = std::min(num_channels, num_codec_channels);
   RemixAndResample(audio, samples_per_channel, num_channels, sample_rate_hz,
                    &resampler_, &_audioFrame);
 }
 
 int32_t TransmitMixer::RecordAudioToFile(
     uint32_t mixingFrequency)
 {
-    CriticalSectionScoped cs(&_critSect);
+    rtc::CritScope cs(&_critSect);
     if (_fileRecorderPtr == NULL)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, -1),
                      "TransmitMixer::RecordAudioToFile() filerecorder doesnot"
                      "exist");
         return -1;
     }
 
     if (_fileRecorderPtr->RecordAudioToFile(_audioFrame) != 0)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, -1),
                      "TransmitMixer::RecordAudioToFile() file recording"
                      "failed");
         return -1;
     }
 
     return 0;
 }
 
 int32_t TransmitMixer::MixOrReplaceAudioWithFile(
     int mixingFrequency)
 {
   rtc::scoped_ptr<int16_t[]> fileBuffer(new int16_t[640]);
 
     size_t fileSamples(0);
     {
-        CriticalSectionScoped cs(&_critSect);
+        rtc::CritScope cs(&_critSect);
         if (_filePlayerPtr == NULL)
         {
             WEBRTC_TRACE(kTraceWarning, kTraceVoice,
                          VoEId(_instanceId, -1),
                          "TransmitMixer::MixOrReplaceAudioWithFile()"
                          "fileplayer doesnot exist");
             return -1;
         }
 
         if (_filePlayerPtr->Get10msAudioFromFile(fileBuffer.get(),
@@ skipping 57 matching lines @@
 
   int err = audioproc_->ProcessStream(&_audioFrame);
   if (err != 0) {
     LOG(LS_ERROR) << "ProcessStream() error: " << err;
     assert(false);
   }
 
   // Store new capture level. Only updated when analog AGC is enabled.
   _captureLevel = agc->stream_analog_level();
 
-  CriticalSectionScoped cs(&_critSect);
+  rtc::CritScope cs(&_critSect);
   // Triggers a callback in OnPeriodicProcess().
   _saturationWarning |= agc->stream_is_saturated();
 }
 
 #ifdef WEBRTC_VOICE_ENGINE_TYPING_DETECTION
 void TransmitMixer::TypingDetection(bool keyPressed)
 {
   // We let the VAD determine if we're using this feature or not.
   if (_audioFrame.vad_activity_ == AudioFrame::kVadUnknown) {
     return;
   }
 
   bool vadActive = _audioFrame.vad_activity_ == AudioFrame::kVadActive;
   if (_typingDetection.Process(keyPressed, vadActive)) {
-    CriticalSectionScoped cs(&_critSect);
+    rtc::CritScope cs(&_critSect);
     _typingNoiseWarningPending = true;
     _typingNoiseDetected = true;
   } else {
-    CriticalSectionScoped cs(&_critSect);
+    rtc::CritScope cs(&_critSect);
     // If there is already a warning pending, do not change the state.
     // Otherwise set a warning pending if last callback was for noise detected.
     if (!_typingNoiseWarningPending && _typingNoiseDetected) {
       _typingNoiseWarningPending = true;
       _typingNoiseDetected = false;
     }
   }
 }
 #endif
 
@@ skipping 33 matching lines @@
 void TransmitMixer::EnableStereoChannelSwapping(bool enable) {
   swap_stereo_channels_ = enable;
 }
 
 bool TransmitMixer::IsStereoChannelSwappingEnabled() {
   return swap_stereo_channels_;
 }
 
 }  // namespace voe
 }  // namespace webrtc