Drop VideoOptions from VideoSendParameters.

webrtc/media/engine/webrtcvideoengine2_unittest.cc

 /*
  *  Copyright (c) 2004 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 1023 matching lines @@
     EXPECT_EQ(expected_extension,
               send_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(
-      const cricket::VideoSendParameters& parameters,
+      uint32_t ssrc,
       cricket::FakeVideoCapturer* capturer,
       bool enabled) {
-    cricket::VideoSendParameters params = parameters;
-    params.options.video_noise_reduction = rtc::Optional<bool>(enabled);
-    // TODO(nisse): Switch to using SetOptions?
-    channel_->SetSendParameters(params);
+    cricket::VideoOptions options;
+    options.video_noise_reduction = rtc::Optional<bool>(enabled);
+    channel_->SetVideoSend(ssrc, true, &options);
     // Options only take effect on the next frame.
     EXPECT_TRUE(capturer->CaptureFrame());
 
     return fake_call_->GetVideoSendStreams().back();
   }
 
   FakeVideoSendStream* SetUpSimulcast(bool enabled, bool with_rtx) {
     const int kRtxSsrcOffset = 0xDEADBEEF;
     last_ssrc_ += 3;
     std::vector<uint32_t> ssrcs;
@@ skipping 421 matching lines @@
   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, UsesCorrectSettingsForScreencast) {
   static const int kScreenshareMinBitrateKbps = 800;
   cricket::VideoCodec codec = kVp8Codec360p;
   cricket::VideoSendParameters parameters;
   parameters.codecs.push_back(codec);
-  parameters.options.screencast_min_bitrate_kbps =
+  EXPECT_TRUE(channel_->SetSendParameters(parameters));
+  AddSendStream();
+
+  VideoOptions mbr_options;
+  mbr_options.screencast_min_bitrate_kbps =
       rtc::Optional<int>(kScreenshareMinBitrateKbps);
-  EXPECT_TRUE(channel_->SetSendParameters(parameters));
-
-  AddSendStream();
+  channel_->SetVideoSend(last_ssrc_, true, &mbr_options);
 
   cricket::FakeVideoCapturer capturer;
   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);
   EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(capture_format_hd));
 
   EXPECT_TRUE(channel_->SetSend(true));
@@ skipping 10 matching lines @@
             encoder_config.content_type);
   EXPECT_EQ(codec.width, encoder_config.streams.front().width);
   EXPECT_EQ(codec.height, encoder_config.streams.front().height);
   EXPECT_EQ(0, encoder_config.min_transmit_bitrate_bps)
       << "Non-screenshare shouldn't use min-transmit bitrate.";
 
   EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, nullptr));
   // Removing a capturer triggers a black frame to be sent.
   EXPECT_EQ(2, send_stream->GetNumberOfSwappedFrames());
   EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
-  parameters.options.is_screencast = rtc::Optional<bool>(true);
-  EXPECT_TRUE(channel_->SetSendParameters(parameters));
+  VideoOptions screencast_options;
+  screencast_options.is_screencast = rtc::Optional<bool>(true);
+  EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, &screencast_options));
   EXPECT_TRUE(capturer.CaptureFrame());
   // Send stream not recreated after option change.
   ASSERT_EQ(send_stream, fake_call_->GetVideoSendStreams().front());
   EXPECT_EQ(3, send_stream->GetNumberOfSwappedFrames());
 
   // Verify screencast settings.
   encoder_config = send_stream->GetEncoderConfig();
   EXPECT_EQ(webrtc::VideoEncoderConfig::ContentType::kScreen,
             encoder_config.content_type);
   EXPECT_EQ(kScreenshareMinBitrateKbps * 1000,
@@ skipping 55 matching lines @@
             encoder_config.content_type);
 
   EXPECT_TRUE(channel_->SetCapturer(kSsrc, NULL));
 }
 
 TEST_F(WebRtcVideoChannel2Test,
        ConferenceModeScreencastConfiguresTemporalLayer) {
   static const int kConferenceScreencastTemporalBitrateBps =
       ScreenshareLayerConfig::GetDefault().tl0_bitrate_kbps * 1000;
   send_parameters_.conference_mode = true;
-  send_parameters_.options.is_screencast = rtc::Optional<bool>(true);
   channel_->SetSendParameters(send_parameters_);
 
   AddSendStream();
-
+  VideoOptions options;
+  options.is_screencast = rtc::Optional<bool>(true);
+  channel_->SetVideoSend(last_ssrc_, true, &options);
   cricket::FakeVideoCapturer capturer;
   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));
 
   EXPECT_TRUE(channel_->SetSend(true));
 
   EXPECT_TRUE(capturer.CaptureFrame());
   ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size());
@@ skipping 63 matching lines @@
   EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
   channel_->SetSend(true);
 
   EXPECT_TRUE(capturer.CaptureFrame());
 
   webrtc::VideoCodecVP8 vp8_settings;
   ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
   EXPECT_TRUE(vp8_settings.denoisingOn)
       << "VP8 denoising should be on by default.";
 
-  stream = SetDenoisingOption(parameters, &capturer, false);
+  stream = SetDenoisingOption(last_ssrc_, &capturer, false);
 
   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(parameters, &capturer, true);
+  stream = SetDenoisingOption(last_ssrc_, &capturer, 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.
-  parameters.options.is_screencast = rtc::Optional<bool>(true);
-  EXPECT_TRUE(channel_->SetSendParameters(parameters));
+  VideoOptions options;
+  options.is_screencast = rtc::Optional<bool>(true);
+  EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, &options));
 
-  stream = SetDenoisingOption(parameters, &capturer, false);
+  stream = SetDenoisingOption(last_ssrc_, &capturer, 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(parameters, &capturer, true);
+  stream = SetDenoisingOption(last_ssrc_, &capturer, 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 {
@@ skipping 32 matching lines @@
   EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
   channel_->SetSend(true);
 
   EXPECT_TRUE(capturer.CaptureFrame());
 
   webrtc::VideoCodecVP9 vp9_settings;
   ASSERT_TRUE(stream->GetVp9Settings(&vp9_settings)) << "No VP9 config set.";
   EXPECT_FALSE(vp9_settings.denoisingOn)
       << "VP9 denoising should be off by default.";
 
-  stream = SetDenoisingOption(parameters, &capturer, false);
+  stream = SetDenoisingOption(last_ssrc_, &capturer, false);
 
   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(parameters, &capturer, true);
+  stream = SetDenoisingOption(last_ssrc_, &capturer, 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.
-  parameters.options.is_screencast = rtc::Optional<bool>(true);
-  EXPECT_TRUE(channel_->SetSendParameters(parameters));
+  VideoOptions options;
+  options.is_screencast = rtc::Optional<bool>(true);
+  EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, &options));
 
-  stream = SetDenoisingOption(parameters, &capturer, false);
+  stream = SetDenoisingOption(last_ssrc_, &capturer, 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(parameters, &capturer, false);
+  stream = SetDenoisingOption(last_ssrc_, &capturer, 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, AdaptsOnOveruse) {
   TestCpuAdaptation(true, false);
@@ skipping 79 matching lines @@
   cricket::VideoSendParameters parameters;
   parameters.codecs.push_back(codec);
 
   MediaConfig media_config = MediaConfig();
   if (!enable_overuse) {
     media_config.video.enable_cpu_overuse_detection = false;
   }
   channel_.reset(
       engine_.CreateChannel(fake_call_.get(), media_config, VideoOptions()));
 
-  parameters.options.is_screencast = rtc::Optional<bool>(is_screenshare);
   EXPECT_TRUE(channel_->SetSendParameters(parameters));
 
   AddSendStream();
 
+  VideoOptions options;
+  options.is_screencast = rtc::Optional<bool>(is_screenshare);
+  EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, &options));
+
   cricket::FakeVideoCapturer capturer;
   EXPECT_TRUE(channel_->SetCapturer(last_ssrc_, &capturer));
   EXPECT_EQ(cricket::CS_RUNNING,
             capturer.Start(capturer.GetSupportedFormats()->front()));
 
   EXPECT_TRUE(channel_->SetSend(true));
 
   // Trigger overuse.
   ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size());
   FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front();
@@ skipping 1328 matching lines @@
 }
 
 // Test that we normalize send codec format size in simulcast.
 TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWithOddSizeInSimulcast) {
   cricket::VideoCodec codec(kVp8Codec270p);
   codec.width += 1;
   codec.height += 1;
   VerifySimulcastSettings(codec, 2, 2);
 }
 }  // namespace cricket
-