diff --git a/call/adaptation/resource_adaptation_processor.cc b/call/adaptation/resource_adaptation_processor.cc
index c6b1374..254d006 100644
--- a/call/adaptation/resource_adaptation_processor.cc
+++ b/call/adaptation/resource_adaptation_processor.cc
@@ -326,7 +326,8 @@
 ResourceAdaptationProcessor::FindMostLimitedResources() const {
   std::vector<scoped_refptr<Resource>> most_limited_resources;
   VideoStreamAdapter::RestrictionsWithCounters most_limited_restrictions{
-      VideoSourceRestrictions(), VideoAdaptationCounters()};
+      .restrictions = VideoSourceRestrictions(),
+      .counters = VideoAdaptationCounters()};
 
   for (const auto& resource_and_adaptation_limit_ :
        adaptation_limits_by_resources_) {
@@ -355,7 +356,7 @@
       adaptation_limits.counters == counters) {
     return;
   }
-  adaptation_limits = {restrictions, counters};
+  adaptation_limits = {.restrictions = restrictions, .counters = counters};
 
   std::map<scoped_refptr<Resource>, VideoAdaptationCounters> limitations;
   for (const auto& p : adaptation_limits_by_resources_) {
diff --git a/call/adaptation/video_stream_adapter.cc b/call/adaptation/video_stream_adapter.cc
index 5863931..e296a36 100644
--- a/call/adaptation/video_stream_adapter.cc
+++ b/call/adaptation/video_stream_adapter.cc
@@ -246,8 +246,8 @@
   // Invalidate any previously returned Adaptation.
   RTC_LOG(LS_INFO) << "Resetting restrictions";
   ++adaptation_validation_id_;
-  current_restrictions_ = {VideoSourceRestrictions(),
-                           VideoAdaptationCounters()};
+  current_restrictions_ = {.restrictions = VideoSourceRestrictions(),
+                           .counters = VideoAdaptationCounters()};
   awaiting_frame_size_change_ = std::nullopt;
   BroadcastVideoRestrictionsUpdate(input_state_provider_->InputState(),
                                    nullptr);
@@ -327,9 +327,10 @@
     VideoStreamAdapter::RestrictionsOrState step_or_state,
     const VideoStreamInputState& input_state) const {
   RTC_DCHECK(!step_or_state.valueless_by_exception());
-  return std::visit(
-      RestrictionsOrStateVisitor{adaptation_validation_id_, input_state},
-      step_or_state);
+  return std::visit(RestrictionsOrStateVisitor{.adaptation_validation_id =
+                                                   adaptation_validation_id_,
+                                               .input_state = input_state},
+                    step_or_state);
 }
 
 Adaptation VideoStreamAdapter::GetAdaptationUp(
@@ -676,7 +677,8 @@
   } else {
     awaiting_frame_size_change_ = std::nullopt;
   }
-  current_restrictions_ = {adaptation.restrictions(), adaptation.counters()};
+  current_restrictions_ = {.restrictions = adaptation.restrictions(),
+                           .counters = adaptation.counters()};
   BroadcastVideoRestrictionsUpdate(adaptation.input_state(), resource);
 }
 
diff --git a/call/bitrate_allocator.cc b/call/bitrate_allocator.cc
index 434fd81..c0744e2 100644
--- a/call/bitrate_allocator.cc
+++ b/call/bitrate_allocator.cc
@@ -143,9 +143,9 @@
   std::vector<PriorityRateObserverConfig> priority_rate_observers;
   for (const auto& observer_config : allocatable_tracks) {
     priority_rate_observers.push_back(PriorityRateObserverConfig{
-        observer_config.observer,
-        observers_capacities.at(observer_config.observer),
-        observer_config.config.bitrate_priority});
+        .allocation_key = observer_config.observer,
+        .capacity_bps = observers_capacities.at(observer_config.observer),
+        .bitrate_priority = observer_config.config.bitrate_priority});
     bitrate_priority_sum += observer_config.config.bitrate_priority;
   }
 
diff --git a/call/bitrate_allocator_unittest.cc b/call/bitrate_allocator_unittest.cc
index b4bb332..51cc607 100644
--- a/call/bitrate_allocator_unittest.cc
+++ b/call/bitrate_allocator_unittest.cc
@@ -135,10 +135,14 @@
       bool enforce_min_bitrate,
       double bitrate_priority,
       std::optional<TrackRateElasticity> rate_elasticity = std::nullopt) {
-    allocator_->AddObserver(
-        observer, {min_bitrate_bps, max_bitrate_bps, pad_up_bitrate_bps,
-                   /* priority_bitrate */ 0, enforce_min_bitrate,
-                   bitrate_priority, rate_elasticity});
+    allocator_->AddObserver(observer,
+                            {.min_bitrate_bps = min_bitrate_bps,
+                             .max_bitrate_bps = max_bitrate_bps,
+                             .pad_up_bitrate_bps = pad_up_bitrate_bps,
+                             .priority_bitrate_bps = 0,
+                             .enforce_min_bitrate = enforce_min_bitrate,
+                             .bitrate_priority = bitrate_priority,
+                             .rate_elasticity = rate_elasticity});
   }
   MediaStreamAllocationConfig DefaultConfig() const {
     MediaStreamAllocationConfig default_config;
@@ -334,9 +338,13 @@
                    bool enforce_min_bitrate,
                    absl::string_view /* track_id */,
                    double bitrate_priority) {
-    allocator_->AddObserver(
-        observer, {min_bitrate_bps, max_bitrate_bps, pad_up_bitrate_bps, 0,
-                   enforce_min_bitrate, bitrate_priority});
+    allocator_->AddObserver(observer,
+                            {.min_bitrate_bps = min_bitrate_bps,
+                             .max_bitrate_bps = max_bitrate_bps,
+                             .pad_up_bitrate_bps = pad_up_bitrate_bps,
+                             .priority_bitrate_bps = 0,
+                             .enforce_min_bitrate = enforce_min_bitrate,
+                             .bitrate_priority = bitrate_priority});
   }
   NiceMock<MockLimitObserver> limit_observer_;
   std::unique_ptr<BitrateAllocator> allocator_;
