diff --git a/p2p/BUILD.gn b/p2p/BUILD.gn index b548f4b815..96b24d8549 100644 --- a/p2p/BUILD.gn +++ b/p2p/BUILD.gn @@ -736,7 +736,9 @@ rtc_library("port_interface") { 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 9372c5ada0..d45d1e4998 100644 --- a/p2p/base/fake_port_allocator.h +++ b/p2p/base/fake_port_allocator.h @@ -34,18 +34,12 @@ namespace cricket { 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 @@ class TestUDPPort : public UDPPort { } 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 @@ class FakePortAllocatorSession : public PortAllocatorSession { (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 4e31cf9461..272214c458 100644 --- a/p2p/base/port.cc +++ b/p2p/base/port.cc @@ -95,52 +95,32 @@ const char TCPTYPE_ACTIVE_STR[] = "active"; 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 @@ Port::Port(TaskQueueBase* thread, << 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 6cf71f4f82..ff55035a6e 100644 --- a/p2p/base/port.h +++ b/p2p/base/port.h @@ -170,25 +170,45 @@ typedef std::set ServerAddresses; // 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 48189823f1..34f835d138 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 81066cf68b..be3b365427 100644 --- a/p2p/base/port_unittest.cc +++ b/p2p/base/port_unittest.cc @@ -140,23 +140,8 @@ bool WriteStunMessage(const StunMessage& msg, ByteBufferWriter* buf) { // 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 @@ class PortTest : public ::testing::Test, public sigslot::has_slots<> { } std::unique_ptr 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 @@ class PortTest : public ::testing::Test, public sigslot::has_slots<> { 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 @@ class PortTest : public ::testing::Test, public sigslot::has_slots<> { } std::unique_ptr 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 CreateStunPort(const SocketAddress& addr, - rtc::PacketSocketFactory* factory) { + std::unique_ptr 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 @@ class PortTest : public ::testing::Test, public sigslot::has_slots<> { absl::string_view username, absl::string_view password, const webrtc::FieldTrialsView* field_trials = nullptr) { - auto port = - std::make_unique(&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(args, 0, 0); port->SignalRoleConflict.connect(this, &PortTest::OnRoleConflict); return port; } @@ -844,8 +851,13 @@ class PortTest : public ::testing::Test, public sigslot::has_slots<> { std::unique_ptr CreateTestPort(const rtc::Network* network, absl::string_view username, absl::string_view password) { - auto port = std::make_unique(&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(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 cf8830afff..93c303015c 100644 --- a/p2p/base/stun_port.cc +++ b/p2p/base/stun_port.cc @@ -159,18 +159,13 @@ bool UDPPort::AddressResolver::GetResolvedAddress( 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 @@ UDPPort::UDPPort(rtc::Thread* thread, 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 @@ bool UDPPort::HasStunCandidateWithAddress( } std::unique_ptr StunPort::Create( - rtc::Thread* thread, + const PortParametersRef& args, + uint16_t min_port, + uint16_t max_port, + const ServerAddresses& servers, + absl::optional 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::Create( + webrtc::TaskQueueBase* thread, rtc::PacketSocketFactory* factory, const rtc::Network* network, uint16_t min_port, @@ -634,36 +631,24 @@ std::unique_ptr StunPort::Create( const ServerAddresses& servers, absl::optional 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 f558b9266f..3133a4157e 100644 --- a/p2p/base/stun_port.h +++ b/p2p/base/stun_port.h @@ -36,47 +36,77 @@ static const int HIGH_COST_PORT_KEEPALIVE_LIFETIME = 2 * 60 * 1000; class RTC_EXPORT UDPPort : public Port { public: static std::unique_ptr 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 stun_keepalive_interval, - const webrtc::FieldTrialsView* field_trials = nullptr) { + absl::optional 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 + 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 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 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 stun_keepalive_interval, - const webrtc::FieldTrialsView* field_trials = nullptr) { + absl::optional 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 + 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 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 @@ class RTC_EXPORT UDPPort : public Port { StunRequestManager& request_manager() { return request_manager_; } protected: - UDPPort(rtc::Thread* thread, + UDPPort(const PortParametersRef& args, + webrtc::IceCandidateType type, + rtc::AsyncPacketSocket* socket, + bool emit_local_for_anyaddress); + 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); - - 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 RTC_EXPORT UDPPort : public Port { class StunPort : public UDPPort { public: static std::unique_ptr 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 stun_keepalive_interval, - const webrtc::FieldTrialsView* field_trials); - + absl::optional stun_keepalive_interval); + [[deprecated("Pass arguments using PortParametersRef")]] static std:: + unique_ptr + 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 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 9646fab438..423d16b11b 100644 --- a/p2p/base/stun_port_unittest.cc +++ b/p2p/base/stun_port_unittest.cc @@ -137,9 +137,13 @@ class StunPortTestBase : public ::testing::Test, public sigslot::has_slots<> { 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 @@ class StunPortTestBase : public ::testing::Test, public sigslot::has_slots<> { 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 4d4373f6ee..78c6e4799e 100644 --- a/p2p/base/tcp_port.cc +++ b/p2p/base/tcp_port.cc @@ -90,24 +90,11 @@ using ::webrtc::IceCandidateType; 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 bd7ed4c110..37609ff5f4 100644 --- a/p2p/base/tcp_port.h +++ b/p2p/base/tcp_port.h @@ -36,20 +36,32 @@ class TCPConnection; // call this TCPPort::OnReadPacket (3 arg) to dispatch to a connection. class TCPPort : public Port { public: - static std::unique_ptr 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 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 + 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 @@ class TCPPort : public Port { 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 1bb59811b8..be246a8576 100644 --- a/p2p/base/tcp_port_unittest.cc +++ b/p2p/base/tcp_port_unittest.cc @@ -84,16 +84,26 @@ class TCPPortTest : public ::testing::Test, public sigslot::has_slots<> { std::unique_ptr CreateTCPPort(const SocketAddress& addr) { auto port = std::unique_ptr( - 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 CreateTCPPort(const rtc::Network* network) { auto port = std::unique_ptr( - 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 3e29dedc5b..71deb693c1 100644 --- a/p2p/base/turn_port.cc +++ b/p2p/base/turn_port.cc @@ -208,7 +208,68 @@ class TurnEntry : public sigslot::has_slots<> { 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& tls_alpn_protocols, + const std::vector& 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& tls_alpn_protocols, + const std::vector& 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 @@ TurnPort::TurnPort(TaskQueueBase* thread, 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 @@ TurnPort::TurnPort(TaskQueueBase* thread, 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 69832aef7f..f8783d5daf 100644 --- a/p2p/base/turn_port.h +++ b/p2p/base/turn_port.h @@ -81,12 +81,16 @@ class TurnPort : public Port { } // 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 @@ class TurnPort : public Port { 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 @@ class TurnPort : public Port { 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& tls_alpn_protocols, const std::vector& 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& tls_alpn_protocols, const std::vector& 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& tls_alpn_protocols, + const std::vector& 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& tls_alpn_protocols, + const std::vector& 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 6915afab8c..66a154048b 100644 --- a/p2p/base/turn_port_unittest.cc +++ b/p2p/base/turn_port_unittest.cc @@ -366,9 +366,13 @@ class TurnPortTest : public ::testing::Test, 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 832d6da27a..f1525b0589 100644 --- a/p2p/client/basic_port_allocator.cc +++ b/p2p/client/basic_port_allocator.cc @@ -1470,19 +1470,25 @@ void AllocationSequence::CreateUDPPorts() { !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 @@ void AllocationSequence::CreateTCPPorts() { } std::unique_ptr 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 @@ void AllocationSequence::CreateStunPorts() { } std::unique_ptr 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);