Revert "Use the new DNS resolver API in PeerConnection"

This reverts commit acf8ccb3c9f001b0ed749aca52b2d436d66f9586.

Reason for revert: Speculative revert for https://ci.chromium.org/ui/p/chromium/builders/try/win10_chromium_x64_rel_ng/b8851745102358680592/overview.

Original change's description:
> Use the new DNS resolver API in PeerConnection
>
> Bug: webrtc:12598
> Change-Id: I5a14058e7f28c993ed927749df7357c715ba83fb
> Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/212961
> Reviewed-by: Niels Moller <nisse@webrtc.org>
> Commit-Queue: Harald Alvestrand <hta@webrtc.org>
> Cr-Commit-Position: refs/heads/master@{#33561}

# Not skipping CQ checks because original CL landed > 1 day ago.

TBR=hta@webrtc.org

Bug: webrtc:12598
Change-Id: Idc9853cb569849c49052f9cbd865614710fff979
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/213188
Reviewed-by: Mirko Bonadei <mbonadei@webrtc.org>
Commit-Queue: Mirko Bonadei <mbonadei@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#33591}

api/BUILD.gn

@@ -160,7 +160,6 @@ rtc_library("libjingle_peerconnection_api") {
   ]
   deps = [
     ":array_view",
-    ":async_dns_resolver",
     ":audio_options_api",
     ":callfactory_api",
     ":fec_controller_api",
@@ -250,11 +249,11 @@ rtc_library("rtc_error") {
 rtc_source_set("packet_socket_factory") {
   visibility = [ "*" ]
   sources = [
+    "async_dns_resolver.h",
     "async_resolver_factory.h",
     "packet_socket_factory.h",
   ]
   deps = [
-    ":async_dns_resolver",
     "../rtc_base:async_resolver_interface",
     "../rtc_base:rtc_base",
     "../rtc_base:socket_address",
@@ -262,14 +261,6 @@ rtc_source_set("packet_socket_factory") {
   ]
 }
 
-rtc_source_set("async_dns_resolver") {
-  sources = [ "async_dns_resolver.h" ]
-  deps = [
-    "../rtc_base:socket_address",
-    "../rtc_base/system:rtc_export",
-  ]
-}
-
 rtc_source_set("scoped_refptr") {
   visibility = [ "*" ]
   sources = [ "scoped_refptr.h" ]
@@ -949,15 +940,6 @@ if (rtc_include_tests) {
     ]
   }
 
-  rtc_source_set("mock_async_dns_resolver") {
-    testonly = true
-    sources = [ "test/mock_async_dns_resolver.h" ]
-    deps = [
-      ":async_dns_resolver",
-      "../test:test_support",
-    ]
-  }
-
   rtc_source_set("mock_rtp") {
     visibility = [ "*" ]
     testonly = true
@@ -1110,7 +1092,6 @@ if (rtc_include_tests) {
       ":dummy_peer_connection",
       ":fake_frame_decryptor",
       ":fake_frame_encryptor",
-      ":mock_async_dns_resolver",
       ":mock_audio_mixer",
       ":mock_data_channel",
       ":mock_frame_decryptor",

api/async_dns_resolver.h

@@ -11,7 +11,6 @@
 #ifndef API_ASYNC_DNS_RESOLVER_H_
 #define API_ASYNC_DNS_RESOLVER_H_
 
-#include <functional>
 #include <memory>
 
 #include "rtc_base/socket_address.h"

api/ice_transport_factory.cc

@@ -58,18 +58,10 @@ rtc::scoped_refptr<IceTransportInterface> CreateIceTransport(
 
 rtc::scoped_refptr<IceTransportInterface> CreateIceTransport(
     IceTransportInit init) {
-  if (init.async_resolver_factory()) {
-    // Backwards compatibility mode
   return new rtc::RefCountedObject<IceTransportWithTransportChannel>(
       std::make_unique<cricket::P2PTransportChannel>(
           "", cricket::ICE_CANDIDATE_COMPONENT_RTP, init.port_allocator(),
           init.async_resolver_factory(), init.event_log()));
-  } else {
-    return new rtc::RefCountedObject<IceTransportWithTransportChannel>(
-        cricket::P2PTransportChannel::Create(
-            "", cricket::ICE_CANDIDATE_COMPONENT_RTP, init.port_allocator(),
-            init.async_dns_resolver_factory(), init.event_log()));
-  }
 }
 
 }  // namespace webrtc

api/ice_transport_interface.h

@@ -13,7 +13,6 @@
 
 #include <string>
 
-#include "api/async_dns_resolver.h"
 #include "api/async_resolver_factory.h"
 #include "api/rtc_error.h"
 #include "api/rtc_event_log/rtc_event_log.h"
@@ -53,21 +52,11 @@ struct IceTransportInit final {
     port_allocator_ = port_allocator;
   }
 
-  AsyncDnsResolverFactoryInterface* async_dns_resolver_factory() {
-    return async_dns_resolver_factory_;
-  }
-  void set_async_dns_resolver_factory(
-      AsyncDnsResolverFactoryInterface* async_dns_resolver_factory) {
-    RTC_DCHECK(!async_resolver_factory_);
-    async_dns_resolver_factory_ = async_dns_resolver_factory;
-  }
   AsyncResolverFactory* async_resolver_factory() {
     return async_resolver_factory_;
   }
-  ABSL_DEPRECATED("bugs.webrtc.org/12598")
   void set_async_resolver_factory(
       AsyncResolverFactory* async_resolver_factory) {
-    RTC_DCHECK(!async_dns_resolver_factory_);
     async_resolver_factory_ = async_resolver_factory;
   }
 
@@ -76,8 +65,6 @@ struct IceTransportInit final {
 
  private:
   cricket::PortAllocator* port_allocator_ = nullptr;
-  AsyncDnsResolverFactoryInterface* async_dns_resolver_factory_ = nullptr;
-  // For backwards compatibility. Only one resolver factory can be set.
   AsyncResolverFactory* async_resolver_factory_ = nullptr;
   RtcEventLog* event_log_ = nullptr;
 };

api/peer_connection_interface.h

@@ -74,7 +74,6 @@
 #include <vector>
 
 #include "api/adaptation/resource.h"
-#include "api/async_dns_resolver.h"
 #include "api/async_resolver_factory.h"
 #include "api/audio/audio_mixer.h"
 #include "api/audio_codecs/audio_decoder_factory.h"
@@ -1323,10 +1322,6 @@ struct RTC_EXPORT PeerConnectionDependencies final {
   // packet_socket_factory, not both.
   std::unique_ptr<cricket::PortAllocator> allocator;
   std::unique_ptr<rtc::PacketSocketFactory> packet_socket_factory;
-  // Factory for creating resolvers that look up hostnames in DNS
-  std::unique_ptr<webrtc::AsyncDnsResolverFactoryInterface>
-      async_dns_resolver_factory;
-  // Deprecated - use async_dns_resolver_factory
   std::unique_ptr<webrtc::AsyncResolverFactory> async_resolver_factory;
   std::unique_ptr<webrtc::IceTransportFactory> ice_transport_factory;
   std::unique_ptr<rtc::RTCCertificateGeneratorInterface> cert_generator;

api/test/compile_all_headers.cc

@@ -30,7 +30,6 @@
 #include "api/test/dummy_peer_connection.h"
 #include "api/test/fake_frame_decryptor.h"
 #include "api/test/fake_frame_encryptor.h"
-#include "api/test/mock_async_dns_resolver.h"
 #include "api/test/mock_audio_mixer.h"
 #include "api/test/mock_data_channel.h"
 #include "api/test/mock_frame_decryptor.h"

api/test/mock_async_dns_resolver.h

@@ -1,54 +0,0 @@
-/*
- *  Copyright 2021 The WebRTC Project Authors. All rights reserved.
- *
- *  Use of this source code is governed by a BSD-style license
- *  that can be found in the LICENSE file in the root of the source
- *  tree. An additional intellectual property rights grant can be found
- *  in the file PATENTS.  All contributing project authors may
- *  be found in the AUTHORS file in the root of the source tree.
- */
-
-#ifndef API_TEST_MOCK_ASYNC_DNS_RESOLVER_H_
-#define API_TEST_MOCK_ASYNC_DNS_RESOLVER_H_
-
-#include <functional>
-#include <memory>
-
-#include "api/async_dns_resolver.h"
-#include "test/gmock.h"
-
-namespace webrtc {
-
-class MockAsyncDnsResolverResult : public AsyncDnsResolverResult {
- public:
-  MOCK_METHOD(bool,
-              GetResolvedAddress,
-              (int, rtc::SocketAddress*),
-              (const override));
-  MOCK_METHOD(int, GetError, (), (const override));
-};
-
-class MockAsyncDnsResolver : public AsyncDnsResolverInterface {
- public:
-  MOCK_METHOD(void,
-              Start,
-              (const rtc::SocketAddress&, std::function<void()>),
-              (override));
-  MOCK_METHOD(AsyncDnsResolverResult&, result, (), (const override));
-};
-
-class MockAsyncDnsResolverFactory : public AsyncDnsResolverFactoryInterface {
- public:
-  MOCK_METHOD(std::unique_ptr<webrtc::AsyncDnsResolverInterface>,
-              CreateAndResolve,
-              (const rtc::SocketAddress&, std::function<void()>),
-              (override));
-  MOCK_METHOD(std::unique_ptr<webrtc::AsyncDnsResolverInterface>,
-              Create,
-              (),
-              (override));
-};
-
-}  // namespace webrtc
-
-#endif  // API_TEST_MOCK_ASYNC_DNS_RESOLVER_H_

p2p/BUILD.gn

@@ -86,8 +86,6 @@ rtc_library("rtc_p2p") {
   ]
 
   deps = [
-    "../api:array_view",
-    "../api:async_dns_resolver",
     "../api:libjingle_peerconnection_api",
     "../api:packet_socket_factory",
     "../api:rtc_error",
@@ -95,7 +93,6 @@ rtc_library("rtc_p2p") {
     "../api:sequence_checker",
     "../api/crypto:options",
     "../api/rtc_event_log",
-    "../api/task_queue",
     "../api/transport:enums",
     "../api/transport:stun_types",
     "../logging:ice_log",
@@ -238,7 +235,6 @@ if (rtc_include_tests) {
       ":p2p_test_utils",
       ":rtc_p2p",
       "../api:libjingle_peerconnection_api",
-      "../api:mock_async_dns_resolver",
       "../api:packet_socket_factory",
       "../api:scoped_refptr",
       "../api/transport:stun_types",

p2p/base/basic_async_resolver_factory.cc

@@ -16,7 +16,6 @@
 #include "absl/memory/memory.h"
 #include "api/async_dns_resolver.h"
 #include "rtc_base/async_resolver.h"
-#include "rtc_base/logging.h"
 
 namespace webrtc {
 

p2p/base/basic_async_resolver_factory.h

@@ -32,15 +32,9 @@ class BasicAsyncResolverFactory final : public AsyncResolverFactory {
 class WrappingAsyncDnsResolverFactory final
     : public AsyncDnsResolverFactoryInterface {
  public:
-  explicit WrappingAsyncDnsResolverFactory(
+  WrappingAsyncDnsResolverFactory(
       std::unique_ptr<AsyncResolverFactory> wrapped_factory)
-      : owned_factory_(std::move(wrapped_factory)),
+      : wrapped_factory_(std::move(wrapped_factory)) {}
-        wrapped_factory_(owned_factory_.get()) {}
-
-  explicit WrappingAsyncDnsResolverFactory(
-      AsyncResolverFactory* non_owned_factory)
-      : wrapped_factory_(non_owned_factory) {}
-
   std::unique_ptr<webrtc::AsyncDnsResolverInterface> CreateAndResolve(
       const rtc::SocketAddress& addr,
       std::function<void()> callback) override;
@@ -48,8 +42,7 @@ class WrappingAsyncDnsResolverFactory final
   std::unique_ptr<webrtc::AsyncDnsResolverInterface> Create() override;
 
  private:
-  const std::unique_ptr<AsyncResolverFactory> owned_factory_;
+  const std::unique_ptr<AsyncResolverFactory> wrapped_factory_;
-  AsyncResolverFactory* const wrapped_factory_;
 };
 
 }  // namespace webrtc

p2p/base/default_ice_transport_factory.cc

@@ -45,9 +45,9 @@ DefaultIceTransportFactory::CreateIceTransport(
     IceTransportInit init) {
   BasicIceControllerFactory factory;
   return new rtc::RefCountedObject<DefaultIceTransport>(
-      cricket::P2PTransportChannel::Create(
+      std::make_unique<cricket::P2PTransportChannel>(
           transport_name, component, init.port_allocator(),
-          init.async_dns_resolver_factory(), init.event_log(), &factory));
+          init.async_resolver_factory(), init.event_log(), &factory));
 }
 
 }  // namespace webrtc

p2p/base/p2p_transport_channel.cc

@@ -10,38 +10,27 @@
 
 #include "p2p/base/p2p_transport_channel.h"
 
-#include <errno.h>
+#include <iterator>
-#include <stdlib.h>
-
-#include <algorithm>
-#include <functional>
 #include <memory>
 #include <set>
 #include <utility>
 
 #include "absl/algorithm/container.h"
-#include "absl/memory/memory.h"
 #include "absl/strings/match.h"
-#include "api/async_dns_resolver.h"
 #include "api/candidate.h"
-#include "api/task_queue/queued_task.h"
 #include "logging/rtc_event_log/ice_logger.h"
-#include "p2p/base/basic_async_resolver_factory.h"
 #include "p2p/base/basic_ice_controller.h"
+#include "p2p/base/candidate_pair_interface.h"
 #include "p2p/base/connection.h"
-#include "p2p/base/connection_info.h"
 #include "p2p/base/port.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/crc32.h"
 #include "rtc_base/experiments/struct_parameters_parser.h"
-#include "rtc_base/ip_address.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/net_helper.h"
-#include "rtc_base/network.h"
+#include "rtc_base/net_helpers.h"
-#include "rtc_base/network_constants.h"
 #include "rtc_base/string_encode.h"
 #include "rtc_base/task_utils/to_queued_task.h"
-#include "rtc_base/third_party/sigslot/sigslot.h"
 #include "rtc_base/time_utils.h"
 #include "system_wrappers/include/field_trial.h"
 #include "system_wrappers/include/metrics.h"
@@ -133,50 +122,26 @@ bool IceCredentialsChanged(const std::string& old_ufrag,
   return (old_ufrag != new_ufrag) || (old_pwd != new_pwd);
 }
 
-// static
-std::unique_ptr<P2PTransportChannel> P2PTransportChannel::Create(
-    const std::string& transport_name,
-    int component,
-    PortAllocator* allocator,
-    webrtc::AsyncDnsResolverFactoryInterface* async_dns_resolver_factory,
-    webrtc::RtcEventLog* event_log,
-    IceControllerFactoryInterface* ice_controller_factory) {
-  return absl::WrapUnique(new P2PTransportChannel(
-      transport_name, component, allocator, async_dns_resolver_factory,
-      /* owned_dns_resolver_factory= */ nullptr, event_log,
-      ice_controller_factory));
-}
-
 P2PTransportChannel::P2PTransportChannel(const std::string& transport_name,
                                          int component,
                                          PortAllocator* allocator)
     : P2PTransportChannel(transport_name,
                           component,
                           allocator,
-                          /* async_dns_resolver_factory= */ nullptr,
+                          nullptr,
-                          /* owned_dns_resolver_factory= */ nullptr,
+                          nullptr) {}
-                          /* event_log= */ nullptr,
-                          /* ice_controller_factory= */ nullptr) {}
 
-// Private constructor, called from Create()
 P2PTransportChannel::P2PTransportChannel(
     const std::string& transport_name,
     int component,
     PortAllocator* allocator,
-    webrtc::AsyncDnsResolverFactoryInterface* async_dns_resolver_factory,
+    webrtc::AsyncResolverFactory* async_resolver_factory,
-    std::unique_ptr<webrtc::AsyncDnsResolverFactoryInterface>
-        owned_dns_resolver_factory,
     webrtc::RtcEventLog* event_log,
     IceControllerFactoryInterface* ice_controller_factory)
     : transport_name_(transport_name),
       component_(component),
       allocator_(allocator),
-      // If owned_dns_resolver_factory is given, async_dns_resolver_factory is
+      async_resolver_factory_(async_resolver_factory),
-      // ignored.
-      async_dns_resolver_factory_(owned_dns_resolver_factory
-                                      ? owned_dns_resolver_factory.get()
-                                      : async_dns_resolver_factory),
-      owned_dns_resolver_factory_(std::move(owned_dns_resolver_factory)),
       network_thread_(rtc::Thread::Current()),
       incoming_only_(false),
       error_(0),
@@ -227,31 +192,15 @@ P2PTransportChannel::P2PTransportChannel(
   }
 }
 
-// Public constructor, exposed for backwards compatibility.
-// Deprecated.
-P2PTransportChannel::P2PTransportChannel(
-    const std::string& transport_name,
-    int component,
-    PortAllocator* allocator,
-    webrtc::AsyncResolverFactory* async_resolver_factory,
-    webrtc::RtcEventLog* event_log,
-    IceControllerFactoryInterface* ice_controller_factory)
-    : P2PTransportChannel(
-          transport_name,
-          component,
-          allocator,
-          nullptr,
-          std::make_unique<webrtc::WrappingAsyncDnsResolverFactory>(
-              async_resolver_factory),
-          event_log,
-          ice_controller_factory) {}
-
 P2PTransportChannel::~P2PTransportChannel() {
   RTC_DCHECK_RUN_ON(network_thread_);
   std::vector<Connection*> copy(connections().begin(), connections().end());
   for (Connection* con : copy) {
     con->Destroy();
   }
+  for (auto& p : resolvers_) {
+    p.resolver_->Destroy(false);
+  }
   resolvers_.clear();
 }
 
@@ -1215,17 +1164,16 @@ void P2PTransportChannel::OnNominated(Connection* conn) {
 
 void P2PTransportChannel::ResolveHostnameCandidate(const Candidate& candidate) {
   RTC_DCHECK_RUN_ON(network_thread_);
-  if (!async_dns_resolver_factory_) {
+  if (!async_resolver_factory_) {
     RTC_LOG(LS_WARNING) << "Dropping ICE candidate with hostname address "
                            "(no AsyncResolverFactory)";
     return;
   }
 
-  auto resolver = async_dns_resolver_factory_->Create();
+  rtc::AsyncResolverInterface* resolver = async_resolver_factory_->Create();
-  auto resptr = resolver.get();
+  resolvers_.emplace_back(candidate, resolver);
-  resolvers_.emplace_back(candidate, std::move(resolver));
+  resolver->SignalDone.connect(this, &P2PTransportChannel::OnCandidateResolved);
-  resptr->Start(candidate.address(),
+  resolver->Start(candidate.address());
-                [this, resptr]() { OnCandidateResolved(resptr); });
   RTC_LOG(LS_INFO) << "Asynchronously resolving ICE candidate hostname "
                    << candidate.address().HostAsSensitiveURIString();
 }
@@ -1280,37 +1228,38 @@ void P2PTransportChannel::AddRemoteCandidate(const Candidate& candidate) {
 
 P2PTransportChannel::CandidateAndResolver::CandidateAndResolver(
     const Candidate& candidate,
-    std::unique_ptr<webrtc::AsyncDnsResolverInterface>&& resolver)
+    rtc::AsyncResolverInterface* resolver)
-    : candidate_(candidate), resolver_(std::move(resolver)) {}
+    : candidate_(candidate), resolver_(resolver) {}
 
 P2PTransportChannel::CandidateAndResolver::~CandidateAndResolver() {}
 
 void P2PTransportChannel::OnCandidateResolved(
-    webrtc::AsyncDnsResolverInterface* resolver) {
+    rtc::AsyncResolverInterface* resolver) {
   RTC_DCHECK_RUN_ON(network_thread_);
   auto p =
       absl::c_find_if(resolvers_, [resolver](const CandidateAndResolver& cr) {
-        return cr.resolver_.get() == resolver;
+        return cr.resolver_ == resolver;
       });
   if (p == resolvers_.end()) {
-    RTC_LOG(LS_ERROR) << "Unexpected AsyncDnsResolver return";
+    RTC_LOG(LS_ERROR) << "Unexpected AsyncResolver signal";
     RTC_NOTREACHED();
     return;
   }
   Candidate candidate = p->candidate_;
-  AddRemoteCandidateWithResult(candidate, resolver->result());
-  // Now we can delete the resolver.
   resolvers_.erase(p);
+  AddRemoteCandidateWithResolver(candidate, resolver);
+  network_thread_->PostTask(
+      ToQueuedTask([resolver]() { resolver->Destroy(false); }));
 }
 
-void P2PTransportChannel::AddRemoteCandidateWithResult(
+void P2PTransportChannel::AddRemoteCandidateWithResolver(
     Candidate candidate,
-    const webrtc::AsyncDnsResolverResult& result) {
+    rtc::AsyncResolverInterface* resolver) {
   RTC_DCHECK_RUN_ON(network_thread_);
-  if (result.GetError()) {
+  if (resolver->GetError()) {
     RTC_LOG(LS_WARNING) << "Failed to resolve ICE candidate hostname "
                         << candidate.address().HostAsSensitiveURIString()
-                        << " with error " << result.GetError();
+                        << " with error " << resolver->GetError();
     return;
   }
 
@@ -1318,8 +1267,9 @@ void P2PTransportChannel::AddRemoteCandidateWithResult(
   // Prefer IPv6 to IPv4 if we have it (see RFC 5245 Section 15.1).
   // TODO(zstein): This won't work if we only have IPv4 locally but receive an
   // AAAA DNS record.
-  bool have_address = result.GetResolvedAddress(AF_INET6, &resolved_address) ||
+  bool have_address =
-                      result.GetResolvedAddress(AF_INET, &resolved_address);
+      resolver->GetResolvedAddress(AF_INET6, &resolved_address) ||
+      resolver->GetResolvedAddress(AF_INET, &resolved_address);
   if (!have_address) {
     RTC_LOG(LS_INFO) << "ICE candidate hostname "
                      << candidate.address().HostAsSensitiveURIString()

p2p/base/p2p_transport_channel.h

@@ -20,9 +20,6 @@
 #ifndef P2P_BASE_P2P_TRANSPORT_CHANNEL_H_
 #define P2P_BASE_P2P_TRANSPORT_CHANNEL_H_
 
-#include <stddef.h>
-#include <stdint.h>
-
 #include <algorithm>
 #include <map>
 #include <memory>
@@ -30,43 +27,26 @@
 #include <string>
 #include <vector>
 
-#include "absl/base/attributes.h"
-#include "absl/types/optional.h"
-#include "api/array_view.h"
-#include "api/async_dns_resolver.h"
 #include "api/async_resolver_factory.h"
 #include "api/candidate.h"
 #include "api/rtc_error.h"
-#include "api/sequence_checker.h"
-#include "api/transport/enums.h"
-#include "api/transport/stun.h"
 #include "logging/rtc_event_log/events/rtc_event_ice_candidate_pair_config.h"
 #include "logging/rtc_event_log/ice_logger.h"
 #include "p2p/base/candidate_pair_interface.h"
-#include "p2p/base/connection.h"
 #include "p2p/base/ice_controller_factory_interface.h"
 #include "p2p/base/ice_controller_interface.h"
 #include "p2p/base/ice_transport_internal.h"
 #include "p2p/base/p2p_constants.h"
 #include "p2p/base/p2p_transport_channel_ice_field_trials.h"
-#include "p2p/base/port.h"
 #include "p2p/base/port_allocator.h"
 #include "p2p/base/port_interface.h"
 #include "p2p/base/regathering_controller.h"
-#include "p2p/base/transport_description.h"
 #include "rtc_base/async_packet_socket.h"
-#include "rtc_base/checks.h"
 #include "rtc_base/constructor_magic.h"
-#include "rtc_base/dscp.h"
-#include "rtc_base/network/sent_packet.h"
-#include "rtc_base/network_route.h"
-#include "rtc_base/socket.h"
-#include "rtc_base/socket_address.h"
 #include "rtc_base/strings/string_builder.h"
 #include "rtc_base/system/rtc_export.h"
 #include "rtc_base/task_utils/pending_task_safety_flag.h"
 #include "rtc_base/third_party/sigslot/sigslot.h"
-#include "rtc_base/thread.h"
 #include "rtc_base/thread_annotations.h"
 
 namespace webrtc {
@@ -102,19 +82,11 @@ class RemoteCandidate : public Candidate {
 // two P2P clients connected to each other.
 class RTC_EXPORT P2PTransportChannel : public IceTransportInternal {
  public:
-  static std::unique_ptr<P2PTransportChannel> Create(
-      const std::string& transport_name,
-      int component,
-      PortAllocator* allocator,
-      webrtc::AsyncDnsResolverFactoryInterface* async_dns_resolver_factory,
-      webrtc::RtcEventLog* event_log = nullptr,
-      IceControllerFactoryInterface* ice_controller_factory = nullptr);
   // For testing only.
-  // TODO(zstein): Remove once AsyncDnsResolverFactory is required.
+  // TODO(zstein): Remove once AsyncResolverFactory is required.
   P2PTransportChannel(const std::string& transport_name,
                       int component,
                       PortAllocator* allocator);
-  ABSL_DEPRECATED("bugs.webrtc.org/12598")
   P2PTransportChannel(
       const std::string& transport_name,
       int component,
@@ -237,18 +209,6 @@ class RTC_EXPORT P2PTransportChannel : public IceTransportInternal {
   }
 
  private:
-  P2PTransportChannel(
-      const std::string& transport_name,
-      int component,
-      PortAllocator* allocator,
-      // DNS resolver factory
-      webrtc::AsyncDnsResolverFactoryInterface* async_dns_resolver_factory,
-      // If the P2PTransportChannel has to delete the DNS resolver factory
-      // on release, this pointer is set.
-      std::unique_ptr<webrtc::AsyncDnsResolverFactoryInterface>
-          owned_dns_resolver_factory,
-      webrtc::RtcEventLog* event_log = nullptr,
-      IceControllerFactoryInterface* ice_controller_factory = nullptr);
   bool IsGettingPorts() {
     RTC_DCHECK_RUN_ON(network_thread_);
     return allocator_session()->IsGettingPorts();
@@ -403,10 +363,8 @@ class RTC_EXPORT P2PTransportChannel : public IceTransportInternal {
   std::string transport_name_ RTC_GUARDED_BY(network_thread_);
   int component_ RTC_GUARDED_BY(network_thread_);
   PortAllocator* allocator_ RTC_GUARDED_BY(network_thread_);
-  webrtc::AsyncDnsResolverFactoryInterface* const async_dns_resolver_factory_
+  webrtc::AsyncResolverFactory* async_resolver_factory_
       RTC_GUARDED_BY(network_thread_);
-  const std::unique_ptr<webrtc::AsyncDnsResolverFactoryInterface>
-      owned_dns_resolver_factory_;
   rtc::Thread* const network_thread_;
   bool incoming_only_ RTC_GUARDED_BY(network_thread_);
   int error_ RTC_GUARDED_BY(network_thread_);
@@ -468,23 +426,17 @@ class RTC_EXPORT P2PTransportChannel : public IceTransportInternal {
       RTC_GUARDED_BY(network_thread_);
 
   struct CandidateAndResolver final {
-    CandidateAndResolver(
+    CandidateAndResolver(const Candidate& candidate,
-        const Candidate& candidate,
+                         rtc::AsyncResolverInterface* resolver);
-        std::unique_ptr<webrtc::AsyncDnsResolverInterface>&& resolver);
     ~CandidateAndResolver();
-    // Moveable, but not copyable.
-    CandidateAndResolver(CandidateAndResolver&&) = default;
-    CandidateAndResolver& operator=(CandidateAndResolver&&) = default;
-
     Candidate candidate_;
-    std::unique_ptr<webrtc::AsyncDnsResolverInterface> resolver_;
+    rtc::AsyncResolverInterface* resolver_;
   };
   std::vector<CandidateAndResolver> resolvers_ RTC_GUARDED_BY(network_thread_);
   void FinishAddingRemoteCandidate(const Candidate& new_remote_candidate);
-  void OnCandidateResolved(webrtc::AsyncDnsResolverInterface* resolver);
+  void OnCandidateResolved(rtc::AsyncResolverInterface* resolver);
-  void AddRemoteCandidateWithResult(
+  void AddRemoteCandidateWithResolver(Candidate candidate,
-      Candidate candidate,
+                                      rtc::AsyncResolverInterface* resolver);
-      const webrtc::AsyncDnsResolverResult& result);
 
   // Number of times the selected_connection_ has been modified.
   uint32_t selected_candidate_pair_changes_ = 0;

p2p/base/p2p_transport_channel_unittest.cc

@@ -14,7 +14,6 @@
 #include <memory>
 #include <utility>
 
-#include "api/test/mock_async_dns_resolver.h"
 #include "p2p/base/basic_ice_controller.h"
 #include "p2p/base/connection.h"
 #include "p2p/base/fake_port_allocator.h"
@@ -52,12 +51,9 @@ using ::testing::Assign;
 using ::testing::Contains;
 using ::testing::DoAll;
 using ::testing::InSequence;
-using ::testing::InvokeArgument;
 using ::testing::InvokeWithoutArgs;
 using ::testing::NiceMock;
 using ::testing::Return;
-using ::testing::ReturnRef;
-using ::testing::SaveArg;
 using ::testing::SetArgPointee;
 using ::testing::SizeIs;
 
@@ -191,51 +187,6 @@ class MockIceControllerFactory : public cricket::IceControllerFactoryInterface {
   MOCK_METHOD(void, RecordIceControllerCreated, ());
 };
 
-// An one-shot resolver factory with default return arguments.
-// Resolution is immediate, always succeeds, and returns nonsense.
-class ResolverFactoryFixture : public webrtc::MockAsyncDnsResolverFactory {
- public:
-  ResolverFactoryFixture() {
-    mock_async_dns_resolver_ = std::make_unique<webrtc::MockAsyncDnsResolver>();
-    ON_CALL(*mock_async_dns_resolver_, Start(_, _))
-        .WillByDefault(InvokeArgument<1>());
-    EXPECT_CALL(*mock_async_dns_resolver_, result())
-        .WillOnce(ReturnRef(mock_async_dns_resolver_result_));
-
-    // A default action for GetResolvedAddress. Will be overruled
-    // by SetAddressToReturn.
-    ON_CALL(mock_async_dns_resolver_result_, GetResolvedAddress(_, _))
-        .WillByDefault(Return(true));
-
-    EXPECT_CALL(mock_async_dns_resolver_result_, GetError())
-        .WillOnce(Return(0));
-    EXPECT_CALL(*this, Create()).WillOnce([this]() {
-      return std::move(mock_async_dns_resolver_);
-    });
-  }
-
-  void SetAddressToReturn(rtc::SocketAddress address_to_return) {
-    EXPECT_CALL(mock_async_dns_resolver_result_, GetResolvedAddress(_, _))
-        .WillOnce(DoAll(SetArgPointee<1>(address_to_return), Return(true)));
-  }
-  void DelayResolution() {
-    // This function must be called before Create().
-    ASSERT_TRUE(!!mock_async_dns_resolver_);
-    EXPECT_CALL(*mock_async_dns_resolver_, Start(_, _))
-        .WillOnce(SaveArg<1>(&saved_callback_));
-  }
-  void FireDelayedResolution() {
-    // This function must be called after Create().
-    ASSERT_TRUE(saved_callback_);
-    saved_callback_();
-  }
-
- private:
-  std::unique_ptr<webrtc::MockAsyncDnsResolver> mock_async_dns_resolver_;
-  webrtc::MockAsyncDnsResolverResult mock_async_dns_resolver_result_;
-  std::function<void()> saved_callback_;
-};
-
 }  // namespace
 
 namespace cricket {
@@ -394,7 +345,7 @@ class P2PTransportChannelTestBase : public ::testing::Test,
 
     rtc::FakeNetworkManager network_manager_;
     std::unique_ptr<BasicPortAllocator> allocator_;
-    webrtc::AsyncDnsResolverFactoryInterface* async_dns_resolver_factory_;
+    webrtc::AsyncResolverFactory* async_resolver_factory_;
     ChannelData cd1_;
     ChannelData cd2_;
     IceRole role_;
@@ -427,10 +378,10 @@ class P2PTransportChannelTestBase : public ::testing::Test,
         IceParamsWithRenomination(kIceParams[0], renomination);
     IceParameters ice_ep2_cd1_ch =
         IceParamsWithRenomination(kIceParams[1], renomination);
-    ep1_.cd1_.ch_ = CreateChannel(0, ICE_CANDIDATE_COMPONENT_DEFAULT,
+    ep1_.cd1_.ch_.reset(CreateChannel(0, ICE_CANDIDATE_COMPONENT_DEFAULT,
-                                  ice_ep1_cd1_ch, ice_ep2_cd1_ch);
+                                      ice_ep1_cd1_ch, ice_ep2_cd1_ch));
-    ep2_.cd1_.ch_ = CreateChannel(1, ICE_CANDIDATE_COMPONENT_DEFAULT,
+    ep2_.cd1_.ch_.reset(CreateChannel(1, ICE_CANDIDATE_COMPONENT_DEFAULT,
-                                  ice_ep2_cd1_ch, ice_ep1_cd1_ch);
+                                      ice_ep2_cd1_ch, ice_ep1_cd1_ch));
     ep1_.cd1_.ch_->SetIceConfig(ep1_config);
     ep2_.cd1_.ch_->SetIceConfig(ep2_config);
     ep1_.cd1_.ch_->MaybeStartGathering();
@@ -446,14 +397,13 @@ class P2PTransportChannelTestBase : public ::testing::Test,
     CreateChannels(default_config, default_config, false);
   }
 
-  std::unique_ptr<P2PTransportChannel> CreateChannel(
+  P2PTransportChannel* CreateChannel(int endpoint,
-      int endpoint,
                                      int component,
                                      const IceParameters& local_ice,
                                      const IceParameters& remote_ice) {
-    auto channel = P2PTransportChannel::Create(
+    P2PTransportChannel* channel = new P2PTransportChannel(
         "test content name", component, GetAllocator(endpoint),
-        GetEndpoint(endpoint)->async_dns_resolver_factory_);
+        GetEndpoint(endpoint)->async_resolver_factory_);
     channel->SignalReadyToSend.connect(
         this, &P2PTransportChannelTestBase::OnReadyToSend);
     channel->SignalCandidateGathered.connect(
@@ -2129,8 +2079,8 @@ TEST_F(P2PTransportChannelTest, TurnToTurnPresumedWritable) {
                      kDefaultPortAllocatorFlags);
   // Only configure one channel so we can control when the remote candidate
   // is added.
-  GetEndpoint(0)->cd1_.ch_ = CreateChannel(0, ICE_CANDIDATE_COMPONENT_DEFAULT,
+  GetEndpoint(0)->cd1_.ch_.reset(CreateChannel(
-                                           kIceParams[0], kIceParams[1]);
+      0, ICE_CANDIDATE_COMPONENT_DEFAULT, kIceParams[0], kIceParams[1]));
   IceConfig config;
   config.presume_writable_when_fully_relayed = true;
   ep1_ch1()->SetIceConfig(config);
@@ -2178,10 +2128,10 @@ TEST_F(P2PTransportChannelTest, TurnToPrflxPresumedWritable) {
   test_turn_server()->set_enable_permission_checks(false);
   IceConfig config;
   config.presume_writable_when_fully_relayed = true;
-  GetEndpoint(0)->cd1_.ch_ = CreateChannel(0, ICE_CANDIDATE_COMPONENT_DEFAULT,
+  GetEndpoint(0)->cd1_.ch_.reset(CreateChannel(
-                                           kIceParams[0], kIceParams[1]);
+      0, ICE_CANDIDATE_COMPONENT_DEFAULT, kIceParams[0], kIceParams[1]));
-  GetEndpoint(1)->cd1_.ch_ = CreateChannel(1, ICE_CANDIDATE_COMPONENT_DEFAULT,
+  GetEndpoint(1)->cd1_.ch_.reset(CreateChannel(
-                                           kIceParams[1], kIceParams[0]);
+      1, ICE_CANDIDATE_COMPONENT_DEFAULT, kIceParams[1], kIceParams[0]));
   ep1_ch1()->SetIceConfig(config);
   ep2_ch1()->SetIceConfig(config);
   // Don't signal candidates from channel 2, so that channel 1 sees the TURN
@@ -2217,10 +2167,10 @@ TEST_F(P2PTransportChannelTest, PresumedWritablePreferredOverUnreliable) {
                      kDefaultPortAllocatorFlags);
   IceConfig config;
   config.presume_writable_when_fully_relayed = true;
-  GetEndpoint(0)->cd1_.ch_ = CreateChannel(0, ICE_CANDIDATE_COMPONENT_DEFAULT,
+  GetEndpoint(0)->cd1_.ch_.reset(CreateChannel(
-                                           kIceParams[0], kIceParams[1]);
+      0, ICE_CANDIDATE_COMPONENT_DEFAULT, kIceParams[0], kIceParams[1]));
-  GetEndpoint(1)->cd1_.ch_ = CreateChannel(1, ICE_CANDIDATE_COMPONENT_DEFAULT,
+  GetEndpoint(1)->cd1_.ch_.reset(CreateChannel(
-                                           kIceParams[1], kIceParams[0]);
+      1, ICE_CANDIDATE_COMPONENT_DEFAULT, kIceParams[1], kIceParams[0]));
   ep1_ch1()->SetIceConfig(config);
   ep2_ch1()->SetIceConfig(config);
   ep1_ch1()->MaybeStartGathering();
@@ -2255,8 +2205,8 @@ TEST_F(P2PTransportChannelTest, SignalReadyToSendWithPresumedWritable) {
                      kDefaultPortAllocatorFlags);
   // Only test one endpoint, so we can ensure the connection doesn't receive a
   // binding response and advance beyond being "presumed" writable.
-  GetEndpoint(0)->cd1_.ch_ = CreateChannel(0, ICE_CANDIDATE_COMPONENT_DEFAULT,
+  GetEndpoint(0)->cd1_.ch_.reset(CreateChannel(
-                                           kIceParams[0], kIceParams[1]);
+      0, ICE_CANDIDATE_COMPONENT_DEFAULT, kIceParams[0], kIceParams[1]));
   IceConfig config;
   config.presume_writable_when_fully_relayed = true;
   ep1_ch1()->SetIceConfig(config);
@@ -2308,10 +2258,10 @@ TEST_F(P2PTransportChannelTest,
   // to configure the server to accept packets from an address we haven't
   // explicitly installed permission for.
   test_turn_server()->set_enable_permission_checks(false);
-  GetEndpoint(0)->cd1_.ch_ = CreateChannel(0, ICE_CANDIDATE_COMPONENT_DEFAULT,
+  GetEndpoint(0)->cd1_.ch_.reset(CreateChannel(
-                                           kIceParams[0], kIceParams[1]);
+      0, ICE_CANDIDATE_COMPONENT_DEFAULT, kIceParams[0], kIceParams[1]));
-  GetEndpoint(1)->cd1_.ch_ = CreateChannel(1, ICE_CANDIDATE_COMPONENT_DEFAULT,
+  GetEndpoint(1)->cd1_.ch_.reset(CreateChannel(
-                                           kIceParams[1], kIceParams[0]);
+      1, ICE_CANDIDATE_COMPONENT_DEFAULT, kIceParams[1], kIceParams[0]));
   // Don't signal candidates from channel 2, so that channel 1 sees the TURN
   // candidate as peer reflexive.
   PauseCandidates(1);
@@ -4884,18 +4834,31 @@ TEST_F(P2PTransportChannelMostLikelyToWorkFirstTest, TestTcpTurn) {
 // when the address is a hostname. The destruction should happen even
 // if the channel is not destroyed.
 TEST(P2PTransportChannelResolverTest, HostnameCandidateIsResolved) {
-  ResolverFactoryFixture resolver_fixture;
+  rtc::MockAsyncResolver mock_async_resolver;
+  EXPECT_CALL(mock_async_resolver, GetError()).WillOnce(Return(0));
+  EXPECT_CALL(mock_async_resolver, GetResolvedAddress(_, _))
+      .WillOnce(Return(true));
+  // Destroy is called asynchronously after the address is resolved,
+  // so we need a variable to wait on.
+  bool destroy_called = false;
+  EXPECT_CALL(mock_async_resolver, Destroy(_))
+      .WillOnce(Assign(&destroy_called, true));
+  webrtc::MockAsyncResolverFactory mock_async_resolver_factory;
+  EXPECT_CALL(mock_async_resolver_factory, Create())
+      .WillOnce(Return(&mock_async_resolver));
+
   FakePortAllocator allocator(rtc::Thread::Current(), nullptr);
-  auto channel =
+  P2PTransportChannel channel("tn", 0, &allocator,
-      P2PTransportChannel::Create("tn", 0, &allocator, &resolver_fixture);
+                              &mock_async_resolver_factory);
   Candidate hostname_candidate;
   SocketAddress hostname_address("fake.test", 1000);
   hostname_candidate.set_address(hostname_address);
-  channel->AddRemoteCandidate(hostname_candidate);
+  channel.AddRemoteCandidate(hostname_candidate);
 
-  ASSERT_EQ_WAIT(1u, channel->remote_candidates().size(), kDefaultTimeout);
+  ASSERT_EQ_WAIT(1u, channel.remote_candidates().size(), kDefaultTimeout);
-  const RemoteCandidate& candidate = channel->remote_candidates()[0];
+  const RemoteCandidate& candidate = channel.remote_candidates()[0];
   EXPECT_FALSE(candidate.address().IsUnresolvedIP());
+  WAIT(destroy_called, kShortTimeout);
 }
 
 // Test that if we signal a hostname candidate after the remote endpoint
@@ -4904,6 +4867,11 @@ TEST(P2PTransportChannelResolverTest, HostnameCandidateIsResolved) {
 // done.
 TEST_F(P2PTransportChannelTest,
        PeerReflexiveCandidateBeforeSignalingWithMdnsName) {
+  rtc::MockAsyncResolver mock_async_resolver;
+  webrtc::MockAsyncResolverFactory mock_async_resolver_factory;
+  EXPECT_CALL(mock_async_resolver_factory, Create())
+      .WillOnce(Return(&mock_async_resolver));
+
   // ep1 and ep2 will only gather host candidates with addresses
   // kPublicAddrs[0] and kPublicAddrs[1], respectively.
   ConfigureEndpoints(OPEN, OPEN, kOnlyLocalPorts, kOnlyLocalPorts);
@@ -4911,9 +4879,7 @@ TEST_F(P2PTransportChannelTest,
   set_remote_ice_parameter_source(FROM_SETICEPARAMETERS);
   GetEndpoint(0)->network_manager_.set_mdns_responder(
       std::make_unique<webrtc::FakeMdnsResponder>(rtc::Thread::Current()));
-
+  GetEndpoint(1)->async_resolver_factory_ = &mock_async_resolver_factory;
-  ResolverFactoryFixture resolver_fixture;
-  GetEndpoint(1)->async_dns_resolver_factory_ = &resolver_fixture;
   CreateChannels();
   // Pause sending candidates from both endpoints until we find out what port
   // number is assgined to ep1's host candidate.
@@ -4928,7 +4894,6 @@ TEST_F(P2PTransportChannelTest,
   // This is the underlying private IP address of the same candidate at ep1.
   const auto local_address = rtc::SocketAddress(
       kPublicAddrs[0].ipaddr(), local_candidate.address().port());
-
   // Let ep2 signal its candidate to ep1. ep1 should form a candidate
   // pair and start to ping. After receiving the ping, ep2 discovers a prflx
   // remote candidate and form a candidate pair as well.
@@ -4944,7 +4909,19 @@ TEST_F(P2PTransportChannelTest,
   EXPECT_EQ(kIceUfrag[0], selected_connection->remote_candidate().username());
   EXPECT_EQ(kIcePwd[0], selected_connection->remote_candidate().password());
   // Set expectation before ep1 signals a hostname candidate.
-  resolver_fixture.SetAddressToReturn(local_address);
+  {
+    InSequence sequencer;
+    EXPECT_CALL(mock_async_resolver, Start(_));
+    EXPECT_CALL(mock_async_resolver, GetError()).WillOnce(Return(0));
+    // Let the mock resolver of ep2 receives the correct resolution.
+    EXPECT_CALL(mock_async_resolver, GetResolvedAddress(_, _))
+        .WillOnce(DoAll(SetArgPointee<1>(local_address), Return(true)));
+  }
+  // Destroy is called asynchronously after the address is resolved,
+  // so we need a variable to wait on.
+  bool destroy_called = false;
+  EXPECT_CALL(mock_async_resolver, Destroy(_))
+      .WillOnce(Assign(&destroy_called, true));
   ResumeCandidates(0);
   // Verify ep2's selected connection is updated to use the 'local' candidate.
   EXPECT_EQ_WAIT(LOCAL_PORT_TYPE,
@@ -4952,6 +4929,7 @@ TEST_F(P2PTransportChannelTest,
                  kMediumTimeout);
   EXPECT_EQ(selected_connection, ep2_ch1()->selected_connection());
 
+  WAIT(destroy_called, kShortTimeout);
   DestroyChannels();
 }
 
@@ -4961,9 +4939,13 @@ TEST_F(P2PTransportChannelTest,
 // address after the resolution completes.
 TEST_F(P2PTransportChannelTest,
        PeerReflexiveCandidateDuringResolvingHostCandidateWithMdnsName) {
-  ResolverFactoryFixture resolver_fixture;
+  auto mock_async_resolver = new NiceMock<rtc::MockAsyncResolver>();
-  // Prevent resolution until triggered by FireDelayedResolution.
+  ON_CALL(*mock_async_resolver, Destroy).WillByDefault([mock_async_resolver] {
-  resolver_fixture.DelayResolution();
+    delete mock_async_resolver;
+  });
+  webrtc::MockAsyncResolverFactory mock_async_resolver_factory;
+  EXPECT_CALL(mock_async_resolver_factory, Create())
+      .WillOnce(Return(mock_async_resolver));
 
   // ep1 and ep2 will only gather host candidates with addresses
   // kPublicAddrs[0] and kPublicAddrs[1], respectively.
@@ -4972,13 +4954,12 @@ TEST_F(P2PTransportChannelTest,
   set_remote_ice_parameter_source(FROM_SETICEPARAMETERS);
   GetEndpoint(0)->network_manager_.set_mdns_responder(
       std::make_unique<webrtc::FakeMdnsResponder>(rtc::Thread::Current()));
-  GetEndpoint(1)->async_dns_resolver_factory_ = &resolver_fixture;
+  GetEndpoint(1)->async_resolver_factory_ = &mock_async_resolver_factory;
   CreateChannels();
   // Pause sending candidates from both endpoints until we find out what port
   // number is assgined to ep1's host candidate.
   PauseCandidates(0);
   PauseCandidates(1);
-
   ASSERT_EQ_WAIT(1u, GetEndpoint(0)->saved_candidates_.size(), kMediumTimeout);
   ASSERT_EQ(1u, GetEndpoint(0)->saved_candidates_[0]->candidates.size());
   const auto& local_candidate =
@@ -4988,16 +4969,24 @@ TEST_F(P2PTransportChannelTest,
   // This is the underlying private IP address of the same candidate at ep1.
   const auto local_address = rtc::SocketAddress(
       kPublicAddrs[0].ipaddr(), local_candidate.address().port());
+  bool mock_async_resolver_started = false;
+  // Not signaling done yet, and only make sure we are in the process of
+  // resolution.
+  EXPECT_CALL(*mock_async_resolver, Start(_))
+      .WillOnce(InvokeWithoutArgs([&mock_async_resolver_started]() {
+        mock_async_resolver_started = true;
+      }));
   // Let ep1 signal its hostname candidate to ep2.
   ResumeCandidates(0);
+  ASSERT_TRUE_WAIT(mock_async_resolver_started, kMediumTimeout);
   // Now that ep2 is in the process of resolving the hostname candidate signaled
   // by ep1. Let ep2 signal its host candidate with an IP address to ep1, so
   // that ep1 can form a candidate pair, select it and start to ping ep2.
   ResumeCandidates(1);
   ASSERT_TRUE_WAIT(ep1_ch1()->selected_connection() != nullptr, kMediumTimeout);
   // Let the mock resolver of ep2 receives the correct resolution.
-  resolver_fixture.SetAddressToReturn(local_address);
+  EXPECT_CALL(*mock_async_resolver, GetResolvedAddress(_, _))
-
+      .WillOnce(DoAll(SetArgPointee<1>(local_address), Return(true)));
   // Upon receiving a ping from ep1, ep2 adds a prflx candidate from the
   // unknown address and establishes a connection.
   //
@@ -5008,9 +4997,7 @@ TEST_F(P2PTransportChannelTest,
             ep2_ch1()->selected_connection()->remote_candidate().type());
   // ep2 should also be able resolve the hostname candidate. The resolved remote
   // host candidate should be merged with the prflx remote candidate.
-
+  mock_async_resolver->SignalDone(mock_async_resolver);
-  resolver_fixture.FireDelayedResolution();
-
   EXPECT_EQ_WAIT(LOCAL_PORT_TYPE,
                  ep2_ch1()->selected_connection()->remote_candidate().type(),
                  kMediumTimeout);
@@ -5023,7 +5010,10 @@ TEST_F(P2PTransportChannelTest,
 // which is obfuscated by an mDNS name, and if the peer can complete the name
 // resolution with the correct IP address, we can have a p2p connection.
 TEST_F(P2PTransportChannelTest, CanConnectWithHostCandidateWithMdnsName) {
-  ResolverFactoryFixture resolver_fixture;
+  NiceMock<rtc::MockAsyncResolver> mock_async_resolver;
+  webrtc::MockAsyncResolverFactory mock_async_resolver_factory;
+  EXPECT_CALL(mock_async_resolver_factory, Create())
+      .WillOnce(Return(&mock_async_resolver));
 
   // ep1 and ep2 will only gather host candidates with addresses
   // kPublicAddrs[0] and kPublicAddrs[1], respectively.
@@ -5032,7 +5022,7 @@ TEST_F(P2PTransportChannelTest, CanConnectWithHostCandidateWithMdnsName) {
   set_remote_ice_parameter_source(FROM_SETICEPARAMETERS);
   GetEndpoint(0)->network_manager_.set_mdns_responder(
       std::make_unique<webrtc::FakeMdnsResponder>(rtc::Thread::Current()));
-  GetEndpoint(1)->async_dns_resolver_factory_ = &resolver_fixture;
+  GetEndpoint(1)->async_resolver_factory_ = &mock_async_resolver_factory;
   CreateChannels();
   // Pause sending candidates from both endpoints until we find out what port
   // number is assgined to ep1's host candidate.
@@ -5049,7 +5039,8 @@ TEST_F(P2PTransportChannelTest, CanConnectWithHostCandidateWithMdnsName) {
   rtc::SocketAddress resolved_address_ep1(local_candidate_ep1.address());
   resolved_address_ep1.SetResolvedIP(kPublicAddrs[0].ipaddr());
 
-  resolver_fixture.SetAddressToReturn(resolved_address_ep1);
+  EXPECT_CALL(mock_async_resolver, GetResolvedAddress(_, _))
+      .WillOnce(DoAll(SetArgPointee<1>(resolved_address_ep1), Return(true)));
   // Let ep1 signal its hostname candidate to ep2.
   ResumeCandidates(0);
 
@@ -5073,7 +5064,10 @@ TEST_F(P2PTransportChannelTest, CanConnectWithHostCandidateWithMdnsName) {
 // this remote host candidate in stats.
 TEST_F(P2PTransportChannelTest,
        CandidatesSanitizedInStatsWhenMdnsObfuscationEnabled) {
-  ResolverFactoryFixture resolver_fixture;
+  NiceMock<rtc::MockAsyncResolver> mock_async_resolver;
+  webrtc::MockAsyncResolverFactory mock_async_resolver_factory;
+  EXPECT_CALL(mock_async_resolver_factory, Create())
+      .WillOnce(Return(&mock_async_resolver));
 
   // ep1 and ep2 will gather host candidates with addresses
   // kPublicAddrs[0] and kPublicAddrs[1], respectively. ep1 also gathers a srflx
@@ -5085,7 +5079,7 @@ TEST_F(P2PTransportChannelTest,
   set_remote_ice_parameter_source(FROM_SETICEPARAMETERS);
   GetEndpoint(0)->network_manager_.set_mdns_responder(
       std::make_unique<webrtc::FakeMdnsResponder>(rtc::Thread::Current()));
-  GetEndpoint(1)->async_dns_resolver_factory_ = &resolver_fixture;
+  GetEndpoint(1)->async_resolver_factory_ = &mock_async_resolver_factory;
   CreateChannels();
   // Pause sending candidates from both endpoints until we find out what port
   // number is assigned to ep1's host candidate.
@@ -5103,7 +5097,9 @@ TEST_F(P2PTransportChannelTest,
       // and let the mock resolver of ep2 receive the correct resolution.
       rtc::SocketAddress resolved_address_ep1(local_candidate_ep1.address());
       resolved_address_ep1.SetResolvedIP(kPublicAddrs[0].ipaddr());
-      resolver_fixture.SetAddressToReturn(resolved_address_ep1);
+      EXPECT_CALL(mock_async_resolver, GetResolvedAddress(_, _))
+          .WillOnce(
+              DoAll(SetArgPointee<1>(resolved_address_ep1), Return(true)));
       break;
     }
   }
@@ -5252,7 +5248,10 @@ TEST_F(P2PTransportChannelTest,
 // when it is queried via GetSelectedCandidatePair.
 TEST_F(P2PTransportChannelTest,
        SelectedCandidatePairSanitizedWhenMdnsObfuscationEnabled) {
-  ResolverFactoryFixture resolver_fixture;
+  NiceMock<rtc::MockAsyncResolver> mock_async_resolver;
+  webrtc::MockAsyncResolverFactory mock_async_resolver_factory;
+  EXPECT_CALL(mock_async_resolver_factory, Create())
+      .WillOnce(Return(&mock_async_resolver));
 
   // ep1 and ep2 will gather host candidates with addresses
   // kPublicAddrs[0] and kPublicAddrs[1], respectively.
@@ -5261,7 +5260,7 @@ TEST_F(P2PTransportChannelTest,
   set_remote_ice_parameter_source(FROM_SETICEPARAMETERS);
   GetEndpoint(0)->network_manager_.set_mdns_responder(
       std::make_unique<webrtc::FakeMdnsResponder>(rtc::Thread::Current()));
-  GetEndpoint(1)->async_dns_resolver_factory_ = &resolver_fixture;
+  GetEndpoint(1)->async_resolver_factory_ = &mock_async_resolver_factory;
   CreateChannels();
   // Pause sending candidates from both endpoints until we find out what port
   // number is assigned to ep1's host candidate.
@@ -5276,8 +5275,8 @@ TEST_F(P2PTransportChannelTest,
   // and let the mock resolver of ep2 receive the correct resolution.
   rtc::SocketAddress resolved_address_ep1(local_candidate_ep1.address());
   resolved_address_ep1.SetResolvedIP(kPublicAddrs[0].ipaddr());
-  resolver_fixture.SetAddressToReturn(resolved_address_ep1);
+  EXPECT_CALL(mock_async_resolver, GetResolvedAddress(_, _))
-
+      .WillOnce(DoAll(SetArgPointee<1>(resolved_address_ep1), Return(true)));
   ResumeCandidates(0);
   ResumeCandidates(1);
 
@@ -5306,8 +5305,8 @@ TEST_F(P2PTransportChannelTest,
   // We use one endpoint to test the behavior of adding remote candidates, and
   // this endpoint only gathers relay candidates.
   ConfigureEndpoints(OPEN, OPEN, kOnlyRelayPorts, kDefaultPortAllocatorFlags);
-  GetEndpoint(0)->cd1_.ch_ = CreateChannel(0, ICE_CANDIDATE_COMPONENT_DEFAULT,
+  GetEndpoint(0)->cd1_.ch_.reset(CreateChannel(
-                                           kIceParams[0], kIceParams[1]);
+      0, ICE_CANDIDATE_COMPONENT_DEFAULT, kIceParams[0], kIceParams[1]));
   IceConfig config;
   // Start gathering and we should have only a single relay port.
   ep1_ch1()->SetIceConfig(config);
@@ -5870,21 +5869,21 @@ class ForgetLearnedStateControllerFactory
 TEST_F(P2PTransportChannelPingTest, TestForgetLearnedState) {
   ForgetLearnedStateControllerFactory factory;
   FakePortAllocator pa(rtc::Thread::Current(), nullptr);
-  auto ch = P2PTransportChannel::Create("ping sufficiently", 1, &pa, nullptr,
+  P2PTransportChannel ch("ping sufficiently", 1, &pa, nullptr, nullptr,
-                                        nullptr, &factory);
+                         &factory);
-  PrepareChannel(ch.get());
+  PrepareChannel(&ch);
-  ch->MaybeStartGathering();
+  ch.MaybeStartGathering();
-  ch->AddRemoteCandidate(CreateUdpCandidate(LOCAL_PORT_TYPE, "1.1.1.1", 1, 1));
+  ch.AddRemoteCandidate(CreateUdpCandidate(LOCAL_PORT_TYPE, "1.1.1.1", 1, 1));
-  ch->AddRemoteCandidate(CreateUdpCandidate(LOCAL_PORT_TYPE, "2.2.2.2", 2, 2));
+  ch.AddRemoteCandidate(CreateUdpCandidate(LOCAL_PORT_TYPE, "2.2.2.2", 2, 2));
 
-  Connection* conn1 = WaitForConnectionTo(ch.get(), "1.1.1.1", 1);
+  Connection* conn1 = WaitForConnectionTo(&ch, "1.1.1.1", 1);
-  Connection* conn2 = WaitForConnectionTo(ch.get(), "2.2.2.2", 2);
+  Connection* conn2 = WaitForConnectionTo(&ch, "2.2.2.2", 2);
   ASSERT_TRUE(conn1 != nullptr);
   ASSERT_TRUE(conn2 != nullptr);
 
   // Wait for conn1 to be selected.
   conn1->ReceivedPingResponse(LOW_RTT, "id");
-  EXPECT_EQ_WAIT(conn1, ch->selected_connection(), kMediumTimeout);
+  EXPECT_EQ_WAIT(conn1, ch.selected_connection(), kMediumTimeout);
 
   conn2->ReceivedPingResponse(LOW_RTT, "id");
   EXPECT_TRUE(conn2->writable());
@@ -5905,23 +5904,23 @@ TEST_F(P2PTransportChannelTest, DisableDnsLookupsWithTransportPolicyRelay) {
   auto* ep1 = GetEndpoint(0);
   ep1->allocator_->SetCandidateFilter(CF_RELAY);
 
-  std::unique_ptr<webrtc::MockAsyncDnsResolver> mock_async_resolver =
+  rtc::MockAsyncResolver mock_async_resolver;
-      std::make_unique<webrtc::MockAsyncDnsResolver>();
+  webrtc::MockAsyncResolverFactory mock_async_resolver_factory;
-  // This test expects resolution to not be started.
-  EXPECT_CALL(*mock_async_resolver, Start(_, _)).Times(0);
-
-  webrtc::MockAsyncDnsResolverFactory mock_async_resolver_factory;
   ON_CALL(mock_async_resolver_factory, Create())
-      .WillByDefault(
+      .WillByDefault(Return(&mock_async_resolver));
-          [&mock_async_resolver]() { return std::move(mock_async_resolver); });
+  ep1->async_resolver_factory_ = &mock_async_resolver_factory;
 
-  ep1->async_dns_resolver_factory_ = &mock_async_resolver_factory;
+  bool lookup_started = false;
+  ON_CALL(mock_async_resolver, Start(_))
+      .WillByDefault(Assign(&lookup_started, true));
 
   CreateChannels();
 
   ep1_ch1()->AddRemoteCandidate(
       CreateUdpCandidate(LOCAL_PORT_TYPE, "hostname.test", 1, 100));
 
+  EXPECT_FALSE(lookup_started);
+
   DestroyChannels();
 }
 
@@ -5931,23 +5930,23 @@ TEST_F(P2PTransportChannelTest, DisableDnsLookupsWithTransportPolicyNone) {
   auto* ep1 = GetEndpoint(0);
   ep1->allocator_->SetCandidateFilter(CF_NONE);
 
-  std::unique_ptr<webrtc::MockAsyncDnsResolver> mock_async_resolver =
+  rtc::MockAsyncResolver mock_async_resolver;
-      std::make_unique<webrtc::MockAsyncDnsResolver>();
+  webrtc::MockAsyncResolverFactory mock_async_resolver_factory;
-  // This test expects resolution to not be started.
-  EXPECT_CALL(*mock_async_resolver, Start(_, _)).Times(0);
-
-  webrtc::MockAsyncDnsResolverFactory mock_async_resolver_factory;
   ON_CALL(mock_async_resolver_factory, Create())
-      .WillByDefault(
+      .WillByDefault(Return(&mock_async_resolver));
-          [&mock_async_resolver]() { return std::move(mock_async_resolver); });
+  ep1->async_resolver_factory_ = &mock_async_resolver_factory;
 
-  ep1->async_dns_resolver_factory_ = &mock_async_resolver_factory;
+  bool lookup_started = false;
+  ON_CALL(mock_async_resolver, Start(_))
+      .WillByDefault(Assign(&lookup_started, true));
 
   CreateChannels();
 
   ep1_ch1()->AddRemoteCandidate(
       CreateUdpCandidate(LOCAL_PORT_TYPE, "hostname.test", 1, 100));
 
+  EXPECT_FALSE(lookup_started);
+
   DestroyChannels();
 }
 
@@ -5957,18 +5956,17 @@ TEST_F(P2PTransportChannelTest, EnableDnsLookupsWithTransportPolicyNoHost) {
   auto* ep1 = GetEndpoint(0);
   ep1->allocator_->SetCandidateFilter(CF_ALL & ~CF_HOST);
 
-  std::unique_ptr<webrtc::MockAsyncDnsResolver> mock_async_resolver =
+  rtc::MockAsyncResolver mock_async_resolver;
-      std::make_unique<webrtc::MockAsyncDnsResolver>();
+  webrtc::MockAsyncResolverFactory mock_async_resolver_factory;
-  bool lookup_started = false;
-  EXPECT_CALL(*mock_async_resolver, Start(_, _))
-      .WillOnce(Assign(&lookup_started, true));
-
-  webrtc::MockAsyncDnsResolverFactory mock_async_resolver_factory;
   EXPECT_CALL(mock_async_resolver_factory, Create())
-      .WillOnce(
+      .WillOnce(Return(&mock_async_resolver));
-          [&mock_async_resolver]() { return std::move(mock_async_resolver); });
+  EXPECT_CALL(mock_async_resolver, Destroy(_));
 
-  ep1->async_dns_resolver_factory_ = &mock_async_resolver_factory;
+  ep1->async_resolver_factory_ = &mock_async_resolver_factory;
+
+  bool lookup_started = false;
+  EXPECT_CALL(mock_async_resolver, Start(_))
+      .WillOnce(Assign(&lookup_started, true));
 
   CreateChannels();
 

pc/BUILD.gn

@@ -77,7 +77,6 @@ rtc_library("rtc_pc_base") {
   deps = [
     ":media_protocol_names",
     "../api:array_view",
-    "../api:async_dns_resolver",
     "../api:audio_options_api",
     "../api:call_api",
     "../api:function_view",
@@ -237,7 +236,6 @@ rtc_library("peerconnection") {
     ":video_track",
     ":video_track_source",
     "../api:array_view",
-    "../api:async_dns_resolver",
     "../api:audio_options_api",
     "../api:call_api",
     "../api:callfactory_api",

pc/jsep_transport_controller.cc

@@ -39,11 +39,11 @@ namespace webrtc {
 JsepTransportController::JsepTransportController(
     rtc::Thread* network_thread,
     cricket::PortAllocator* port_allocator,
-    AsyncDnsResolverFactoryInterface* async_dns_resolver_factory,
+    AsyncResolverFactory* async_resolver_factory,
     Config config)
     : network_thread_(network_thread),
       port_allocator_(port_allocator),
-      async_dns_resolver_factory_(async_dns_resolver_factory),
+      async_resolver_factory_(async_resolver_factory),
       config_(config),
       active_reset_srtp_params_(config.active_reset_srtp_params) {
   // The |transport_observer| is assumed to be non-null.
@@ -398,7 +398,7 @@ JsepTransportController::CreateIceTransport(const std::string& transport_name,
 
   IceTransportInit init;
   init.set_port_allocator(port_allocator_);
-  init.set_async_dns_resolver_factory(async_dns_resolver_factory_);
+  init.set_async_resolver_factory(async_resolver_factory_);
   init.set_event_log(config_.event_log);
   return config_.ice_transport_factory->CreateIceTransport(
       transport_name, component, std::move(init));

pc/jsep_transport_controller.h

@@ -21,7 +21,7 @@
 #include <vector>
 
 #include "absl/types/optional.h"
-#include "api/async_dns_resolver.h"
+#include "api/async_resolver_factory.h"
 #include "api/candidate.h"
 #include "api/crypto/crypto_options.h"
 #include "api/ice_transport_factory.h"
@@ -140,10 +140,9 @@ class JsepTransportController : public sigslot::has_slots<> {
   // All the transport related methods are called on the |network_thread|
   // and destruction of the JsepTransportController must occur on the
   // |network_thread|.
-  JsepTransportController(
+  JsepTransportController(rtc::Thread* network_thread,
-      rtc::Thread* network_thread,
                           cricket::PortAllocator* port_allocator,
-      AsyncDnsResolverFactoryInterface* async_dns_resolver_factory,
+                          AsyncResolverFactory* async_resolver_factory,
                           Config config);
   virtual ~JsepTransportController();
 
@@ -462,7 +461,7 @@ class JsepTransportController : public sigslot::has_slots<> {
 
   rtc::Thread* const network_thread_ = nullptr;
   cricket::PortAllocator* const port_allocator_ = nullptr;
-  AsyncDnsResolverFactoryInterface* const async_dns_resolver_factory_ = nullptr;
+  AsyncResolverFactory* const async_resolver_factory_ = nullptr;
 
   std::map<std::string, std::unique_ptr<cricket::JsepTransport>>
       jsep_transports_by_name_ RTC_GUARDED_BY(network_thread_);

pc/peer_connection.cc

@@ -12,7 +12,6 @@
 
 #include <limits.h>
 #include <stddef.h>
-
 #include <algorithm>
 #include <memory>
 #include <set>
@@ -34,7 +33,6 @@
 #include "media/base/rid_description.h"
 #include "media/base/stream_params.h"
 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
-#include "p2p/base/basic_async_resolver_factory.h"
 #include "p2p/base/connection.h"
 #include "p2p/base/connection_info.h"
 #include "p2p/base/dtls_transport_internal.h"
@@ -437,30 +435,6 @@ RTCErrorOr<rtc::scoped_refptr<PeerConnection>> PeerConnection::Create(
   bool is_unified_plan =
       configuration.sdp_semantics == SdpSemantics::kUnifiedPlan;
   bool dtls_enabled = DtlsEnabled(configuration, options, dependencies);
-
-  // 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.
-  // TODO(bugs.webrtc.org/12598): Remove code once all callers pass a
-  // AsyncDnsResolverFactory.
-  if (dependencies.async_dns_resolver_factory &&
-      dependencies.async_resolver_factory) {
-    RTC_LOG(LS_ERROR)
-        << "Attempt to set both old and new type of DNS resolver factory";
-    return RTCError(RTCErrorType::INVALID_PARAMETER,
-                    "Both old and new type of DNS resolver given");
-  }
-  if (dependencies.async_resolver_factory) {
-    dependencies.async_dns_resolver_factory =
-        std::make_unique<WrappingAsyncDnsResolverFactory>(
-            std::move(dependencies.async_resolver_factory));
-  } else {
-    dependencies.async_dns_resolver_factory =
-        std::make_unique<WrappingAsyncDnsResolverFactory>(
-            std::make_unique<BasicAsyncResolverFactory>());
-  }
-
   // The PeerConnection constructor consumes some, but not all, dependencies.
   rtc::scoped_refptr<PeerConnection> pc(
       new rtc::RefCountedObject<PeerConnection>(
@@ -488,8 +462,7 @@ PeerConnection::PeerConnection(
       is_unified_plan_(is_unified_plan),
       event_log_(std::move(event_log)),
       event_log_ptr_(event_log_.get()),
-      async_dns_resolver_factory_(
+      async_resolver_factory_(std::move(dependencies.async_resolver_factory)),
-          std::move(dependencies.async_dns_resolver_factory)),
       port_allocator_(std::move(dependencies.allocator)),
       ice_transport_factory_(std::move(dependencies.ice_transport_factory)),
       tls_cert_verifier_(std::move(dependencies.tls_cert_verifier)),
@@ -698,7 +671,7 @@ void PeerConnection::InitializeTransportController_n(
 
   transport_controller_.reset(
       new JsepTransportController(network_thread(), port_allocator_.get(),
-                                  async_dns_resolver_factory_.get(), config));
+                                  async_resolver_factory_.get(), config));
 
   transport_controller_->SubscribeIceConnectionState(
       [this](cricket::IceConnectionState s) {

pc/peer_connection.h

@@ -23,7 +23,6 @@
 
 #include "absl/types/optional.h"
 #include "api/adaptation/resource.h"
-#include "api/async_dns_resolver.h"
 #include "api/async_resolver_factory.h"
 #include "api/audio_options.h"
 #include "api/candidate.h"
@@ -636,8 +635,11 @@ class PeerConnection : public PeerConnectionInternal,
   PeerConnectionInterface::RTCConfiguration configuration_
       RTC_GUARDED_BY(signaling_thread());
 
-  const std::unique_ptr<AsyncDnsResolverFactoryInterface>
+  // TODO(zstein): |async_resolver_factory_| can currently be nullptr if it
-      async_dns_resolver_factory_;
+  // is not injected. It should be required once chromium supplies it.
+  // This member variable is only used by JsepTransportController so we should
+  // consider moving ownership to there.
+  const std::unique_ptr<AsyncResolverFactory> async_resolver_factory_;
   std::unique_ptr<cricket::PortAllocator>
       port_allocator_;  // TODO(bugs.webrtc.org/9987): Accessed on both
                         // signaling and network thread.