Revert removal of simulcast screenshare experimental code (killswitch checks)

This reverts commit a3df0f2d05c7b0973c31fe171507e97e588671a5.

Reason for revert: We decided to keep a killswitch in M70 just in case.

Original reviewed at: https://webrtc-review.googlesource.com/c/src/+/90251

Bug: chromium:690537
Change-Id: Ieb0eb8d5487e03fc55a221f10366ed9768a6eb16
Reviewed-on: https://webrtc-review.googlesource.com/95061
Commit-Queue: Erik Språng <sprang@webrtc.org>
Reviewed-by: Stefan Holmer <stefan@webrtc.org>
Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org>
Reviewed-by: Erik Språng <sprang@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#24385}

media/base/videocapturer.cc

@@ -27,6 +27,8 @@ static const int64_t kMaxDistance = ~(static_cast<int64_t>(1) << 63);
 #ifdef WEBRTC_LINUX
 static const int kYU12Penalty = 16;  // Needs to be higher than MJPG index.
 #endif
+static const char* kSimulcastScreenshareFieldTrialName =
+    "WebRTC-SimulcastScreenshare";
 
 }  // namespace
 
@@ -182,7 +184,10 @@ bool VideoCapturer::AdaptFrame(int width,
     return false;
   }
 
-  if (enable_video_adapter_) {
+  bool simulcast_screenshare_enabled =
+      !webrtc::field_trial::IsDisabled(kSimulcastScreenshareFieldTrialName);
+  if (enable_video_adapter_ &&
+      (!IsScreencast() || simulcast_screenshare_enabled)) {
     if (!video_adapter_.AdaptFrameResolution(
             width, height, camera_time_us * rtc::kNumNanosecsPerMicrosec,
             crop_width, crop_height, out_width, out_height)) {

media/engine/simulcast.cc

@@ -32,6 +32,8 @@ constexpr int kScreenshareDefaultTl1BitrateKbps = 1000;
 // Max bitrate for the higher one of the two simulcast stream used for screen
 // content.
 constexpr int kScreenshareHighStreamMaxBitrateBps = 1250000;
+static const char* kSimulcastScreenshareFieldTrialName =
+    "WebRTC-SimulcastScreenshare";
 
 }  // namespace
 
@@ -196,9 +198,9 @@ std::vector<webrtc::VideoStream> GetSimulcastConfig(
     bool is_screenshare,
     bool temporal_layers_supported) {
   if (is_screenshare) {
-    return GetScreenshareLayers(max_layers, width, height, bitrate_priority,
-                                max_qp, max_framerate,
-                                temporal_layers_supported);
+    return GetScreenshareLayers(
+        max_layers, width, height, bitrate_priority, max_qp, max_framerate,
+        ScreenshareSimulcastFieldTrialEnabled(), temporal_layers_supported);
   } else {
     return GetNormalSimulcastLayers(max_layers, width, height, bitrate_priority,
                                     max_qp, max_framerate,
@@ -297,9 +299,12 @@ std::vector<webrtc::VideoStream> GetScreenshareLayers(
     double bitrate_priority,
     int max_qp,
     int max_framerate,
+    bool screenshare_simulcast_enabled,
     bool temporal_layers_supported) {
+  auto max_screenshare_layers =
+      screenshare_simulcast_enabled ? kMaxScreenshareSimulcastLayers : 1;
   size_t num_simulcast_layers =
-      std::min<int>(max_layers, kMaxScreenshareSimulcastLayers);
+      std::min<int>(max_layers, max_screenshare_layers);
 
   std::vector<webrtc::VideoStream> layers(num_simulcast_layers);
   // For legacy screenshare in conference mode, tl0 and tl1 bitrates are
@@ -362,4 +367,8 @@ std::vector<webrtc::VideoStream> GetScreenshareLayers(
   return layers;
 }
 
+bool ScreenshareSimulcastFieldTrialEnabled() {
+  return !webrtc::field_trial::IsDisabled(kSimulcastScreenshareFieldTrialName);
+}
+
 }  // namespace cricket

media/engine/simulcast.h

@@ -56,7 +56,11 @@ std::vector<webrtc::VideoStream> GetScreenshareLayers(
     double bitrate_priority,
     int max_qp,
     int max_framerate,
+    bool screenshare_simulcast_enabled,
     bool temporal_layers_supported = true);
+
+bool ScreenshareSimulcastFieldTrialEnabled();
+
 }  // namespace cricket
 
 #endif  // MEDIA_ENGINE_SIMULCAST_H_

media/engine/simulcast_unittest.cc

@@ -134,6 +134,27 @@ TEST(SimulcastTest, GetConfigWithNormalizedResolution) {
   EXPECT_EQ(360u, streams[1].height);
 }
 
+TEST(SimulcastTest, GetConfigForScreenshare) {
+  test::ScopedFieldTrials field_trials("WebRTC-SimulcastScreenshare/Disabled/");
+
+  const size_t kMaxLayers = 3;
+  std::vector<VideoStream> streams = cricket::GetSimulcastConfig(
+      kMaxLayers, 1400, 800, kMaxBitrateBps, kBitratePriority, kQpMax, kMaxFps,
+      kScreenshare);
+
+  EXPECT_EQ(1u, streams.size()) << "No simulcast.";
+  EXPECT_EQ(1400u, streams[0].width);
+  EXPECT_EQ(800u, streams[0].height);
+  EXPECT_EQ(kQpMax, streams[0].max_qp);
+  EXPECT_EQ(kBitratePriority, streams[0].bitrate_priority);
+  EXPECT_TRUE(streams[0].active);
+  EXPECT_GT(streams[0].num_temporal_layers, size_t{1});
+  EXPECT_GT(streams[0].max_framerate, 0);
+  EXPECT_EQ(cricket::kMinVideoBitrateBps, streams[0].min_bitrate_bps);
+  EXPECT_GT(streams[0].target_bitrate_bps, streams[0].min_bitrate_bps);
+  EXPECT_GT(streams[0].max_bitrate_bps, streams[0].target_bitrate_bps);
+}
+
 TEST(SimulcastTest, GetConfigForScreenshareSimulcast) {
   const size_t kMaxLayers = 3;
   std::vector<VideoStream> streams = cricket::GetSimulcastConfig(
@@ -155,6 +176,8 @@ TEST(SimulcastTest, GetConfigForScreenshareSimulcast) {
 }
 
 TEST(SimulcastTest, GetConfigForScreenshareSimulcastWithLimitedMaxLayers) {
+  test::ScopedFieldTrials field_trials("WebRTC-SimulcastScreenshare/Enabled/");
+
   const size_t kMaxLayers = 1;
   std::vector<VideoStream> streams = cricket::GetSimulcastConfig(
       kMaxLayers, 1400, 800, kMaxBitrateBps, kBitratePriority, kQpMax, kMaxFps,

media/engine/webrtcvideoengine.cc

@@ -1957,7 +1957,8 @@ WebRtcVideoChannel::WebRtcVideoSendStream::CreateVideoEncoderConfig(
   // configure a single stream.
   encoder_config.number_of_streams = parameters_.config.rtp.ssrcs.size();
   if (IsCodecBlacklistedForSimulcast(codec.name) ||
-      (is_screencast && !parameters_.conference_mode)) {
+      (is_screencast && (!ScreenshareSimulcastFieldTrialEnabled() ||
+                         !parameters_.conference_mode))) {
     encoder_config.number_of_streams = 1;
   }
 
@@ -2736,7 +2737,10 @@ std::vector<webrtc::VideoStream> EncoderStreamFactory::CreateEncoderStreams(
     int width,
     int height,
     const webrtc::VideoEncoderConfig& encoder_config) {
-  if (is_screenshare_ && !screenshare_config_explicitly_enabled_) {
+  bool screenshare_simulcast_enabled =
+      screenshare_config_explicitly_enabled_ &&
+      cricket::ScreenshareSimulcastFieldTrialEnabled();
+  if (is_screenshare_ && !screenshare_simulcast_enabled) {
     RTC_DCHECK_EQ(1, encoder_config.number_of_streams);
   }
   RTC_DCHECK_GT(encoder_config.number_of_streams, 0);

media/engine/webrtcvideoengine_unittest.cc

@@ -6521,6 +6521,25 @@ TEST_F(WebRtcVideoChannelSimulcastTest, SetSendCodecsWithOddSizeInSimulcast) {
                           true);
 }
 
+// TODO(ilnik): Remove this test once Simulcast Screenshare is launched.
+TEST_F(WebRtcVideoChannelSimulcastTest, SetSendCodecsForScreenshare) {
+  webrtc::test::ScopedFieldTrials override_field_trials_(
+      "WebRTC-SimulcastScreenshare/Disabled/");
+
+  VerifySimulcastSettings(cricket::VideoCodec("VP8"), 1280, 720, 3, 1, true,
+                          false);
+}
+
+// TODO(ilnik): Remove this test once Simulcast Screenshare is launched.
+TEST_F(WebRtcVideoChannelSimulcastTest,
+       SetSendCodecsForConferenceModeScreenshare) {
+  webrtc::test::ScopedFieldTrials override_field_trials_(
+      "WebRTC-SimulcastScreenshare/Disabled/");
+
+  VerifySimulcastSettings(cricket::VideoCodec("VP8"), 1280, 720, 3, 1, true,
+                          true);
+}
+
 TEST_F(WebRtcVideoChannelSimulcastTest, SetSendCodecsForSimulcastScreenshare) {
   VerifySimulcastSettings(cricket::VideoCodec("VP8"), 1280, 720, 3, 2, true,
                           true);