diff --git a/p2p/BUILD.gn b/p2p/BUILD.gn
index b548f4b..96b24d8 100644
--- a/p2p/BUILD.gn
+++ b/p2p/BUILD.gn
@@ -736,7 +736,9 @@
   deps = [
     ":transport_description",
     "../api:candidate",
+    "../api:field_trials_view",
     "../api:packet_socket_factory",
+    "../api/task_queue:task_queue",
     "../rtc_base:async_packet_socket",
     "../rtc_base:callback_list",
     "../rtc_base:socket_address",
diff --git a/p2p/base/fake_port_allocator.h b/p2p/base/fake_port_allocator.h
index 9372c5a..d45d1e4 100644
--- a/p2p/base/fake_port_allocator.h
+++ b/p2p/base/fake_port_allocator.h
@@ -34,18 +34,12 @@
 
 class TestUDPPort : public UDPPort {
  public:
-  static TestUDPPort* Create(rtc::Thread* thread,
-                             rtc::PacketSocketFactory* factory,
-                             const rtc::Network* network,
+  static TestUDPPort* Create(const PortParametersRef& args,
                              uint16_t min_port,
                              uint16_t max_port,
-                             absl::string_view username,
-                             absl::string_view password,
-                             bool emit_localhost_for_anyaddress,
-                             const webrtc::FieldTrialsView* field_trials) {
-    TestUDPPort* port =
-        new TestUDPPort(thread, factory, network, min_port, max_port, username,
-                        password, emit_localhost_for_anyaddress, field_trials);
+                             bool emit_localhost_for_anyaddress) {
+    TestUDPPort* port = new TestUDPPort(args, min_port, max_port,
+                                        emit_localhost_for_anyaddress);
     if (!port->Init()) {
       delete port;
       port = nullptr;
@@ -54,25 +48,15 @@
   }
 
  protected:
-  TestUDPPort(rtc::Thread* thread,
-              rtc::PacketSocketFactory* factory,
-              const rtc::Network* network,
+  TestUDPPort(const PortParametersRef& args,
               uint16_t min_port,
               uint16_t max_port,
-              absl::string_view username,
-              absl::string_view password,
-              bool emit_localhost_for_anyaddress,
-              const webrtc::FieldTrialsView* field_trials)
-      : UDPPort(thread,
+              bool emit_localhost_for_anyaddress)
+      : UDPPort(args,
                 webrtc::IceCandidateType::kHost,
-                factory,
-                network,
                 min_port,
                 max_port,
-                username,
-                password,
-                emit_localhost_for_anyaddress,
-                field_trials) {}
+                emit_localhost_for_anyaddress) {}
 };
 
 // A FakePortAllocatorSession can be used with either a real or fake socket
@@ -123,9 +107,13 @@
           (rtc::HasIPv6Enabled() && (flags() & PORTALLOCATOR_ENABLE_IPV6))
               ? ipv6_network_
               : ipv4_network_;
-      port_.reset(TestUDPPort::Create(network_thread_, factory_, &network, 0, 0,
-                                      username(), password(), false,
-                                      field_trials_));
+      port_.reset(TestUDPPort::Create({.network_thread = network_thread_,
+                                       .socket_factory = factory_,
+                                       .network = &network,
+                                       .ice_username_fragment = username(),
+                                       .ice_password = password(),
+                                       .field_trials = field_trials_},
+                                      0, 0, false));
       RTC_DCHECK(port_);
       port_->SetIceTiebreaker(allocator_->ice_tiebreaker());
       port_->SubscribePortDestroyed(
diff --git a/p2p/base/port.cc b/p2p/base/port.cc
index 4e31cf9..272214c 100644
--- a/p2p/base/port.cc
+++ b/p2p/base/port.cc
@@ -95,52 +95,32 @@
 const char TCPTYPE_PASSIVE_STR[] = "passive";
 const char TCPTYPE_SIMOPEN_STR[] = "so";
 
-Port::Port(TaskQueueBase* thread,
-           webrtc::IceCandidateType type,
-           rtc::PacketSocketFactory* factory,
-           const rtc::Network* network,
-           absl::string_view username_fragment,
-           absl::string_view password,
-           const webrtc::FieldTrialsView* field_trials)
-    : Port(thread,
-           type,
-           factory,
-           network,
-           0,
-           0,
-           username_fragment,
-           password,
-           field_trials,
-           true) {}
+Port::Port(const PortParametersRef& args, webrtc::IceCandidateType type)
+    : Port(args, type, 0, 0, true) {}
 
-Port::Port(TaskQueueBase* thread,
+Port::Port(const PortParametersRef& args,
            webrtc::IceCandidateType type,
-           rtc::PacketSocketFactory* factory,
-           const rtc::Network* network,
            uint16_t min_port,
            uint16_t max_port,
-           absl::string_view username_fragment,
-           absl::string_view password,
-           const webrtc::FieldTrialsView* field_trials,
            bool shared_socket /*= false*/)
-    : thread_(thread),
-      factory_(factory),
-      field_trials_(field_trials),
+    : thread_(args.network_thread),
+      factory_(args.socket_factory),
+      field_trials_(args.field_trials),
       type_(type),
       send_retransmit_count_attribute_(false),
-      network_(network),
+      network_(args.network),
       min_port_(min_port),
       max_port_(max_port),
       component_(ICE_CANDIDATE_COMPONENT_DEFAULT),
       generation_(0),
-      ice_username_fragment_(username_fragment),
-      password_(password),
+      ice_username_fragment_(args.ice_username_fragment),
+      password_(args.ice_password),
       timeout_delay_(kPortTimeoutDelay),
       enable_port_packets_(false),
       ice_role_(ICEROLE_UNKNOWN),
       tiebreaker_(0),
       shared_socket_(shared_socket),
-      network_cost_(network->GetCost(*field_trials_)),
+      network_cost_(args.network->GetCost(*field_trials_)),
       weak_factory_(this) {
   RTC_DCHECK_RUN_ON(thread_);
   RTC_DCHECK(factory_ != nullptr);
@@ -159,6 +139,42 @@
                    << network_cost_;
 }
 
+Port::Port(TaskQueueBase* thread,
+           webrtc::IceCandidateType type,
+           rtc::PacketSocketFactory* factory,
+           const rtc::Network* network,
+           absl::string_view username_fragment,
+           absl::string_view password,
+           const webrtc::FieldTrialsView* field_trials)
+    : Port({.network_thread = thread,
+            .socket_factory = factory,
+            .network = network,
+            .ice_username_fragment = username_fragment,
+            .ice_password = password,
+            .field_trials = field_trials},
+           type) {}
+
+Port::Port(TaskQueueBase* thread,
+           webrtc::IceCandidateType type,
+           rtc::PacketSocketFactory* factory,
+           const rtc::Network* network,
+           uint16_t min_port,
+           uint16_t max_port,
+           absl::string_view username_fragment,
+           absl::string_view password,
+           const webrtc::FieldTrialsView* field_trials,
+           bool shared_socket /*= false*/)
+    : Port({.network_thread = thread,
+            .socket_factory = factory,
+            .network = network,
+            .ice_username_fragment = username_fragment,
+            .ice_password = password,
+            .field_trials = field_trials},
+           type,
+           min_port,
+           max_port,
+           shared_socket) {}
+
 Port::~Port() {
   RTC_DCHECK_RUN_ON(thread_);
   DestroyAllConnections();
diff --git a/p2p/base/port.h b/p2p/base/port.h
index 6cf71f4..ff55035 100644
--- a/p2p/base/port.h
+++ b/p2p/base/port.h
@@ -170,25 +170,45 @@
 // connections to similar mechanisms of the other client.  Subclasses of this
 // one add support for specific mechanisms like local UDP ports.
 class RTC_EXPORT Port : public PortInterface, public sigslot::has_slots<> {
+ public:
+  // A struct containing common arguments to creating a port. See also
+  // CreateRelayPortArgs.
+  struct PortParametersRef {
+    webrtc::TaskQueueBase* network_thread;
+    rtc::PacketSocketFactory* socket_factory;
+    const rtc::Network* network;
+    absl::string_view ice_username_fragment;
+    absl::string_view ice_password;
+    const webrtc::FieldTrialsView* field_trials;
+  };
+
  protected:
   // Constructors for use only by via constructors in derived classes.
-  Port(webrtc::TaskQueueBase* thread,
+  Port(const PortParametersRef& args, webrtc::IceCandidateType type);
+  Port(const PortParametersRef& args,
        webrtc::IceCandidateType type,
-       rtc::PacketSocketFactory* factory,
-       const rtc::Network* network,
-       absl::string_view username_fragment,
-       absl::string_view password,
-       const webrtc::FieldTrialsView* field_trials = nullptr);
-  Port(webrtc::TaskQueueBase* thread,
-       webrtc::IceCandidateType type,
-       rtc::PacketSocketFactory* factory,
-       const rtc::Network* network,
        uint16_t min_port,
        uint16_t max_port,
-       absl::string_view username_fragment,
-       absl::string_view password,
-       const webrtc::FieldTrialsView* field_trials = nullptr,
        bool shared_socket = false);
+  [[deprecated("Pass arguments using PortParametersRef")]] Port(
+      webrtc::TaskQueueBase* thread,
+      webrtc::IceCandidateType type,
+      rtc::PacketSocketFactory* factory,
+      const rtc::Network* network,
+      absl::string_view username_fragment,
+      absl::string_view password,
+      const webrtc::FieldTrialsView* field_trials = nullptr);
+  [[deprecated("Pass arguments using PortParametersRef")]] Port(
+      webrtc::TaskQueueBase* thread,
+      webrtc::IceCandidateType type,
+      rtc::PacketSocketFactory* factory,
+      const rtc::Network* network,
+      uint16_t min_port,
+      uint16_t max_port,
+      absl::string_view username_fragment,
+      absl::string_view password,
+      const webrtc::FieldTrialsView* field_trials = nullptr,
+      bool shared_socket = false);
 
  public:
   ~Port() override;
diff --git a/p2p/base/port_interface.h b/p2p/base/port_interface.h
index 4818982..34f835d 100644
--- a/p2p/base/port_interface.h
+++ b/p2p/base/port_interface.h
@@ -19,7 +19,9 @@
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 #include "api/candidate.h"
+#include "api/field_trials_view.h"
 #include "api/packet_socket_factory.h"
+#include "api/task_queue/task_queue_base.h"
 #include "p2p/base/transport_description.h"
 #include "rtc_base/async_packet_socket.h"
 #include "rtc_base/callback_list.h"
diff --git a/p2p/base/port_unittest.cc b/p2p/base/port_unittest.cc
index 81066cf..be3b365 100644
--- a/p2p/base/port_unittest.cc
+++ b/p2p/base/port_unittest.cc
@@ -140,23 +140,8 @@
 // Stub port class for testing STUN generation and processing.
 class TestPort : public Port {
  public:
-  TestPort(rtc::Thread* thread,
-           rtc::PacketSocketFactory* factory,
-           const rtc::Network* network,
-           uint16_t min_port,
-           uint16_t max_port,
-           absl::string_view username_fragment,
-           absl::string_view password,
-           const webrtc::FieldTrialsView* field_trials = nullptr)
-      : Port(thread,
-             IceCandidateType::kHost,
-             factory,
-             network,
-             min_port,
-             max_port,
-             username_fragment,
-             password,
-             field_trials) {}
+  TestPort(const PortParametersRef& args, uint16_t min_port, uint16_t max_port)
+      : Port(args, IceCandidateType::kHost, min_port, max_port) {}
   ~TestPort() {}
 
   // Expose GetStunMessage so that we can test it.
@@ -550,9 +535,13 @@
   }
   std::unique_ptr<UDPPort> CreateUdpPort(const SocketAddress& addr,
                                          PacketSocketFactory* socket_factory) {
-    auto port = UDPPort::Create(&main_, socket_factory, MakeNetwork(addr), 0, 0,
-                                username_, password_, true, absl::nullopt,
-                                &field_trials_);
+    auto port = UDPPort::Create({.network_thread = &main_,
+                                 .socket_factory = socket_factory,
+                                 .network = MakeNetwork(addr),
+                                 .ice_username_fragment = username_,
+                                 .ice_password = password_,
+                                 .field_trials = &field_trials_},
+                                0, 0, true, absl::nullopt);
     port->SetIceTiebreaker(kTiebreakerDefault);
     return port;
   }
@@ -562,9 +551,13 @@
       const SocketAddress& link_local_addr,
       PacketSocketFactory* socket_factory) {
     auto port = UDPPort::Create(
-        &main_, socket_factory,
-        MakeNetworkMultipleAddrs(global_addr, link_local_addr), 0, 0, username_,
-        password_, true, absl::nullopt, &field_trials_);
+        {.network_thread = &main_,
+         .socket_factory = socket_factory,
+         .network = MakeNetworkMultipleAddrs(global_addr, link_local_addr),
+         .ice_username_fragment = username_,
+         .ice_password = password_,
+         .field_trials = &field_trials_},
+        0, 0, true, absl::nullopt);
     port->SetIceTiebreaker(kTiebreakerDefault);
     return port;
   }
@@ -573,18 +566,28 @@
   }
   std::unique_ptr<TCPPort> CreateTcpPort(const SocketAddress& addr,
                                          PacketSocketFactory* socket_factory) {
-    auto port = TCPPort::Create(&main_, socket_factory, MakeNetwork(addr), 0, 0,
-                                username_, password_, true, &field_trials_);
+    auto port = TCPPort::Create({.network_thread = &main_,
+                                 .socket_factory = socket_factory,
+                                 .network = MakeNetwork(addr),
+                                 .ice_username_fragment = username_,
+                                 .ice_password = password_,
+                                 .field_trials = &field_trials_},
+                                0, 0, true);
     port->SetIceTiebreaker(kTiebreakerDefault);
     return port;
   }
-  std::unique_ptr<StunPort> CreateStunPort(const SocketAddress& addr,
-                                           rtc::PacketSocketFactory* factory) {
+  std::unique_ptr<StunPort> CreateStunPort(
+      const SocketAddress& addr,
+      rtc::PacketSocketFactory* socket_factory) {
     ServerAddresses stun_servers;
     stun_servers.insert(kStunAddr);
-    auto port = StunPort::Create(&main_, factory, MakeNetwork(addr), 0, 0,
-                                 username_, password_, stun_servers,
-                                 absl::nullopt, &field_trials_);
+    auto port = StunPort::Create({.network_thread = &main_,
+                                  .socket_factory = socket_factory,
+                                  .network = MakeNetwork(addr),
+                                  .ice_username_fragment = username_,
+                                  .ice_password = password_,
+                                  .field_trials = &field_trials_},
+                                 0, 0, stun_servers, absl::nullopt);
     port->SetIceTiebreaker(kTiebreakerDefault);
     return port;
   }
@@ -824,9 +827,13 @@
       absl::string_view username,
       absl::string_view password,
       const webrtc::FieldTrialsView* field_trials = nullptr) {
-    auto port =
-        std::make_unique<TestPort>(&main_, &socket_factory_, MakeNetwork(addr),
-                                   0, 0, username, password, field_trials);
+    Port::PortParametersRef args = {.network_thread = &main_,
+                                    .socket_factory = &socket_factory_,
+                                    .network = MakeNetwork(addr),
+                                    .ice_username_fragment = username,
+                                    .ice_password = password,
+                                    .field_trials = field_trials};
+    auto port = std::make_unique<TestPort>(args, 0, 0);
     port->SignalRoleConflict.connect(this, &PortTest::OnRoleConflict);
     return port;
   }
@@ -844,8 +851,13 @@
   std::unique_ptr<TestPort> CreateTestPort(const rtc::Network* network,
                                            absl::string_view username,
                                            absl::string_view password) {
-    auto port = std::make_unique<TestPort>(&main_, &socket_factory_, network, 0,
-                                           0, username, password);
+    Port::PortParametersRef args = {.network_thread = &main_,
+                                    .socket_factory = &socket_factory_,
+                                    .network = network,
+                                    .ice_username_fragment = username,
+                                    .ice_password = password,
+                                    .field_trials = nullptr};
+    auto port = std::make_unique<TestPort>(args, 0, 0);
     port->SignalRoleConflict.connect(this, &PortTest::OnRoleConflict);
     return port;
   }
diff --git a/p2p/base/stun_port.cc b/p2p/base/stun_port.cc
index cf8830a..93c3030 100644
--- a/p2p/base/stun_port.cc
+++ b/p2p/base/stun_port.cc
@@ -159,18 +159,13 @@
   return it->second->result().GetResolvedAddress(family, output);
 }
 
-UDPPort::UDPPort(rtc::Thread* thread,
+UDPPort::UDPPort(const PortParametersRef& args,
                  webrtc::IceCandidateType type,
-                 rtc::PacketSocketFactory* factory,
-                 const rtc::Network* network,
                  rtc::AsyncPacketSocket* socket,
-                 absl::string_view username,
-                 absl::string_view password,
-                 bool emit_local_for_anyaddress,
-                 const webrtc::FieldTrialsView* field_trials)
-    : Port(thread, type, factory, network, username, password, field_trials),
+                 bool emit_local_for_anyaddress)
+    : Port(args, type),
       request_manager_(
-          thread,
+          args.network_thread,
           [this](const void* data, size_t size, StunRequest* request) {
             OnSendPacket(data, size, request);
           }),
@@ -181,27 +176,14 @@
       dscp_(rtc::DSCP_NO_CHANGE),
       emit_local_for_anyaddress_(emit_local_for_anyaddress) {}
 
-UDPPort::UDPPort(rtc::Thread* thread,
+UDPPort::UDPPort(const PortParametersRef& args,
                  webrtc::IceCandidateType type,
-                 rtc::PacketSocketFactory* factory,
-                 const rtc::Network* network,
                  uint16_t min_port,
                  uint16_t max_port,
-                 absl::string_view username,
-                 absl::string_view password,
-                 bool emit_local_for_anyaddress,
-                 const webrtc::FieldTrialsView* field_trials)
-    : Port(thread,
-           type,
-           factory,
-           network,
-           min_port,
-           max_port,
-           username,
-           password,
-           field_trials),
+                 bool emit_local_for_anyaddress)
+    : Port(args, type, min_port, max_port),
       request_manager_(
-          thread,
+          args.network_thread,
           [this](const void* data, size_t size, StunRequest* request) {
             OnSendPacket(data, size, request);
           }),
@@ -624,7 +606,22 @@
 }
 
 std::unique_ptr<StunPort> StunPort::Create(
-    rtc::Thread* thread,
+    const PortParametersRef& args,
+    uint16_t min_port,
+    uint16_t max_port,
+    const ServerAddresses& servers,
+    absl::optional<int> stun_keepalive_interval) {
+  // Using `new` to access a non-public constructor.
+  auto port = absl::WrapUnique(new StunPort(args, min_port, max_port, servers));
+  port->set_stun_keepalive_delay(stun_keepalive_interval);
+  if (!port->Init()) {
+    return nullptr;
+  }
+  return port;
+}
+
+std::unique_ptr<StunPort> StunPort::Create(
+    webrtc::TaskQueueBase* thread,
     rtc::PacketSocketFactory* factory,
     const rtc::Network* network,
     uint16_t min_port,
@@ -634,36 +631,24 @@
     const ServerAddresses& servers,
     absl::optional<int> stun_keepalive_interval,
     const webrtc::FieldTrialsView* field_trials) {
-  // Using `new` to access a non-public constructor.
-  auto port = absl::WrapUnique(new StunPort(thread, factory, network, min_port,
-                                            max_port, username, password,
-                                            servers, field_trials));
-  port->set_stun_keepalive_delay(stun_keepalive_interval);
-  if (!port->Init()) {
-    return nullptr;
-  }
-  return port;
+  return Create({.network_thread = thread,
+                 .socket_factory = factory,
+                 .network = network,
+                 .ice_username_fragment = username,
+                 .ice_password = password,
+                 .field_trials = field_trials},
+                min_port, max_port, servers, stun_keepalive_interval);
 }
 
-StunPort::StunPort(rtc::Thread* thread,
-                   rtc::PacketSocketFactory* factory,
-                   const rtc::Network* network,
+StunPort::StunPort(const PortParametersRef& args,
                    uint16_t min_port,
                    uint16_t max_port,
-                   absl::string_view username,
-                   absl::string_view password,
-                   const ServerAddresses& servers,
-                   const webrtc::FieldTrialsView* field_trials)
-    : UDPPort(thread,
+                   const ServerAddresses& servers)
+    : UDPPort(args,
               webrtc::IceCandidateType::kSrflx,
-              factory,
-              network,
               min_port,
               max_port,
-              username,
-              password,
-              false,
-              field_trials) {
+              false) {
   set_server_addresses(servers);
 }
 
diff --git a/p2p/base/stun_port.h b/p2p/base/stun_port.h
index f558b92..3133a41 100644
--- a/p2p/base/stun_port.h
+++ b/p2p/base/stun_port.h
@@ -36,47 +36,77 @@
 class RTC_EXPORT UDPPort : public Port {
  public:
   static std::unique_ptr<UDPPort> Create(
-      rtc::Thread* thread,
-      rtc::PacketSocketFactory* factory,
-      const rtc::Network* network,
+      const PortParametersRef& args,
       rtc::AsyncPacketSocket* socket,
-      absl::string_view username,
-      absl::string_view password,
       bool emit_local_for_anyaddress,
-      absl::optional<int> stun_keepalive_interval,
-      const webrtc::FieldTrialsView* field_trials = nullptr) {
+      absl::optional<int> stun_keepalive_interval) {
     // Using `new` to access a non-public constructor.
-    auto port = absl::WrapUnique(new UDPPort(
-        thread, webrtc::IceCandidateType::kHost, factory, network, socket,
-        username, password, emit_local_for_anyaddress, field_trials));
+    auto port =
+        absl::WrapUnique(new UDPPort(args, webrtc::IceCandidateType::kHost,
+                                     socket, emit_local_for_anyaddress));
     port->set_stun_keepalive_delay(stun_keepalive_interval);
     if (!port->Init()) {
       return nullptr;
     }
     return port;
   }
+  [[deprecated("Pass arguments using PortParametersRef")]] static std::
+      unique_ptr<UDPPort>
+      Create(webrtc::TaskQueueBase* thread,
+             rtc::PacketSocketFactory* factory,
+             const rtc::Network* network,
+             rtc::AsyncPacketSocket* socket,
+             absl::string_view username,
+             absl::string_view password,
+             bool emit_local_for_anyaddress,
+             absl::optional<int> stun_keepalive_interval,
+             const webrtc::FieldTrialsView* field_trials = nullptr) {
+    return Create({.network_thread = thread,
+                   .socket_factory = factory,
+                   .network = network,
+                   .ice_username_fragment = username,
+                   .ice_password = password,
+                   .field_trials = field_trials},
+                  socket, emit_local_for_anyaddress, stun_keepalive_interval);
+  }
 
   static std::unique_ptr<UDPPort> Create(
-      rtc::Thread* thread,
-      rtc::PacketSocketFactory* factory,
-      const rtc::Network* network,
+      const PortParametersRef& args,
       uint16_t min_port,
       uint16_t max_port,
-      absl::string_view username,
-      absl::string_view password,
       bool emit_local_for_anyaddress,
-      absl::optional<int> stun_keepalive_interval,
-      const webrtc::FieldTrialsView* field_trials = nullptr) {
+      absl::optional<int> stun_keepalive_interval) {
     // Using `new` to access a non-public constructor.
-    auto port = absl::WrapUnique(new UDPPort(
-        thread, webrtc::IceCandidateType::kHost, factory, network, min_port,
-        max_port, username, password, emit_local_for_anyaddress, field_trials));
+    auto port = absl::WrapUnique(
+        new UDPPort(args, webrtc::IceCandidateType::kHost, min_port, max_port,
+                    emit_local_for_anyaddress));
     port->set_stun_keepalive_delay(stun_keepalive_interval);
     if (!port->Init()) {
       return nullptr;
     }
     return port;
   }
+  [[deprecated("Pass arguments using PortParametersRef")]] static std::
+      unique_ptr<UDPPort>
+      Create(webrtc::TaskQueueBase* thread,
+             rtc::PacketSocketFactory* factory,
+             const rtc::Network* network,
+             uint16_t min_port,
+             uint16_t max_port,
+             absl::string_view username,
+             absl::string_view password,
+             bool emit_local_for_anyaddress,
+             absl::optional<int> stun_keepalive_interval,
+             const webrtc::FieldTrialsView* field_trials = nullptr) {
+    return Create({.network_thread = thread,
+                   .socket_factory = factory,
+                   .network = network,
+                   .ice_username_fragment = username,
+                   .ice_password = password,
+                   .field_trials = field_trials},
+                  min_port, max_port, emit_local_for_anyaddress,
+                  stun_keepalive_interval);
+  }
 
   ~UDPPort() override;
 
@@ -117,27 +147,15 @@
   StunRequestManager& request_manager() { return request_manager_; }
 
  protected:
-  UDPPort(rtc::Thread* thread,
+  UDPPort(const PortParametersRef& args,
           webrtc::IceCandidateType type,
-          rtc::PacketSocketFactory* factory,
-          const rtc::Network* network,
+          rtc::AsyncPacketSocket* socket,
+          bool emit_local_for_anyaddress);
+  UDPPort(const PortParametersRef& args,
+          webrtc::IceCandidateType type,
           uint16_t min_port,
           uint16_t max_port,
-          absl::string_view username,
-          absl::string_view password,
-          bool emit_local_for_anyaddress,
-          const webrtc::FieldTrialsView* field_trials);
-
-  UDPPort(rtc::Thread* thread,
-          webrtc::IceCandidateType type,
-          rtc::PacketSocketFactory* factory,
-          const rtc::Network* network,
-          rtc::AsyncPacketSocket* socket,
-          absl::string_view username,
-          absl::string_view password,
-          bool emit_local_for_anyaddress,
-          const webrtc::FieldTrialsView* field_trials);
-
+          bool emit_local_for_anyaddress);
   bool Init();
 
   int SendTo(const void* data,
@@ -268,29 +286,30 @@
 class StunPort : public UDPPort {
  public:
   static std::unique_ptr<StunPort> Create(
-      rtc::Thread* thread,
-      rtc::PacketSocketFactory* factory,
-      const rtc::Network* network,
+      const PortParametersRef& args,
       uint16_t min_port,
       uint16_t max_port,
-      absl::string_view username,
-      absl::string_view password,
       const ServerAddresses& servers,
-      absl::optional<int> stun_keepalive_interval,
-      const webrtc::FieldTrialsView* field_trials);
-
+      absl::optional<int> stun_keepalive_interval);
+  [[deprecated("Pass arguments using PortParametersRef")]] static std::
+      unique_ptr<StunPort>
+      Create(webrtc::TaskQueueBase* thread,
+             rtc::PacketSocketFactory* factory,
+             const rtc::Network* network,
+             uint16_t min_port,
+             uint16_t max_port,
+             absl::string_view username,
+             absl::string_view password,
+             const ServerAddresses& servers,
+             absl::optional<int> stun_keepalive_interval,
+             const webrtc::FieldTrialsView* field_trials);
   void PrepareAddress() override;
 
  protected:
-  StunPort(rtc::Thread* thread,
-           rtc::PacketSocketFactory* factory,
-           const rtc::Network* network,
+  StunPort(const PortParametersRef& args,
            uint16_t min_port,
            uint16_t max_port,
-           absl::string_view username,
-           absl::string_view password,
-           const ServerAddresses& servers,
-           const webrtc::FieldTrialsView* field_trials);
+           const ServerAddresses& servers);
 };
 
 }  // namespace cricket
diff --git a/p2p/base/stun_port_unittest.cc b/p2p/base/stun_port_unittest.cc
index 9646fab..423d16b 100644
--- a/p2p/base/stun_port_unittest.cc
+++ b/p2p/base/stun_port_unittest.cc
@@ -137,9 +137,13 @@
   void CreateStunPort(const ServerAddresses& stun_servers,
                       const webrtc::FieldTrialsView* field_trials = nullptr) {
     stun_port_ = cricket::StunPort::Create(
-        rtc::Thread::Current(), socket_factory(), &network_, 0, 0,
-        rtc::CreateRandomString(16), rtc::CreateRandomString(22), stun_servers,
-        absl::nullopt, field_trials);
+        {.network_thread = rtc::Thread::Current(),
+         .socket_factory = socket_factory(),
+         .network = &network_,
+         .ice_username_fragment = rtc::CreateRandomString(16),
+         .ice_password = rtc::CreateRandomString(22),
+         .field_trials = field_trials},
+        0, 0, stun_servers, absl::nullopt);
     stun_port_->SetIceTiebreaker(kTiebreakerDefault);
     stun_port_->set_stun_keepalive_delay(stun_keepalive_delay_);
     // If `stun_keepalive_lifetime_` is negative, let the stun port
@@ -170,9 +174,13 @@
           OnReadPacket(socket, packet);
         });
     stun_port_ = cricket::UDPPort::Create(
-        rtc::Thread::Current(), socket_factory(), &network_, socket_.get(),
-        rtc::CreateRandomString(16), rtc::CreateRandomString(22), false,
-        absl::nullopt, field_trials);
+        {.network_thread = rtc::Thread::Current(),
+         .socket_factory = socket_factory(),
+         .network = &network_,
+         .ice_username_fragment = rtc::CreateRandomString(16),
+         .ice_password = rtc::CreateRandomString(22),
+         .field_trials = field_trials},
+        socket_.get(), false, absl::nullopt);
     ASSERT_TRUE(stun_port_ != NULL);
     stun_port_->SetIceTiebreaker(kTiebreakerDefault);
     ServerAddresses stun_servers;
diff --git a/p2p/base/tcp_port.cc b/p2p/base/tcp_port.cc
index 4d4373f..78c6e47 100644
--- a/p2p/base/tcp_port.cc
+++ b/p2p/base/tcp_port.cc
@@ -90,24 +90,11 @@
 using ::webrtc::SafeTask;
 using ::webrtc::TimeDelta;
 
-TCPPort::TCPPort(rtc::Thread* thread,
-                 rtc::PacketSocketFactory* factory,
-                 const rtc::Network* network,
+TCPPort::TCPPort(const PortParametersRef& args,
                  uint16_t min_port,
                  uint16_t max_port,
-                 absl::string_view username,
-                 absl::string_view password,
-                 bool allow_listen,
-                 const webrtc::FieldTrialsView* field_trials)
-    : Port(thread,
-           IceCandidateType::kHost,
-           factory,
-           network,
-           min_port,
-           max_port,
-           username,
-           password,
-           field_trials),
+                 bool allow_listen)
+    : Port(args, IceCandidateType::kHost, min_port, max_port),
       allow_listen_(allow_listen),
       error_(0) {
   // TODO(mallinath) - Set preference value as per RFC 6544.
diff --git a/p2p/base/tcp_port.h b/p2p/base/tcp_port.h
index bd7ed4c..37609ff 100644
--- a/p2p/base/tcp_port.h
+++ b/p2p/base/tcp_port.h
@@ -36,20 +36,32 @@
 // call this TCPPort::OnReadPacket (3 arg) to dispatch to a connection.
 class TCPPort : public Port {
  public:
-  static std::unique_ptr<TCPPort> Create(
-      rtc::Thread* thread,
-      rtc::PacketSocketFactory* factory,
-      const rtc::Network* network,
-      uint16_t min_port,
-      uint16_t max_port,
-      absl::string_view username,
-      absl::string_view password,
-      bool allow_listen,
-      const webrtc::FieldTrialsView* field_trials = nullptr) {
+  static std::unique_ptr<TCPPort> Create(const PortParametersRef& args,
+                                         uint16_t min_port,
+                                         uint16_t max_port,
+                                         bool allow_listen) {
     // Using `new` to access a non-public constructor.
-    return absl::WrapUnique(new TCPPort(thread, factory, network, min_port,
-                                        max_port, username, password,
-                                        allow_listen, field_trials));
+    return absl::WrapUnique(
+        new TCPPort(args, min_port, max_port, allow_listen));
+  }
+  [[deprecated("Pass arguments using PortParametersRef")]] static std::
+      unique_ptr<TCPPort>
+      Create(webrtc::TaskQueueBase* thread,
+             rtc::PacketSocketFactory* factory,
+             const rtc::Network* network,
+             uint16_t min_port,
+             uint16_t max_port,
+             absl::string_view username,
+             absl::string_view password,
+             bool allow_listen,
+             const webrtc::FieldTrialsView* field_trials = nullptr) {
+    return Create({.network_thread = thread,
+                   .socket_factory = factory,
+                   .network = network,
+                   .ice_username_fragment = username,
+                   .ice_password = password,
+                   .field_trials = field_trials},
+                  min_port, max_port, allow_listen);
   }
   ~TCPPort() override;
 
@@ -68,15 +80,10 @@
   ProtocolType GetProtocol() const override;
 
  protected:
-  TCPPort(rtc::Thread* thread,
-          rtc::PacketSocketFactory* factory,
-          const rtc::Network* network,
+  TCPPort(const PortParametersRef& args,
           uint16_t min_port,
           uint16_t max_port,
-          absl::string_view username,
-          absl::string_view password,
-          bool allow_listen,
-          const webrtc::FieldTrialsView* field_trials);
+          bool allow_listen);
 
   // Handles sending using the local TCP socket.
   int SendTo(const void* data,
diff --git a/p2p/base/tcp_port_unittest.cc b/p2p/base/tcp_port_unittest.cc
index 1bb5981..be246a8 100644
--- a/p2p/base/tcp_port_unittest.cc
+++ b/p2p/base/tcp_port_unittest.cc
@@ -84,16 +84,26 @@
 
   std::unique_ptr<TCPPort> CreateTCPPort(const SocketAddress& addr) {
     auto port = std::unique_ptr<TCPPort>(
-        TCPPort::Create(&main_, &socket_factory_, MakeNetwork(addr), 0, 0,
-                        username_, password_, true, &field_trials_));
+        TCPPort::Create({.network_thread = &main_,
+                         .socket_factory = &socket_factory_,
+                         .network = MakeNetwork(addr),
+                         .ice_username_fragment = username_,
+                         .ice_password = password_,
+                         .field_trials = &field_trials_},
+                        0, 0, true));
     port->SetIceTiebreaker(kTiebreakerDefault);
     return port;
   }
 
   std::unique_ptr<TCPPort> CreateTCPPort(const rtc::Network* network) {
     auto port = std::unique_ptr<TCPPort>(
-        TCPPort::Create(&main_, &socket_factory_, network, 0, 0, username_,
-                        password_, true, &field_trials_));
+        TCPPort::Create({.network_thread = &main_,
+                         .socket_factory = &socket_factory_,
+                         .network = network,
+                         .ice_username_fragment = username_,
+                         .ice_password = password_,
+                         .field_trials = &field_trials_},
+                        0, 0, true));
     port->SetIceTiebreaker(kTiebreakerDefault);
     return port;
   }
diff --git a/p2p/base/turn_port.cc b/p2p/base/turn_port.cc
index 3e29ded..71deb69 100644
--- a/p2p/base/turn_port.cc
+++ b/p2p/base/turn_port.cc
@@ -208,7 +208,68 @@
   webrtc::ScopedTaskSafety task_safety_;
 };
 
-TurnPort::TurnPort(TaskQueueBase* thread,
+TurnPort::TurnPort(const PortParametersRef& args,
+                   rtc::AsyncPacketSocket* socket,
+                   const ProtocolAddress& server_address,
+                   const RelayCredentials& credentials,
+                   int server_priority,
+                   const std::vector<std::string>& tls_alpn_protocols,
+                   const std::vector<std::string>& tls_elliptic_curves,
+                   webrtc::TurnCustomizer* customizer,
+                   rtc::SSLCertificateVerifier* tls_cert_verifier)
+    : Port(args, IceCandidateType::kRelay),
+      server_address_(server_address),
+      server_url_(ReconstructServerUrl()),
+      tls_alpn_protocols_(tls_alpn_protocols),
+      tls_elliptic_curves_(tls_elliptic_curves),
+      tls_cert_verifier_(tls_cert_verifier),
+      credentials_(credentials),
+      socket_(socket),
+      error_(0),
+      stun_dscp_value_(rtc::DSCP_NO_CHANGE),
+      request_manager_(
+          args.network_thread,
+          [this](const void* data, size_t size, StunRequest* request) {
+            OnSendStunPacket(data, size, request);
+          }),
+      next_channel_number_(TURN_CHANNEL_NUMBER_START),
+      state_(STATE_CONNECTING),
+      server_priority_(server_priority),
+      allocate_mismatch_retries_(0),
+      turn_customizer_(customizer) {}
+
+TurnPort::TurnPort(const PortParametersRef& args,
+                   uint16_t min_port,
+                   uint16_t max_port,
+                   const ProtocolAddress& server_address,
+                   const RelayCredentials& credentials,
+                   int server_priority,
+                   const std::vector<std::string>& tls_alpn_protocols,
+                   const std::vector<std::string>& tls_elliptic_curves,
+                   webrtc::TurnCustomizer* customizer,
+                   rtc::SSLCertificateVerifier* tls_cert_verifier)
+    : Port(args, IceCandidateType::kRelay, min_port, max_port),
+      server_address_(server_address),
+      server_url_(ReconstructServerUrl()),
+      tls_alpn_protocols_(tls_alpn_protocols),
+      tls_elliptic_curves_(tls_elliptic_curves),
+      tls_cert_verifier_(tls_cert_verifier),
+      credentials_(credentials),
+      socket_(nullptr),
+      error_(0),
+      stun_dscp_value_(rtc::DSCP_NO_CHANGE),
+      request_manager_(
+          args.network_thread,
+          [this](const void* data, size_t size, StunRequest* request) {
+            OnSendStunPacket(data, size, request);
+          }),
+      next_channel_number_(TURN_CHANNEL_NUMBER_START),
+      state_(STATE_CONNECTING),
+      server_priority_(server_priority),
+      allocate_mismatch_retries_(0),
+      turn_customizer_(customizer) {}
+
+TurnPort::TurnPort(webrtc::TaskQueueBase* thread,
                    rtc::PacketSocketFactory* factory,
                    const rtc::Network* network,
                    rtc::AsyncPacketSocket* socket,
@@ -222,34 +283,21 @@
                    webrtc::TurnCustomizer* customizer,
                    rtc::SSLCertificateVerifier* tls_cert_verifier,
                    const webrtc::FieldTrialsView* field_trials)
-    : Port(thread,
-           IceCandidateType::kRelay,
-           factory,
-           network,
-           username,
-           password,
-           field_trials),
-      server_address_(server_address),
-      server_url_(ReconstructServerUrl()),
-      tls_alpn_protocols_(tls_alpn_protocols),
-      tls_elliptic_curves_(tls_elliptic_curves),
-      tls_cert_verifier_(tls_cert_verifier),
-      credentials_(credentials),
-      socket_(socket),
-      error_(0),
-      stun_dscp_value_(rtc::DSCP_NO_CHANGE),
-      request_manager_(
-          thread,
-          [this](const void* data, size_t size, StunRequest* request) {
-            OnSendStunPacket(data, size, request);
-          }),
-      next_channel_number_(TURN_CHANNEL_NUMBER_START),
-      state_(STATE_CONNECTING),
-      server_priority_(server_priority),
-      allocate_mismatch_retries_(0),
-      turn_customizer_(customizer) {}
-
-TurnPort::TurnPort(TaskQueueBase* thread,
+    : TurnPort({.network_thread = thread,
+                .socket_factory = factory,
+                .network = network,
+                .ice_username_fragment = username,
+                .ice_password = password,
+                .field_trials = field_trials},
+               socket,
+               server_address,
+               credentials,
+               server_priority,
+               tls_alpn_protocols,
+               tls_elliptic_curves,
+               customizer,
+               tls_cert_verifier) {}
+TurnPort::TurnPort(webrtc::TaskQueueBase* thread,
                    rtc::PacketSocketFactory* factory,
                    const rtc::Network* network,
                    uint16_t min_port,
@@ -264,34 +312,21 @@
                    webrtc::TurnCustomizer* customizer,
                    rtc::SSLCertificateVerifier* tls_cert_verifier,
                    const webrtc::FieldTrialsView* field_trials)
-    : Port(thread,
-           IceCandidateType::kRelay,
-           factory,
-           network,
-           min_port,
-           max_port,
-           username,
-           password,
-           field_trials),
-      server_address_(server_address),
-      server_url_(ReconstructServerUrl()),
-      tls_alpn_protocols_(tls_alpn_protocols),
-      tls_elliptic_curves_(tls_elliptic_curves),
-      tls_cert_verifier_(tls_cert_verifier),
-      credentials_(credentials),
-      socket_(nullptr),
-      error_(0),
-      stun_dscp_value_(rtc::DSCP_NO_CHANGE),
-      request_manager_(
-          thread,
-          [this](const void* data, size_t size, StunRequest* request) {
-            OnSendStunPacket(data, size, request);
-          }),
-      next_channel_number_(TURN_CHANNEL_NUMBER_START),
-      state_(STATE_CONNECTING),
-      server_priority_(server_priority),
-      allocate_mismatch_retries_(0),
-      turn_customizer_(customizer) {}
+    : TurnPort({.network_thread = thread,
+                .socket_factory = factory,
+                .network = network,
+                .ice_username_fragment = username,
+                .ice_password = password,
+                .field_trials = field_trials},
+               min_port,
+               max_port,
+               server_address,
+               credentials,
+               server_priority,
+               tls_alpn_protocols,
+               tls_elliptic_curves,
+               customizer,
+               tls_cert_verifier) {}
 
 TurnPort::~TurnPort() {
   // TODO(juberti): Should this even be necessary?
diff --git a/p2p/base/turn_port.h b/p2p/base/turn_port.h
index 69832ae..f8783d5 100644
--- a/p2p/base/turn_port.h
+++ b/p2p/base/turn_port.h
@@ -81,12 +81,16 @@
     }
     // Using `new` to access a non-public constructor.
     return absl::WrapUnique(
-        new TurnPort(args.network_thread, args.socket_factory, args.network,
-                     socket, args.username, args.password, *args.server_address,
-                     args.config->credentials, args.relative_priority,
-                     args.config->tls_alpn_protocols,
+        new TurnPort({.network_thread = args.network_thread,
+                      .socket_factory = args.socket_factory,
+                      .network = args.network,
+                      .ice_username_fragment = args.username,
+                      .ice_password = args.password,
+                      .field_trials = args.field_trials},
+                     socket, *args.server_address, args.config->credentials,
+                     args.relative_priority, args.config->tls_alpn_protocols,
                      args.config->tls_elliptic_curves, args.turn_customizer,
-                     args.config->tls_cert_verifier, args.field_trials));
+                     args.config->tls_cert_verifier));
   }
 
   // Create a TURN port that will use a new socket, bound to `network` and
@@ -98,13 +102,17 @@
       return nullptr;
     }
     // Using `new` to access a non-public constructor.
-    return absl::WrapUnique(
-        new TurnPort(args.network_thread, args.socket_factory, args.network,
-                     min_port, max_port, args.username, args.password,
-                     *args.server_address, args.config->credentials,
-                     args.relative_priority, args.config->tls_alpn_protocols,
-                     args.config->tls_elliptic_curves, args.turn_customizer,
-                     args.config->tls_cert_verifier, args.field_trials));
+    return absl::WrapUnique(new TurnPort(
+        {.network_thread = args.network_thread,
+         .socket_factory = args.socket_factory,
+         .network = args.network,
+         .ice_username_fragment = args.username,
+         .ice_password = args.password,
+         .field_trials = args.field_trials},
+        min_port, max_port, *args.server_address, args.config->credentials,
+        args.relative_priority, args.config->tls_alpn_protocols,
+        args.config->tls_elliptic_curves, args.turn_customizer,
+        args.config->tls_cert_verifier));
   }
 
   ~TurnPort() override;