diff --git a/call/payload_type_picker.cc b/call/payload_type_picker.cc
index 9b4e7f1..c25c0d6 100644
--- a/call/payload_type_picker.cc
+++ b/call/payload_type_picker.cc
@@ -138,18 +138,18 @@
   // Default audio codecs. Duplicates media/engine/payload_type_mapper.cc
   const MapTableEntry default_audio_mappings[] = {
       // Static payload type assignments according to RFC 3551.
-      {{kPcmuCodecName, 8000, 1}, 0},
-      {{"GSM", 8000, 1}, 3},
-      {{"G723", 8000, 1}, 4},
-      {{"DVI4", 8000, 1}, 5},
-      {{"DVI4", 16000, 1}, 6},
-      {{"LPC", 8000, 1}, 7},
-      {{kPcmaCodecName, 8000, 1}, 8},
-      {{kG722CodecName, 8000, 1}, 9},
-      {{kL16CodecName, 44100, 2}, 10},
-      {{kL16CodecName, 44100, 1}, 11},
-      {{"QCELP", 8000, 1}, 12},
-      {{kCnCodecName, 8000, 1}, 13},
+      {.format = {kPcmuCodecName, 8000, 1}, .payload_type = 0},
+      {.format = {"GSM", 8000, 1}, .payload_type = 3},
+      {.format = {"G723", 8000, 1}, .payload_type = 4},
+      {.format = {"DVI4", 8000, 1}, .payload_type = 5},
+      {.format = {"DVI4", 16000, 1}, .payload_type = 6},
+      {.format = {"LPC", 8000, 1}, .payload_type = 7},
+      {.format = {kPcmaCodecName, 8000, 1}, .payload_type = 8},
+      {.format = {kG722CodecName, 8000, 1}, .payload_type = 9},
+      {.format = {kL16CodecName, 44100, 2}, .payload_type = 10},
+      {.format = {kL16CodecName, 44100, 1}, .payload_type = 11},
+      {.format = {"QCELP", 8000, 1}, .payload_type = 12},
+      {.format = {kCnCodecName, 8000, 1}, .payload_type = 13},
       // RFC 4566 is a bit ambiguous on the contents of the "encoding
       // parameters" field, which, for audio, encodes the number of
       // channels. It is "optional and may be omitted if the number of
@@ -158,39 +158,39 @@
       // specify a value for this parameter for MPA, I've included both 0
       // and 1 here, to increase the chances it will be correctly used if
       // someone implements an MPEG audio encoder/decoder.
-      {{"MPA", 90000, 0}, 14},
-      {{"MPA", 90000, 1}, 14},
-      {{"G728", 8000, 1}, 15},
-      {{"DVI4", 11025, 1}, 16},
-      {{"DVI4", 22050, 1}, 17},
-      {{"G729", 8000, 1}, 18},
+      {.format = {"MPA", 90000, 0}, .payload_type = 14},
+      {.format = {"MPA", 90000, 1}, .payload_type = 14},
+      {.format = {"G728", 8000, 1}, .payload_type = 15},
+      {.format = {"DVI4", 11025, 1}, .payload_type = 16},
+      {.format = {"DVI4", 22050, 1}, .payload_type = 17},
+      {.format = {"G729", 8000, 1}, .payload_type = 18},
 
       // Payload type assignments currently used by WebRTC.
       // Includes data to reduce collisions (and thus reassignments)
       // TODO(bugs.webrtc.org/400630582): Delete this, it's only for test
       // stability.
-      {{"reserved-do-not-use", 1, 0}, 102},
-      {{kCnCodecName, 16000, 1}, 105},
-      {{kCnCodecName, 32000, 1}, 106},
-      {{kOpusCodecName,
-        48000,
-        2,
-        {{kCodecParamMinPTime, "10"},
-         {kCodecParamUseInbandFec, kParamValueTrue}}},
-       111},
+      {.format = {"reserved-do-not-use", 1, 0}, .payload_type = 102},
+      {.format = {kCnCodecName, 16000, 1}, .payload_type = 105},
+      {.format = {kCnCodecName, 32000, 1}, .payload_type = 106},
+      {.format = {kOpusCodecName,
+                  48000,
+                  2,
+                  {{kCodecParamMinPTime, "10"},
+                   {kCodecParamUseInbandFec, kParamValueTrue}}},
+       .payload_type = 111},
       // RED for opus is assigned in the lower range, starting at the top.
       // Note that the FMTP refers to the opus payload type.
-      {{kRedCodecName,
-        48000,
-        2,
-        {{kCodecParamNotInNameValueFormat, "111/111"}}},
-       63},
+      {.format = {kRedCodecName,
+                  48000,
+                  2,
+                  {{kCodecParamNotInNameValueFormat, "111/111"}}},
+       .payload_type = 63},
       // TODO(solenberg): Remove the hard coded 16k,32k,48k DTMF once we
       // assign payload types dynamically for send side as well.
-      {{kDtmfCodecName, 48000, 1}, 110},
-      {{kDtmfCodecName, 32000, 1}, 112},
-      {{kDtmfCodecName, 16000, 1}, 113},
-      {{kDtmfCodecName, 8000, 1}, 126}};
+      {.format = {kDtmfCodecName, 48000, 1}, .payload_type = 110},
+      {.format = {kDtmfCodecName, 32000, 1}, .payload_type = 112},
+      {.format = {kDtmfCodecName, 16000, 1}, .payload_type = 113},
+      {.format = {kDtmfCodecName, 8000, 1}, .payload_type = 126}};
   for (const MapTableEntry& entry : default_audio_mappings) {
     AddMapping(PayloadType(entry.payload_type), CreateAudioCodec(entry.format));
   }
