Moving WebRtcVoiceMediaChannel::SendSetCodec to AudioSendStream.

webrtc/media/engine/webrtcvoiceengine_unittest.cc

Index: webrtc/media/engine/webrtcvoiceengine_unittest.cc
diff --git a/webrtc/media/engine/webrtcvoiceengine_unittest.cc b/webrtc/media/engine/webrtcvoiceengine_unittest.cc
index 8be3b9d2497fa463d79915ee4bd37508e2d807b7..b64b2d8db06fd290cee4441c10e8ab02a1abe189 100644
--- a/webrtc/media/engine/webrtcvoiceengine_unittest.cc
+++ b/webrtc/media/engine/webrtcvoiceengine_unittest.cc
@@ -238,11 +238,7 @@ class WebRtcVoiceEngineTestFake : public testing::Test {
     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.
@@ -261,14 +257,47 @@ class WebRtcVoiceEngineTestFake : public testing::Test {
     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,
@@ -292,7 +321,7 @@ class WebRtcVoiceEngineTestFake : public testing::Test {
               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) {
@@ -846,10 +875,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthMultiRateAsCallee) {
   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.
@@ -860,20 +886,15 @@ TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthCbr) {
 
   // 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
@@ -966,16 +987,16 @@ TEST_F(WebRtcVoiceEngineTestFake, RtpParametersArePerStream) {
   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.
@@ -1054,17 +1075,18 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecs) {
   parameters.codecs.push_back(kCn8000Codec);
   parameters.codecs[0].id = 96;
   parameters.codecs[0].bitrate = 48000;
-  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));
+  const int initial_num = call_.GetNumCreatedSendStreams();
+  EXPECT_TRUE(channel_->SetSendParameters(parameters));
+  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());
 }
 
@@ -1078,23 +1100,24 @@ TEST_F(WebRtcVoiceEngineTestFake, DontResetSetSendCodec) {
   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);
@@ -1167,115 +1190,82 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad1Channel1Stereo) {
 // 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);
@@ -1287,50 +1277,35 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrateNoStereo) {
 // 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.
@@ -1338,28 +1313,22 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrate1Stereo) {
 // 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.
@@ -1467,97 +1436,78 @@ TEST_F(WebRtcVoiceEngineTestFake, AddRecvStreamEnableNack) {
 // 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) {
@@ -1585,214 +1535,169 @@ TEST_F(WebRtcVoiceEngineTestFake, TransportCcCanBeEnabledAndDisabled) {
 // 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);
 
@@ -1801,12 +1706,16 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsIsacOpusSwitching) {
   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);
 }
@@ -1814,40 +1723,48 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsIsacOpusSwitching) {
 // 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);
@@ -1855,7 +1772,9 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsBitrate) {
   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);
@@ -1864,36 +1783,29 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsBitrate) {
 // 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.
@@ -1907,7 +1819,6 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsNoCodecs) {
 // 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);
@@ -1915,8 +1826,9 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsDTMFOnTop) {
   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());
@@ -1947,7 +1859,6 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsDTMFPayloadTypeOutOfRange) {
 // 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);
@@ -1955,17 +1866,18 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNOnTop) {
   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);
@@ -1977,13 +1889,15 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCaller) {
   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());
 }
 
@@ -2003,15 +1917,16 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCallee) {
   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());
 }
 
@@ -2019,43 +1934,52 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCallee) {
 // 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);
@@ -2067,13 +1991,15 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCaseInsensitive) {
   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());
 }
 
@@ -2226,23 +2152,28 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsWithMultipleSendStreams) {
   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);
   }
 }