What can't loopback test be more like full stack test?

webrtc/video/screenshare_loopback.cc

 /*
  *  Copyright (c) 2015 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 109 matching lines @@
   return static_cast<int>(FLAG_avg_propagation_delay_ms);
 }
 
 DEFINE_int(std_propagation_delay_ms,
            0,
            "Link propagation delay standard deviation in ms.");
 int StdPropagationDelayMs() {
   return static_cast<int>(FLAG_std_propagation_delay_ms);
 }
 
-DEFINE_int(selected_stream, 0, "ID of the stream to show or analyze.");
+DEFINE_int(num_streams, 0, "Number of streams to show or analyze.");
+int NumStreams() {
+  return static_cast<int>(FLAG_num_streams);
+}
+
+DEFINE_int(selected_stream,
+           0,
+           "ID of the stream to show or analyze. "
+           "Set to the number of streams to show them all.");
 int SelectedStream() {
   return static_cast<int>(FLAG_selected_stream);
 }
 
 DEFINE_int(num_spatial_layers, 1, "Number of spatial layers to use.");
 int NumSpatialLayers() {
   return static_cast<int>(FLAG_num_spatial_layers);
 }
 
 DEFINE_int(selected_sl,
@@ skipping 120 matching lines @@
                   false,  // FlexFEC disabled.
                   flags::EncodedFramePath(),
                   ""};
   params.screenshare = {true, flags::SlideChangeInterval(),
                         flags::ScrollDuration(), flags::Slides()};
   params.analyzer = {"screenshare", 0.0, 0.0, flags::DurationSecs(),
       flags::OutputFilename(), flags::GraphTitle()};
   params.pipe = pipe_config;
   params.logs = flags::FLAG_logs;
 
+  if (flags::NumStreams() > 1 && flags::Stream0().empty() &&
+      flags::Stream1().empty()) {
+    params.ss.infer_streams = true;
+  }
+
   std::vector<std::string> stream_descriptors;
   stream_descriptors.push_back(flags::Stream0());
   stream_descriptors.push_back(flags::Stream1());
   std::vector<std::string> SL_descriptors;
   SL_descriptors.push_back(flags::SL0());
   SL_descriptors.push_back(flags::SL1());
   VideoQualityTest::FillScalabilitySettings(
-      &params, stream_descriptors, flags::SelectedStream(),
+      &params, stream_descriptors, flags::NumStreams(), flags::SelectedStream(),
       flags::NumSpatialLayers(), flags::SelectedSL(), SL_descriptors);
 
   VideoQualityTest test;
   if (flags::DurationSecs()) {
     test.RunWithAnalyzer(params);
   } else {
     test.RunWithRenderers(params);
   }
 }
 }  // namespace webrtc
 
 int main(int argc, char* argv[]) {
   ::testing::InitGoogleTest(&argc, argv);
   rtc::FlagList::SetFlagsFromCommandLine(&argc, argv, true);
   if (webrtc::flags::FLAG_help) {
     rtc::FlagList::Print(nullptr, false);
     return 0;
   }
 
-  webrtc::test::InitFieldTrialsFromString(
-      webrtc::flags::FLAG_force_fieldtrials);
+  // InitFieldTrialsFromString needs a reference to an std::string instance,
+  // with a scope that outlives the test.
+  std::string field_trials = webrtc::flags::FLAG_force_fieldtrials;
+  webrtc::test::InitFieldTrialsFromString(field_trials);
   webrtc::test::RunTest(webrtc::Loopback);
   return 0;
 }