Remove the VoiceEngineObserver callback interface.

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 69 matching lines @@
   MOCK_METHOD2(OnAllocationLimitsChanged,
                void(uint32_t min_send_bitrate_bps,
                     uint32_t max_padding_bitrate_bps));
 };
 
 class MockTransmitMixer : public voe::TransmitMixer {
  public:
   MOCK_CONST_METHOD0(AudioLevelFullRange, int16_t());
   MOCK_CONST_METHOD0(GetTotalInputEnergy, double());
   MOCK_CONST_METHOD0(GetTotalInputDuration, double());
+  MOCK_CONST_METHOD0(typing_noise_detected, bool());
 };
 
 std::unique_ptr<MockAudioEncoder> SetupAudioEncoderMock(
     int payload_type,
     const SdpAudioFormat& format) {
   for (const auto& spec : kCodecSpecs) {
     if (format == spec.format) {
       std::unique_ptr<MockAudioEncoder> encoder(new MockAudioEncoder);
       ON_CALL(*encoder.get(), SampleRateHz())
           .WillByDefault(Return(spec.info.sample_rate_hz));
@@ skipping 39 matching lines @@
             &simulated_clock_,
             nullptr /* observer */,
             &event_log_,
             &pacer_)),
         fake_transport_(&packet_router_, &pacer_, send_side_cc_.get()),
         bitrate_allocator_(&limit_observer_),
         worker_queue_("ConfigHelper_worker_queue"),
         audio_encoder_(nullptr) {
     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_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);
@@ skipping 142 matching lines @@
         .WillRepeatedly(Return(ANAStats()));
     EXPECT_CALL(voice_engine_, transmit_mixer())
         .WillRepeatedly(Return(&transmit_mixer_));
 
     EXPECT_CALL(transmit_mixer_, AudioLevelFullRange())
         .WillRepeatedly(Return(kSpeechInputLevel));
     EXPECT_CALL(transmit_mixer_, GetTotalInputEnergy())
         .WillRepeatedly(Return(kTotalInputEnergy));
     EXPECT_CALL(transmit_mixer_, GetTotalInputDuration())
         .WillRepeatedly(Return(kTotalInputDuration));
+    EXPECT_CALL(transmit_mixer_, typing_noise_detected())
+        .WillRepeatedly(Return(true));
 
     // 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;
@@ skipping 124 matching lines @@
   EXPECT_EQ(kCallStats.rttMs, stats.rtt_ms);
   EXPECT_EQ(static_cast<int32_t>(kSpeechInputLevel), stats.audio_level);
   EXPECT_EQ(kTotalInputEnergy, stats.total_input_energy);
   EXPECT_EQ(kTotalInputDuration, stats.total_input_duration);
   EXPECT_EQ(-1, stats.aec_quality_min);
   EXPECT_EQ(kEchoDelayMedian, stats.echo_delay_median_ms);
   EXPECT_EQ(kEchoDelayStdDev, stats.echo_delay_std_ms);
   EXPECT_EQ(kEchoReturnLoss, stats.echo_return_loss);
   EXPECT_EQ(kEchoReturnLossEnhancement, stats.echo_return_loss_enhancement);
   EXPECT_EQ(kResidualEchoLikelihood, stats.residual_echo_likelihood);
-  EXPECT_FALSE(stats.typing_noise_detected);
-}
-
-TEST(AudioSendStreamTest, GetStatsTypingNoiseDetected) {
-  ConfigHelper helper(false, true);
-  internal::AudioSendStream send_stream(
-      helper.config(), helper.audio_state(), helper.worker_queue(),
-      helper.transport(), helper.bitrate_allocator(), helper.event_log(),
-      helper.rtcp_rtt_stats(), rtc::Optional<RtpState>());
-  helper.SetupMockForGetStats();
-  EXPECT_FALSE(send_stream.GetStats().typing_noise_detected);
-
-  internal::AudioState* internal_audio_state =
-      static_cast<internal::AudioState*>(helper.audio_state().get());
-  VoiceEngineObserver* voe_observer =
-      static_cast<VoiceEngineObserver*>(internal_audio_state);
-  voe_observer->CallbackOnError(-1, VE_TYPING_NOISE_WARNING);
-  EXPECT_TRUE(send_stream.GetStats().typing_noise_detected);
-  voe_observer->CallbackOnError(-1, VE_TYPING_NOISE_OFF_WARNING);
-  EXPECT_FALSE(send_stream.GetStats().typing_noise_detected);
+  EXPECT_TRUE(stats.typing_noise_detected);
 }
 
 TEST(AudioSendStreamTest, SendCodecAppliesAudioNetworkAdaptor) {
   ConfigHelper helper(false, true);
   auto stream_config = helper.config();
   stream_config.send_codec_spec =
       rtc::Optional<AudioSendStream::Config::SendCodecSpec>({0, kOpusFormat});
   const std::string kAnaConfigString = "abcde";
   const std::string kAnaReconfigString = "12345";
 
@@ skipping 118 matching lines @@
     EXPECT_CALL(*helper.channel_proxy(), RegisterSenderCongestionControlObjects(
         helper.transport(), Ne(nullptr)))
         .Times(1);
   }
   send_stream.Reconfigure(new_config);
 }
 
 
 }  // namespace test
 }  // namespace webrtc