Use the AsyncDnsResolver in PeerConnection defaults

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

p2p/BUILD.gn

@@ -115,6 +115,7 @@ rtc_library("rtc_p2p") {
     "../api/units:time_delta",
     "../api/units:timestamp",
     "../logging:ice_log",
+    "../rtc_base:async_dns_resolver",
     "../rtc_base:async_packet_socket",
     "../rtc_base:async_resolver_interface",
     "../rtc_base:async_tcp_socket",

p2p/base/basic_async_resolver_factory.cc

@@ -16,6 +16,7 @@
 #include "absl/memory/memory.h"
 #include "api/async_dns_resolver.h"
 #include "api/wrapping_async_dns_resolver.h"
+#include "rtc_base/async_dns_resolver.h"
 #include "rtc_base/async_resolver.h"
 #include "rtc_base/logging.h"
 
@@ -25,6 +26,28 @@ rtc::AsyncResolverInterface* BasicAsyncResolverFactory::Create() {
   return new rtc::AsyncResolver();
 }
 
+std::unique_ptr<webrtc::AsyncDnsResolverInterface>
+BasicAsyncDnsResolverFactory::Create() {
+  return std::make_unique<AsyncDnsResolver>();
+}
+
+std::unique_ptr<webrtc::AsyncDnsResolverInterface>
+BasicAsyncDnsResolverFactory::CreateAndResolve(const rtc::SocketAddress& addr,
+                                               std::function<void()> callback) {
+  std::unique_ptr<webrtc::AsyncDnsResolverInterface> resolver = Create();
+  resolver->Start(addr, std::move(callback));
+  return resolver;
+}
+
+std::unique_ptr<webrtc::AsyncDnsResolverInterface>
+BasicAsyncDnsResolverFactory::CreateAndResolve(const rtc::SocketAddress& addr,
+                                               int family,
+                                               std::function<void()> callback) {
+  std::unique_ptr<webrtc::AsyncDnsResolverInterface> resolver = Create();
+  resolver->Start(addr, family, std::move(callback));
+  return resolver;
+}
+
 std::unique_ptr<webrtc::AsyncDnsResolverInterface>
 WrappingAsyncDnsResolverFactory::Create() {
   return std::make_unique<WrappingAsyncDnsResolver>(wrapped_factory_->Create());

p2p/base/basic_async_resolver_factory.h

@@ -26,6 +26,24 @@ class BasicAsyncResolverFactory final : public AsyncResolverFactory {
   rtc::AsyncResolverInterface* Create() override;
 };
 
+// A factory that vends AsyncDnsResolver instances.
+class BasicAsyncDnsResolverFactory final
+    : public AsyncDnsResolverFactoryInterface {
+ public:
+  BasicAsyncDnsResolverFactory() = default;
+
+  std::unique_ptr<webrtc::AsyncDnsResolverInterface> CreateAndResolve(
+      const rtc::SocketAddress& addr,
+      std::function<void()> callback) override;
+
+  std::unique_ptr<webrtc::AsyncDnsResolverInterface> CreateAndResolve(
+      const rtc::SocketAddress& addr,
+      int family,
+      std::function<void()> callback) override;
+
+  std::unique_ptr<webrtc::AsyncDnsResolverInterface> Create() override;
+};
+
 // This class wraps a factory using the older webrtc::AsyncResolverFactory API,
 // and produces webrtc::AsyncDnsResolver objects that contain an
 // rtc::AsyncResolver object.

pc/peer_connection.cc

@@ -461,8 +461,7 @@ RTCErrorOr<rtc::scoped_refptr<PeerConnection>> PeerConnection::Create(
 
   // Interim code: If an AsyncResolverFactory is given, but not an
   // AsyncDnsResolverFactory, wrap it in a WrappingAsyncDnsResolverFactory
-  // If neither is given, create a WrappingAsyncDnsResolverFactory wrapping
+  // If neither is given, create a BasicAsyncDnsResolverFactory.
-  // a BasicAsyncResolver.
   // TODO(bugs.webrtc.org/12598): Remove code once all callers pass a
   // AsyncDnsResolverFactory.
   if (dependencies.async_dns_resolver_factory &&
@@ -478,8 +477,7 @@ RTCErrorOr<rtc::scoped_refptr<PeerConnection>> PeerConnection::Create(
             std::move(dependencies.async_resolver_factory));
   } else {
     dependencies.async_dns_resolver_factory =
-        std::make_unique<WrappingAsyncDnsResolverFactory>(
+        std::make_unique<BasicAsyncDnsResolverFactory>();
-            std::make_unique<BasicAsyncResolverFactory>());
   }
 
   // The PeerConnection constructor consumes some, but not all, dependencies.