Allow an external audio processing module to be used in WebRTC

webrtc/audio/audio_send_stream_unittest.cc

 /*
  *  Copyright (c) 2015 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.
  */
 
@@ skipping 110 matching lines @@
       .WillByDefault(Invoke([](int payload_type, const SdpAudioFormat& format,
                                std::unique_ptr<AudioEncoder>* return_value) {
         *return_value = SetupAudioEncoderMock(payload_type, format);
       }));
   return factory;
 }
 
 struct ConfigHelper {
   ConfigHelper(bool audio_bwe_enabled, bool expect_set_encoder_call)
       : stream_config_(nullptr),
+        audio_processing_(new rtc::RefCountedObject<MockAudioProcessing>()),
         simulated_clock_(123456),
         send_side_cc_(rtc::MakeUnique<SendSideCongestionController>(
             &simulated_clock_,
             nullptr /* observer */,
             &event_log_,
             &packet_router_)),
         fake_transport_(&packet_router_, send_side_cc_.get()),
         bitrate_allocator_(&limit_observer_),
         worker_queue_("ConfigHelper_worker_queue") {
     using testing::Invoke;
 
     EXPECT_CALL(voice_engine_,
         RegisterVoiceEngineObserver(_)).WillOnce(Return(0));
     EXPECT_CALL(voice_engine_,
         DeRegisterVoiceEngineObserver()).WillOnce(Return(0));
     EXPECT_CALL(voice_engine_, audio_device_module());
-    EXPECT_CALL(voice_engine_, audio_processing());
     EXPECT_CALL(voice_engine_, audio_transport());
 
     AudioState::Config config;
     config.voice_engine = &voice_engine_;
     config.audio_mixer = AudioMixerImpl::Create();
+    config.audio_processing = audio_processing_;
     audio_state_ = AudioState::Create(config);
 
     SetupDefaultChannelProxy(audio_bwe_enabled);
 
     EXPECT_CALL(voice_engine_, ChannelProxyFactory(kChannelId))
         .WillOnce(Invoke([this](int channel_id) {
           return channel_proxy_;
         }));
 
     SetupMockForSetupSendCodec(expect_set_encoder_call);
@@ skipping 108 matching lines @@
     block.fraction_lost = 0;
     report_blocks.push_back(block);  // Duplicate SSRC, bad fraction_lost.
 
     EXPECT_TRUE(channel_proxy_);
     EXPECT_CALL(*channel_proxy_, GetRTCPStatistics())
         .WillRepeatedly(Return(kCallStats));
     EXPECT_CALL(*channel_proxy_, GetRemoteRTCPReportBlocks())
         .WillRepeatedly(Return(report_blocks));
     EXPECT_CALL(voice_engine_, transmit_mixer())
         .WillRepeatedly(Return(&transmit_mixer_));
-    EXPECT_CALL(voice_engine_, audio_processing())
-        .WillRepeatedly(Return(&audio_processing_));
 
     EXPECT_CALL(transmit_mixer_, AudioLevelFullRange())
         .WillRepeatedly(Return(kSpeechInputLevel));
 
     // We have to set the instantaneous value, the average, min and max. We only
     // care about the instantaneous value, so we set all to the same value.
     audio_processing_stats_.echo_return_loss.Set(
         kEchoReturnLoss, kEchoReturnLoss, kEchoReturnLoss, kEchoReturnLoss);
     audio_processing_stats_.echo_return_loss_enhancement.Set(
         kEchoReturnLossEnhancement, kEchoReturnLossEnhancement,
         kEchoReturnLossEnhancement, kEchoReturnLossEnhancement);
     audio_processing_stats_.delay_median = kEchoDelayMedian;
     audio_processing_stats_.delay_standard_deviation = kEchoDelayStdDev;
 
-    EXPECT_CALL(audio_processing_, GetStatistics())
+    EXPECT_CALL(*audio_processing_, GetStatistics())
         .WillRepeatedly(Return(audio_processing_stats_));
   }
 
  private:
   testing::StrictMock<MockVoiceEngine> voice_engine_;
   rtc::scoped_refptr<AudioState> audio_state_;
   AudioSendStream::Config stream_config_;
   testing::StrictMock<MockVoEChannelProxy>* channel_proxy_ = nullptr;
-  MockAudioProcessing audio_processing_;
+  rtc::scoped_refptr<MockAudioProcessing> audio_processing_;
   MockTransmitMixer transmit_mixer_;
   AudioProcessing::AudioProcessingStatistics audio_processing_stats_;
   SimulatedClock simulated_clock_;
   PacketRouter packet_router_;
   std::unique_ptr<SendSideCongestionController> send_side_cc_;
   FakeRtpTransportControllerSend fake_transport_;
   MockRtcEventLog event_log_;
   MockRtpRtcp rtp_rtcp_;
   MockRtcpRttStats rtcp_rtt_stats_;
   testing::NiceMock<MockLimitObserver> limit_observer_;
@@ skipping 220 matching lines @@
   stream_config.send_codec_spec->cng_payload_type = rtc::Optional<int>(105);
   internal::AudioSendStream send_stream(
       stream_config, helper.audio_state(), helper.worker_queue(),
       helper.transport(), helper.bitrate_allocator(), helper.event_log(),
       helper.rtcp_rtt_stats(), rtc::Optional<RtpState>());
   send_stream.Reconfigure(stream_config);
 }
 
 }  // namespace test
 }  // namespace webrtc