diff --git a/p2p/base/basic_ice_controller.cc b/p2p/base/basic_ice_controller.cc
index 3dce374..ca8f826 100644
--- a/p2p/base/basic_ice_controller.cc
+++ b/p2p/base/basic_ice_controller.cc
@@ -449,7 +449,7 @@
   if (!field_trials_->initial_select_dampening.has_value() &&
       !field_trials_->initial_select_dampening_ping_received.has_value()) {
     // experiment not enabled => select connection.
-    return {new_connection, std::nullopt};
+    return {.connection = new_connection};
   }
 
   int64_t now = TimeMillis();
@@ -470,7 +470,7 @@
                      << initial_select_timestamp_ms_
                      << " selection delayed by: " << (now - start_wait) << "ms";
     initial_select_timestamp_ms_ = 0;
-    return {new_connection, std::nullopt};
+    return {.connection = new_connection};
   }
 
   // We are not yet ready to select first connection...
@@ -493,8 +493,7 @@
   }
 
   RTC_LOG(LS_INFO) << "delay initial selection up to " << min_delay << "ms";
-  return {.connection = std::nullopt,
-          .recheck_event = IceRecheckEvent(
+  return {.recheck_event = IceRecheckEvent(
               IceSwitchReason::ICE_CONTROLLER_RECHECK, min_delay)};
 }
 
@@ -502,7 +501,7 @@
     IceSwitchReason reason,
     const Connection* new_connection) {
   if (!ReadyToSend(new_connection) || selected_connection_ == new_connection) {
-    return {std::nullopt, std::nullopt};
+    return {};
   }
 
   if (selected_connection_ == nullptr) {
@@ -515,7 +514,7 @@
   int compare_a_b_by_networks = CompareCandidatePairNetworks(
       new_connection, selected_connection_, config_.network_preference);
   if (compare_a_b_by_networks == b_is_better && !new_connection->receiving()) {
-    return {std::nullopt, std::nullopt};
+    return {};
   }
 
   bool missed_receiving_unchanged_threshold = false;
@@ -537,18 +536,18 @@
   }
 
   if (cmp < 0) {
-    return {new_connection, std::nullopt};
+    return {.connection = new_connection};
   } else if (cmp > 0) {
-    return {std::nullopt, recheck_event};
+    return {.recheck_event = recheck_event};
   }
 
   // If everything else is the same, switch only if rtt has improved by
   // a margin.
   if (new_connection->rtt() <= selected_connection_->rtt() - kMinImprovement) {
-    return {new_connection, std::nullopt};
+    return {.connection = new_connection};
   }
 
-  return {std::nullopt, recheck_event};
+  return {.recheck_event = recheck_event};
 }
 
 IceControllerInterface::SwitchResult
