diff --git a/rtc_base/physical_socket_server_unittest.cc b/rtc_base/physical_socket_server_unittest.cc
index e905375111..3da777a235 100644
--- a/rtc_base/physical_socket_server_unittest.cc
+++ b/rtc_base/physical_socket_server_unittest.cc
@@ -116,15 +116,16 @@ class PhysicalSocketTest : public SocketTest {
 
  protected:
   PhysicalSocketTest()
-      : server_(new FakePhysicalSocketServer(this)),
-        thread_(server_.get()),
+      : SocketTest(&server_),
+        server_(this),
+        thread_(&server_),
         fail_accept_(false),
         max_send_size_(-1) {}
 
   void ConnectInternalAcceptError(const IPAddress& loopback);
   void WritableAfterPartialWrite(const IPAddress& loopback);
 
-  std::unique_ptr<FakePhysicalSocketServer> server_;
+  FakePhysicalSocketServer server_;
   rtc::AutoSocketServerThread thread_;
   bool fail_accept_;
   int max_send_size_;
@@ -200,20 +201,20 @@ void PhysicalSocketTest::ConnectInternalAcceptError(const IPAddress& loopback) {
 
   // Create two clients.
   std::unique_ptr<Socket> client1(
-      server_->CreateSocket(loopback.family(), SOCK_STREAM));
+      server_.CreateSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(client1.get());
   EXPECT_EQ(Socket::CS_CLOSED, client1->GetState());
   EXPECT_TRUE(IsUnspecOrEmptyIP(client1->GetLocalAddress().ipaddr()));
 
   std::unique_ptr<Socket> client2(
-      server_->CreateSocket(loopback.family(), SOCK_STREAM));
+      server_.CreateSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(client2.get());
   EXPECT_EQ(Socket::CS_CLOSED, client2->GetState());
   EXPECT_TRUE(IsUnspecOrEmptyIP(client2->GetLocalAddress().ipaddr()));
 
   // Create server and listen.
   std::unique_ptr<Socket> server(
-      server_->CreateSocket(loopback.family(), SOCK_STREAM));
+      server_.CreateSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(server.get());
   EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
   EXPECT_EQ(0, server->Listen(5));
@@ -477,22 +478,22 @@ TEST_F(PhysicalSocketTest,
        BindFailsIfNetworkBinderFailsForNonLoopbackInterface) {
   MAYBE_SKIP_IPV4;
   FakeNetworkBinder fake_network_binder;
-  server_->set_network_binder(&fake_network_binder);
-  std::unique_ptr<Socket> socket(server_->CreateSocket(AF_INET, SOCK_DGRAM));
+  server_.set_network_binder(&fake_network_binder);
+  std::unique_ptr<Socket> socket(server_.CreateSocket(AF_INET, SOCK_DGRAM));
   fake_network_binder.set_result(NetworkBindingResult::FAILURE);
   EXPECT_EQ(-1, socket->Bind(SocketAddress("192.168.0.1", 0)));
-  server_->set_network_binder(nullptr);
+  server_.set_network_binder(nullptr);
 }
 
 // Network binder shouldn't be used if the socket is bound to the "any" IP.
 TEST_F(PhysicalSocketTest, NetworkBinderIsNotUsedForAnyIp) {
   MAYBE_SKIP_IPV4;
   FakeNetworkBinder fake_network_binder;
-  server_->set_network_binder(&fake_network_binder);
-  std::unique_ptr<Socket> socket(server_->CreateSocket(AF_INET, SOCK_DGRAM));
+  server_.set_network_binder(&fake_network_binder);
+  std::unique_ptr<Socket> socket(server_.CreateSocket(AF_INET, SOCK_DGRAM));
   EXPECT_EQ(0, socket->Bind(SocketAddress("0.0.0.0", 0)));
   EXPECT_EQ(0, fake_network_binder.num_binds());
-  server_->set_network_binder(nullptr);
+  server_.set_network_binder(nullptr);
 }
 
 // For a loopback interface, failures to bind to the interface should be
@@ -501,11 +502,11 @@ TEST_F(PhysicalSocketTest,
        BindSucceedsIfNetworkBinderFailsForLoopbackInterface) {
   MAYBE_SKIP_IPV4;
   FakeNetworkBinder fake_network_binder;
-  server_->set_network_binder(&fake_network_binder);
-  std::unique_ptr<Socket> socket(server_->CreateSocket(AF_INET, SOCK_DGRAM));
+  server_.set_network_binder(&fake_network_binder);
+  std::unique_ptr<Socket> socket(server_.CreateSocket(AF_INET, SOCK_DGRAM));
   fake_network_binder.set_result(NetworkBindingResult::FAILURE);
   EXPECT_EQ(0, socket->Bind(SocketAddress(kIPv4Loopback, 0)));
-  server_->set_network_binder(nullptr);
+  server_.set_network_binder(nullptr);
 }
 
 #endif
diff --git a/rtc_base/socket_unittest.cc b/rtc_base/socket_unittest.cc
index 720dc6ccc7..01a2bed26d 100644
--- a/rtc_base/socket_unittest.cc
+++ b/rtc_base/socket_unittest.cc
@@ -53,10 +53,6 @@ using webrtc::testing::StreamSink;
 // Data size to be used in TcpInternal tests.
 static const size_t kTcpInternalDataSize = 1024 * 1024;  // bytes
 
-void SocketTest::SetUp() {
-  ss_ = Thread::Current()->socketserver();
-}
-
 void SocketTest::TestConnectIPv4() {
   ConnectInternal(kIPv4Loopback);
 }
@@ -242,14 +238,14 @@ void SocketTest::ConnectInternal(const IPAddress& loopback) {
 
   // Create client.
   std::unique_ptr<Socket> client(
-      ss_->CreateSocket(loopback.family(), SOCK_STREAM));
+      socket_factory_->CreateSocket(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(
-      ss_->CreateSocket(loopback.family(), SOCK_STREAM));
+      socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(server.get());
   EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
   EXPECT_EQ(0, server->Listen(5));
@@ -297,12 +293,12 @@ void SocketTest::ConnectWithDnsLookupInternal(const IPAddress& loopback,
 
   // Create client.
   std::unique_ptr<Socket> client(
-      ss_->CreateSocket(loopback.family(), SOCK_STREAM));
+      socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(client.get());
 
   // Create server and listen.
   std::unique_ptr<Socket> server(
-      ss_->CreateSocket(loopback.family(), SOCK_STREAM));
+      socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(server.get());
   EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
   EXPECT_EQ(0, server->Listen(5));
@@ -345,12 +341,12 @@ void SocketTest::ConnectFailInternal(const IPAddress& loopback) {
 
   // Create client.
   std::unique_ptr<Socket> client(
-      ss_->CreateSocket(loopback.family(), SOCK_STREAM));
+      socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(client.get());
 
   // Create server, but don't listen yet.
   std::unique_ptr<Socket> server(
-      ss_->CreateSocket(loopback.family(), SOCK_STREAM));
+      socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(server.get());
   EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
 
@@ -378,12 +374,12 @@ void SocketTest::ConnectWithDnsLookupFailInternal(const IPAddress& loopback) {
 
   // Create client.
   std::unique_ptr<Socket> client(
-      ss_->CreateSocket(loopback.family(), SOCK_STREAM));
+      socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(client.get());
 
   // Create server, but don't listen yet.
   std::unique_ptr<Socket> server(
-      ss_->CreateSocket(loopback.family(), SOCK_STREAM));
+      socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(server.get());
   EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
 
@@ -415,13 +411,13 @@ void SocketTest::ConnectWithDnsLookupFailInternal(const IPAddress& loopback) {
 void SocketTest::ConnectWithClosedSocketInternal(const IPAddress& loopback) {
   // Create server and listen.
   std::unique_ptr<Socket> server(
-      ss_->CreateSocket(loopback.family(), SOCK_STREAM));
+      socket_factory_->CreateSocket(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(
-      ss_->CreateSocket(loopback.family(), SOCK_STREAM));
+      socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
   EXPECT_EQ(0, client->Close());
   EXPECT_EQ(Socket::CS_CLOSED, client->GetState());
 
@@ -434,13 +430,13 @@ void SocketTest::ConnectWhileNotClosedInternal(const IPAddress& loopback) {
   // Create server and listen.
   StreamSink sink;
   std::unique_ptr<Socket> server(
-      ss_->CreateSocket(loopback.family(), SOCK_STREAM));
+      socket_factory_->CreateSocket(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(
-      ss_->CreateSocket(loopback.family(), SOCK_STREAM));
+      socket_factory_->CreateSocket(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.
@@ -477,12 +473,12 @@ void SocketTest::ServerCloseDuringConnectInternal(const IPAddress& loopback) {
 
   // Create client.
   std::unique_ptr<Socket> client(
-      ss_->CreateSocket(loopback.family(), SOCK_STREAM));
+      socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(client.get());
 
   // Create server and listen.
   std::unique_ptr<Socket> server(
-      ss_->CreateSocket(loopback.family(), SOCK_STREAM));
+      socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(server.get());
   EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
   EXPECT_EQ(0, server->Listen(5));
@@ -506,12 +502,12 @@ void SocketTest::ClientCloseDuringConnectInternal(const IPAddress& loopback) {
 
   // Create client.
   std::unique_ptr<Socket> client(
-      ss_->CreateSocket(loopback.family(), SOCK_STREAM));
+      socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(client.get());
 
   // Create server and listen.
   std::unique_ptr<Socket> server(
-      ss_->CreateSocket(loopback.family(), SOCK_STREAM));
+      socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(server.get());
   EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
   EXPECT_EQ(0, server->Listen(5));
@@ -544,12 +540,12 @@ void SocketTest::ServerCloseInternal(const IPAddress& loopback) {
 
   // Create client.
   std::unique_ptr<Socket> client(
-      ss_->CreateSocket(loopback.family(), SOCK_STREAM));
+      socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(client.get());
 
   // Create server and listen.
   std::unique_ptr<Socket> server(
-      ss_->CreateSocket(loopback.family(), SOCK_STREAM));
+      socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(server.get());
   EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
   EXPECT_EQ(0, server->Listen(5));
@@ -618,13 +614,13 @@ void SocketTest::CloseInClosedCallbackInternal(const IPAddress& loopback) {
 
   // Create client.
   std::unique_ptr<Socket> client(
-      ss_->CreateSocket(loopback.family(), SOCK_STREAM));
+      socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(client.get());
   client->SignalCloseEvent.connect(&closer, &SocketCloser::OnClose);
 
   // Create server and listen.
   std::unique_ptr<Socket> server(
-      ss_->CreateSocket(loopback.family(), SOCK_STREAM));
+      socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(server.get());
   EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
   EXPECT_EQ(0, server->Listen(5));
@@ -677,9 +673,9 @@ class SocketDeleter : public sigslot::has_slots<> {
 // became readable at the same time.
 void SocketTest::DeleteInReadCallbackInternal(const IPAddress& loopback) {
   std::unique_ptr<Socket> socket1(
-      ss_->CreateSocket(loopback.family(), SOCK_DGRAM));
+      socket_factory_->CreateSocket(loopback.family(), SOCK_DGRAM));
   std::unique_ptr<Socket> socket2(
-      ss_->CreateSocket(loopback.family(), SOCK_DGRAM));
+      socket_factory_->CreateSocket(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()));
@@ -705,9 +701,9 @@ void SocketTest::SocketServerWaitInternal(const IPAddress& loopback) {
 
   // Create & connect server and client sockets.
   std::unique_ptr<Socket> client(
-      ss_->CreateSocket(loopback.family(), SOCK_STREAM));
+      socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
   std::unique_ptr<Socket> server(
-      ss_->CreateSocket(loopback.family(), SOCK_STREAM));
+      socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(client.get());
   sink.Monitor(server.get());
   EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
@@ -757,12 +753,12 @@ void SocketTest::TcpInternal(const IPAddress& loopback,
 
   // Create receiving client.
   std::unique_ptr<Socket> receiver(
-      ss_->CreateSocket(loopback.family(), SOCK_STREAM));
+      socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(receiver.get());
 
   // Create server and listen.
   std::unique_ptr<Socket> server(
-      ss_->CreateSocket(loopback.family(), SOCK_STREAM));
+      socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(server.get());
   EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
   EXPECT_EQ(0, server->Listen(5));
@@ -883,12 +879,12 @@ void SocketTest::SingleFlowControlCallbackInternal(const IPAddress& loopback) {
 
   // Create client.
   std::unique_ptr<Socket> client(
-      ss_->CreateSocket(loopback.family(), SOCK_STREAM));
+      socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(client.get());
 
   // Create server and listen.
   std::unique_ptr<Socket> server(
-      ss_->CreateSocket(loopback.family(), SOCK_STREAM));
+      socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
   sink.Monitor(server.get());
   EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
   EXPECT_EQ(0, server->Listen(5));
@@ -949,7 +945,7 @@ 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 = ss_->CreateSocket(loopback.family(), SOCK_DGRAM);
+  Socket* socket = socket_factory_->CreateSocket(loopback.family(), SOCK_DGRAM);
   EXPECT_EQ(Socket::CS_CLOSED, socket->GetState());
   EXPECT_EQ(0, socket->Bind(SocketAddress(loopback, 0)));
   SocketAddress addr1 = socket->GetLocalAddress();
@@ -960,10 +956,10 @@ void SocketTest::UdpInternal(const IPAddress& loopback) {
   delete socket;
 
   // Test send/receive behavior.
-  std::unique_ptr<TestClient> client1(
-      new TestClient(absl::WrapUnique(AsyncUDPSocket::Create(ss_, addr1))));
-  std::unique_ptr<TestClient> client2(
-      new TestClient(absl::WrapUnique(AsyncUDPSocket::Create(ss_, empty))));
+  auto client1 = std::make_unique<TestClient>(
+      absl::WrapUnique(AsyncUDPSocket::Create(socket_factory_, addr1)));
+  auto client2 = std::make_unique<TestClient>(
+      absl::WrapUnique(AsyncUDPSocket::Create(socket_factory_, empty)));
 
   SocketAddress addr2;
   EXPECT_EQ(3, client2->SendTo("foo", 3, addr1));
@@ -975,8 +971,8 @@ void SocketTest::UdpInternal(const IPAddress& loopback) {
   EXPECT_EQ(addr3, addr1);
   // TODO: figure out what the intent is here
   for (int i = 0; i < 10; ++i) {
-    client2.reset(
-        new TestClient(absl::WrapUnique(AsyncUDPSocket::Create(ss_, empty))));
+    client2 = std::make_unique<TestClient>(
+        absl::WrapUnique(AsyncUDPSocket::Create(socket_factory_, empty)));
 
     SocketAddress addr4;
     EXPECT_EQ(3, client2->SendTo("foo", 3, addr1));
@@ -1002,8 +998,8 @@ void SocketTest::UdpReadyToSend(const IPAddress& loopback) {
   SocketAddress test_addr(dest, 2345);
 
   // Test send
-  std::unique_ptr<TestClient> client(
-      new TestClient(absl::WrapUnique(AsyncUDPSocket::Create(ss_, empty))));
+  auto client = std::make_unique<TestClient>(
+      absl::WrapUnique(AsyncUDPSocket::Create(socket_factory_, empty)));
   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.
@@ -1040,7 +1036,7 @@ void SocketTest::UdpReadyToSend(const IPAddress& loopback) {
 
 void SocketTest::GetSetOptionsInternal(const IPAddress& loopback) {
   std::unique_ptr<Socket> socket(
-      ss_->CreateSocket(loopback.family(), SOCK_DGRAM));
+      socket_factory_->CreateSocket(loopback.family(), SOCK_DGRAM));
   socket->Bind(SocketAddress(loopback, 0));
 
   // Check SNDBUF/RCVBUF.
@@ -1083,7 +1079,7 @@ void SocketTest::GetSetOptionsInternal(const IPAddress& loopback) {
 
 void SocketTest::SocketRecvTimestamp(const IPAddress& loopback) {
   std::unique_ptr<Socket> socket(
-      ss_->CreateSocket(loopback.family(), SOCK_DGRAM));
+      socket_factory_->CreateSocket(loopback.family(), SOCK_DGRAM));
   EXPECT_EQ(0, socket->Bind(SocketAddress(loopback, 0)));
   SocketAddress address = socket->GetLocalAddress();
 
diff --git a/rtc_base/socket_unittest.h b/rtc_base/socket_unittest.h
index 91ef39c59e..772df635d7 100644
--- a/rtc_base/socket_unittest.h
+++ b/rtc_base/socket_unittest.h
@@ -21,11 +21,10 @@ namespace rtc {
 // socketserver, and call the SocketTest test methods.
 class SocketTest : public ::testing::Test {
  protected:
-  SocketTest()
+  explicit SocketTest(rtc::SocketFactory* socket_factory)
       : kIPv4Loopback(INADDR_LOOPBACK),
         kIPv6Loopback(in6addr_loopback),
-        ss_(nullptr) {}
-  void SetUp() override;
+        socket_factory_(socket_factory) {}
   void TestConnectIPv4();
   void TestConnectIPv6();
   void TestConnectWithDnsLookupIPv4();
@@ -93,7 +92,7 @@ class SocketTest : public ::testing::Test {
   void GetSetOptionsInternal(const IPAddress& loopback);
   void SocketRecvTimestamp(const IPAddress& loopback);
 
-  SocketServer* ss_;
+  SocketFactory* socket_factory_;
 };
 
 // For unbound sockets, GetLocalAddress / GetRemoteAddress return AF_UNSPEC
diff --git a/rtc_base/win32_socket_server_unittest.cc b/rtc_base/win32_socket_server_unittest.cc
index e5454605f4..f75f51312c 100644
--- a/rtc_base/win32_socket_server_unittest.cc
+++ b/rtc_base/win32_socket_server_unittest.cc
@@ -38,7 +38,7 @@ TEST(Win32SocketServerTest, TestPump) {
 // Test that Win32Socket passes all the generic Socket tests.
 class Win32SocketTest : public SocketTest {
  protected:
-  Win32SocketTest() : thread_(&server_) {}
+  Win32SocketTest() : SocketTest(&server_), thread_(&server_) {}
   Win32SocketServer server_;
   rtc::AutoSocketServerThread thread_;
 };