diff --git a/api/test/video_quality_test_fixture.h b/api/test/video_quality_test_fixture.h
index ec07c23cd4..92c398aa54 100644
--- a/api/test/video_quality_test_fixture.h
+++ b/api/test/video_quality_test_fixture.h
@@ -22,6 +22,7 @@
 #include "api/test/simulated_network.h"
 #include "api/transport/bitrate_settings.h"
 #include "api/transport/network_control.h"
+#include "api/video_codecs/sdp_video_format.h"
 #include "api/video_codecs/video_decoder_factory.h"
 #include "api/video_codecs/video_encoder_config.h"
 #include "api/video_codecs/video_encoder_factory.h"
@@ -31,60 +32,56 @@ namespace webrtc {
 class VideoQualityTestFixtureInterface {
  public:
   // Parameters are grouped into smaller structs to make it easier to set
-  // the desired elements and skip unused, using aggregate initialization.
-  // Unfortunately, C++11 (as opposed to C11) doesn't support unnamed structs,
-  // which makes the implementation of VideoQualityTest a bit uglier.
+  // the desired elements and skip unused.
   struct Params {
-    Params();
-    ~Params();
     struct CallConfig {
-      bool send_side_bwe;
-      bool generic_descriptor;
+      bool send_side_bwe = false;
+      bool generic_descriptor = false;
       BitrateConstraints call_bitrate_config;
-      int num_thumbnails;
+      int num_thumbnails = 0;
       // Indicates if secondary_(video|ss|screenshare) structures are used.
-      bool dual_video;
+      bool dual_video = false;
     } call;
     struct Video {
-      bool enabled;
-      size_t width;
-      size_t height;
-      int32_t fps;
-      int min_bitrate_bps;
-      int target_bitrate_bps;
-      int max_bitrate_bps;
-      bool suspend_below_min_bitrate;
-      std::string codec;
-      int num_temporal_layers;
-      int selected_tl;
-      int min_transmit_bps;
-      bool ulpfec;
-      bool flexfec;
-      bool automatic_scaling;
+      bool enabled = false;
+      size_t width = 640;
+      size_t height = 480;
+      int32_t fps = 30;
+      int min_bitrate_bps = 50;
+      int target_bitrate_bps = 800;
+      int max_bitrate_bps = 800;
+      bool suspend_below_min_bitrate = false;
+      std::string codec = "VP8";
+      int num_temporal_layers = 1;
+      int selected_tl = -1;
+      int min_transmit_bps = 0;
+      bool ulpfec = false;
+      bool flexfec = false;
+      bool automatic_scaling = false;
       std::string clip_path;  // "Generator" to generate frames instead.
-      size_t capture_device_index;
+      size_t capture_device_index = 0;
       SdpVideoFormat::Parameters sdp_params;
-      double encoder_overshoot_factor;
+      double encoder_overshoot_factor = 0.0;
     } video[2];
     struct Audio {
-      bool enabled;
-      bool sync_video;
-      bool dtx;
-      bool use_real_adm;
+      bool enabled = false;
+      bool sync_video = false;
+      bool dtx = false;
+      bool use_real_adm = false;
       absl::optional<std::string> ana_config;
     } audio;
     struct Screenshare {
-      bool enabled;
-      bool generate_slides;
-      int32_t slide_change_interval;
-      int32_t scroll_duration;
+      bool enabled = false;
+      bool generate_slides = false;
+      int32_t slide_change_interval = 10;
+      int32_t scroll_duration = 0;
       std::vector<std::string> slides;
     } screenshare[2];
     struct Analyzer {
       std::string test_label;
-      double avg_psnr_threshold;  // (*)
-      double avg_ssim_threshold;  // (*)
-      int test_durations_secs;
+      double avg_psnr_threshold = 0.0;  // (*)
+      double avg_ssim_threshold = 0.0;  // (*)
+      int test_durations_secs = 0;
       std::string graph_data_output_filename;
       std::string graph_title;
     } analyzer;
@@ -95,14 +92,14 @@ class VideoQualityTestFixtureInterface {
     absl::optional<BuiltInNetworkBehaviorConfig> config;
     struct SS {                          // Spatial scalability.
       std::vector<VideoStream> streams;  // If empty, one stream is assumed.
-      size_t selected_stream;
-      int num_spatial_layers;
-      int selected_sl;
-      InterLayerPredMode inter_layer_pred;
+      size_t selected_stream = 0;
+      int num_spatial_layers = 0;
+      int selected_sl = -1;
+      InterLayerPredMode inter_layer_pred = InterLayerPredMode::kOn;
       // If empty, bitrates are generated in VP9Impl automatically.
       std::vector<SpatialLayer> spatial_layers;
       // If set, default parameters will be used instead of |streams|.
-      bool infer_streams;
+      bool infer_streams = false;
     } ss[2];
     struct Logging {
       std::string rtc_event_log_name;
diff --git a/video/screenshare_loopback.cc b/video/screenshare_loopback.cc
index b8121dc85c..239e472f6e 100644
--- a/video/screenshare_loopback.cc
+++ b/video/screenshare_loopback.cc
@@ -325,32 +325,29 @@ void Loopback() {
   call_bitrate_config.max_bitrate_bps = -1;  // Don't cap bandwidth estimate.
 
   VideoQualityTest::Params params;
-  params.call = {absl::GetFlag(FLAGS_send_side_bwe),
-                 absl::GetFlag(FLAGS_generic_descriptor), call_bitrate_config};
-  params.video[0] = {true,
-                     Width(),
-                     Height(),
-                     Fps(),
-                     MinBitrateKbps() * 1000,
-                     TargetBitrateKbps() * 1000,
-                     MaxBitrateKbps() * 1000,
-                     false,
-                     Codec(),
-                     NumTemporalLayers(),
-                     SelectedTL(),
-                     MinTransmitBitrateKbps() * 1000,
-                     false,  // ULPFEC disabled.
-                     false,  // FlexFEC disabled.
-                     false,  // Automatic scaling disabled.
-                     "",
-                     0,  // capture_device_index.
-                     SdpVideoFormat::Parameters()};
-  params.screenshare[0] = {true, GenerateSlides(), SlideChangeInterval(),
-                           ScrollDuration(), Slides()};
-  params.analyzer = {"screenshare",    0.0,         0.0, DurationSecs(),
-                     OutputFilename(), GraphTitle()};
+  params.call.send_side_bwe = absl::GetFlag(FLAGS_send_side_bwe);
+  params.call.generic_descriptor = absl::GetFlag(FLAGS_generic_descriptor);
+  params.call.call_bitrate_config = call_bitrate_config;
+  params.video[0].enabled = true;
+  params.video[0].width = Width();
+  params.video[0].height = Height();
+  params.video[0].fps = Fps();
+  params.video[0].min_bitrate_bps = MinBitrateKbps() * 1000;
+  params.video[0].target_bitrate_bps = TargetBitrateKbps() * 1000;
+  params.video[0].max_bitrate_bps = MaxBitrateKbps() * 1000;
+  params.video[0].codec = Codec();
+  params.video[0].num_temporal_layers = NumTemporalLayers();
+  params.video[0].selected_tl = SelectedTL();
+  params.video[0].min_transmit_bps = MinTransmitBitrateKbps() * 1000;
+  params.screenshare[0].enabled = true;
+  params.screenshare[0].generate_slides = GenerateSlides();
+  params.screenshare[0].slide_change_interval = SlideChangeInterval();
+  params.screenshare[0].scroll_duration = ScrollDuration();
+  params.screenshare[0].slides = Slides();
   params.config = pipe_config;
-  params.logging = {RtcEventLogName(), RtpDumpName(), EncodedFramePath()};
+  params.logging.rtc_event_log_name = RtcEventLogName();
+  params.logging.rtp_dump_name = RtpDumpName();
+  params.logging.encoded_frame_base_path = EncodedFramePath();
 
   if (NumStreams() > 1 && Stream0().empty() && Stream1().empty()) {
     params.ss[0].infer_streams = true;
diff --git a/video/sv_loopback.cc b/video/sv_loopback.cc
index ec236d6e62..af475ae4eb 100644
--- a/video/sv_loopback.cc
+++ b/video/sv_loopback.cc
@@ -605,56 +605,62 @@ void Loopback() {
   call_bitrate_config.max_bitrate_bps =
       (ScreenshareMaxBitrateKbps() + VideoMaxBitrateKbps()) * 1000;
 
-  VideoQualityTest::Params params, camera_params, screenshare_params;
-  params.call = {absl::GetFlag(FLAGS_send_side_bwe),
-                 absl::GetFlag(FLAGS_generic_descriptor), call_bitrate_config,
-                 0};
+  VideoQualityTest::Params params;
+  params.call.send_side_bwe = absl::GetFlag(FLAGS_send_side_bwe);
+  params.call.generic_descriptor = absl::GetFlag(FLAGS_generic_descriptor);
+  params.call.call_bitrate_config = call_bitrate_config;
   params.call.dual_video = true;
-  params.video[screenshare_idx] = {true,
-                                   ScreenshareWidth(),
-                                   ScreenshareHeight(),
-                                   ScreenshareFps(),
-                                   ScreenshareMinBitrateKbps() * 1000,
-                                   ScreenshareTargetBitrateKbps() * 1000,
-                                   ScreenshareMaxBitrateKbps() * 1000,
-                                   false,
-                                   Codec(),
-                                   ScreenshareNumTemporalLayers(),
-                                   ScreenshareSelectedTL(),
-                                   ScreenshareMinTransmitBitrateKbps() * 1000,
-                                   false,  // ULPFEC disabled.
-                                   false,  // FlexFEC disabled.
-                                   false,  // Automatic scaling disabled
-                                   ""};
-  params.video[camera_idx] = {absl::GetFlag(FLAGS_video),
-                              VideoWidth(),
-                              VideoHeight(),
-                              VideoFps(),
-                              VideoMinBitrateKbps() * 1000,
-                              VideoTargetBitrateKbps() * 1000,
-                              VideoMaxBitrateKbps() * 1000,
-                              absl::GetFlag(FLAGS_suspend_below_min_bitrate),
-                              Codec(),
-                              VideoNumTemporalLayers(),
-                              VideoSelectedTL(),
-                              0,  // No min transmit bitrate.
-                              absl::GetFlag(FLAGS_use_ulpfec),
-                              absl::GetFlag(FLAGS_use_flexfec),
-                              false,
-                              VideoClip(),
-                              GetCaptureDevice()};
-  params.audio = {absl::GetFlag(FLAGS_audio),
-                  absl::GetFlag(FLAGS_audio_video_sync),
-                  absl::GetFlag(FLAGS_audio_dtx)};
-  params.logging = {RtcEventLogName(), RtpDumpName(), EncodedFramePath()};
-  params.analyzer = {"dual_streams",   0.0,         0.0, DurationSecs(),
-                     OutputFilename(), GraphTitle()};
+  params.video[screenshare_idx].enabled = true;
+  params.video[screenshare_idx].width = ScreenshareWidth();
+  params.video[screenshare_idx].height = ScreenshareHeight();
+  params.video[screenshare_idx].fps = ScreenshareFps();
+  params.video[screenshare_idx].min_bitrate_bps =
+      ScreenshareMinBitrateKbps() * 1000;
+  params.video[screenshare_idx].target_bitrate_bps =
+      ScreenshareTargetBitrateKbps() * 1000;
+  params.video[screenshare_idx].max_bitrate_bps =
+      ScreenshareMaxBitrateKbps() * 1000;
+  params.video[screenshare_idx].codec = Codec();
+  params.video[screenshare_idx].num_temporal_layers =
+      ScreenshareNumTemporalLayers();
+  params.video[screenshare_idx].selected_tl = ScreenshareSelectedTL();
+  params.video[screenshare_idx].min_transmit_bps =
+      ScreenshareMinTransmitBitrateKbps() * 1000;
+  params.video[camera_idx].enabled = absl::GetFlag(FLAGS_video);
+  params.video[camera_idx].width = VideoWidth();
+  params.video[camera_idx].height = VideoHeight();
+  params.video[camera_idx].fps = VideoFps();
+  params.video[camera_idx].min_bitrate_bps = VideoMinBitrateKbps() * 1000;
+  params.video[camera_idx].target_bitrate_bps = VideoTargetBitrateKbps() * 1000;
+  params.video[camera_idx].max_bitrate_bps = VideoMaxBitrateKbps() * 1000;
+  params.video[camera_idx].suspend_below_min_bitrate =
+      absl::GetFlag(FLAGS_suspend_below_min_bitrate);
+  params.video[camera_idx].codec = Codec();
+  params.video[camera_idx].num_temporal_layers = VideoNumTemporalLayers();
+  params.video[camera_idx].selected_tl = VideoSelectedTL();
+  params.video[camera_idx].ulpfec = absl::GetFlag(FLAGS_use_ulpfec);
+  params.video[camera_idx].flexfec = absl::GetFlag(FLAGS_use_flexfec);
+  params.video[camera_idx].clip_path = VideoClip();
+  params.video[camera_idx].capture_device_index = GetCaptureDevice();
+  params.audio.enabled = absl::GetFlag(FLAGS_audio);
+  params.audio.sync_video = absl::GetFlag(FLAGS_audio_video_sync);
+  params.audio.dtx = absl::GetFlag(FLAGS_audio_dtx);
+  params.logging.rtc_event_log_name = RtcEventLogName();
+  params.logging.rtp_dump_name = RtpDumpName();
+  params.logging.encoded_frame_base_path = EncodedFramePath();
+  params.analyzer.test_label = "dual_streams";
+  params.analyzer.test_durations_secs = DurationSecs();
+  params.analyzer.graph_data_output_filename = OutputFilename();
+  params.analyzer.graph_title = GraphTitle();
   params.config = pipe_config;
 
   params.screenshare[camera_idx].enabled = false;
-  params.screenshare[screenshare_idx] = {true, GenerateSlides(),
-                                         SlideChangeInterval(),
-                                         ScrollDuration(), Slides()};
+  params.screenshare[screenshare_idx].enabled = true;
+  params.screenshare[screenshare_idx].generate_slides = GenerateSlides();
+  params.screenshare[screenshare_idx].slide_change_interval =
+      SlideChangeInterval();
+  params.screenshare[screenshare_idx].scroll_duration = ScrollDuration();
+  params.screenshare[screenshare_idx].slides = Slides();
 
   if (VideoNumStreams() > 1 && VideoStream0().empty() &&
       VideoStream1().empty()) {
diff --git a/video/video_loopback.cc b/video/video_loopback.cc
index 99ff4493bd..7762d9653d 100644
--- a/video/video_loopback.cc
+++ b/video/video_loopback.cc
@@ -376,33 +376,40 @@ void Loopback() {
   call_bitrate_config.max_bitrate_bps = -1;  // Don't cap bandwidth estimate.
 
   VideoQualityTest::Params params;
-  params.call = {absl::GetFlag(FLAGS_send_side_bwe),
-                 absl::GetFlag(FLAGS_generic_descriptor), call_bitrate_config,
-                 0};
-  params.video[0] = {absl::GetFlag(FLAGS_video),
-                     Width(),
-                     Height(),
-                     Fps(),
-                     MinBitrateKbps() * 1000,
-                     TargetBitrateKbps() * 1000,
-                     MaxBitrateKbps() * 1000,
-                     absl::GetFlag(FLAGS_suspend_below_min_bitrate),
-                     Codec(),
-                     NumTemporalLayers(),
-                     SelectedTL(),
-                     0,  // No min transmit bitrate.
-                     absl::GetFlag(FLAGS_use_ulpfec),
-                     absl::GetFlag(FLAGS_use_flexfec),
-                     NumStreams() < 2,  // Automatic quality scaling.
-                     Clip(),
-                     GetCaptureDevice()};
-  params.audio = {
-      absl::GetFlag(FLAGS_audio), absl::GetFlag(FLAGS_audio_video_sync),
-      absl::GetFlag(FLAGS_audio_dtx), absl::GetFlag(FLAGS_use_real_adm)};
-  params.logging = {RtcEventLogName(), RtpDumpName(), EncodedFramePath()};
+  params.call.send_side_bwe = absl::GetFlag(FLAGS_send_side_bwe);
+  params.call.generic_descriptor = absl::GetFlag(FLAGS_generic_descriptor);
+  params.call.call_bitrate_config = call_bitrate_config;
+
+  params.video[0].enabled = absl::GetFlag(FLAGS_video);
+  params.video[0].width = Width();
+  params.video[0].height = Height();
+  params.video[0].fps = Fps();
+  params.video[0].min_bitrate_bps = MinBitrateKbps() * 1000;
+  params.video[0].target_bitrate_bps = TargetBitrateKbps() * 1000;
+  params.video[0].max_bitrate_bps = MaxBitrateKbps() * 1000;
+  params.video[0].suspend_below_min_bitrate =
+      absl::GetFlag(FLAGS_suspend_below_min_bitrate);
+  params.video[0].codec = Codec();
+  params.video[0].num_temporal_layers = NumTemporalLayers();
+  params.video[0].selected_tl = SelectedTL();
+  params.video[0].min_transmit_bps = 0;
+  params.video[0].ulpfec = absl::GetFlag(FLAGS_use_ulpfec);
+  params.video[0].flexfec = absl::GetFlag(FLAGS_use_flexfec);
+  params.video[0].automatic_scaling = NumStreams() < 2;
+  params.video[0].clip_path = Clip();
+  params.video[0].capture_device_index = GetCaptureDevice();
+  params.audio.enabled = absl::GetFlag(FLAGS_audio);
+  params.audio.sync_video = absl::GetFlag(FLAGS_audio_video_sync);
+  params.audio.dtx = absl::GetFlag(FLAGS_audio_dtx);
+  params.audio.use_real_adm = absl::GetFlag(FLAGS_use_real_adm);
+  params.logging.rtc_event_log_name = RtcEventLogName();
+  params.logging.rtp_dump_name = RtpDumpName();
+  params.logging.encoded_frame_base_path = EncodedFramePath();
   params.screenshare[0].enabled = false;
-  params.analyzer = {"video",          0.0,         0.0, DurationSecs(),
-                     OutputFilename(), GraphTitle()};
+  params.analyzer.test_label = "video";
+  params.analyzer.test_durations_secs = DurationSecs();
+  params.analyzer.graph_data_output_filename = OutputFilename();
+  params.analyzer.graph_title = GraphTitle();
   params.config = pipe_config;
 
   if (NumStreams() > 1 && Stream0().empty() && Stream1().empty()) {
diff --git a/video/video_quality_test.cc b/video/video_quality_test.cc
index 88270b4b2e..d2f3f9b5b8 100644
--- a/video/video_quality_test.cc
+++ b/video/video_quality_test.cc
@@ -434,58 +434,6 @@ VideoQualityTest::VideoQualityTest(
       std::move(injection_components_->network_controller_factory);
 }
 
-VideoQualityTest::Params::Params()
-    : call({false, false, BitrateConstraints(), 0}),
-      video{{false,
-             640,
-             480,
-             30,
-             50,
-             800,
-             800,
-             false,
-             "VP8",
-             1,
-             -1,
-             0,
-             false,
-             false,
-             false,
-             "",
-             0,
-             {},
-             0.0},
-            {false,
-             640,
-             480,
-             30,
-             50,
-             800,
-             800,
-             false,
-             "VP8",
-             1,
-             -1,
-             0,
-             false,
-             false,
-             false,
-             "",
-             0,
-             {},
-             0.0}},
-      audio({false, false, false, false}),
-      screenshare{{false, false, 10, 0}, {false, false, 10, 0}},
-      analyzer({"", 0.0, 0.0, 0, "", ""}),
-      config(absl::nullopt),
-      ss{{std::vector<VideoStream>(), 0, 0, -1, InterLayerPredMode::kOn,
-          std::vector<SpatialLayer>()},
-         {std::vector<VideoStream>(), 0, 0, -1, InterLayerPredMode::kOn,
-          std::vector<SpatialLayer>()}},
-      logging({"", "", ""}) {}
-
-VideoQualityTest::Params::~Params() = default;
-
 VideoQualityTest::InjectionComponents::InjectionComponents() = default;
 
 VideoQualityTest::InjectionComponents::~InjectionComponents() = default;