Start using APM directly in WVoMC (not VoEAudioProcessing)

webrtc/modules/audio_processing/include/mock_audio_processing.h

Index: webrtc/modules/audio_processing/include/mock_audio_processing.h
diff --git a/webrtc/modules/audio_processing/include/mock_audio_processing.h b/webrtc/modules/audio_processing/include/mock_audio_processing.h
index 998153deaa2ac7dc2070fe0ca8afb0e2351d9dd3..8acb83ba23a31d07621b4e1a61241d7903a88e43 100644
--- a/webrtc/modules/audio_processing/include/mock_audio_processing.h
+++ b/webrtc/modules/audio_processing/include/mock_audio_processing.h
@@ -14,257 +14,174 @@
 #include <memory>
 
 #include "webrtc/modules/audio_processing/include/audio_processing.h"
+#include "webrtc/test/gmock.h"
 
 namespace webrtc {
 
+namespace test {
+
 class MockEchoCancellation : public EchoCancellation {
  public:
-  MOCK_METHOD1(Enable,
-      int(bool enable));
-  MOCK_CONST_METHOD0(is_enabled,
-      bool());
-  MOCK_METHOD1(enable_drift_compensation,
-      int(bool enable));
-  MOCK_CONST_METHOD0(is_drift_compensation_enabled,
-      bool());
-  MOCK_METHOD1(set_stream_drift_samples,
-      void(int drift));
-  MOCK_CONST_METHOD0(stream_drift_samples,
-      int());
-  MOCK_METHOD1(set_suppression_level,
-      int(SuppressionLevel level));
-  MOCK_CONST_METHOD0(suppression_level,
-      SuppressionLevel());
-  MOCK_CONST_METHOD0(stream_has_echo,
-      bool());
-  MOCK_METHOD1(enable_metrics,
-      int(bool enable));
-  MOCK_CONST_METHOD0(are_metrics_enabled,
-      bool());
-  MOCK_METHOD1(GetMetrics,
-      int(Metrics* metrics));
-  MOCK_METHOD1(enable_delay_logging,
-      int(bool enable));
-  MOCK_CONST_METHOD0(is_delay_logging_enabled,
-      bool());
-  MOCK_METHOD2(GetDelayMetrics,
-      int(int* median, int* std));
-  MOCK_METHOD3(GetDelayMetrics,
-      int(int* median, int* std, float* fraction_poor_delays));
-  MOCK_CONST_METHOD0(aec_core,
-      struct AecCore*());
+  virtual ~MockEchoCancellation() {}
+  MOCK_METHOD1(Enable, int(bool enable));
+  MOCK_CONST_METHOD0(is_enabled, bool());
+  MOCK_METHOD1(enable_drift_compensation, int(bool enable));
+  MOCK_CONST_METHOD0(is_drift_compensation_enabled, bool());
+  MOCK_METHOD1(set_stream_drift_samples, void(int drift));
+  MOCK_CONST_METHOD0(stream_drift_samples, int());
+  MOCK_METHOD1(set_suppression_level, int(SuppressionLevel level));
+  MOCK_CONST_METHOD0(suppression_level, SuppressionLevel());
+  MOCK_CONST_METHOD0(stream_has_echo, bool());
+  MOCK_METHOD1(enable_metrics, int(bool enable));
+  MOCK_CONST_METHOD0(are_metrics_enabled, bool());
+  MOCK_METHOD1(GetMetrics, int(Metrics* metrics));
+  MOCK_METHOD1(enable_delay_logging, int(bool enable));
+  MOCK_CONST_METHOD0(is_delay_logging_enabled, bool());
+  MOCK_METHOD2(GetDelayMetrics, int(int* median, int* std));
+  MOCK_METHOD3(GetDelayMetrics, int(int* median, int* std,
+                                    float* fraction_poor_delays));
+  MOCK_CONST_METHOD0(aec_core, struct AecCore*());
 };
 
 class MockEchoControlMobile : public EchoControlMobile {
  public:
-  MOCK_METHOD1(Enable,
-      int(bool enable));
-  MOCK_CONST_METHOD0(is_enabled,
-      bool());
-  MOCK_METHOD1(set_routing_mode,
-      int(RoutingMode mode));
-  MOCK_CONST_METHOD0(routing_mode,
-      RoutingMode());
-  MOCK_METHOD1(enable_comfort_noise,
-      int(bool enable));
-  MOCK_CONST_METHOD0(is_comfort_noise_enabled,
-      bool());
-  MOCK_METHOD2(SetEchoPath,
-      int(const void* echo_path, size_t size_bytes));
-  MOCK_CONST_METHOD2(GetEchoPath,
-      int(void* echo_path, size_t size_bytes));
+  virtual ~MockEchoControlMobile() {}
+  MOCK_METHOD1(Enable, int(bool enable));
+  MOCK_CONST_METHOD0(is_enabled, bool());
+  MOCK_METHOD1(set_routing_mode, int(RoutingMode mode));
+  MOCK_CONST_METHOD0(routing_mode, RoutingMode());
+  MOCK_METHOD1(enable_comfort_noise, int(bool enable));
+  MOCK_CONST_METHOD0(is_comfort_noise_enabled, bool());
+  MOCK_METHOD2(SetEchoPath, int(const void* echo_path, size_t size_bytes));
+  MOCK_CONST_METHOD2(GetEchoPath, int(void* echo_path, size_t size_bytes));
 };
 
 class MockGainControl : public GainControl {
  public:
-  MOCK_METHOD1(Enable,
-      int(bool enable));
-  MOCK_CONST_METHOD0(is_enabled,
-      bool());
-  MOCK_METHOD1(set_stream_analog_level,
-      int(int level));
-  MOCK_METHOD0(stream_analog_level,
-      int());
-  MOCK_METHOD1(set_mode,
-      int(Mode mode));
-  MOCK_CONST_METHOD0(mode,
-      Mode());
-  MOCK_METHOD1(set_target_level_dbfs,
-      int(int level));
-  MOCK_CONST_METHOD0(target_level_dbfs,
-      int());
-  MOCK_METHOD1(set_compression_gain_db,
-      int(int gain));
-  MOCK_CONST_METHOD0(compression_gain_db,
-      int());
-  MOCK_METHOD1(enable_limiter,
-      int(bool enable));
-  MOCK_CONST_METHOD0(is_limiter_enabled,
-      bool());
-  MOCK_METHOD2(set_analog_level_limits,
-      int(int minimum, int maximum));
-  MOCK_CONST_METHOD0(analog_level_minimum,
-      int());
-  MOCK_CONST_METHOD0(analog_level_maximum,
-      int());
-  MOCK_CONST_METHOD0(stream_is_saturated,
-      bool());
+  virtual ~MockGainControl() {}
+  MOCK_METHOD1(Enable, int(bool enable));
+  MOCK_CONST_METHOD0(is_enabled, bool());
+  MOCK_METHOD1(set_stream_analog_level, int(int level));
+  MOCK_METHOD0(stream_analog_level, int());
+  MOCK_METHOD1(set_mode, int(Mode mode));
+  MOCK_CONST_METHOD0(mode, Mode());
+  MOCK_METHOD1(set_target_level_dbfs, int(int level));
+  MOCK_CONST_METHOD0(target_level_dbfs, int());
+  MOCK_METHOD1(set_compression_gain_db, int(int gain));
+  MOCK_CONST_METHOD0(compression_gain_db, int());
+  MOCK_METHOD1(enable_limiter, int(bool enable));
+  MOCK_CONST_METHOD0(is_limiter_enabled, bool());
+  MOCK_METHOD2(set_analog_level_limits, int(int minimum, int maximum));
+  MOCK_CONST_METHOD0(analog_level_minimum, int());
+  MOCK_CONST_METHOD0(analog_level_maximum, int());
+  MOCK_CONST_METHOD0(stream_is_saturated, bool());
 };
 
 class MockHighPassFilter : public HighPassFilter {
  public:
-  MOCK_METHOD1(Enable,
-      int(bool enable));
-  MOCK_CONST_METHOD0(is_enabled,
-      bool());
+  virtual ~MockHighPassFilter() {}
+  MOCK_METHOD1(Enable, int(bool enable));
+  MOCK_CONST_METHOD0(is_enabled, bool());
 };
 
 class MockLevelEstimator : public LevelEstimator {
  public:
-  MOCK_METHOD1(Enable,
-      int(bool enable));
-  MOCK_CONST_METHOD0(is_enabled,
-      bool());
-  MOCK_METHOD0(RMS,
-      int());
+  virtual ~MockLevelEstimator() {}
+  MOCK_METHOD1(Enable, int(bool enable));
+  MOCK_CONST_METHOD0(is_enabled, bool());
+  MOCK_METHOD0(RMS, int());
 };
 
 class MockNoiseSuppression : public NoiseSuppression {
  public:
-  MOCK_METHOD1(Enable,
-      int(bool enable));
-  MOCK_CONST_METHOD0(is_enabled,
-      bool());
-  MOCK_METHOD1(set_level,
-      int(Level level));
-  MOCK_CONST_METHOD0(level,
-      Level());
-  MOCK_CONST_METHOD0(speech_probability,
-      float());
+  virtual ~MockNoiseSuppression() {}
+  MOCK_METHOD1(Enable, int(bool enable));
+  MOCK_CONST_METHOD0(is_enabled, bool());
+  MOCK_METHOD1(set_level, int(Level level));
+  MOCK_CONST_METHOD0(level, Level());
+  MOCK_CONST_METHOD0(speech_probability, float());
   MOCK_METHOD0(NoiseEstimate, std::vector<float>());
 };
 
 class MockVoiceDetection : public VoiceDetection {
  public:
-  MOCK_METHOD1(Enable,
-      int(bool enable));
-  MOCK_CONST_METHOD0(is_enabled,
-      bool());
-  MOCK_CONST_METHOD0(stream_has_voice,
-      bool());
-  MOCK_METHOD1(set_stream_has_voice,
-      int(bool has_voice));
-  MOCK_METHOD1(set_likelihood,
-      int(Likelihood likelihood));
-  MOCK_CONST_METHOD0(likelihood,
-      Likelihood());
-  MOCK_METHOD1(set_frame_size_ms,
-      int(int size));
-  MOCK_CONST_METHOD0(frame_size_ms,
-      int());
+  virtual ~MockVoiceDetection() {}
+  MOCK_METHOD1(Enable, int(bool enable));
+  MOCK_CONST_METHOD0(is_enabled, bool());
+  MOCK_CONST_METHOD0(stream_has_voice, bool());
+  MOCK_METHOD1(set_stream_has_voice, int(bool has_voice));
+  MOCK_METHOD1(set_likelihood, int(Likelihood likelihood));
+  MOCK_CONST_METHOD0(likelihood, Likelihood());
+  MOCK_METHOD1(set_frame_size_ms, int(int size));
+  MOCK_CONST_METHOD0(frame_size_ms, int());
 };
 
 class MockAudioProcessing : public AudioProcessing {
  public:
   MockAudioProcessing()
-      : echo_cancellation_(new MockEchoCancellation),
-        echo_control_mobile_(new MockEchoControlMobile),
-        gain_control_(new MockGainControl),
-        high_pass_filter_(new MockHighPassFilter),
-        level_estimator_(new MockLevelEstimator),
-        noise_suppression_(new MockNoiseSuppression),
-        voice_detection_(new MockVoiceDetection) {
+      : echo_cancellation_(new testing::NiceMock<MockEchoCancellation>()),
+        echo_control_mobile_(new testing::NiceMock<MockEchoControlMobile>()),
+        gain_control_(new testing::NiceMock<MockGainControl>()),
+        high_pass_filter_(new testing::NiceMock<MockHighPassFilter>()),
+        level_estimator_(new testing::NiceMock<MockLevelEstimator>()),
+        noise_suppression_(new testing::NiceMock<MockNoiseSuppression>()),
+        voice_detection_(new testing::NiceMock<MockVoiceDetection>()) {
   }
 
-  virtual ~MockAudioProcessing() {
-  }
+  virtual ~MockAudioProcessing() {}
 
-  MOCK_METHOD0(Initialize,
-      int());
-  MOCK_METHOD6(Initialize,
-               int(int capture_input_sample_rate_hz,
-                   int capture_output_sample_rate_hz,
-                   int render_sample_rate_hz,
-                   ChannelLayout capture_input_layout,
-                   ChannelLayout capture_output_layout,
-                   ChannelLayout render_input_layout));
-  MOCK_METHOD1(Initialize,
-      int(const ProcessingConfig& processing_config));
+  MOCK_METHOD0(Initialize, int());
+  MOCK_METHOD6(Initialize, int(int capture_input_sample_rate_hz,
+                               int capture_output_sample_rate_hz,
+                               int render_sample_rate_hz,
+                               ChannelLayout capture_input_layout,
+                               ChannelLayout capture_output_layout,
+                               ChannelLayout render_input_layout));
+  MOCK_METHOD1(Initialize, int(const ProcessingConfig& processing_config));
   MOCK_METHOD1(ApplyConfig, void(const Config& config));
   MOCK_METHOD1(SetExtraOptions, void(const webrtc::Config& config));
-  MOCK_METHOD1(set_sample_rate_hz,
-      int(int rate));
-  MOCK_CONST_METHOD0(input_sample_rate_hz,
-      int());
-  MOCK_CONST_METHOD0(sample_rate_hz,
-      int());
-  MOCK_CONST_METHOD0(proc_sample_rate_hz,
-      int());
-  MOCK_CONST_METHOD0(proc_split_sample_rate_hz,
-      int());
-  MOCK_CONST_METHOD0(num_input_channels,
-      size_t());
-  MOCK_CONST_METHOD0(num_output_channels,
-      size_t());
-  MOCK_CONST_METHOD0(num_reverse_channels,
-      size_t());
-  MOCK_METHOD1(set_output_will_be_muted,
-      void(bool muted));
-  MOCK_CONST_METHOD0(output_will_be_muted,
-      bool());
-  MOCK_METHOD1(ProcessStream,
-      int(AudioFrame* frame));
-  MOCK_METHOD7(ProcessStream,
-      int(const float* const* src,
-          size_t samples_per_channel,
-          int input_sample_rate_hz,
-          ChannelLayout input_layout,
-          int output_sample_rate_hz,
-          ChannelLayout output_layout,
-          float* const* dest));
-  MOCK_METHOD4(ProcessStream,
-               int(const float* const* src,
-                   const StreamConfig& input_config,
-                   const StreamConfig& output_config,
-                   float* const* dest));
-  MOCK_METHOD1(AnalyzeReverseStream,
-      int(AudioFrame* frame));
+  MOCK_CONST_METHOD0(proc_sample_rate_hz, int());
+  MOCK_CONST_METHOD0(proc_split_sample_rate_hz, int());
+  MOCK_CONST_METHOD0(num_input_channels, size_t());
+  MOCK_CONST_METHOD0(num_proc_channels, size_t());
+  MOCK_CONST_METHOD0(num_output_channels, size_t());
+  MOCK_CONST_METHOD0(num_reverse_channels, size_t());
+  MOCK_METHOD1(set_output_will_be_muted, void(bool muted));
+  MOCK_METHOD1(ProcessStream, int(AudioFrame* frame));
+  MOCK_METHOD7(ProcessStream, int(const float* const* src,
+                                  size_t samples_per_channel,
+                                  int input_sample_rate_hz,
+                                  ChannelLayout input_layout,
+                                  int output_sample_rate_hz,
+                                  ChannelLayout output_layout,
+                                  float* const* dest));
+  MOCK_METHOD4(ProcessStream, int(const float* const* src,
+                                 const StreamConfig& input_config,
+                                 const StreamConfig& output_config,
+                                 float* const* dest));
   MOCK_METHOD1(ProcessReverseStream, int(AudioFrame* frame));
-  MOCK_METHOD4(AnalyzeReverseStream,
-               int(const float* const* data,
-                   size_t samples_per_channel,
-                   int sample_rate_hz,
-                   ChannelLayout layout));
-  MOCK_METHOD4(ProcessReverseStream,
-               int(const float* const* src,
-                   const StreamConfig& input_config,
-                   const StreamConfig& output_config,
-                   float* const* dest));
-  MOCK_METHOD1(set_stream_delay_ms,
-      int(int delay));
-  MOCK_CONST_METHOD0(stream_delay_ms,
-      int());
-  MOCK_CONST_METHOD0(was_stream_delay_set,
-      bool());
-  MOCK_METHOD1(set_stream_key_pressed,
-      void(bool key_pressed));
-  MOCK_CONST_METHOD0(stream_key_pressed,
-      bool());
-  MOCK_METHOD1(set_delay_offset_ms,
-      void(int offset));
-  MOCK_CONST_METHOD0(delay_offset_ms,
-      int());
-  MOCK_METHOD2(StartDebugRecording,
-               int(const char filename[kMaxFilenameSize],
-                   int64_t max_log_size_bytes));
-  MOCK_METHOD2(StartDebugRecording,
-               int(FILE* handle, int64_t max_log_size_bytes));
-  MOCK_METHOD1(StartDebugRecording,
-               int (FILE* handle));
-  MOCK_METHOD1(StartDebugRecording,
+  MOCK_METHOD4(AnalyzeReverseStream, int(const float* const* data,
+                                         size_t samples_per_channel,
+                                         int sample_rate_hz,
+                                         ChannelLayout layout));
+  MOCK_METHOD4(ProcessReverseStream, int(const float* const* src,
+                                         const StreamConfig& input_config,
+                                         const StreamConfig& output_config,
+                                         float* const* dest));
+  MOCK_METHOD1(set_stream_delay_ms, int(int delay));
+  MOCK_CONST_METHOD0(stream_delay_ms, int());
+  MOCK_CONST_METHOD0(was_stream_delay_set, bool());
+  MOCK_METHOD1(set_stream_key_pressed, void(bool key_pressed));
+  MOCK_METHOD1(set_delay_offset_ms, void(int offset));
+  MOCK_CONST_METHOD0(delay_offset_ms, int());
+  MOCK_METHOD2(StartDebugRecording, int(const char filename[kMaxFilenameSize],
+                                        int64_t max_log_size_bytes));
+  MOCK_METHOD2(StartDebugRecording, int(FILE* handle,
+                                        int64_t max_log_size_bytes));
+  MOCK_METHOD1(StartDebugRecording, int (FILE* handle));
+  MOCK_METHOD1(StartDebugRecordingForPlatformFile,
                int(rtc::PlatformFile handle));
-  MOCK_METHOD0(StopDebugRecording,
-      int());
+  MOCK_METHOD0(StopDebugRecording, int());
   MOCK_METHOD0(UpdateHistogramsOnCallEnd, void());
   virtual MockEchoCancellation* echo_cancellation() const {
     return echo_cancellation_.get();
@@ -298,6 +215,7 @@ class MockAudioProcessing : public AudioProcessing {
   std::unique_ptr<MockVoiceDetection> voice_detection_;
 };
 
+}  // namespace test
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_AUDIO_PROCESSING_INCLUDE_MOCK_AUDIO_PROCESSING_H_