Moving WebRtcVoiceMediaChannel::SendSetCodec to AudioSendStream.

webrtc/media/engine/webrtcvoiceengine_unittest.cc

 /*
  *  Copyright (c) 2008 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 220 matching lines @@
   // |expected_result| is the expected result from SetMaxSendBandwidth().
   // |expected_bitrate| is the expected audio bitrate afterward.
   void TestMaxSendBandwidth(const cricket::AudioCodec& codec,
                             int max_bitrate,
                             bool expected_result,
                             int expected_bitrate) {
     cricket::AudioSendParameters parameters;
     parameters.codecs.push_back(codec);
     parameters.max_bandwidth_bps = max_bitrate;
     EXPECT_EQ(expected_result, channel_->SetSendParameters(parameters));
-
-    int channel_num = voe_.GetLastChannel();
-    webrtc::CodecInst temp_codec;
-    EXPECT_FALSE(voe_.GetSendCodec(channel_num, temp_codec));
-    EXPECT_EQ(expected_bitrate, temp_codec.rate);
+    CheckCodecBitrate(kSsrc1, expected_bitrate);
   }
 
   // Sets the per-stream maximum bitrate limit for the specified SSRC.
   bool SetMaxBitrateForStream(int32_t ssrc, int bitrate) {
     webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(ssrc);
     EXPECT_EQ(1UL, parameters.encodings.size());
 
     parameters.encodings[0].max_bitrate_bps = bitrate;
     return channel_->SetRtpSendParameters(ssrc, parameters);
   }
 
   bool SetGlobalMaxBitrate(const cricket::AudioCodec& codec, int bitrate) {
     cricket::AudioSendParameters send_parameters;
     send_parameters.codecs.push_back(codec);
     send_parameters.max_bandwidth_bps = bitrate;
     return channel_->SetSendParameters(send_parameters);
   }
 
-  int GetCodecBitrate(int32_t ssrc) {
-    cricket::WebRtcVoiceMediaChannel* media_channel =
-        static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_);
-    int channel = media_channel->GetSendChannelId(ssrc);
-    EXPECT_NE(-1, channel);
-    webrtc::CodecInst codec;
-    EXPECT_FALSE(voe_.GetSendCodec(channel, codec));
-    return codec.rate;
+  void CheckSendCodec(int32_t ssrc,
+                      const char expected_name[],
+                      int expected_channels,
+                      int expected_bitrate) {
+    ASSERT_TRUE(call_.GetAudioSendStream(ssrc) != nullptr);
+    auto codec =
+        call_.GetAudioSendStream(ssrc)->GetConfig().send_codec_spec.codec_inst;
+    EXPECT_STREQ(expected_name, codec.plname);
+    EXPECT_EQ(expected_channels, codec.channels);
+    EXPECT_EQ(expected_bitrate, codec.rate);
+  }
+
+  void CheckOpusMaxPlaybackRate(int32_t ssrc, int expected_max_playback_rate) {
+    ASSERT_TRUE(call_.GetAudioSendStream(ssrc) != nullptr);
+    auto codec = call_.GetAudioSendStream(ssrc)->GetConfig().send_codec_spec;
+    EXPECT_EQ(expected_max_playback_rate, codec.opus_max_playback_rate);
+  }
+
+  void CheckOpusDtx(int32_t ssrc, bool expected_dtx_enabled) {
+    ASSERT_TRUE(call_.GetAudioSendStream(ssrc) != nullptr);
+    auto codec = call_.GetAudioSendStream(ssrc)->GetConfig().send_codec_spec;

[the sun, 2016/10/17 14:58:22]

Generally, I don't think it's a good idea to hide test expectations in utility
functions. They should live right in the test case. Utilities for extracting
values though, is a good thing. We already have:

GetSendStreamConfig(uint32_t ssrc), which gives you a
webrtc::AudioSendStream::Config&. How about you create two more utilities:

const webrtc::AudioSendStream::Config::SendCodecSpec&
GetSendStreamCodecSpec(uint32_t ssrc)
and
const webrtc::Codecinst& GetSendStreamCodecInst(uint32_t ssrc)

and add the EXPECT_EQ in the test cases instead, e.g.:

CheckCodecBitrate(kSsrc1, kDesiredBitrate);
becomes
EXPECT_EQ(kDesiredBitrate, GetSendStreamCodecInst(kSsrc1).pacsize);

[minyue-webrtc, 2016/10/17 15:08:27]

The reason for these CheckXXX helpers two two folded:
1) with void return, we can ASSERT. If we let them return a value, ASSERT has to
be placed outside, then theywill not simplify the code at all.
2) I want to check several things together in one of them: CheckSendCodec

+    EXPECT_EQ(expected_dtx_enabled, codec.enable_opus_dtx);
+  }
+  void CheckCodecFec(int32_t ssrc, bool expected_fec_enabled) {
+    ASSERT_TRUE(call_.GetAudioSendStream(ssrc) != nullptr);
+    auto codec = call_.GetAudioSendStream(ssrc)->GetConfig().send_codec_spec;
+    EXPECT_EQ(expected_fec_enabled, codec.enable_codec_fec);
+  }
+
+  void CheckCodecBitrate(int32_t ssrc, int expected_bitrate) {
+    ASSERT_TRUE(call_.GetAudioSendStream(ssrc) != nullptr);
+    auto codec =
+        call_.GetAudioSendStream(ssrc)->GetConfig().send_codec_spec.codec_inst;
+    EXPECT_EQ(expected_bitrate, codec.rate);
+  }
+
+  void CheckCodecPacSize(int32_t ssrc, int expected_bitrate) {
+    ASSERT_TRUE(call_.GetAudioSendStream(ssrc) != nullptr);
+    auto codec =
+        call_.GetAudioSendStream(ssrc)->GetConfig().send_codec_spec.codec_inst;
+    EXPECT_EQ(expected_bitrate, codec.pacsize);
   }
 
   void SetAndExpectMaxBitrate(const cricket::AudioCodec& codec,
                               int global_max,
                               int stream_max,
                               bool expected_result,
                               int expected_codec_bitrate) {
     // Clear the bitrate limit from the previous test case.
     EXPECT_TRUE(SetMaxBitrateForStream(kSsrc1, -1));
 
     // Attempt to set the requested bitrate limits.
     EXPECT_TRUE(SetGlobalMaxBitrate(codec, global_max));
     EXPECT_EQ(expected_result, SetMaxBitrateForStream(kSsrc1, stream_max));
 
     // Verify that reading back the parameters gives results
     // consistent with the Set() result.
     webrtc::RtpParameters resulting_parameters =
         channel_->GetRtpSendParameters(kSsrc1);
     EXPECT_EQ(1UL, resulting_parameters.encodings.size());
     EXPECT_EQ(expected_result ? stream_max : -1,
               resulting_parameters.encodings[0].max_bitrate_bps);
 
     // Verify that the codec settings have the expected bitrate.
-    EXPECT_EQ(expected_codec_bitrate, GetCodecBitrate(kSsrc1));
+    CheckCodecBitrate(kSsrc1, expected_codec_bitrate);
   }
 
   void TestSetSendRtpHeaderExtensions(const std::string& ext) {
     EXPECT_TRUE(SetupSendStream());
 
     // Ensure extensions are off by default.
     EXPECT_EQ(0u, GetSendStreamConfig(kSsrc1).rtp.extensions.size());
 
     // Ensure unknown extensions won't cause an error.
     send_parameters_.extensions.push_back(
@@ skipping 533 matching lines @@
   EXPECT_TRUE(SetupChannel());
   const int kDesiredBitrate = 128000;
   cricket::AudioSendParameters parameters;
   parameters.codecs = engine_->send_codecs();
   parameters.max_bandwidth_bps = kDesiredBitrate;
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
 
   EXPECT_TRUE(channel_->AddSendStream(
       cricket::StreamParams::CreateLegacy(kSsrc1)));
 
-  int channel_num = voe_.GetLastChannel();
-  webrtc::CodecInst codec;
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, codec));
-  EXPECT_EQ(kDesiredBitrate, codec.rate);
+  CheckCodecBitrate(kSsrc1, kDesiredBitrate);
 }
 
 // Test that bitrate cannot be set for CBR codecs.
 // Bitrate is ignored if it is higher than the fixed bitrate.
 // Bitrate less then the fixed bitrate is an error.
 TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthCbr) {
   EXPECT_TRUE(SetupSendStream());
 
   // PCMU, default bitrate == 64000.
   EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
-  int channel_num = voe_.GetLastChannel();
-  webrtc::CodecInst codec;
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, codec));
-  EXPECT_EQ(64000, codec.rate);
+  CheckCodecBitrate(kSsrc1, 64000);
 
   send_parameters_.max_bandwidth_bps = 128000;
   EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, codec));
-  EXPECT_EQ(64000, codec.rate);
+  CheckCodecBitrate(kSsrc1, 64000);
 
   send_parameters_.max_bandwidth_bps = 128;
   EXPECT_FALSE(channel_->SetSendParameters(send_parameters_));
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, codec));
-  EXPECT_EQ(64000, codec.rate);
+  CheckCodecBitrate(kSsrc1, 64000);
 }
 
 // Test that the per-stream bitrate limit and the global
 // bitrate limit both apply.
 TEST_F(WebRtcVoiceEngineTestFake, SetMaxBitratePerStream) {
   EXPECT_TRUE(SetupSendStream());
 
   // opus, default bitrate == 64000.
   SetAndExpectMaxBitrate(kOpusCodec, 0, 0, true, 64000);
   SetAndExpectMaxBitrate(kOpusCodec, 48000, 0, true, 48000);
@@ skipping 72 matching lines @@
         channel_->AddSendStream(cricket::StreamParams::CreateLegacy(ssrc)));
   }
   // Configure one stream to be limited by the stream config, another to be
   // limited by the global max, and the third one with no per-stream limit
   // (still subject to the global limit).
   EXPECT_TRUE(SetGlobalMaxBitrate(kOpusCodec, 64000));
   EXPECT_TRUE(SetMaxBitrateForStream(kSsrcs4[0], 48000));
   EXPECT_TRUE(SetMaxBitrateForStream(kSsrcs4[1], 96000));
   EXPECT_TRUE(SetMaxBitrateForStream(kSsrcs4[2], -1));
 
-  EXPECT_EQ(48000, GetCodecBitrate(kSsrcs4[0]));
-  EXPECT_EQ(64000, GetCodecBitrate(kSsrcs4[1]));
-  EXPECT_EQ(64000, GetCodecBitrate(kSsrcs4[2]));
+  CheckCodecBitrate(kSsrcs4[0], 48000);
+  CheckCodecBitrate(kSsrcs4[1], 64000);
+  CheckCodecBitrate(kSsrcs4[2], 64000);
 
   // Remove the global cap; the streams should switch to their respective
   // maximums (or remain unchanged if there was no other limit on them.)
   EXPECT_TRUE(SetGlobalMaxBitrate(kOpusCodec, -1));
-  EXPECT_EQ(48000, GetCodecBitrate(kSsrcs4[0]));
-  EXPECT_EQ(96000, GetCodecBitrate(kSsrcs4[1]));
-  EXPECT_EQ(64000, GetCodecBitrate(kSsrcs4[2]));
+  CheckCodecBitrate(kSsrcs4[0], 48000);
+  CheckCodecBitrate(kSsrcs4[1], 96000);
+  CheckCodecBitrate(kSsrcs4[2], 64000);
 }
 
 // Test that GetRtpSendParameters returns the currently configured codecs.
 TEST_F(WebRtcVoiceEngineTestFake, GetRtpSendParametersCodecs) {
   EXPECT_TRUE(SetupSendStream());
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kIsacCodec);
   parameters.codecs.push_back(kPcmuCodec);
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
 
@@ skipping 58 matching lines @@
 
 // Test that we apply codecs properly.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecs) {
   EXPECT_TRUE(SetupSendStream());
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kIsacCodec);
   parameters.codecs.push_back(kPcmuCodec);
   parameters.codecs.push_back(kCn8000Codec);
   parameters.codecs[0].id = 96;
   parameters.codecs[0].bitrate = 48000;
+  const int initial_num = call_.GetNumCreatedSendStreams();
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  EXPECT_EQ(1, voe_.GetNumSetSendCodecs());
-  int channel_num = voe_.GetLastChannel();
-  webrtc::CodecInst gcodec;
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
-  EXPECT_EQ(96, gcodec.pltype);
-  EXPECT_EQ(48000, gcodec.rate);
-  EXPECT_STREQ("ISAC", gcodec.plname);
-  EXPECT_FALSE(voe_.GetVAD(channel_num));
-  EXPECT_EQ(13, voe_.GetSendCNPayloadType(channel_num, false));
-  EXPECT_EQ(105, voe_.GetSendCNPayloadType(channel_num, true));
+  EXPECT_EQ(initial_num + 1, call_.GetNumCreatedSendStreams());
+  ASSERT_TRUE(call_.GetAudioSendStream(kSsrc1) != nullptr);
+  auto send_codec_spec =
+      call_.GetAudioSendStream(kSsrc1)->GetConfig().send_codec_spec;
+  EXPECT_EQ(96, send_codec_spec.codec_inst.pltype);
+  EXPECT_EQ(48000, send_codec_spec.codec_inst.rate);
+  EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname);
+  EXPECT_NE(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq);
+  EXPECT_EQ(13, send_codec_spec.cng_payload_type);
+  EXPECT_EQ(webrtc::kFreq8000Hz, send_codec_spec.cng_plfreq);
   EXPECT_FALSE(channel_->CanInsertDtmf());
 }
 
 // Test that VoE Channel doesn't call SetSendCodec again if same codec is tried
 // to apply.
 TEST_F(WebRtcVoiceEngineTestFake, DontResetSetSendCodec) {
   EXPECT_TRUE(SetupSendStream());
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kIsacCodec);
   parameters.codecs.push_back(kPcmuCodec);
   parameters.codecs.push_back(kCn8000Codec);
   parameters.codecs[0].id = 96;
   parameters.codecs[0].bitrate = 48000;
+  const int initial_num = call_.GetNumCreatedSendStreams();
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  EXPECT_EQ(1, voe_.GetNumSetSendCodecs());
+  EXPECT_EQ(initial_num + 1, call_.GetNumCreatedSendStreams());
   // Calling SetSendCodec again with same codec which is already set.
   // In this case media channel shouldn't send codec to VoE.
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  EXPECT_EQ(1, voe_.GetNumSetSendCodecs());
+  EXPECT_EQ(initial_num + 1, call_.GetNumCreatedSendStreams());
 }
 
 // Verify that G722 is set with 16000 samples per second to WebRTC.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecG722) {
   EXPECT_TRUE(SetupSendStream());
-  int channel_num = voe_.GetLastChannel();
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kG722CodecSdp);
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  webrtc::CodecInst gcodec;
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
+  ASSERT_TRUE(call_.GetAudioSendStream(kSsrc1) != nullptr);
+  webrtc::CodecInst gcodec =
+      call_.GetAudioSendStream(kSsrc1)->GetConfig().send_codec_spec.codec_inst;
   EXPECT_STREQ("G722", gcodec.plname);
   EXPECT_EQ(1, gcodec.channels);
   EXPECT_EQ(16000, gcodec.plfreq);
 }
 
 // Test that if clockrate is not 48000 for opus, we fail.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusBadClockrate) {
   EXPECT_TRUE(SetupSendStream());
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kOpusCodec);
@@ skipping 52 matching lines @@
   parameters.codecs[0].bitrate = 0;
   parameters.codecs[0].channels = 1;
   parameters.codecs[0].params["stereo"] = "1";
   EXPECT_FALSE(channel_->SetSendParameters(parameters));
 }
 
 // Test that with bitrate=0 and no stereo,
 // channels and bitrate are 1 and 32000.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0BitrateNoStereo) {
   EXPECT_TRUE(SetupSendStream());
-  int channel_num = voe_.GetLastChannel();
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kOpusCodec);
   parameters.codecs[0].bitrate = 0;
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  webrtc::CodecInst gcodec;
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
-  EXPECT_STREQ("opus", gcodec.plname);
-  EXPECT_EQ(1, gcodec.channels);
-  EXPECT_EQ(32000, gcodec.rate);
+  CheckSendCodec(kSsrc1, "opus", 1, 32000);
 }
 
 // Test that with bitrate=0 and stereo=0,
 // channels and bitrate are 1 and 32000.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0Bitrate0Stereo) {
   EXPECT_TRUE(SetupSendStream());
-  int channel_num = voe_.GetLastChannel();
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kOpusCodec);
   parameters.codecs[0].bitrate = 0;
   parameters.codecs[0].params["stereo"] = "0";
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  webrtc::CodecInst gcodec;
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
-  EXPECT_STREQ("opus", gcodec.plname);
-  EXPECT_EQ(1, gcodec.channels);
-  EXPECT_EQ(32000, gcodec.rate);
+  CheckSendCodec(kSsrc1, "opus", 1, 32000);
 }
 
 // Test that with bitrate=invalid and stereo=0,
 // channels and bitrate are 1 and 32000.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodXBitrate0Stereo) {
   EXPECT_TRUE(SetupSendStream());
-  int channel_num = voe_.GetLastChannel();
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kOpusCodec);
   parameters.codecs[0].params["stereo"] = "0";
-  webrtc::CodecInst gcodec;
-
   // bitrate that's out of the range between 6000 and 510000 will be clamped.
   parameters.codecs[0].bitrate = 5999;
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
-  EXPECT_STREQ("opus", gcodec.plname);
-  EXPECT_EQ(1, gcodec.channels);
-  EXPECT_EQ(6000, gcodec.rate);
+  CheckSendCodec(kSsrc1, "opus", 1, 6000);
 
   parameters.codecs[0].bitrate = 510001;
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
-  EXPECT_STREQ("opus", gcodec.plname);
-  EXPECT_EQ(1, gcodec.channels);
-  EXPECT_EQ(510000, gcodec.rate);
+  CheckSendCodec(kSsrc1, "opus", 1, 510000);
 }
 
 // Test that with bitrate=0 and stereo=1,
 // channels and bitrate are 2 and 64000.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0Bitrate1Stereo) {
   EXPECT_TRUE(SetupSendStream());
-  int channel_num = voe_.GetLastChannel();
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kOpusCodec);
   parameters.codecs[0].bitrate = 0;
   parameters.codecs[0].params["stereo"] = "1";
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  webrtc::CodecInst gcodec;
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
-  EXPECT_STREQ("opus", gcodec.plname);
-  EXPECT_EQ(2, gcodec.channels);
-  EXPECT_EQ(64000, gcodec.rate);
+  CheckSendCodec(kSsrc1, "opus", 2, 64000);
 }
 
 // Test that with bitrate=invalid and stereo=1,
 // channels and bitrate are 2 and 64000.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodXBitrate1Stereo) {
   EXPECT_TRUE(SetupSendStream());
-  int channel_num = voe_.GetLastChannel();
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kOpusCodec);
   parameters.codecs[0].params["stereo"] = "1";
-  webrtc::CodecInst gcodec;
-
   // bitrate that's out of the range between 6000 and 510000 will be clamped.
   parameters.codecs[0].bitrate = 5999;
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
-  EXPECT_STREQ("opus", gcodec.plname);
-  EXPECT_EQ(2, gcodec.channels);
-  EXPECT_EQ(6000, gcodec.rate);
+  CheckSendCodec(kSsrc1, "opus", 2, 6000);
 
   parameters.codecs[0].bitrate = 510001;
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
-  EXPECT_STREQ("opus", gcodec.plname);
-  EXPECT_EQ(2, gcodec.channels);
-  EXPECT_EQ(510000, gcodec.rate);
+  CheckSendCodec(kSsrc1, "opus", 2, 510000);
 }
 
 // Test that with bitrate=N and stereo unset,
 // channels and bitrate are 1 and N.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrateNoStereo) {
   EXPECT_TRUE(SetupSendStream());
-  int channel_num = voe_.GetLastChannel();
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kOpusCodec);
   parameters.codecs[0].bitrate = 96000;
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  webrtc::CodecInst gcodec;
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
+  ASSERT_TRUE(call_.GetAudioSendStream(kSsrc1) != nullptr);
+  webrtc::CodecInst gcodec =
+      call_.GetAudioSendStream(kSsrc1)->GetConfig().send_codec_spec.codec_inst;
   EXPECT_EQ(111, gcodec.pltype);
   EXPECT_EQ(96000, gcodec.rate);
   EXPECT_STREQ("opus", gcodec.plname);
   EXPECT_EQ(1, gcodec.channels);
   EXPECT_EQ(48000, gcodec.plfreq);
 }
 
 // Test that with bitrate=N and stereo=0,
 // channels and bitrate are 1 and N.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrate0Stereo) {
   EXPECT_TRUE(SetupSendStream());
-  int channel_num = voe_.GetLastChannel();
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kOpusCodec);
   parameters.codecs[0].bitrate = 30000;
   parameters.codecs[0].params["stereo"] = "0";
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  webrtc::CodecInst gcodec;
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
-  EXPECT_EQ(1, gcodec.channels);
-  EXPECT_EQ(30000, gcodec.rate);
-  EXPECT_STREQ("opus", gcodec.plname);
+  CheckSendCodec(kSsrc1, "opus", 1, 30000);
 }
 
 // Test that with bitrate=N and without any parameters,
 // channels and bitrate are 1 and N.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrateNoParameters) {
   EXPECT_TRUE(SetupSendStream());
-  int channel_num = voe_.GetLastChannel();
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kOpusCodec);
   parameters.codecs[0].bitrate = 30000;
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  webrtc::CodecInst gcodec;
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
-  EXPECT_EQ(1, gcodec.channels);
-  EXPECT_EQ(30000, gcodec.rate);
-  EXPECT_STREQ("opus", gcodec.plname);
+  CheckSendCodec(kSsrc1, "opus", 1, 30000);
 }
 
 // Test that with bitrate=N and stereo=1,
 // channels and bitrate are 2 and N.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrate1Stereo) {
   EXPECT_TRUE(SetupSendStream());
-  int channel_num = voe_.GetLastChannel();
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kOpusCodec);
   parameters.codecs[0].bitrate = 30000;
   parameters.codecs[0].params["stereo"] = "1";
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  webrtc::CodecInst gcodec;
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
-  EXPECT_EQ(2, gcodec.channels);
-  EXPECT_EQ(30000, gcodec.rate);
-  EXPECT_STREQ("opus", gcodec.plname);
+  CheckSendCodec(kSsrc1, "opus", 2, 30000);
 }
 
 // Test that bitrate will be overridden by the "maxaveragebitrate" parameter.
 // Also test that the "maxaveragebitrate" can't be set to values outside the
 // range of 6000 and 510000
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusMaxAverageBitrate) {
   EXPECT_TRUE(SetupSendStream());
-  int channel_num = voe_.GetLastChannel();
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kOpusCodec);
   parameters.codecs[0].bitrate = 30000;
-  webrtc::CodecInst gcodec;
-
   // Ignore if less than 6000.
   parameters.codecs[0].params["maxaveragebitrate"] = "5999";
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
-  EXPECT_EQ(6000, gcodec.rate);
+  CheckCodecBitrate(kSsrc1, 6000);
 
   // Ignore if larger than 510000.
   parameters.codecs[0].params["maxaveragebitrate"] = "510001";
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
-  EXPECT_EQ(510000, gcodec.rate);
+  CheckCodecBitrate(kSsrc1, 510000);
 
   parameters.codecs[0].params["maxaveragebitrate"] = "200000";
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
-  EXPECT_EQ(200000, gcodec.rate);
+  CheckCodecBitrate(kSsrc1, 200000);
 }
 
 // Test that we can enable NACK with opus as caller.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecEnableNackAsCaller) {
   EXPECT_TRUE(SetupSendStream());
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kOpusCodec);
   parameters.codecs[0].AddFeedbackParam(
       cricket::FeedbackParam(cricket::kRtcpFbParamNack,
                              cricket::kParamValueEmpty));
@@ skipping 87 matching lines @@
 
   EXPECT_TRUE(AddRecvStream(kSsrc2));
   EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrc2).rtp.nack.rtp_history_ms);
   EXPECT_TRUE(AddRecvStream(kSsrc3));
   EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrc3).rtp.nack.rtp_history_ms);
 }
 
 // Test that without useinbandfec, Opus FEC is off.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecNoOpusFec) {
   EXPECT_TRUE(SetupSendStream());
-  int channel_num = voe_.GetLastChannel();
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kOpusCodec);
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  EXPECT_FALSE(voe_.GetCodecFEC(channel_num));
+  CheckCodecFec(kSsrc1, false);
 }
 
 // Test that with useinbandfec=0, Opus FEC is off.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusDisableFec) {
   EXPECT_TRUE(SetupSendStream());
-  int channel_num = voe_.GetLastChannel();
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kOpusCodec);
   parameters.codecs[0].bitrate = 0;
   parameters.codecs[0].params["useinbandfec"] = "0";
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  EXPECT_FALSE(voe_.GetCodecFEC(channel_num));
-  webrtc::CodecInst gcodec;
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
-  EXPECT_STREQ("opus", gcodec.plname);
-  EXPECT_EQ(1, gcodec.channels);
-  EXPECT_EQ(32000, gcodec.rate);
+  CheckSendCodec(kSsrc1, "opus", 1, 32000);
 }
 
 // Test that with useinbandfec=1, Opus FEC is on.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusEnableFec) {
   EXPECT_TRUE(SetupSendStream());
-  int channel_num = voe_.GetLastChannel();
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kOpusCodec);
   parameters.codecs[0].bitrate = 0;
   parameters.codecs[0].params["useinbandfec"] = "1";
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  EXPECT_TRUE(voe_.GetCodecFEC(channel_num));
-  webrtc::CodecInst gcodec;
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
-  EXPECT_STREQ("opus", gcodec.plname);
-  EXPECT_EQ(1, gcodec.channels);
-  EXPECT_EQ(32000, gcodec.rate);
+  CheckCodecFec(kSsrc1, true);
+  CheckSendCodec(kSsrc1, "opus", 1, 32000);
 }
 
 // Test that with useinbandfec=1, stereo=1, Opus FEC is on.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusEnableFecStereo) {
   EXPECT_TRUE(SetupSendStream());
-  int channel_num = voe_.GetLastChannel();
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kOpusCodec);
   parameters.codecs[0].bitrate = 0;
   parameters.codecs[0].params["stereo"] = "1";
   parameters.codecs[0].params["useinbandfec"] = "1";
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  EXPECT_TRUE(voe_.GetCodecFEC(channel_num));
-  webrtc::CodecInst gcodec;
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
-  EXPECT_STREQ("opus", gcodec.plname);
-  EXPECT_EQ(2, gcodec.channels);
-  EXPECT_EQ(64000, gcodec.rate);
+  CheckCodecFec(kSsrc1, true);
+  CheckSendCodec(kSsrc1, "opus", 2, 64000);
 }
 
 // Test that with non-Opus, codec FEC is off.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecIsacNoFec) {
   EXPECT_TRUE(SetupSendStream());
-  int channel_num = voe_.GetLastChannel();
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kIsacCodec);
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  EXPECT_FALSE(voe_.GetCodecFEC(channel_num));
+  CheckCodecFec(kSsrc1, false);
 }
 
 // Test the with non-Opus, even if useinbandfec=1, FEC is off.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecIsacWithParamNoFec) {
   EXPECT_TRUE(SetupSendStream());
-  int channel_num = voe_.GetLastChannel();
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kIsacCodec);
   parameters.codecs[0].params["useinbandfec"] = "1";
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  EXPECT_FALSE(voe_.GetCodecFEC(channel_num));
+  CheckCodecFec(kSsrc1, false);
 }
 
 // Test that Opus FEC status can be changed.
 TEST_F(WebRtcVoiceEngineTestFake, ChangeOpusFecStatus) {
   EXPECT_TRUE(SetupSendStream());
-  int channel_num = voe_.GetLastChannel();
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kOpusCodec);
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  EXPECT_FALSE(voe_.GetCodecFEC(channel_num));
+  CheckCodecFec(kSsrc1, false);
+
   parameters.codecs[0].params["useinbandfec"] = "1";
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  EXPECT_TRUE(voe_.GetCodecFEC(channel_num));
+  CheckCodecFec(kSsrc1, true);
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, TransportCcCanBeEnabledAndDisabled) {
   EXPECT_TRUE(SetupChannel());
   cricket::AudioSendParameters send_parameters;
   send_parameters.codecs.push_back(kOpusCodec);
   EXPECT_TRUE(send_parameters.codecs[0].feedback_params.params().empty());
   EXPECT_TRUE(channel_->SetSendParameters(send_parameters));
 
   cricket::AudioRecvParameters recv_parameters;
   recv_parameters.codecs.push_back(kIsacCodec);
   EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters));
   EXPECT_TRUE(AddRecvStream(kSsrc1));
   ASSERT_TRUE(call_.GetAudioReceiveStream(kSsrc1) != nullptr);
   EXPECT_FALSE(
       call_.GetAudioReceiveStream(kSsrc1)->GetConfig().rtp.transport_cc);
 
   send_parameters.codecs = engine_->send_codecs();
   EXPECT_TRUE(channel_->SetSendParameters(send_parameters));
   ASSERT_TRUE(call_.GetAudioReceiveStream(kSsrc1) != nullptr);
   EXPECT_TRUE(
       call_.GetAudioReceiveStream(kSsrc1)->GetConfig().rtp.transport_cc);
 }
 
 // Test maxplaybackrate <= 8000 triggers Opus narrow band mode.
 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateNb) {
   EXPECT_TRUE(SetupSendStream());
-  int channel_num = voe_.GetLastChannel();
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kOpusCodec);
   parameters.codecs[0].bitrate = 0;
   parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 8000);
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  EXPECT_EQ(cricket::kOpusBandwidthNb,
-            voe_.GetMaxEncodingBandwidth(channel_num));
-  webrtc::CodecInst gcodec;
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
-  EXPECT_STREQ("opus", gcodec.plname);
+  CheckOpusMaxPlaybackRate(kSsrc1, 8000);
+  CheckCodecBitrate(kSsrc1, 12000);
 
-  EXPECT_EQ(12000, gcodec.rate);
   parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1");
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
-  EXPECT_EQ(24000, gcodec.rate);
+  CheckCodecBitrate(kSsrc1, 24000);
 }
 
 // Test 8000 < maxplaybackrate <= 12000 triggers Opus medium band mode.
 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateMb) {
   EXPECT_TRUE(SetupSendStream());
-  int channel_num = voe_.GetLastChannel();
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kOpusCodec);
   parameters.codecs[0].bitrate = 0;
   parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 8001);
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  EXPECT_EQ(cricket::kOpusBandwidthMb,
-            voe_.GetMaxEncodingBandwidth(channel_num));
-  webrtc::CodecInst gcodec;
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
-  EXPECT_STREQ("opus", gcodec.plname);
+  CheckOpusMaxPlaybackRate(kSsrc1, 8001);
+  CheckCodecBitrate(kSsrc1, 20000);
 
-  EXPECT_EQ(20000, gcodec.rate);
   parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1");
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
-  EXPECT_EQ(40000, gcodec.rate);
+  CheckCodecBitrate(kSsrc1, 40000);
 }
 
 // Test 12000 < maxplaybackrate <= 16000 triggers Opus wide band mode.
 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateWb) {
   EXPECT_TRUE(SetupSendStream());
-  int channel_num = voe_.GetLastChannel();
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kOpusCodec);
   parameters.codecs[0].bitrate = 0;
   parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 12001);
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  EXPECT_EQ(cricket::kOpusBandwidthWb,
-            voe_.GetMaxEncodingBandwidth(channel_num));
-  webrtc::CodecInst gcodec;
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
-  EXPECT_STREQ("opus", gcodec.plname);
+  CheckOpusMaxPlaybackRate(kSsrc1, 12001);
+  CheckCodecBitrate(kSsrc1, 20000);
 
-  EXPECT_EQ(20000, gcodec.rate);
   parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1");
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
-  EXPECT_EQ(40000, gcodec.rate);
+  CheckCodecBitrate(kSsrc1, 40000);
 }
 
 // Test 16000 < maxplaybackrate <= 24000 triggers Opus super wide band mode.
 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateSwb) {
   EXPECT_TRUE(SetupSendStream());
-  int channel_num = voe_.GetLastChannel();
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kOpusCodec);
   parameters.codecs[0].bitrate = 0;
   parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 16001);
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  EXPECT_EQ(cricket::kOpusBandwidthSwb,
-            voe_.GetMaxEncodingBandwidth(channel_num));
-  webrtc::CodecInst gcodec;
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
-  EXPECT_STREQ("opus", gcodec.plname);
+  CheckOpusMaxPlaybackRate(kSsrc1, 16001);
+  CheckCodecBitrate(kSsrc1, 32000);
 
-  EXPECT_EQ(32000, gcodec.rate);
   parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1");
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
-  EXPECT_EQ(64000, gcodec.rate);
+  CheckCodecBitrate(kSsrc1, 64000);
 }
 
 // Test 24000 < maxplaybackrate triggers Opus full band mode.
 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateFb) {
   EXPECT_TRUE(SetupSendStream());
-  int channel_num = voe_.GetLastChannel();
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kOpusCodec);
   parameters.codecs[0].bitrate = 0;
   parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 24001);
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  EXPECT_EQ(cricket::kOpusBandwidthFb,
-            voe_.GetMaxEncodingBandwidth(channel_num));
-  webrtc::CodecInst gcodec;
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
-  EXPECT_STREQ("opus", gcodec.plname);
+  CheckOpusMaxPlaybackRate(kSsrc1, 24001);
+  CheckCodecBitrate(kSsrc1, 32000);
 
-  EXPECT_EQ(32000, gcodec.rate);
   parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1");
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
-  EXPECT_EQ(64000, gcodec.rate);
+  CheckCodecBitrate(kSsrc1, 64000);
 }
 
 // Test Opus that without maxplaybackrate, default playback rate is used.
 TEST_F(WebRtcVoiceEngineTestFake, DefaultOpusMaxPlaybackRate) {
   EXPECT_TRUE(SetupSendStream());
-  int channel_num = voe_.GetLastChannel();
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kOpusCodec);
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  EXPECT_EQ(cricket::kOpusBandwidthFb,
-            voe_.GetMaxEncodingBandwidth(channel_num));
+  CheckOpusMaxPlaybackRate(kSsrc1, 48000);
 }
 
 // Test the with non-Opus, maxplaybackrate has no effect.
 TEST_F(WebRtcVoiceEngineTestFake, SetNonOpusMaxPlaybackRate) {
   EXPECT_TRUE(SetupSendStream());
-  int channel_num = voe_.GetLastChannel();
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kIsacCodec);
   parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 32000);
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  EXPECT_EQ(0, voe_.GetMaxEncodingBandwidth(channel_num));
+  CheckOpusMaxPlaybackRate(kSsrc1, 0);
 }
 
 // Test maxplaybackrate can be set on two streams.
 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateOnTwoStreams) {
   EXPECT_TRUE(SetupSendStream());
-  int channel_num = voe_.GetLastChannel();
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kOpusCodec);
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  // Default bandwidth is 24000.
-  EXPECT_EQ(cricket::kOpusBandwidthFb,
-            voe_.GetMaxEncodingBandwidth(channel_num));
+  CheckOpusMaxPlaybackRate(kSsrc1, 48000);
 
   parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 8000);
-
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  EXPECT_EQ(cricket::kOpusBandwidthNb,
-            voe_.GetMaxEncodingBandwidth(channel_num));
+  CheckOpusMaxPlaybackRate(kSsrc1, 8000);
 
   channel_->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc2));
-  channel_num = voe_.GetLastChannel();
-  EXPECT_EQ(cricket::kOpusBandwidthNb,
-            voe_.GetMaxEncodingBandwidth(channel_num));
+  CheckOpusMaxPlaybackRate(kSsrc2, 8000);
 }
 
 // Test that with usedtx=0, Opus DTX is off.
 TEST_F(WebRtcVoiceEngineTestFake, DisableOpusDtxOnOpus) {
   EXPECT_TRUE(SetupSendStream());
-  int channel_num = voe_.GetLastChannel();
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kOpusCodec);
   parameters.codecs[0].params["usedtx"] = "0";
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  EXPECT_FALSE(voe_.GetOpusDtx(channel_num));
+  CheckOpusDtx(kSsrc1, false);
 }
 
 // Test that with usedtx=1, Opus DTX is on.
 TEST_F(WebRtcVoiceEngineTestFake, EnableOpusDtxOnOpus) {
   EXPECT_TRUE(SetupSendStream());
-  int channel_num = voe_.GetLastChannel();
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kOpusCodec);
   parameters.codecs[0].params["usedtx"] = "1";
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  EXPECT_TRUE(voe_.GetOpusDtx(channel_num));
-  EXPECT_FALSE(voe_.GetVAD(channel_num));  // Opus DTX should not affect VAD.
+  CheckOpusDtx(kSsrc1, true);
 }
 
 // Test that usedtx=1 works with stereo Opus.
 TEST_F(WebRtcVoiceEngineTestFake, EnableOpusDtxOnOpusStereo) {
   EXPECT_TRUE(SetupSendStream());
-  int channel_num = voe_.GetLastChannel();
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kOpusCodec);
   parameters.codecs[0].params["usedtx"] = "1";
   parameters.codecs[0].params["stereo"] = "1";
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  EXPECT_TRUE(voe_.GetOpusDtx(channel_num));
-  EXPECT_FALSE(voe_.GetVAD(channel_num));   // Opus DTX should not affect VAD.
+  CheckOpusDtx(kSsrc1, true);
 }
 
 // Test that usedtx=1 does not work with non Opus.
 TEST_F(WebRtcVoiceEngineTestFake, CannotEnableOpusDtxOnNonOpus) {
   EXPECT_TRUE(SetupSendStream());
-  int channel_num = voe_.GetLastChannel();
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kIsacCodec);
   parameters.codecs[0].params["usedtx"] = "1";
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  EXPECT_FALSE(voe_.GetOpusDtx(channel_num));
+  CheckOpusDtx(kSsrc1, false);
 }
 
 // Test that we can switch back and forth between Opus and ISAC with CN.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsIsacOpusSwitching) {
   EXPECT_TRUE(SetupSendStream());
-  int channel_num = voe_.GetLastChannel();
+
   cricket::AudioSendParameters opus_parameters;
   opus_parameters.codecs.push_back(kOpusCodec);
   EXPECT_TRUE(channel_->SetSendParameters(opus_parameters));
-  webrtc::CodecInst gcodec;
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
+  ASSERT_TRUE(call_.GetAudioSendStream(kSsrc1) != nullptr);
+  webrtc::CodecInst gcodec =
+      call_.GetAudioSendStream(kSsrc1)->GetConfig().send_codec_spec.codec_inst;
   EXPECT_EQ(111, gcodec.pltype);
   EXPECT_STREQ("opus", gcodec.plname);
 
   cricket::AudioSendParameters isac_parameters;
   isac_parameters.codecs.push_back(kIsacCodec);
   isac_parameters.codecs.push_back(kCn16000Codec);
   isac_parameters.codecs.push_back(kOpusCodec);
   EXPECT_TRUE(channel_->SetSendParameters(isac_parameters));
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
+  ASSERT_TRUE(call_.GetAudioSendStream(kSsrc1) != nullptr);
+  gcodec =
+      call_.GetAudioSendStream(kSsrc1)->GetConfig().send_codec_spec.codec_inst;
   EXPECT_EQ(103, gcodec.pltype);
   EXPECT_STREQ("ISAC", gcodec.plname);
 
   EXPECT_TRUE(channel_->SetSendParameters(opus_parameters));
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
+  ASSERT_TRUE(call_.GetAudioSendStream(kSsrc1) != nullptr);
+  gcodec =
+      call_.GetAudioSendStream(kSsrc1)->GetConfig().send_codec_spec.codec_inst;
   EXPECT_EQ(111, gcodec.pltype);
   EXPECT_STREQ("opus", gcodec.plname);
 }
 
 // Test that we handle various ways of specifying bitrate.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsBitrate) {
   EXPECT_TRUE(SetupSendStream());
-  int channel_num = voe_.GetLastChannel();
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kIsacCodec);  // bitrate == 32000
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  webrtc::CodecInst gcodec;
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
+  ASSERT_TRUE(call_.GetAudioSendStream(kSsrc1) != nullptr);
+  webrtc::CodecInst gcodec =
+      call_.GetAudioSendStream(kSsrc1)->GetConfig().send_codec_spec.codec_inst;
   EXPECT_EQ(103, gcodec.pltype);
   EXPECT_STREQ("ISAC", gcodec.plname);
   EXPECT_EQ(32000, gcodec.rate);
 
   parameters.codecs[0].bitrate = 0;         // bitrate == default
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
+  ASSERT_TRUE(call_.GetAudioSendStream(kSsrc1) != nullptr);
+  gcodec =
+      call_.GetAudioSendStream(kSsrc1)->GetConfig().send_codec_spec.codec_inst;
   EXPECT_EQ(103, gcodec.pltype);
   EXPECT_STREQ("ISAC", gcodec.plname);
   EXPECT_EQ(-1, gcodec.rate);
 
   parameters.codecs[0].bitrate = 28000;     // bitrate == 28000
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
+  ASSERT_TRUE(call_.GetAudioSendStream(kSsrc1) != nullptr);
+  gcodec =
+      call_.GetAudioSendStream(kSsrc1)->GetConfig().send_codec_spec.codec_inst;
   EXPECT_EQ(103, gcodec.pltype);
   EXPECT_STREQ("ISAC", gcodec.plname);
   EXPECT_EQ(28000, gcodec.rate);
 
   parameters.codecs[0] = kPcmuCodec;        // bitrate == 64000
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
+  ASSERT_TRUE(call_.GetAudioSendStream(kSsrc1) != nullptr);
+  gcodec =
+      call_.GetAudioSendStream(kSsrc1)->GetConfig().send_codec_spec.codec_inst;
   EXPECT_EQ(0, gcodec.pltype);
   EXPECT_STREQ("PCMU", gcodec.plname);
   EXPECT_EQ(64000, gcodec.rate);
 
   parameters.codecs[0].bitrate = 0;         // bitrate == default
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
+  ASSERT_TRUE(call_.GetAudioSendStream(kSsrc1) != nullptr);
+  gcodec =
+      call_.GetAudioSendStream(kSsrc1)->GetConfig().send_codec_spec.codec_inst;
   EXPECT_EQ(0, gcodec.pltype);
   EXPECT_STREQ("PCMU", gcodec.plname);
   EXPECT_EQ(64000, gcodec.rate);
 
   parameters.codecs[0] = kOpusCodec;
   parameters.codecs[0].bitrate = 0;         // bitrate == default
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
+  ASSERT_TRUE(call_.GetAudioSendStream(kSsrc1) != nullptr);
+  gcodec =
+      call_.GetAudioSendStream(kSsrc1)->GetConfig().send_codec_spec.codec_inst;
   EXPECT_EQ(111, gcodec.pltype);
   EXPECT_STREQ("opus", gcodec.plname);
   EXPECT_EQ(32000, gcodec.rate);
 }
 
 // Test that we could set packet size specified in kCodecParamPTime.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsPTimeAsPacketSize) {
   EXPECT_TRUE(SetupSendStream());
-  int channel_num = voe_.GetLastChannel();
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kOpusCodec);
   parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 40); // Within range.
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  webrtc::CodecInst gcodec;
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
-  EXPECT_EQ(1920, gcodec.pacsize);  // Opus gets 40ms.
+  CheckCodecPacSize(kSsrc1, 1920);  // Opus gets 40ms.
 
   parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 5); // Below range.
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
-  EXPECT_EQ(480, gcodec.pacsize);  // Opus gets 10ms.
+  CheckCodecPacSize(kSsrc1, 480);  // Opus gets 10ms.
 
   parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 80); // Beyond range.
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
-  EXPECT_EQ(2880, gcodec.pacsize);  // Opus gets 60ms.
+  CheckCodecPacSize(kSsrc1, 2880);  // Opus gets 60ms.
 
   parameters.codecs[0] = kIsacCodec;  // Also try Isac, with unsupported size.
   parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 40); // Within range.
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
-  EXPECT_EQ(480, gcodec.pacsize);  // Isac gets 30ms as the next smallest value.
+  CheckCodecPacSize(kSsrc1, 480);  // Isac gets 30ms as the next smallest value.
 
   parameters.codecs[0] = kG722CodecSdp;  // Try G722 @8kHz as negotiated in SDP.
   parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 40);
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
-  EXPECT_EQ(640, gcodec.pacsize);  // G722 gets 40ms @16kHz as defined in VoE.
+  CheckCodecPacSize(kSsrc1, 640);  // G722 gets 40ms @16kHz as defined in VoE.
 }
 
 // Test that we fail if no codecs are specified.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsNoCodecs) {
   EXPECT_TRUE(SetupSendStream());
   cricket::AudioSendParameters parameters;
   EXPECT_FALSE(channel_->SetSendParameters(parameters));
 }
 
 // Test that we can set send codecs even with telephone-event codec as the first
 // one on the list.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsDTMFOnTop) {
   EXPECT_TRUE(SetupSendStream());
-  int channel_num = voe_.GetLastChannel();
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kTelephoneEventCodec);
   parameters.codecs.push_back(kIsacCodec);
   parameters.codecs.push_back(kPcmuCodec);
   parameters.codecs[0].id = 98;  // DTMF
   parameters.codecs[1].id = 96;
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  webrtc::CodecInst gcodec;
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
+  ASSERT_TRUE(call_.GetAudioSendStream(kSsrc1) != nullptr);
+  webrtc::CodecInst gcodec =
+      call_.GetAudioSendStream(kSsrc1)->GetConfig().send_codec_spec.codec_inst;
   EXPECT_EQ(96, gcodec.pltype);
   EXPECT_STREQ("ISAC", gcodec.plname);
   EXPECT_TRUE(channel_->CanInsertDtmf());
 }
 
 // Test that payload type range is limited for telephone-event codec.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsDTMFPayloadTypeOutOfRange) {
   EXPECT_TRUE(SetupSendStream());
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kTelephoneEventCodec);
@@ skipping 10 matching lines @@
   EXPECT_TRUE(channel_->CanInsertDtmf());
   parameters.codecs[0].id = -1;  // DTMF
   EXPECT_FALSE(channel_->SetSendParameters(parameters));
   EXPECT_FALSE(channel_->CanInsertDtmf());
 }
 
 // Test that we can set send codecs even with CN codec as the first
 // one on the list.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNOnTop) {
   EXPECT_TRUE(SetupSendStream());
-  int channel_num = voe_.GetLastChannel();
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kCn16000Codec);
   parameters.codecs.push_back(kIsacCodec);
   parameters.codecs.push_back(kPcmuCodec);
   parameters.codecs[0].id = 98;  // wideband CN
   parameters.codecs[1].id = 96;
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  webrtc::CodecInst gcodec;
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
-  EXPECT_EQ(96, gcodec.pltype);
-  EXPECT_STREQ("ISAC", gcodec.plname);
-  EXPECT_EQ(98, voe_.GetSendCNPayloadType(channel_num, true));
+  ASSERT_TRUE(call_.GetAudioSendStream(kSsrc1) != nullptr);
+  auto send_codec_spec =
+      call_.GetAudioSendStream(kSsrc1)->GetConfig().send_codec_spec;
+  EXPECT_EQ(96, send_codec_spec.codec_inst.pltype);
+  EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname);
+  EXPECT_EQ(98, send_codec_spec.cng_payload_type);
+  EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq);
 }
 
 // Test that we set VAD and DTMF types correctly as caller.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCaller) {
   EXPECT_TRUE(SetupSendStream());
-  int channel_num = voe_.GetLastChannel();
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kIsacCodec);
   parameters.codecs.push_back(kPcmuCodec);
   // TODO(juberti): cn 32000
   parameters.codecs.push_back(kCn16000Codec);
   parameters.codecs.push_back(kCn8000Codec);
   parameters.codecs.push_back(kTelephoneEventCodec);
   parameters.codecs[0].id = 96;
   parameters.codecs[2].id = 97;  // wideband CN
   parameters.codecs[4].id = 98;  // DTMF
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  webrtc::CodecInst gcodec;
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
-  EXPECT_EQ(96, gcodec.pltype);
-  EXPECT_STREQ("ISAC", gcodec.plname);
-  EXPECT_TRUE(voe_.GetVAD(channel_num));
-  EXPECT_EQ(13, voe_.GetSendCNPayloadType(channel_num, false));
-  EXPECT_EQ(97, voe_.GetSendCNPayloadType(channel_num, true));
+  ASSERT_TRUE(call_.GetAudioSendStream(kSsrc1) != nullptr);
+  auto send_codec_spec =
+      call_.GetAudioSendStream(kSsrc1)->GetConfig().send_codec_spec;
+  EXPECT_EQ(96, send_codec_spec.codec_inst.pltype);
+  EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname);
+  EXPECT_EQ(1, send_codec_spec.codec_inst.channels);
+  EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq);
+  EXPECT_EQ(97, send_codec_spec.cng_payload_type);
+  EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq);
   EXPECT_TRUE(channel_->CanInsertDtmf());
 }
 
 // Test that we set VAD and DTMF types correctly as callee.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCallee) {
   EXPECT_TRUE(SetupChannel());
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kIsacCodec);
   parameters.codecs.push_back(kPcmuCodec);
   // TODO(juberti): cn 32000
   parameters.codecs.push_back(kCn16000Codec);
   parameters.codecs.push_back(kCn8000Codec);
   parameters.codecs.push_back(kTelephoneEventCodec);
   parameters.codecs[0].id = 96;
   parameters.codecs[2].id = 97;  // wideband CN
   parameters.codecs[4].id = 98;  // DTMF
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
   EXPECT_TRUE(channel_->AddSendStream(
       cricket::StreamParams::CreateLegacy(kSsrc1)));
-  int channel_num = voe_.GetLastChannel();
 
-  webrtc::CodecInst gcodec;
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
-  EXPECT_EQ(96, gcodec.pltype);
-  EXPECT_STREQ("ISAC", gcodec.plname);
-  EXPECT_TRUE(voe_.GetVAD(channel_num));
-  EXPECT_EQ(13, voe_.GetSendCNPayloadType(channel_num, false));
-  EXPECT_EQ(97, voe_.GetSendCNPayloadType(channel_num, true));
+  ASSERT_TRUE(call_.GetAudioSendStream(kSsrc1) != nullptr);
+  auto send_codec_spec =
+      call_.GetAudioSendStream(kSsrc1)->GetConfig().send_codec_spec;
+  EXPECT_EQ(96, send_codec_spec.codec_inst.pltype);
+  EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname);
+  EXPECT_EQ(1, send_codec_spec.codec_inst.channels);
+  EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq);
+  EXPECT_EQ(97, send_codec_spec.cng_payload_type);
+  EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq);
   EXPECT_TRUE(channel_->CanInsertDtmf());
 }
 
 // Test that we only apply VAD if we have a CN codec that matches the
 // send codec clockrate.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNNoMatch) {
   EXPECT_TRUE(SetupSendStream());
-  int channel_num = voe_.GetLastChannel();
   cricket::AudioSendParameters parameters;
   // Set ISAC(16K) and CN(16K). VAD should be activated.
   parameters.codecs.push_back(kIsacCodec);
   parameters.codecs.push_back(kCn16000Codec);
   parameters.codecs[1].id = 97;
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  webrtc::CodecInst gcodec;
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
-  EXPECT_STREQ("ISAC", gcodec.plname);
-  EXPECT_TRUE(voe_.GetVAD(channel_num));
-  EXPECT_EQ(97, voe_.GetSendCNPayloadType(channel_num, true));
+  ASSERT_TRUE(call_.GetAudioSendStream(kSsrc1) != nullptr);
+  auto send_codec_spec =
+      call_.GetAudioSendStream(kSsrc1)->GetConfig().send_codec_spec;
+  EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname);
+  EXPECT_EQ(1, send_codec_spec.codec_inst.channels);
+  EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq);
+  EXPECT_EQ(97, send_codec_spec.cng_payload_type);
+  EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq);
   // Set PCMU(8K) and CN(16K). VAD should not be activated.
   parameters.codecs[0] = kPcmuCodec;
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
-  EXPECT_STREQ("PCMU", gcodec.plname);
-  EXPECT_FALSE(voe_.GetVAD(channel_num));
+  ASSERT_TRUE(call_.GetAudioSendStream(kSsrc1) != nullptr);
+  send_codec_spec =
+      call_.GetAudioSendStream(kSsrc1)->GetConfig().send_codec_spec;
+  EXPECT_STREQ("PCMU", send_codec_spec.codec_inst.plname);
+  EXPECT_NE(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq);
   // Set PCMU(8K) and CN(8K). VAD should be activated.
   parameters.codecs[1] = kCn8000Codec;
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
-  EXPECT_STREQ("PCMU", gcodec.plname);
-  EXPECT_TRUE(voe_.GetVAD(channel_num));
-  EXPECT_EQ(13, voe_.GetSendCNPayloadType(channel_num, false));
+  ASSERT_TRUE(call_.GetAudioSendStream(kSsrc1) != nullptr);
+  send_codec_spec =
+      call_.GetAudioSendStream(kSsrc1)->GetConfig().send_codec_spec;
+  EXPECT_STREQ("PCMU", send_codec_spec.codec_inst.plname);
+  EXPECT_EQ(1, send_codec_spec.codec_inst.channels);
+  EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq);
+  EXPECT_EQ(13, send_codec_spec.cng_payload_type);
+  EXPECT_EQ(webrtc::kFreq8000Hz, send_codec_spec.cng_plfreq);
   // Set ISAC(16K) and CN(8K). VAD should not be activated.
   parameters.codecs[0] = kIsacCodec;
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
-  EXPECT_STREQ("ISAC", gcodec.plname);
-  EXPECT_FALSE(voe_.GetVAD(channel_num));
+  ASSERT_TRUE(call_.GetAudioSendStream(kSsrc1) != nullptr);
+  send_codec_spec =
+      call_.GetAudioSendStream(kSsrc1)->GetConfig().send_codec_spec;
+  EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname);
+  EXPECT_NE(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq);
 }
 
 // Test that we perform case-insensitive matching of codec names.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCaseInsensitive) {
   EXPECT_TRUE(SetupSendStream());
-  int channel_num = voe_.GetLastChannel();
   cricket::AudioSendParameters parameters;
   parameters.codecs.push_back(kIsacCodec);
   parameters.codecs.push_back(kPcmuCodec);
   parameters.codecs.push_back(kCn16000Codec);
   parameters.codecs.push_back(kCn8000Codec);
   parameters.codecs.push_back(kTelephoneEventCodec);
   parameters.codecs[0].name = "iSaC";
   parameters.codecs[0].id = 96;
   parameters.codecs[2].id = 97;  // wideband CN
   parameters.codecs[4].id = 98;  // DTMF
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
-  webrtc::CodecInst gcodec;
-  EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
-  EXPECT_EQ(96, gcodec.pltype);
-  EXPECT_STREQ("ISAC", gcodec.plname);
-  EXPECT_TRUE(voe_.GetVAD(channel_num));
-  EXPECT_EQ(13, voe_.GetSendCNPayloadType(channel_num, false));
-  EXPECT_EQ(97, voe_.GetSendCNPayloadType(channel_num, true));
+  ASSERT_TRUE(call_.GetAudioSendStream(kSsrc1) != nullptr);
+  auto send_codec_spec =
+      call_.GetAudioSendStream(kSsrc1)->GetConfig().send_codec_spec;
+  EXPECT_EQ(96, send_codec_spec.codec_inst.pltype);
+  EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname);
+  EXPECT_EQ(1, send_codec_spec.codec_inst.channels);
+  EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq);
+  EXPECT_EQ(97, send_codec_spec.cng_payload_type);
+  EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq);
   EXPECT_TRUE(channel_->CanInsertDtmf());
 }
 
 class WebRtcVoiceEngineWithSendSideBweTest : public WebRtcVoiceEngineTestFake {
  public:
   WebRtcVoiceEngineWithSendSideBweTest()
       : WebRtcVoiceEngineTestFake("WebRTC-Audio-SendSideBwe/Enabled/") {}
 };
 
 TEST_F(WebRtcVoiceEngineWithSendSideBweTest,
@@ skipping 132 matching lines @@
   }
 
   cricket::AudioSendParameters parameters;
   // Set ISAC(16K) and CN(16K). VAD should be activated.
   parameters.codecs.push_back(kIsacCodec);
   parameters.codecs.push_back(kCn16000Codec);
   parameters.codecs[1].id = 97;
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
 
   // Verify ISAC and VAD are corrected configured on all send channels.
-  webrtc::CodecInst gcodec;
   for (uint32_t ssrc : kSsrcs4) {
-    int channel_num = GetSendStreamConfig(ssrc).voe_channel_id;
-    EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
-    EXPECT_STREQ("ISAC", gcodec.plname);
-    EXPECT_TRUE(voe_.GetVAD(channel_num));
-    EXPECT_EQ(97, voe_.GetSendCNPayloadType(channel_num, true));
+    ASSERT_TRUE(call_.GetAudioSendStream(ssrc) != nullptr);
+    auto send_codec_spec =
+        call_.GetAudioSendStream(ssrc)->GetConfig().send_codec_spec;
+    EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname);
+    EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq);
+    EXPECT_EQ(1, send_codec_spec.codec_inst.channels);
+    EXPECT_EQ(97, send_codec_spec.cng_payload_type);
+    EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq);
   }
 
-  // Change to PCMU(8K) and CN(16K). VAD should not be activated.
+  // Change to PCMU(8K) and CN(16K).
   parameters.codecs[0] = kPcmuCodec;
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
   for (uint32_t ssrc : kSsrcs4) {
-    int channel_num = GetSendStreamConfig(ssrc).voe_channel_id;
-    EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
-    EXPECT_STREQ("PCMU", gcodec.plname);
-    EXPECT_FALSE(voe_.GetVAD(channel_num));
+    ASSERT_TRUE(call_.GetAudioSendStream(ssrc) != nullptr);
+    auto send_codec_spec =
+        call_.GetAudioSendStream(ssrc)->GetConfig().send_codec_spec;
+    EXPECT_STREQ("PCMU", send_codec_spec.codec_inst.plname);
+    EXPECT_NE(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq);
+    EXPECT_EQ(97, send_codec_spec.cng_payload_type);
+    EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq);
   }
 }
 
 // Test we can SetSend on all send streams correctly.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendWithMultipleSendStreams) {
   SetupForMultiSendStream();
 
   // Create the send channels and they should be a "not sending" date.
   for (uint32_t ssrc : kSsrcs4) {
     EXPECT_TRUE(channel_->AddSendStream(
@@ skipping 1252 matching lines @@
   cricket::WebRtcVoiceEngine engine(
       nullptr, webrtc::CreateBuiltinAudioDecoderFactory());
   std::unique_ptr<webrtc::Call> call(
       webrtc::Call::Create(webrtc::Call::Config()));
   cricket::WebRtcVoiceMediaChannel channel(&engine, cricket::MediaConfig(),
                                            cricket::AudioOptions(), call.get());
   cricket::AudioRecvParameters parameters;
   parameters.codecs = engine.recv_codecs();
   EXPECT_TRUE(channel.SetRecvParameters(parameters));
 }