diff --git a/p2p/BUILD.gn b/p2p/BUILD.gn
index 529413c439..b8dc0b03ad 100644
--- a/p2p/BUILD.gn
+++ b/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",
diff --git a/p2p/base/basic_async_resolver_factory.cc b/p2p/base/basic_async_resolver_factory.cc
index 2769f828d7..b351121cc8 100644
--- a/p2p/base/basic_async_resolver_factory.cc
+++ b/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());
diff --git a/p2p/base/basic_async_resolver_factory.h b/p2p/base/basic_async_resolver_factory.h
index 9a0ba1ab28..147a71c68c 100644
--- a/p2p/base/basic_async_resolver_factory.h
+++ b/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.
diff --git a/pc/peer_connection.cc b/pc/peer_connection.cc
index d697f65960..b20e536ac5 100644
--- a/pc/peer_connection.cc
+++ b/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
-  // a BasicAsyncResolver.
+  // If neither is given, create a BasicAsyncDnsResolverFactory.
   // 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<BasicAsyncResolverFactory>());
+        std::make_unique<BasicAsyncDnsResolverFactory>();
   }
 
   // The PeerConnection constructor consumes some, but not all, dependencies.