commit a6eb82f85a4a67f15e8b5d108586c4bb5a41f5dc
parent 68822426fedbea01b315db20808d973a126a7c36
Author: Dan Baker <dbaker@mozilla.com>
Date: Mon, 1 Dec 2025 21:13:57 -0700
Bug 2000941 - Vendor libwebrtc from c62fdaa2da
Upstream commit: https://webrtc.googlesource.com/src/+/c62fdaa2dae5f0885a09b406e3dd80863ddb0875
Provide Environment for AsyncUDPSocket in rtc_base unittests
Cleanup nearby code:
use SocketServer::Create instead of SocketServer::CreateSocket to get
unique_ptr directly
Save AsyncUDPSocket using unique_ptr instead of raw pointer
Unwrap TestClient from unique_ptr where unique_ptr is not moved
Bug: webrtc:42223992
Change-Id: I3dc41bcac369e50d332e46e278eb55ab644758d5
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/409548
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#45664}
Diffstat:
13 files changed, 251 insertions(+), 216 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-02T04:11:22.195589+00:00.
+libwebrtc updated from /Users/danielbaker/elm/.moz-fast-forward/moz-libwebrtc commit mozpatches on 2025-12-02T04:13:43.134333+00:00.
# base of lastest vendoring
-54c4cab4f5
+c62fdaa2da
diff --git a/third_party/libwebrtc/moz-patch-stack/s0001.patch b/third_party/libwebrtc/moz-patch-stack/s0001.patch
@@ -1392,7 +1392,7 @@ index 5ccc3d7d38..cd957416bc 100644
const bool enable_svc_for_simulcast_;
std::optional<SimulcastToSvcConverter> simulcast_to_svc_converter_;
diff --git a/rtc_base/BUILD.gn b/rtc_base/BUILD.gn
-index db13e5a411..324a40843d 100644
+index ce7896bbed..668b55b766 100644
--- a/rtc_base/BUILD.gn
+++ b/rtc_base/BUILD.gn
@@ -449,6 +449,12 @@ rtc_library("logging") {
diff --git a/third_party/libwebrtc/moz-patch-stack/s0027.patch b/third_party/libwebrtc/moz-patch-stack/s0027.patch
@@ -1008,7 +1008,7 @@ index 39aa39a41c..b26e30e8bb 100644
"/config/external/nspr",
"/nsprpub/lib/ds",
diff --git a/rtc_base/BUILD.gn b/rtc_base/BUILD.gn
-index 324a40843d..c629c55a07 100644
+index 668b55b766..fa927c25d9 100644
--- a/rtc_base/BUILD.gn
+++ b/rtc_base/BUILD.gn
@@ -326,6 +326,7 @@ rtc_library("sample_counter") {
@@ -1176,7 +1176,7 @@ index 324a40843d..c629c55a07 100644
rtc_library("ssl_adapter") {
visibility = [ "*" ]
-@@ -2382,7 +2406,7 @@ if (rtc_include_tests) {
+@@ -2386,7 +2410,7 @@ if (rtc_include_tests) {
}
}
diff --git a/third_party/libwebrtc/moz-patch-stack/s0053.patch b/third_party/libwebrtc/moz-patch-stack/s0053.patch
@@ -29,7 +29,7 @@ index 7db75d5fd3..d0feb5007c 100644
rtc_library("task_queue_test") {
visibility = [ "*" ]
diff --git a/rtc_base/BUILD.gn b/rtc_base/BUILD.gn
-index c629c55a07..03f57cf419 100644
+index fa927c25d9..7bca814660 100644
--- a/rtc_base/BUILD.gn
+++ b/rtc_base/BUILD.gn
@@ -664,10 +664,14 @@ if (is_mac || is_ios) {
diff --git a/third_party/libwebrtc/moz-patch-stack/s0091.patch b/third_party/libwebrtc/moz-patch-stack/s0091.patch
@@ -13,7 +13,7 @@ Mercurial Revision: https://hg.mozilla.org/mozilla-central/rev/4e7b3c485e549e7e3
1 file changed, 6 insertions(+)
diff --git a/rtc_base/BUILD.gn b/rtc_base/BUILD.gn
-index 03f57cf419..180a0656f1 100644
+index 7bca814660..d640c9ddc3 100644
--- a/rtc_base/BUILD.gn
+++ b/rtc_base/BUILD.gn
@@ -992,6 +992,12 @@ rtc_library("threading") {
diff --git a/third_party/libwebrtc/moz-patch-stack/s0094.patch b/third_party/libwebrtc/moz-patch-stack/s0094.patch
@@ -9,7 +9,7 @@ Mercurial Revision: https://hg.mozilla.org/mozilla-central/rev/ee2f06666bcc6d22c
1 file changed, 2 insertions(+)
diff --git a/rtc_base/BUILD.gn b/rtc_base/BUILD.gn
-index 180a0656f1..3ce3e5d941 100644
+index d640c9ddc3..f7a8428d3f 100644
--- a/rtc_base/BUILD.gn
+++ b/rtc_base/BUILD.gn
@@ -1690,6 +1690,7 @@ if (!build_with_mozilla) {
diff --git a/third_party/libwebrtc/moz-patch-stack/s0102.patch b/third_party/libwebrtc/moz-patch-stack/s0102.patch
@@ -616,7 +616,7 @@ index 4c837bb838..96fbcc9539 100644
if (rtc_build_libsrtp) {
diff --git a/rtc_base/BUILD.gn b/rtc_base/BUILD.gn
-index 3ce3e5d941..f53d995584 100644
+index f7a8428d3f..408573e6a7 100644
--- a/rtc_base/BUILD.gn
+++ b/rtc_base/BUILD.gn
@@ -9,8 +9,8 @@
diff --git a/third_party/libwebrtc/moz-patch-stack/s0107.patch b/third_party/libwebrtc/moz-patch-stack/s0107.patch
@@ -116,7 +116,7 @@ index ecbb7eae7e..a13fe19324 100644
public_configs = []
if (!build_with_chromium) {
diff --git a/rtc_base/BUILD.gn b/rtc_base/BUILD.gn
-index f53d995584..978e369668 100644
+index 408573e6a7..2f064aaf3a 100644
--- a/rtc_base/BUILD.gn
+++ b/rtc_base/BUILD.gn
@@ -1569,6 +1569,7 @@ rtc_source_set("ssl_header") {
diff --git a/third_party/libwebrtc/rtc_base/BUILD.gn b/third_party/libwebrtc/rtc_base/BUILD.gn
@@ -2067,10 +2067,12 @@ if (rtc_include_tests) {
":threading",
":timeutils",
"../api:rtc_error_matchers",
+ "../api/environment",
"../api/transport:ecn_marking",
"../api/units:time_delta",
"../api/units:timestamp",
"../system_wrappers",
+ "../test:create_test_environment",
"../test:fileutils",
"../test:test_main",
"../test:test_support",
@@ -2189,6 +2191,7 @@ if (rtc_include_tests) {
"../api:make_ref_counted",
"../api:ref_count",
"../api:scoped_refptr",
+ "../api/environment",
"../api/numerics",
"../api/units:data_rate",
"../api/units:data_size",
@@ -2196,6 +2199,7 @@ if (rtc_include_tests) {
"../api/units:time_delta",
"../api/units:timestamp",
"../system_wrappers",
+ "../test:create_test_environment",
"../test:fileutils",
"../test:test_main",
"../test:test_support",
diff --git a/third_party/libwebrtc/rtc_base/socket_unittest.cc b/third_party/libwebrtc/rtc_base/socket_unittest.cc
@@ -18,24 +18,25 @@
#include <string>
#include <utility>
-#include "absl/memory/memory.h"
#include "absl/strings/string_view.h"
#include "api/test/rtc_error_matchers.h"
#include "api/transport/ecn_marking.h"
+#include "api/units/time_delta.h"
#include "rtc_base/async_udp_socket.h"
#include "rtc_base/buffer.h"
-#include "rtc_base/gunit.h"
#include "rtc_base/ip_address.h"
#include "rtc_base/logging.h"
#include "rtc_base/net_helpers.h"
#include "rtc_base/net_test_helpers.h"
#include "rtc_base/socket_address.h"
+#include "rtc_base/socket_factory.h"
#include "rtc_base/socket_server.h"
#include "rtc_base/socket_unittest.h"
#include "rtc_base/test_client.h"
#include "rtc_base/test_utils.h"
#include "rtc_base/third_party/sigslot/sigslot.h"
#include "rtc_base/thread.h"
+#include "test/create_test_environment.h"
#include "test/gmock.h"
#include "test/gtest.h"
#include "test/wait_until.h"
@@ -48,6 +49,10 @@
namespace webrtc {
+MATCHER_P2(Near, expected, max_error, "") {
+ return expected - max_error < arg && arg < expected + max_error;
+}
+
using testing::SSE_CLOSE;
using testing::SSE_ERROR;
using testing::SSE_OPEN;
@@ -58,6 +63,12 @@ using testing::StreamSink;
// Data size to be used in TcpInternal tests.
static const size_t kTcpInternalDataSize = 1024 * 1024; // bytes
+SocketTest::SocketTest(SocketFactory* socket_factory)
+ : kIPv4Loopback(INADDR_LOOPBACK),
+ kIPv6Loopback(in6addr_loopback),
+ env_(CreateTestEnvironment()),
+ socket_factory_(socket_factory) {}
+
void SocketTest::TestConnectIPv4() {
ConnectInternal(kIPv4Loopback);
}
@@ -260,15 +271,15 @@ void SocketTest::ConnectInternal(const IPAddress& loopback) {
SocketAddress accept_addr;
// Create client.
- std::unique_ptr<Socket> client(
- socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> client =
+ socket_factory_->Create(loopback.family(), SOCK_STREAM);
sink.Monitor(client.get());
EXPECT_EQ(Socket::CS_CLOSED, client->GetState());
EXPECT_TRUE(IsUnspecOrEmptyIP(client->GetLocalAddress().ipaddr()));
// Create server and listen.
- std::unique_ptr<Socket> server(
- socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> server =
+ socket_factory_->Create(loopback.family(), SOCK_STREAM);
sink.Monitor(server.get());
EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
@@ -319,13 +330,13 @@ void SocketTest::ConnectWithDnsLookupInternal(const IPAddress& loopback,
SocketAddress accept_addr;
// Create client.
- std::unique_ptr<Socket> client(
- socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> client =
+ socket_factory_->Create(loopback.family(), SOCK_STREAM);
sink.Monitor(client.get());
// Create server and listen.
- std::unique_ptr<Socket> server(
- socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> server =
+ socket_factory_->Create(loopback.family(), SOCK_STREAM);
sink.Monitor(server.get());
EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
@@ -371,13 +382,13 @@ void SocketTest::ConnectFailInternal(const IPAddress& loopback) {
SocketAddress accept_addr;
// Create client.
- std::unique_ptr<Socket> client(
- socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> client =
+ socket_factory_->Create(loopback.family(), SOCK_STREAM);
sink.Monitor(client.get());
// Create server, but don't listen yet.
- std::unique_ptr<Socket> server(
- socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> server =
+ socket_factory_->Create(loopback.family(), SOCK_STREAM);
sink.Monitor(server.get());
EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
@@ -406,13 +417,13 @@ void SocketTest::ConnectWithDnsLookupFailInternal(const IPAddress& loopback) {
SocketAddress accept_addr;
// Create client.
- std::unique_ptr<Socket> client(
- socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> client =
+ socket_factory_->Create(loopback.family(), SOCK_STREAM);
sink.Monitor(client.get());
// Create server, but don't listen yet.
- std::unique_ptr<Socket> server(
- socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> server =
+ socket_factory_->Create(loopback.family(), SOCK_STREAM);
sink.Monitor(server.get());
EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
@@ -445,14 +456,14 @@ void SocketTest::ConnectWithDnsLookupFailInternal(const IPAddress& loopback) {
void SocketTest::ConnectWithClosedSocketInternal(const IPAddress& loopback) {
// Create server and listen.
- std::unique_ptr<Socket> server(
- socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> server =
+ socket_factory_->Create(loopback.family(), SOCK_STREAM);
EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
// Create a client and put in to CS_CLOSED state.
- std::unique_ptr<Socket> client(
- socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> client =
+ socket_factory_->Create(loopback.family(), SOCK_STREAM);
EXPECT_EQ(0, client->Close());
EXPECT_EQ(Socket::CS_CLOSED, client->GetState());
@@ -464,14 +475,14 @@ void SocketTest::ConnectWithClosedSocketInternal(const IPAddress& loopback) {
void SocketTest::ConnectWhileNotClosedInternal(const IPAddress& loopback) {
// Create server and listen.
StreamSink sink;
- std::unique_ptr<Socket> server(
- socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> server =
+ socket_factory_->Create(loopback.family(), SOCK_STREAM);
sink.Monitor(server.get());
EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
// Create client, connect.
- std::unique_ptr<Socket> client(
- socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> client =
+ socket_factory_->Create(loopback.family(), SOCK_STREAM);
EXPECT_EQ(0, client->Connect(SocketAddress(server->GetLocalAddress())));
EXPECT_EQ(Socket::CS_CONNECTING, client->GetState());
// Try to connect again. Should fail, but not interfere with original attempt.
@@ -511,13 +522,13 @@ void SocketTest::ServerCloseDuringConnectInternal(const IPAddress& loopback) {
StreamSink sink;
// Create client.
- std::unique_ptr<Socket> client(
- socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> client =
+ socket_factory_->Create(loopback.family(), SOCK_STREAM);
sink.Monitor(client.get());
// Create server and listen.
- std::unique_ptr<Socket> server(
- socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> server =
+ socket_factory_->Create(loopback.family(), SOCK_STREAM);
sink.Monitor(server.get());
EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
@@ -544,13 +555,13 @@ void SocketTest::ClientCloseDuringConnectInternal(const IPAddress& loopback) {
SocketAddress accept_addr;
// Create client.
- std::unique_ptr<Socket> client(
- socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> client =
+ socket_factory_->Create(loopback.family(), SOCK_STREAM);
sink.Monitor(client.get());
// Create server and listen.
- std::unique_ptr<Socket> server(
- socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> server =
+ socket_factory_->Create(loopback.family(), SOCK_STREAM);
sink.Monitor(server.get());
EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
@@ -586,13 +597,13 @@ void SocketTest::ServerCloseInternal(const IPAddress& loopback) {
SocketAddress accept_addr;
// Create client.
- std::unique_ptr<Socket> client(
- socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> client =
+ socket_factory_->Create(loopback.family(), SOCK_STREAM);
sink.Monitor(client.get());
// Create server and listen.
- std::unique_ptr<Socket> server(
- socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> server =
+ socket_factory_->Create(loopback.family(), SOCK_STREAM);
sink.Monitor(server.get());
EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
@@ -668,14 +679,14 @@ void SocketTest::CloseInClosedCallbackInternal(const IPAddress& loopback) {
SocketAddress accept_addr;
// Create client.
- std::unique_ptr<Socket> client(
- socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> client =
+ socket_factory_->Create(loopback.family(), SOCK_STREAM);
sink.Monitor(client.get());
client->SignalCloseEvent.connect(&closer, &SocketCloser::OnClose);
// Create server and listen.
- std::unique_ptr<Socket> server(
- socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> server =
+ socket_factory_->Create(loopback.family(), SOCK_STREAM);
sink.Monitor(server.get());
EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
@@ -733,10 +744,10 @@ class SocketDeleter : public sigslot::has_slots<> {
// iteration of the select loop failed in this situation, if both sockets
// became readable at the same time.
void SocketTest::DeleteInReadCallbackInternal(const IPAddress& loopback) {
- std::unique_ptr<Socket> socket1(
- socket_factory_->CreateSocket(loopback.family(), SOCK_DGRAM));
- std::unique_ptr<Socket> socket2(
- socket_factory_->CreateSocket(loopback.family(), SOCK_DGRAM));
+ std::unique_ptr<Socket> socket1 =
+ socket_factory_->Create(loopback.family(), SOCK_DGRAM);
+ std::unique_ptr<Socket> socket2 =
+ socket_factory_->Create(loopback.family(), SOCK_DGRAM);
EXPECT_EQ(0, socket1->Bind(SocketAddress(loopback, 0)));
EXPECT_EQ(0, socket2->Bind(SocketAddress(loopback, 0)));
EXPECT_EQ(3, socket1->SendTo("foo", 3, socket1->GetLocalAddress()));
@@ -757,10 +768,10 @@ void SocketTest::SocketServerWaitInternal(const IPAddress& loopback) {
SocketAddress accept_addr;
// Create & connect server and client sockets.
- std::unique_ptr<Socket> client(
- socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
- std::unique_ptr<Socket> server(
- socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> client =
+ socket_factory_->Create(loopback.family(), SOCK_STREAM);
+ std::unique_ptr<Socket> server =
+ socket_factory_->Create(loopback.family(), SOCK_STREAM);
sink.Monitor(client.get());
sink.Monitor(server.get());
EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
@@ -813,13 +824,13 @@ void SocketTest::TcpInternal(const IPAddress& loopback,
SocketAddress accept_addr;
// Create receiving client.
- std::unique_ptr<Socket> receiver(
- socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> receiver =
+ socket_factory_->Create(loopback.family(), SOCK_STREAM);
sink.Monitor(receiver.get());
// Create server and listen.
- std::unique_ptr<Socket> server(
- socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> server =
+ socket_factory_->Create(loopback.family(), SOCK_STREAM);
sink.Monitor(server.get());
EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
@@ -950,13 +961,13 @@ void SocketTest::SingleFlowControlCallbackInternal(const IPAddress& loopback) {
SocketAddress accept_addr;
// Create client.
- std::unique_ptr<Socket> client(
- socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> client =
+ socket_factory_->Create(loopback.family(), SOCK_STREAM);
sink.Monitor(client.get());
// Create server and listen.
- std::unique_ptr<Socket> server(
- socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> server =
+ socket_factory_->Create(loopback.family(), SOCK_STREAM);
sink.Monitor(server.get());
EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
@@ -1027,7 +1038,8 @@ void SocketTest::SingleFlowControlCallbackInternal(const IPAddress& loopback) {
void SocketTest::UdpInternal(const IPAddress& loopback) {
SocketAddress empty = EmptySocketAddressWithFamily(loopback.family());
// Test basic bind and connect behavior.
- Socket* socket = socket_factory_->CreateSocket(loopback.family(), SOCK_DGRAM);
+ std::unique_ptr<Socket> socket =
+ socket_factory_->Create(loopback.family(), SOCK_DGRAM);
EXPECT_EQ(Socket::CS_CLOSED, socket->GetState());
EXPECT_EQ(0, socket->Bind(SocketAddress(loopback, 0)));
SocketAddress addr1 = socket->GetLocalAddress();
@@ -1035,13 +1047,13 @@ void SocketTest::UdpInternal(const IPAddress& loopback) {
EXPECT_EQ(Socket::CS_CONNECTED, socket->GetState());
socket->Close();
EXPECT_EQ(Socket::CS_CLOSED, socket->GetState());
- delete socket;
+ socket = nullptr;
// Test send/receive behavior.
auto client1 = std::make_unique<TestClient>(
- absl::WrapUnique(AsyncUDPSocket::Create(socket_factory_, addr1)));
+ AsyncUDPSocket::Create(env_, addr1, *socket_factory_));
auto client2 = std::make_unique<TestClient>(
- absl::WrapUnique(AsyncUDPSocket::Create(socket_factory_, empty)));
+ AsyncUDPSocket::Create(env_, empty, *socket_factory_));
SocketAddress addr2;
EXPECT_EQ(3, client2->SendTo("foo", 3, addr1));
@@ -1054,7 +1066,7 @@ void SocketTest::UdpInternal(const IPAddress& loopback) {
// TODO: figure out what the intent is here
for (int i = 0; i < 10; ++i) {
client2 = std::make_unique<TestClient>(
- absl::WrapUnique(AsyncUDPSocket::Create(socket_factory_, empty)));
+ AsyncUDPSocket::Create(env_, empty, *socket_factory_));
SocketAddress addr4;
EXPECT_EQ(3, client2->SendTo("foo", 3, addr1));
@@ -1080,8 +1092,7 @@ void SocketTest::UdpReadyToSend(const IPAddress& loopback) {
SocketAddress test_addr(dest, 2345);
// Test send
- auto client = std::make_unique<TestClient>(
- absl::WrapUnique(AsyncUDPSocket::Create(socket_factory_, empty)));
+ TestClient client(AsyncUDPSocket::Create(env_, empty, *socket_factory_));
int test_packet_size = 1200;
std::unique_ptr<char[]> test_packet(new char[test_packet_size]);
// Init the test packet just to avoid memcheck warning.
@@ -1092,17 +1103,17 @@ void SocketTest::UdpReadyToSend(const IPAddress& loopback) {
#if defined(WEBRTC_LINUX) && !defined(WEBRTC_ANDROID)
send_buffer_size /= 2;
#endif
- client->SetOption(Socket::OPT_SNDBUF, send_buffer_size);
+ client.SetOption(Socket::OPT_SNDBUF, send_buffer_size);
int error = 0;
- uint32_t start_ms = clock_.TimeInMilliseconds();
+ uint32_t start_ms = env_.clock().TimeInMilliseconds();
int sent_packet_num = 0;
int expected_error = EWOULDBLOCK;
- while (start_ms + 5000 > clock_.TimeInMilliseconds()) {
- int ret = client->SendTo(test_packet.get(), test_packet_size, test_addr);
+ while (start_ms + 5000 > env_.clock().TimeInMilliseconds()) {
+ int ret = client.SendTo(test_packet.get(), test_packet_size, test_addr);
++sent_packet_num;
if (ret != test_packet_size) {
- error = client->GetError();
+ error = client.GetError();
if (error == expected_error) {
RTC_LOG(LS_INFO) << "Got expected error code after sending "
<< sent_packet_num << " packets.";
@@ -1111,16 +1122,14 @@ void SocketTest::UdpReadyToSend(const IPAddress& loopback) {
}
}
EXPECT_EQ(expected_error, error);
- EXPECT_FALSE(client->ready_to_send());
- EXPECT_THAT(
- WaitUntil([&] { return client->ready_to_send(); }, ::testing::IsTrue()),
- IsRtcOk());
+ EXPECT_FALSE(client.ready_to_send());
+ EXPECT_TRUE(WaitUntil([&] { return client.ready_to_send(); }));
RTC_LOG(LS_INFO) << "Got SignalReadyToSend";
}
void SocketTest::GetSetOptionsInternal(const IPAddress& loopback) {
- std::unique_ptr<Socket> socket(
- socket_factory_->CreateSocket(loopback.family(), SOCK_DGRAM));
+ std::unique_ptr<Socket> socket =
+ socket_factory_->Create(loopback.family(), SOCK_DGRAM);
socket->Bind(SocketAddress(loopback, 0));
// Check SNDBUF/RCVBUF.
@@ -1173,7 +1182,7 @@ void SocketTest::GetSetOptionsInternal(const IPAddress& loopback) {
#endif
// Prepare on TCP specific options.
- socket.reset(socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
+ socket = socket_factory_->Create(loopback.family(), SOCK_STREAM);
socket->Bind(SocketAddress(loopback, 0));
// Check that we can set NODELAY on a TCP socket.
@@ -1213,13 +1222,13 @@ void SocketTest::GetSetOptionsInternal(const IPAddress& loopback) {
void SocketTest::SocketRecvTimestamp(const IPAddress& loopback) {
StreamSink sink;
- std::unique_ptr<Socket> socket(
- socket_factory_->CreateSocket(loopback.family(), SOCK_DGRAM));
+ std::unique_ptr<Socket> socket =
+ socket_factory_->Create(loopback.family(), SOCK_DGRAM);
EXPECT_EQ(0, socket->Bind(SocketAddress(loopback, 0)));
SocketAddress address = socket->GetLocalAddress();
sink.Monitor(socket.get());
- int64_t send_time_1 = clock_.TimeInMicroseconds();
+ int64_t send_time_1 = env_.clock().TimeInMicroseconds();
socket->SendTo("foo", 3, address);
// Wait until data is available.
@@ -1233,7 +1242,7 @@ void SocketTest::SocketRecvTimestamp(const IPAddress& loopback) {
const int64_t kTimeBetweenPacketsMs = 100;
Thread::SleepMs(kTimeBetweenPacketsMs);
- int64_t send_time_2 = clock_.TimeInMicroseconds();
+ int64_t send_time_2 = env_.clock().TimeInMicroseconds();
socket->SendTo("bar", 3, address);
// Wait until data is available.
EXPECT_THAT(WaitUntil([&] { return sink.Check(socket.get(), SSE_READ); },
@@ -1252,37 +1261,35 @@ void SocketTest::SocketRecvTimestamp(const IPAddress& loopback) {
void SocketTest::UdpSocketRecvTimestampUseRtcEpoch(const IPAddress& loopback) {
SocketAddress empty = EmptySocketAddressWithFamily(loopback.family());
- std::unique_ptr<Socket> socket(
- socket_factory_->CreateSocket(loopback.family(), SOCK_DGRAM));
+ std::unique_ptr<Socket> socket =
+ socket_factory_->Create(loopback.family(), SOCK_DGRAM);
ASSERT_EQ(socket->Bind(SocketAddress(loopback, 0)), 0);
SocketAddress address = socket->GetLocalAddress();
socket = nullptr;
- auto client1 = std::make_unique<TestClient>(
- absl::WrapUnique(AsyncUDPSocket::Create(socket_factory_, address)));
- auto client2 = std::make_unique<TestClient>(
- absl::WrapUnique(AsyncUDPSocket::Create(socket_factory_, empty)));
+ TestClient client1(AsyncUDPSocket::Create(env_, address, *socket_factory_));
+ TestClient client2(AsyncUDPSocket::Create(env_, empty, *socket_factory_));
SocketAddress addr2;
- client2->SendTo("foo", 3, address);
- std::unique_ptr<TestClient::Packet> packet_1 = client1->NextPacket(10000);
+ client2.SendTo("foo", 3, address);
+ std::unique_ptr<TestClient::Packet> packet_1 = client1.NextPacket(10000);
ASSERT_TRUE(packet_1 != nullptr);
- EXPECT_NEAR(packet_1->packet_time->us(), clock_.TimeInMicroseconds(),
- 1000'000);
+ EXPECT_THAT(packet_1->packet_time,
+ Near(env_.clock().CurrentTime(), TimeDelta::Seconds(1)));
Thread::SleepMs(100);
- client2->SendTo("bar", 3, address);
- std::unique_ptr<TestClient::Packet> packet_2 = client1->NextPacket(10000);
+ client2.SendTo("bar", 3, address);
+ std::unique_ptr<TestClient::Packet> packet_2 = client1.NextPacket(10000);
ASSERT_TRUE(packet_2 != nullptr);
- EXPECT_GT(packet_2->packet_time->us(), packet_1->packet_time->us());
- EXPECT_NEAR(packet_2->packet_time->us(), clock_.TimeInMicroseconds(),
- 1000'000);
+ EXPECT_GT(packet_2->packet_time, packet_1->packet_time);
+ EXPECT_THAT(packet_2->packet_time,
+ Near(env_.clock().CurrentTime(), TimeDelta::Seconds(1)));
}
void SocketTest::SocketSendRecvWithEcn(const IPAddress& loopback) {
StreamSink sink;
- std::unique_ptr<Socket> socket(
- socket_factory_->CreateSocket(loopback.family(), SOCK_DGRAM));
+ std::unique_ptr<Socket> socket =
+ socket_factory_->Create(loopback.family(), SOCK_DGRAM);
EXPECT_EQ(0, socket->Bind(SocketAddress(loopback, 0)));
SocketAddress address = socket->GetLocalAddress();
sink.Monitor(socket.get());
diff --git a/third_party/libwebrtc/rtc_base/socket_unittest.h b/third_party/libwebrtc/rtc_base/socket_unittest.h
@@ -14,9 +14,9 @@
#include <cstddef>
#include "absl/strings/string_view.h"
+#include "api/environment/environment.h"
#include "rtc_base/ip_address.h"
#include "rtc_base/socket_factory.h"
-#include "system_wrappers/include/clock.h"
#include "test/gtest.h"
namespace webrtc {
@@ -26,11 +26,8 @@ namespace webrtc {
// socketserver, and call the SocketTest test methods.
class SocketTest : public ::testing::Test {
protected:
- explicit SocketTest(SocketFactory* socket_factory)
- : kIPv4Loopback(INADDR_LOOPBACK),
- kIPv6Loopback(in6addr_loopback),
- clock_(*Clock::GetRealTimeClock()),
- socket_factory_(socket_factory) {}
+ explicit SocketTest(SocketFactory* socket_factory);
+
void TestConnectIPv4();
void TestConnectIPv6();
void TestConnectWithDnsLookupIPv4();
@@ -79,7 +76,6 @@ class SocketTest : public ::testing::Test {
void TcpInternal(const IPAddress& loopback,
size_t data_size,
ptrdiff_t max_send_size);
- Clock& clock_;
private:
void ConnectInternal(const IPAddress& loopback);
@@ -104,6 +100,7 @@ class SocketTest : public ::testing::Test {
void UdpSocketRecvTimestampUseRtcEpoch(const IPAddress& loopback);
void SocketSendRecvWithEcn(const IPAddress& loopback);
+ const Environment env_;
SocketFactory* socket_factory_;
};
diff --git a/third_party/libwebrtc/rtc_base/thread_unittest.cc b/third_party/libwebrtc/rtc_base/thread_unittest.cc
@@ -34,10 +34,12 @@
#include "rtc_base/null_socket_server.h"
#include "rtc_base/socket.h"
#include "rtc_base/socket_address.h"
+#include "rtc_base/socket_factory.h"
#include "rtc_base/socket_server.h"
#include "rtc_base/synchronization/mutex.h"
#include "rtc_base/thread_annotations.h"
#include "rtc_base/time_utils.h"
+#include "test/create_test_environment.h"
#include "test/gmock.h"
#include "test/gtest.h"
#include "test/testsupport/rtc_expect_death.h"
@@ -88,11 +90,13 @@ class MessageClient : public TestGenerator {
// Receives on a socket and sends by posting messages.
class SocketClient : public TestGenerator {
public:
- SocketClient(Socket* socket,
+ SocketClient(SocketFactory* socket_factory,
const SocketAddress& addr,
Thread* post_thread,
MessageClient* phandler)
- : socket_(AsyncUDPSocket::Create(socket, addr)),
+ : socket_(AsyncUDPSocket::Create(CreateTestEnvironment(),
+ addr,
+ *socket_factory)),
post_thread_(post_thread),
post_handler_(phandler) {
socket_->RegisterReceivedPacketCallback(
@@ -101,7 +105,7 @@ class SocketClient : public TestGenerator {
});
}
- ~SocketClient() { delete socket_; }
+ ~SocketClient() = default;
SocketAddress address() const { return socket_->GetLocalAddress(); }
@@ -117,7 +121,7 @@ class SocketClient : public TestGenerator {
}
private:
- AsyncUDPSocket* socket_;
+ std::unique_ptr<AsyncUDPSocket> socket_;
Thread* post_thread_;
MessageClient* post_handler_;
};
@@ -166,9 +170,7 @@ TEST(ThreadTest, DISABLED_Main) {
// Create the socket client on its own thread.
auto th2 = Thread::CreateWithSocketServer();
- Socket* asocket =
- th2->socketserver()->CreateSocket(addr.family(), SOCK_DGRAM);
- SocketClient sock_client(asocket, addr, th1.get(), &msg_client);
+ SocketClient sock_client(th2->socketserver(), addr, th1.get(), &msg_client);
socket->Connect(sock_client.address());
diff --git a/third_party/libwebrtc/rtc_base/virtual_socket_unittest.cc b/third_party/libwebrtc/rtc_base/virtual_socket_unittest.cc
@@ -15,8 +15,10 @@
#include <cstring>
#include <ctime>
#include <memory>
+#include <utility>
#include "absl/memory/memory.h"
+#include "api/environment/environment.h"
#include "api/units/time_delta.h"
#include "rtc_base/async_packet_socket.h"
#include "rtc_base/async_udp_socket.h"
@@ -32,8 +34,8 @@
#include "rtc_base/test_client.h"
#include "rtc_base/test_utils.h"
#include "rtc_base/thread.h"
-#include "rtc_base/time_utils.h"
#include "rtc_base/virtual_socket_server.h"
+#include "test/create_test_environment.h"
#include "test/gtest.h"
namespace webrtc {
@@ -48,15 +50,19 @@ using testing::StreamSink;
// Sends at a constant rate but with random packet sizes.
struct Sender {
- Sender(Thread* th, Socket* s, uint32_t rt)
- : thread(th),
- socket(std::make_unique<AsyncUDPSocket>(s)),
+ Sender(const Environment& env,
+ Thread* th,
+ std::unique_ptr<Socket> s,
+ uint32_t rt)
+ : env(env),
+ thread(th),
+ socket(std::make_unique<AsyncUDPSocket>(env, std::move(s))),
rate(rt),
count(0) {
- last_send = TimeMillis();
+ last_send = this->env.clock().TimeInMilliseconds();
periodic = RepeatingTaskHandle::DelayedStart(thread, NextDelay(), [this] {
- int64_t cur_time = TimeMillis();
+ int64_t cur_time = this->env.clock().TimeInMilliseconds();
int64_t delay = cur_time - last_send;
uint32_t size =
std::clamp<uint32_t>(rate * delay / 1000, sizeof(uint32_t), 4096);
@@ -74,6 +80,7 @@ struct Sender {
return TimeDelta::Seconds(1) * size / rate;
}
+ const Environment env;
Thread* thread;
std::unique_ptr<AsyncUDPSocket> socket;
AsyncSocketPacketOptions options;
@@ -85,9 +92,13 @@ struct Sender {
};
struct Receiver {
- Receiver(Thread* th, Socket* s, uint32_t bw)
- : thread(th),
- socket(std::make_unique<AsyncUDPSocket>(s)),
+ Receiver(const Environment& env,
+ Thread* th,
+ std::unique_ptr<Socket> s,
+ uint32_t bw)
+ : env(env),
+ thread(th),
+ socket(std::make_unique<AsyncUDPSocket>(this->env, std::move(s))),
bandwidth(bw),
count(0),
sec_count(0),
@@ -121,13 +132,14 @@ struct Receiver {
uint32_t send_time =
*reinterpret_cast<const uint32_t*>(packet.payload().data());
- uint32_t recv_time = TimeMillis();
+ uint32_t recv_time = env.clock().TimeInMilliseconds();
uint32_t delay = recv_time - send_time;
sum += delay;
sum_sq += delay * delay;
samples += 1;
}
+ const Environment env;
Thread* thread;
std::unique_ptr<AsyncUDPSocket> socket;
uint32_t bandwidth;
@@ -174,70 +186,80 @@ class VirtualSocketServerTest : public ::testing::Test {
ss_.SetDefaultSourceAddress(default_address);
// Create client1 bound to the any address.
- Socket* socket = ss_.CreateSocket(default_address.family(), SOCK_DGRAM);
+ std::unique_ptr<Socket> socket =
+ ss_.Create(default_address.family(), SOCK_DGRAM);
socket->Bind(EmptySocketAddressWithFamily(default_address.family()));
SocketAddress client1_any_addr = socket->GetLocalAddress();
EXPECT_TRUE(client1_any_addr.IsAnyIP());
- auto client1 = std::make_unique<TestClient>(
- std::make_unique<AsyncUDPSocket>(socket), &fake_clock_);
+ TestClient client1(
+ std::make_unique<AsyncUDPSocket>(env_, std::move(socket)),
+ &fake_clock_);
// Create client2 bound to the address route.
- Socket* socket2 = ss_.CreateSocket(default_address.family(), SOCK_DGRAM);
+ std::unique_ptr<Socket> socket2 =
+ ss_.Create(default_address.family(), SOCK_DGRAM);
socket2->Bind(SocketAddress(default_address, 0));
SocketAddress client2_addr = socket2->GetLocalAddress();
EXPECT_FALSE(client2_addr.IsAnyIP());
- auto client2 = std::make_unique<TestClient>(
- std::make_unique<AsyncUDPSocket>(socket2), &fake_clock_);
+ TestClient client2(
+ std::make_unique<AsyncUDPSocket>(env_, std::move(socket2)),
+ &fake_clock_);
// Client1 sends to client2, client2 should see the default address as
// client1's address.
SocketAddress client1_addr;
- EXPECT_EQ(6, client1->SendTo("bizbaz", 6, client2_addr));
- EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &client1_addr));
+ EXPECT_EQ(6, client1.SendTo("bizbaz", 6, client2_addr));
+ EXPECT_TRUE(client2.CheckNextPacket("bizbaz", 6, &client1_addr));
EXPECT_EQ(client1_addr,
SocketAddress(default_address, client1_any_addr.port()));
// Client2 can send back to client1's default address.
- EXPECT_EQ(3, client2->SendTo("foo", 3, client1_addr));
- EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &client2_addr));
+ EXPECT_EQ(3, client2.SendTo("foo", 3, client1_addr));
+ EXPECT_TRUE(client1.CheckNextPacket("foo", 3, &client2_addr));
}
void BasicTest(const SocketAddress& initial_addr) {
- Socket* socket = ss_.CreateSocket(initial_addr.family(), SOCK_DGRAM);
+ std::unique_ptr<Socket> socket =
+ ss_.Create(initial_addr.family(), SOCK_DGRAM);
socket->Bind(initial_addr);
SocketAddress server_addr = socket->GetLocalAddress();
// Make sure VSS didn't switch families on us.
EXPECT_EQ(server_addr.family(), initial_addr.family());
- auto client1 = std::make_unique<TestClient>(
- std::make_unique<AsyncUDPSocket>(socket), &fake_clock_);
- Socket* socket2 = ss_.CreateSocket(initial_addr.family(), SOCK_DGRAM);
- auto client2 = std::make_unique<TestClient>(
- std::make_unique<AsyncUDPSocket>(socket2), &fake_clock_);
-
+ TestClient client1(
+ std::make_unique<AsyncUDPSocket>(env_, std::move(socket)),
+ &fake_clock_);
SocketAddress client2_addr;
- EXPECT_EQ(3, client2->SendTo("foo", 3, server_addr));
- EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &client2_addr));
+ {
+ std::unique_ptr<Socket> socket2 =
+ ss_.Create(initial_addr.family(), SOCK_DGRAM);
+ TestClient client2(
+ std::make_unique<AsyncUDPSocket>(env_, std::move(socket2)),
+ &fake_clock_);
- SocketAddress client1_addr;
- EXPECT_EQ(6, client1->SendTo("bizbaz", 6, client2_addr));
- EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &client1_addr));
- EXPECT_EQ(client1_addr, server_addr);
+ EXPECT_EQ(3, client2.SendTo("foo", 3, server_addr));
+ EXPECT_TRUE(client1.CheckNextPacket("foo", 3, &client2_addr));
+
+ SocketAddress client1_addr;
+ EXPECT_EQ(6, client1.SendTo("bizbaz", 6, client2_addr));
+ EXPECT_TRUE(client2.CheckNextPacket("bizbaz", 6, &client1_addr));
+ EXPECT_EQ(client1_addr, server_addr);
+ }
SocketAddress empty = EmptySocketAddressWithFamily(initial_addr.family());
for (int i = 0; i < 10; i++) {
- client2 = std::make_unique<TestClient>(
- absl::WrapUnique(AsyncUDPSocket::Create(&ss_, empty)), &fake_clock_);
+ TestClient client2(AsyncUDPSocket::Create(env_, empty, ss_),
+ &fake_clock_);
SocketAddress next_client2_addr;
- EXPECT_EQ(3, client2->SendTo("foo", 3, server_addr));
- EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &next_client2_addr));
+ EXPECT_EQ(3, client2.SendTo("foo", 3, server_addr));
+ EXPECT_TRUE(client1.CheckNextPacket("foo", 3, &next_client2_addr));
CheckPortIncrementalization(next_client2_addr, client2_addr);
// EXPECT_EQ(next_client2_addr.port(), client2_addr.port() + 1);
SocketAddress server_addr2;
- EXPECT_EQ(6, client1->SendTo("bizbaz", 6, next_client2_addr));
- EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &server_addr2));
+ EXPECT_EQ(6, client1.SendTo("bizbaz", 6, next_client2_addr));
+ EXPECT_TRUE(client2.CheckNextPacket("bizbaz", 6, &server_addr2));
EXPECT_EQ(server_addr2, server_addr);
client2_addr = next_client2_addr;
@@ -253,14 +275,14 @@ class VirtualSocketServerTest : public ::testing::Test {
// Create client
std::unique_ptr<Socket> client =
- absl::WrapUnique(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
+ ss_.Create(initial_addr.family(), SOCK_STREAM);
sink.Monitor(client.get());
EXPECT_EQ(client->GetState(), Socket::CS_CLOSED);
EXPECT_TRUE(client->GetLocalAddress().IsNil());
// Create server
std::unique_ptr<Socket> server =
- absl::WrapUnique(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
+ ss_.Create(initial_addr.family(), SOCK_STREAM);
sink.Monitor(server.get());
EXPECT_NE(0, server->Listen(5)); // Bind required
EXPECT_EQ(0, server->Bind(initial_addr));
@@ -322,12 +344,12 @@ class VirtualSocketServerTest : public ::testing::Test {
// Create client
std::unique_ptr<Socket> client =
- absl::WrapUnique(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
+ ss_.Create(initial_addr.family(), SOCK_STREAM);
sink.Monitor(client.get());
// Create server
std::unique_ptr<Socket> server =
- absl::WrapUnique(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
+ ss_.Create(initial_addr.family(), SOCK_STREAM);
sink.Monitor(server.get());
EXPECT_EQ(0, server->Bind(initial_addr));
EXPECT_EQ(server->GetLocalAddress().family(), initial_addr.family());
@@ -355,11 +377,11 @@ class VirtualSocketServerTest : public ::testing::Test {
EmptySocketAddressWithFamily(initial_addr.family());
// Create client and server
- std::unique_ptr<Socket> client(
- ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> client =
+ ss_.Create(initial_addr.family(), SOCK_STREAM);
sink.Monitor(client.get());
- std::unique_ptr<Socket> server(
- ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> server =
+ ss_.Create(initial_addr.family(), SOCK_STREAM);
sink.Monitor(server.get());
// Initiate connect
@@ -379,7 +401,7 @@ class VirtualSocketServerTest : public ::testing::Test {
EXPECT_EQ(client->GetState(), Socket::CS_CLOSED);
EXPECT_TRUE(sink.Check(client.get(), SSE_ERROR));
- server.reset(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
+ server = ss_.Create(initial_addr.family(), SOCK_STREAM);
sink.Monitor(server.get());
// Initiate connect
@@ -402,7 +424,7 @@ class VirtualSocketServerTest : public ::testing::Test {
EXPECT_TRUE(sink.Check(client.get(), SSE_ERROR));
// New server
- server.reset(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
+ server = ss_.Create(initial_addr.family(), SOCK_STREAM);
sink.Monitor(server.get());
// Initiate connect
@@ -440,14 +462,12 @@ class VirtualSocketServerTest : public ::testing::Test {
const SocketAddress kEmptyAddr;
// Create clients
- std::unique_ptr<Socket> a =
- absl::WrapUnique(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> a = ss_.Create(initial_addr.family(), SOCK_STREAM);
sink.Monitor(a.get());
a->Bind(initial_addr);
EXPECT_EQ(a->GetLocalAddress().family(), initial_addr.family());
- std::unique_ptr<Socket> b =
- absl::WrapUnique(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> b = ss_.Create(initial_addr.family(), SOCK_STREAM);
sink.Monitor(b.get());
b->Bind(initial_addr);
EXPECT_EQ(b->GetLocalAddress().family(), initial_addr.family());
@@ -490,14 +510,12 @@ class VirtualSocketServerTest : public ::testing::Test {
const SocketAddress kEmptyAddr;
// Connect two sockets
- std::unique_ptr<Socket> a =
- absl::WrapUnique(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> a = ss_.Create(initial_addr.family(), SOCK_STREAM);
sink.Monitor(a.get());
a->Bind(initial_addr);
EXPECT_EQ(a->GetLocalAddress().family(), initial_addr.family());
- std::unique_ptr<Socket> b =
- absl::WrapUnique(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> b = ss_.Create(initial_addr.family(), SOCK_STREAM);
sink.Monitor(b.get());
b->Bind(initial_addr);
EXPECT_EQ(b->GetLocalAddress().family(), initial_addr.family());
@@ -612,10 +630,8 @@ class VirtualSocketServerTest : public ::testing::Test {
const SocketAddress kEmptyAddr;
// Connect two sockets
- std::unique_ptr<Socket> a =
- absl::WrapUnique(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
- std::unique_ptr<Socket> b =
- absl::WrapUnique(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> a = ss_.Create(initial_addr.family(), SOCK_STREAM);
+ std::unique_ptr<Socket> b = ss_.Create(initial_addr.family(), SOCK_STREAM);
a->Bind(initial_addr);
EXPECT_EQ(a->GetLocalAddress().family(), initial_addr.family());
@@ -666,8 +682,10 @@ class VirtualSocketServerTest : public ::testing::Test {
// incremental port behavior could ensure the 2 Binds result in different
// address.
void BandwidthTest(const SocketAddress& initial_addr) {
- Socket* send_socket = ss_.CreateSocket(initial_addr.family(), SOCK_DGRAM);
- Socket* recv_socket = ss_.CreateSocket(initial_addr.family(), SOCK_DGRAM);
+ std::unique_ptr<Socket> send_socket =
+ ss_.Create(initial_addr.family(), SOCK_DGRAM);
+ std::unique_ptr<Socket> recv_socket =
+ ss_.Create(initial_addr.family(), SOCK_DGRAM);
ASSERT_EQ(0, send_socket->Bind(initial_addr));
ASSERT_EQ(0, recv_socket->Bind(initial_addr));
EXPECT_EQ(send_socket->GetLocalAddress().family(), initial_addr.family());
@@ -678,8 +696,8 @@ class VirtualSocketServerTest : public ::testing::Test {
ss_.set_bandwidth(bandwidth);
Thread* pthMain = Thread::Current();
- Sender sender(pthMain, send_socket, 80 * 1024);
- Receiver receiver(pthMain, recv_socket, bandwidth);
+ Sender sender(env_, pthMain, std::move(send_socket), 80 * 1024);
+ Receiver receiver(env_, pthMain, std::move(recv_socket), bandwidth);
// Allow the sender to run for 5 (simulated) seconds, then be stopped for 5
// seconds.
@@ -709,8 +727,10 @@ class VirtualSocketServerTest : public ::testing::Test {
ss_.set_delay_stddev(stddev);
ss_.UpdateDelayDistribution();
- Socket* send_socket = ss_.CreateSocket(initial_addr.family(), SOCK_DGRAM);
- Socket* recv_socket = ss_.CreateSocket(initial_addr.family(), SOCK_DGRAM);
+ std::unique_ptr<Socket> send_socket =
+ ss_.Create(initial_addr.family(), SOCK_DGRAM);
+ std::unique_ptr<Socket> recv_socket =
+ ss_.Create(initial_addr.family(), SOCK_DGRAM);
ASSERT_EQ(0, send_socket->Bind(initial_addr));
ASSERT_EQ(0, recv_socket->Bind(initial_addr));
EXPECT_EQ(send_socket->GetLocalAddress().family(), initial_addr.family());
@@ -720,8 +740,8 @@ class VirtualSocketServerTest : public ::testing::Test {
Thread* pthMain = Thread::Current();
// Avg packet size is 2K, so at 200KB/s for 10s, we should see about
// 1000 packets, which is necessary to get a good distribution.
- Sender sender(pthMain, send_socket, 100 * 2 * 1024);
- Receiver receiver(pthMain, recv_socket, 0);
+ Sender sender(env_, pthMain, std::move(send_socket), 100 * 2 * 1024);
+ Receiver receiver(env_, pthMain, std::move(recv_socket), 0);
// Simulate 10 seconds of packets being sent, then check the observed delay
// distribution.
@@ -761,7 +781,7 @@ class VirtualSocketServerTest : public ::testing::Test {
// Client gets a IPv4 address
std::unique_ptr<Socket> client =
- absl::WrapUnique(ss_.CreateSocket(client_addr.family(), SOCK_STREAM));
+ ss_.Create(client_addr.family(), SOCK_STREAM);
sink.Monitor(client.get());
EXPECT_EQ(client->GetState(), Socket::CS_CLOSED);
EXPECT_EQ(client->GetLocalAddress(), kEmptyAddr);
@@ -770,7 +790,7 @@ class VirtualSocketServerTest : public ::testing::Test {
// Server gets a non-mapped non-any IPv6 address.
// IPv4 sockets should not be able to connect to this.
std::unique_ptr<Socket> server =
- absl::WrapUnique(ss_.CreateSocket(server_addr.family(), SOCK_STREAM));
+ ss_.Create(server_addr.family(), SOCK_STREAM);
sink.Monitor(server.get());
server->Bind(server_addr);
server->Listen(5);
@@ -806,33 +826,36 @@ class VirtualSocketServerTest : public ::testing::Test {
void CrossFamilyDatagramTest(const SocketAddress& client_addr,
const SocketAddress& server_addr,
bool shouldSucceed) {
- Socket* socket = ss_.CreateSocket(AF_INET, SOCK_DGRAM);
+ std::unique_ptr<Socket> socket = ss_.Create(AF_INET, SOCK_DGRAM);
socket->Bind(server_addr);
SocketAddress bound_server_addr = socket->GetLocalAddress();
- auto client1 = std::make_unique<TestClient>(
- std::make_unique<AsyncUDPSocket>(socket), &fake_clock_);
+ TestClient client1(
+ std::make_unique<AsyncUDPSocket>(env_, std::move(socket)),
+ &fake_clock_);
- Socket* socket2 = ss_.CreateSocket(AF_INET, SOCK_DGRAM);
+ std::unique_ptr<Socket> socket2 = ss_.Create(AF_INET, SOCK_DGRAM);
socket2->Bind(client_addr);
- auto client2 = std::make_unique<TestClient>(
- std::make_unique<AsyncUDPSocket>(socket2), &fake_clock_);
+ TestClient client2(
+ std::make_unique<AsyncUDPSocket>(env_, std::move(socket2)),
+ &fake_clock_);
SocketAddress client2_addr;
if (shouldSucceed) {
- EXPECT_EQ(3, client2->SendTo("foo", 3, bound_server_addr));
- EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &client2_addr));
+ EXPECT_EQ(3, client2.SendTo("foo", 3, bound_server_addr));
+ EXPECT_TRUE(client1.CheckNextPacket("foo", 3, &client2_addr));
SocketAddress client1_addr;
- EXPECT_EQ(6, client1->SendTo("bizbaz", 6, client2_addr));
- EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &client1_addr));
+ EXPECT_EQ(6, client1.SendTo("bizbaz", 6, client2_addr));
+ EXPECT_TRUE(client2.CheckNextPacket("bizbaz", 6, &client1_addr));
EXPECT_EQ(client1_addr, bound_server_addr);
} else {
- EXPECT_EQ(-1, client2->SendTo("foo", 3, bound_server_addr));
- EXPECT_TRUE(client1->CheckNoPacket());
+ EXPECT_EQ(-1, client2.SendTo("foo", 3, bound_server_addr));
+ EXPECT_TRUE(client1.CheckNoPacket());
}
}
protected:
ScopedFakeClock fake_clock_;
+ const Environment env_ = CreateTestEnvironment();
VirtualSocketServer ss_;
AutoSocketServerThread thread_;
const SocketAddress kIPv4AnyAddress;
@@ -1014,22 +1037,24 @@ TEST_F(VirtualSocketServerTest, CanSendDatagramFromUnboundIPv6ToIPv4Any) {
}
TEST_F(VirtualSocketServerTest, SetSendingBlockedWithUdpSocket) {
- Socket* socket1 = ss_.CreateSocket(kIPv4AnyAddress.family(), SOCK_DGRAM);
+ std::unique_ptr<Socket> socket1 =
+ ss_.Create(kIPv4AnyAddress.family(), SOCK_DGRAM);
+ Socket& socket1_ref = *socket1;
std::unique_ptr<Socket> socket2 =
- absl::WrapUnique(ss_.CreateSocket(kIPv4AnyAddress.family(), SOCK_DGRAM));
+ ss_.Create(kIPv4AnyAddress.family(), SOCK_DGRAM);
socket1->Bind(kIPv4AnyAddress);
socket2->Bind(kIPv4AnyAddress);
- auto client1 = std::make_unique<TestClient>(
- std::make_unique<AsyncUDPSocket>(socket1), &fake_clock_);
+ TestClient client1(std::make_unique<AsyncUDPSocket>(env_, std::move(socket1)),
+ &fake_clock_);
ss_.SetSendingBlocked(true);
- EXPECT_EQ(-1, client1->SendTo("foo", 3, socket2->GetLocalAddress()));
- EXPECT_TRUE(socket1->IsBlocking());
- EXPECT_EQ(0, client1->ready_to_send_count());
+ EXPECT_EQ(-1, client1.SendTo("foo", 3, socket2->GetLocalAddress()));
+ EXPECT_TRUE(socket1_ref.IsBlocking());
+ EXPECT_EQ(0, client1.ready_to_send_count());
ss_.SetSendingBlocked(false);
- EXPECT_EQ(1, client1->ready_to_send_count());
- EXPECT_EQ(3, client1->SendTo("foo", 3, socket2->GetLocalAddress()));
+ EXPECT_EQ(1, client1.ready_to_send_count());
+ EXPECT_EQ(3, client1.SendTo("foo", 3, socket2->GetLocalAddress()));
}
TEST_F(VirtualSocketServerTest, SetSendingBlockedWithTcpSocket) {
@@ -1039,9 +1064,9 @@ TEST_F(VirtualSocketServerTest, SetSendingBlockedWithTcpSocket) {
StreamSink sink;
std::unique_ptr<Socket> socket1 =
- absl::WrapUnique(ss_.CreateSocket(kIPv4AnyAddress.family(), SOCK_STREAM));
+ ss_.Create(kIPv4AnyAddress.family(), SOCK_STREAM);
std::unique_ptr<Socket> socket2 =
- absl::WrapUnique(ss_.CreateSocket(kIPv4AnyAddress.family(), SOCK_STREAM));
+ ss_.Create(kIPv4AnyAddress.family(), SOCK_STREAM);
sink.Monitor(socket1.get());
sink.Monitor(socket2.get());
socket1->Bind(kIPv4AnyAddress);