@@ -201,36 +209,59 @@
   void SetCallbacksForTest(CallbacksForTest* callbacks);
 
  protected:
-  TurnPort(webrtc::TaskQueueBase* thread,
-           rtc::PacketSocketFactory* factory,
-           const rtc::Network* network,
+  TurnPort(const PortParametersRef& args,
            rtc::AsyncPacketSocket* socket,
-           absl::string_view username,
-           absl::string_view password,
            const ProtocolAddress& server_address,
            const RelayCredentials& credentials,
            int server_priority,
            const std::vector<std::string>& tls_alpn_protocols,
            const std::vector<std::string>& tls_elliptic_curves,
            webrtc::TurnCustomizer* customizer,
-           rtc::SSLCertificateVerifier* tls_cert_verifier = nullptr,
-           const webrtc::FieldTrialsView* field_trials = nullptr);
+           rtc::SSLCertificateVerifier* tls_cert_verifier = nullptr);
 
-  TurnPort(webrtc::TaskQueueBase* thread,
-           rtc::PacketSocketFactory* factory,
-           const rtc::Network* network,
+  TurnPort(const PortParametersRef& args,
            uint16_t min_port,
            uint16_t max_port,
-           absl::string_view username,
-           absl::string_view password,
            const ProtocolAddress& server_address,
            const RelayCredentials& credentials,
            int server_priority,
            const std::vector<std::string>& tls_alpn_protocols,
            const std::vector<std::string>& tls_elliptic_curves,
            webrtc::TurnCustomizer* customizer,
-           rtc::SSLCertificateVerifier* tls_cert_verifier = nullptr,
-           const webrtc::FieldTrialsView* field_trials = nullptr);
+           rtc::SSLCertificateVerifier* tls_cert_verifier = nullptr);
+
+  [[deprecated("Pass arguments using PortParametersRef")]] TurnPort(
+      webrtc::TaskQueueBase* thread,
+      rtc::PacketSocketFactory* factory,
+      const rtc::Network* network,
+      rtc::AsyncPacketSocket* socket,
+      absl::string_view username,
+      absl::string_view password,
+      const ProtocolAddress& server_address,
+      const RelayCredentials& credentials,
+      int server_priority,
+      const std::vector<std::string>& tls_alpn_protocols,
+      const std::vector<std::string>& tls_elliptic_curves,
+      webrtc::TurnCustomizer* customizer,
+      rtc::SSLCertificateVerifier* tls_cert_verifier = nullptr,
+      const webrtc::FieldTrialsView* field_trials = nullptr);
+
+  [[deprecated("Pass arguments using PortParametersRef")]] TurnPort(
+      webrtc::TaskQueueBase* thread,
+      rtc::PacketSocketFactory* factory,
+      const rtc::Network* network,
+      uint16_t min_port,
+      uint16_t max_port,
+      absl::string_view username,
+      absl::string_view password,
+      const ProtocolAddress& server_address,
+      const RelayCredentials& credentials,
+      int server_priority,
+      const std::vector<std::string>& tls_alpn_protocols,
+      const std::vector<std::string>& tls_elliptic_curves,
+      webrtc::TurnCustomizer* customizer,
+      rtc::SSLCertificateVerifier* tls_cert_verifier = nullptr,
+      const webrtc::FieldTrialsView* field_trials = nullptr);
 
   // NOTE: This method needs to be accessible for StunPort
   // return true if entry was created (i.e channel_number consumed).
