Prepare to deprecate AsyncResolver class

This removes internal usage of AsyncResolver, including from
PhysicalSocketServer.
PhysicalSocketServer was also run through IWYU.

Bug: webrtc:12598
Change-Id: I18aa6fb60e4a40face4afa0446a161379470680d
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/322721
Commit-Queue: Harald Alvestrand <hta@webrtc.org>
Reviewed-by: Tomas Gunnarsson <tommi@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#40900}

examples/BUILD.gn

@@ -686,6 +686,7 @@ if (is_linux || is_chromeos || is_win) {
     ]
 
     deps = [
+      "../api:async_dns_resolver",
       "../api:audio_options_api",
       "../api:create_peerconnection_factory",
       "../api:libjingle_peerconnection_api",
@@ -703,6 +704,7 @@ if (is_linux || is_chromeos || is_win) {
       "../media:rtc_media_base",
       "../p2p:rtc_p2p",
       "../pc:video_track_source",
+      "../rtc_base:async_dns_resolver",
       "../rtc_base:checks",
       "../rtc_base:logging",
       "../rtc_base:macromagic",

examples/peerconnection/client/peer_connection_client.cc

@@ -12,6 +12,7 @@
 
 #include "api/units/time_delta.h"
 #include "examples/peerconnection/client/defaults.h"
+#include "rtc_base/async_dns_resolver.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/net_helpers.h"
@@ -32,7 +33,7 @@ rtc::Socket* CreateClientSocket(int family) {
 }  // namespace
 
 PeerConnectionClient::PeerConnectionClient()
-    : callback_(NULL), resolver_(NULL), state_(NOT_CONNECTED), my_id_(-1) {}
+    : callback_(NULL), resolver_(nullptr), state_(NOT_CONNECTED), my_id_(-1) {}
 
 PeerConnectionClient::~PeerConnectionClient() = default;
 
@@ -95,26 +96,32 @@ void PeerConnectionClient::Connect(const std::string& server,
   client_name_ = client_name;
 
   if (server_address_.IsUnresolvedIP()) {
+    RTC_DCHECK_NE(state_, RESOLVING);
+    RTC_DCHECK(!resolver_);
     state_ = RESOLVING;
-    resolver_ = new rtc::AsyncResolver();
+    resolver_ = std::make_unique<webrtc::AsyncDnsResolver>();
-    resolver_->SignalDone.connect(this, &PeerConnectionClient::OnResolveResult);
+    resolver_->Start(server_address_,
-    resolver_->Start(server_address_);
+                     [this] { OnResolveResult(resolver_->result()); });
   } else {
     DoConnect();
   }
 }
 
 void PeerConnectionClient::OnResolveResult(
-    rtc::AsyncResolverInterface* resolver) {
+    const webrtc::AsyncDnsResolverResult& result) {
-  if (resolver_->GetError() != 0) {
+  if (result.GetError() != 0) {
     callback_->OnServerConnectionFailure();
-    resolver_->Destroy(false);
+    resolver_.reset();
-    resolver_ = NULL;
     state_ = NOT_CONNECTED;
-  } else {
+    return;
-    server_address_ = resolver_->address();
-    DoConnect();
   }
+  if (!result.GetResolvedAddress(AF_INET, &server_address_)) {
+    callback_->OnServerConnectionFailure();
+    resolver_.reset();
+    state_ = NOT_CONNECTED;
+    return;
+  }
+  DoConnect();
 }
 
 void PeerConnectionClient::DoConnect() {
@@ -196,10 +203,7 @@ void PeerConnectionClient::Close() {
   hanging_get_->Close();
   onconnect_data_.clear();
   peers_.clear();
-  if (resolver_ != NULL) {
+  resolver_.reset();
-    resolver_->Destroy(false);
-    resolver_ = NULL;
-  }
   my_id_ = -1;
   state_ = NOT_CONNECTED;
 }

examples/peerconnection/client/peer_connection_client.h

@@ -15,6 +15,7 @@
 #include <memory>
 #include <string>
 
+#include "api/async_dns_resolver.h"
 #include "api/task_queue/pending_task_safety_flag.h"
 #include "rtc_base/net_helpers.h"
 #include "rtc_base/physical_socket_server.h"
@@ -109,11 +110,11 @@ class PeerConnectionClient : public sigslot::has_slots<> {
 
   void OnClose(rtc::Socket* socket, int err);
 
-  void OnResolveResult(rtc::AsyncResolverInterface* resolver);
+  void OnResolveResult(const webrtc::AsyncDnsResolverResult& result);
 
   PeerConnectionClientObserver* callback_;
   rtc::SocketAddress server_address_;
-  rtc::AsyncResolver* resolver_;
+  std::unique_ptr<webrtc::AsyncDnsResolverInterface> resolver_;
   std::unique_ptr<rtc::Socket> control_socket_;
   std::unique_ptr<rtc::Socket> hanging_get_;
   std::string onconnect_data_;

p2p/base/basic_async_resolver_factory.cc

@@ -22,9 +22,12 @@
 
 namespace webrtc {
 
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
 rtc::AsyncResolverInterface* BasicAsyncResolverFactory::Create() {
   return new rtc::AsyncResolver();
 }
+#pragma clang diagnostic pop
 
 std::unique_ptr<webrtc::AsyncDnsResolverInterface>
 BasicAsyncDnsResolverFactory::Create() {

p2p/base/basic_packet_socket_factory.cc

@@ -184,11 +184,14 @@ AsyncResolverInterface* BasicPacketSocketFactory::CreateAsyncResolver() {
   return new AsyncResolver();
 }
 
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
 std::unique_ptr<webrtc::AsyncDnsResolverInterface>
 BasicPacketSocketFactory::CreateAsyncDnsResolver() {
   return std::make_unique<webrtc::WrappingAsyncDnsResolver>(
       new AsyncResolver());
 }
+#pragma clang diagnostic pop
 
 int BasicPacketSocketFactory::BindSocket(Socket* socket,
                                          const SocketAddress& local_address,

rtc_base/BUILD.gn

@@ -1046,6 +1046,7 @@ rtc_library("threading") {
     "//third_party/abseil-cpp/absl/strings",
   ]
   deps = [
+    ":async_dns_resolver",
     ":async_resolver_interface",
     ":byte_order",
     ":checks",
@@ -1061,9 +1062,11 @@ rtc_library("threading") {
     ":refcount",
     ":rtc_event",
     ":rtc_task_queue",
+    ":socket",
     ":socket_address",
     ":socket_server",
     ":timeutils",
+    "../api:async_dns_resolver",
     "../api:function_view",
     "../api:location",
     "../api:refcountedbase",

rtc_base/physical_socket_server.cc

@@ -10,6 +10,7 @@
 #include "rtc_base/physical_socket_server.h"
 
 #include <cstdint>
+#include <utility>
 
 #if defined(_MSC_VER) && _MSC_VER < 1300
 #pragma warning(disable : 4786)
@@ -21,7 +22,6 @@
 
 #if defined(WEBRTC_POSIX)
 #include <fcntl.h>
-#include <string.h>
 #if defined(WEBRTC_USE_EPOLL)
 // "poll" will be used to wait for the signal dispatcher.
 #include <poll.h>
@@ -30,7 +30,6 @@
 #endif
 #include <sys/ioctl.h>
 #include <sys/select.h>
-#include <sys/time.h>
 #include <unistd.h>
 #endif
 
@@ -38,20 +37,18 @@
 #include <windows.h>
 #include <winsock2.h>
 #include <ws2tcpip.h>
+
 #undef SetPort
 #endif
 
 #include <errno.h>
 
-#include <algorithm>
+#include "rtc_base/async_dns_resolver.h"
-#include <map>
-
-#include "rtc_base/arraysize.h"
-#include "rtc_base/byte_order.h"
 #include "rtc_base/checks.h"
+#include "rtc_base/event.h"
+#include "rtc_base/ip_address.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/network_monitor.h"
-#include "rtc_base/null_socket_server.h"
 #include "rtc_base/synchronization/mutex.h"
 #include "rtc_base/time_utils.h"
 #include "system_wrappers/include/field_trial.h"
@@ -70,6 +67,7 @@
 
 #if defined(WEBRTC_POSIX)
 #include <netinet/tcp.h>  // for TCP_NODELAY
+
 #define IP_MTU 14  // Until this is integrated from linux/in.h to netinet/in.h
 typedef void* SockOptArg;
 
@@ -252,9 +250,8 @@ int PhysicalSocket::Connect(const SocketAddress& addr) {
   }
   if (addr.IsUnresolvedIP()) {
     RTC_LOG(LS_VERBOSE) << "Resolving addr in PhysicalSocket::Connect";
-    resolver_ = new AsyncResolver();
+    resolver_ = std::make_unique<webrtc::AsyncDnsResolver>();
-    resolver_->SignalDone.connect(this, &PhysicalSocket::OnResolveResult);
+    resolver_->Start(addr, [this] { OnResolveResult(resolver_->result()); });
-    resolver_->Start(addr);
     state_ = CS_CONNECTING;
     return 0;
   }
@@ -564,8 +561,7 @@ int PhysicalSocket::Close() {
   state_ = CS_CLOSED;
   SetEnabledEvents(0);
   if (resolver_) {
-    resolver_->Destroy(false);
+    resolver_.reset();
-    resolver_ = nullptr;
   }
   return err;
 }
@@ -589,14 +585,16 @@ int PhysicalSocket::DoSendTo(SOCKET socket,
   return ::sendto(socket, buf, len, flags, dest_addr, addrlen);
 }
 
-void PhysicalSocket::OnResolveResult(AsyncResolverInterface* resolver) {
+void PhysicalSocket::OnResolveResult(
-  if (resolver != resolver_) {
+    const webrtc::AsyncDnsResolverResult& result) {
-    return;
+  int error = result.GetError();
-  }
-
-  int error = resolver_->GetError();
   if (error == 0) {
-    error = DoConnect(resolver_->address());
+    SocketAddress address;
+    if (result.GetResolvedAddress(AF_INET, &address)) {
+      error = DoConnect(address);
+    } else {
+      Close();
+    }
   } else {
     Close();
   }

rtc_base/physical_socket_server.h

@@ -11,17 +11,23 @@
 #ifndef RTC_BASE_PHYSICAL_SOCKET_SERVER_H_
 #define RTC_BASE_PHYSICAL_SOCKET_SERVER_H_
 
+#include "api/async_dns_resolver.h"
 #include "api/units/time_delta.h"
+#include "rtc_base/socket.h"
+#include "rtc_base/socket_address.h"
+#include "rtc_base/third_party/sigslot/sigslot.h"
 
 #if defined(WEBRTC_POSIX)
 #if defined(WEBRTC_LINUX)
 // On Linux, use epoll.
 #include <sys/epoll.h>
+
 #define WEBRTC_USE_EPOLL 1
 #elif defined(WEBRTC_FUCHSIA)
 // Fuchsia implements select and poll but not epoll, and testing shows that poll
 // is faster than select.
 #include <poll.h>
+
 #define WEBRTC_USE_POLL 1
 #else
 // On other POSIX systems, use select by default.
@@ -29,7 +35,9 @@
 #endif  // WEBRTC_POSIX
 
 #include <array>
+#include <cstdint>
 #include <memory>
+#include <string>
 #include <unordered_map>
 #include <vector>
 
@@ -218,7 +226,7 @@ class PhysicalSocket : public Socket, public sigslot::has_slots<> {
                        SocketAddress* out_addr,
                        int64_t* timestamp);
 
-  void OnResolveResult(AsyncResolverInterface* resolver);
+  void OnResolveResult(const webrtc::AsyncDnsResolverResult& resolver);
 
   void UpdateLastError();
   void MaybeRemapSendError();
@@ -237,7 +245,7 @@ class PhysicalSocket : public Socket, public sigslot::has_slots<> {
   mutable webrtc::Mutex mutex_;
   int error_ RTC_GUARDED_BY(mutex_);
   ConnState state_;
-  AsyncResolver* resolver_;
+  std::unique_ptr<webrtc::AsyncDnsResolverInterface> resolver_;
 
 #if !defined(NDEBUG)
   std::string dbg_addr_;