Delete BasicPacketSocketFactory default constructor

Update users to pass in the appropriate rtc::SocketFactory, instead of
relying on BasicPacketSocketFactory using the rtc::SocketServer
associated with the thread the constructor runs on.

Bug: webrtc:13145
Change-Id: I74eca1ce2c5885c14372a797f6374825b1bc1873
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/231134
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Commit-Queue: Niels Moller <nisse@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#34914}

examples/stunprober/main.cc

@@ -21,6 +21,7 @@
 #include "rtc_base/helpers.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/network.h"
+#include "rtc_base/physical_socket_server.h"
 #include "rtc_base/socket_address.h"
 #include "rtc_base/ssl_adapter.h"
 #include "rtc_base/thread.h"
@@ -122,23 +123,23 @@ int main(int argc, char* argv[]) {
 
   rtc::InitializeSSL();
   rtc::InitRandom(rtc::Time32());
-  rtc::Thread* thread = rtc::ThreadManager::Instance()->WrapCurrentThread();
-  std::unique_ptr<rtc::BasicPacketSocketFactory> socket_factory(
-      new rtc::BasicPacketSocketFactory());
+  rtc::PhysicalSocketServer socket_server;
+  rtc::AutoSocketServerThread thread(&socket_server);
+  auto socket_factory =
+      std::make_unique<rtc::BasicPacketSocketFactory>(&socket_server);
   std::unique_ptr<rtc::BasicNetworkManager> network_manager(
       new rtc::BasicNetworkManager());
   rtc::NetworkManager::NetworkList networks;
   network_manager->GetNetworks(&networks);
-  StunProber* prober =
-      new StunProber(socket_factory.get(), rtc::Thread::Current(), networks);
-  auto finish_callback = [thread](StunProber* prober, int result) {
-    StopTrial(thread, prober, result);
+  auto prober = std::make_unique<StunProber>(socket_factory.get(),
+                                             rtc::Thread::Current(), networks);
+  auto finish_callback = [&thread](StunProber* prober, int result) {
+    StopTrial(&thread, prober, result);
   };
   prober->Start(server_addresses, absl::GetFlag(FLAGS_shared_socket),
                 absl::GetFlag(FLAGS_interval),
                 absl::GetFlag(FLAGS_pings_per_ip), absl::GetFlag(FLAGS_timeout),
                 AsyncCallback(finish_callback));
-  thread->Run();
-  delete prober;
+  thread.Run();
   return 0;
 }

examples/turnserver/turnserver_main.cc

@@ -20,8 +20,8 @@
 #include "p2p/base/turn_server.h"
 #include "rtc_base/async_udp_socket.h"
 #include "rtc_base/ip_address.h"
+#include "rtc_base/physical_socket_server.h"
 #include "rtc_base/socket_address.h"
-#include "rtc_base/socket_server.h"
 #include "rtc_base/thread.h"
 
 namespace {
@@ -69,16 +69,17 @@ int main(int argc, char* argv[]) {
     return 1;
   }
 
-  rtc::Thread* main = rtc::Thread::Current();
+  rtc::PhysicalSocketServer socket_server;
+  rtc::AutoSocketServerThread main(&socket_server);
   rtc::AsyncUDPSocket* int_socket =
-      rtc::AsyncUDPSocket::Create(main->socketserver(), int_addr);
+      rtc::AsyncUDPSocket::Create(&socket_server, int_addr);
   if (!int_socket) {
     std::cerr << "Failed to create a UDP socket bound at" << int_addr.ToString()
               << std::endl;
     return 1;
   }
 
-  cricket::TurnServer server(main);
+  cricket::TurnServer server(&main);
   std::fstream auth_file(argv[4], std::fstream::in);
 
   TurnFileAuth auth(auth_file.is_open()
@@ -88,11 +89,12 @@ int main(int argc, char* argv[]) {
   server.set_software(kSoftware);
   server.set_auth_hook(&auth);
   server.AddInternalSocket(int_socket, cricket::PROTO_UDP);
-  server.SetExternalSocketFactory(new rtc::BasicPacketSocketFactory(),
-                                  rtc::SocketAddress(ext_addr, 0));
+  server.SetExternalSocketFactory(
+      new rtc::BasicPacketSocketFactory(&socket_server),
+      rtc::SocketAddress(ext_addr, 0));
 
   std::cout << "Listening internally at " << int_addr.ToString() << std::endl;
 
-  main->Run();
+  main.Run();
   return 0;
 }

p2p/base/basic_packet_socket_factory.cc

@@ -29,9 +29,6 @@
 
 namespace rtc {
 
-BasicPacketSocketFactory::BasicPacketSocketFactory()
-    : thread_(Thread::Current()), socket_factory_(NULL) {}
-
 BasicPacketSocketFactory::BasicPacketSocketFactory(Thread* thread)
     : thread_(thread), socket_factory_(NULL) {}
 

p2p/base/basic_packet_socket_factory.h

@@ -23,7 +23,6 @@ class Thread;
 
 class BasicPacketSocketFactory : public PacketSocketFactory {
  public:
-  BasicPacketSocketFactory();
   explicit BasicPacketSocketFactory(Thread* thread);
   explicit BasicPacketSocketFactory(SocketFactory* socket_factory);
   ~BasicPacketSocketFactory() override;

p2p/base/turn_server_unittest.cc

@@ -21,7 +21,7 @@ namespace cricket {
 
 class TurnServerConnectionTest : public ::testing::Test {
  public:
-  TurnServerConnectionTest() : thread_(&vss_) {}
+  TurnServerConnectionTest() : thread_(&vss_), socket_factory_(&vss_) {}
 
   void ExpectEqual(const TurnServerConnection& a,
                    const TurnServerConnection& b) {
@@ -41,8 +41,6 @@ class TurnServerConnectionTest : public ::testing::Test {
  protected:
   rtc::VirtualSocketServer vss_;
   rtc::AutoSocketServerThread thread_;
-  // Since this is constructed after `thread_`, it will pick up `threads_`'s
-  // socket server.
   rtc::BasicPacketSocketFactory socket_factory_;
 };
 

p2p/client/basic_port_allocator_unittest.cc

@@ -470,7 +470,8 @@ class BasicPortAllocatorTestBase : public ::testing::Test,
           rtc::NAT_OPEN_CONE, vss_.get(), kNatUdpAddr, kNatTcpAddr, vss_.get(),
           rtc::SocketAddress(kNatUdpAddr.ipaddr(), 0)));
     } else {
-      nat_socket_factory_.reset(new rtc::BasicPacketSocketFactory());
+      nat_socket_factory_ =
+          std::make_unique<rtc::BasicPacketSocketFactory>(fss_.get());
     }
 
     ServerAddresses stun_servers;

p2p/stunprober/stun_prober_unittest.cc

@@ -80,8 +80,8 @@ class StunProberTest : public ::testing::Test {
     rtc::NetworkManager::NetworkList networks;
     networks.push_back(&ipv4_network1);
 
-    std::unique_ptr<rtc::BasicPacketSocketFactory> socket_factory(
-        new rtc::BasicPacketSocketFactory());
+    auto socket_factory =
+        std::make_unique<rtc::BasicPacketSocketFactory>(ss_.get());
 
     // Set up the expected results for verification.
     std::set<std::string> srflx_addresses;