diff --git a/p2p/base/turn_port_unittest.cc b/p2p/base/turn_port_unittest.cc
index 6915afa..66a1540 100644
--- a/p2p/base/turn_port_unittest.cc
+++ b/p2p/base/turn_port_unittest.cc
@@ -366,9 +366,13 @@
   void CreateUdpPort() { CreateUdpPort(kLocalAddr2); }
 
   void CreateUdpPort(const SocketAddress& address) {
-    udp_port_ = UDPPort::Create(&main_, socket_factory(), MakeNetwork(address),
-                                0, 0, kIceUfrag2, kIcePwd2, false,
-                                absl::nullopt, &field_trials_);
+    udp_port_ = UDPPort::Create({.network_thread = &main_,
+                                 .socket_factory = socket_factory(),
+                                 .network = MakeNetwork(address),
+                                 .ice_username_fragment = kIceUfrag2,
+                                 .ice_password = kIcePwd2,
+                                 .field_trials = &field_trials_},
+                                0, 0, false, absl::nullopt);
     // UDP port will be controlled.
     udp_port_->SetIceRole(ICEROLE_CONTROLLED);
     udp_port_->SetIceTiebreaker(kTiebreakerDefault);
diff --git a/p2p/client/basic_port_allocator.cc b/p2p/client/basic_port_allocator.cc
index 832d6da..f1525b0 100644
--- a/p2p/client/basic_port_allocator.cc
+++ b/p2p/client/basic_port_allocator.cc
@@ -1470,19 +1470,25 @@
       !IsFlagSet(PORTALLOCATOR_DISABLE_DEFAULT_LOCAL_CANDIDATE);
   if (IsFlagSet(PORTALLOCATOR_ENABLE_SHARED_SOCKET) && udp_socket_) {
     port = UDPPort::Create(
-        session_->network_thread(), session_->socket_factory(), network_,
-        udp_socket_.get(), session_->username(), session_->password(),
-        emit_local_candidate_for_anyaddress,
-        session_->allocator()->stun_candidate_keepalive_interval(),
-        session_->allocator()->field_trials());
+        {.network_thread = session_->network_thread(),
+         .socket_factory = session_->socket_factory(),
+         .network = network_,
+         .ice_username_fragment = session_->username(),
+         .ice_password = session_->password(),
+         .field_trials = session_->allocator()->field_trials()},
+        udp_socket_.get(), emit_local_candidate_for_anyaddress,
+        session_->allocator()->stun_candidate_keepalive_interval());
   } else {
     port = UDPPort::Create(
-        session_->network_thread(), session_->socket_factory(), network_,
+        {.network_thread = session_->network_thread(),
+         .socket_factory = session_->socket_factory(),
+         .network = network_,
+         .ice_username_fragment = session_->username(),
+         .ice_password = session_->password(),
+         .field_trials = session_->allocator()->field_trials()},
         session_->allocator()->min_port(), session_->allocator()->max_port(),
-        session_->username(), session_->password(),
         emit_local_candidate_for_anyaddress,
-        session_->allocator()->stun_candidate_keepalive_interval(),
-        session_->allocator()->field_trials());
+        session_->allocator()->stun_candidate_keepalive_interval());
   }
 
   if (port) {
@@ -1516,11 +1522,15 @@
   }
 
   std::unique_ptr<Port> port = TCPPort::Create(
-      session_->network_thread(), session_->socket_factory(), network_,
+      {.network_thread = session_->network_thread(),
+       .socket_factory = session_->socket_factory(),
+       .network = network_,
+       .ice_username_fragment = session_->username(),
+       .ice_password = session_->password(),
+       .field_trials = session_->allocator()->field_trials()},
       session_->allocator()->min_port(), session_->allocator()->max_port(),
-      session_->username(), session_->password(),
-      session_->allocator()->allow_tcp_listen(),
-      session_->allocator()->field_trials());
+
+      session_->allocator()->allow_tcp_listen());
   if (port) {
     port->SetIceTiebreaker(session_->allocator()->ice_tiebreaker());
     session_->AddAllocatedPort(port.release(), this);
@@ -1546,11 +1556,15 @@
   }
 
   std::unique_ptr<StunPort> port = StunPort::Create(
-      session_->network_thread(), session_->socket_factory(), network_,
+      {.network_thread = session_->network_thread(),
+       .socket_factory = session_->socket_factory(),
+       .network = network_,
+       .ice_username_fragment = session_->username(),
+       .ice_password = session_->password(),
+       .field_trials = session_->allocator()->field_trials()},
       session_->allocator()->min_port(), session_->allocator()->max_port(),
-      session_->username(), session_->password(), config_->StunServers(),
-      session_->allocator()->stun_candidate_keepalive_interval(),
-      session_->allocator()->field_trials());
+      config_->StunServers(),
+      session_->allocator()->stun_candidate_keepalive_interval());
   if (port) {
     port->SetIceTiebreaker(session_->allocator()->ice_tiebreaker());
     session_->AddAllocatedPort(port.release(), this);