Add field trial for balanced degradation preference.

webrtc/media/engine/webrtcvideoengine_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 1197 matching lines @@
         AddSendStream(cricket::StreamParams::CreateLegacy(123));
 
     // Verify that only one of them has been set, and that it is the one with
     // highest priority (transport sequence number).
     ASSERT_EQ(1u, send_stream->GetConfig().rtp.extensions.size());
     EXPECT_EQ(expected_id, send_stream->GetConfig().rtp.extensions[0].id);
     EXPECT_EQ(expected_extension,
               send_stream->GetConfig().rtp.extensions[0].uri);
   }
 
+  void TestDegradationPreference(bool resolution_scaling_enabled,
+                                 bool fps_scaling_enabled);
+
   void TestCpuAdaptation(bool enable_overuse, bool is_screenshare);
   void TestReceiverLocalSsrcConfiguration(bool receiver_first);
   void TestReceiveUnsignaledSsrcPacket(uint8_t payload_type,
                                        bool expect_created_receive_stream);
 
   FakeVideoSendStream* SetDenoisingOption(
       uint32_t ssrc,
       cricket::FakeVideoCapturer* capturer,
       bool enabled) {
     cricket::VideoOptions options;
@@ skipping 862 matching lines @@
       : Vp9SettingsTestWithFieldTrial(
             "WebRTC-SupportVP9SVC/EnabledByFlag_2SL3TL/") {}
 };
 
 TEST_F(Vp9SettingsTestWith2SL3TLFlag, VerifySettings) {
   const int kNumSpatialLayers = 2;
   const int kNumTemporalLayers = 3;
   VerifySettings(kNumSpatialLayers, kNumTemporalLayers);
 }
 
+TEST_F(WebRtcVideoChannelTest,
+       BalancedDegradationPreferenceNotSupportedWithoutFieldtrial) {
+  webrtc::test::ScopedFieldTrials override_field_trials_(
+      "WebRTC-Video-BalancedDegradation/Disabled/");
+  const bool kResolutionScalingEnabled = true;
+  const bool kFpsScalingEnabled = false;
+  TestDegradationPreference(kResolutionScalingEnabled, kFpsScalingEnabled);
+}
+
+TEST_F(WebRtcVideoChannelTest,
+       BalancedDegradationPreferenceSupportedBehindFieldtrial) {
+  webrtc::test::ScopedFieldTrials override_field_trials_(
+      "WebRTC-Video-BalancedDegradation/Enabled/");
+  const bool kResolutionScalingEnabled = true;
+  const bool kFpsScalingEnabled = true;
+  TestDegradationPreference(kResolutionScalingEnabled, kFpsScalingEnabled);
+}
+
 TEST_F(WebRtcVideoChannelTest, AdaptsOnOveruse) {
   TestCpuAdaptation(true, false);
 }
 
 TEST_F(WebRtcVideoChannelTest, DoesNotAdaptOnOveruseWhenDisabled) {
   TestCpuAdaptation(false, false);
 }
 
 TEST_F(WebRtcVideoChannelTest, DoesNotAdaptOnOveruseWhenScreensharing) {
   TestCpuAdaptation(true, true);
@@ skipping 146 matching lines @@
   EXPECT_TRUE(capturer.CaptureCustomFrame(1280, 720, cricket::FOURCC_I420));
   ASSERT_EQ(3, fake_call_->GetNumCreatedSendStreams());
   send_stream = fake_call_->GetVideoSendStreams().front();
   EXPECT_EQ(1, send_stream->GetNumberOfSwappedFrames());
   EXPECT_EQ(1280 * 3 / 4, send_stream->GetLastWidth());
   EXPECT_EQ(720 * 3 / 4, send_stream->GetLastHeight());
 
   EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, nullptr));
 }
 
+// TODO(asapersson): Remove this test when the balanced field trial is removed.
+void WebRtcVideoChannelTest::TestDegradationPreference(
+    bool resolution_scaling_enabled,
+    bool fps_scaling_enabled) {
+  cricket::VideoCodec codec = GetEngineCodec("VP8");
+  cricket::VideoSendParameters parameters;
+  parameters.codecs.push_back(codec);
+
+  MediaConfig media_config = GetMediaConfig();
+  media_config.video.enable_cpu_overuse_detection = true;
+  channel_.reset(
+      engine_.CreateChannel(fake_call_.get(), media_config, VideoOptions()));
+  channel_->OnReadyToSend(true);
+
+  EXPECT_TRUE(channel_->SetSendParameters(parameters));
+
+  AddSendStream();
+
+  cricket::FakeVideoCapturer capturer;
+  VideoOptions options;
+  EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, &options, &capturer));
+  cricket::VideoFormat capture_format = capturer.GetSupportedFormats()->front();
+  EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(capture_format));
+
+  EXPECT_TRUE(channel_->SetSend(true));
+
+  FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front();
+  EXPECT_EQ(resolution_scaling_enabled,
+            send_stream->resolution_scaling_enabled());
+  EXPECT_EQ(fps_scaling_enabled, send_stream->framerate_scaling_enabled());
+
+  EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, nullptr));
+}
+
 void WebRtcVideoChannelTest::TestCpuAdaptation(bool enable_overuse,
                                                bool is_screenshare) {
   const int kDefaultFps = 30;
   cricket::VideoCodec codec = GetEngineCodec("VP8");
   cricket::VideoSendParameters parameters;
   parameters.codecs.push_back(codec);
 
   MediaConfig media_config = GetMediaConfig();
   if (enable_overuse) {
     media_config.video.enable_cpu_overuse_detection = true;
@@ skipping 2350 matching lines @@
 
 TEST_F(WebRtcVideoChannelSimulcastTest,
        NoSimulcastScreenshareWithoutConference) {
   webrtc::test::ScopedFieldTrials override_field_trials_(
       "WebRTC-SimulcastScreenshare/Enabled/");
   VerifySimulcastSettings(cricket::VideoCodec("VP8"), 1280, 720, 3, 1, true,
                           false);
 }
 
 }  // namespace cricket