diff --git a/p2p/base/p2p_transport_channel.cc b/p2p/base/p2p_transport_channel.cc
index 4904e5b..323cdd2 100644
--- a/p2p/base/p2p_transport_channel.cc
+++ b/p2p/base/p2p_transport_channel.cc
@@ -219,18 +219,21 @@
   ParseFieldTrials(field_trials);
 
   IceControllerFactoryArgs args{
-      [this] { return GetState(); }, [this] { return GetIceRole(); },
-      [this](const Connection* connection) {
-        return IsPortPruned(connection->port()) ||
-               IsRemoteCandidatePruned(connection->remote_candidate());
-      },
-      &ice_field_trials_,
-      field_trials ? field_trials->Lookup("WebRTC-IceControllerFieldTrials")
-                   : ""};
+      .ice_transport_state_func = [this] { return GetState(); },
+      .ice_role_func = [this] { return GetIceRole(); },
+      .is_connection_pruned_func =
+          [this](const Connection* connection) {
+            return IsPortPruned(connection->port()) ||
+                   IsRemoteCandidatePruned(connection->remote_candidate());
+          },
+      .ice_field_trials = &ice_field_trials_,
+      .ice_controller_field_trials =
+          field_trials ? field_trials->Lookup("WebRTC-IceControllerFieldTrials")
+                       : ""};
 
   if (active_ice_controller_factory) {
-    ActiveIceControllerFactoryArgs active_args{args,
-                                               /* ice_agent= */ this};
+    ActiveIceControllerFactoryArgs active_args{.legacy_args = args,
+                                               .ice_agent = this};
     ice_controller_ = active_ice_controller_factory->Create(active_args);
   } else {
     ice_controller_ = std::make_unique<WrappingActiveIceController>(
diff --git a/p2p/base/stun_port_unittest.cc b/p2p/base/stun_port_unittest.cc
index 963335b..6fa8096 100644
--- a/p2p/base/stun_port_unittest.cc
+++ b/p2p/base/stun_port_unittest.cc
@@ -760,10 +760,10 @@
 }
 
 const IPAddressTypeTestConfig kAllIPAddressTypeTestConfigs[] = {
-    {"127.0.0.1", webrtc::IPAddressType::kLoopback},
-    {"localhost", webrtc::IPAddressType::kLoopback},
-    {"10.0.0.3", webrtc::IPAddressType::kPrivate},
-    {"1.1.1.1", webrtc::IPAddressType::kPublic},
+    {.address = "127.0.0.1", .address_type = webrtc::IPAddressType::kLoopback},
+    {.address = "localhost", .address_type = webrtc::IPAddressType::kLoopback},
+    {.address = "10.0.0.3", .address_type = webrtc::IPAddressType::kPrivate},
+    {.address = "1.1.1.1", .address_type = webrtc::IPAddressType::kPublic},
 };
 
 INSTANTIATE_TEST_SUITE_P(All,
@@ -1019,9 +1019,11 @@
 }
 
 const IPAddressTypeTestConfig kAllIPv6AddressTypeTestConfigs[] = {
-    {"::1", webrtc::IPAddressType::kLoopback},
-    {"fd00:4860:4860::8844", webrtc::IPAddressType::kPrivate},
-    {"2001:4860:4860::8888", webrtc::IPAddressType::kPublic},
+    {.address = "::1", .address_type = webrtc::IPAddressType::kLoopback},
+    {.address = "fd00:4860:4860::8844",
+     .address_type = webrtc::IPAddressType::kPrivate},
+    {.address = "2001:4860:4860::8888",
+     .address_type = webrtc::IPAddressType::kPublic},
 };
 
 INSTANTIATE_TEST_SUITE_P(All,
diff --git a/p2p/base/turn_port_unittest.cc b/p2p/base/turn_port_unittest.cc
index e296ed7..152f70a 100644
--- a/p2p/base/turn_port_unittest.cc
+++ b/p2p/base/turn_port_unittest.cc
@@ -2183,13 +2183,14 @@
   absl::string_view address;
   IPAddressType address_type;
 } kAllIPAddressTypeTestConfigs[] = {
-    {"127.0.0.1", IPAddressType::kLoopback},
-    {"localhost", IPAddressType::kLoopback},
-    {"::1", IPAddressType::kLoopback},
-    {"10.0.0.3", IPAddressType::kPrivate},
-    {"fd00:4860:4860::8844", IPAddressType::kPrivate},
-    {"1.1.1.1", IPAddressType::kPublic},
-    {"2001:4860:4860::8888", IPAddressType::kPublic},
+    {.address = "127.0.0.1", .address_type = IPAddressType::kLoopback},
+    {.address = "localhost", .address_type = IPAddressType::kLoopback},
+    {.address = "::1", .address_type = IPAddressType::kLoopback},
+    {.address = "10.0.0.3", .address_type = IPAddressType::kPrivate},
+    {.address = "fd00:4860:4860::8844",
+     .address_type = IPAddressType::kPrivate},
+    {.address = "1.1.1.1", .address_type = IPAddressType::kPublic},
+    {.address = "2001:4860:4860::8888", .address_type = IPAddressType::kPublic},
 };
 
 // Used by the test framework to print the param value for parameterized tests.
diff --git a/p2p/base/wrapping_active_ice_controller_unittest.cc b/p2p/base/wrapping_active_ice_controller_unittest.cc
index df31376..074f3b6 100644
--- a/p2p/base/wrapping_active_ice_controller_unittest.cc
+++ b/p2p/base/wrapping_active_ice_controller_unittest.cc
@@ -128,10 +128,10 @@
   std::vector<const Connection*> conns_to_forget{kConnectionTwo};
   int recheck_delay_ms = 10;
   IceControllerInterface::SwitchResult switch_result{
-      kConnection,
-      IceRecheckEvent(IceSwitchReason::ICE_CONTROLLER_RECHECK,
-                      recheck_delay_ms),
-      conns_to_forget};
+      .connection = kConnection,
+      .recheck_event = IceRecheckEvent(IceSwitchReason::ICE_CONTROLLER_RECHECK,
+                                       recheck_delay_ms),
+      .connections_to_forget_state_on = conns_to_forget};
 
   // ICE controller should switch to given connection immediately.
   Sequence check_then_switch;
@@ -174,10 +174,10 @@
   std::vector<const Connection*> conns_to_prune{kConnectionThree};
   int recheck_delay_ms = 10;
   IceControllerInterface::SwitchResult switch_result{
-      kConnection,
-      IceRecheckEvent(IceSwitchReason::ICE_CONTROLLER_RECHECK,
-                      recheck_delay_ms),
-      conns_to_forget};
+      .connection = kConnection,
+      .recheck_event = IceRecheckEvent(IceSwitchReason::ICE_CONTROLLER_RECHECK,
+                                       recheck_delay_ms),
+      .connections_to_forget_state_on = conns_to_forget};
 
   Sequence sort_and_switch;
   EXPECT_CALL(agent, UpdateConnectionStates()).InSequence(sort_and_switch);
