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

talk/media/webrtc/webrtcvideoengine2_unittest.cc

 /*
  * libjingle
  * Copyright 2004 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 259 matching lines @@
   FAIL() << "Video Rotation extension not in header-extension list.";
 }
 
 TEST_F(WebRtcVideoEngine2Test, CVOSetHeaderExtensionBeforeCapturer) {
   // Allocate the capturer first to prevent early destruction before channel's
   // dtor is called.
   cricket::FakeVideoCapturer capturer;
 
   cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
   encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
-  std::vector<cricket::VideoCodec> codecs;
-  codecs.push_back(kVp8Codec);
+  cricket::VideoSendParameters parameters;
+  parameters.codecs.push_back(kVp8Codec);
 
   rtc::scoped_ptr<VideoMediaChannel> channel(
-      SetUpForExternalEncoderFactory(&encoder_factory, codecs));
+      SetUpForExternalEncoderFactory(&encoder_factory, parameters.codecs));
   EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(kSsrc)));
 
   // Add CVO extension.
   const int id = 1;
-  std::vector<cricket::RtpHeaderExtension> extensions;
-  extensions.push_back(
+  parameters.extensions.push_back(
       cricket::RtpHeaderExtension(kRtpVideoRotationHeaderExtension, id));
-  EXPECT_TRUE(channel->SetSendRtpHeaderExtensions(extensions));
+  EXPECT_TRUE(channel->SetSendParameters(parameters));
 
   // Set capturer.
   EXPECT_TRUE(channel->SetCapturer(kSsrc, &capturer));
 
   // Verify capturer has turned off applying rotation.
   EXPECT_FALSE(capturer.GetApplyRotation());
 
   // Verify removing header extension turns on applying rotation.
-  extensions.clear();
-  EXPECT_TRUE(channel->SetSendRtpHeaderExtensions(extensions));
+  parameters.extensions.clear();
+  EXPECT_TRUE(channel->SetSendParameters(parameters));
   EXPECT_TRUE(capturer.GetApplyRotation());
 }
 
 TEST_F(WebRtcVideoEngine2Test, CVOSetHeaderExtensionAfterCapturer) {
   cricket::FakeVideoCapturer capturer;
 
   cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
   encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
-  std::vector<cricket::VideoCodec> codecs;
-  codecs.push_back(kVp8Codec);
+  cricket::VideoSendParameters parameters;
+  parameters.codecs.push_back(kVp8Codec);
 
   rtc::scoped_ptr<VideoMediaChannel> channel(
-      SetUpForExternalEncoderFactory(&encoder_factory, codecs));
+      SetUpForExternalEncoderFactory(&encoder_factory, parameters.codecs));
   EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(kSsrc)));
 
   // Set capturer.
   EXPECT_TRUE(channel->SetCapturer(kSsrc, &capturer));
 
   // Add CVO extension.
   const int id = 1;
-  std::vector<cricket::RtpHeaderExtension> extensions;
-  extensions.push_back(
+  parameters.extensions.push_back(
       cricket::RtpHeaderExtension(kRtpVideoRotationHeaderExtension, id));
-  EXPECT_TRUE(channel->SetSendRtpHeaderExtensions(extensions));
+  EXPECT_TRUE(channel->SetSendParameters(parameters));
 
   // Verify capturer has turned off applying rotation.
   EXPECT_FALSE(capturer.GetApplyRotation());
 
   // Verify removing header extension turns on applying rotation.
-  extensions.clear();
-  EXPECT_TRUE(channel->SetSendRtpHeaderExtensions(extensions));
+  parameters.extensions.clear();
+  EXPECT_TRUE(channel->SetSendParameters(parameters));
   EXPECT_TRUE(capturer.GetApplyRotation());
 }
 
 TEST_F(WebRtcVideoEngine2Test, SetSendFailsBeforeSettingCodecs) {
   engine_.Init();
   rtc::scoped_ptr<VideoMediaChannel> channel(
       engine_.CreateChannel(call_.get(), cricket::VideoOptions()));
 
   EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(123)));
 
   EXPECT_FALSE(channel->SetSend(true))
       << "Channel should not start without codecs.";
   EXPECT_TRUE(channel->SetSend(false))
       << "Channel should be stoppable even without set codecs.";
 }
 
 TEST_F(WebRtcVideoEngine2Test, GetStatsWithoutSendCodecsSetDoesNotCrash) {
   engine_.Init();
   rtc::scoped_ptr<VideoMediaChannel> channel(
       engine_.CreateChannel(call_.get(), cricket::VideoOptions()));
   EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(123)));
   VideoMediaInfo info;
   channel->GetStats(&info);
 }
 
 TEST_F(WebRtcVideoEngine2Test, UseExternalFactoryForVp8WhenSupported) {
   cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
   encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
-  std::vector<cricket::VideoCodec> codecs;
-  codecs.push_back(kVp8Codec);
+  cricket::VideoSendParameters parameters;
+  parameters.codecs.push_back(kVp8Codec);
 
   rtc::scoped_ptr<VideoMediaChannel> channel(
-      SetUpForExternalEncoderFactory(&encoder_factory, codecs));
+      SetUpForExternalEncoderFactory(&encoder_factory, parameters.codecs));
 
   EXPECT_TRUE(
       channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
   ASSERT_EQ(1u, encoder_factory.encoders().size());
   EXPECT_TRUE(channel->SetSend(true));
 
   cricket::FakeVideoCapturer capturer;
   EXPECT_TRUE(channel->SetCapturer(kSsrc, &capturer));
   EXPECT_EQ(cricket::CS_RUNNING,
             capturer.Start(capturer.GetSupportedFormats()->front()));
   EXPECT_TRUE(capturer.CaptureFrame());
   EXPECT_TRUE_WAIT(encoder_factory.encoders()[0]->GetNumEncodedFrames() > 0,
                    kTimeout);
 
   // Sending one frame will have reallocated the encoder since input size
   // changes from a small default to the actual frame width/height.
   int num_created_encoders = encoder_factory.GetNumCreatedEncoders();
   EXPECT_EQ(num_created_encoders, 2);
 
   // Setting codecs of the same type should not reallocate any encoders
   // (expecting a no-op).
-  EXPECT_TRUE(channel->SetSendCodecs(codecs));
+  EXPECT_TRUE(channel->SetSendParameters(parameters));
   EXPECT_EQ(num_created_encoders, encoder_factory.GetNumCreatedEncoders());
 
   // Remove stream previously added to free the external encoder instance.
   EXPECT_TRUE(channel->RemoveSendStream(kSsrc));
   EXPECT_EQ(0u, encoder_factory.encoders().size());
 }
 
 TEST_F(WebRtcVideoEngine2Test, CanConstructDecoderForVp9EncoderFactory) {
   cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
   encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP9, "VP9");
@@ skipping 125 matching lines @@
 }
 
 VideoMediaChannel* WebRtcVideoEngine2Test::SetUpForExternalEncoderFactory(
     cricket::WebRtcVideoEncoderFactory* encoder_factory,
     const std::vector<VideoCodec>& codecs) {
   engine_.SetExternalEncoderFactory(encoder_factory);
   engine_.Init();
 
   VideoMediaChannel* channel =
       engine_.CreateChannel(call_.get(), cricket::VideoOptions());
-  EXPECT_TRUE(channel->SetSendCodecs(codecs));
+  cricket::VideoSendParameters parameters;
+  parameters.codecs = codecs;
+  EXPECT_TRUE(channel->SetSendParameters(parameters));
 
   return channel;
 }
 
 VideoMediaChannel* WebRtcVideoEngine2Test::SetUpForExternalDecoderFactory(
     cricket::WebRtcVideoDecoderFactory* decoder_factory,
     const std::vector<VideoCodec>& codecs) {
   engine_.SetExternalDecoderFactory(decoder_factory);
   engine_.Init();
 
   VideoMediaChannel* channel =
       engine_.CreateChannel(call_.get(), cricket::VideoOptions());
-  EXPECT_TRUE(channel->SetRecvCodecs(codecs));
+  cricket::VideoRecvParameters parameters;
+  parameters.codecs = codecs;
+  EXPECT_TRUE(channel->SetRecvParameters(parameters));
 
   return channel;
 }
 
 TEST_F(WebRtcVideoEngine2Test, UsesSimulcastAdapterForVp8Factories) {
   cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
   encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8");
   std::vector<cricket::VideoCodec> codecs;
   codecs.push_back(kVp8Codec);
 
@@ skipping 37 matching lines @@
   std::vector<cricket::VideoCodec> codecs;
   codecs.push_back(kH264Codec);
 
   rtc::scoped_ptr<VideoMediaChannel> channel(
       SetUpForExternalEncoderFactory(&encoder_factory, codecs));
 
   EXPECT_TRUE(
       channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
   ASSERT_EQ(1u, encoder_factory.encoders().size());
 
-  codecs.clear();
-  codecs.push_back(kVp8Codec);
-  EXPECT_TRUE(channel->SetSendCodecs(codecs));
-
+  cricket::VideoSendParameters parameters;
+  parameters.codecs.push_back(kVp8Codec);
+  EXPECT_TRUE(channel->SetSendParameters(parameters));
   ASSERT_EQ(0u, encoder_factory.encoders().size());
 }
 
 TEST_F(WebRtcVideoEngine2Test,
        DontUseExternalEncoderFactoryForUnsupportedCodecs) {
   cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
   encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264, "H264");
   std::vector<cricket::VideoCodec> codecs;
   codecs.push_back(kVp8Codec);
 
@@ skipping 101 matching lines @@
   cricket::VideoCodec external_codec = codecs.back();
 
   // The external codec will appear at last.
   EXPECT_EQ("VP8", internal_codec.name);
   EXPECT_EQ("H264", external_codec.name);
 }
 
 TEST_F(WebRtcVideoEngine2Test, RegisterExternalDecodersIfSupported) {
   cricket::FakeWebRtcVideoDecoderFactory decoder_factory;
   decoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8);
-  std::vector<cricket::VideoCodec> codecs;
-  codecs.push_back(kVp8Codec);
+  cricket::VideoRecvParameters parameters;
+  parameters.codecs.push_back(kVp8Codec);
 
   rtc::scoped_ptr<VideoMediaChannel> channel(
-      SetUpForExternalDecoderFactory(&decoder_factory, codecs));
+      SetUpForExternalDecoderFactory(&decoder_factory, parameters.codecs));
 
   EXPECT_TRUE(
       channel->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc)));
   ASSERT_EQ(1u, decoder_factory.decoders().size());
 
   // Setting codecs of the same type should not reallocate the decoder.
-  EXPECT_TRUE(channel->SetRecvCodecs(codecs));
+  EXPECT_TRUE(channel->SetRecvParameters(parameters));
   EXPECT_EQ(1, decoder_factory.GetNumCreatedDecoders());
 
   // Remove stream previously added to free the external decoder instance.
   EXPECT_TRUE(channel->RemoveRecvStream(kSsrc));
   EXPECT_EQ(0u, decoder_factory.decoders().size());
 }
 
 // Verifies that we can set up decoders that are not internally supported.
 TEST_F(WebRtcVideoEngine2Test, RegisterExternalH264DecoderIfSupported) {
   // TODO(pbos): Do not assume that encoder/decoder support is symmetric. We
@@ skipping 144 matching lines @@
 
 class WebRtcVideoChannel2Test : public WebRtcVideoEngine2Test {
  public:
   WebRtcVideoChannel2Test() : last_ssrc_(0) {}
   void SetUp() override {
     fake_call_.reset(new FakeCall(webrtc::Call::Config()));
     engine_.Init();
     channel_.reset(
         engine_.CreateChannel(fake_call_.get(), cricket::VideoOptions()));
     last_ssrc_ = 123;
-    ASSERT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
+    send_parameters_.codecs = engine_.codecs();
+    recv_parameters_.codecs = engine_.codecs();
+    ASSERT_TRUE(channel_->SetSendParameters(send_parameters_));
   }
 
  protected:
   virtual std::vector<cricket::VideoCodec> GetCodecs() {
     return engine_.codecs();
   }
 
   FakeVideoSendStream* AddSendStream() {
     return AddSendStream(StreamParams::CreateLegacy(++last_ssrc_));
   }
@@ skipping 23 matching lines @@
     EXPECT_EQ(num_streams + 1, streams.size());
     return streams[streams.size() - 1];
   }
 
   void SetSendCodecsShouldWorkForBitrates(const char* min_bitrate_kbps,
                                           int expected_min_bitrate_bps,
                                           const char* start_bitrate_kbps,
                                           int expected_start_bitrate_bps,
                                           const char* max_bitrate_kbps,
                                           int expected_max_bitrate_bps) {
-    std::vector<VideoCodec> codecs;
+    auto& codecs = send_parameters_.codecs;
+    codecs.clear();
     codecs.push_back(kVp8Codec);
     codecs[0].params[kCodecParamMinBitrate] = min_bitrate_kbps;
     codecs[0].params[kCodecParamStartBitrate] = start_bitrate_kbps;
     codecs[0].params[kCodecParamMaxBitrate] = max_bitrate_kbps;
-    EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+    EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
 
     EXPECT_EQ(expected_min_bitrate_bps,
               fake_call_->GetConfig().bitrate_config.min_bitrate_bps);
     EXPECT_EQ(expected_start_bitrate_bps,
               fake_call_->GetConfig().bitrate_config.start_bitrate_bps);
     EXPECT_EQ(expected_max_bitrate_bps,
               fake_call_->GetConfig().bitrate_config.max_bitrate_bps);
   }
 
   void TestSetSendRtpHeaderExtensions(const std::string& cricket_ext,
                                       const std::string& webrtc_ext) {
     // Enable extension.
     const int id = 1;
-    std::vector<cricket::RtpHeaderExtension> extensions;
-    extensions.push_back(cricket::RtpHeaderExtension(cricket_ext, id));
-    EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions));
-
+    cricket::VideoSendParameters parameters = send_parameters_;
+    parameters.extensions.push_back(
+        cricket::RtpHeaderExtension(cricket_ext, id));
+    EXPECT_TRUE(channel_->SetSendParameters(parameters));
     FakeVideoSendStream* send_stream =
         AddSendStream(cricket::StreamParams::CreateLegacy(123));
 
     // Verify the send extension id.
     ASSERT_EQ(1u, send_stream->GetConfig().rtp.extensions.size());
     EXPECT_EQ(id, send_stream->GetConfig().rtp.extensions[0].id);
     EXPECT_EQ(webrtc_ext, send_stream->GetConfig().rtp.extensions[0].name);
     // Verify call with same set of extensions returns true.
-    EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions));
+    EXPECT_TRUE(channel_->SetSendParameters(parameters));
     // Verify that SetSendRtpHeaderExtensions doesn't implicitly add them for
     // receivers.
     EXPECT_TRUE(AddRecvStream(cricket::StreamParams::CreateLegacy(123))
                     ->GetConfig()
                     .rtp.extensions.empty());
 
     // Verify that existing RTP header extensions can be removed.
-    std::vector<cricket::RtpHeaderExtension> empty_extensions;
-    EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(empty_extensions));
+    EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
     ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size());
     send_stream = fake_call_->GetVideoSendStreams()[0];
     EXPECT_TRUE(send_stream->GetConfig().rtp.extensions.empty());
 
     // Verify that adding receive RTP header extensions adds them for existing
     // streams.
-    EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions));
+    EXPECT_TRUE(channel_->SetSendParameters(parameters));
     send_stream = fake_call_->GetVideoSendStreams()[0];
     ASSERT_EQ(1u, send_stream->GetConfig().rtp.extensions.size());
     EXPECT_EQ(id, send_stream->GetConfig().rtp.extensions[0].id);
     EXPECT_EQ(webrtc_ext, send_stream->GetConfig().rtp.extensions[0].name);
   }
 
   void TestSetRecvRtpHeaderExtensions(const std::string& cricket_ext,
                                       const std::string& webrtc_ext) {
     // Enable extension.
     const int id = 1;
-    std::vector<cricket::RtpHeaderExtension> extensions;
-    extensions.push_back(cricket::RtpHeaderExtension(cricket_ext, id));
-    EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions));
+    cricket::VideoRecvParameters parameters = recv_parameters_;
+    parameters.extensions.push_back(
+        cricket::RtpHeaderExtension(cricket_ext, id));
+    EXPECT_TRUE(channel_->SetRecvParameters(parameters));
 
     FakeVideoReceiveStream* recv_stream =
         AddRecvStream(cricket::StreamParams::CreateLegacy(123));
 
     // Verify the recv extension id.
     ASSERT_EQ(1u, recv_stream->GetConfig().rtp.extensions.size());
     EXPECT_EQ(id, recv_stream->GetConfig().rtp.extensions[0].id);
     EXPECT_EQ(webrtc_ext, recv_stream->GetConfig().rtp.extensions[0].name);
     // Verify call with same set of extensions returns true.
-    EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions));
+    EXPECT_TRUE(channel_->SetRecvParameters(parameters));
 
     // Verify that SetRecvRtpHeaderExtensions doesn't implicitly add them for
     // senders.
     EXPECT_TRUE(AddSendStream(cricket::StreamParams::CreateLegacy(123))
                     ->GetConfig()
                     .rtp.extensions.empty());
 
     // Verify that existing RTP header extensions can be removed.
-    std::vector<cricket::RtpHeaderExtension> empty_extensions;
-    EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(empty_extensions));
+    EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
     ASSERT_EQ(1u, fake_call_->GetVideoReceiveStreams().size());
     recv_stream = fake_call_->GetVideoReceiveStreams()[0];
     EXPECT_TRUE(recv_stream->GetConfig().rtp.extensions.empty());
 
     // Verify that adding receive RTP header extensions adds them for existing
     // streams.
-    EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions));
+    EXPECT_TRUE(channel_->SetRecvParameters(parameters));
     recv_stream = fake_call_->GetVideoReceiveStreams()[0];
     ASSERT_EQ(1u, recv_stream->GetConfig().rtp.extensions.size());
     EXPECT_EQ(id, recv_stream->GetConfig().rtp.extensions[0].id);
     EXPECT_EQ(webrtc_ext, recv_stream->GetConfig().rtp.extensions[0].name);
   }
 
   void TestCpuAdaptation(bool enable_overuse, bool is_screenshare);
   void TestReceiverLocalSsrcConfiguration(bool receiver_first);
   void TestReceiveUnsignalledSsrcPacket(uint8_t payload_type,
                                         bool expect_created_receive_stream);
 
-  FakeVideoSendStream* SetDenoisingOption(bool enabled) {
-    VideoOptions options;
-    options.video_noise_reduction.Set(enabled);
-    channel_->SetOptions(options);
+  FakeVideoSendStream* SetDenoisingOption(
+      const cricket::VideoSendParameters& parameters, bool enabled) {
+    cricket::VideoSendParameters params = parameters;
+    params.options.video_noise_reduction.Set(enabled);
+    channel_->SetSendParameters(params);
     return fake_call_->GetVideoSendStreams().back();
   }
 
   FakeVideoSendStream* SetUpSimulcast(bool enabled, bool with_rtx) {
     const int kRtxSsrcOffset = 0xDEADBEEF;
     last_ssrc_ += 3;
     std::vector<uint32_t> ssrcs;
     std::vector<uint32_t> rtx_ssrcs;
     uint32_t num_streams = enabled ? 3 : 1;
     for (uint32_t i = 0; i < num_streams; ++i) {
       uint32_t ssrc = last_ssrc_ + i;
       ssrcs.push_back(ssrc);
       if (with_rtx) {
         rtx_ssrcs.push_back(ssrc + kRtxSsrcOffset);
       }
     }
     if (with_rtx) {
       return AddSendStream(
           cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs));
     }
     return AddSendStream(CreateSimStreamParams("cname", ssrcs));
   }
 
   rtc::scoped_ptr<FakeCall> fake_call_;
   rtc::scoped_ptr<VideoMediaChannel> channel_;
+  cricket::VideoSendParameters send_parameters_;
+  cricket::VideoRecvParameters recv_parameters_;
   uint32 last_ssrc_;
 };
 
 TEST_F(WebRtcVideoChannel2Test, SetsSyncGroupFromSyncLabel) {
   const uint32 kVideoSsrc = 123;
   const std::string kSyncLabel = "AvSyncLabel";
 
   cricket::StreamParams sp = cricket::StreamParams::CreateLegacy(kVideoSsrc);
   sp.sync_label = kSyncLabel;
   EXPECT_TRUE(channel_->AddRecvStream(sp));
 
   EXPECT_EQ(1, fake_call_->GetVideoReceiveStreams().size());
   EXPECT_EQ(kSyncLabel,
             fake_call_->GetVideoReceiveStreams()[0]->GetConfig().sync_group)
       << "SyncGroup should be set based on sync_label";
 }
 
 TEST_F(WebRtcVideoChannel2Test, RecvStreamWithSimAndRtx) {
-  EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
+  cricket::VideoSendParameters parameters;
+  parameters.codecs = engine_.codecs();
+  EXPECT_TRUE(channel_->SetSendParameters(parameters));
   EXPECT_TRUE(channel_->SetSend(true));
-  cricket::VideoOptions options;
-  options.conference_mode.Set(true);
-  EXPECT_TRUE(channel_->SetOptions(options));
+  parameters.options.conference_mode.Set(true);
+  EXPECT_TRUE(channel_->SetSendParameters(parameters));
 
   // Send side.
   const std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs1);
   const std::vector<uint32> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
   FakeVideoSendStream* send_stream = AddSendStream(
       cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs));
 
   ASSERT_EQ(rtx_ssrcs.size(), send_stream->GetConfig().rtp.rtx.ssrcs.size());
   for (size_t i = 0; i < rtx_ssrcs.size(); ++i)
     EXPECT_EQ(rtx_ssrcs[i], send_stream->GetConfig().rtp.rtx.ssrcs[i]);
@@ skipping 66 matching lines @@
 }
 TEST_F(WebRtcVideoChannel2Test, RecvVideoRotationHeaderExtensions) {
   TestSetRecvRtpHeaderExtensions(kRtpVideoRotationHeaderExtension,
                                  webrtc::RtpExtension::kVideoRotation);
 }
 
 TEST_F(WebRtcVideoChannel2Test, IdenticalSendExtensionsDoesntRecreateStream) {
   const int kTOffsetId = 1;
   const int kAbsSendTimeId = 2;
   const int kVideoRotationId = 3;
-  std::vector<cricket::RtpHeaderExtension> extensions;
-  extensions.push_back(cricket::RtpHeaderExtension(
+  send_parameters_.extensions.push_back(cricket::RtpHeaderExtension(
       kRtpAbsoluteSenderTimeHeaderExtension, kAbsSendTimeId));
-  extensions.push_back(cricket::RtpHeaderExtension(
+  send_parameters_.extensions.push_back(cricket::RtpHeaderExtension(
       kRtpTimestampOffsetHeaderExtension, kTOffsetId));
-  extensions.push_back(cricket::RtpHeaderExtension(
+  send_parameters_.extensions.push_back(cricket::RtpHeaderExtension(
       kRtpVideoRotationHeaderExtension, kVideoRotationId));
 
-  EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions));
+  EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
   FakeVideoSendStream* send_stream =
       AddSendStream(cricket::StreamParams::CreateLegacy(123));
 
   EXPECT_EQ(1, fake_call_->GetNumCreatedSendStreams());
   ASSERT_EQ(3u, send_stream->GetConfig().rtp.extensions.size());
 
   // Setting the same extensions (even if in different order) shouldn't
   // reallocate the stream.
-  std::reverse(extensions.begin(), extensions.end());
-  EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions));
+  std::reverse(send_parameters_.extensions.begin(),
+               send_parameters_.extensions.end());
+  EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
 
   EXPECT_EQ(1, fake_call_->GetNumCreatedSendStreams());
 
   // Setting different extensions should recreate the stream.
-  extensions.resize(1);
-  EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions));
+  send_parameters_.extensions.resize(1);
+  EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
 
   EXPECT_EQ(2, fake_call_->GetNumCreatedSendStreams());
 }
 
 TEST_F(WebRtcVideoChannel2Test, IdenticalRecvExtensionsDoesntRecreateStream) {
   const int kTOffsetId = 1;
   const int kAbsSendTimeId = 2;
   const int kVideoRotationId = 3;
-  std::vector<cricket::RtpHeaderExtension> extensions;
-  extensions.push_back(cricket::RtpHeaderExtension(
+  recv_parameters_.extensions.push_back(cricket::RtpHeaderExtension(
       kRtpAbsoluteSenderTimeHeaderExtension, kAbsSendTimeId));
-  extensions.push_back(cricket::RtpHeaderExtension(
+  recv_parameters_.extensions.push_back(cricket::RtpHeaderExtension(
       kRtpTimestampOffsetHeaderExtension, kTOffsetId));
-  extensions.push_back(cricket::RtpHeaderExtension(
+  recv_parameters_.extensions.push_back(cricket::RtpHeaderExtension(
       kRtpVideoRotationHeaderExtension, kVideoRotationId));
 
-  EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions));
+  EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
   FakeVideoReceiveStream* recv_stream =
       AddRecvStream(cricket::StreamParams::CreateLegacy(123));
 
   EXPECT_EQ(1, fake_call_->GetNumCreatedReceiveStreams());
   ASSERT_EQ(3u, recv_stream->GetConfig().rtp.extensions.size());
 
   // Setting the same extensions (even if in different order) shouldn't
   // reallocate the stream.
-  std::reverse(extensions.begin(), extensions.end());
-  EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions));
+  std::reverse(recv_parameters_.extensions.begin(),
+               recv_parameters_.extensions.end());
+  EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
 
   EXPECT_EQ(1, fake_call_->GetNumCreatedReceiveStreams());
 
   // Setting different extensions should recreate the stream.
-  extensions.resize(1);
-  EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions));
+  recv_parameters_.extensions.resize(1);
+  EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
 
   EXPECT_EQ(2, fake_call_->GetNumCreatedReceiveStreams());
 }
 
 TEST_F(WebRtcVideoChannel2Test,
        SetSendRtpHeaderExtensionsExcludeUnsupportedExtensions) {
   const int kUnsupportedId = 1;
   const int kTOffsetId = 2;
 
-  std::vector<cricket::RtpHeaderExtension> extensions;
-  extensions.push_back(
+  send_parameters_.extensions.push_back(
       cricket::RtpHeaderExtension(kUnsupportedExtensionName, kUnsupportedId));
-  extensions.push_back(
+  send_parameters_.extensions.push_back(
       cricket::RtpHeaderExtension(webrtc::RtpExtension::kTOffset, kTOffsetId));
-  EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions));
+  EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
   FakeVideoSendStream* send_stream =
       AddSendStream(cricket::StreamParams::CreateLegacy(123));
 
   // Only timestamp offset extension is set to send stream,
   // unsupported rtp extension is ignored.
   ASSERT_EQ(1u, send_stream->GetConfig().rtp.extensions.size());
   EXPECT_STREQ(webrtc::RtpExtension::kTOffset,
                send_stream->GetConfig().rtp.extensions[0].name.c_str());
 }
 
 TEST_F(WebRtcVideoChannel2Test,
        SetRecvRtpHeaderExtensionsExcludeUnsupportedExtensions) {
   const int kUnsupportedId = 1;
   const int kTOffsetId = 2;
 
-  std::vector<cricket::RtpHeaderExtension> extensions;
-  extensions.push_back(
+  recv_parameters_.extensions.push_back(
       cricket::RtpHeaderExtension(kUnsupportedExtensionName, kUnsupportedId));
-  extensions.push_back(
+  recv_parameters_.extensions.push_back(
       cricket::RtpHeaderExtension(webrtc::RtpExtension::kTOffset, kTOffsetId));
-  EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions));
+  EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
   FakeVideoReceiveStream* recv_stream =
       AddRecvStream(cricket::StreamParams::CreateLegacy(123));
 
   // Only timestamp offset extension is set to receive stream,
   // unsupported rtp extension is ignored.
   ASSERT_EQ(1u, recv_stream->GetConfig().rtp.extensions.size());
   EXPECT_STREQ(webrtc::RtpExtension::kTOffset,
                recv_stream->GetConfig().rtp.extensions[0].name.c_str());
 }
 
 TEST_F(WebRtcVideoChannel2Test, SetSendRtpHeaderExtensionsRejectsIncorrectIds) {
   const int kIncorrectIds[] = {-2, -1, 0, 15, 16};
   for (size_t i = 0; i < arraysize(kIncorrectIds); ++i) {
-    std::vector<cricket::RtpHeaderExtension> extensions;
-    extensions.push_back(cricket::RtpHeaderExtension(
+    send_parameters_.extensions.push_back(cricket::RtpHeaderExtension(
         webrtc::RtpExtension::kTOffset, kIncorrectIds[i]));
-    EXPECT_FALSE(channel_->SetSendRtpHeaderExtensions(extensions))
+    EXPECT_FALSE(channel_->SetSendParameters(send_parameters_))
         << "Bad extension id '" << kIncorrectIds[i] << "' accepted.";
   }
 }
 
 TEST_F(WebRtcVideoChannel2Test, SetRecvRtpHeaderExtensionsRejectsIncorrectIds) {
   const int kIncorrectIds[] = {-2, -1, 0, 15, 16};
   for (size_t i = 0; i < arraysize(kIncorrectIds); ++i) {
-    std::vector<cricket::RtpHeaderExtension> extensions;
-    extensions.push_back(cricket::RtpHeaderExtension(
+    recv_parameters_.extensions.push_back(cricket::RtpHeaderExtension(
         webrtc::RtpExtension::kTOffset, kIncorrectIds[i]));
-    EXPECT_FALSE(channel_->SetRecvRtpHeaderExtensions(extensions))
+    EXPECT_FALSE(channel_->SetRecvParameters(recv_parameters_))
         << "Bad extension id '" << kIncorrectIds[i] << "' accepted.";
   }
 }
 
 TEST_F(WebRtcVideoChannel2Test, SetSendRtpHeaderExtensionsRejectsDuplicateIds) {
   const int id = 1;
-  std::vector<cricket::RtpHeaderExtension> extensions;
-  extensions.push_back(
+  send_parameters_.extensions.push_back(
       cricket::RtpHeaderExtension(webrtc::RtpExtension::kTOffset, id));
-  extensions.push_back(
+  send_parameters_.extensions.push_back(
       cricket::RtpHeaderExtension(kRtpAbsoluteSenderTimeHeaderExtension, id));
-  EXPECT_FALSE(channel_->SetSendRtpHeaderExtensions(extensions));
+  EXPECT_FALSE(channel_->SetSendParameters(send_parameters_));
 
   // Duplicate entries are also not supported.
-  extensions.clear();
-  extensions.push_back(
+  send_parameters_.extensions.clear();
+  send_parameters_.extensions.push_back(
       cricket::RtpHeaderExtension(webrtc::RtpExtension::kTOffset, id));
-  extensions.push_back(extensions.back());
-  EXPECT_FALSE(channel_->SetSendRtpHeaderExtensions(extensions));
+  send_parameters_.extensions.push_back(send_parameters_.extensions.back());
+  EXPECT_FALSE(channel_->SetSendParameters(send_parameters_));
 }
 
 TEST_F(WebRtcVideoChannel2Test, SetRecvRtpHeaderExtensionsRejectsDuplicateIds) {
   const int id = 1;
-  std::vector<cricket::RtpHeaderExtension> extensions;
-  extensions.push_back(
+  recv_parameters_.extensions.push_back(
       cricket::RtpHeaderExtension(webrtc::RtpExtension::kTOffset, id));
-  extensions.push_back(
+  recv_parameters_.extensions.push_back(
       cricket::RtpHeaderExtension(kRtpAbsoluteSenderTimeHeaderExtension, id));
-  EXPECT_FALSE(channel_->SetRecvRtpHeaderExtensions(extensions));
+  EXPECT_FALSE(channel_->SetRecvParameters(recv_parameters_));
 
   // Duplicate entries are also not supported.
-  extensions.clear();
-  extensions.push_back(
+  recv_parameters_.extensions.clear();
+  recv_parameters_.extensions.push_back(
       cricket::RtpHeaderExtension(webrtc::RtpExtension::kTOffset, id));
-  extensions.push_back(extensions.back());
-  EXPECT_FALSE(channel_->SetRecvRtpHeaderExtensions(extensions));
+  recv_parameters_.extensions.push_back(recv_parameters_.extensions.back());
+  EXPECT_FALSE(channel_->SetRecvParameters(recv_parameters_));
 }
 
 TEST_F(WebRtcVideoChannel2Test, DISABLED_LeakyBucketTest) {
   FAIL() << "Not implemented.";  // TODO(pbos): Implement.
 }
 
 TEST_F(WebRtcVideoChannel2Test, DISABLED_BufferedModeLatency) {
   FAIL() << "Not implemented.";  // TODO(pbos): Implement.
 }
 
@@ skipping 14 matching lines @@
 TEST_F(WebRtcVideoChannel2Test, RembIsEnabledByDefault) {
   FakeVideoReceiveStream* stream = AddRecvStream();
   EXPECT_TRUE(stream->GetConfig().rtp.remb);
 }
 
 TEST_F(WebRtcVideoChannel2Test, RembCanBeEnabledAndDisabled) {
   FakeVideoReceiveStream* stream = AddRecvStream();
   EXPECT_TRUE(stream->GetConfig().rtp.remb);
 
   // Verify that REMB is turned off when send(!) codecs without REMB are set.
-  std::vector<VideoCodec> codecs;
-  codecs.push_back(kVp8Codec);
-  EXPECT_TRUE(codecs[0].feedback_params.params().empty());
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  cricket::VideoSendParameters parameters;
+  parameters.codecs.push_back(kVp8Codec);
+  EXPECT_TRUE(parameters.codecs[0].feedback_params.params().empty());
+  EXPECT_TRUE(channel_->SetSendParameters(parameters));
   stream = fake_call_->GetVideoReceiveStreams()[0];
   EXPECT_FALSE(stream->GetConfig().rtp.remb);
 
   // Verify that REMB is turned on when setting default codecs since the
   // default codecs have REMB enabled.
-  EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
+  parameters.codecs = engine_.codecs();
+  EXPECT_TRUE(channel_->SetSendParameters(parameters));
   stream = fake_call_->GetVideoReceiveStreams()[0];
   EXPECT_TRUE(stream->GetConfig().rtp.remb);
 }
 
 TEST_F(WebRtcVideoChannel2Test, NackIsEnabledByDefault) {
   VerifyCodecHasDefaultFeedbackParams(default_codec_);
 
-  EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
+  cricket::VideoSendParameters parameters;
+  parameters.codecs = engine_.codecs();
+  EXPECT_TRUE(channel_->SetSendParameters(parameters));
   EXPECT_TRUE(channel_->SetSend(true));
 
   // Send side.
   FakeVideoSendStream* send_stream =
       AddSendStream(cricket::StreamParams::CreateLegacy(1));
   EXPECT_GT(send_stream->GetConfig().rtp.nack.rtp_history_ms, 0);
 
   // Receiver side.
   FakeVideoReceiveStream* recv_stream =
       AddRecvStream(cricket::StreamParams::CreateLegacy(1));
   EXPECT_GT(recv_stream->GetConfig().rtp.nack.rtp_history_ms, 0);
 
   // Nack history size should match between sender and receiver.
   EXPECT_EQ(send_stream->GetConfig().rtp.nack.rtp_history_ms,
             recv_stream->GetConfig().rtp.nack.rtp_history_ms);
 }
 
 TEST_F(WebRtcVideoChannel2Test, NackCanBeEnabledAndDisabled) {
   FakeVideoSendStream* send_stream = AddSendStream();
   FakeVideoReceiveStream* recv_stream = AddRecvStream();
 
   EXPECT_GT(recv_stream->GetConfig().rtp.nack.rtp_history_ms, 0);
   EXPECT_GT(send_stream->GetConfig().rtp.nack.rtp_history_ms, 0);
 
   // Verify that NACK is turned off when send(!) codecs without NACK are set.
-  std::vector<VideoCodec> codecs;
-  codecs.push_back(kVp8Codec);
-  EXPECT_TRUE(codecs[0].feedback_params.params().empty());
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  cricket::VideoSendParameters parameters;
+  parameters.codecs.push_back(kVp8Codec);
+  EXPECT_TRUE(parameters.codecs[0].feedback_params.params().empty());
+  EXPECT_TRUE(channel_->SetSendParameters(parameters));
   recv_stream = fake_call_->GetVideoReceiveStreams()[0];
   EXPECT_EQ(0, recv_stream->GetConfig().rtp.nack.rtp_history_ms);
   send_stream = fake_call_->GetVideoSendStreams()[0];
   EXPECT_EQ(0, send_stream->GetConfig().rtp.nack.rtp_history_ms);
 
   // Verify that NACK is turned on when setting default codecs since the
   // default codecs have NACK enabled.
-  EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
+  parameters.codecs = engine_.codecs();
+  EXPECT_TRUE(channel_->SetSendParameters(parameters));
   recv_stream = fake_call_->GetVideoReceiveStreams()[0];
   EXPECT_GT(recv_stream->GetConfig().rtp.nack.rtp_history_ms, 0);
   send_stream = fake_call_->GetVideoSendStreams()[0];
   EXPECT_GT(send_stream->GetConfig().rtp.nack.rtp_history_ms, 0);
 }
 
 TEST_F(WebRtcVideoChannel2Test, DISABLED_VideoProtectionInterop) {
   FAIL() << "Not implemented.";  // TODO(pbos): Implement.
 }
 
@@ skipping 25 matching lines @@
   FAIL() << "Not implemented.";  // TODO(pbos): Implement.
 }
 
 TEST_F(WebRtcVideoChannel2Test, DISABLED_SetBandwidthInConference) {
   FAIL() << "Not implemented.";  // TODO(pbos): Implement.
 }
 
 TEST_F(WebRtcVideoChannel2Test, UsesCorrectSettingsForScreencast) {
   static const int kScreenshareMinBitrateKbps = 800;
   cricket::VideoCodec codec = kVp8Codec360p;
-  std::vector<cricket::VideoCodec> codecs;
-  codecs.push_back(codec);
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
-  VideoOptions options;
-  options.screencast_min_bitrate.Set(kScreenshareMinBitrateKbps);
-  channel_->SetOptions(options);
+  cricket::VideoSendParameters parameters;
+  parameters.codecs.push_back(codec);
+  parameters.options.screencast_min_bitrate.Set(kScreenshareMinBitrateKbps);
+  EXPECT_TRUE(channel_->SetSendParameters(parameters));
 
   AddSendStream();
 
   cricket::FakeVideoCapturer capturer;
   capturer.SetScreencast(false);
   EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
   cricket::VideoFormat capture_format_hd =
       capturer.GetSupportedFormats()->front();
   EXPECT_EQ(1280, capture_format_hd.width);
   EXPECT_EQ(720, capture_format_hd.height);
@@ skipping 32 matching lines @@
   EXPECT_EQ(capture_format_hd.height, encoder_config.streams.front().height);
   EXPECT_TRUE(encoder_config.streams[0].temporal_layer_thresholds_bps.empty());
 
   EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, NULL));
 }
 
 TEST_F(WebRtcVideoChannel2Test,
        ConferenceModeScreencastConfiguresTemporalLayer) {
   static const int kConferenceScreencastTemporalBitrateBps =
       ScreenshareLayerConfig::GetDefault().tl0_bitrate_kbps * 1000;
-  VideoOptions options;
-  options.conference_mode.Set(true);
-  channel_->SetOptions(options);
+  send_parameters_.options.conference_mode.Set(true);
+  channel_->SetSendParameters(send_parameters_);
 
   AddSendStream();
 
   cricket::FakeVideoCapturer capturer;
   capturer.SetScreencast(true);
   EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
   cricket::VideoFormat capture_format_hd =
       capturer.GetSupportedFormats()->front();
   EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(capture_format_hd));
 
@@ skipping 25 matching lines @@
        DISABLED_SetSendSsrcAfterCreatingReceiveChannel) {
   FAIL() << "Not implemented.";  // TODO(pbos): Implement.
 }
 
 TEST_F(WebRtcVideoChannel2Test, SuspendBelowMinBitrateDisabledByDefault) {
   FakeVideoSendStream* stream = AddSendStream();
   EXPECT_FALSE(stream->GetConfig().suspend_below_min_bitrate);
 }
 
 TEST_F(WebRtcVideoChannel2Test, SetOptionsWithSuspendBelowMinBitrate) {
-  VideoOptions options;
-  options.suspend_below_min_bitrate.Set(true);
-  channel_->SetOptions(options);
+  send_parameters_.options.suspend_below_min_bitrate.Set(true);
+  channel_->SetSendParameters(send_parameters_);
 
   FakeVideoSendStream* stream = AddSendStream();
   EXPECT_TRUE(stream->GetConfig().suspend_below_min_bitrate);
 
-  options.suspend_below_min_bitrate.Set(false);
-  channel_->SetOptions(options);
+  send_parameters_.options.suspend_below_min_bitrate.Set(false);
+  channel_->SetSendParameters(send_parameters_);
 
   stream = fake_call_->GetVideoSendStreams()[0];
   EXPECT_FALSE(stream->GetConfig().suspend_below_min_bitrate);
 }
 
 TEST_F(WebRtcVideoChannel2Test, Vp8DenoisingEnabledByDefault) {
   FakeVideoSendStream* stream = AddSendStream();
   webrtc::VideoCodecVP8 vp8_settings;
   ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
   EXPECT_TRUE(vp8_settings.denoisingOn);
 }
 
 TEST_F(WebRtcVideoChannel2Test, VerifyVp8SpecificSettings) {
-  std::vector<cricket::VideoCodec> codecs;
-  codecs.push_back(kVp8Codec720p);
-  ASSERT_TRUE(channel_->SetSendCodecs(codecs));
+  cricket::VideoSendParameters parameters;
+  parameters.codecs.push_back(kVp8Codec720p);
+  ASSERT_TRUE(channel_->SetSendParameters(parameters));
 
   // Single-stream settings should apply with RTX as well (verifies that we
   // check number of regular SSRCs and not StreamParams::ssrcs which contains
   // both RTX and regular SSRCs).
   FakeVideoSendStream* stream = SetUpSimulcast(false, true);
 
   cricket::FakeVideoCapturer capturer;
   capturer.SetScreencast(false);
   EXPECT_EQ(cricket::CS_RUNNING,
             capturer.Start(capturer.GetSupportedFormats()->front()));
   EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
   channel_->SetSend(true);
 
   EXPECT_TRUE(capturer.CaptureFrame());
 
-  stream = SetDenoisingOption(false);
+  stream = SetDenoisingOption(parameters, false);
 
   webrtc::VideoCodecVP8 vp8_settings;
   ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
   EXPECT_FALSE(vp8_settings.denoisingOn);
   EXPECT_TRUE(vp8_settings.automaticResizeOn);
   EXPECT_TRUE(vp8_settings.frameDroppingOn);
 
-  stream = SetDenoisingOption(true);
+  stream = SetDenoisingOption(parameters, true);
 
   ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
   EXPECT_TRUE(vp8_settings.denoisingOn);
   EXPECT_TRUE(vp8_settings.automaticResizeOn);
   EXPECT_TRUE(vp8_settings.frameDroppingOn);
 
   EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, NULL));
   stream = SetUpSimulcast(true, false);
   EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
   channel_->SetSend(true);
   EXPECT_TRUE(capturer.CaptureFrame());
 
   EXPECT_EQ(3, stream->GetVideoStreams().size());
   ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
   // Autmatic resize off when using simulcast.
   EXPECT_FALSE(vp8_settings.automaticResizeOn);
   EXPECT_TRUE(vp8_settings.frameDroppingOn);
 
   // In screen-share mode, denoising is forced off and simulcast disabled.
   capturer.SetScreencast(true);
   EXPECT_TRUE(capturer.CaptureFrame());
-  stream = SetDenoisingOption(false);
+  stream = SetDenoisingOption(parameters, false);
 
   EXPECT_EQ(1, stream->GetVideoStreams().size());
   ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
   EXPECT_FALSE(vp8_settings.denoisingOn);
   // Resizing and frame dropping always off for screen sharing.
   EXPECT_FALSE(vp8_settings.automaticResizeOn);
   EXPECT_FALSE(vp8_settings.frameDroppingOn);
 
-  stream = SetDenoisingOption(true);
+  stream = SetDenoisingOption(parameters, true);
 
   ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
   EXPECT_FALSE(vp8_settings.denoisingOn);
   EXPECT_FALSE(vp8_settings.automaticResizeOn);
   EXPECT_FALSE(vp8_settings.frameDroppingOn);
 
   EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, NULL));
 }
 
 class Vp9SettingsTest : public WebRtcVideoChannel2Test {
  public:
   Vp9SettingsTest() : WebRtcVideoChannel2Test() {
     encoder_factory_.AddSupportedVideoCodecType(webrtc::kVideoCodecVP9, "VP9");
   }
   virtual ~Vp9SettingsTest() {}
 
  protected:
   void SetUp() override {
     engine_.SetExternalEncoderFactory(&encoder_factory_);
 
     WebRtcVideoChannel2Test::SetUp();
   }
 
   void TearDown() override {
     // Remove references to encoder_factory_ since this will be destroyed
     // before channel_ and engine_.
-    ASSERT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
+    ASSERT_TRUE(channel_->SetSendParameters(send_parameters_));
   }
 
   cricket::FakeWebRtcVideoEncoderFactory encoder_factory_;
 };
 
 TEST_F(Vp9SettingsTest, VerifyVp9SpecificSettings) {
-  std::vector<cricket::VideoCodec> codecs;
-  codecs.push_back(kVp9Codec);
-  ASSERT_TRUE(channel_->SetSendCodecs(codecs));
+  cricket::VideoSendParameters parameters;
+  parameters.codecs.push_back(kVp9Codec);
+  ASSERT_TRUE(channel_->SetSendParameters(parameters));
 
   FakeVideoSendStream* stream = SetUpSimulcast(false, false);
 
   cricket::FakeVideoCapturer capturer;
   capturer.SetScreencast(false);
   EXPECT_EQ(cricket::CS_RUNNING,
             capturer.Start(capturer.GetSupportedFormats()->front()));
   EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
   channel_->SetSend(true);
 
   EXPECT_TRUE(capturer.CaptureFrame());
 
-  stream = SetDenoisingOption(false);
+  stream = SetDenoisingOption(parameters, false);
 
   webrtc::VideoCodecVP9 vp9_settings;
   ASSERT_TRUE(stream->GetVp9Settings(&vp9_settings)) << "No VP9 config set.";
   EXPECT_FALSE(vp9_settings.denoisingOn);
   // Frame dropping always on for real time video.
   EXPECT_TRUE(vp9_settings.frameDroppingOn);
 
-  stream = SetDenoisingOption(true);
+  stream = SetDenoisingOption(parameters, true);
 
   ASSERT_TRUE(stream->GetVp9Settings(&vp9_settings)) << "No VP9 config set.";
   EXPECT_TRUE(vp9_settings.denoisingOn);
   EXPECT_TRUE(vp9_settings.frameDroppingOn);
 
   // In screen-share mode, denoising is forced off.
   capturer.SetScreencast(true);
   EXPECT_TRUE(capturer.CaptureFrame());
-  stream = SetDenoisingOption(false);
+  stream = SetDenoisingOption(parameters, false);
 
   ASSERT_TRUE(stream->GetVp9Settings(&vp9_settings)) << "No VP9 config set.";
   EXPECT_FALSE(vp9_settings.denoisingOn);
   // Frame dropping always off for screen sharing.
   EXPECT_FALSE(vp9_settings.frameDroppingOn);
 
-  stream = SetDenoisingOption(false);
+  stream = SetDenoisingOption(parameters, false);
 
   ASSERT_TRUE(stream->GetVp9Settings(&vp9_settings)) << "No VP9 config set.";
   EXPECT_FALSE(vp9_settings.denoisingOn);
   EXPECT_FALSE(vp9_settings.frameDroppingOn);
 
   EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, NULL));
 }
 
 TEST_F(WebRtcVideoChannel2Test, DISABLED_MultipleSendStreamsWithOneCapturer) {
   FAIL() << "Not implemented.";  // TODO(pbos): Implement.
@@ skipping 11 matching lines @@
   TestCpuAdaptation(false, false);
 }
 
 TEST_F(WebRtcVideoChannel2Test, DoesNotAdaptOnOveruseWhenScreensharing) {
   TestCpuAdaptation(true, true);
 }
 
 void WebRtcVideoChannel2Test::TestCpuAdaptation(bool enable_overuse,
                                                 bool is_screenshare) {
   cricket::VideoCodec codec = kVp8Codec720p;
-  std::vector<cricket::VideoCodec> codecs;
-  codecs.push_back(codec);
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
-
+  cricket::VideoSendParameters parameters;
+  parameters.codecs.push_back(codec);
   if (!enable_overuse) {
-    VideoOptions options;
-    options.cpu_overuse_detection.Set(false);
-    channel_->SetOptions(options);
+    parameters.options.cpu_overuse_detection.Set(false);
   }
+  EXPECT_TRUE(channel_->SetSendParameters(parameters));
 
   AddSendStream();
 
   cricket::FakeVideoCapturer capturer;
   capturer.SetScreencast(is_screenshare);
   EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
   EXPECT_EQ(cricket::CS_RUNNING,
             capturer.Start(capturer.GetSupportedFormats()->front()));
 
   EXPECT_TRUE(channel_->SetSend(true));
@@ skipping 27 matching lines @@
   EXPECT_EQ(codec.height, send_stream->GetLastHeight());
 
   EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, NULL));
 }
 
 TEST_F(WebRtcVideoChannel2Test, EstimatesNtpStartTimeAndElapsedTimeCorrectly) {
   // Start at last timestamp to verify that wraparounds are estimated correctly.
   static const uint32_t kInitialTimestamp = 0xFFFFFFFFu;
   static const int64_t kInitialNtpTimeMs = 1247891230;
   static const int kFrameOffsetMs = 20;
-  EXPECT_TRUE(channel_->SetRecvCodecs(engine_.codecs()));
+  EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
 
   FakeVideoReceiveStream* stream = AddRecvStream();
   cricket::FakeVideoRenderer renderer;
   EXPECT_TRUE(channel_->SetRenderer(last_ssrc_, &renderer));
   EXPECT_TRUE(channel_->SetRender(true));
 
   webrtc::VideoFrame video_frame;
   CreateBlackFrame(&video_frame, 4, 4);
   video_frame.set_timestamp(kInitialTimestamp);
   // Initial NTP time is not available on the first frame, but should still be
@@ skipping 15 matching lines @@
             renderer.last_frame_elapsed_time_ns());
 
   // Verify that NTP time has been correctly deduced.
   cricket::VideoMediaInfo info;
   ASSERT_TRUE(channel_->GetStats(&info));
   ASSERT_EQ(1u, info.receivers.size());
   EXPECT_EQ(kInitialNtpTimeMs, info.receivers[0].capture_start_ntp_time_ms);
 }
 
 TEST_F(WebRtcVideoChannel2Test, SetDefaultSendCodecs) {
-  ASSERT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
+  ASSERT_TRUE(channel_->SetSendParameters(send_parameters_));
 
   VideoCodec codec;
   EXPECT_TRUE(channel_->GetSendCodec(&codec));
   EXPECT_TRUE(codec.Matches(engine_.codecs()[0]));
 
   // Using a RTX setup to verify that the default RTX payload type is good.
   const std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs1);
   const std::vector<uint32> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
   FakeVideoSendStream* stream = AddSendStream(
       cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs));
   webrtc::VideoSendStream::Config config = stream->GetConfig();
 
   // Make sure NACK and FEC are enabled on the correct payload types.
   EXPECT_EQ(1000, config.rtp.nack.rtp_history_ms);
   EXPECT_EQ(default_ulpfec_codec_.id, config.rtp.fec.ulpfec_payload_type);
   EXPECT_EQ(default_red_codec_.id, config.rtp.fec.red_payload_type);
 
   EXPECT_EQ(1u, config.rtp.rtx.ssrcs.size());
   EXPECT_EQ(kRtxSsrcs1[0], config.rtp.rtx.ssrcs[0]);
   VerifySendStreamHasRtxTypes(config, default_apt_rtx_types_);
   // TODO(juberti): Check RTCP, PLI, TMMBR.
 }
 
 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithoutFec) {
-  std::vector<VideoCodec> codecs;
-  codecs.push_back(kVp8Codec);
-  ASSERT_TRUE(channel_->SetSendCodecs(codecs));
+  cricket::VideoSendParameters parameters;
+  parameters.codecs.push_back(kVp8Codec);
+  ASSERT_TRUE(channel_->SetSendParameters(parameters));
 
   FakeVideoSendStream* stream = AddSendStream();
   webrtc::VideoSendStream::Config config = stream->GetConfig();
 
   EXPECT_EQ(-1, config.rtp.fec.ulpfec_payload_type);
   EXPECT_EQ(-1, config.rtp.fec.red_payload_type);
 }
 
 TEST_F(WebRtcVideoChannel2Test,
        SetSendCodecRejectsRtxWithoutAssociatedPayloadType) {
-  std::vector<VideoCodec> codecs;
+  cricket::VideoSendParameters parameters;
   cricket::VideoCodec rtx_codec(96, "rtx", 0, 0, 0, 0);
-  codecs.push_back(rtx_codec);
-  EXPECT_FALSE(channel_->SetSendCodecs(codecs))
+  parameters.codecs.push_back(rtx_codec);
+  EXPECT_FALSE(channel_->SetSendParameters(parameters))
       << "RTX codec without associated payload type should be rejected.";
 }
 
 TEST_F(WebRtcVideoChannel2Test,
        SetSendCodecRejectsRtxWithoutMatchingVideoCodec) {
-  std::vector<VideoCodec> codecs;
+  cricket::VideoSendParameters parameters;
   cricket::VideoCodec rtx_codec =
       cricket::VideoCodec::CreateRtxCodec(96, kVp8Codec.id);
-  codecs.push_back(kVp8Codec);
-  codecs.push_back(rtx_codec);
-  ASSERT_TRUE(channel_->SetSendCodecs(codecs));
+  parameters.codecs.push_back(kVp8Codec);
+  parameters.codecs.push_back(rtx_codec);
+  ASSERT_TRUE(channel_->SetSendParameters(parameters));
 
   cricket::VideoCodec rtx_codec2 =
       cricket::VideoCodec::CreateRtxCodec(96, kVp8Codec.id + 1);
-  codecs.pop_back();
-  codecs.push_back(rtx_codec2);
-  EXPECT_FALSE(channel_->SetSendCodecs(codecs))
+  parameters.codecs.pop_back();
+  parameters.codecs.push_back(rtx_codec2);
+  EXPECT_FALSE(channel_->SetSendParameters(parameters))
       << "RTX without matching video codec should be rejected.";
 }
 
 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithoutFecDisablesFec) {
-  std::vector<VideoCodec> codecs;
-  codecs.push_back(kVp8Codec);
-  codecs.push_back(kUlpfecCodec);
-  ASSERT_TRUE(channel_->SetSendCodecs(codecs));
+  cricket::VideoSendParameters parameters;
+  parameters.codecs.push_back(kVp8Codec);
+  parameters.codecs.push_back(kUlpfecCodec);
+  ASSERT_TRUE(channel_->SetSendParameters(parameters));
 
   FakeVideoSendStream* stream = AddSendStream();
   webrtc::VideoSendStream::Config config = stream->GetConfig();
 
   EXPECT_EQ(kUlpfecCodec.id, config.rtp.fec.ulpfec_payload_type);
 
-  codecs.pop_back();
-  ASSERT_TRUE(channel_->SetSendCodecs(codecs));
+  parameters.codecs.pop_back();
+  ASSERT_TRUE(channel_->SetSendParameters(parameters));
   stream = fake_call_->GetVideoSendStreams()[0];
   ASSERT_TRUE(stream != NULL);
   config = stream->GetConfig();
   EXPECT_EQ(-1, config.rtp.fec.ulpfec_payload_type)
       << "SetSendCodec without FEC should disable current FEC.";
 }
 
 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsChangesExistingStreams) {
-  std::vector<VideoCodec> codecs;
-  codecs.push_back(kVp8Codec720p);
-  ASSERT_TRUE(channel_->SetSendCodecs(codecs));
+  cricket::VideoSendParameters parameters;
+  parameters.codecs.push_back(kVp8Codec720p);
+  ASSERT_TRUE(channel_->SetSendParameters(parameters));
   channel_->SetSend(true);
 
   FakeVideoSendStream* stream = AddSendStream();
 
   cricket::FakeVideoCapturer capturer;
   EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
   EXPECT_EQ(cricket::CS_RUNNING,
             capturer.Start(capturer.GetSupportedFormats()->front()));
   EXPECT_TRUE(capturer.CaptureFrame());
 
   std::vector<webrtc::VideoStream> streams = stream->GetVideoStreams();
   EXPECT_EQ(kVp8Codec720p.width, streams[0].width);
   EXPECT_EQ(kVp8Codec720p.height, streams[0].height);
 
-  codecs.clear();
-  codecs.push_back(kVp8Codec360p);
-  ASSERT_TRUE(channel_->SetSendCodecs(codecs));
+  parameters.codecs.clear();
+  parameters.codecs.push_back(kVp8Codec360p);
+  ASSERT_TRUE(channel_->SetSendParameters(parameters));
   streams = fake_call_->GetVideoSendStreams()[0]->GetVideoStreams();
   EXPECT_EQ(kVp8Codec360p.width, streams[0].width);
   EXPECT_EQ(kVp8Codec360p.height, streams[0].height);
   EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, NULL));
 }
 
 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithBitrates) {
   SetSendCodecsShouldWorkForBitrates("100", 100000, "150", 150000, "200",
                                      200000);
 }
 
 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithHighMaxBitrate) {
   SetSendCodecsShouldWorkForBitrates("", 0, "", -1, "10000", 10000000);
   std::vector<webrtc::VideoStream> streams = AddSendStream()->GetVideoStreams();
   ASSERT_EQ(1u, streams.size());
   EXPECT_EQ(10000000, streams[0].max_bitrate_bps);
 }
 
 TEST_F(WebRtcVideoChannel2Test,
        SetSendCodecsWithoutBitratesUsesCorrectDefaults) {
   SetSendCodecsShouldWorkForBitrates(
       "", 0, "", -1, "", -1);
 }
 
 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsCapsMinAndStartBitrate) {
   SetSendCodecsShouldWorkForBitrates("-1", 0, "-100", -1, "", -1);
 }
 
 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectsMaxLessThanMinBitrate) {
-  std::vector<VideoCodec> video_codecs = engine_.codecs();
-  video_codecs[0].params[kCodecParamMinBitrate] = "300";
-  video_codecs[0].params[kCodecParamMaxBitrate] = "200";
-  EXPECT_FALSE(channel_->SetSendCodecs(video_codecs));
+  send_parameters_.codecs[0].params[kCodecParamMinBitrate] = "300";
+  send_parameters_.codecs[0].params[kCodecParamMaxBitrate] = "200";
+  EXPECT_FALSE(channel_->SetSendParameters(send_parameters_));
 }
 
 TEST_F(WebRtcVideoChannel2Test,
        SetMaxSendBandwidthShouldPreserveOtherBitrates) {
   SetSendCodecsShouldWorkForBitrates("100", 100000, "150", 150000, "200",
                                      200000);
-  channel_->SetMaxSendBandwidth(300000);
+  send_parameters_.max_bandwidth_bps = 300000;
+  EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
   EXPECT_EQ(100000, fake_call_->GetConfig().bitrate_config.min_bitrate_bps)
       << "Setting max bitrate should keep previous min bitrate.";
   EXPECT_EQ(-1, fake_call_->GetConfig().bitrate_config.start_bitrate_bps)
       << "Setting max bitrate should not reset start bitrate.";
   EXPECT_EQ(300000, fake_call_->GetConfig().bitrate_config.max_bitrate_bps);
 }
 
 TEST_F(WebRtcVideoChannel2Test, SetMaxSendBandwidthShouldBeRemovable) {
-  channel_->SetMaxSendBandwidth(300000);
+  send_parameters_.max_bandwidth_bps = 300000;
+  EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
   EXPECT_EQ(300000, fake_call_->GetConfig().bitrate_config.max_bitrate_bps);
   // <= 0 means disable (infinite) max bitrate.
-  channel_->SetMaxSendBandwidth(0);
+  send_parameters_.max_bandwidth_bps = 0;
+  EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
   EXPECT_EQ(-1, fake_call_->GetConfig().bitrate_config.max_bitrate_bps)
       << "Setting zero max bitrate did not reset start bitrate.";
 }
 
 TEST_F(WebRtcVideoChannel2Test, SetMaxSendBitrateCanIncreaseSenderBitrate) {
-  std::vector<VideoCodec> codecs;
-  codecs.push_back(kVp8Codec720p);
-  ASSERT_TRUE(channel_->SetSendCodecs(codecs));
+  cricket::VideoSendParameters parameters;
+  parameters.codecs.push_back(kVp8Codec720p);
+  ASSERT_TRUE(channel_->SetSendParameters(parameters));
   channel_->SetSend(true);
 
   FakeVideoSendStream* stream = AddSendStream();
 
   std::vector<webrtc::VideoStream> streams = stream->GetVideoStreams();
   int initial_max_bitrate_bps = streams[0].max_bitrate_bps;
   EXPECT_GT(initial_max_bitrate_bps, 0);
 
-  EXPECT_TRUE(channel_->SetMaxSendBandwidth(initial_max_bitrate_bps * 2));
+  parameters.max_bandwidth_bps = initial_max_bitrate_bps * 2;
+  EXPECT_TRUE(channel_->SetSendParameters(parameters));
   streams = stream->GetVideoStreams();
   EXPECT_EQ(initial_max_bitrate_bps * 2, streams[0].max_bitrate_bps);
 }
 
 TEST_F(WebRtcVideoChannel2Test,
        SetMaxSendBitrateCanIncreaseSimulcastSenderBitrate) {
-  std::vector<VideoCodec> codecs;
-  codecs.push_back(kVp8Codec720p);
-  ASSERT_TRUE(channel_->SetSendCodecs(codecs));
+  cricket::VideoSendParameters parameters;
+  parameters.codecs.push_back(kVp8Codec720p);
+  ASSERT_TRUE(channel_->SetSendParameters(parameters));
   channel_->SetSend(true);
 
   FakeVideoSendStream* stream = AddSendStream(
       cricket::CreateSimStreamParams("cname", MAKE_VECTOR(kSsrcs3)));
 
   // Send a frame to make sure this scales up to >1 stream (simulcast).
   cricket::FakeVideoCapturer capturer;
   EXPECT_TRUE(channel_->SetCapturer(kSsrcs3[0], &capturer));
   EXPECT_EQ(cricket::CS_RUNNING,
             capturer.Start(capturer.GetSupportedFormats()->front()));
   EXPECT_TRUE(capturer.CaptureFrame());
 
   std::vector<webrtc::VideoStream> streams = stream->GetVideoStreams();
   ASSERT_GT(streams.size(), 1u)
       << "Without simulcast this test doesn't make sense.";
   int initial_max_bitrate_bps = 0;
   for (auto& video_stream : streams)
     initial_max_bitrate_bps += video_stream.max_bitrate_bps;
   EXPECT_GT(initial_max_bitrate_bps, 0);
 
-  EXPECT_TRUE(channel_->SetMaxSendBandwidth(initial_max_bitrate_bps * 2));
+  parameters.max_bandwidth_bps = initial_max_bitrate_bps * 2;
+  EXPECT_TRUE(channel_->SetSendParameters(parameters));
   streams = stream->GetVideoStreams();
   int increased_max_bitrate_bps = 0;
   for (auto& video_stream : streams)
     increased_max_bitrate_bps += video_stream.max_bitrate_bps;
   EXPECT_EQ(initial_max_bitrate_bps * 2, increased_max_bitrate_bps);
 
   EXPECT_TRUE(channel_->SetCapturer(kSsrcs3[0], nullptr));
 }
 
 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithMaxQuantization) {
   static const char* kMaxQuantization = "21";
-  std::vector<VideoCodec> codecs;
-  codecs.push_back(kVp8Codec);
-  codecs[0].params[kCodecParamMaxQuantization] = kMaxQuantization;
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  cricket::VideoSendParameters parameters;
+  parameters.codecs.push_back(kVp8Codec);
+  parameters.codecs[0].params[kCodecParamMaxQuantization] = kMaxQuantization;
+  EXPECT_TRUE(channel_->SetSendParameters(parameters));
   EXPECT_EQ(static_cast<unsigned int>(atoi(kMaxQuantization)),
             AddSendStream()->GetVideoStreams().back().max_qp);
 
   VideoCodec codec;
   EXPECT_TRUE(channel_->GetSendCodec(&codec));
   EXPECT_EQ(kMaxQuantization, codec.params[kCodecParamMaxQuantization]);
 }
 
 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectBadDimensions) {
-  std::vector<cricket::VideoCodec> codecs;
-  codecs.push_back(kVp8Codec);
+  cricket::VideoSendParameters parameters;
+  parameters.codecs.push_back(kVp8Codec);
 
-  codecs[0].width = 0;
-  EXPECT_FALSE(channel_->SetSendCodecs(codecs))
+  parameters.codecs[0].width = 0;
+  EXPECT_FALSE(channel_->SetSendParameters(parameters))
       << "Codec set though codec width is zero.";
 
-  codecs[0].width = kVp8Codec.width;
-  codecs[0].height = 0;
-  EXPECT_FALSE(channel_->SetSendCodecs(codecs))
+  parameters.codecs[0].width = kVp8Codec.width;
+  parameters.codecs[0].height = 0;
+  EXPECT_FALSE(channel_->SetSendParameters(parameters))
       << "Codec set though codec height is zero.";
 }
 
 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectBadPayloadTypes) {
   // TODO(pbos): Should we only allow the dynamic range?
   static const int kIncorrectPayloads[] = {-2, -1, 128, 129};
-  std::vector<cricket::VideoCodec> codecs;
-  codecs.push_back(kVp8Codec);
+  cricket::VideoSendParameters parameters;
+  parameters.codecs.push_back(kVp8Codec);
   for (size_t i = 0; i < arraysize(kIncorrectPayloads); ++i) {
-    codecs[0].id = kIncorrectPayloads[i];
-    EXPECT_FALSE(channel_->SetSendCodecs(codecs))
+    parameters.codecs[0].id = kIncorrectPayloads[i];
+    EXPECT_FALSE(channel_->SetSendParameters(parameters))
         << "Bad payload type '" << kIncorrectPayloads[i] << "' accepted.";
   }
 }
 
 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsAcceptAllValidPayloadTypes) {
-  std::vector<cricket::VideoCodec> codecs;
-  codecs.push_back(kVp8Codec);
+  cricket::VideoSendParameters parameters;
+  parameters.codecs.push_back(kVp8Codec);
   for (int payload_type = 0; payload_type <= 127; ++payload_type) {
-    codecs[0].id = payload_type;
-    EXPECT_TRUE(channel_->SetSendCodecs(codecs))
+    parameters.codecs[0].id = payload_type;
+    EXPECT_TRUE(channel_->SetSendParameters(parameters))
         << "Payload type '" << payload_type << "' rejected.";
   }
 }
 
 TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsWithOnlyVp8) {
-  std::vector<cricket::VideoCodec> codecs;
-  codecs.push_back(kVp8Codec);
-  EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
+  cricket::VideoRecvParameters parameters;
+  parameters.codecs.push_back(kVp8Codec);
+  EXPECT_TRUE(channel_->SetRecvParameters(parameters));
 }
 
 // Test that we set our inbound RTX codecs properly.
 TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsWithRtx) {
-  std::vector<cricket::VideoCodec> codecs;
-  codecs.push_back(kVp8Codec);
+  cricket::VideoRecvParameters parameters;
+  parameters.codecs.push_back(kVp8Codec);
   cricket::VideoCodec rtx_codec(96, "rtx", 0, 0, 0, 0);
-  codecs.push_back(rtx_codec);
-  EXPECT_FALSE(channel_->SetRecvCodecs(codecs))
+  parameters.codecs.push_back(rtx_codec);
+  EXPECT_FALSE(channel_->SetRecvParameters(parameters))
       << "RTX codec without associated payload should be rejected.";
 
-  codecs[1].SetParam("apt", kVp8Codec.id + 1);
-  EXPECT_FALSE(channel_->SetRecvCodecs(codecs))
+  parameters.codecs[1].SetParam("apt", kVp8Codec.id + 1);
+  EXPECT_FALSE(channel_->SetRecvParameters(parameters))
       << "RTX codec with invalid associated payload type should be rejected.";
 
-  codecs[1].SetParam("apt", kVp8Codec.id);
-  EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
+  parameters.codecs[1].SetParam("apt", kVp8Codec.id);
+  EXPECT_TRUE(channel_->SetRecvParameters(parameters));
 
   cricket::VideoCodec rtx_codec2(97, "rtx", 0, 0, 0, 0);
   rtx_codec2.SetParam("apt", rtx_codec.id);
-  codecs.push_back(rtx_codec2);
+  parameters.codecs.push_back(rtx_codec2);
 
-  EXPECT_FALSE(channel_->SetRecvCodecs(codecs)) << "RTX codec with another RTX "
-                                                   "as associated payload type "
-                                                   "should be rejected.";
+  EXPECT_FALSE(channel_->SetRecvParameters(parameters)) <<
+      "RTX codec with another RTX as associated payload type should be "
+      "rejected.";
 }
 
 TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsDifferentPayloadType) {
-  std::vector<cricket::VideoCodec> codecs;
-  codecs.push_back(kVp8Codec);
-  codecs[0].id = 99;
-  EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
+  cricket::VideoRecvParameters parameters;
+  parameters.codecs.push_back(kVp8Codec);
+  parameters.codecs[0].id = 99;
+  EXPECT_TRUE(channel_->SetRecvParameters(parameters));
 }
 
 TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsAcceptDefaultCodecs) {
-  EXPECT_TRUE(channel_->SetRecvCodecs(engine_.codecs()));
+  cricket::VideoRecvParameters parameters;
+  parameters.codecs = engine_.codecs();
+  EXPECT_TRUE(channel_->SetRecvParameters(parameters));
 
   FakeVideoReceiveStream* stream = AddRecvStream();
   webrtc::VideoReceiveStream::Config config = stream->GetConfig();
   EXPECT_EQ(engine_.codecs()[0].name, config.decoders[0].payload_name);
   EXPECT_EQ(engine_.codecs()[0].id, config.decoders[0].payload_type);
 }
 
 TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsRejectUnsupportedCodec) {
-  std::vector<VideoCodec> codecs;
-  codecs.push_back(kVp8Codec);
-  codecs.push_back(VideoCodec(101, "WTF3", 640, 400, 30, 0));
-  EXPECT_FALSE(channel_->SetRecvCodecs(codecs));
+  cricket::VideoRecvParameters parameters;
+  parameters.codecs.push_back(kVp8Codec);
+  parameters.codecs.push_back(VideoCodec(101, "WTF3", 640, 400, 30, 0));
+  EXPECT_FALSE(channel_->SetRecvParameters(parameters));
 }
 
 // TODO(pbos): Enable VP9 through external codec support
 TEST_F(WebRtcVideoChannel2Test,
        DISABLED_SetRecvCodecsAcceptsMultipleVideoCodecs) {
-  std::vector<VideoCodec> codecs;
-  codecs.push_back(kVp8Codec);
-  codecs.push_back(kVp9Codec);
-  EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
+  cricket::VideoRecvParameters parameters;
+  parameters.codecs.push_back(kVp8Codec);
+  parameters.codecs.push_back(kVp9Codec);
+  EXPECT_TRUE(channel_->SetRecvParameters(parameters));
 }
 
 TEST_F(WebRtcVideoChannel2Test,
        DISABLED_SetRecvCodecsSetsFecForAllVideoCodecs) {
-  std::vector<VideoCodec> codecs;
-  codecs.push_back(kVp8Codec);
-  codecs.push_back(kVp9Codec);
-  EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
+  cricket::VideoRecvParameters parameters;
+  parameters.codecs.push_back(kVp8Codec);
+  parameters.codecs.push_back(kVp9Codec);
+  EXPECT_TRUE(channel_->SetRecvParameters(parameters));
   FAIL();  // TODO(pbos): Verify that the FEC parameters are set for all codecs.
 }
 
 TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsWithoutFecDisablesFec) {
-  std::vector<VideoCodec> codecs;
-  codecs.push_back(kVp8Codec);
-  codecs.push_back(kUlpfecCodec);
-  ASSERT_TRUE(channel_->SetSendCodecs(codecs));
+  cricket::VideoSendParameters send_parameters;
+  send_parameters.codecs.push_back(kVp8Codec);
+  send_parameters.codecs.push_back(kUlpfecCodec);
+  ASSERT_TRUE(channel_->SetSendParameters(send_parameters));
 
   FakeVideoReceiveStream* stream = AddRecvStream();
   webrtc::VideoReceiveStream::Config config = stream->GetConfig();
 
   EXPECT_EQ(kUlpfecCodec.id, config.rtp.fec.ulpfec_payload_type);
 
-  codecs.pop_back();
-  ASSERT_TRUE(channel_->SetRecvCodecs(codecs));
+  cricket::VideoRecvParameters recv_parameters;
+  recv_parameters.codecs.push_back(kVp8Codec);
+  ASSERT_TRUE(channel_->SetRecvParameters(recv_parameters));
   stream = fake_call_->GetVideoReceiveStreams()[0];
   ASSERT_TRUE(stream != NULL);
   config = stream->GetConfig();
   EXPECT_EQ(-1, config.rtp.fec.ulpfec_payload_type)
       << "SetSendCodec without FEC should disable current FEC.";
 }
 
 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectDuplicateFecPayloads) {
-  std::vector<VideoCodec> codecs;
-  codecs.push_back(kVp8Codec);
-  codecs.push_back(kRedCodec);
-  codecs[1].id = codecs[0].id;
-  EXPECT_FALSE(channel_->SetRecvCodecs(codecs));
+  cricket::VideoRecvParameters parameters;
+  parameters.codecs.push_back(kVp8Codec);
+  parameters.codecs.push_back(kRedCodec);
+  parameters.codecs[1].id = parameters.codecs[0].id;
+  EXPECT_FALSE(channel_->SetRecvParameters(parameters));
 }
 
 TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsRejectDuplicateCodecPayloads) {
-  std::vector<VideoCodec> codecs;
-  codecs.push_back(kVp8Codec);
-  codecs.push_back(kVp9Codec);
-  codecs[1].id = codecs[0].id;
-  EXPECT_FALSE(channel_->SetRecvCodecs(codecs));
+  cricket::VideoRecvParameters parameters;
+  parameters.codecs.push_back(kVp8Codec);
+  parameters.codecs.push_back(kVp9Codec);
+  parameters.codecs[1].id = parameters.codecs[0].id;
+  EXPECT_FALSE(channel_->SetRecvParameters(parameters));
 }
 
 TEST_F(WebRtcVideoChannel2Test,
        SetRecvCodecsAcceptSameCodecOnMultiplePayloadTypes) {
-  std::vector<VideoCodec> codecs;
-  codecs.push_back(kVp8Codec);
-  codecs.push_back(kVp8Codec);
-  codecs[1].id += 1;
-  EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
+  cricket::VideoRecvParameters parameters;
+  parameters.codecs.push_back(kVp8Codec);
+  parameters.codecs.push_back(kVp8Codec);
+  parameters.codecs[1].id += 1;
+  EXPECT_TRUE(channel_->SetRecvParameters(parameters));
 }
 
 // Test that setting the same codecs but with a different order and preference
 // doesn't result in the stream being recreated.
 TEST_F(WebRtcVideoChannel2Test,
        SetRecvCodecsDifferentOrderAndPreferenceDoesntRecreateStream) {
-  std::vector<VideoCodec> codecs1;
-  codecs1.push_back(kVp8Codec);
-  codecs1.push_back(kRedCodec);
-  EXPECT_TRUE(channel_->SetRecvCodecs(codecs1));
+  cricket::VideoRecvParameters parameters1;
+  parameters1.codecs.push_back(kVp8Codec);
+  parameters1.codecs.push_back(kRedCodec);
+  EXPECT_TRUE(channel_->SetRecvParameters(parameters1));
 
   AddRecvStream(cricket::StreamParams::CreateLegacy(123));
   EXPECT_EQ(1, fake_call_->GetNumCreatedReceiveStreams());
 
-  std::vector<VideoCodec> codecs2;
-  codecs2.push_back(kRedCodec);
-  codecs2.push_back(kVp8Codec);
-  codecs2[1].preference += 1;
-  EXPECT_TRUE(channel_->SetRecvCodecs(codecs2));
+  cricket::VideoRecvParameters parameters2;
+  parameters2.codecs.push_back(kRedCodec);
+  parameters2.codecs.push_back(kVp8Codec);
+  parameters2.codecs[1].preference += 1;
+  EXPECT_TRUE(channel_->SetRecvParameters(parameters2));
   EXPECT_EQ(1, fake_call_->GetNumCreatedReceiveStreams());
 }
 
 TEST_F(WebRtcVideoChannel2Test, SendStreamNotSendingByDefault) {
   EXPECT_FALSE(AddSendStream()->IsSending());
 }
 
 TEST_F(WebRtcVideoChannel2Test, ReceiveStreamReceivingByDefault) {
   EXPECT_TRUE(AddRecvStream()->IsReceiving());
 }
@@ skipping 19 matching lines @@
   FakeVideoSendStream* new_stream = AddSendStream();
   EXPECT_TRUE(new_stream->IsSending())
       << "Send stream created after SetSend(true) not sending initially.";
 }
 
 // This test verifies DSCP settings are properly applied on video media channel.
 TEST_F(WebRtcVideoChannel2Test, TestSetDscpOptions) {
   rtc::scoped_ptr<cricket::FakeNetworkInterface> network_interface(
       new cricket::FakeNetworkInterface);
   channel_->SetInterface(network_interface.get());
-  cricket::VideoOptions options;
-  EXPECT_TRUE(channel_->SetOptions(options));
+  cricket::VideoSendParameters parameters = send_parameters_;
+  EXPECT_TRUE(channel_->SetSendParameters(parameters));
   EXPECT_EQ(rtc::DSCP_NO_CHANGE, network_interface->dscp());
-  options.dscp.Set(true);
-  EXPECT_TRUE(channel_->SetOptions(options));
+  parameters.options.dscp.Set(true);
+  EXPECT_TRUE(channel_->SetSendParameters(parameters));
   EXPECT_EQ(rtc::DSCP_AF41, network_interface->dscp());
   // Verify previous value is not modified if dscp option is not set.
-  cricket::VideoOptions options1;
-  EXPECT_TRUE(channel_->SetOptions(options1));
+  cricket::VideoSendParameters parameters1 = send_parameters_;
+  EXPECT_TRUE(channel_->SetSendParameters(parameters1));
   EXPECT_EQ(rtc::DSCP_AF41, network_interface->dscp());
-  options.dscp.Set(false);
-  EXPECT_TRUE(channel_->SetOptions(options));
+  parameters1.options.dscp.Set(false);
+  EXPECT_TRUE(channel_->SetSendParameters(parameters1));
   EXPECT_EQ(rtc::DSCP_DEFAULT, network_interface->dscp());
   channel_->SetInterface(NULL);
 }
 
 TEST_F(WebRtcVideoChannel2Test, OnReadyToSendSignalsNetworkState) {
   EXPECT_EQ(webrtc::kNetworkUp, fake_call_->GetNetworkState());
 
   channel_->OnReadyToSend(false);
   EXPECT_EQ(webrtc::kNetworkDown, fake_call_->GetNetworkState());
 
   channel_->OnReadyToSend(true);
   EXPECT_EQ(webrtc::kNetworkUp, fake_call_->GetNetworkState());
 }
 
 TEST_F(WebRtcVideoChannel2Test, GetStatsReportsSentCodecName) {
-  std::vector<cricket::VideoCodec> codecs;
-  codecs.push_back(kVp8Codec);
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  cricket::VideoSendParameters parameters;
+  parameters.codecs.push_back(kVp8Codec);
+  EXPECT_TRUE(channel_->SetSendParameters(parameters));
 
   AddSendStream();
 
   cricket::VideoMediaInfo info;
   ASSERT_TRUE(channel_->GetStats(&info));
   EXPECT_EQ(kVp8Codec.name, info.senders[0].codec_name);
 }
 
 TEST_F(WebRtcVideoChannel2Test, GetStatsReportsCpuOveruseMetrics) {
   FakeVideoSendStream* stream = AddSendStream();
@@ skipping 32 matching lines @@
   // Capture format VGA.
   cricket::FakeVideoCapturer video_capturer_vga;
   const std::vector<cricket::VideoFormat>* formats =
       video_capturer_vga.GetSupportedFormats();
   cricket::VideoFormat capture_format_vga = (*formats)[1];
   EXPECT_EQ(cricket::CS_RUNNING, video_capturer_vga.Start(capture_format_vga));
   EXPECT_TRUE(channel_->SetCapturer(kSsrcs3[0], &video_capturer_vga));
   EXPECT_TRUE(video_capturer_vga.CaptureFrame());
 
   cricket::VideoCodec send_codec(100, "VP8", 640, 480, 30, 0);
-  std::vector<cricket::VideoCodec> codecs;
-  codecs.push_back(send_codec);
-  EXPECT_TRUE(channel_->SetSendCodecs(codecs));
+  cricket::VideoSendParameters parameters;
+  parameters.codecs.push_back(send_codec);
+  EXPECT_TRUE(channel_->SetSendParameters(parameters));
   EXPECT_TRUE(channel_->SetSend(true));
 
   // Verify that the CpuOveruseObserver is registered and trigger downgrade.
-  cricket::VideoOptions options;
-  options.cpu_overuse_detection.Set(true);
-  EXPECT_TRUE(channel_->SetOptions(options));
+  parameters.options.cpu_overuse_detection.Set(true);
+  EXPECT_TRUE(channel_->SetSendParameters(parameters));
 
   // Trigger overuse.
   ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size());
   webrtc::LoadObserver* overuse_callback =
       fake_call_->GetVideoSendStreams().front()->GetConfig().overuse_callback;
   ASSERT_TRUE(overuse_callback != NULL);
   overuse_callback->OnLoadUpdate(webrtc::LoadObserver::kOveruse);
 
   // Capture format VGA -> adapt (OnCpuResolutionRequest downgrade) -> VGA/2.
   EXPECT_TRUE(video_capturer_vga.CaptureFrame());
@@ skipping 176 matching lines @@
             info.bw_estimations[0].target_enc_bitrate);
   EXPECT_EQ(stats.media_bitrate_bps + stats2.media_bitrate_bps,
             info.bw_estimations[0].actual_enc_bitrate);
   EXPECT_EQ(1 + 3 + 5 + 7, info.bw_estimations[0].transmit_bitrate)
       << "Bandwidth stats should take all streams into account.";
   EXPECT_EQ(2 + 4 + 6 + 8, info.bw_estimations[0].retransmit_bitrate)
       << "Bandwidth stats should take all streams into account.";
 }
 
 TEST_F(WebRtcVideoChannel2Test, DefaultReceiveStreamReconfiguresToUseRtx) {
-  EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
+  EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
 
   const std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs1);
   const std::vector<uint32> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
 
   ASSERT_EQ(0u, fake_call_->GetVideoReceiveStreams().size());
   const size_t kDataLength = 12;
   uint8_t data[kDataLength];
   memset(data, 0, sizeof(data));
   rtc::SetBE32(&data[8], ssrcs[0]);
   rtc::Buffer packet(data, kDataLength);
@@ skipping 10 matching lines @@
       cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs)));
   ASSERT_EQ(1u, fake_call_->GetVideoReceiveStreams().size())
       << "AddRecvStream should've reconfigured, not added a new receiver.";
   recv_stream = fake_call_->GetVideoReceiveStreams()[0];
   ASSERT_EQ(1u, recv_stream->GetConfig().rtp.rtx.size());
   EXPECT_EQ(rtx_ssrcs[0],
             recv_stream->GetConfig().rtp.rtx.begin()->second.ssrc);
 }
 
 TEST_F(WebRtcVideoChannel2Test, RejectsAddingStreamsWithMissingSsrcsForRtx) {
-  EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
+  EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
 
   const std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs1);
   const std::vector<uint32> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
 
   StreamParams sp =
       cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs);
   sp.ssrcs = ssrcs;  // Without RTXs, this is the important part.
 
   EXPECT_FALSE(channel_->AddSendStream(sp));
   EXPECT_FALSE(channel_->AddRecvStream(sp));
 }
 
 TEST_F(WebRtcVideoChannel2Test, RejectsAddingStreamsWithOverlappingRtxSsrcs) {
-  EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
+  EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
 
   const std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs1);
   const std::vector<uint32> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
 
   StreamParams sp =
       cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs);
 
   EXPECT_TRUE(channel_->AddSendStream(sp));
   EXPECT_TRUE(channel_->AddRecvStream(sp));
 
   // The RTX SSRC is already used in previous streams, using it should fail.
   sp = cricket::StreamParams::CreateLegacy(rtx_ssrcs[0]);
   EXPECT_FALSE(channel_->AddSendStream(sp));
   EXPECT_FALSE(channel_->AddRecvStream(sp));
 
   // After removing the original stream this should be fine to add (makes sure
   // that RTX ssrcs are not forever taken).
   EXPECT_TRUE(channel_->RemoveSendStream(ssrcs[0]));
   EXPECT_TRUE(channel_->RemoveRecvStream(ssrcs[0]));
   EXPECT_TRUE(channel_->AddSendStream(sp));
   EXPECT_TRUE(channel_->AddRecvStream(sp));
 }
 
 TEST_F(WebRtcVideoChannel2Test,
        RejectsAddingStreamsWithOverlappingSimulcastSsrcs) {
   static const uint32 kFirstStreamSsrcs[] = {1, 2, 3};
   static const uint32 kOverlappingStreamSsrcs[] = {4, 3, 5};
-  EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
+  EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
 
   StreamParams sp =
       cricket::CreateSimStreamParams("cname", MAKE_VECTOR(kFirstStreamSsrcs));
 
   EXPECT_TRUE(channel_->AddSendStream(sp));
   EXPECT_TRUE(channel_->AddRecvStream(sp));
 
   // One of the SSRCs is already used in previous streams, using it should fail.
   sp = cricket::CreateSimStreamParams("cname",
                                       MAKE_VECTOR(kOverlappingStreamSsrcs));
   EXPECT_FALSE(channel_->AddSendStream(sp));
   EXPECT_FALSE(channel_->AddRecvStream(sp));
 
   // After removing the original stream this should be fine to add (makes sure
   // that RTX ssrcs are not forever taken).
   EXPECT_TRUE(channel_->RemoveSendStream(kFirstStreamSsrcs[0]));
   EXPECT_TRUE(channel_->RemoveRecvStream(kFirstStreamSsrcs[0]));
   EXPECT_TRUE(channel_->AddSendStream(sp));
   EXPECT_TRUE(channel_->AddRecvStream(sp));
 }
 
 TEST_F(WebRtcVideoChannel2Test, ReportsSsrcGroupsInStats) {
-  EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
+  EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
 
   static const uint32_t kSenderSsrcs[] = {4, 7, 10};
   static const uint32_t kSenderRtxSsrcs[] = {5, 8, 11};
 
   StreamParams sender_sp = cricket::CreateSimWithRtxStreamParams(
       "cname", MAKE_VECTOR(kSenderSsrcs), MAKE_VECTOR(kSenderRtxSsrcs));
 
   EXPECT_TRUE(channel_->AddSendStream(sender_sp));
 
   static const uint32_t kReceiverSsrcs[] = {3};
@@ skipping 33 matching lines @@
   // Report no codec name for unknown playload types.
   stats.current_payload_type = 3;
   stream->SetStats(stats);
   ASSERT_TRUE(channel_->GetStats(&info));
   EXPECT_STREQ("", info.receivers[0].codec_name.c_str());
 }
 
 void WebRtcVideoChannel2Test::TestReceiveUnsignalledSsrcPacket(
     uint8_t payload_type,
     bool expect_created_receive_stream) {
-  std::vector<VideoCodec> codecs(engine_.codecs());
   // Add a RED RTX codec.
   VideoCodec red_rtx_codec =
       VideoCodec::CreateRtxCodec(kRedRtxPayloadType, kDefaultRedPlType);
-  codecs.push_back(red_rtx_codec);
-  EXPECT_TRUE(channel_->SetRecvCodecs(codecs));
+  recv_parameters_.codecs.push_back(red_rtx_codec);
+  EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
 
   ASSERT_EQ(0u, fake_call_->GetVideoReceiveStreams().size());
   const size_t kDataLength = 12;
   uint8_t data[kDataLength];
   memset(data, 0, sizeof(data));
 
   rtc::Set8(data, 1, payload_type);
   rtc::SetBE32(&data[8], kIncomingUnsignalledSsrc);
   rtc::Buffer packet(data, kDataLength);
   rtc::PacketTime packet_time;
@@ skipping 25 matching lines @@
 TEST_F(WebRtcVideoChannel2Test, UlpfecPacketDoesntCreateUnsignalledStream) {
   TestReceiveUnsignalledSsrcPacket(kDefaultUlpfecType, false);
 }
 
 TEST_F(WebRtcVideoChannel2Test, RedRtxPacketDoesntCreateUnsignalledStream) {
   TestReceiveUnsignalledSsrcPacket(kRedRtxPayloadType, false);
 }
 
 void WebRtcVideoChannel2Test::TestReceiverLocalSsrcConfiguration(
     bool receiver_first) {
-  EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs()));
+  EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
 
   const uint32_t kSenderSsrc = 0xC0FFEE;
   const uint32_t kReceiverSsrc = 0x4711;
 
   if (receiver_first) {
     AddRecvStream(StreamParams::CreateLegacy(kReceiverSsrc));
     std::vector<FakeVideoReceiveStream*> receive_streams =
         fake_call_->GetVideoReceiveStreams();
     ASSERT_EQ(1u, receive_streams.size());
     // Bogus local SSRC when we have no sender.
@@ skipping 172 matching lines @@
     channel_.reset(engine_.CreateChannel(&fake_call_, VideoOptions()));
     last_ssrc_ = 123;
   }
 
  protected:
   void VerifySimulcastSettings(const VideoCodec& codec,
                                VideoOptions::HighestBitrate bitrate_mode,
                                size_t num_configured_streams,
                                size_t expected_num_streams,
                                SimulcastBitrateMode simulcast_bitrate_mode) {
-    cricket::VideoOptions options;
-    options.video_highest_bitrate.Set(bitrate_mode);
-    EXPECT_TRUE(channel_->SetOptions(options));
-
-    std::vector<VideoCodec> codecs;
-    codecs.push_back(codec);
-    ASSERT_TRUE(channel_->SetSendCodecs(codecs));
+    cricket::VideoSendParameters parameters;
+    parameters.options.video_highest_bitrate.Set(bitrate_mode);
+    parameters.codecs.push_back(codec);
+    ASSERT_TRUE(channel_->SetSendParameters(parameters));
 
     std::vector<uint32> ssrcs = MAKE_VECTOR(kSsrcs3);
     RTC_DCHECK(num_configured_streams <= ssrcs.size());
     ssrcs.resize(num_configured_streams);
 
     FakeVideoSendStream* stream =
         AddSendStream(CreateSimStreamParams("cname", ssrcs));
     // Send a full-size frame to trigger a stream reconfiguration to use all
     // expected simulcast layers.
     cricket::FakeVideoCapturer capturer;
@@ skipping 214 matching lines @@
 // Ensures that the correct settings are applied to the codec when two temporal
 // layer screencasting is enabled, and that the correct simulcast settings are
 // reapplied when disabling screencasting.
 TEST_F(WebRtcVideoChannel2SimulcastTest,
        DISABLED_TwoTemporalLayerScreencastSettings) {
   // TODO(pbos): Implement.
   FAIL() << "Not implemented.";
 }
 
 }  // namespace cricket