Remove the VoiceEngineObserver callback interface.

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 "voice_engine/transmit_mixer.h"
 
 #include <memory>
 
 #include "audio/utility/audio_frame_operations.h"
 #include "rtc_base/format_macros.h"
 #include "rtc_base/location.h"
 #include "rtc_base/logging.h"
 #include "system_wrappers/include/event_wrapper.h"
 #include "system_wrappers/include/trace.h"
 #include "voice_engine/channel.h"
 #include "voice_engine/channel_manager.h"
 #include "voice_engine/statistics.h"
 #include "voice_engine/utility.h"
-#include "voice_engine/voe_base_impl.h"
 
 namespace webrtc {
 namespace voe {
 
-#if WEBRTC_VOICE_ENGINE_TYPING_DETECTION
-// TODO(ajm): The thread safety of this is dubious...
-void TransmitMixer::OnPeriodicProcess()
-{
-    WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId, -1),
-                 "TransmitMixer::OnPeriodicProcess()");
-
-    bool send_typing_noise_warning = false;
-    bool typing_noise_detected = false;
-    {
-      rtc::CritScope cs(&_critSect);
-      if (_typingNoiseWarningPending) {
-        send_typing_noise_warning = true;
-        typing_noise_detected = _typingNoiseDetected;
-        _typingNoiseWarningPending = false;
-      }
-    }
-    if (send_typing_noise_warning) {
-        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  // WEBRTC_VOICE_ENGINE_TYPING_DETECTION
+// TODO(solenberg): The thread safety in this class is dubious.
 
 int32_t
 TransmitMixer::Create(TransmitMixer*& mixer, uint32_t instanceId)
 {
     WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(instanceId, -1),
                  "TransmitMixer::Create(instanceId=%d)", instanceId);
     mixer = new TransmitMixer(instanceId);
     if (mixer == NULL)
     {
         WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(instanceId, -1),
                      "TransmitMixer::Create() unable to allocate memory"
                      "for mixer");
         return -1;
     }
     return 0;
 }
 
 void
 TransmitMixer::Destroy(TransmitMixer*& mixer)
 {
     if (mixer)
     {
         delete mixer;
         mixer = NULL;
     }
 }
 
 TransmitMixer::TransmitMixer(uint32_t instanceId) :
-#if WEBRTC_VOICE_ENGINE_TYPING_DETECTION
-    _monitorModule(this),
-#endif
     _instanceId(instanceId)
 {
     WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(_instanceId, -1),
                  "TransmitMixer::TransmitMixer() - ctor");
 }
 
-TransmitMixer::~TransmitMixer()
-{
-    WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(_instanceId, -1),
-                 "TransmitMixer::~TransmitMixer() - dtor");
-#if WEBRTC_VOICE_ENGINE_TYPING_DETECTION
-    if (_processThreadPtr)
-        _processThreadPtr->DeRegisterModule(&_monitorModule);
-#endif
+TransmitMixer::~TransmitMixer() = default;
+
+void TransmitMixer::SetEngineInformation(ChannelManager* channelManager) {
+  _channelManagerPtr = channelManager;
 }
 
 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;
-
-#if WEBRTC_VOICE_ENGINE_TYPING_DETECTION
-    _processThreadPtr->RegisterModule(&_monitorModule, RTC_FROM_HERE);
-#endif
-    return 0;
-}
-
-int32_t
-TransmitMixer::RegisterVoiceEngineObserver(VoiceEngineObserver& observer)
-{
-    WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
-                 "TransmitMixer::RegisterVoiceEngineObserver()");
-    rtc::CritScope cs(&_callbackCritSect);
-
-    if (_voiceEngineObserverPtr)
-    {
-        _engineStatisticsPtr->SetLastError(
-            VE_INVALID_OPERATION, kTraceError,
-            "RegisterVoiceEngineObserver() observer already enabled");
-        return -1;
-    }
-    _voiceEngineObserverPtr = &observer;
-    return 0;
-}
-
-int32_t
 TransmitMixer::SetAudioProcessingModule(AudioProcessing* audioProcessingModule)
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
                  "TransmitMixer::SetAudioProcessingModule("
                  "audioProcessingModule=0x%x)",
                  audioProcessingModule);
     audioproc_ = audioProcessingModule;
     return 0;
 }
 
@@ skipping 153 matching lines @@
   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();
 }
 
 #if WEBRTC_VOICE_ENGINE_TYPING_DETECTION
-void TransmitMixer::TypingDetection(bool keyPressed)
+void TransmitMixer::TypingDetection(bool key_pressed)
 {
   // 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)) {
-    rtc::CritScope cs(&_critSect);
-    _typingNoiseWarningPending = true;
-    _typingNoiseDetected = true;
-  } else {
-    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;
-    }
-  }
+  bool vad_active = _audioFrame.vad_activity_ == AudioFrame::kVadActive;
+  bool typing_detected = typing_detection_.Process(key_pressed, vad_active);
+
+  rtc::CritScope cs(&lock_);
+  typing_noise_detected_ = typing_detected;
 }
 #endif
 
 void TransmitMixer::EnableStereoChannelSwapping(bool enable) {
   swap_stereo_channels_ = enable;
 }
 
 bool TransmitMixer::IsStereoChannelSwappingEnabled() {
   return swap_stereo_channels_;
 }
 
+bool TransmitMixer::typing_noise_detected() const {
+  rtc::CritScope cs(&lock_);
+  return typing_noise_detected_;
+}
+
 }  // namespace voe
 }  // namespace webrtc