Remove remaining calls to VoE APIs from Audio[Send|Receive]Stream.

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 136 matching lines @@
     EXPECT_CALL(*channel_proxy_, DeRegisterExternalTransport()).Times(1);
     EXPECT_CALL(*channel_proxy_, SetRtcEventLog(testing::NotNull())).Times(1);
     EXPECT_CALL(*channel_proxy_, SetRtcEventLog(testing::IsNull()))
         .Times(1);  // Destructor resets the event log
     EXPECT_CALL(*channel_proxy_, SetRtcpRttStats(&rtcp_rtt_stats_)).Times(1);
     EXPECT_CALL(*channel_proxy_, SetRtcpRttStats(testing::IsNull()))
         .Times(1);  // Destructor resets the rtt stats.
   }
 
   void SetupMockForSetupSendCodec() {
-    EXPECT_CALL(voice_engine_, SetVADStatus(kChannelId, false, _, _))
-        .WillOnce(Return(0));
-    EXPECT_CALL(voice_engine_, SetFECStatus(kChannelId, false))
-        .WillOnce(Return(0));
+    EXPECT_CALL(*channel_proxy_, SetVADStatus(false))
+        .WillOnce(Return(true));
+    EXPECT_CALL(*channel_proxy_, SetCodecFECStatus(false))
+        .WillOnce(Return(true));
     EXPECT_CALL(*channel_proxy_, DisableAudioNetworkAdaptor());
-    // Let |GetSendCodec| return -1 for the first time to indicate that no send
-    // codec has been set.
-    EXPECT_CALL(voice_engine_, GetSendCodec(kChannelId, _))
-        .WillOnce(Return(-1));
-    EXPECT_CALL(voice_engine_, SetSendCodec(kChannelId, _)).WillOnce(Return(0));
+    // Let |GetSendCodec| return false for the first time to indicate that no
+    // send codec has been set.
+    EXPECT_CALL(*channel_proxy_, GetSendCodec(_)).WillOnce(Return(false));
+    EXPECT_CALL(*channel_proxy_, SetSendCodec(_)).WillOnce(Return(true));
   }
   RtcpRttStats* rtcp_rtt_stats() { return &rtcp_rtt_stats_; }
 
   void SetupMockForSendTelephoneEvent() {
     EXPECT_TRUE(channel_proxy_);
     EXPECT_CALL(*channel_proxy_,
         SetSendTelephoneEventPayloadType(kTelephoneEventPayloadType,
                                          kTelephoneEventPayloadFrequency))
             .WillOnce(Return(true));
     EXPECT_CALL(*channel_proxy_,
         SendTelephoneEventOutband(kTelephoneEventCode, kTelephoneEventDuration))
             .WillOnce(Return(true));
   }
 
   void SetupMockForGetStats() {
     using testing::DoAll;
+    using testing::SetArgPointee;
     using testing::SetArgReferee;
 
     std::vector<ReportBlock> report_blocks;
     webrtc::ReportBlock block = kReportBlock;
     report_blocks.push_back(block);  // Has wrong SSRC.
     block.source_SSRC = kSsrc;
     report_blocks.push_back(block);  // Correct block.
     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_, GetSendCodec(kChannelId, _))
-        .WillRepeatedly(DoAll(SetArgReferee<1>(kIsacCodec), Return(0)));
+    EXPECT_CALL(*channel_proxy_, GetSendCodec(_))
+        .WillRepeatedly(DoAll(SetArgPointee<0>(kIsacCodec), Return(true)));
     EXPECT_CALL(voice_engine_, GetSpeechInputLevelFullRange(_))
         .WillRepeatedly(DoAll(SetArgReferee<0>(kSpeechInputLevel), Return(0)));
     EXPECT_CALL(voice_engine_, audio_processing())
         .WillRepeatedly(Return(&audio_processing_));
 
     // 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(
@@ skipping 147 matching lines @@
   stream_config.send_codec_spec.codec_inst = kOpusCodec;
   stream_config.send_codec_spec.enable_codec_fec = true;
   stream_config.send_codec_spec.enable_opus_dtx = true;
   stream_config.send_codec_spec.opus_max_playback_rate = 12345;
   stream_config.send_codec_spec.cng_plfreq = 16000;
   stream_config.send_codec_spec.cng_payload_type = 105;
   stream_config.send_codec_spec.min_ptime_ms = 10;
   stream_config.send_codec_spec.max_ptime_ms = 60;
   stream_config.audio_network_adaptor_config =
       rtc::Optional<std::string>("abced");
