Make Port constructor take a CreatePortArgs argument
Introduces a struct CreatePortArgs that is similar to the existing
CreateRelayPortArgs and contains parameters that will be passed from
the constructors of descendents of the Port class to the Port.
This struct makes it easier to add new arguments to the port
constructor without changing all inheriting classes.
Rebase of https://webrtc-review.googlesource.com/c/src/+/341021
BUG=webrtc:14626
Change-Id: Id8e5c24a36149e1699e2b42c57e52002d27c86c8
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/345860
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Reviewed-by: Tomas Gunnarsson <tommi@webrtc.org>
Commit-Queue: Philipp Hancke <phancke@meta.com>
Cr-Commit-Position: refs/heads/main@{#42339}
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);