@@ -239,10 +239,10 @@
   std::vector<const Connection*> conns_to_forget{kConnectionTwo};
   int recheck_delay_ms = 10;
   IceControllerInterface::SwitchResult switch_result{
-      kConnection,
-      IceRecheckEvent(IceSwitchReason::ICE_CONTROLLER_RECHECK,
-                      recheck_delay_ms),
-      conns_to_forget};
+      .connection = kConnection,
+      .recheck_event = IceRecheckEvent(IceSwitchReason::ICE_CONTROLLER_RECHECK,
+                                       recheck_delay_ms),
+      .connections_to_forget_state_on = conns_to_forget};
 
   // Sort and switch should take place as the subsequent task.
   Sequence sort_and_switch;
diff --git a/p2p/dtls/dtls_transport_unittest.cc b/p2p/dtls/dtls_transport_unittest.cc
index fd06974..d31f64f 100644
--- a/p2p/dtls/dtls_transport_unittest.cc
+++ b/p2p/dtls/dtls_transport_unittest.cc
@@ -731,8 +731,8 @@
   int version_bytes;
   const std::vector<HandshakeTestEvent>& events;
 } kEventsPerVersion[] = {
-    {kDtls12VersionBytes, dtls_12_handshake_events},
-    {kDtls13VersionBytes, dtls_13_handshake_events},
+    {.version_bytes = kDtls12VersionBytes, .events = dtls_12_handshake_events},
+    {.version_bytes = kDtls13VersionBytes, .events = dtls_13_handshake_events},
 };
 
 struct EndpointConfig {
diff --git a/p2p/test/turn_server.cc b/p2p/test/turn_server.cc
index 57fb0fd..0f03db9 100644
--- a/p2p/test/turn_server.cc
+++ b/p2p/test/turn_server.cc
@@ -128,7 +128,8 @@
 
   RTC_DCHECK(server_listen_sockets_.end() ==
              server_listen_sockets_.find(socket));
-  server_listen_sockets_[socket] = {proto, std::move(ssl_adapter_factory)};
+  server_listen_sockets_[socket] = {
+      .proto = proto, .ssl_adapter_factory = std::move(ssl_adapter_factory)};
   socket->SignalReadEvent.connect(this, &TurnServer::OnNewInternalConnection);
 }
 
