commit 8ee52a2d34dc565d21f3f81e5fadfe3fd70c90ff
parent d7044f62e19dd3df1a2c22fc1bb849f40b6f060e
Author: Dan Baker <dbaker@mozilla.com>
Date: Mon, 1 Dec 2025 19:34:56 -0700
Bug 2000941 - Vendor libwebrtc from dc5f3e9b89
Upstream commit: https://webrtc.googlesource.com/src/+/dc5f3e9b8995a91be395db949c2c0984d7424a4d
Propagate Environment through BasicPacketSocketFactory
Update nearby code that pass pointers with ownership to use unique_ptr
Bug: webrtc:42223992
Change-Id: Ie602a724007f0bcf155265ea454e13e0c4513141
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/408906
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#45625}
Diffstat:
11 files changed, 72 insertions(+), 70 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:31:53.214353+00:00.
+libwebrtc updated from /Users/danielbaker/elm/.moz-fast-forward/moz-libwebrtc commit mozpatches on 2025-12-02T02:34:37.298808+00:00.
# base of lastest vendoring
-bb6b3aab15
+dc5f3e9b89
diff --git a/third_party/libwebrtc/p2p/BUILD.gn b/third_party/libwebrtc/p2p/BUILD.gn
@@ -108,6 +108,7 @@ rtc_library("basic_packet_socket_factory") {
":async_stun_tcp_socket",
"../api:async_dns_resolver",
"../api:packet_socket_factory",
+ "../api/environment",
"../rtc_base:async_dns_resolver",
"../rtc_base:async_packet_socket",
"../rtc_base:async_tcp_socket",
diff --git a/third_party/libwebrtc/p2p/base/async_stun_tcp_socket.cc b/third_party/libwebrtc/p2p/base/async_stun_tcp_socket.cc
@@ -17,7 +17,6 @@
#include <utility>
#include "absl/base/nullability.h"
-#include "absl/memory/memory.h"
#include "api/array_view.h"
#include "api/environment/environment.h"
#include "api/transport/stun.h"
@@ -52,9 +51,6 @@ AsyncStunTCPSocket::AsyncStunTCPSocket(
absl_nonnull std::unique_ptr<Socket> socket)
: AsyncTCPSocketBase(std::move(socket), kBufSize) {}
-AsyncStunTCPSocket::AsyncStunTCPSocket(Socket* socket)
- : AsyncTCPSocketBase(absl::WrapUnique(socket), kBufSize) {}
-
int AsyncStunTCPSocket::Send(const void* pv,
size_t cb,
const AsyncSocketPacketOptions& options) {
diff --git a/third_party/libwebrtc/p2p/base/async_stun_tcp_socket.h b/third_party/libwebrtc/p2p/base/async_stun_tcp_socket.h
@@ -28,9 +28,6 @@ class AsyncStunTCPSocket : public AsyncTCPSocketBase {
public:
AsyncStunTCPSocket(const Environment& env,
absl_nonnull std::unique_ptr<Socket> socket);
- // TODO: bugs.webrtc.org/42223992 - Delete or deprecate constructor below when
- // WebRTC is updated to use constructor that provides Environment.
- explicit AsyncStunTCPSocket(Socket* socket);
AsyncStunTCPSocket(const AsyncStunTCPSocket&) = delete;
AsyncStunTCPSocket& operator=(const AsyncStunTCPSocket&) = delete;
diff --git a/third_party/libwebrtc/p2p/base/async_stun_tcp_socket_unittest.cc b/third_party/libwebrtc/p2p/base/async_stun_tcp_socket_unittest.cc
@@ -74,14 +74,10 @@ class AsyncStunServerTCPSocket : public AsyncTcpListenSocket {
public:
AsyncStunServerTCPSocket(const Environment& env,
std::unique_ptr<Socket> socket)
- : AsyncTcpListenSocket(std::move(socket)), env_(env) {}
- void HandleIncomingConnection(Socket* socket) override {
- SignalNewConnection(this,
- new AsyncStunTCPSocket(env_, absl::WrapUnique(socket)));
+ : AsyncTcpListenSocket(env, std::move(socket)) {}
+ void HandleIncomingConnection(std::unique_ptr<Socket> socket) override {
+ SignalNewConnection(this, new AsyncStunTCPSocket(env(), std::move(socket)));
}
-
- private:
- const Environment env_;
};
class AsyncStunTCPSocketTest : public ::testing::Test,
diff --git a/third_party/libwebrtc/p2p/base/basic_packet_socket_factory.cc b/third_party/libwebrtc/p2p/base/basic_packet_socket_factory.cc
@@ -13,9 +13,11 @@
#include <cstdint>
#include <memory>
#include <string>
+#include <utility>
#include "absl/memory/memory.h"
#include "api/async_dns_resolver.h"
+#include "api/environment/environment.h"
#include "api/packet_socket_factory.h"
#include "p2p/base/async_stun_tcp_socket.h"
#include "rtc_base/async_dns_resolver.h"
@@ -38,24 +40,27 @@ BasicPacketSocketFactory::BasicPacketSocketFactory(
BasicPacketSocketFactory::~BasicPacketSocketFactory() {}
-AsyncPacketSocket* BasicPacketSocketFactory::CreateUdpSocket(
+std::unique_ptr<AsyncPacketSocket> BasicPacketSocketFactory::CreateUdpSocket(
+ const Environment& env,
const SocketAddress& address,
uint16_t min_port,
uint16_t max_port) {
// UDP sockets are simple.
- Socket* socket = socket_factory_->CreateSocket(address.family(), SOCK_DGRAM);
+ std::unique_ptr<Socket> socket =
+ socket_factory_->Create(address.family(), SOCK_DGRAM);
if (!socket) {
return nullptr;
}
- if (BindSocket(socket, address, min_port, max_port) < 0) {
+ if (BindSocket(*socket, address, min_port, max_port) < 0) {
RTC_LOG(LS_ERROR) << "UDP bind failed with error " << socket->GetError();
- delete socket;
return nullptr;
}
- return new AsyncUDPSocket(socket);
+ return std::make_unique<AsyncUDPSocket>(env, std::move(socket));
}
-AsyncListenSocket* BasicPacketSocketFactory::CreateServerTcpSocket(
+std::unique_ptr<AsyncListenSocket>
+BasicPacketSocketFactory::CreateServerTcpSocket(
+ const Environment& env,
const SocketAddress& local_address,
uint16_t min_port,
uint16_t max_port,
@@ -70,34 +75,35 @@ AsyncListenSocket* BasicPacketSocketFactory::CreateServerTcpSocket(
RTC_LOG(LS_ERROR) << "Fake TLS not supported.";
return nullptr;
}
- Socket* socket =
- socket_factory_->CreateSocket(local_address.family(), SOCK_STREAM);
+ std::unique_ptr<Socket> socket =
+ socket_factory_->Create(local_address.family(), SOCK_STREAM);
if (!socket) {
return nullptr;
}
- if (BindSocket(socket, local_address, min_port, max_port) < 0) {
+ if (BindSocket(*socket, local_address, min_port, max_port) < 0) {
RTC_LOG(LS_ERROR) << "TCP bind failed with error " << socket->GetError();
- delete socket;
return nullptr;
}
RTC_CHECK(!(opts & PacketSocketFactory::OPT_STUN));
- return new AsyncTcpListenSocket(absl::WrapUnique(socket));
+ return std::make_unique<AsyncTcpListenSocket>(env, std::move(socket));
}
-AsyncPacketSocket* BasicPacketSocketFactory::CreateClientTcpSocket(
+std::unique_ptr<AsyncPacketSocket>
+BasicPacketSocketFactory::CreateClientTcpSocket(
+ const Environment& env,
const SocketAddress& local_address,
const SocketAddress& remote_address,
const PacketSocketTcpOptions& tcp_options) {
- Socket* socket =
- socket_factory_->CreateSocket(local_address.family(), SOCK_STREAM);
+ std::unique_ptr<Socket> socket =
+ socket_factory_->Create(local_address.family(), SOCK_STREAM);
if (!socket) {
return nullptr;
}
- if (BindSocket(socket, local_address, 0, 0) < 0) {
+ if (BindSocket(*socket, local_address, 0, 0) < 0) {
// Allow BindSocket to fail if we're binding to the ANY address, since this
// is mostly redundant in the first place. The socket will be bound when we
// call Connect() instead.
@@ -106,7 +112,6 @@ AsyncPacketSocket* BasicPacketSocketFactory::CreateClientTcpSocket(
<< "; ignoring since socket is using 'any' address.";
} else {
RTC_LOG(LS_ERROR) << "TCP bind failed with error " << socket->GetError();
- delete socket;
return nullptr;
}
}
@@ -130,7 +135,8 @@ AsyncPacketSocket* BasicPacketSocketFactory::CreateClientTcpSocket(
if ((tlsOpts & PacketSocketFactory::OPT_TLS) ||
(tlsOpts & PacketSocketFactory::OPT_TLS_INSECURE)) {
// Using TLS, wrap the socket in an SSL adapter.
- SSLAdapter* ssl_adapter = SSLAdapter::Create(socket);
+ std::unique_ptr<SSLAdapter> ssl_adapter =
+ absl::WrapUnique(SSLAdapter::Create(socket.release()));
if (!ssl_adapter) {
return nullptr;
}
@@ -143,33 +149,26 @@ AsyncPacketSocket* BasicPacketSocketFactory::CreateClientTcpSocket(
ssl_adapter->SetEllipticCurves(tcp_options.tls_elliptic_curves);
ssl_adapter->SetCertVerifier(tcp_options.tls_cert_verifier);
- socket = ssl_adapter;
-
if (ssl_adapter->StartSSL(remote_address.hostname().c_str()) != 0) {
- delete ssl_adapter;
return nullptr;
}
-
+ socket = std::move(ssl_adapter);
} else if (tlsOpts & PacketSocketFactory::OPT_TLS_FAKE) {
// Using fake TLS, wrap the TCP socket in a pseudo-SSL socket.
- socket = new AsyncSSLSocket(socket);
+ socket = std::make_unique<AsyncSSLSocket>(socket.release());
}
if (socket->Connect(remote_address) < 0) {
RTC_LOG(LS_ERROR) << "TCP connect failed with error " << socket->GetError();
- delete socket;
return nullptr;
}
// Finally, wrap that socket in a TCP or STUN TCP packet socket.
- AsyncPacketSocket* tcp_socket;
if (tcp_options.opts & PacketSocketFactory::OPT_STUN) {
- tcp_socket = new AsyncStunTCPSocket(socket);
+ return std::make_unique<AsyncStunTCPSocket>(env, std::move(socket));
} else {
- tcp_socket = new AsyncTCPSocket(socket);
+ return std::make_unique<AsyncTCPSocket>(env, std::move(socket));
}
-
- return tcp_socket;
}
std::unique_ptr<AsyncDnsResolverInterface>
@@ -177,18 +176,18 @@ BasicPacketSocketFactory::CreateAsyncDnsResolver() {
return std::make_unique<AsyncDnsResolver>();
}
-int BasicPacketSocketFactory::BindSocket(Socket* socket,
+int BasicPacketSocketFactory::BindSocket(Socket& socket,
const SocketAddress& local_address,
uint16_t min_port,
uint16_t max_port) {
int ret = -1;
if (min_port == 0 && max_port == 0) {
// If there's no port range, let the OS pick a port for us.
- ret = socket->Bind(local_address);
+ ret = socket.Bind(local_address);
} else {
// Otherwise, try to find a port in the provided range.
for (int port = min_port; ret < 0 && port <= max_port; ++port) {
- ret = socket->Bind(SocketAddress(local_address.ipaddr(), port));
+ ret = socket.Bind(SocketAddress(local_address.ipaddr(), port));
}
}
return ret;
diff --git a/third_party/libwebrtc/p2p/base/basic_packet_socket_factory.h b/third_party/libwebrtc/p2p/base/basic_packet_socket_factory.h
@@ -15,6 +15,7 @@
#include <memory>
#include "api/async_dns_resolver.h"
+#include "api/environment/environment.h"
#include "api/packet_socket_factory.h"
#include "rtc_base/async_packet_socket.h"
#include "rtc_base/socket.h"
@@ -29,14 +30,19 @@ class RTC_EXPORT BasicPacketSocketFactory : public PacketSocketFactory {
explicit BasicPacketSocketFactory(SocketFactory* socket_factory);
~BasicPacketSocketFactory() override;
- AsyncPacketSocket* CreateUdpSocket(const SocketAddress& local_address,
- uint16_t min_port,
- uint16_t max_port) override;
- AsyncListenSocket* CreateServerTcpSocket(const SocketAddress& local_address,
- uint16_t min_port,
- uint16_t max_port,
- int opts) override;
- AsyncPacketSocket* CreateClientTcpSocket(
+ std::unique_ptr<AsyncPacketSocket> CreateUdpSocket(
+ const Environment& env,
+ const SocketAddress& local_address,
+ uint16_t min_port,
+ uint16_t max_port) override;
+ std::unique_ptr<AsyncListenSocket> CreateServerTcpSocket(
+ const Environment& env,
+ const SocketAddress& local_address,
+ uint16_t min_port,
+ uint16_t max_port,
+ int opts) override;
+ std::unique_ptr<AsyncPacketSocket> CreateClientTcpSocket(
+ const Environment& env,
const SocketAddress& local_address,
const SocketAddress& remote_address,
const PacketSocketTcpOptions& tcp_options) override;
@@ -44,7 +50,7 @@ class RTC_EXPORT BasicPacketSocketFactory : public PacketSocketFactory {
std::unique_ptr<AsyncDnsResolverInterface> CreateAsyncDnsResolver() override;
private:
- int BindSocket(Socket* socket,
+ int BindSocket(Socket& socket,
const SocketAddress& local_address,
uint16_t min_port,
uint16_t max_port);
diff --git a/third_party/libwebrtc/p2p/test/turn_server_unittest.cc b/third_party/libwebrtc/p2p/test/turn_server_unittest.cc
@@ -12,12 +12,14 @@
#include <memory>
+#include "api/environment/environment.h"
#include "p2p/base/basic_packet_socket_factory.h"
#include "p2p/base/port_interface.h"
#include "rtc_base/async_packet_socket.h"
#include "rtc_base/socket_address.h"
#include "rtc_base/thread.h"
#include "rtc_base/virtual_socket_server.h"
+#include "test/create_test_environment.h"
#include "test/gtest.h"
// NOTE: This is a work in progress. Currently this file only has tests for
@@ -51,10 +53,11 @@ class TurnServerConnectionTest : public ::testing::Test {
};
TEST_F(TurnServerConnectionTest, ComparisonOperators) {
- std::unique_ptr<AsyncPacketSocket> socket1(
- socket_factory_.CreateUdpSocket(SocketAddress("1.1.1.1", 1), 0, 0));
- std::unique_ptr<AsyncPacketSocket> socket2(
- socket_factory_.CreateUdpSocket(SocketAddress("2.2.2.2", 2), 0, 0));
+ const Environment env = CreateTestEnvironment();
+ std::unique_ptr<AsyncPacketSocket> socket1 =
+ socket_factory_.CreateUdpSocket(env, SocketAddress("1.1.1.1", 1), 0, 0);
+ std::unique_ptr<AsyncPacketSocket> socket2 =
+ socket_factory_.CreateUdpSocket(env, SocketAddress("2.2.2.2", 2), 0, 0);
TurnServerConnection connection1(socket2->GetLocalAddress(), PROTO_UDP,
socket1.get());
TurnServerConnection connection2(socket2->GetLocalAddress(), PROTO_UDP,
diff --git a/third_party/libwebrtc/rtc_base/async_tcp_socket.cc b/third_party/libwebrtc/rtc_base/async_tcp_socket.cc
@@ -293,8 +293,9 @@ size_t AsyncTCPSocket::ProcessInput(ArrayView<const uint8_t> data) {
}
}
-AsyncTcpListenSocket::AsyncTcpListenSocket(std::unique_ptr<Socket> socket)
- : socket_(std::move(socket)) {
+AsyncTcpListenSocket::AsyncTcpListenSocket(const Environment& env,
+ std::unique_ptr<Socket> socket)
+ : env_(env), socket_(std::move(socket)) {
RTC_DCHECK(socket_.get() != nullptr);
socket_->SignalReadEvent.connect(this, &AsyncTcpListenSocket::OnReadEvent);
if (socket_->Listen(kListenBacklog) < 0) {
@@ -330,14 +331,15 @@ void AsyncTcpListenSocket::OnReadEvent(Socket* socket) {
return;
}
- HandleIncomingConnection(new_socket);
+ HandleIncomingConnection(absl::WrapUnique(new_socket));
// Prime a read event in case data is waiting.
new_socket->SignalReadEvent(new_socket);
}
-void AsyncTcpListenSocket::HandleIncomingConnection(Socket* socket) {
- SignalNewConnection(this, new AsyncTCPSocket(socket));
+void AsyncTcpListenSocket::HandleIncomingConnection(
+ std::unique_ptr<Socket> socket) {
+ SignalNewConnection(this, new AsyncTCPSocket(env_, std::move(socket)));
}
} // namespace webrtc
diff --git a/third_party/libwebrtc/rtc_base/async_tcp_socket.h b/third_party/libwebrtc/rtc_base/async_tcp_socket.h
@@ -101,17 +101,20 @@ class AsyncTCPSocket : public AsyncTCPSocketBase {
class AsyncTcpListenSocket : public AsyncListenSocket {
public:
- explicit AsyncTcpListenSocket(std::unique_ptr<Socket> socket);
+ AsyncTcpListenSocket(const Environment& env, std::unique_ptr<Socket> socket);
State GetState() const override;
SocketAddress GetLocalAddress() const override;
- virtual void HandleIncomingConnection(Socket* socket);
+ protected:
+ const Environment& env() const { return env_; }
private:
// Called by the underlying socket
void OnReadEvent(Socket* socket);
+ virtual void HandleIncomingConnection(std::unique_ptr<Socket> socket);
+ const Environment env_;
std::unique_ptr<Socket> socket_;
};
diff --git a/third_party/libwebrtc/rtc_tools/network_tester/test_controller.cc b/third_party/libwebrtc/rtc_tools/network_tester/test_controller.cc
@@ -54,9 +54,8 @@ TestController::TestController(const Environment& env,
packet_sender_thread_->Start();
packet_sender_thread_->BlockingCall([&] {
RTC_DCHECK_RUN_ON(packet_sender_thread_.get());
- udp_socket_ =
- std::unique_ptr<AsyncPacketSocket>(socket_factory_.CreateUdpSocket(
- SocketAddress(GetAnyIP(AF_INET), 0), min_port, max_port));
+ udp_socket_ = socket_factory_.CreateUdpSocket(
+ env_, SocketAddress(GetAnyIP(AF_INET), 0), min_port, max_port);
RTC_CHECK(udp_socket_ != nullptr);
udp_socket_->RegisterReceivedPacketCallback(
[&](AsyncPacketSocket* socket, const ReceivedIpPacket& packet) {
