commit 58196f6ea378ce792a89dd58659537159554512c
parent 4962f02978fa900718e8028cc7b040437c69e329
Author: Dan Baker <dbaker@mozilla.com>
Date: Mon, 1 Dec 2025 19:51:12 -0700
Bug 2000941 - Vendor libwebrtc from e5e553f078
Upstream commit: https://webrtc.googlesource.com/src/+/e5e553f078c95d25cb63144602d6fdda3b3a62c3
Provide Environment for test helper NatServer
To pass it to AsyncUDPSocket at construction.
Do additional cleanups nearby:
- Update passing pointers with ownership to use unique_ptr
- Replace some unique_ptr<T> that are never moved with T per https://abseil.io/tips/187
Bug: webrtc:42223992
Change-Id: Ie5296cd8aae8833e31c8c2a8439e3c3e7a0a197c
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/408940
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#45631}
Diffstat:
10 files changed, 202 insertions(+), 196 deletions(-)
diff --git a/third_party/libwebrtc/README.mozilla.last-vendor b/third_party/libwebrtc/README.mozilla.last-vendor
@@ -1,4 +1,4 @@
# ./mach python dom/media/webrtc/third_party_build/vendor-libwebrtc.py --from-local /Users/danielbaker/elm/.moz-fast-forward/moz-libwebrtc --commit mozpatches libwebrtc
-libwebrtc updated from /Users/danielbaker/elm/.moz-fast-forward/moz-libwebrtc commit mozpatches on 2025-12-02T02:48:27.164652+00:00.
+libwebrtc updated from /Users/danielbaker/elm/.moz-fast-forward/moz-libwebrtc commit mozpatches on 2025-12-02T02:50:51.570071+00:00.
# base of lastest vendoring
-083f0427a6
+e5e553f078
diff --git a/third_party/libwebrtc/p2p/base/p2p_transport_channel_unittest.cc b/third_party/libwebrtc/p2p/base/p2p_transport_channel_unittest.cc
@@ -1131,16 +1131,16 @@ class P2PTransportChannelTest : public P2PTransportChannelTestBase {
int allocator_flags1,
int allocator_flags2) {
CreatePortAllocators(env);
- ConfigureEndpoint(0, config1);
+ ConfigureEndpoint(env, 0, config1);
SetAllocatorFlags(0, allocator_flags1);
SetAllocationStepDelay(0, kMinimumStepDelay);
- ConfigureEndpoint(1, config2);
+ ConfigureEndpoint(env, 1, config2);
SetAllocatorFlags(1, allocator_flags2);
SetAllocationStepDelay(1, kMinimumStepDelay);
set_remote_ice_parameter_source(FROM_SETICEPARAMETERS);
}
- void ConfigureEndpoint(int endpoint, Config config) {
+ void ConfigureEndpoint(const Environment& env, int endpoint, Config config) {
switch (config) {
case OPEN:
AddAddress(endpoint, kPublicAddrs[endpoint]);
@@ -1152,7 +1152,7 @@ class P2PTransportChannelTest : public P2PTransportChannelTestBase {
AddAddress(endpoint, kPrivateAddrs[endpoint]);
// Add a single NAT of the desired type
nat()
- ->AddTranslator(kPublicAddrs[endpoint], kNatAddrs[endpoint],
+ ->AddTranslator(env, kPublicAddrs[endpoint], kNatAddrs[endpoint],
static_cast<NATType>(config - NAT_FULL_CONE))
->AddClient(kPrivateAddrs[endpoint]);
break;
@@ -1161,11 +1161,11 @@ class P2PTransportChannelTest : public P2PTransportChannelTestBase {
AddAddress(endpoint, kCascadedPrivateAddrs[endpoint]);
// Add a two cascaded NATs of the desired types
nat()
- ->AddTranslator(kPublicAddrs[endpoint], kNatAddrs[endpoint],
+ ->AddTranslator(env, kPublicAddrs[endpoint], kNatAddrs[endpoint],
(config == Config::NAT_DOUBLE_CONE)
? NATType::NAT_OPEN_CONE
: NATType::NAT_SYMMETRIC)
- ->AddTranslator(kPrivateAddrs[endpoint],
+ ->AddTranslator(env, kPrivateAddrs[endpoint],
kCascadedNatAddrs[endpoint], NAT_OPEN_CONE)
->AddClient(kCascadedPrivateAddrs[endpoint]);
break;
@@ -2484,13 +2484,14 @@ class P2PTransportChannelSameNatTest : public P2PTransportChannelTestBase {
RTC_CHECK_LE(nat_type, NAT_SYMMETRIC);
CreatePortAllocators(env);
NATSocketServer::Translator* outer_nat =
- nat()->AddTranslator(kPublicAddrs[0], kNatAddrs[0],
+ nat()->AddTranslator(env, kPublicAddrs[0], kNatAddrs[0],
static_cast<NATType>(nat_type - NAT_FULL_CONE));
- ConfigureEndpoint(outer_nat, 0, config1);
- ConfigureEndpoint(outer_nat, 1, config2);
+ ConfigureEndpoint(env, outer_nat, 0, config1);
+ ConfigureEndpoint(env, outer_nat, 1, config2);
set_remote_ice_parameter_source(FROM_SETICEPARAMETERS);
}
- void ConfigureEndpoint(NATSocketServer::Translator* nat,
+ void ConfigureEndpoint(const Environment& env,
+ NATSocketServer::Translator* nat,
int endpoint,
Config config) {
RTC_CHECK(config <= NAT_SYMMETRIC);
@@ -2499,7 +2500,8 @@ class P2PTransportChannelSameNatTest : public P2PTransportChannelTestBase {
nat->AddClient(kPrivateAddrs[endpoint]);
} else {
AddAddress(endpoint, kCascadedPrivateAddrs[endpoint]);
- nat->AddTranslator(kPrivateAddrs[endpoint], kCascadedNatAddrs[endpoint],
+ nat->AddTranslator(env, kPrivateAddrs[endpoint],
+ kCascadedNatAddrs[endpoint],
static_cast<NATType>(config - NAT_FULL_CONE))
->AddClient(kCascadedPrivateAddrs[endpoint]);
}
diff --git a/third_party/libwebrtc/p2p/base/port_unittest.cc b/third_party/libwebrtc/p2p/base/port_unittest.cc
@@ -641,7 +641,7 @@ class PortTest : public ::testing::Test, public sigslot::has_slots<> {
std::unique_ptr<NATServer> CreateNatServer(const SocketAddress& addr,
NATType type) {
- return std::make_unique<NATServer>(type, main_, ss_.get(), addr, addr,
+ return std::make_unique<NATServer>(env_, type, main_, ss_.get(), addr, addr,
main_, ss_.get(), addr);
}
static const char* StunName(NATType type) {
diff --git a/third_party/libwebrtc/p2p/base/stun_port_unittest.cc b/third_party/libwebrtc/p2p/base/stun_port_unittest.cc
@@ -16,6 +16,7 @@
#include <optional>
#include <set>
#include <string>
+#include <utility>
#include <vector>
#include "absl/functional/any_invocable.h"
@@ -70,6 +71,7 @@ namespace {
using ::testing::_;
using ::testing::DoAll;
using ::testing::Eq;
+using ::testing::Field;
using ::testing::IsTrue;
using ::testing::Return;
using ::testing::ReturnPointee;
@@ -147,7 +149,8 @@ class StunPortTestBase : public ::testing::Test, public sigslot::has_slots<> {
StunPortTestBase(const webrtc::IPAddress address,
const std::set<webrtc::SocketAddress>& stun_server_addresses,
const webrtc::SocketAddress& nat_server_address)
- : ss_(new webrtc::VirtualSocketServer()),
+ : env_(CreateTestEnvironment()),
+ ss_(new webrtc::VirtualSocketServer()),
thread_(ss_.get()),
nat_factory_(ss_.get(), nat_server_address, nat_server_address),
nat_socket_factory_(&nat_factory_),
@@ -167,8 +170,8 @@ class StunPortTestBase : public ::testing::Test, public sigslot::has_slots<> {
std::unique_ptr<webrtc::NATServer> CreateNatServer(const SocketAddress& addr,
webrtc::NATType type) {
- return std::make_unique<webrtc::NATServer>(type, thread_, ss_.get(), addr,
- addr, thread_, ss_.get(), addr);
+ return std::make_unique<webrtc::NATServer>(
+ env_, type, thread_, ss_.get(), addr, addr, thread_, ss_.get(), addr);
}
virtual webrtc::PacketSocketFactory* socket_factory() {
@@ -198,8 +201,13 @@ class StunPortTestBase : public ::testing::Test, public sigslot::has_slots<> {
void CreateStunPort(const ServerAddresses& stun_servers,
const webrtc::FieldTrialsView* field_trials = nullptr) {
+ // Overwrite field trials if provided.
+ EnvironmentFactory env_factory(env_);
+ env_factory.Set(field_trials);
+ Environment env = env_factory.Create();
+
stun_port_ = webrtc::StunPort::Create(
- {.env = CreateEnvironment(field_trials),
+ {.env = env,
.network_thread = &thread_,
.socket_factory = socket_factory(),
.network = network_,
@@ -223,17 +231,13 @@ class StunPortTestBase : public ::testing::Test, public sigslot::has_slots<> {
});
}
- void CreateSharedUdpPort(
- const webrtc::SocketAddress& server_addr,
- webrtc::AsyncPacketSocket* socket,
- const webrtc::FieldTrialsView* field_trials = nullptr) {
- const Environment env =
- CreateTestEnvironment({.field_trials = field_trials});
+ void CreateSharedUdpPort(const SocketAddress& server_addr,
+ std::unique_ptr<AsyncPacketSocket> socket) {
if (socket) {
- socket_.reset(socket);
+ socket_ = std::move(socket);
} else {
socket_ = socket_factory()->CreateUdpSocket(
- env, webrtc::SocketAddress(kPrivateIP.ipaddr(), 0), 0, 0);
+ env_, SocketAddress(kPrivateIP.ipaddr(), 0), 0, 0);
}
ASSERT_TRUE(socket_ != nullptr);
socket_->RegisterReceivedPacketCallback(
@@ -244,7 +248,7 @@ class StunPortTestBase : public ::testing::Test, public sigslot::has_slots<> {
ServerAddresses stun_servers;
stun_servers.insert(server_addr);
stun_port_ = webrtc::UDPPort::Create(
- {.env = env,
+ {.env = env_,
.network_thread = &thread_,
.socket_factory = socket_factory(),
.network = network_,
@@ -310,6 +314,7 @@ class StunPortTestBase : public ::testing::Test, public sigslot::has_slots<> {
webrtc::SocketFactory* nat_factory() { return &nat_factory_; }
private:
+ const Environment env_;
std::vector<webrtc::Network> networks_;
webrtc::Network* network_;
@@ -349,7 +354,7 @@ TEST_F(StunPortTest, TestCreateStunPort) {
// Test that we can create a UDP port.
TEST_F(StunPortTest, TestCreateUdpPort) {
- CreateSharedUdpPort(kStunServerAddr1, nullptr, nullptr);
+ CreateSharedUdpPort(kStunServerAddr1, nullptr);
EXPECT_EQ(IceCandidateType::kHost, port()->Type());
EXPECT_EQ(0U, port()->Candidates().size());
}
@@ -520,7 +525,7 @@ TEST_F(StunPortTest, TestKeepAliveResponse) {
// Test that a local candidate can be generated using a shared socket.
TEST_F(StunPortTest, TestSharedSocketPrepareAddress) {
- CreateSharedUdpPort(kStunServerAddr1, nullptr, nullptr);
+ CreateSharedUdpPort(kStunServerAddr1, nullptr);
PrepareAddress();
EXPECT_THAT(
webrtc::WaitUntil([&] { return done(); }, IsTrue(),
@@ -805,33 +810,32 @@ class MockAsyncPacketSocket : public webrtc::AsyncPacketSocket {
// Test that outbound packets inherit the dscp value assigned to the socket.
TEST_F(StunPortTest, TestStunPacketsHaveDscpPacketOption) {
- MockAsyncPacketSocket* socket = new MockAsyncPacketSocket();
- CreateSharedUdpPort(kStunServerAddr1, socket);
- EXPECT_CALL(*socket, GetLocalAddress()).WillRepeatedly(Return(kPrivateIP));
- EXPECT_CALL(*socket, GetState())
- .WillRepeatedly(Return(webrtc::AsyncPacketSocket::STATE_BOUND));
- EXPECT_CALL(*socket, SetOption(_, _)).WillRepeatedly(Return(0));
+ auto mocked_socket = std::make_unique<MockAsyncPacketSocket>();
+ MockAsyncPacketSocket& socket = *mocked_socket;
+ CreateSharedUdpPort(kStunServerAddr1, std::move(mocked_socket));
+
+ EXPECT_CALL(socket, GetLocalAddress).WillRepeatedly(Return(kPrivateIP));
+ EXPECT_CALL(socket, GetState)
+ .WillRepeatedly(Return(AsyncPacketSocket::STATE_BOUND));
+ EXPECT_CALL(socket, SetOption).WillRepeatedly(Return(0));
// If DSCP is not set on the socket, stun packets should have no value.
- EXPECT_CALL(*socket,
- SendTo(_, _, _,
- ::testing::Field(&webrtc::AsyncSocketPacketOptions::dscp,
- Eq(webrtc::DSCP_NO_CHANGE))))
+ EXPECT_CALL(socket, SendTo(_, _, _,
+ Field(&AsyncSocketPacketOptions::dscp,
+ Eq(DSCP_NO_CHANGE))))
.WillOnce(Return(100));
PrepareAddress();
// Once it is set transport wide, they should inherit that value.
- port()->SetOption(webrtc::Socket::OPT_DSCP, webrtc::DSCP_AF41);
- EXPECT_CALL(*socket,
- SendTo(_, _, _,
- ::testing::Field(&webrtc::AsyncSocketPacketOptions::dscp,
- Eq(webrtc::DSCP_AF41))))
+ port()->SetOption(Socket::OPT_DSCP, DSCP_AF41);
+ EXPECT_CALL(
+ socket,
+ SendTo(_, _, _, Field(&AsyncSocketPacketOptions::dscp, Eq(DSCP_AF41))))
.WillRepeatedly(Return(100));
- EXPECT_THAT(
- webrtc::WaitUntil([&] { return done(); }, IsTrue(),
- {.timeout = webrtc::TimeDelta::Millis(kTimeoutMs),
- .clock = &fake_clock}),
- webrtc::IsRtcOk());
+
+ EXPECT_TRUE(WaitUntil(
+ [&] { return done(); },
+ {.timeout = TimeDelta::Millis(kTimeoutMs), .clock = &fake_clock}));
}
class StunIPv6PortTestBase : public StunPortTestBase {
diff --git a/third_party/libwebrtc/p2p/client/basic_port_allocator_unittest.cc b/third_party/libwebrtc/p2p/client/basic_port_allocator_unittest.cc
@@ -487,9 +487,9 @@ class BasicPortAllocatorTestBase : public ::testing::Test,
void ResetWithStunServer(const SocketAddress& stun_server, bool with_nat) {
if (with_nat) {
- nat_server_.reset(new NATServer(
- NAT_OPEN_CONE, thread_, vss_.get(), kNatUdpAddr, kNatTcpAddr, thread_,
- vss_.get(), SocketAddress(kNatUdpAddr.ipaddr(), 0)));
+ nat_server_ = std::make_unique<NATServer>(
+ env_, NAT_OPEN_CONE, thread_, vss_.get(), kNatUdpAddr, kNatTcpAddr,
+ thread_, vss_.get(), SocketAddress(kNatUdpAddr.ipaddr(), 0));
} else {
nat_socket_factory_ =
std::make_unique<BasicPacketSocketFactory>(fss_.get());
diff --git a/third_party/libwebrtc/p2p/test/nat_server.cc b/third_party/libwebrtc/p2p/test/nat_server.cc
@@ -13,8 +13,11 @@
#include <cstddef>
#include <cstdint>
#include <cstring>
+#include <memory>
+#include <utility>
#include "api/array_view.h"
+#include "api/environment/environment.h"
#include "p2p/test/nat_socket_factory.h"
#include "p2p/test/nat_types.h"
#include "rtc_base/async_packet_socket.h"
@@ -143,7 +146,8 @@ class NATProxyServer : public ProxyServer {
}
};
-NATServer::NATServer(NATType type,
+NATServer::NATServer(const Environment& env,
+ NATType type,
Thread& internal_socket_thread,
SocketFactory* internal,
const SocketAddress& internal_udp_addr,
@@ -151,14 +155,16 @@ NATServer::NATServer(NATType type,
Thread& external_socket_thread,
SocketFactory* external,
const SocketAddress& external_ip)
- : internal_socket_thread_(internal_socket_thread),
+ : env_(env),
+ internal_socket_thread_(internal_socket_thread),
external_socket_thread_(external_socket_thread),
external_(external),
external_ip_(external_ip.ipaddr(), 0) {
nat_ = NAT::Create(type);
internal_socket_thread_.BlockingCall([&] {
- udp_server_socket_ = AsyncUDPSocket::Create(internal, internal_udp_addr);
+ udp_server_socket_ =
+ AsyncUDPSocket::Create(env_, internal_udp_addr, *internal);
udp_server_socket_->RegisterReceivedPacketCallback(
[&](AsyncPacketSocket* socket, const ReceivedIpPacket& packet) {
OnInternalUDPPacket(socket, packet);
@@ -178,7 +184,6 @@ NATServer::~NATServer() {
delete iter->second;
delete nat_;
- delete udp_server_socket_;
delete tcp_proxy_server_;
delete int_map_;
delete ext_map_;
@@ -220,7 +225,7 @@ void NATServer::OnExternalUDPPacket(AsyncPacketSocket* socket,
RTC_DCHECK(iter != ext_map_->end());
// Allow the NAT to reject this packet.
- if (ShouldFilterOut(iter->second, packet.source_address())) {
+ if (iter->second->ShouldFilterOut(packet.source_address())) {
RTC_LOG(LS_INFO) << "Packet from "
<< packet.source_address().ToSensitiveString()
<< " was filtered out by the NAT.";
@@ -240,48 +245,37 @@ void NATServer::OnExternalUDPPacket(AsyncPacketSocket* socket,
void NATServer::Translate(const SocketAddressPair& route) {
external_socket_thread_.BlockingCall([&] {
- AsyncUDPSocket* socket = AsyncUDPSocket::Create(external_, external_ip_);
+ std::unique_ptr<AsyncUDPSocket> socket =
+ AsyncUDPSocket::Create(env_, external_ip_, *external_);
if (!socket) {
RTC_LOG(LS_ERROR) << "Couldn't find a free port!";
return;
}
- TransEntry* entry = new TransEntry(route, socket, nat_);
+ TransEntry* entry = new TransEntry(route, std::move(socket), nat_);
(*int_map_)[route] = entry;
- (*ext_map_)[socket->GetLocalAddress()] = entry;
- socket->RegisterReceivedPacketCallback(
+ (*ext_map_)[entry->socket->GetLocalAddress()] = entry;
+ entry->socket->RegisterReceivedPacketCallback(
[&](AsyncPacketSocket* socket, const ReceivedIpPacket& packet) {
OnExternalUDPPacket(socket, packet);
});
});
}
-bool NATServer::ShouldFilterOut(TransEntry* entry,
- const SocketAddress& ext_addr) {
- return entry->AllowlistContains(ext_addr);
-}
-
NATServer::TransEntry::TransEntry(const SocketAddressPair& r,
- AsyncUDPSocket* s,
+ std::unique_ptr<AsyncUDPSocket> s,
NAT* nat)
- : route(r), socket(s) {
- allowlist = new AddressSet(AddrCmp(nat));
-}
-
-NATServer::TransEntry::~TransEntry() {
- delete allowlist;
- delete socket;
-}
+ : route(r), socket(std::move(s)), allowlist(AddrCmp(nat)) {}
void NATServer::TransEntry::AllowlistInsert(const SocketAddress& addr) {
MutexLock lock(&mutex_);
- allowlist->insert(addr);
+ allowlist.insert(addr);
}
-bool NATServer::TransEntry::AllowlistContains(const SocketAddress& ext_addr) {
+bool NATServer::TransEntry::ShouldFilterOut(const SocketAddress& ext_addr) {
MutexLock lock(&mutex_);
- return allowlist->find(ext_addr) == allowlist->end();
+ return !allowlist.contains(ext_addr);
}
} // namespace webrtc
diff --git a/third_party/libwebrtc/p2p/test/nat_server.h b/third_party/libwebrtc/p2p/test/nat_server.h
@@ -13,8 +13,10 @@
#include <cstddef>
#include <map>
+#include <memory>
#include <set>
+#include "api/environment/environment.h"
#include "p2p/test/nat_types.h"
#include "rtc_base/async_packet_socket.h"
#include "rtc_base/async_udp_socket.h"
@@ -64,7 +66,8 @@ const int NAT_SERVER_TCP_PORT = 4238;
class NATServer {
public:
- NATServer(NATType type,
+ NATServer(const Environment& env,
+ NATType type,
Thread& internal_socket_thread,
SocketFactory* internal,
const SocketAddress& internal_udp_addr,
@@ -92,19 +95,18 @@ class NATServer {
const ReceivedIpPacket& packet);
private:
- typedef std::set<SocketAddress, AddrCmp> AddressSet;
-
/* Records a translation and the associated external socket. */
struct TransEntry {
- TransEntry(const SocketAddressPair& r, AsyncUDPSocket* s, NAT* nat);
- ~TransEntry();
+ TransEntry(const SocketAddressPair& r,
+ std::unique_ptr<AsyncUDPSocket> s,
+ NAT* nat);
void AllowlistInsert(const SocketAddress& addr);
- bool AllowlistContains(const SocketAddress& ext_addr);
+ bool ShouldFilterOut(const SocketAddress& ext_addr);
SocketAddressPair route;
- AsyncUDPSocket* socket;
- AddressSet* allowlist;
+ std::unique_ptr<AsyncUDPSocket> socket;
+ std::set<SocketAddress, AddrCmp> allowlist;
Mutex mutex_;
};
@@ -117,12 +119,13 @@ class NATServer {
/* Determines whether the NAT would filter out a packet from this address. */
bool ShouldFilterOut(TransEntry* entry, const SocketAddress& ext_addr);
+ const Environment env_;
NAT* nat_;
Thread& internal_socket_thread_;
Thread& external_socket_thread_;
SocketFactory* external_;
SocketAddress external_ip_;
- AsyncUDPSocket* udp_server_socket_;
+ std::unique_ptr<AsyncUDPSocket> udp_server_socket_;
ProxyServer* tcp_proxy_server_;
InternalMap* int_map_;
ExternalMap* ext_map_;
diff --git a/third_party/libwebrtc/p2p/test/nat_socket_factory.cc b/third_party/libwebrtc/p2p/test/nat_socket_factory.cc
@@ -17,6 +17,7 @@
#include <set>
#include "api/array_view.h"
+#include "api/environment/environment.h"
#include "api/units/time_delta.h"
#include "api/units/timestamp.h"
#include "p2p/test/nat_server.h"
@@ -361,6 +362,7 @@ NATSocketServer::Translator* NATSocketServer::GetTranslator(
}
NATSocketServer::Translator* NATSocketServer::AddTranslator(
+ const Environment& env,
const SocketAddress& ext_ip,
const SocketAddress& int_ip,
NATType type) {
@@ -368,8 +370,8 @@ NATSocketServer::Translator* NATSocketServer::AddTranslator(
if (nats_.Get(ext_ip))
return nullptr;
- return nats_.Add(
- ext_ip, new Translator(this, type, int_ip, *msg_queue_, server_, ext_ip));
+ return nats_.Add(ext_ip, new Translator(env, this, type, int_ip, *msg_queue_,
+ server_, ext_ip));
}
void NATSocketServer::RemoveTranslator(const SocketAddress& ext_ip) {
@@ -410,7 +412,8 @@ Socket* NATSocketServer::CreateInternalSocket(int family,
}
// NATSocketServer::Translator
-NATSocketServer::Translator::Translator(NATSocketServer* server,
+NATSocketServer::Translator::Translator(const Environment& env,
+ NATSocketServer* server,
NATType type,
const SocketAddress& int_ip,
Thread& external_socket_thread,
@@ -423,7 +426,7 @@ NATSocketServer::Translator::Translator(NATSocketServer* server,
internal_server_ = std::make_unique<VirtualSocketServer>();
internal_server_->SetMessageQueue(server_->queue());
nat_server_ = std::make_unique<NATServer>(
- type, *server->queue(), internal_server_.get(), int_ip, int_ip,
+ env, type, *server->queue(), internal_server_.get(), int_ip, int_ip,
external_socket_thread, ext_factory, ext_ip);
}
@@ -437,6 +440,7 @@ NATSocketServer::Translator* NATSocketServer::Translator::GetTranslator(
}
NATSocketServer::Translator* NATSocketServer::Translator::AddTranslator(
+ const Environment& env,
const SocketAddress& ext_ip,
const SocketAddress& int_ip,
NATType type) {
@@ -445,7 +449,7 @@ NATSocketServer::Translator* NATSocketServer::Translator::AddTranslator(
return nullptr;
AddClient(ext_ip);
- return nats_.Add(ext_ip, new Translator(server_, type, int_ip,
+ return nats_.Add(ext_ip, new Translator(env, server_, type, int_ip,
*server_->queue(), server_, ext_ip));
}
void NATSocketServer::Translator::RemoveTranslator(
diff --git a/third_party/libwebrtc/p2p/test/nat_socket_factory.h b/third_party/libwebrtc/p2p/test/nat_socket_factory.h
@@ -18,6 +18,7 @@
#include <set>
#include "api/array_view.h"
+#include "api/environment/environment.h"
#include "api/units/time_delta.h"
#include "p2p/test/nat_server.h"
#include "p2p/test/nat_types.h"
@@ -102,7 +103,8 @@ class NATSocketServer : public SocketServer, public NATInternalSocketFactory {
// a specific NAT
class Translator {
public:
- Translator(NATSocketServer* server,
+ Translator(const Environment& env,
+ NATSocketServer* server,
NATType type,
const SocketAddress& int_addr,
Thread& external_socket_thread,
@@ -119,7 +121,8 @@ class NATSocketServer : public SocketServer, public NATInternalSocketFactory {
}
Translator* GetTranslator(const SocketAddress& ext_ip);
- Translator* AddTranslator(const SocketAddress& ext_ip,
+ Translator* AddTranslator(const Environment& env,
+ const SocketAddress& ext_ip,
const SocketAddress& int_ip,
NATType type);
void RemoveTranslator(const SocketAddress& ext_ip);
@@ -147,7 +150,8 @@ class NATSocketServer : public SocketServer, public NATInternalSocketFactory {
Thread* queue() { return msg_queue_; }
Translator* GetTranslator(const SocketAddress& ext_ip);
- Translator* AddTranslator(const SocketAddress& ext_ip,
+ Translator* AddTranslator(const Environment& env,
+ const SocketAddress& ext_ip,
const SocketAddress& int_ip,
NATType type);
void RemoveTranslator(const SocketAddress& ext_ip);
diff --git a/third_party/libwebrtc/p2p/test/nat_unittest.cc b/third_party/libwebrtc/p2p/test/nat_unittest.cc
@@ -11,11 +11,10 @@
#include <cstddef>
#include <cstring>
#include <memory>
+#include <utility>
#include <vector>
-#include "absl/memory/memory.h"
-#include "api/environment/environment_factory.h"
-#include "api/test/rtc_error_matchers.h"
+#include "api/environment/environment.h"
#include "p2p/test/nat_server.h"
#include "p2p/test/nat_socket_factory.h"
#include "p2p/test/nat_types.h"
@@ -36,35 +35,38 @@
#include "rtc_base/third_party/sigslot/sigslot.h"
#include "rtc_base/thread.h"
#include "rtc_base/virtual_socket_server.h"
-#include "test/gmock.h"
+#include "test/create_test_environment.h"
#include "test/gtest.h"
#include "test/wait_until.h"
namespace webrtc {
namespace {
-bool CheckReceive(TestClient* client,
+bool CheckReceive(TestClient& client,
bool should_receive,
const char* buf,
size_t size) {
- return (should_receive) ? client->CheckNextPacket(buf, size, nullptr)
- : client->CheckNoPacket();
+ return should_receive ? client.CheckNextPacket(buf, size, nullptr)
+ : client.CheckNoPacket();
}
-webrtc::TestClient* CreateTestClient(SocketFactory* factory,
- const SocketAddress& local_addr) {
- return new TestClient(
- absl::WrapUnique(AsyncUDPSocket::Create(factory, local_addr)));
+std::unique_ptr<TestClient> CreateTestClient(const Environment& env,
+ const SocketAddress& local_addr,
+ SocketFactory& factory) {
+ return std::make_unique<TestClient>(
+ AsyncUDPSocket::Create(env, local_addr, factory));
}
-webrtc::TestClient* CreateTCPTestClient(Socket* socket) {
- return new TestClient(std::make_unique<AsyncTCPSocket>(socket));
+TestClient CreateTCPTestClient(const Environment& env,
+ std::unique_ptr<Socket> socket) {
+ return TestClient(std::make_unique<AsyncTCPSocket>(env, std::move(socket)));
}
// Tests that when sending from internal_addr to external_addrs through the
// NAT type specified by nat_type, all external addrs receive the sent packet
// and, if exp_same is true, all use the same mapped-address on the NAT.
-void TestSend(SocketServer* internal,
+void TestSend(const Environment& env,
+ SocketServer* internal,
const SocketAddress& internal_addr,
SocketServer* external,
const SocketAddress external_addrs[4],
@@ -78,19 +80,19 @@ void TestSend(SocketServer* internal,
SocketAddress server_addr = internal_addr;
server_addr.SetPort(0); // Auto-select a port
- NATServer* nat =
- new NATServer(nat_type, th_int, internal, server_addr, server_addr,
- th_ext, external, external_addrs[0]);
- NATSocketFactory* natsf = new NATSocketFactory(
- internal, nat->internal_udp_address(), nat->internal_tcp_address());
+ NATServer nat(env, nat_type, th_int, internal, server_addr, server_addr,
+ th_ext, external, external_addrs[0]);
+ NATSocketFactory natsf(internal, nat.internal_udp_address(),
+ nat.internal_tcp_address());
- TestClient* in;
- th_int.BlockingCall([&] { in = CreateTestClient(natsf, internal_addr); });
+ std::unique_ptr<TestClient> in;
+ th_int.BlockingCall(
+ [&] { in = CreateTestClient(env, internal_addr, natsf); });
- TestClient* out[4];
+ std::unique_ptr<TestClient> out[4];
th_ext.BlockingCall([&] {
for (int i = 0; i < 4; i++)
- out[i] = CreateTestClient(external, external_addrs[i]);
+ out[i] = CreateTestClient(env, external_addrs[i], *external);
});
const char* buf = "filter_test";
@@ -115,17 +117,12 @@ void TestSend(SocketServer* internal,
th_int.Stop();
th_ext.Stop();
-
- delete nat;
- delete natsf;
- delete in;
- for (int i = 0; i < 4; i++)
- delete out[i];
}
// Tests that when sending from external_addrs to internal_addr, the packet
// is delivered according to the specified filter_ip and filter_port rules.
-void TestRecv(SocketServer* internal,
+void TestRecv(const Environment& env,
+ SocketServer* internal,
const SocketAddress& internal_addr,
SocketServer* external,
const SocketAddress external_addrs[4],
@@ -139,19 +136,19 @@ void TestRecv(SocketServer* internal,
server_addr.SetPort(0); // Auto-select a port
th_int.Start();
th_ext.Start();
- NATServer* nat =
- new NATServer(nat_type, th_int, internal, server_addr, server_addr,
- th_ext, external, external_addrs[0]);
- NATSocketFactory* natsf = new NATSocketFactory(
- internal, nat->internal_udp_address(), nat->internal_tcp_address());
+ NATServer nat(env, nat_type, th_int, internal, server_addr, server_addr,
+ th_ext, external, external_addrs[0]);
+ NATSocketFactory natsf(internal, nat.internal_udp_address(),
+ nat.internal_tcp_address());
- TestClient* in = nullptr;
- th_int.BlockingCall([&] { in = CreateTestClient(natsf, internal_addr); });
+ std::unique_ptr<TestClient> in;
+ th_int.BlockingCall(
+ [&] { in = CreateTestClient(env, internal_addr, natsf); });
- TestClient* out[4];
+ std::unique_ptr<TestClient> out[4];
th_ext.BlockingCall([&] {
for (int i = 0; i < 4; i++)
- out[i] = CreateTestClient(external, external_addrs[i]);
+ out[i] = CreateTestClient(env, external_addrs[i], *external);
});
const char* buf = "filter_test";
@@ -164,56 +161,52 @@ void TestRecv(SocketServer* internal,
th_ext.BlockingCall([&] { out[1]->SendTo(buf, len, trans_addr); });
th_int.BlockingCall(
- [&] { EXPECT_TRUE(CheckReceive(in, !filter_ip, buf, len)); });
+ [&] { EXPECT_TRUE(CheckReceive(*in, !filter_ip, buf, len)); });
th_ext.BlockingCall([&] { out[2]->SendTo(buf, len, trans_addr); });
th_int.BlockingCall(
- [&] { EXPECT_TRUE(CheckReceive(in, !filter_port, buf, len)); });
+ [&] { EXPECT_TRUE(CheckReceive(*in, !filter_port, buf, len)); });
th_ext.BlockingCall([&] { out[3]->SendTo(buf, len, trans_addr); });
th_int.BlockingCall([&] {
- EXPECT_TRUE(CheckReceive(in, !filter_ip && !filter_port, buf, len));
+ EXPECT_TRUE(CheckReceive(*in, !filter_ip && !filter_port, buf, len));
});
th_int.Stop();
th_ext.Stop();
-
- delete nat;
- delete natsf;
- delete in;
- for (int i = 0; i < 4; i++)
- delete out[i];
}
// Tests that NATServer allocates bindings properly.
-void TestBindings(SocketServer* internal,
+void TestBindings(const Environment& env,
+ SocketServer* internal,
const SocketAddress& internal_addr,
SocketServer* external,
const SocketAddress external_addrs[4]) {
- TestSend(internal, internal_addr, external, external_addrs, NAT_OPEN_CONE,
- true);
- TestSend(internal, internal_addr, external, external_addrs,
+ TestSend(env, internal, internal_addr, external, external_addrs,
+ NAT_OPEN_CONE, true);
+ TestSend(env, internal, internal_addr, external, external_addrs,
NAT_ADDR_RESTRICTED, true);
- TestSend(internal, internal_addr, external, external_addrs,
+ TestSend(env, internal, internal_addr, external, external_addrs,
NAT_PORT_RESTRICTED, true);
- TestSend(internal, internal_addr, external, external_addrs, NAT_SYMMETRIC,
- false);
+ TestSend(env, internal, internal_addr, external, external_addrs,
+ NAT_SYMMETRIC, false);
}
// Tests that NATServer filters packets properly.
-void TestFilters(SocketServer* internal,
+void TestFilters(const Environment& env,
+ SocketServer* internal,
const SocketAddress& internal_addr,
SocketServer* external,
const SocketAddress external_addrs[4]) {
- TestRecv(internal, internal_addr, external, external_addrs, NAT_OPEN_CONE,
- false, false);
- TestRecv(internal, internal_addr, external, external_addrs,
+ TestRecv(env, internal, internal_addr, external, external_addrs,
+ NAT_OPEN_CONE, false, false);
+ TestRecv(env, internal, internal_addr, external, external_addrs,
NAT_ADDR_RESTRICTED, true, false);
- TestRecv(internal, internal_addr, external, external_addrs,
+ TestRecv(env, internal, internal_addr, external, external_addrs,
NAT_PORT_RESTRICTED, true, true);
- TestRecv(internal, internal_addr, external, external_addrs, NAT_SYMMETRIC,
- true, true);
+ TestRecv(env, internal, internal_addr, external, external_addrs,
+ NAT_SYMMETRIC, true, true);
}
bool TestConnectivity(const SocketAddress& src, const IPAddress& dst) {
@@ -241,7 +234,8 @@ bool TestConnectivity(const SocketAddress& src, const IPAddress& dst) {
void TestPhysicalInternal(const SocketAddress& int_addr) {
AutoThread main_thread;
PhysicalSocketServer socket_server;
- BasicNetworkManager network_manager(CreateEnvironment(), &socket_server);
+ const Environment env = CreateTestEnvironment();
+ BasicNetworkManager network_manager(env, &socket_server);
network_manager.StartUpdating();
// Process pending messages so the network list is updated.
Thread::Current()->ProcessMessages(0);
@@ -281,8 +275,8 @@ void TestPhysicalInternal(const SocketAddress& int_addr) {
std::unique_ptr<PhysicalSocketServer> int_pss(new PhysicalSocketServer());
std::unique_ptr<PhysicalSocketServer> ext_pss(new PhysicalSocketServer());
- TestBindings(int_pss.get(), int_addr, ext_pss.get(), ext_addrs);
- TestFilters(int_pss.get(), int_addr, ext_pss.get(), ext_addrs);
+ TestBindings(env, int_pss.get(), int_addr, ext_pss.get(), ext_addrs);
+ TestFilters(env, int_pss.get(), int_addr, ext_pss.get(), ext_addrs);
}
TEST(NatTest, TestPhysicalIPv4) {
@@ -309,6 +303,7 @@ class TestVirtualSocketServer : public VirtualSocketServer {
void TestVirtualInternal(int family) {
AutoThread main_thread;
+ const Environment env = CreateTestEnvironment();
std::unique_ptr<TestVirtualSocketServer> int_vss(
new TestVirtualSocketServer());
std::unique_ptr<TestVirtualSocketServer> ext_vss(
@@ -322,8 +317,8 @@ void TestVirtualInternal(int family) {
ext_addrs[2].SetIP(ext_addrs[0].ipaddr());
ext_addrs[3].SetIP(ext_addrs[1].ipaddr());
- TestBindings(int_vss.get(), int_addr, ext_vss.get(), ext_addrs);
- TestFilters(int_vss.get(), int_addr, ext_vss.get(), ext_addrs);
+ TestBindings(env, int_vss.get(), int_addr, ext_vss.get(), ext_addrs);
+ TestFilters(env, int_vss.get(), int_addr, ext_vss.get(), ext_addrs);
}
TEST(NatTest, TestVirtualIPv4) {
@@ -341,26 +336,26 @@ TEST(NatTest, TestVirtualIPv6) {
class NatTcpTest : public ::testing::Test, public sigslot::has_slots<> {
public:
NatTcpTest()
- : int_addr_("192.168.0.1", 0),
+ : env_(CreateTestEnvironment()),
+ int_addr_("192.168.0.1", 0),
ext_addr_("10.0.0.1", 0),
connected_(false),
- int_vss_(new TestVirtualSocketServer()),
- ext_vss_(new TestVirtualSocketServer()),
- int_thread_(new Thread(int_vss_.get())),
- ext_thread_(new Thread(ext_vss_.get())),
- nat_(new NATServer(NAT_OPEN_CONE,
- *int_thread_,
- int_vss_.get(),
- int_addr_,
- int_addr_,
- *ext_thread_,
- ext_vss_.get(),
- ext_addr_)),
- natsf_(new NATSocketFactory(int_vss_.get(),
- nat_->internal_udp_address(),
- nat_->internal_tcp_address())) {
- int_thread_->Start();
- ext_thread_->Start();
+ int_thread_(&int_vss_),
+ ext_thread_(&ext_vss_),
+ nat_(env_,
+ NAT_OPEN_CONE,
+ int_thread_,
+ &int_vss_,
+ int_addr_,
+ int_addr_,
+ ext_thread_,
+ &ext_vss_,
+ ext_addr_),
+ natsf_(&int_vss_,
+ nat_.internal_udp_address(),
+ nat_.internal_tcp_address()) {
+ int_thread_.Start();
+ ext_thread_.Start();
}
void OnConnectEvent(Socket* socket) { connected_ = true; }
@@ -376,48 +371,48 @@ class NatTcpTest : public ::testing::Test, public sigslot::has_slots<> {
client_->SignalConnectEvent.connect(this, &NatTcpTest::OnConnectEvent);
}
+ const Environment env_;
SocketAddress int_addr_;
SocketAddress ext_addr_;
bool connected_;
- std::unique_ptr<TestVirtualSocketServer> int_vss_;
- std::unique_ptr<TestVirtualSocketServer> ext_vss_;
- std::unique_ptr<Thread> int_thread_;
- std::unique_ptr<Thread> ext_thread_;
- std::unique_ptr<NATServer> nat_;
- std::unique_ptr<NATSocketFactory> natsf_;
+ TestVirtualSocketServer int_vss_;
+ TestVirtualSocketServer ext_vss_;
+ Thread int_thread_;
+ Thread ext_thread_;
+ NATServer nat_;
+ NATSocketFactory natsf_;
std::unique_ptr<Socket> client_;
std::unique_ptr<Socket> server_;
std::unique_ptr<Socket> accepted_;
};
TEST_F(NatTcpTest, DISABLED_TestConnectOut) {
- server_.reset(ext_vss_->CreateSocket(AF_INET, SOCK_STREAM));
+ server_ = ext_vss_.Create(AF_INET, SOCK_STREAM);
server_->Bind(ext_addr_);
server_->Listen(5);
- client_.reset(natsf_->CreateSocket(AF_INET, SOCK_STREAM));
+ client_ = natsf_.Create(AF_INET, SOCK_STREAM);
EXPECT_GE(0, client_->Bind(int_addr_));
EXPECT_GE(0, client_->Connect(server_->GetLocalAddress()));
ConnectEvents();
- EXPECT_THAT(WaitUntil([&] { return connected_; }, ::testing::IsTrue()),
- IsRtcOk());
+ EXPECT_TRUE(WaitUntil([&] { return connected_; }));
EXPECT_EQ(client_->GetRemoteAddress(), server_->GetLocalAddress());
EXPECT_EQ(accepted_->GetRemoteAddress().ipaddr(), ext_addr_.ipaddr());
- std::unique_ptr<TestClient> in(CreateTCPTestClient(client_.release()));
- std::unique_ptr<TestClient> out(CreateTCPTestClient(accepted_.release()));
+ TestClient in = CreateTCPTestClient(env_, std::move(client_));
+ TestClient out = CreateTCPTestClient(env_, std::move(accepted_));
const char* buf = "test_packet";
size_t len = strlen(buf);
- in->Send(buf, len);
+ in.Send(buf, len);
SocketAddress trans_addr;
- EXPECT_TRUE(out->CheckNextPacket(buf, len, &trans_addr));
+ EXPECT_TRUE(out.CheckNextPacket(buf, len, &trans_addr));
- out->Send(buf, len);
- EXPECT_TRUE(in->CheckNextPacket(buf, len, &trans_addr));
+ out.Send(buf, len);
+ EXPECT_TRUE(in.CheckNextPacket(buf, len, &trans_addr));
}
} // namespace