-  EXPECT_CALL(*helper.voice_engine(), SetFECStatus(kChannelId, true))
-      .WillOnce(Return(0));
+  EXPECT_CALL(*helper.channel_proxy(), SetCodecFECStatus(true))
+      .WillOnce(Return(true));
   EXPECT_CALL(
-      *helper.voice_engine(),
-      SetOpusDtx(kChannelId, stream_config.send_codec_spec.enable_opus_dtx))
-      .WillOnce(Return(0));
+      *helper.channel_proxy(),
+      SetOpusDtx(stream_config.send_codec_spec.enable_opus_dtx))
+      .WillOnce(Return(true));
   EXPECT_CALL(
-      *helper.voice_engine(),
+      *helper.channel_proxy(),
       SetOpusMaxPlaybackRate(
-          kChannelId, stream_config.send_codec_spec.opus_max_playback_rate))
-      .WillOnce(Return(0));
-  EXPECT_CALL(*helper.voice_engine(),
+          stream_config.send_codec_spec.opus_max_playback_rate))
+      .WillOnce(Return(true));
+  EXPECT_CALL(*helper.channel_proxy(),
               SetSendCNPayloadType(
-                  kChannelId, stream_config.send_codec_spec.cng_payload_type,
+                  stream_config.send_codec_spec.cng_payload_type,
                   webrtc::kFreq16000Hz))
-      .WillOnce(Return(0));
+      .WillOnce(Return(true));
   EXPECT_CALL(
       *helper.channel_proxy(),
       SetReceiverFrameLengthRange(stream_config.send_codec_spec.min_ptime_ms,
                                   stream_config.send_codec_spec.max_ptime_ms));
   EXPECT_CALL(
       *helper.channel_proxy(),
       EnableAudioNetworkAdaptor(*stream_config.audio_network_adaptor_config));
   internal::AudioSendStream send_stream(
       stream_config, helper.audio_state(), helper.worker_queue(),
       helper.packet_router(), helper.congestion_controller(),
       helper.bitrate_allocator(), helper.event_log(), helper.rtcp_rtt_stats());
 }
 
 // VAD is applied when codec is mono and the CNG frequency matches the codec
 // sample rate.
 TEST(AudioSendStreamTest, SendCodecCanApplyVad) {
   ConfigHelper helper;
   auto stream_config = helper.config();
   const CodecInst kG722Codec = {9, "g722", 8000, 160, 1, 16000};
   stream_config.send_codec_spec.codec_inst = kG722Codec;
   stream_config.send_codec_spec.cng_plfreq = 8000;
   stream_config.send_codec_spec.cng_payload_type = 105;
-  EXPECT_CALL(*helper.voice_engine(), SetVADStatus(kChannelId, true, _, _))
-      .WillOnce(Return(0));
+  EXPECT_CALL(*helper.channel_proxy(), SetVADStatus(true))
+      .WillOnce(Return(true));
   internal::AudioSendStream send_stream(
       stream_config, helper.audio_state(), helper.worker_queue(),
       helper.packet_router(), helper.congestion_controller(),
       helper.bitrate_allocator(), helper.event_log(), helper.rtcp_rtt_stats());
 }
 
 TEST(AudioSendStreamTest, DoesNotPassHigherBitrateThanMaxBitrate) {
   ConfigHelper helper;
   internal::AudioSendStream send_stream(
       helper.config(), helper.audio_state(), helper.worker_queue(),
@@ skipping 10 matching lines @@
   internal::AudioSendStream send_stream(
       helper.config(), helper.audio_state(), helper.worker_queue(),
       helper.packet_router(), helper.congestion_controller(),
       helper.bitrate_allocator(), helper.event_log(), helper.rtcp_rtt_stats());
   EXPECT_CALL(*helper.channel_proxy(), SetBitrate(_, 5000));
   send_stream.OnBitrateUpdated(50000, 0.0, 50, 5000);
 }
 
 }  // namespace test
 }  // namespace webrtc