diff --git a/rtc_base/async_dns_resolver.cc b/rtc_base/async_dns_resolver.cc
index b11175a..5847650 100644
--- a/rtc_base/async_dns_resolver.cc
+++ b/rtc_base/async_dns_resolver.cc
@@ -48,8 +48,7 @@
                     std::vector<IPAddress>& addresses) {
   addresses.clear();
   struct addrinfo* result = nullptr;
-  struct addrinfo hints = {0};
-  hints.ai_family = family;
+  struct addrinfo hints = {.ai_flags = AI_ADDRCONFIG, .ai_family = family};
   // `family` here will almost always be AF_UNSPEC, because `family` comes from
   // AsyncResolver::addr_.family(), which comes from a SocketAddress constructed
   // with a hostname. When a SocketAddress is constructed with a hostname, its
@@ -67,7 +66,6 @@
   // Android (source code, not documentation):
   // https://android.googlesource.com/platform/bionic/+/
   // 7e0bfb511e85834d7c6cb9631206b62f82701d60/libc/netbsd/net/getaddrinfo.c#1657
-  hints.ai_flags = AI_ADDRCONFIG;
   int ret =
       getaddrinfo(std::string(hostname).c_str(), nullptr, &hints, &result);
   if (ret != 0) {
diff --git a/rtc_base/base64_unittest.cc b/rtc_base/base64_unittest.cc
index 51c90d5..d3804b2 100644
--- a/rtc_base/base64_unittest.cc
+++ b/rtc_base/base64_unittest.cc
@@ -66,11 +66,11 @@
 };
 
 const Base64DecodeTestCase kBase64DecodeTestCases[] = {
-    {"InvalidCharacters", "invalid;;;", std::nullopt},
-    {"InvalidLength", "abcde", std::nullopt},
-    {"ValidInput", "abcd", "i\xB7\x1D"},
-    {"ValidInputPadding", "abc=", "i\xB7"},
-    {"EmptyInput", "", ""},
+    {.name = "InvalidCharacters", .data = "invalid;;;", .result = std::nullopt},
+    {.name = "InvalidLength", .data = "abcde", .result = std::nullopt},
+    {.name = "ValidInput", .data = "abcd", .result = "i\xB7\x1D"},
+    {.name = "ValidInputPadding", .data = "abc=", .result = "i\xB7"},
+    {.name = "EmptyInput", .data = "", .result = ""},
 };
 
 using Base64DecodeTest = TestWithParam<Base64DecodeTestCase>;
@@ -93,31 +93,35 @@
 
 const Base64DecodeTestCase kBase64DecodeForgivingTestCases[] = {
     {
-        "ForgivingPadding",
-        "abc",
-        "i\xB7",
+        .name = "ForgivingPadding",
+        .data = "abc",
+        .result = "i\xB7",
     },
     {
-        "WhitespaceForgivenTab",
-        "ab\tcd",
-        "i\xB7\x1D",
+        .name = "WhitespaceForgivenTab",
+        .data = "ab\tcd",
+        .result = "i\xB7\x1D",
     },
     {
-        "WhitespaceForgivenSpace",
-        "a bc d",
-        "i\xB7\x1D",
+        .name = "WhitespaceForgivenSpace",
+        .data = "a bc d",
+        .result = "i\xB7\x1D",
     },
     {
-        "WhitespaceForgivenNewline",
-        "a\nbc\nd",
-        "i\xB7\x1D",
+        .name = "WhitespaceForgivenNewline",
+        .data = "a\nbc\nd",
+        .result = "i\xB7\x1D",
     },
     {
-        "WhitespaceForgivenCarriageReturn",
-        "a\r\nbc\rd",
-        "i\xB7\x1D",
+        .name = "WhitespaceForgivenCarriageReturn",
+        .data = "a\r\nbc\rd",
+        .result = "i\xB7\x1D",
     },
-    {"WhitespaceForgivenLineFeed", "a\fbcd", "i\xB7\x1D"},
+    {
+        .name = "WhitespaceForgivenLineFeed",
+        .data = "a\fbcd",
+        .result = "i\xB7\x1D",
+    },
 };
 
 using Base64DecodeForgivingTest = TestWithParam<Base64DecodeTestCase>;
diff --git a/rtc_base/experiments/field_trial_units.cc b/rtc_base/experiments/field_trial_units.cc
index f65db33..1322f29 100644
--- a/rtc_base/experiments/field_trial_units.cc
+++ b/rtc_base/experiments/field_trial_units.cc
@@ -34,16 +34,18 @@
 
 std::optional<ValueWithUnit> ParseValueWithUnit(absl::string_view str) {
   if (str == "inf") {
-    return ValueWithUnit{std::numeric_limits<double>::infinity(), ""};
+    return ValueWithUnit{.value = std::numeric_limits<double>::infinity(),
+                         .unit = ""};
   } else if (str == "-inf") {
-    return ValueWithUnit{-std::numeric_limits<double>::infinity(), ""};
+    return ValueWithUnit{.value = -std::numeric_limits<double>::infinity(),
+                         .unit = ""};
   } else {
     double double_val;
     char unit_char[RTC_TRIAL_UNIT_SIZE];
     unit_char[0] = 0;
     if (sscanf(std::string(str).c_str(), "%lf%" RTC_TRIAL_UNIT_LENGTH_STR "s",
                &double_val, unit_char) >= 1) {
-      return ValueWithUnit{double_val, unit_char};
+      return ValueWithUnit{.value = double_val, .unit = unit_char};
     }
   }
   return std::nullopt;
diff --git a/rtc_base/experiments/quality_scaling_experiment_unittest.cc b/rtc_base/experiments/quality_scaling_experiment_unittest.cc
index 65e9253..acd7d00 100644
--- a/rtc_base/experiments/quality_scaling_experiment_unittest.cc
+++ b/rtc_base/experiments/quality_scaling_experiment_unittest.cc
@@ -58,8 +58,17 @@
 }
 
 TEST(QualityScalingExperimentTest, ParseSettings) {
-  const QualityScalingExperiment::Settings kExpected = {1, 2, 3,    4,     5, 6,
-                                                        7, 8, 0.9f, 0.99f, 1};
+  const QualityScalingExperiment::Settings kExpected = {.vp8_low = 1,
+                                                        .vp8_high = 2,
+                                                        .vp9_low = 3,
+                                                        .vp9_high = 4,
+                                                        .h264_low = 5,
+                                                        .h264_high = 6,
+                                                        .generic_low = 7,
+                                                        .generic_high = 8,
+                                                        .alpha_high = 0.9f,
+                                                        .alpha_low = 0.99f,
+                                                        .drop = 1};
   FieldTrials field_trials(
       "WebRTC-Video-QualityScaling/Enabled-1,2,3,4,5,6,7,8,0.9,0.99,1/");
   const auto settings = QualityScalingExperiment::ParseSettings(field_trials);
diff --git a/rtc_base/logging.cc b/rtc_base/logging.cc
index f157205..53faf0e 100644
--- a/rtc_base/logging.cc
+++ b/rtc_base/logging.cc
@@ -460,7 +460,8 @@
   const char* tag = nullptr;
   switch (*fmt) {
     case LogArgType::kLogMetadata: {
-      meta = {va_arg(args, LogMetadata), ERRCTX_NONE, 0};
+      meta = {
+          .meta = va_arg(args, LogMetadata), .err_ctx = ERRCTX_NONE, .err = 0};
       break;
     }
     case LogArgType::kLogMetadataErr: {
diff --git a/rtc_base/openssl_stream_adapter.cc b/rtc_base/openssl_stream_adapter.cc
index 50be6b5..4acbb55 100644
--- a/rtc_base/openssl_stream_adapter.cc
+++ b/rtc_base/openssl_stream_adapter.cc
@@ -82,10 +82,10 @@
 
 // This isn't elegant, but it's better than an external reference
 constexpr SrtpCipherMapEntry kSrtpCipherMap[] = {
-    {"SRTP_AES128_CM_SHA1_80", kSrtpAes128CmSha1_80},
-    {"SRTP_AES128_CM_SHA1_32", kSrtpAes128CmSha1_32},
-    {"SRTP_AEAD_AES_128_GCM", kSrtpAeadAes128Gcm},
-    {"SRTP_AEAD_AES_256_GCM", kSrtpAeadAes256Gcm}};
+    {.internal_name = "SRTP_AES128_CM_SHA1_80", .id = kSrtpAes128CmSha1_80},
+    {.internal_name = "SRTP_AES128_CM_SHA1_32", .id = kSrtpAes128CmSha1_32},
+    {.internal_name = "SRTP_AEAD_AES_128_GCM", .id = kSrtpAeadAes128Gcm},
+    {.internal_name = "SRTP_AEAD_AES_256_GCM", .id = kSrtpAeadAes256Gcm}};
 
 #ifdef OPENSSL_IS_BORINGSSL
 // Enabled by EnableTimeCallbackForTesting. Should never be set in production
@@ -1271,16 +1271,17 @@
 
 static const cipher_list OK_DTLS13_ciphers[] = {
 #ifdef TLS1_3_CK_AES_128_GCM_SHA256  // BoringSSL TLS 1.3
-    {static_cast<uint16_t>(TLS1_3_CK_AES_128_GCM_SHA256 & 0xffff),
-     "TLS_AES_128_GCM_SHA256"},
+    {.cipher = static_cast<uint16_t>(TLS1_3_CK_AES_128_GCM_SHA256 & 0xffff),
+     .cipher_str = "TLS_AES_128_GCM_SHA256"},
 #endif
 #ifdef TLS1_3_CK_AES_256_GCM_SHA256  // BoringSSL TLS 1.3
     {static_cast<uint16_t>(TLS1_3_CK_AES_256_GCM_SHA256 & 0xffff),
      "TLS_AES_256_GCM_SHA256"},
 #endif
 #ifdef TLS1_3_CK_CHACHA20_POLY1305_SHA256  // BoringSSL TLS 1.3
-    {static_cast<uint16_t>(TLS1_3_CK_CHACHA20_POLY1305_SHA256 & 0xffff),
-     "TLS_CHACHA20_POLY1305_SHA256"},
+    {.cipher =
+         static_cast<uint16_t>(TLS1_3_CK_CHACHA20_POLY1305_SHA256 & 0xffff),
+     .cipher_str = "TLS_CHACHA20_POLY1305_SHA256"},
 #endif
 };
 
diff --git a/rtc_base/physical_socket_server.cc b/rtc_base/physical_socket_server.cc
index 2116af1..10adcfe 100644
--- a/rtc_base/physical_socket_server.cc
+++ b/rtc_base/physical_socket_server.cc
@@ -1631,7 +1631,7 @@
     return;
   }
 
-  struct epoll_event event = {0};
+  struct epoll_event event = {};
   event.events = GetEpollEvents(pdispatcher->GetRequestedEvents());
   if (event.events == 0u) {
     // Don't add at all if we don't have any requested events. Could indicate a
@@ -1654,7 +1654,7 @@
     return;
   }
 
-  struct epoll_event event = {0};
+  struct epoll_event event = {};
   int err = epoll_ctl(epoll_fd_, EPOLL_CTL_DEL, fd, &event);
   RTC_DCHECK(err == 0 || errno == ENOENT);
   // Ignore ENOENT, which could occur if this descriptor wasn't added due to
@@ -1672,7 +1672,7 @@
     return;
   }
 
-  struct epoll_event event = {0};
+  struct epoll_event event = {};
   event.events = GetEpollEvents(pdispatcher->GetRequestedEvents());
   event.data.u64 = key;
   // Remove if we don't have any requested events. Could indicate a closed
diff --git a/rtc_base/ssl_identity_unittest.cc b/rtc_base/ssl_identity_unittest.cc
index fb6ff08..136ef60 100644
--- a/rtc_base/ssl_identity_unittest.cc
+++ b/rtc_base/ssl_identity_unittest.cc
@@ -514,58 +514,63 @@
       int64_t want;
     } static const data[] = {
         // clang-format off
-        // clang formatting breaks this nice alignment
+      // clang formatting breaks this nice alignment
 
       // Valid examples.
-      {"19700101000000Z",  true,  0},
-      {"700101000000Z",    false, 0},
-      {"19700101000001Z",  true,  1},
-      {"700101000001Z",    false, 1},
-      {"19700101000100Z",  true,  60},
-      {"19700101000101Z",  true,  61},
-      {"19700101010000Z",  true,  3600},
-      {"19700101010001Z",  true,  3601},
-      {"19700101010100Z",  true,  3660},
-      {"19700101010101Z",  true,  3661},
-      {"710911012345Z",    false, 53400225},
-      {"20000101000000Z",  true,  946684800},
-      {"20000101000000Z",  true,  946684800},
-      {"20151130140156Z",  true,  1448892116},
-      {"151130140156Z",    false, 1448892116},
-      {"20491231235959Z",  true,  2524607999},
-      {"491231235959Z",    false, 2524607999},
-      {"20500101000000Z",  true,  2524607999+1},
-      {"20700101000000Z",  true,  3155760000},
-      {"21000101000000Z",  true,  4102444800},
-      {"24000101000000Z",  true,  13569465600},
+      {.string="19700101000000Z",  .long_format=true,  .want=0},
+      {.string="700101000000Z",    .long_format=false, .want=0},
+      {.string="19700101000001Z",  .long_format=true,  .want=1},
+      {.string="700101000001Z",    .long_format=false, .want=1},
+      {.string="19700101000100Z",  .long_format=true,  .want=60},
+      {.string="19700101000101Z",  .long_format=true,  .want=61},
+      {.string="19700101010000Z",  .long_format=true,  .want=3600},
+      {.string="19700101010001Z",  .long_format=true,  .want=3601},
+      {.string="19700101010100Z",  .long_format=true,  .want=3660},
+      {.string="19700101010101Z",  .long_format=true,  .want=3661},
+      {.string="710911012345Z",    .long_format=false, .want=53400225},
+      {.string="20000101000000Z",  .long_format=true,  .want=946684800},
+      {.string="20000101000000Z",  .long_format=true,  .want=946684800},
+      {.string="20151130140156Z",  .long_format=true,  .want=1448892116},
+      {.string="151130140156Z",    .long_format=false, .want=1448892116},
+      {.string="20491231235959Z",  .long_format=true,  .want=2524607999},
+      {.string="491231235959Z",    .long_format=false, .want=2524607999},
+      {.string="20500101000000Z",  .long_format=true,  .want=2524607999+1},
+      {.string="20700101000000Z",  .long_format=true,  .want=3155760000},
+      {.string="21000101000000Z",  .long_format=true,  .want=4102444800},
+      {.string="24000101000000Z",  .long_format=true,  .want=13569465600},
 
       // Invalid examples.
-      {"19700101000000",    true,  -1},  // missing Z long format
-      {"19700101000000X",   true,  -1},  // X instead of Z long format
-      {"197001010000000",   true,  -1},  // 0 instead of Z long format
-      {"1970010100000000Z", true,  -1},  // excess digits long format
-      {"700101000000",      false, -1},  // missing Z short format
-      {"700101000000X",     false, -1},  // X instead of Z short format
-      {"7001010000000",     false, -1},  // 0 instead of Z short format
-      {"70010100000000Z",   false, -1},  // excess digits short format
-      {":9700101000000Z",   true,  -1},  // invalid character
-      {"1:700101000001Z",   true,  -1},  // invalid character
-      {"19:00101000100Z",   true,  -1},  // invalid character
-      {"197:0101000101Z",   true,  -1},  // invalid character
-      {"1970:101010000Z",   true,  -1},  // invalid character
-      {"19700:01010001Z",   true,  -1},  // invalid character
-      {"197001:1010100Z",   true,  -1},  // invalid character
-      {"1970010:010101Z",   true,  -1},  // invalid character
-      {"70010100:000Z",     false, -1},  // invalid character
-      {"700101000:01Z",     false, -1},  // invalid character
-      {"2000010100:000Z",   true,  -1},  // invalid character
-      {"21000101000:00Z",   true,  -1},  // invalid character
-      {"240001010000:0Z",   true,  -1},  // invalid character
-      {"500101000000Z",     false, -1},  // but too old for epoch
-      {"691231235959Z",     false, -1},  // too old for epoch
-      {"19611118043000Z",   false, -1},  // way too old for epoch
-
-        // clang-format off
+      // Long format: missing Z, X instead of Z, 0 instead of Z,
+      // excess digits.
+      {.string="19700101000000",    .long_format=true,  .want=-1},
+      {.string="19700101000000X",   .long_format=true,  .want=-1},
+      {.string="197001010000000",   .long_format=true,  .want=-1},
+      {.string="1970010100000000Z", .long_format=true,  .want=-1},
+      // Short format: missing Z, X instead of Z, 0 instead of Z,
+      // excess digits.
+      {.string="700101000000",      .long_format=false, .want=-1},
+      {.string="700101000000X",     .long_format=false, .want=-1},
+      {.string="7001010000000",     .long_format=false, .want=-1},
+      {.string="70010100000000Z",   .long_format=false, .want=-1},
+      // Invalid character.
+      {.string=":9700101000000Z",   .long_format=true,  .want=-1},
+      {.string="1:700101000001Z",   .long_format=true,  .want=-1},
+      {.string="19:00101000100Z",   .long_format=true,  .want=-1},
+      {.string="197:0101000101Z",   .long_format=true,  .want=-1},
+      {.string="1970:101010000Z",   .long_format=true,  .want=-1},
+      {.string="19700:01010001Z",   .long_format=true,  .want=-1},
+      {.string="197001:1010100Z",   .long_format=true,  .want=-1},
+      {.string="1970010:010101Z",   .long_format=true,  .want=-1},
+      {.string="70010100:000Z",     .long_format=false, .want=-1},
+      {.string="700101000:01Z",     .long_format=false, .want=-1},
+      {.string="2000010100:000Z",   .long_format=true,  .want=-1},
+      {.string="21000101000:00Z",   .long_format=true,  .want=-1},
+      {.string="240001010000:0Z",   .long_format=true,  .want=-1},
+      // Dates prior to unix epoch (January 1st, 1970).
+      {.string="500101000000Z",     .long_format=false, .want=-1},
+      {.string="691231235959Z",     .long_format=false, .want=-1},
+      {.string="19611118043000Z",   .long_format=false, .want=-1},
+      // clang-format off
     };
 
     unsigned char buf[EVP_MAX_MD_SIZE];
diff --git a/rtc_base/synchronization/yield.cc b/rtc_base/synchronization/yield.cc
index 812dfe6..f53ceb2 100644
--- a/rtc_base/synchronization/yield.cc
+++ b/rtc_base/synchronization/yield.cc
@@ -29,7 +29,7 @@
     !RTC_USE_NATIVE_MUTEX_ON_MAC
   sched_yield();
 #else
-  static const struct timespec ts_null = {0};
+  static const struct timespec ts_null = {.tv_sec = 0, .tv_nsec = 0};
   nanosleep(&ts_null, nullptr);
 #endif
 }