Full impl of NnChannel::SetSendParameters and NnChannel::SetRecvParameters

talk/media/webrtc/webrtcvoiceengine_unittest.cc

 /*
  * libjingle
  * Copyright 2008 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 110 matching lines @@
     uint32 ssrc_;
     cricket::VoiceMediaChannel::Error error_;
   };
 
   WebRtcVoiceEngineTestFake()
       : call_(webrtc::Call::Config()),
         voe_(kAudioCodecs, ARRAY_SIZE(kAudioCodecs)),
         trace_wrapper_(new FakeVoETraceWrapper()),
         engine_(new FakeVoEWrapper(&voe_), trace_wrapper_),
         channel_(nullptr) {
+    send_parameters_.codecs.push_back(kPcmuCodec);
+    recv_parameters_.codecs.push_back(kPcmuCodec);
     options_conference_.conference_mode.Set(true);
     options_adjust_agc_.adjust_agc_delta.Set(-10);
   }
   bool SetupEngineWithoutStream() {
     if (!engine_.Init(rtc::Thread::Current())) {
       return false;
     }
     channel_ = engine_.CreateChannel(&call_, cricket::AudioOptions());
     return (channel_ != nullptr);
   }
@@ skipping 31 matching lines @@
     EXPECT_TRUE(channel_ != nullptr);
     if (caller) {
       // if this is a caller, local description will be applied and add the
       // send stream.
       EXPECT_TRUE(channel_->AddSendStream(
           cricket::StreamParams::CreateLegacy(kSsrc1)));
     }
     int channel_id = voe_.GetLastChannel();
 
     // Test we can only InsertDtmf when the other side supports telephone-event.
-    std::vector<cricket::AudioCodec> codecs;
-    codecs.push_back(kPcmuCodec);
-    EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+    EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
     EXPECT_TRUE(channel_->SetSend(cricket::SEND_MICROPHONE));
     EXPECT_FALSE(channel_->CanInsertDtmf());
     EXPECT_FALSE(channel_->InsertDtmf(ssrc, 1, 111, cricket::DF_SEND));
-    codecs.push_back(kTelephoneEventCodec);
-    EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+    send_parameters_.codecs.push_back(kTelephoneEventCodec);
+    EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
     EXPECT_TRUE(channel_->CanInsertDtmf());
 
     if (!caller) {
       // There's no active send channel yet.
       EXPECT_FALSE(channel_->InsertDtmf(ssrc, 2, 123, cricket::DF_SEND));
       EXPECT_TRUE(channel_->AddSendStream(
           cricket::StreamParams::CreateLegacy(kSsrc1)));
     }
 
     // Check we fail if the ssrc is invalid.
@@ skipping 20 matching lines @@
 
   // Test that send bandwidth is set correctly.
   // |codec| is the codec under test.
   // |max_bitrate| is a parameter to set to SetMaxSendBandwidth().
   // |expected_result| is the expected result from SetMaxSendBandwidth().
   // |expected_bitrate| is the expected audio bitrate afterward.
   void TestSendBandwidth(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();
-    std::vector<cricket::AudioCodec> codecs;
-
-    codecs.push_back(codec);
-    EXPECT_TRUE(channel_->SetSendCodecs(codecs));
-
-    bool result = channel_->SetMaxSendBandwidth(max_bitrate);
-    EXPECT_EQ(expected_result, result);
-
     webrtc::CodecInst temp_codec;
     EXPECT_FALSE(voe_.GetSendCodec(channel_num, temp_codec));
-
     EXPECT_EQ(expected_bitrate, temp_codec.rate);
   }
 
   void TestSetSendRtpHeaderExtensions(const std::string& ext) {
     EXPECT_TRUE(SetupEngineWithoutStream());
     int channel_num = voe_.GetLastChannel();
 
     // Ensure extensions are off by default.
     EXPECT_EQ(-1, voe_.GetSendRtpExtensionId(channel_num, ext));
 
-    std::vector<cricket::RtpHeaderExtension> extensions;
     // Ensure unknown extensions won't cause an error.
-    extensions.push_back(cricket::RtpHeaderExtension(
+    send_parameters_.extensions.push_back(cricket::RtpHeaderExtension(
         "urn:ietf:params:unknownextention", 1));
-    EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions));
+    EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
     EXPECT_EQ(-1, voe_.GetSendRtpExtensionId(channel_num, ext));
 
     // Ensure extensions stay off with an empty list of headers.
-    extensions.clear();
-    EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions));
+    send_parameters_.extensions.clear();
+    EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
     EXPECT_EQ(-1, voe_.GetSendRtpExtensionId(channel_num, ext));
 
     // Ensure extension is set properly.
     const int id = 1;
-    extensions.push_back(cricket::RtpHeaderExtension(ext, id));
-    EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions));
+    send_parameters_.extensions.push_back(cricket::RtpHeaderExtension(ext, id));
+    EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
     EXPECT_EQ(id, voe_.GetSendRtpExtensionId(channel_num, ext));
 
     // Ensure extension is set properly on new channel.
     // The first stream to occupy the default channel.
     EXPECT_TRUE(channel_->AddSendStream(
         cricket::StreamParams::CreateLegacy(123)));
     EXPECT_TRUE(channel_->AddSendStream(
         cricket::StreamParams::CreateLegacy(234)));
     int new_channel_num = voe_.GetLastChannel();
     EXPECT_NE(channel_num, new_channel_num);
     EXPECT_EQ(id, voe_.GetSendRtpExtensionId(new_channel_num, ext));
 
     // Ensure all extensions go back off with an empty list.
-    extensions.clear();
-    EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions));
+    send_parameters_.codecs.push_back(kPcmuCodec);
+    send_parameters_.extensions.clear();
+    EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
     EXPECT_EQ(-1, voe_.GetSendRtpExtensionId(channel_num, ext));
     EXPECT_EQ(-1, voe_.GetSendRtpExtensionId(new_channel_num, ext));
   }
 
   void TestSetRecvRtpHeaderExtensions(const std::string& ext) {
     EXPECT_TRUE(SetupEngineWithoutStream());
     int channel_num = voe_.GetLastChannel();
 
     // Ensure extensions are off by default.
     EXPECT_EQ(-1, voe_.GetReceiveRtpExtensionId(channel_num, ext));
 
-    std::vector<cricket::RtpHeaderExtension> extensions;
+    cricket::AudioRecvParameters parameters;
     // Ensure unknown extensions won't cause an error.
-    extensions.push_back(cricket::RtpHeaderExtension(
+    parameters.extensions.push_back(cricket::RtpHeaderExtension(
         "urn:ietf:params:unknownextention", 1));
-    EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions));
+    EXPECT_TRUE(channel_->SetRecvParameters(parameters));
     EXPECT_EQ(-1, voe_.GetReceiveRtpExtensionId(channel_num, ext));
 
     // Ensure extensions stay off with an empty list of headers.
-    extensions.clear();
-    EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions));
+    parameters.extensions.clear();
+    EXPECT_TRUE(channel_->SetRecvParameters(parameters));
     EXPECT_EQ(-1, voe_.GetReceiveRtpExtensionId(channel_num, ext));
 
     // Ensure extension is set properly.
     const int id = 2;
-    extensions.push_back(cricket::RtpHeaderExtension(ext, id));
-    EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions));
+    parameters.extensions.push_back(cricket::RtpHeaderExtension(ext, id));
+    EXPECT_TRUE(channel_->SetRecvParameters(parameters));
     EXPECT_EQ(id, voe_.GetReceiveRtpExtensionId(channel_num, ext));
 
     // Ensure extension is set properly on new channel.
     // The first stream to occupy the default channel.
     EXPECT_TRUE(channel_->AddRecvStream(
         cricket::StreamParams::CreateLegacy(345)));
     EXPECT_TRUE(channel_->AddRecvStream(
         cricket::StreamParams::CreateLegacy(456)));
     int new_channel_num = voe_.GetLastChannel();
     EXPECT_NE(channel_num, new_channel_num);
     EXPECT_EQ(id, voe_.GetReceiveRtpExtensionId(new_channel_num, ext));
 
     // Ensure all extensions go back off with an empty list.
-    extensions.clear();
-    EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions));
+    parameters.extensions.clear();
+    EXPECT_TRUE(channel_->SetRecvParameters(parameters));
     EXPECT_EQ(-1, voe_.GetReceiveRtpExtensionId(channel_num, ext));
     EXPECT_EQ(-1, voe_.GetReceiveRtpExtensionId(new_channel_num, ext));
   }
 
  protected:
   cricket::FakeCall call_;
   cricket::FakeWebRtcVoiceEngine voe_;
   FakeVoETraceWrapper* trace_wrapper_;
   cricket::WebRtcVoiceEngine engine_;
   cricket::VoiceMediaChannel* channel_;
 
+  cricket::AudioSendParameters send_parameters_;
+  cricket::AudioRecvParameters recv_parameters_;
   cricket::AudioOptions options_conference_;
   cricket::AudioOptions options_adjust_agc_;
 };
 
 // Tests that our stub library "works".
 TEST_F(WebRtcVoiceEngineTestFake, StartupShutdown) {
   EXPECT_FALSE(voe_.IsInited());
   EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
   EXPECT_TRUE(voe_.IsInited());
   engine_.Terminate();
@@ skipping 64 matching lines @@
   codec.bitrate = 32000;
   EXPECT_TRUE(engine_.FindWebRtcCodec(codec, &codec_inst));
   EXPECT_EQ(codec.id, codec_inst.pltype);
   EXPECT_EQ(32000, codec_inst.rate);
 }
 
 // Test that we set our inbound codecs properly, including changing PT.
 TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecs) {
   EXPECT_TRUE(SetupEngine());
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kIsacCodec);
-  codecs.push_back(kPcmuCodec);
-  codecs.push_back(kTelephoneEventCodec);
-  codecs[0].id = 106;  // collide with existing telephone-event
-  codecs[2].id = 126;
-  EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
+  cricket::AudioRecvParameters parameters;
+  parameters.codecs.push_back(kIsacCodec);
+  parameters.codecs.push_back(kPcmuCodec);
+  parameters.codecs.push_back(kTelephoneEventCodec);
+  parameters.codecs[0].id = 106;  // collide with existing telephone-event
+  parameters.codecs[2].id = 126;
+  EXPECT_TRUE(channel_->SetRecvParameters(parameters));
   webrtc::CodecInst gcodec;
   rtc::strcpyn(gcodec.plname, ARRAY_SIZE(gcodec.plname), "ISAC");
   gcodec.plfreq = 16000;
   gcodec.channels = 1;
   EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num, gcodec));
   EXPECT_EQ(106, gcodec.pltype);
   EXPECT_STREQ("ISAC", gcodec.plname);
   rtc::strcpyn(gcodec.plname, ARRAY_SIZE(gcodec.plname),
       "telephone-event");
   gcodec.plfreq = 8000;
   EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num, gcodec));
   EXPECT_EQ(126, gcodec.pltype);
   EXPECT_STREQ("telephone-event", gcodec.plname);
 }
 
 // Test that we fail to set an unknown inbound codec.
 TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsUnsupportedCodec) {
   EXPECT_TRUE(SetupEngine());
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kIsacCodec);
-  codecs.push_back(cricket::AudioCodec(127, "XYZ", 32000, 0, 1, 0));
-  EXPECT_FALSE(channel_->SetRecvCodecs(codecs));
+  cricket::AudioRecvParameters parameters;
+  parameters.codecs.push_back(kIsacCodec);
+  parameters.codecs.push_back(cricket::AudioCodec(127, "XYZ", 32000, 0, 1, 0));
+  EXPECT_FALSE(channel_->SetRecvParameters(parameters));
 }
 
 // Test that we fail if we have duplicate types in the inbound list.
 TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsDuplicatePayloadType) {
   EXPECT_TRUE(SetupEngine());
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kIsacCodec);
-  codecs.push_back(kCn16000Codec);
-  codecs[1].id = kIsacCodec.id;
-  EXPECT_FALSE(channel_->SetRecvCodecs(codecs));
+  cricket::AudioRecvParameters parameters;
+  parameters.codecs.push_back(kIsacCodec);
+  parameters.codecs.push_back(kCn16000Codec);
+  parameters.codecs[1].id = kIsacCodec.id;
+  EXPECT_FALSE(channel_->SetRecvParameters(parameters));
 }
 
 // Test that we can decode OPUS without stereo parameters.
 TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsWithOpusNoStereo) {
   EXPECT_TRUE(SetupEngine());
-  EXPECT_TRUE(channel_->SetOptions(options_conference_));
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kIsacCodec);
-  codecs.push_back(kPcmuCodec);
-  codecs.push_back(kOpusCodec);
-  EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
+  cricket::AudioRecvParameters parameters;
+  parameters.codecs.push_back(kIsacCodec);
+  parameters.codecs.push_back(kPcmuCodec);
+  parameters.codecs.push_back(kOpusCodec);
+  EXPECT_TRUE(channel_->SetRecvParameters(parameters));
   EXPECT_TRUE(channel_->AddRecvStream(
       cricket::StreamParams::CreateLegacy(kSsrc1)));
   int channel_num2 = voe_.GetLastChannel();
   webrtc::CodecInst opus;
   engine_.FindWebRtcCodec(kOpusCodec, &opus);
   // Even without stereo parameters, recv codecs still specify channels = 2.
   EXPECT_EQ(2, opus.channels);
   EXPECT_EQ(111, opus.pltype);
   EXPECT_STREQ("opus", opus.plname);
   opus.pltype = 0;
   EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num2, opus));
   EXPECT_EQ(111, opus.pltype);
 }
 
 // Test that we can decode OPUS with stereo = 0.
 TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsWithOpus0Stereo) {
   EXPECT_TRUE(SetupEngine());
-  EXPECT_TRUE(channel_->SetOptions(options_conference_));
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kIsacCodec);
-  codecs.push_back(kPcmuCodec);
-  codecs.push_back(kOpusCodec);
-  codecs[2].params["stereo"] = "0";
-  EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
+  cricket::AudioRecvParameters parameters;
+  parameters.codecs.push_back(kIsacCodec);
+  parameters.codecs.push_back(kPcmuCodec);
+  parameters.codecs.push_back(kOpusCodec);
+  parameters.codecs[2].params["stereo"] = "0";
+  EXPECT_TRUE(channel_->SetRecvParameters(parameters));
   EXPECT_TRUE(channel_->AddRecvStream(
       cricket::StreamParams::CreateLegacy(kSsrc1)));
   int channel_num2 = voe_.GetLastChannel();
   webrtc::CodecInst opus;
   engine_.FindWebRtcCodec(kOpusCodec, &opus);
   // Even when stereo is off, recv codecs still specify channels = 2.
   EXPECT_EQ(2, opus.channels);
   EXPECT_EQ(111, opus.pltype);
   EXPECT_STREQ("opus", opus.plname);
   opus.pltype = 0;
   EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num2, opus));
   EXPECT_EQ(111, opus.pltype);
 }
 
 // Test that we can decode OPUS with stereo = 1.
 TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsWithOpus1Stereo) {
   EXPECT_TRUE(SetupEngine());
-  EXPECT_TRUE(channel_->SetOptions(options_conference_));
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kIsacCodec);
-  codecs.push_back(kPcmuCodec);
-  codecs.push_back(kOpusCodec);
-  codecs[2].params["stereo"] = "1";
-  EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
+  cricket::AudioRecvParameters parameters;
+  parameters.codecs.push_back(kIsacCodec);
+  parameters.codecs.push_back(kPcmuCodec);
+  parameters.codecs.push_back(kOpusCodec);
+  parameters.codecs[2].params["stereo"] = "1";
+  EXPECT_TRUE(channel_->SetRecvParameters(parameters));
   EXPECT_TRUE(channel_->AddRecvStream(
       cricket::StreamParams::CreateLegacy(kSsrc1)));
   int channel_num2 = voe_.GetLastChannel();
   webrtc::CodecInst opus;
   engine_.FindWebRtcCodec(kOpusCodec, &opus);
   EXPECT_EQ(2, opus.channels);
   EXPECT_EQ(111, opus.pltype);
   EXPECT_STREQ("opus", opus.plname);
   opus.pltype = 0;
   EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num2, opus));
   EXPECT_EQ(111, opus.pltype);
 }
 
 // Test that changes to recv codecs are applied to all streams.
 TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsWithMultipleStreams) {
   EXPECT_TRUE(SetupEngine());
-  EXPECT_TRUE(channel_->SetOptions(options_conference_));
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kIsacCodec);
-  codecs.push_back(kPcmuCodec);
-  codecs.push_back(kTelephoneEventCodec);
-  codecs[0].id = 106;  // collide with existing telephone-event
-  codecs[2].id = 126;
-  EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
+  cricket::AudioRecvParameters parameters;
+  parameters.codecs.push_back(kIsacCodec);
+  parameters.codecs.push_back(kPcmuCodec);
+  parameters.codecs.push_back(kTelephoneEventCodec);
+  parameters.codecs[0].id = 106;  // collide with existing telephone-event
+  parameters.codecs[2].id = 126;
+  EXPECT_TRUE(channel_->SetRecvParameters(parameters));
   EXPECT_TRUE(channel_->AddRecvStream(
       cricket::StreamParams::CreateLegacy(kSsrc1)));
   int channel_num2 = voe_.GetLastChannel();
   webrtc::CodecInst gcodec;
   rtc::strcpyn(gcodec.plname, ARRAY_SIZE(gcodec.plname), "ISAC");
   gcodec.plfreq = 16000;
   gcodec.channels = 1;
   EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num2, gcodec));
   EXPECT_EQ(106, gcodec.pltype);
   EXPECT_STREQ("ISAC", gcodec.plname);
   rtc::strcpyn(gcodec.plname, ARRAY_SIZE(gcodec.plname),
       "telephone-event");
   gcodec.plfreq = 8000;
   gcodec.channels = 1;
   EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num2, gcodec));
   EXPECT_EQ(126, gcodec.pltype);
   EXPECT_STREQ("telephone-event", gcodec.plname);
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsAfterAddingStreams) {
   EXPECT_TRUE(SetupEngine());
-  EXPECT_TRUE(channel_->SetOptions(options_conference_));
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kIsacCodec);
-  codecs[0].id = 106;  // collide with existing telephone-event
-
+  cricket::AudioRecvParameters parameters;
+  parameters.codecs.push_back(kIsacCodec);
+  parameters.codecs[0].id = 106;  // collide with existing telephone-event
   EXPECT_TRUE(channel_->AddRecvStream(
       cricket::StreamParams::CreateLegacy(kSsrc1)));
-  EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
+  EXPECT_TRUE(channel_->SetRecvParameters(parameters));
 
   int channel_num2 = voe_.GetLastChannel();
   webrtc::CodecInst gcodec;
   rtc::strcpyn(gcodec.plname, ARRAY_SIZE(gcodec.plname), "ISAC");
   gcodec.plfreq = 16000;
   gcodec.channels = 1;
   EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num2, gcodec));
   EXPECT_EQ(106, gcodec.pltype);
   EXPECT_STREQ("ISAC", gcodec.plname);
 }
 
 // Test that we can apply the same set of codecs again while playing.
 TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsWhilePlaying) {
   EXPECT_TRUE(SetupEngine());
-  int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kIsacCodec);
-  codecs.push_back(kCn16000Codec);
-  EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
+  cricket::AudioRecvParameters parameters;
+  parameters.codecs.push_back(kIsacCodec);
+  parameters.codecs.push_back(kCn16000Codec);
+  EXPECT_TRUE(channel_->SetRecvParameters(parameters));
   EXPECT_TRUE(channel_->SetPlayout(true));
-  EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
+  EXPECT_TRUE(channel_->SetRecvParameters(parameters));
 
   // Changing the payload type of a codec should fail.
-  codecs[0].id = 127;
-  EXPECT_FALSE(channel_->SetRecvCodecs(codecs));
+  parameters.codecs[0].id = 127;
+  EXPECT_FALSE(channel_->SetRecvParameters(parameters));
+  int channel_num = voe_.GetLastChannel();
   EXPECT_TRUE(voe_.GetPlayout(channel_num));
 }
 
 // Test that we can add a codec while playing.
 TEST_F(WebRtcVoiceEngineTestFake, AddRecvCodecsWhilePlaying) {
   EXPECT_TRUE(SetupEngine());
-  int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kIsacCodec);
-  codecs.push_back(kCn16000Codec);
-  EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
+  cricket::AudioRecvParameters parameters;
+  parameters.codecs.push_back(kIsacCodec);
+  parameters.codecs.push_back(kCn16000Codec);
+  EXPECT_TRUE(channel_->SetRecvParameters(parameters));
   EXPECT_TRUE(channel_->SetPlayout(true));
 
-  codecs.push_back(kOpusCodec);
-  EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
+  parameters.codecs.push_back(kOpusCodec);
+  EXPECT_TRUE(channel_->SetRecvParameters(parameters));
+  int channel_num = voe_.GetLastChannel();
   EXPECT_TRUE(voe_.GetPlayout(channel_num));
   webrtc::CodecInst gcodec;
   EXPECT_TRUE(engine_.FindWebRtcCodec(kOpusCodec, &gcodec));
   EXPECT_EQ(kOpusCodec.id, gcodec.pltype);
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, SetSendBandwidthAuto) {
   EXPECT_TRUE(SetupEngine());
-  EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
 
   // Test that when autobw is enabled, bitrate is kept as the default
   // value. autobw is enabled for the following tests because the target
   // bitrate is <= 0.
 
   // ISAC, default bitrate == 32000.
   TestSendBandwidth(kIsacCodec, 0, true, 32000);
 
   // PCMU, default bitrate == 64000.
   TestSendBandwidth(kPcmuCodec, -1, true, 64000);
 
   // opus, default bitrate == 64000.
   TestSendBandwidth(kOpusCodec, -1, true, 64000);
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthMultiRateAsCaller) {
   EXPECT_TRUE(SetupEngine());
-  EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
 
   // Test that the bitrate of a multi-rate codec is always the maximum.
 
   // ISAC, default bitrate == 32000.
   TestSendBandwidth(kIsacCodec, 128000, true, 128000);
   TestSendBandwidth(kIsacCodec, 16000, true, 16000);
 
   // opus, default bitrate == 64000.
   TestSendBandwidth(kOpusCodec, 96000, true, 96000);
   TestSendBandwidth(kOpusCodec, 48000, true, 48000);
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthFixedRateAsCaller) {
   EXPECT_TRUE(SetupEngine());
-  EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
 
   // Test that we can only set a maximum bitrate for a fixed-rate codec
   // if it's bigger than the fixed rate.
 
   // PCMU, fixed bitrate == 64000.
   TestSendBandwidth(kPcmuCodec, 0, true, 64000);
   TestSendBandwidth(kPcmuCodec, 1, false, 64000);
   TestSendBandwidth(kPcmuCodec, 128000, true, 64000);
   TestSendBandwidth(kPcmuCodec, 32000, false, 64000);
   TestSendBandwidth(kPcmuCodec, 64000, true, 64000);
   TestSendBandwidth(kPcmuCodec, 63999, false, 64000);
   TestSendBandwidth(kPcmuCodec, 64001, true, 64000);
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthMultiRateAsCallee) {
-  EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
-  channel_ = engine_.CreateChannel(&call_, cricket::AudioOptions());
-  EXPECT_TRUE(channel_ != nullptr);
-  EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
-
-  int desired_bitrate = 128000;
-  EXPECT_TRUE(channel_->SetMaxSendBandwidth(desired_bitrate));
+  EXPECT_TRUE(SetupEngineWithoutStream());
+  const int kDesiredBitrate = 128000;
+  cricket::AudioSendParameters parameters;
+  parameters.codecs = engine_.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(desired_bitrate, codec.rate);
+  EXPECT_EQ(kDesiredBitrate, codec.rate);
 }
 
 // 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(SetupEngine());
-  EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
-
-  webrtc::CodecInst codec;
-  int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
 
   // PCMU, default bitrate == 64000.
-  codecs.push_back(kPcmuCodec);
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  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);
-  EXPECT_TRUE(channel_->SetMaxSendBandwidth(128000));
+
+  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);
-  EXPECT_FALSE(channel_->SetMaxSendBandwidth(128));
+
+  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);
 }
 
 // Test that we apply codecs properly.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecs) {
   EXPECT_TRUE(SetupEngine());
+  cricket::AudioSendParameters parameters;
+  parameters.codecs.push_back(kIsacCodec);
+  parameters.codecs.push_back(kPcmuCodec);
+  parameters.codecs.push_back(kRedCodec);
+  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();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kIsacCodec);
-  codecs.push_back(kPcmuCodec);
-  codecs.push_back(kRedCodec);
-  codecs[0].id = 96;
-  codecs[0].bitrate = 48000;
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
-  EXPECT_EQ(1, voe_.GetNumSetSendCodecs());
   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_FALSE(voe_.GetRED(channel_num));
   EXPECT_EQ(13, voe_.GetSendCNPayloadType(channel_num, false));
   EXPECT_EQ(105, voe_.GetSendCNPayloadType(channel_num, true));
   EXPECT_EQ(106, voe_.GetSendTelephoneEventPayloadType(channel_num));
 }
 
 // Test that VoE Channel doesn't call SetSendCodec again if same codec is tried
 // to apply.
 TEST_F(WebRtcVoiceEngineTestFake, DontResetSetSendCodec) {
   EXPECT_TRUE(SetupEngine());
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kIsacCodec);
-  codecs.push_back(kPcmuCodec);
-  codecs.push_back(kRedCodec);
-  codecs[0].id = 96;
-  codecs[0].bitrate = 48000;
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  cricket::AudioSendParameters parameters;
+  parameters.codecs.push_back(kIsacCodec);
+  parameters.codecs.push_back(kPcmuCodec);
+  parameters.codecs.push_back(kRedCodec);
+  parameters.codecs[0].id = 96;
+  parameters.codecs[0].bitrate = 48000;
+  EXPECT_TRUE(channel_->SetSendParameters(parameters));
   EXPECT_EQ(1, voe_.GetNumSetSendCodecs());
   // Calling SetSendCodec again with same codec which is already set.
   // In this case media channel shouldn't send codec to VoE.
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  EXPECT_TRUE(channel_->SetSendParameters(parameters));
   EXPECT_EQ(1, voe_.GetNumSetSendCodecs());
 }
 
 // Verify that G722 is set with 16000 samples per second to WebRTC.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecG722) {
   EXPECT_TRUE(SetupEngine());
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kG722CodecSdp);
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  cricket::AudioSendParameters parameters;
+  parameters.codecs.push_back(kG722CodecSdp);
+  EXPECT_TRUE(channel_->SetSendParameters(parameters));
   webrtc::CodecInst gcodec;
   EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
   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(SetupEngine());
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kOpusCodec);
-  codecs[0].bitrate = 0;
-  codecs[0].clockrate = 50000;
-  EXPECT_FALSE(channel_->SetSendCodecs(codecs));
+  cricket::AudioSendParameters parameters;
+  parameters.codecs.push_back(kOpusCodec);
+  parameters.codecs[0].bitrate = 0;
+  parameters.codecs[0].clockrate = 50000;
+  EXPECT_FALSE(channel_->SetSendParameters(parameters));
 }
 
 // Test that if channels=0 for opus, we fail.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad0ChannelsNoStereo) {
   EXPECT_TRUE(SetupEngine());
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kOpusCodec);
-  codecs[0].bitrate = 0;
-  codecs[0].channels = 0;
-  EXPECT_FALSE(channel_->SetSendCodecs(codecs));
+  cricket::AudioSendParameters parameters;
+  parameters.codecs.push_back(kOpusCodec);
+  parameters.codecs[0].bitrate = 0;
+  parameters.codecs[0].channels = 0;
+  EXPECT_FALSE(channel_->SetSendParameters(parameters));
 }
 
 // Test that if channels=0 for opus, we fail.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad0Channels1Stereo) {
   EXPECT_TRUE(SetupEngine());
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kOpusCodec);
-  codecs[0].bitrate = 0;
-  codecs[0].channels = 0;
-  codecs[0].params["stereo"] = "1";
-  EXPECT_FALSE(channel_->SetSendCodecs(codecs));
+  cricket::AudioSendParameters parameters;
+  parameters.codecs.push_back(kOpusCodec);
+  parameters.codecs[0].bitrate = 0;
+  parameters.codecs[0].channels = 0;
+  parameters.codecs[0].params["stereo"] = "1";
+  EXPECT_FALSE(channel_->SetSendParameters(parameters));
 }
 
 // Test that if channel is 1 for opus and there's no stereo, we fail.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpus1ChannelNoStereo) {
   EXPECT_TRUE(SetupEngine());
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kOpusCodec);
-  codecs[0].bitrate = 0;
-  codecs[0].channels = 1;
-  EXPECT_FALSE(channel_->SetSendCodecs(codecs));
+  cricket::AudioSendParameters parameters;
+  parameters.codecs.push_back(kOpusCodec);
+  parameters.codecs[0].bitrate = 0;
+  parameters.codecs[0].channels = 1;
+  EXPECT_FALSE(channel_->SetSendParameters(parameters));
 }
 
 // Test that if channel is 1 for opus and stereo=0, we fail.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad1Channel0Stereo) {
   EXPECT_TRUE(SetupEngine());
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kOpusCodec);
-  codecs[0].bitrate = 0;
-  codecs[0].channels = 1;
-  codecs[0].params["stereo"] = "0";
-  EXPECT_FALSE(channel_->SetSendCodecs(codecs));
+  cricket::AudioSendParameters parameters;
+  parameters.codecs.push_back(kOpusCodec);
+  parameters.codecs[0].bitrate = 0;
+  parameters.codecs[0].channels = 1;
+  parameters.codecs[0].params["stereo"] = "0";
+  EXPECT_FALSE(channel_->SetSendParameters(parameters));
 }
 
 // Test that if channel is 1 for opus and stereo=1, we fail.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad1Channel1Stereo) {
   EXPECT_TRUE(SetupEngine());
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kOpusCodec);
-  codecs[0].bitrate = 0;
-  codecs[0].channels = 1;
-  codecs[0].params["stereo"] = "1";
-  EXPECT_FALSE(channel_->SetSendCodecs(codecs));
+  cricket::AudioSendParameters parameters;
+  parameters.codecs.push_back(kOpusCodec);
+  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(SetupEngine());
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kOpusCodec);
-  codecs[0].bitrate = 0;
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  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);
 }
 
 // Test that with bitrate=0 and stereo=0,
 // channels and bitrate are 1 and 32000.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0Bitrate0Stereo) {
   EXPECT_TRUE(SetupEngine());
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kOpusCodec);
-  codecs[0].bitrate = 0;
-  codecs[0].params["stereo"] = "0";
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  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);
 }
 
 // Test that with bitrate=invalid and stereo=0,
 // channels and bitrate are 1 and 32000.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodXBitrate0Stereo) {
   EXPECT_TRUE(SetupEngine());
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kOpusCodec);
-  codecs[0].params["stereo"] = "0";
+  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.
-  codecs[0].bitrate = 5999;
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  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);
 
-  codecs[0].bitrate = 510001;
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  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);
 }
 
 // Test that with bitrate=0 and stereo=1,
 // channels and bitrate are 2 and 64000.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0Bitrate1Stereo) {
   EXPECT_TRUE(SetupEngine());
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kOpusCodec);
-  codecs[0].bitrate = 0;
-  codecs[0].params["stereo"] = "1";
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  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);
 }
 
 // Test that with bitrate=invalid and stereo=1,
 // channels and bitrate are 2 and 64000.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodXBitrate1Stereo) {
   EXPECT_TRUE(SetupEngine());
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kOpusCodec);
-  codecs[0].params["stereo"] = "1";
+  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.
-  codecs[0].bitrate = 5999;
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  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);
 
-  codecs[0].bitrate = 510001;
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  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);
 }
 
 // Test that with bitrate=N and stereo unset,
 // channels and bitrate are 1 and N.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrateNoStereo) {
   EXPECT_TRUE(SetupEngine());
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kOpusCodec);
-  codecs[0].bitrate = 96000;
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  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));
   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(SetupEngine());
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kOpusCodec);
-  codecs[0].bitrate = 30000;
-  codecs[0].params["stereo"] = "0";
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  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);
 }
 
 // Test that with bitrate=N and without any parameters,
 // channels and bitrate are 1 and N.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrateNoParameters) {
   EXPECT_TRUE(SetupEngine());
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kOpusCodec);
-  codecs[0].bitrate = 30000;
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  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);
 }
 
 // Test that with bitrate=N and stereo=1,
 // channels and bitrate are 2 and N.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrate1Stereo) {
   EXPECT_TRUE(SetupEngine());
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kOpusCodec);
-  codecs[0].bitrate = 30000;
-  codecs[0].params["stereo"] = "1";
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  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);
 }
 
 // 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(SetupEngine());
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kOpusCodec);
-  codecs[0].bitrate = 30000;
+  cricket::AudioSendParameters parameters;
+  parameters.codecs.push_back(kOpusCodec);
+  parameters.codecs[0].bitrate = 30000;
   webrtc::CodecInst gcodec;
 
   // Ignore if less than 6000.
-  codecs[0].params["maxaveragebitrate"] = "5999";
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  parameters.codecs[0].params["maxaveragebitrate"] = "5999";
+  EXPECT_TRUE(channel_->SetSendParameters(parameters));
   EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
   EXPECT_EQ(6000, gcodec.rate);
 
   // Ignore if larger than 510000.
-  codecs[0].params["maxaveragebitrate"] = "510001";
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  parameters.codecs[0].params["maxaveragebitrate"] = "510001";
+  EXPECT_TRUE(channel_->SetSendParameters(parameters));
   EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
   EXPECT_EQ(510000, gcodec.rate);
 
-  codecs[0].params["maxaveragebitrate"] = "200000";
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  parameters.codecs[0].params["maxaveragebitrate"] = "200000";
+  EXPECT_TRUE(channel_->SetSendParameters(parameters));
   EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
   EXPECT_EQ(200000, gcodec.rate);
 }
 
 // Test that we can enable NACK with opus as caller.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecEnableNackAsCaller) {
   EXPECT_TRUE(SetupEngine());
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kOpusCodec);
-  codecs[0].AddFeedbackParam(cricket::FeedbackParam(cricket::kRtcpFbParamNack,
-                                                    cricket::kParamValueEmpty));
+  cricket::AudioSendParameters parameters;
+  parameters.codecs.push_back(kOpusCodec);
+  parameters.codecs[0].AddFeedbackParam(
+      cricket::FeedbackParam(cricket::kRtcpFbParamNack,
+                             cricket::kParamValueEmpty));
   EXPECT_FALSE(voe_.GetNACK(channel_num));
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  EXPECT_TRUE(channel_->SetSendParameters(parameters));
   EXPECT_TRUE(voe_.GetNACK(channel_num));
 }
 
 // Test that we can enable NACK with opus as callee.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecEnableNackAsCallee) {
-  EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
-  channel_ = engine_.CreateChannel(&call_, cricket::AudioOptions());
-  EXPECT_TRUE(channel_ != nullptr);
-
+  EXPECT_TRUE(SetupEngineWithoutStream());
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kOpusCodec);
-  codecs[0].AddFeedbackParam(cricket::FeedbackParam(cricket::kRtcpFbParamNack,
-                                                    cricket::kParamValueEmpty));
+  cricket::AudioSendParameters parameters;
+  parameters.codecs.push_back(kOpusCodec);
+  parameters.codecs[0].AddFeedbackParam(
+      cricket::FeedbackParam(cricket::kRtcpFbParamNack,
+                             cricket::kParamValueEmpty));
   EXPECT_FALSE(voe_.GetNACK(channel_num));
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  EXPECT_TRUE(channel_->SetSendParameters(parameters));
   EXPECT_FALSE(voe_.GetNACK(channel_num));
 
   EXPECT_TRUE(channel_->AddSendStream(
       cricket::StreamParams::CreateLegacy(kSsrc1)));
   EXPECT_TRUE(voe_.GetNACK(channel_num));
 }
 
 // Test that we can enable NACK on receive streams.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecEnableNackRecvStreams) {
   EXPECT_TRUE(SetupEngine());
-  EXPECT_TRUE(channel_->SetOptions(options_conference_));
   int channel_num1 = voe_.GetLastChannel();
   EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
   int channel_num2 = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kOpusCodec);
-  codecs[0].AddFeedbackParam(cricket::FeedbackParam(cricket::kRtcpFbParamNack,
-                                                    cricket::kParamValueEmpty));
+  cricket::AudioSendParameters parameters;
+  parameters.codecs.push_back(kOpusCodec);
+  parameters.codecs[0].AddFeedbackParam(
+      cricket::FeedbackParam(cricket::kRtcpFbParamNack,
+                             cricket::kParamValueEmpty));
   EXPECT_FALSE(voe_.GetNACK(channel_num1));
   EXPECT_FALSE(voe_.GetNACK(channel_num2));
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  EXPECT_TRUE(channel_->SetSendParameters(parameters));
   EXPECT_TRUE(voe_.GetNACK(channel_num1));
   EXPECT_TRUE(voe_.GetNACK(channel_num2));
 }
 
 // Test that we can disable NACK.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecDisableNack) {
   EXPECT_TRUE(SetupEngine());
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kOpusCodec);
-  codecs[0].AddFeedbackParam(cricket::FeedbackParam(cricket::kRtcpFbParamNack,
-                                                    cricket::kParamValueEmpty));
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  cricket::AudioSendParameters parameters;
+  parameters.codecs.push_back(kOpusCodec);
+  parameters.codecs[0].AddFeedbackParam(
+      cricket::FeedbackParam(cricket::kRtcpFbParamNack,
+                             cricket::kParamValueEmpty));
+  EXPECT_TRUE(channel_->SetSendParameters(parameters));
   EXPECT_TRUE(voe_.GetNACK(channel_num));
 
-  codecs.clear();
-  codecs.push_back(kOpusCodec);
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  parameters.codecs.clear();
+  parameters.codecs.push_back(kOpusCodec);
+  EXPECT_TRUE(channel_->SetSendParameters(parameters));
   EXPECT_FALSE(voe_.GetNACK(channel_num));
 }
 
 // Test that we can disable NACK on receive streams.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecDisableNackRecvStreams) {
   EXPECT_TRUE(SetupEngine());
-  EXPECT_TRUE(channel_->SetOptions(options_conference_));
   int channel_num1 = voe_.GetLastChannel();
   EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
   int channel_num2 = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kOpusCodec);
-  codecs[0].AddFeedbackParam(cricket::FeedbackParam(cricket::kRtcpFbParamNack,
-                                                    cricket::kParamValueEmpty));
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  cricket::AudioSendParameters parameters;
+  parameters.codecs.push_back(kOpusCodec);
+  parameters.codecs[0].AddFeedbackParam(
+      cricket::FeedbackParam(cricket::kRtcpFbParamNack,
+                             cricket::kParamValueEmpty));
+  EXPECT_TRUE(channel_->SetSendParameters(parameters));
   EXPECT_TRUE(voe_.GetNACK(channel_num1));
   EXPECT_TRUE(voe_.GetNACK(channel_num2));
 
-  codecs.clear();
-  codecs.push_back(kOpusCodec);
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  parameters.codecs.clear();
+  parameters.codecs.push_back(kOpusCodec);
+  EXPECT_TRUE(channel_->SetSendParameters(parameters));
   EXPECT_FALSE(voe_.GetNACK(channel_num1));
   EXPECT_FALSE(voe_.GetNACK(channel_num2));
 }
 
 // Test that NACK is enabled on a new receive stream.
 TEST_F(WebRtcVoiceEngineTestFake, AddRecvStreamEnableNack) {
   EXPECT_TRUE(SetupEngine());
-  EXPECT_TRUE(channel_->SetOptions(options_conference_));
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kIsacCodec);
-  codecs[0].AddFeedbackParam(cricket::FeedbackParam(cricket::kRtcpFbParamNack,
-                                                    cricket::kParamValueEmpty));
-  codecs.push_back(kCn16000Codec);
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  cricket::AudioSendParameters parameters;
+  parameters.codecs.push_back(kIsacCodec);
+  parameters.codecs.push_back(kCn16000Codec);
+  parameters.codecs[0].AddFeedbackParam(
+      cricket::FeedbackParam(cricket::kRtcpFbParamNack,
+                             cricket::kParamValueEmpty));
+  EXPECT_TRUE(channel_->SetSendParameters(parameters));
   EXPECT_TRUE(voe_.GetNACK(channel_num));
 
   EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
   channel_num = voe_.GetLastChannel();
   EXPECT_TRUE(voe_.GetNACK(channel_num));
   EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(3)));
   channel_num = voe_.GetLastChannel();
   EXPECT_TRUE(voe_.GetNACK(channel_num));
 }
 
 // Test that without useinbandfec, Opus FEC is off.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecNoOpusFec) {
   EXPECT_TRUE(SetupEngine());
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kOpusCodec);
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  cricket::AudioSendParameters parameters;
+  parameters.codecs.push_back(kOpusCodec);
+  EXPECT_TRUE(channel_->SetSendParameters(parameters));
   EXPECT_FALSE(voe_.GetCodecFEC(channel_num));
 }
 
 // Test that with useinbandfec=0, Opus FEC is off.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusDisableFec) {
   EXPECT_TRUE(SetupEngine());
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kOpusCodec);
-  codecs[0].bitrate = 0;
-  codecs[0].params["useinbandfec"] = "0";
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  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);
 }
 
 // Test that with useinbandfec=1, Opus FEC is on.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusEnableFec) {
   EXPECT_TRUE(SetupEngine());
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kOpusCodec);
-  codecs[0].bitrate = 0;
-  codecs[0].params["useinbandfec"] = "1";
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  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);
 }
 
 // Test that with useinbandfec=1, stereo=1, Opus FEC is on.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusEnableFecStereo) {
   EXPECT_TRUE(SetupEngine());
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kOpusCodec);
-  codecs[0].bitrate = 0;
-  codecs[0].params["stereo"] = "1";
-  codecs[0].params["useinbandfec"] = "1";
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  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);
 }
 
 // Test that with non-Opus, codec FEC is off.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecIsacNoFec) {
   EXPECT_TRUE(SetupEngine());
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kIsacCodec);
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  cricket::AudioSendParameters parameters;
+  parameters.codecs.push_back(kIsacCodec);
+  EXPECT_TRUE(channel_->SetSendParameters(parameters));
   EXPECT_FALSE(voe_.GetCodecFEC(channel_num));
 }
 
 // Test the with non-Opus, even if useinbandfec=1, FEC is off.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecIsacWithParamNoFec) {
   EXPECT_TRUE(SetupEngine());
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kIsacCodec);
-  codecs[0].params["useinbandfec"] = "1";
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  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));
 }
 
 // Test that Opus FEC status can be changed.
 TEST_F(WebRtcVoiceEngineTestFake, ChangeOpusFecStatus) {
   EXPECT_TRUE(SetupEngine());
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kOpusCodec);
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  cricket::AudioSendParameters parameters;
+  parameters.codecs.push_back(kOpusCodec);
+  EXPECT_TRUE(channel_->SetSendParameters(parameters));
   EXPECT_FALSE(voe_.GetCodecFEC(channel_num));
-  codecs[0].params["useinbandfec"] = "1";
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  parameters.codecs[0].params["useinbandfec"] = "1";
+  EXPECT_TRUE(channel_->SetSendParameters(parameters));
   EXPECT_TRUE(voe_.GetCodecFEC(channel_num));
 }
 
 // Test maxplaybackrate <= 8000 triggers Opus narrow band mode.
 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateNb) {
   EXPECT_TRUE(SetupEngine());
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kOpusCodec);
-  codecs[0].bitrate = 0;
-  codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 8000);
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  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);
 
   EXPECT_EQ(12000, gcodec.rate);
-  codecs[0].SetParam(cricket::kCodecParamStereo, "1");
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  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);
 }
 
 // Test 8000 < maxplaybackrate <= 12000 triggers Opus medium band mode.
 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateMb) {
   EXPECT_TRUE(SetupEngine());
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kOpusCodec);
-  codecs[0].bitrate = 0;
-  codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 8001);
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  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);
 
   EXPECT_EQ(20000, gcodec.rate);
-  codecs[0].SetParam(cricket::kCodecParamStereo, "1");
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  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);
 }
 
 // Test 12000 < maxplaybackrate <= 16000 triggers Opus wide band mode.
 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateWb) {
   EXPECT_TRUE(SetupEngine());
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kOpusCodec);
-  codecs[0].bitrate = 0;
-  codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 12001);
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  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);
 
   EXPECT_EQ(20000, gcodec.rate);
-  codecs[0].SetParam(cricket::kCodecParamStereo, "1");
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  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);
 }
 
 // Test 16000 < maxplaybackrate <= 24000 triggers Opus super wide band mode.
 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateSwb) {
   EXPECT_TRUE(SetupEngine());
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kOpusCodec);
-  codecs[0].bitrate = 0;
-  codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 16001);
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  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);
 
   EXPECT_EQ(32000, gcodec.rate);
-  codecs[0].SetParam(cricket::kCodecParamStereo, "1");
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  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);
 }
 
 // Test 24000 < maxplaybackrate triggers Opus full band mode.
 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateFb) {
   EXPECT_TRUE(SetupEngine());
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kOpusCodec);
-  codecs[0].bitrate = 0;
-  codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 24001);
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  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);
 
   EXPECT_EQ(32000, gcodec.rate);
-  codecs[0].SetParam(cricket::kCodecParamStereo, "1");
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  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);
 }
 
 // Test Opus that without maxplaybackrate, default playback rate is used.
 TEST_F(WebRtcVoiceEngineTestFake, DefaultOpusMaxPlaybackRate) {
   EXPECT_TRUE(SetupEngine());
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kOpusCodec);
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  cricket::AudioSendParameters parameters;
+  parameters.codecs.push_back(kOpusCodec);
+  EXPECT_TRUE(channel_->SetSendParameters(parameters));
   EXPECT_EQ(cricket::kOpusBandwidthFb,
             voe_.GetMaxEncodingBandwidth(channel_num));
 }
 
 // Test the with non-Opus, maxplaybackrate has no effect.
 TEST_F(WebRtcVoiceEngineTestFake, SetNonOpusMaxPlaybackRate) {
   EXPECT_TRUE(SetupEngine());
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kIsacCodec);
-  codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 32000);
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  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));
 }
 
 // Test maxplaybackrate can be set on two streams.
 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateOnTwoStreams) {
   EXPECT_TRUE(SetupEngine());
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kOpusCodec);
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  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));
 
-  codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 8000);
+  parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 8000);
 
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  EXPECT_TRUE(channel_->SetSendParameters(parameters));
   EXPECT_EQ(cricket::kOpusBandwidthNb,
             voe_.GetMaxEncodingBandwidth(channel_num));
 
   channel_->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc2));
   channel_num = voe_.GetLastChannel();
   EXPECT_EQ(cricket::kOpusBandwidthNb,
             voe_.GetMaxEncodingBandwidth(channel_num));
 }
 
 // Test that with usedtx=0, Opus DTX is off.
 TEST_F(WebRtcVoiceEngineTestFake, DisableOpusDtxOnOpus) {
   EXPECT_TRUE(SetupEngine());
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kOpusCodec);
-  codecs[0].params["usedtx"] = "0";
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  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));
 }
 
 // Test that with usedtx=1, Opus DTX is on.
 TEST_F(WebRtcVoiceEngineTestFake, EnableOpusDtxOnOpus) {
   EXPECT_TRUE(SetupEngine());
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kOpusCodec);
-  codecs[0].params["usedtx"] = "1";
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  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.
 }
 
 // Test that usedtx=1 works with stereo Opus.
 TEST_F(WebRtcVoiceEngineTestFake, EnableOpusDtxOnOpusStereo) {
   EXPECT_TRUE(SetupEngine());
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kOpusCodec);
-  codecs[0].params["usedtx"] = "1";
-  codecs[0].params["stereo"] = "1";
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  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.
 }
 
 // Test that usedtx=1 does not work with non Opus.
 TEST_F(WebRtcVoiceEngineTestFake, CannotEnableOpusDtxOnNonOpus) {
   EXPECT_TRUE(SetupEngine());
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kIsacCodec);
-  codecs[0].params["usedtx"] = "1";
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  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));
 }
 
 // Test that we can switch back and forth between Opus and ISAC with CN.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsIsacOpusSwitching) {
   EXPECT_TRUE(SetupEngine());
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> opus_codecs;
-  opus_codecs.push_back(kOpusCodec);
-  EXPECT_TRUE(channel_->SetSendCodecs(opus_codecs));
+  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));
   EXPECT_EQ(111, gcodec.pltype);
   EXPECT_STREQ("opus", gcodec.plname);
 
-  std::vector<cricket::AudioCodec> isac_codecs;
-  isac_codecs.push_back(kIsacCodec);
-  isac_codecs.push_back(kCn16000Codec);
-  isac_codecs.push_back(kOpusCodec);
-  EXPECT_TRUE(channel_->SetSendCodecs(isac_codecs));
+  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));
   EXPECT_EQ(103, gcodec.pltype);
   EXPECT_STREQ("ISAC", gcodec.plname);
 
-  EXPECT_TRUE(channel_->SetSendCodecs(opus_codecs));
+  EXPECT_TRUE(channel_->SetSendParameters(opus_parameters));
   EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
   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(SetupEngine());
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kIsacCodec);  // bitrate == 32000
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  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));
   EXPECT_EQ(103, gcodec.pltype);
   EXPECT_STREQ("ISAC", gcodec.plname);
   EXPECT_EQ(32000, gcodec.rate);
 
-  codecs[0].bitrate = 0;         // bitrate == default
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  parameters.codecs[0].bitrate = 0;         // bitrate == default
+  EXPECT_TRUE(channel_->SetSendParameters(parameters));
   EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
   EXPECT_EQ(103, gcodec.pltype);
   EXPECT_STREQ("ISAC", gcodec.plname);
   EXPECT_EQ(-1, gcodec.rate);
 
-  codecs[0].bitrate = 28000;     // bitrate == 28000
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  parameters.codecs[0].bitrate = 28000;     // bitrate == 28000
+  EXPECT_TRUE(channel_->SetSendParameters(parameters));
   EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
   EXPECT_EQ(103, gcodec.pltype);
   EXPECT_STREQ("ISAC", gcodec.plname);
   EXPECT_EQ(28000, gcodec.rate);
 
-  codecs[0] = kPcmuCodec;        // bitrate == 64000
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  parameters.codecs[0] = kPcmuCodec;        // bitrate == 64000
+  EXPECT_TRUE(channel_->SetSendParameters(parameters));
   EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
   EXPECT_EQ(0, gcodec.pltype);
   EXPECT_STREQ("PCMU", gcodec.plname);
   EXPECT_EQ(64000, gcodec.rate);
 
-  codecs[0].bitrate = 0;         // bitrate == default
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  parameters.codecs[0].bitrate = 0;         // bitrate == default
+  EXPECT_TRUE(channel_->SetSendParameters(parameters));
   EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
   EXPECT_EQ(0, gcodec.pltype);
   EXPECT_STREQ("PCMU", gcodec.plname);
   EXPECT_EQ(64000, gcodec.rate);
 
-  codecs[0] = kOpusCodec;
-  codecs[0].bitrate = 0;         // bitrate == default
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  parameters.codecs[0] = kOpusCodec;
+  parameters.codecs[0].bitrate = 0;         // bitrate == default
+  EXPECT_TRUE(channel_->SetSendParameters(parameters));
   EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
   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(SetupEngine());
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kOpusCodec);
-  codecs[0].SetParam(cricket::kCodecParamPTime, 40);  // Value within range.
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  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.
 
-  codecs[0].SetParam(cricket::kCodecParamPTime, 5);  // Value below range.
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  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.
 
-  codecs[0].SetParam(cricket::kCodecParamPTime, 80);  // Value beyond range.
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  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.
 
-  codecs[0] = kIsacCodec;  // Also try Isac, and with unsupported size.
-  codecs[0].SetParam(cricket::kCodecParamPTime, 40);  // Value within range.
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  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.
 
-  codecs[0] = kG722CodecSdp;  // Try G722 @8kHz as negotiated in SDP.
-  codecs[0].SetParam(cricket::kCodecParamPTime, 40);
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  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.
 }
 
-// Test that we fail if no codecs are specified.
-TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsNoCodecs) {
-  EXPECT_TRUE(SetupEngine());
-  std::vector<cricket::AudioCodec> codecs;
-  EXPECT_FALSE(channel_->SetSendCodecs(codecs));
-}
-
 // 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(SetupEngine());
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kTelephoneEventCodec);
-  codecs.push_back(kIsacCodec);
-  codecs.push_back(kPcmuCodec);
-  codecs[0].id = 98;  // DTMF
-  codecs[1].id = 96;
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  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));
   EXPECT_EQ(96, gcodec.pltype);
   EXPECT_STREQ("ISAC", gcodec.plname);
   EXPECT_EQ(98, voe_.GetSendTelephoneEventPayloadType(channel_num));
 }
 
 // Test that we can set send codecs even with CN codec as the first
 // one on the list.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNOnTop) {
   EXPECT_TRUE(SetupEngine());
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kCn16000Codec);
-  codecs.push_back(kIsacCodec);
-  codecs.push_back(kPcmuCodec);
-  codecs[0].id = 98;  // wideband CN
-  codecs[1].id = 96;
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  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));
 }
 
 // Test that we set VAD and DTMF types correctly as caller.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCaller) {
   EXPECT_TRUE(SetupEngine());
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kIsacCodec);
-  codecs.push_back(kPcmuCodec);
+  cricket::AudioSendParameters parameters;
+  parameters.codecs.push_back(kIsacCodec);
+  parameters.codecs.push_back(kPcmuCodec);
   // TODO(juberti): cn 32000
-  codecs.push_back(kCn16000Codec);
-  codecs.push_back(kCn8000Codec);
-  codecs.push_back(kTelephoneEventCodec);
-  codecs.push_back(kRedCodec);
-  codecs[0].id = 96;
-  codecs[2].id = 97;  // wideband CN
-  codecs[4].id = 98;  // DTMF
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  parameters.codecs.push_back(kCn16000Codec);
+  parameters.codecs.push_back(kCn8000Codec);
+  parameters.codecs.push_back(kTelephoneEventCodec);
+  parameters.codecs.push_back(kRedCodec);
+  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_FALSE(voe_.GetRED(channel_num));
   EXPECT_EQ(13, voe_.GetSendCNPayloadType(channel_num, false));
   EXPECT_EQ(97, voe_.GetSendCNPayloadType(channel_num, true));
   EXPECT_EQ(98, voe_.GetSendTelephoneEventPayloadType(channel_num));
 }
 
 // Test that we set VAD and DTMF types correctly as callee.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCallee) {
   EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
   channel_ = engine_.CreateChannel(&call_, cricket::AudioOptions());
   EXPECT_TRUE(channel_ != nullptr);
 
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kIsacCodec);
-  codecs.push_back(kPcmuCodec);
+  cricket::AudioSendParameters parameters;
+  parameters.codecs.push_back(kIsacCodec);
+  parameters.codecs.push_back(kPcmuCodec);
   // TODO(juberti): cn 32000
-  codecs.push_back(kCn16000Codec);
-  codecs.push_back(kCn8000Codec);
-  codecs.push_back(kTelephoneEventCodec);
-  codecs.push_back(kRedCodec);
-  codecs[0].id = 96;
-  codecs[2].id = 97;  // wideband CN
-  codecs[4].id = 98;  // DTMF
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  parameters.codecs.push_back(kCn16000Codec);
+  parameters.codecs.push_back(kCn8000Codec);
+  parameters.codecs.push_back(kTelephoneEventCodec);
+  parameters.codecs.push_back(kRedCodec);
+  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)));
 
   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_FALSE(voe_.GetRED(channel_num));
   EXPECT_EQ(13, voe_.GetSendCNPayloadType(channel_num, false));
   EXPECT_EQ(97, voe_.GetSendCNPayloadType(channel_num, true));
   EXPECT_EQ(98, voe_.GetSendTelephoneEventPayloadType(channel_num));
 }
 
 // Test that we only apply VAD if we have a CN codec that matches the
 // send codec clockrate.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNNoMatch) {
   EXPECT_TRUE(SetupEngine());
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
+  cricket::AudioSendParameters parameters;
   // Set ISAC(16K) and CN(16K). VAD should be activated.
-  codecs.push_back(kIsacCodec);
-  codecs.push_back(kCn16000Codec);
-  codecs[1].id = 97;
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  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));
   // Set PCMU(8K) and CN(16K). VAD should not be activated.
-  codecs[0] = kPcmuCodec;
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  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));
   // Set PCMU(8K) and CN(8K). VAD should be activated.
-  codecs[1] = kCn8000Codec;
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  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));
   // Set ISAC(16K) and CN(8K). VAD should not be activated.
-  codecs[0] = kIsacCodec;
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  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));
 }
 
 // Test that we perform case-insensitive matching of codec names.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCaseInsensitive) {
   EXPECT_TRUE(SetupEngine());
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kIsacCodec);
-  codecs.push_back(kPcmuCodec);
-  codecs.push_back(kCn16000Codec);
-  codecs.push_back(kCn8000Codec);
-  codecs.push_back(kTelephoneEventCodec);
-  codecs.push_back(kRedCodec);
-  codecs[0].name = "iSaC";
-  codecs[0].id = 96;
-  codecs[2].id = 97;  // wideband CN
-  codecs[4].id = 98;  // DTMF
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  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.push_back(kRedCodec);
+  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_FALSE(voe_.GetRED(channel_num));
   EXPECT_EQ(13, voe_.GetSendCNPayloadType(channel_num, false));
   EXPECT_EQ(97, voe_.GetSendCNPayloadType(channel_num, true));
   EXPECT_EQ(98, voe_.GetSendTelephoneEventPayloadType(channel_num));
 }
 
 // Test that we set up RED correctly as caller.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsREDAsCaller) {
   EXPECT_TRUE(SetupEngine());
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kRedCodec);
-  codecs.push_back(kIsacCodec);
-  codecs.push_back(kPcmuCodec);
-  codecs[0].id = 127;
-  codecs[0].params[""] = "96/96";
-  codecs[1].id = 96;
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  cricket::AudioSendParameters parameters;
+  parameters.codecs.push_back(kRedCodec);
+  parameters.codecs.push_back(kIsacCodec);
+  parameters.codecs.push_back(kPcmuCodec);
+  parameters.codecs[0].id = 127;
+  parameters.codecs[0].params[""] = "96/96";
+  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_TRUE(voe_.GetRED(channel_num));
   EXPECT_EQ(127, voe_.GetSendREDPayloadType(channel_num));
 }
 
 // Test that we set up RED correctly as callee.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsREDAsCallee) {
   EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
   channel_ = engine_.CreateChannel(&call_, cricket::AudioOptions());
   EXPECT_TRUE(channel_ != nullptr);
 
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kRedCodec);
-  codecs.push_back(kIsacCodec);
-  codecs.push_back(kPcmuCodec);
-  codecs[0].id = 127;
-  codecs[0].params[""] = "96/96";
-  codecs[1].id = 96;
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  cricket::AudioSendParameters parameters;
+  parameters.codecs.push_back(kRedCodec);
+  parameters.codecs.push_back(kIsacCodec);
+  parameters.codecs.push_back(kPcmuCodec);
+  parameters.codecs[0].id = 127;
+  parameters.codecs[0].params[""] = "96/96";
+  parameters.codecs[1].id = 96;
+  EXPECT_TRUE(channel_->SetSendParameters(parameters));
   EXPECT_TRUE(channel_->AddSendStream(
       cricket::StreamParams::CreateLegacy(kSsrc1)));
   webrtc::CodecInst gcodec;
   EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
   EXPECT_EQ(96, gcodec.pltype);
   EXPECT_STREQ("ISAC", gcodec.plname);
   EXPECT_TRUE(voe_.GetRED(channel_num));
   EXPECT_EQ(127, voe_.GetSendREDPayloadType(channel_num));
 }
 
 // Test that we set up RED correctly if params are omitted.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsREDNoParams) {
   EXPECT_TRUE(SetupEngine());
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kRedCodec);
-  codecs.push_back(kIsacCodec);
-  codecs.push_back(kPcmuCodec);
-  codecs[0].id = 127;
-  codecs[1].id = 96;
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  cricket::AudioSendParameters parameters;
+  parameters.codecs.push_back(kRedCodec);
+  parameters.codecs.push_back(kIsacCodec);
+  parameters.codecs.push_back(kPcmuCodec);
+  parameters.codecs[0].id = 127;
+  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_TRUE(voe_.GetRED(channel_num));
   EXPECT_EQ(127, voe_.GetSendREDPayloadType(channel_num));
 }
 
 // Test that we ignore RED if the parameters aren't named the way we expect.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsBadRED1) {
   EXPECT_TRUE(SetupEngine());
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kRedCodec);
-  codecs.push_back(kIsacCodec);
-  codecs.push_back(kPcmuCodec);
-  codecs[0].id = 127;
-  codecs[0].params["ABC"] = "96/96";
-  codecs[1].id = 96;
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  cricket::AudioSendParameters parameters;
+  parameters.codecs.push_back(kRedCodec);
+  parameters.codecs.push_back(kIsacCodec);
+  parameters.codecs.push_back(kPcmuCodec);
+  parameters.codecs[0].id = 127;
+  parameters.codecs[0].params["ABC"] = "96/96";
+  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_FALSE(voe_.GetRED(channel_num));
 }
 
 // Test that we ignore RED if it uses different primary/secondary encoding.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsBadRED2) {
   EXPECT_TRUE(SetupEngine());
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kRedCodec);
-  codecs.push_back(kIsacCodec);
-  codecs.push_back(kPcmuCodec);
-  codecs[0].id = 127;
-  codecs[0].params[""] = "96/0";
-  codecs[1].id = 96;
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  cricket::AudioSendParameters parameters;
+  parameters.codecs.push_back(kRedCodec);
+  parameters.codecs.push_back(kIsacCodec);
+  parameters.codecs.push_back(kPcmuCodec);
+  parameters.codecs[0].id = 127;
+  parameters.codecs[0].params[""] = "96/0";
+  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_FALSE(voe_.GetRED(channel_num));
 }
 
 // Test that we ignore RED if it uses more than 2 encodings.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsBadRED3) {
   EXPECT_TRUE(SetupEngine());
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kRedCodec);
-  codecs.push_back(kIsacCodec);
-  codecs.push_back(kPcmuCodec);
-  codecs[0].id = 127;
-  codecs[0].params[""] = "96/96/96";
-  codecs[1].id = 96;
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  cricket::AudioSendParameters parameters;
+  parameters.codecs.push_back(kRedCodec);
+  parameters.codecs.push_back(kIsacCodec);
+  parameters.codecs.push_back(kPcmuCodec);
+  parameters.codecs[0].id = 127;
+  parameters.codecs[0].params[""] = "96/96/96";
+  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_FALSE(voe_.GetRED(channel_num));
 }
 
 // Test that we ignore RED if it has bogus codec ids.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsBadRED4) {
   EXPECT_TRUE(SetupEngine());
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kRedCodec);
-  codecs.push_back(kIsacCodec);
-  codecs.push_back(kPcmuCodec);
-  codecs[0].id = 127;
-  codecs[0].params[""] = "ABC/ABC";
-  codecs[1].id = 96;
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  cricket::AudioSendParameters parameters;
+  parameters.codecs.push_back(kRedCodec);
+  parameters.codecs.push_back(kIsacCodec);
+  parameters.codecs.push_back(kPcmuCodec);
+  parameters.codecs[0].id = 127;
+  parameters.codecs[0].params[""] = "ABC/ABC";
+  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_FALSE(voe_.GetRED(channel_num));
 }
 
 // Test that we ignore RED if it refers to a codec that is not present.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsBadRED5) {
   EXPECT_TRUE(SetupEngine());
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kRedCodec);
-  codecs.push_back(kIsacCodec);
-  codecs.push_back(kPcmuCodec);
-  codecs[0].id = 127;
-  codecs[0].params[""] = "97/97";
-  codecs[1].id = 96;
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  cricket::AudioSendParameters parameters;
+  parameters.codecs.push_back(kRedCodec);
+  parameters.codecs.push_back(kIsacCodec);
+  parameters.codecs.push_back(kPcmuCodec);
+  parameters.codecs[0].id = 127;
+  parameters.codecs[0].params[""] = "97/97";
+  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_FALSE(voe_.GetRED(channel_num));
 }
 
 // Test support for audio level header extension.
 TEST_F(WebRtcVoiceEngineTestFake, SendAudioLevelHeaderExtensions) {
   TestSetSendRtpHeaderExtensions(kRtpAudioLevelHeaderExtension);
 }
 TEST_F(WebRtcVoiceEngineTestFake, RecvAudioLevelHeaderExtensions) {
   TestSetRecvRtpHeaderExtensions(kRtpAudioLevelHeaderExtension);
 }
 
 // Test support for absolute send time header extension.
 TEST_F(WebRtcVoiceEngineTestFake, SendAbsoluteSendTimeHeaderExtensions) {
   TestSetSendRtpHeaderExtensions(kRtpAbsoluteSenderTimeHeaderExtension);
 }
 TEST_F(WebRtcVoiceEngineTestFake, RecvAbsoluteSendTimeHeaderExtensions) {
   TestSetRecvRtpHeaderExtensions(kRtpAbsoluteSenderTimeHeaderExtension);
 }
 
 // Test that we can create a channel and start sending/playing out on it.
 TEST_F(WebRtcVoiceEngineTestFake, SendAndPlayout) {
   EXPECT_TRUE(SetupEngine());
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kPcmuCodec);
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
   EXPECT_TRUE(channel_->SetSend(cricket::SEND_MICROPHONE));
   EXPECT_TRUE(voe_.GetSend(channel_num));
   EXPECT_TRUE(channel_->SetPlayout(true));
   EXPECT_TRUE(voe_.GetPlayout(channel_num));
   EXPECT_TRUE(channel_->SetSend(cricket::SEND_NOTHING));
   EXPECT_FALSE(voe_.GetSend(channel_num));
   EXPECT_TRUE(channel_->SetPlayout(false));
   EXPECT_FALSE(voe_.GetPlayout(channel_num));
 }
 
@@ skipping 36 matching lines @@
 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsWithMultipleSendStreams) {
   SetupForMultiSendStream();
 
   static const uint32 kSsrcs4[] = {1, 2, 3, 4};
   // Create send streams.
   for (unsigned int i = 0; i < ARRAY_SIZE(kSsrcs4); ++i) {
     EXPECT_TRUE(channel_->AddSendStream(
         cricket::StreamParams::CreateLegacy(kSsrcs4[i])));
   }
 
-  std::vector<cricket::AudioCodec> codecs;
+  cricket::AudioSendParameters parameters;
   // Set ISAC(16K) and CN(16K). VAD should be activated.
-  codecs.push_back(kIsacCodec);
-  codecs.push_back(kCn16000Codec);
-  codecs[1].id = 97;
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  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 (unsigned int i = 0; i < ARRAY_SIZE(kSsrcs4); ++i) {
     int channel_num = voe_.GetChannelFromLocalSsrc(kSsrcs4[i]);
     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));
   }
 
   // Change to PCMU(8K) and CN(16K). VAD should not be activated.
-  codecs[0] = kPcmuCodec;
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  parameters.codecs[0] = kPcmuCodec;
+  EXPECT_TRUE(channel_->SetSendParameters(parameters));
   for (unsigned int i = 0; i < ARRAY_SIZE(kSsrcs4); ++i) {
     int channel_num = voe_.GetChannelFromLocalSsrc(kSsrcs4[i]);
     EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec));
     EXPECT_STREQ("PCMU", gcodec.plname);
     EXPECT_FALSE(voe_.GetVAD(channel_num));
   }
 }
 
 // Test we can SetSend on all send streams correctly.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendWithMultipleSendStreams) {
@@ skipping 33 matching lines @@
   // Create send streams.
   for (unsigned int i = 0; i < ARRAY_SIZE(kSsrcs4); ++i) {
     EXPECT_TRUE(channel_->AddSendStream(
         cricket::StreamParams::CreateLegacy(kSsrcs4[i])));
   }
   // Create a receive stream to check that none of the send streams end up in
   // the receive stream stats.
   EXPECT_TRUE(channel_->AddRecvStream(
       cricket::StreamParams::CreateLegacy(kSsrc2)));
   // We need send codec to be set to get all stats.
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kPcmuCodec);
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
-  EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
+  EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
+  EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
 
   cricket::VoiceMediaInfo info;
   EXPECT_EQ(true, channel_->GetStats(&info));
   EXPECT_EQ(static_cast<size_t>(ARRAY_SIZE(kSsrcs4)), info.senders.size());
 
   // Verify the statistic information is correct.
   for (unsigned int i = 0; i < ARRAY_SIZE(kSsrcs4); ++i) {
     EXPECT_EQ(kSsrcs4[i], info.senders[i].ssrc());
     EXPECT_EQ(kPcmuCodec.name, info.senders[i].codec_name);
     EXPECT_EQ(cricket::kIntStatValue, info.senders[i].bytes_sent);
@@ skipping 30 matching lines @@
       info.receivers[0].preemptive_expand_rate);
 }
 
 // Test that we can add and remove receive streams, and do proper send/playout.
 // We can receive on multiple streams while sending one stream.
 TEST_F(WebRtcVoiceEngineTestFake, PlayoutWithMultipleStreams) {
   EXPECT_TRUE(SetupEngine());
   int channel_num1 = voe_.GetLastChannel();
 
   // Start playout on the default channel.
-  EXPECT_TRUE(channel_->SetOptions(options_conference_));
+  send_parameters_.options = options_conference_;
+  EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
   EXPECT_TRUE(channel_->SetPlayout(true));
   EXPECT_TRUE(voe_.GetPlayout(channel_num1));
 
   // Adding another stream should disable playout on the default channel.
   EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
   int channel_num2 = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kPcmuCodec);
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
   EXPECT_TRUE(channel_->SetSend(cricket::SEND_MICROPHONE));
   EXPECT_TRUE(voe_.GetSend(channel_num1));
   EXPECT_FALSE(voe_.GetSend(channel_num2));
 
   // Make sure only the new channel is played out.
   EXPECT_FALSE(voe_.GetPlayout(channel_num1));
   EXPECT_TRUE(voe_.GetPlayout(channel_num2));
 
   // Adding yet another stream should have stream 2 and 3 enabled for playout.
   EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(3)));
@@ skipping 26 matching lines @@
   EXPECT_TRUE(channel_->RemoveRecvStream(3));
   EXPECT_TRUE(channel_->RemoveRecvStream(2));
 
   EXPECT_TRUE(voe_.GetPlayout(channel_num1));
 }
 
 // Test that we can set the devices to use.
 TEST_F(WebRtcVoiceEngineTestFake, SetDevices) {
   EXPECT_TRUE(SetupEngine());
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kPcmuCodec);
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
 
   cricket::Device default_dev(cricket::kFakeDefaultDeviceName,
                               cricket::kFakeDefaultDeviceId);
   cricket::Device dev(cricket::kFakeDeviceName,
                       cricket::kFakeDeviceId);
 
   // Test SetDevices() while not sending or playing.
   EXPECT_TRUE(engine_.SetDevices(&default_dev, &default_dev));
 
   // Test SetDevices() while sending and playing.
@@ skipping 31 matching lines @@
   EXPECT_TRUE(voe_.GetRecordingMicrophone());
   EXPECT_TRUE(voe_.GetSend(channel_num));
   EXPECT_TRUE(voe_.GetPlayout(channel_num));
 }
 
 // Test that we can set the devices to use even if we failed to
 // open the initial ones.
 TEST_F(WebRtcVoiceEngineTestFake, SetDevicesWithInitiallyBadDevices) {
   EXPECT_TRUE(SetupEngine());
   int channel_num = voe_.GetLastChannel();
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kPcmuCodec);
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
 
   cricket::Device default_dev(cricket::kFakeDefaultDeviceName,
                               cricket::kFakeDefaultDeviceId);
   cricket::Device dev(cricket::kFakeDeviceName,
                       cricket::kFakeDeviceId);
 
   // Test that failure to open devices selected before starting
   // send/play does not prevent opening newly selected ones after that.
   voe_.set_fail_start_recording_microphone(true);
   voe_.set_playout_fail_channel(channel_num);
@@ skipping 17 matching lines @@
   EXPECT_TRUE(voe_.GetRecordingMicrophone());
   EXPECT_TRUE(voe_.GetSend(channel_num));
   EXPECT_TRUE(voe_.GetPlayout(channel_num));
 }
 
 // Test that we can create a channel configured for multi-point conferences,
 // and start sending/playing out on it.
 TEST_F(WebRtcVoiceEngineTestFake, ConferenceSendAndPlayout) {
   EXPECT_TRUE(SetupEngine());
   int channel_num = voe_.GetLastChannel();
-  EXPECT_TRUE(channel_->SetOptions(options_conference_));
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kPcmuCodec);
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  send_parameters_.options = options_conference_;
+  EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
   EXPECT_TRUE(channel_->SetSend(cricket::SEND_MICROPHONE));
   EXPECT_TRUE(voe_.GetSend(channel_num));
 }
 
 // Test that we can create a channel configured for Codian bridges,
 // and start sending/playing out on it.
 TEST_F(WebRtcVoiceEngineTestFake, CodianSendAndPlayout) {
   EXPECT_TRUE(SetupEngine());
   int channel_num = voe_.GetLastChannel();
   webrtc::AgcConfig agc_config;
   EXPECT_EQ(0, voe_.GetAgcConfig(agc_config));
   EXPECT_EQ(0, agc_config.targetLeveldBOv);
-  EXPECT_TRUE(channel_->SetOptions(options_adjust_agc_));
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kPcmuCodec);
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  send_parameters_.options = options_adjust_agc_;
+  EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
   EXPECT_TRUE(channel_->SetSend(cricket::SEND_MICROPHONE));
   EXPECT_TRUE(voe_.GetSend(channel_num));
   EXPECT_EQ(0, voe_.GetAgcConfig(agc_config));
   EXPECT_EQ(agc_config.targetLeveldBOv, 10);  // level was attenuated
   EXPECT_TRUE(channel_->SetPlayout(true));
   EXPECT_TRUE(voe_.GetPlayout(channel_num));
   EXPECT_TRUE(channel_->SetSend(cricket::SEND_NOTHING));
   EXPECT_FALSE(voe_.GetSend(channel_num));
   EXPECT_EQ(0, voe_.GetAgcConfig(agc_config));
   EXPECT_EQ(0, agc_config.targetLeveldBOv);  // level was restored
@@ skipping 24 matching lines @@
   options.adjust_agc_delta.Set(-10);
   EXPECT_TRUE(engine_.SetOptions(options));
 
   EXPECT_EQ(0, voe_.GetAgcConfig(agc_config));
   EXPECT_EQ(13, agc_config.targetLeveldBOv);
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, RxAgcConfigViaOptions) {
   EXPECT_TRUE(SetupEngine());
   int channel_num = voe_.GetLastChannel();
-  cricket::AudioOptions options;
-  options.rx_agc_target_dbov.Set(6);
-  options.rx_agc_digital_compression_gain.Set(0);
-  options.rx_agc_limiter.Set(true);
-  options.rx_auto_gain_control.Set(true);
-  EXPECT_TRUE(channel_->SetOptions(options));
+  send_parameters_.options.rx_agc_target_dbov.Set(6);
+  send_parameters_.options.rx_agc_digital_compression_gain.Set(0);
+  send_parameters_.options.rx_agc_limiter.Set(true);
+  send_parameters_.options.rx_auto_gain_control.Set(true);
+  EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
 
   webrtc::AgcConfig agc_config;
   EXPECT_EQ(0, engine_.voe()->processing()->GetRxAgcConfig(
       channel_num, agc_config));
   EXPECT_EQ(6, agc_config.targetLeveldBOv);
   EXPECT_EQ(0, agc_config.digitalCompressionGaindB);
   EXPECT_TRUE(agc_config.limiterEnable);
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, SampleRatesViaOptions) {
@@ skipping 41 matching lines @@
   EXPECT_EQ(kSsrc1, send_ssrc);
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, GetStats) {
   // Setup. We need send codec to be set to get all stats.
   EXPECT_TRUE(SetupEngine());
   // SetupEngine adds a send stream with kSsrc1, so the receive stream has to
   // use a different SSRC.
   EXPECT_TRUE(channel_->AddRecvStream(
       cricket::StreamParams::CreateLegacy(kSsrc2)));
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kPcmuCodec);
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
-  EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
+  EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
+  EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
 
   cricket::VoiceMediaInfo info;
   EXPECT_EQ(true, channel_->GetStats(&info));
   EXPECT_EQ(1u, info.senders.size());
   EXPECT_EQ(kSsrc1, info.senders[0].ssrc());
   EXPECT_EQ(kPcmuCodec.name, info.senders[0].codec_name);
   EXPECT_EQ(cricket::kIntStatValue, info.senders[0].bytes_sent);
   EXPECT_EQ(cricket::kIntStatValue, info.senders[0].packets_sent);
   EXPECT_EQ(cricket::kIntStatValue, info.senders[0].packets_lost);
   EXPECT_EQ(cricket::kFractionLostStatValue, info.senders[0].fraction_lost);
@@ skipping 26 matching lines @@
       (1 << 14), info.receivers[0].speech_expand_rate);
   EXPECT_EQ(static_cast<float>(cricket::kNetStats.currentSecondaryDecodedRate) /
       (1 << 14), info.receivers[0].secondary_decoded_rate);
   // TODO(sriniv): Add testing for more receiver fields.
 }
 
 // Test that we can set the outgoing SSRC properly with multiple streams.
 // SSRC is set in SetupEngine by calling AddSendStream.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendSsrcWithMultipleStreams) {
   EXPECT_TRUE(SetupEngine());
-  EXPECT_TRUE(channel_->SetOptions(options_conference_));
   int channel_num1 = voe_.GetLastChannel();
   unsigned int send_ssrc;
   EXPECT_EQ(0, voe_.GetLocalSSRC(channel_num1, send_ssrc));
   EXPECT_EQ(kSsrc1, send_ssrc);
 
   EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
   int channel_num2 = voe_.GetLastChannel();
   EXPECT_EQ(0, voe_.GetLocalSSRC(channel_num2, send_ssrc));
   EXPECT_EQ(kSsrc1, send_ssrc);
 }
 
 // Test that the local SSRC is the same on sending and receiving channels if the
 // receive channel is created before the send channel.
 TEST_F(WebRtcVoiceEngineTestFake, SetSendSsrcAfterCreatingReceiveChannel) {
   EXPECT_TRUE(engine_.Init(rtc::Thread::Current()));
   channel_ = engine_.CreateChannel(&call_, cricket::AudioOptions());
-  EXPECT_TRUE(channel_->SetOptions(options_conference_));
 
   EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
   int receive_channel_num = voe_.GetLastChannel();
   EXPECT_TRUE(channel_->AddSendStream(
       cricket::StreamParams::CreateLegacy(1234)));
   int send_channel_num = voe_.GetLastChannel();
 
   unsigned int ssrc = 0;
   EXPECT_EQ(0, voe_.GetLocalSSRC(send_channel_num, ssrc));
   EXPECT_EQ(1234U, ssrc);
   ssrc = 0;
   EXPECT_EQ(0, voe_.GetLocalSSRC(receive_channel_num, ssrc));
   EXPECT_EQ(1234U, ssrc);
 }
 
 // Test that we can properly receive packets.
 TEST_F(WebRtcVoiceEngineTestFake, Recv) {
   EXPECT_TRUE(SetupEngine());
   int channel_num = voe_.GetLastChannel();
   DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame));
   EXPECT_TRUE(voe_.CheckPacket(channel_num, kPcmuFrame,
                                sizeof(kPcmuFrame)));
 }
 
 // Test that we can properly receive packets on multiple streams.
 TEST_F(WebRtcVoiceEngineTestFake, RecvWithMultipleStreams) {
   EXPECT_TRUE(SetupEngine());
-  EXPECT_TRUE(channel_->SetOptions(options_conference_));
+  send_parameters_.options = options_conference_;
+  EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
   EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
   int channel_num1 = voe_.GetLastChannel();
   EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
   int channel_num2 = voe_.GetLastChannel();
   EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(3)));
   int channel_num3 = voe_.GetLastChannel();
   // Create packets with the right SSRCs.
   char packets[4][sizeof(kPcmuFrame)];
   for (size_t i = 0; i < ARRAY_SIZE(packets); ++i) {
     memcpy(packets[i], kPcmuFrame, sizeof(kPcmuFrame));
@@ skipping 23 matching lines @@
                                sizeof(packets[3])));
   EXPECT_TRUE(channel_->RemoveRecvStream(3));
   EXPECT_TRUE(channel_->RemoveRecvStream(2));
   EXPECT_TRUE(channel_->RemoveRecvStream(1));
 }
 
 // Test that we properly handle failures to add a stream.
 TEST_F(WebRtcVoiceEngineTestFake, AddStreamFail) {
   EXPECT_TRUE(SetupEngine());
   voe_.set_fail_create_channel(true);
-  EXPECT_TRUE(channel_->SetOptions(options_conference_));
+  send_parameters_.options = options_conference_;
+  EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
   EXPECT_FALSE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
 
   // In 1:1 call, we should not try to create a new channel.
-  cricket::AudioOptions options_no_conference_;
-  options_no_conference_.conference_mode.Set(false);
-  EXPECT_TRUE(channel_->SetOptions(options_no_conference_));
+  send_parameters_.options.conference_mode.Set(false);
+  EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
   EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
 }
 
 // Test that AddRecvStream doesn't create new channel for 1:1 call.
 TEST_F(WebRtcVoiceEngineTestFake, AddRecvStream1On1) {
   EXPECT_TRUE(SetupEngine());
   int channel_num = voe_.GetLastChannel();
   EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
   EXPECT_EQ(channel_num, voe_.GetLastChannel());
 }
 
 // Test that after adding a recv stream, we do not decode more codecs than
 // those previously passed into SetRecvCodecs.
 TEST_F(WebRtcVoiceEngineTestFake, AddRecvStreamUnsupportedCodec) {
   EXPECT_TRUE(SetupEngine());
-  EXPECT_TRUE(channel_->SetOptions(options_conference_));
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kIsacCodec);
-  codecs.push_back(kPcmuCodec);
-  EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
+  cricket::AudioRecvParameters parameters;
+  parameters.codecs.push_back(kIsacCodec);
+  parameters.codecs.push_back(kPcmuCodec);
+  EXPECT_TRUE(channel_->SetRecvParameters(parameters));
   EXPECT_TRUE(channel_->AddRecvStream(
       cricket::StreamParams::CreateLegacy(kSsrc1)));
   int channel_num2 = voe_.GetLastChannel();
   webrtc::CodecInst gcodec;
   rtc::strcpyn(gcodec.plname, ARRAY_SIZE(gcodec.plname), "opus");
   gcodec.plfreq = 48000;
   gcodec.channels = 2;
   EXPECT_EQ(-1, voe_.GetRecPayloadType(channel_num2, gcodec));
 }
 
 // Test that we properly clean up any streams that were added, even if
 // not explicitly removed.
 TEST_F(WebRtcVoiceEngineTestFake, StreamCleanup) {
   EXPECT_TRUE(SetupEngine());
-  EXPECT_TRUE(channel_->SetOptions(options_conference_));
+  send_parameters_.options = options_conference_;
+  EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
   EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
   EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
   EXPECT_EQ(3, voe_.GetNumChannels());  // default channel + 2 added
   delete channel_;
   channel_ = NULL;
   EXPECT_EQ(0, voe_.GetNumChannels());
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, TestAddRecvStreamFailWithZeroSsrc) {
   EXPECT_TRUE(SetupEngine());
@@ skipping 54 matching lines @@
   // Check we stop the tone if a packet arrives.
   EXPECT_TRUE(channel_->PlayRingbackTone(0, true, true));
   EXPECT_EQ(1, voe_.IsPlayingFileLocally(channel_num));
   DeliverPacket(kPcmuFrame, sizeof(kPcmuFrame));
   EXPECT_EQ(0, voe_.IsPlayingFileLocally(channel_num));
 }
 
 // Test that we can play a ringback tone properly in a multi-stream call.
 TEST_F(WebRtcVoiceEngineTestFake, PlayRingbackWithMultipleStreams) {
   EXPECT_TRUE(SetupEngine());
-  EXPECT_TRUE(channel_->SetOptions(options_conference_));
   EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
   EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
   int channel_num = voe_.GetLastChannel();
   EXPECT_EQ(0, voe_.IsPlayingFileLocally(channel_num));
   // Check we fail if no ringback tone specified.
   EXPECT_FALSE(channel_->PlayRingbackTone(2, true, true));
   EXPECT_EQ(0, voe_.IsPlayingFileLocally(channel_num));
   // Check we can set and play a ringback tone on the correct ssrc.
   EXPECT_TRUE(channel_->SetRingbackTone(
                   kRingbackTone, static_cast<int>(strlen(kRingbackTone))));
@@ skipping 16 matching lines @@
   DeliverPacket(packet, sizeof(packet));
   EXPECT_EQ(0, voe_.IsPlayingFileLocally(channel_num));
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, MediaEngineCallbackOnError) {
   rtc::scoped_ptr<ChannelErrorListener> listener;
   cricket::WebRtcVoiceMediaChannel* media_channel;
   unsigned int ssrc = 0;
 
   EXPECT_TRUE(SetupEngine());
-  EXPECT_TRUE(channel_->SetOptions(options_conference_));
+  send_parameters_.options = options_conference_;
+  EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
   EXPECT_TRUE(channel_->SetSend(cricket::SEND_MICROPHONE));
 
   media_channel = static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_);
   listener.reset(new ChannelErrorListener(channel_));
 
   // Test on WebRtc VoE channel.
   voe_.TriggerCallbackOnError(media_channel->voe_channel(),
                               VE_SATURATION_WARNING);
   EXPECT_EQ(cricket::VoiceMediaChannel::ERROR_REC_DEVICE_SATURATION,
             listener->error());
@@ skipping 19 matching lines @@
 
   // Testing a non-existing channel.
   listener->Reset();
   voe_.TriggerCallbackOnError(voe_.GetLastChannel() + 2,
                               VE_SATURATION_WARNING);
   EXPECT_EQ(0, listener->error());
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, TestSetPlayoutError) {
   EXPECT_TRUE(SetupEngine());
-  EXPECT_TRUE(channel_->SetOptions(options_conference_));
-  std::vector<cricket::AudioCodec> codecs;
-  codecs.push_back(kPcmuCodec);
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  send_parameters_.options = options_conference_;
+  EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
   EXPECT_TRUE(channel_->SetSend(cricket::SEND_MICROPHONE));
   EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
   EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(3)));
   EXPECT_TRUE(channel_->SetPlayout(true));
   voe_.set_playout_fail_channel(voe_.GetLastChannel() - 1);
   EXPECT_TRUE(channel_->SetPlayout(false));
   EXPECT_FALSE(channel_->SetPlayout(true));
 }
 
 // Test that the Registering/Unregistering with the
 // webrtcvoiceengine works as expected
 TEST_F(WebRtcVoiceEngineTestFake, RegisterVoiceProcessor) {
   EXPECT_TRUE(SetupEngine());
-  EXPECT_TRUE(channel_->SetOptions(options_conference_));
   EXPECT_TRUE(channel_->AddRecvStream(
       cricket::StreamParams::CreateLegacy(kSsrc2)));
   cricket::FakeMediaProcessor vp_1;
   cricket::FakeMediaProcessor vp_2;
 
   EXPECT_FALSE(engine_.RegisterProcessor(kSsrc2, &vp_1, cricket::MPD_TX));
   EXPECT_TRUE(engine_.RegisterProcessor(kSsrc2, &vp_1, cricket::MPD_RX));
   EXPECT_TRUE(engine_.RegisterProcessor(kSsrc2, &vp_2, cricket::MPD_RX));
   voe_.TriggerProcessPacket(cricket::MPD_RX);
   voe_.TriggerProcessPacket(cricket::MPD_TX);
@@ skipping 281 matching lines @@
 
   // Have to add a stream to make SetSend work.
   cricket::StreamParams stream1;
   stream1.ssrcs.push_back(1);
   channel1->AddSendStream(stream1);
   cricket::StreamParams stream2;
   stream2.ssrcs.push_back(2);
   channel2->AddSendStream(stream2);
 
   // AEC and AGC and NS
-  cricket::AudioOptions options_all;
-  options_all.echo_cancellation.Set(true);
-  options_all.auto_gain_control.Set(true);
-  options_all.noise_suppression.Set(true);
-
-  ASSERT_TRUE(channel1->SetOptions(options_all));
-  cricket::AudioOptions expected_options = options_all;
-  EXPECT_EQ(expected_options, channel1->options());
-  ASSERT_TRUE(channel2->SetOptions(options_all));
-  EXPECT_EQ(expected_options, channel2->options());
+  cricket::AudioSendParameters parameters_options_all = send_parameters_;
+  parameters_options_all.options.echo_cancellation.Set(true);
+  parameters_options_all.options.auto_gain_control.Set(true);
+  parameters_options_all.options.noise_suppression.Set(true);
+  ASSERT_TRUE(channel1->SetSendParameters(parameters_options_all));
+  EXPECT_EQ(parameters_options_all.options, channel1->options());
+  ASSERT_TRUE(channel2->SetSendParameters(parameters_options_all));
+  EXPECT_EQ(parameters_options_all.options, channel2->options());
 
   // unset NS
-  cricket::AudioOptions options_no_ns;
-  options_no_ns.noise_suppression.Set(false);
-  ASSERT_TRUE(channel1->SetOptions(options_no_ns));
-
+  cricket::AudioSendParameters parameters_options_no_ns = send_parameters_;
+  parameters_options_no_ns.options.noise_suppression.Set(false);
+  ASSERT_TRUE(channel1->SetSendParameters(parameters_options_no_ns));
+  cricket::AudioOptions expected_options = parameters_options_all.options;
   expected_options.echo_cancellation.Set(true);
   expected_options.auto_gain_control.Set(true);
   expected_options.noise_suppression.Set(false);
   EXPECT_EQ(expected_options, channel1->options());
 
   // unset AGC
-  cricket::AudioOptions options_no_agc;
-  options_no_agc.auto_gain_control.Set(false);
-  ASSERT_TRUE(channel2->SetOptions(options_no_agc));
-
+  cricket::AudioSendParameters parameters_options_no_agc = send_parameters_;
+  parameters_options_no_agc.options.auto_gain_control.Set(false);
+  ASSERT_TRUE(channel2->SetSendParameters(parameters_options_no_agc));
   expected_options.echo_cancellation.Set(true);
   expected_options.auto_gain_control.Set(false);
   expected_options.noise_suppression.Set(true);
   EXPECT_EQ(expected_options, channel2->options());
 
-  ASSERT_TRUE(engine_.SetOptions(options_all));
+  ASSERT_TRUE(engine_.SetOptions(parameters_options_all.options));
   bool ec_enabled;
   webrtc::EcModes ec_mode;
   bool agc_enabled;
   webrtc::AgcModes agc_mode;
   bool ns_enabled;
   webrtc::NsModes ns_mode;
   voe_.GetEcStatus(ec_enabled, ec_mode);
   voe_.GetAgcStatus(agc_enabled, agc_mode);
   voe_.GetNsStatus(ns_enabled, ns_mode);
   EXPECT_TRUE(ec_enabled);
@@ skipping 26 matching lines @@
 
   channel2->SetSend(cricket::SEND_NOTHING);
   voe_.GetEcStatus(ec_enabled, ec_mode);
   voe_.GetAgcStatus(agc_enabled, agc_mode);
   voe_.GetNsStatus(ns_enabled, ns_mode);
   EXPECT_TRUE(ec_enabled);
   EXPECT_TRUE(agc_enabled);
   EXPECT_TRUE(ns_enabled);
 
   // Make sure settings take effect while we are sending.
-  ASSERT_TRUE(engine_.SetOptions(options_all));
-  cricket::AudioOptions options_no_agc_nor_ns;
-  options_no_agc_nor_ns.auto_gain_control.Set(false);
-  options_no_agc_nor_ns.noise_suppression.Set(false);
+  ASSERT_TRUE(engine_.SetOptions(parameters_options_all.options));
+  cricket::AudioSendParameters parameters_options_no_agc_nor_ns =
+      send_parameters_;
+  parameters_options_no_agc_nor_ns.options.auto_gain_control.Set(false);
+  parameters_options_no_agc_nor_ns.options.noise_suppression.Set(false);
   channel2->SetSend(cricket::SEND_MICROPHONE);
-  channel2->SetOptions(options_no_agc_nor_ns);
-
+  channel2->SetSendParameters(parameters_options_no_agc_nor_ns);
   expected_options.echo_cancellation.Set(true);
   expected_options.auto_gain_control.Set(false);
   expected_options.noise_suppression.Set(false);
   EXPECT_EQ(expected_options, channel2->options());
   voe_.GetEcStatus(ec_enabled, ec_mode);
   voe_.GetAgcStatus(agc_enabled, agc_mode);
   voe_.GetNsStatus(ns_enabled, ns_mode);
   EXPECT_TRUE(ec_enabled);
   EXPECT_FALSE(agc_enabled);
   EXPECT_FALSE(ns_enabled);
 }
 
 // This test verifies DSCP settings are properly applied on voice media channel.
 TEST_F(WebRtcVoiceEngineTestFake, TestSetDscpOptions) {
   EXPECT_TRUE(SetupEngine());
   rtc::scoped_ptr<cricket::VoiceMediaChannel> channel(
       engine_.CreateChannel(&call_, cricket::AudioOptions()));
   rtc::scoped_ptr<cricket::FakeNetworkInterface> network_interface(
       new cricket::FakeNetworkInterface);
   channel->SetInterface(network_interface.get());
-  cricket::AudioOptions options;
-  options.dscp.Set(true);
-  EXPECT_TRUE(channel->SetOptions(options));
+  cricket::AudioSendParameters parameters = send_parameters_;
+  parameters.options.dscp.Set(true);
+  EXPECT_TRUE(channel->SetSendParameters(parameters));
   EXPECT_EQ(rtc::DSCP_EF, network_interface->dscp());
   // Verify previous value is not modified if dscp option is not set.
-  cricket::AudioOptions options1;
-  EXPECT_TRUE(channel->SetOptions(options1));
+  EXPECT_TRUE(channel->SetSendParameters(send_parameters_));
   EXPECT_EQ(rtc::DSCP_EF, network_interface->dscp());
-  options.dscp.Set(false);
-  EXPECT_TRUE(channel->SetOptions(options));
+  parameters.options.dscp.Set(false);
+  EXPECT_TRUE(channel->SetSendParameters(parameters));
   EXPECT_EQ(rtc::DSCP_DEFAULT, network_interface->dscp());
 }
 
 // Test that GetReceiveChannelNum returns the default channel for the first
 // recv stream in 1-1 calls.
 TEST_F(WebRtcVoiceEngineTestFake, TestGetReceiveChannelNumIn1To1Calls) {
   EXPECT_TRUE(SetupEngine());
   cricket::WebRtcVoiceMediaChannel* media_channel =
         static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_);
   // Test that GetChannelNum returns the default channel if the SSRC is unknown.
   EXPECT_EQ(media_channel->voe_channel(),
             media_channel->GetReceiveChannelNum(0));
   cricket::StreamParams stream;
   stream.ssrcs.push_back(kSsrc2);
   EXPECT_TRUE(channel_->AddRecvStream(stream));
   EXPECT_EQ(media_channel->voe_channel(),
             media_channel->GetReceiveChannelNum(kSsrc2));
 }
 
 // Test that GetReceiveChannelNum doesn't return the default channel for the
 // first recv stream in conference calls.
 TEST_F(WebRtcVoiceEngineTestFake, TestGetChannelNumInConferenceCalls) {
   EXPECT_TRUE(SetupEngine());
-  EXPECT_TRUE(channel_->SetOptions(options_conference_));
+  send_parameters_.options = options_conference_;
+  EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
   cricket::StreamParams stream;
   stream.ssrcs.push_back(kSsrc2);
   EXPECT_TRUE(channel_->AddRecvStream(stream));
   cricket::WebRtcVoiceMediaChannel* media_channel =
       static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_);
   EXPECT_LT(media_channel->voe_channel(),
             media_channel->GetReceiveChannelNum(kSsrc2));
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, SetOutputScaling) {
@@ skipping 58 matching lines @@
   EXPECT_EQ(2, call_.GetAudioReceiveStreams().size());
 
   // Combined BWE should be disabled.
   for (uint32 ssrc : ssrcs) {
     const auto* s = call_.GetAudioReceiveStream(ssrc);
     EXPECT_NE(nullptr, s);
     EXPECT_EQ(false, s->GetConfig().combined_audio_video_bwe);
   }
 
   // Enable combined BWE option - now it should be set up.
-  cricket::AudioOptions options;
-  options.combined_audio_video_bwe.Set(true);
-  EXPECT_TRUE(media_channel->SetOptions(options));
+  send_parameters_.options.combined_audio_video_bwe.Set(true);
+  EXPECT_TRUE(media_channel->SetSendParameters(send_parameters_));
   for (uint32 ssrc : ssrcs) {
     const auto* s = call_.GetAudioReceiveStream(ssrc);
     EXPECT_NE(nullptr, s);
     EXPECT_EQ(true, s->GetConfig().combined_audio_video_bwe);
   }
 
   // Disable combined BWE option - should be disabled again.
-  options.combined_audio_video_bwe.Set(false);
-  EXPECT_TRUE(media_channel->SetOptions(options));
+  send_parameters_.options.combined_audio_video_bwe.Set(false);
+  EXPECT_TRUE(media_channel->SetSendParameters(send_parameters_));
   for (uint32 ssrc : ssrcs) {
     const auto* s = call_.GetAudioReceiveStream(ssrc);
     EXPECT_NE(nullptr, s);
     EXPECT_EQ(false, s->GetConfig().combined_audio_video_bwe);
   }
 
   EXPECT_EQ(2, call_.GetAudioReceiveStreams().size());
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, ConfigureCombinedBweForNewRecvStreams) {
   // Test that adding receive streams after enabling combined bandwidth
   // estimation will correctly configure each channel.
   EXPECT_TRUE(SetupEngine());
   cricket::WebRtcVoiceMediaChannel* media_channel =
       static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_);
-  cricket::AudioOptions options;
-  options.combined_audio_video_bwe.Set(true);
-  EXPECT_TRUE(media_channel->SetOptions(options));
+  send_parameters_.options.combined_audio_video_bwe.Set(true);
+  EXPECT_TRUE(media_channel->SetSendParameters(send_parameters_));
 
   static const uint32 kSsrcs[] = {1, 2, 3, 4};
   for (unsigned int i = 0; i < ARRAY_SIZE(kSsrcs); ++i) {
     EXPECT_TRUE(media_channel->AddRecvStream(
         cricket::StreamParams::CreateLegacy(kSsrcs[i])));
     EXPECT_NE(nullptr, call_.GetAudioReceiveStream(kSsrcs[i]));
   }
   EXPECT_EQ(ARRAY_SIZE(kSsrcs), call_.GetAudioReceiveStreams().size());
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, ConfiguresAudioReceiveStreamRtpExtensions) {
   // Test that setting the header extensions results in the expected state
   // changes on an associated Call.
   std::vector<uint32> ssrcs;
   ssrcs.push_back(223);
   ssrcs.push_back(224);
 
   EXPECT_TRUE(SetupEngine());
   cricket::WebRtcVoiceMediaChannel* media_channel =
       static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_);
-  cricket::AudioOptions options;
-  options.combined_audio_video_bwe.Set(true);
-  EXPECT_TRUE(media_channel->SetOptions(options));
+  send_parameters_.options.combined_audio_video_bwe.Set(true);
+  EXPECT_TRUE(media_channel->SetSendParameters(send_parameters_));
   for (uint32 ssrc : ssrcs) {
     EXPECT_TRUE(media_channel->AddRecvStream(
         cricket::StreamParams::CreateLegacy(ssrc)));
   }
 
   // Combined BWE should be set up, but with no configured extensions.
   EXPECT_EQ(2, call_.GetAudioReceiveStreams().size());
   for (uint32 ssrc : ssrcs) {
     const auto* s = call_.GetAudioReceiveStream(ssrc);
     EXPECT_NE(nullptr, s);
     EXPECT_EQ(0, s->GetConfig().rtp.extensions.size());
   }
 
   // Set up receive extensions.
   const auto& e_exts = engine_.rtp_header_extensions();
-  channel_->SetRecvRtpHeaderExtensions(e_exts);
+  cricket::AudioRecvParameters recv_parameters;
+  recv_parameters.extensions = e_exts;
+  channel_->SetRecvParameters(recv_parameters);
   EXPECT_EQ(2, call_.GetAudioReceiveStreams().size());
   for (uint32 ssrc : ssrcs) {
     const auto* s = call_.GetAudioReceiveStream(ssrc);
     EXPECT_NE(nullptr, s);
     const auto& s_exts = s->GetConfig().rtp.extensions;
     EXPECT_EQ(e_exts.size(), s_exts.size());
     for (const auto& e_ext : e_exts) {
       for (const auto& s_ext : s_exts) {
         if (e_ext.id == s_ext.id) {
           EXPECT_EQ(e_ext.uri, s_ext.name);
         }
       }
     }
   }
 
   // Disable receive extensions.
-  std::vector<cricket::RtpHeaderExtension> extensions;
-  channel_->SetRecvRtpHeaderExtensions(extensions);
+  channel_->SetRecvParameters(cricket::AudioRecvParameters());
   for (uint32 ssrc : ssrcs) {
     const auto* s = call_.GetAudioReceiveStream(ssrc);
     EXPECT_NE(nullptr, s);
     EXPECT_EQ(0, s->GetConfig().rtp.extensions.size());
   }
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, DeliverAudioPacket_Call) {
   // Test that packets are forwarded to the Call when configured accordingly.
   const uint32 kAudioSsrc = 1;
   rtc::Buffer kPcmuPacket(kPcmuFrame, sizeof(kPcmuFrame));
   static const unsigned char kRtcp[] = {
     0x80, 0xc9, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
     0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
   };
   rtc::Buffer kRtcpPacket(kRtcp, sizeof(kRtcp));
 
   EXPECT_TRUE(SetupEngine());
   cricket::WebRtcVoiceMediaChannel* media_channel =
       static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_);
-  cricket::AudioOptions options;
-  options.combined_audio_video_bwe.Set(true);
-  EXPECT_TRUE(media_channel->SetOptions(options));
+  send_parameters_.options.combined_audio_video_bwe.Set(true);
+  EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
   EXPECT_TRUE(media_channel->AddRecvStream(
       cricket::StreamParams::CreateLegacy(kAudioSsrc)));
 
   EXPECT_EQ(1, call_.GetAudioReceiveStreams().size());
   const cricket::FakeAudioReceiveStream* s =
       call_.GetAudioReceiveStream(kAudioSsrc);
   EXPECT_EQ(0, s->received_packets());
   channel_->OnPacketReceived(&kPcmuPacket, rtc::PacketTime());
   EXPECT_EQ(1, s->received_packets());
   channel_->OnRtcpReceived(&kRtcpPacket, rtc::PacketTime());
@@ skipping 27 matching lines @@
   // Add send stream, the association remains.
   EXPECT_TRUE(channel_->AddSendStream(cricket::StreamParams::CreateLegacy(3)));
   EXPECT_EQ(voe_.GetAssociateSendChannel(recv_ch_1), -1);
   EXPECT_EQ(voe_.GetAssociateSendChannel(recv_ch_2), default_channel);
 }
 
 // In conference mode, all receive channels should be associated with the
 // default channel, since they do not send RTCP SR.
 TEST_F(WebRtcVoiceEngineTestFake, AssociateDefaultChannelOnConference) {
   EXPECT_TRUE(SetupEngine());
-  EXPECT_TRUE(channel_->SetOptions(options_conference_));
+  send_parameters_.options = options_conference_;
+  EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
   cricket::WebRtcVoiceMediaChannel* media_channel =
       static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_);
   int default_channel = media_channel->voe_channel();
   EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
   int recv_ch = voe_.GetLastChannel();
   EXPECT_NE(recv_ch, default_channel);
   EXPECT_EQ(voe_.GetAssociateSendChannel(recv_ch), default_channel);
   EXPECT_TRUE(channel_->AddSendStream(cricket::StreamParams::CreateLegacy(2)));
   EXPECT_EQ(voe_.GetAssociateSendChannel(recv_ch), default_channel);
 }
 
 TEST_F(WebRtcVoiceEngineTestFake, AssociateChannelResetUponDeleteChannnel) {
   EXPECT_TRUE(SetupEngine());
-  EXPECT_TRUE(channel_->SetOptions(options_conference_));
+  send_parameters_.options = options_conference_;
+  EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
 
   EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1)));
   int recv_ch = voe_.GetLastChannel();
 
   EXPECT_TRUE(channel_->AddSendStream(cricket::StreamParams::CreateLegacy(2)));
   int send_ch = voe_.GetLastChannel();
 
   // Manually associate |recv_ch| to |send_ch|. This test is to verify a
   // deleting logic, i.e., deleting |send_ch| will reset the associate send
   // channel of |recv_ch|.This is not a common case, since， normally, only the
@@ skipping 141 matching lines @@
 
   engine.Terminate();
 }
 
 // Test that we set our preferred codecs properly.
 TEST(WebRtcVoiceEngineTest, SetRecvCodecs) {
   cricket::WebRtcVoiceEngine engine;
   EXPECT_TRUE(engine.Init(rtc::Thread::Current()));
   rtc::scoped_ptr<webrtc::Call> call(
       webrtc::Call::Create(webrtc::Call::Config()));
-  cricket::WebRtcVoiceMediaChannel channel(&engine, call.get());
-  EXPECT_TRUE(channel.SetRecvCodecs(engine.codecs()));
+  cricket::WebRtcVoiceMediaChannel channel(&engine, cricket::AudioOptions(),
+                                           call.get());
+  cricket::AudioRecvParameters parameters;
+  parameters.codecs = engine.codecs();
+  EXPECT_TRUE(channel.SetRecvParameters(parameters));
 }