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}
diff --git a/api/BUILD.gn b/api/BUILD.gn
index 4f729d5..4274014 100644
--- a/api/BUILD.gn
+++ b/api/BUILD.gn
@@ -160,7 +160,6 @@
]
deps = [
":array_view",
- ":async_dns_resolver",
":audio_options_api",
":callfactory_api",
":fec_controller_api",
@@ -250,11 +249,11 @@
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("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 @@
]
}
- 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 @@
":dummy_peer_connection",
":fake_frame_decryptor",
":fake_frame_encryptor",
- ":mock_async_dns_resolver",
":mock_audio_mixer",
":mock_data_channel",
":mock_frame_decryptor",
diff --git a/api/async_dns_resolver.h b/api/async_dns_resolver.h
index eabb41c..800ffa6 100644
--- a/api/async_dns_resolver.h
+++ b/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"
diff --git a/api/ice_transport_factory.cc b/api/ice_transport_factory.cc
index d507812..c9a0a6a 100644
--- a/api/ice_transport_factory.cc
+++ b/api/ice_transport_factory.cc
@@ -58,18 +58,10 @@
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()));
- }
+ 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()));
}
} // namespace webrtc
diff --git a/api/ice_transport_interface.h b/api/ice_transport_interface.h
index a58b37d..d2f1edc 100644
--- a/api/ice_transport_interface.h
+++ b/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 @@
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 @@
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;
};
diff --git a/api/peer_connection_interface.h b/api/peer_connection_interface.h
index 17d9004..cc65592 100644
--- a/api/peer_connection_interface.h
+++ b/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 @@
// 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;
diff --git a/api/test/compile_all_headers.cc b/api/test/compile_all_headers.cc
index 5ecdcc1..6f06742 100644
--- a/api/test/compile_all_headers.cc
+++ b/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"
diff --git a/api/test/mock_async_dns_resolver.h b/api/test/mock_async_dns_resolver.h
deleted file mode 100644
index e863cac..0000000
--- a/api/test/mock_async_dns_resolver.h
+++ /dev/null
@@ -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_
diff --git a/p2p/BUILD.gn b/p2p/BUILD.gn
index 1174465..e2ba8ca 100644
--- a/p2p/BUILD.gn
+++ b/p2p/BUILD.gn
@@ -86,8 +86,6 @@
]
deps = [
- "../api:array_view",
- "../api:async_dns_resolver",
"../api:libjingle_peerconnection_api",
"../api:packet_socket_factory",
"../api:rtc_error",
@@ -95,7 +93,6 @@
"../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 @@
":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",
diff --git a/p2p/base/basic_async_resolver_factory.cc b/p2p/base/basic_async_resolver_factory.cc
index 33bb085..67dd18f 100644
--- a/p2p/base/basic_async_resolver_factory.cc
+++ b/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 {
diff --git a/p2p/base/basic_async_resolver_factory.h b/p2p/base/basic_async_resolver_factory.h
index c988913..9042744 100644
--- a/p2p/base/basic_async_resolver_factory.h
+++ b/p2p/base/basic_async_resolver_factory.h
@@ -32,15 +32,9 @@
class WrappingAsyncDnsResolverFactory final
: public AsyncDnsResolverFactoryInterface {
public:
- explicit WrappingAsyncDnsResolverFactory(
+ WrappingAsyncDnsResolverFactory(
std::unique_ptr<AsyncResolverFactory> wrapped_factory)
- : owned_factory_(std::move(wrapped_factory)),
- wrapped_factory_(owned_factory_.get()) {}
-
- explicit WrappingAsyncDnsResolverFactory(
- AsyncResolverFactory* non_owned_factory)
- : wrapped_factory_(non_owned_factory) {}
-
+ : wrapped_factory_(std::move(wrapped_factory)) {}
std::unique_ptr<webrtc::AsyncDnsResolverInterface> CreateAndResolve(
const rtc::SocketAddress& addr,
std::function<void()> callback) override;
@@ -48,8 +42,7 @@
std::unique_ptr<webrtc::AsyncDnsResolverInterface> Create() override;
private:
- const std::unique_ptr<AsyncResolverFactory> owned_factory_;
- AsyncResolverFactory* const wrapped_factory_;
+ const std::unique_ptr<AsyncResolverFactory> wrapped_factory_;
};
} // namespace webrtc
diff --git a/p2p/base/default_ice_transport_factory.cc b/p2p/base/default_ice_transport_factory.cc
index 7d2fdb8..f4b182e 100644
--- a/p2p/base/default_ice_transport_factory.cc
+++ b/p2p/base/default_ice_transport_factory.cc
@@ -45,9 +45,9 @@
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
diff --git a/p2p/base/p2p_transport_channel.cc b/p2p/base/p2p_transport_channel.cc
index 1efe717..19e172a 100644
--- a/p2p/base/p2p_transport_channel.cc
+++ b/p2p/base/p2p_transport_channel.cc
@@ -10,38 +10,27 @@
#include "p2p/base/p2p_transport_channel.h"
-#include <errno.h>
-#include <stdlib.h>
-
-#include <algorithm>
-#include <functional>
+#include <iterator>
#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/network_constants.h"
+#include "rtc_base/net_helpers.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 @@
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,
- /* owned_dns_resolver_factory= */ nullptr,
- /* event_log= */ nullptr,
- /* ice_controller_factory= */ nullptr) {}
+ nullptr,
+ nullptr) {}
-// Private constructor, called from Create()
P2PTransportChannel::P2PTransportChannel(
const std::string& transport_name,
int component,
PortAllocator* allocator,
- webrtc::AsyncDnsResolverFactoryInterface* async_dns_resolver_factory,
- std::unique_ptr<webrtc::AsyncDnsResolverFactoryInterface>
- owned_dns_resolver_factory,
+ webrtc::AsyncResolverFactory* async_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
- // 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)),
+ async_resolver_factory_(async_resolver_factory),
network_thread_(rtc::Thread::Current()),
incoming_only_(false),
error_(0),
@@ -227,31 +192,15 @@
}
}
-// 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::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();
- auto resptr = resolver.get();
- resolvers_.emplace_back(candidate, std::move(resolver));
- resptr->Start(candidate.address(),
- [this, resptr]() { OnCandidateResolved(resptr); });
+ rtc::AsyncResolverInterface* resolver = async_resolver_factory_->Create();
+ resolvers_.emplace_back(candidate, resolver);
+ resolver->SignalDone.connect(this, &P2PTransportChannel::OnCandidateResolved);
+ resolver->Start(candidate.address());
RTC_LOG(LS_INFO) << "Asynchronously resolving ICE candidate hostname "
<< candidate.address().HostAsSensitiveURIString();
}
@@ -1280,37 +1228,38 @@
P2PTransportChannel::CandidateAndResolver::CandidateAndResolver(
const Candidate& candidate,
- std::unique_ptr<webrtc::AsyncDnsResolverInterface>&& resolver)
- : candidate_(candidate), resolver_(std::move(resolver)) {}
+ rtc::AsyncResolverInterface* 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 @@
// 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) ||
- result.GetResolvedAddress(AF_INET, &resolved_address);
+ bool have_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()
diff --git a/p2p/base/p2p_transport_channel.h b/p2p/base/p2p_transport_channel.h
index 462aa10..1e93942 100644
--- a/p2p/base/p2p_transport_channel.h
+++ b/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 @@
// 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 @@
}
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 @@
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 @@
RTC_GUARDED_BY(network_thread_);
struct CandidateAndResolver final {
- CandidateAndResolver(
- const Candidate& candidate,
- std::unique_ptr<webrtc::AsyncDnsResolverInterface>&& resolver);
+ CandidateAndResolver(const Candidate& candidate,
+ rtc::AsyncResolverInterface* 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 AddRemoteCandidateWithResult(
- Candidate candidate,
- const webrtc::AsyncDnsResolverResult& result);
+ void OnCandidateResolved(rtc::AsyncResolverInterface* resolver);
+ void AddRemoteCandidateWithResolver(Candidate candidate,
+ rtc::AsyncResolverInterface* resolver);
// Number of times the selected_connection_ has been modified.
uint32_t selected_candidate_pair_changes_ = 0;
diff --git a/p2p/base/p2p_transport_channel_unittest.cc b/p2p/base/p2p_transport_channel_unittest.cc
index 19ba370..3ea9ca7 100644
--- a/p2p/base/p2p_transport_channel_unittest.cc
+++ b/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::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 @@
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 @@
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 @@
IceParamsWithRenomination(kIceParams[0], renomination);
IceParameters ice_ep2_cd1_ch =
IceParamsWithRenomination(kIceParams[1], renomination);
- ep1_.cd1_.ch_ = CreateChannel(0, ICE_CANDIDATE_COMPONENT_DEFAULT,
- ice_ep1_cd1_ch, ice_ep2_cd1_ch);
- ep2_.cd1_.ch_ = CreateChannel(1, ICE_CANDIDATE_COMPONENT_DEFAULT,
- ice_ep2_cd1_ch, ice_ep1_cd1_ch);
+ ep1_.cd1_.ch_.reset(CreateChannel(0, ICE_CANDIDATE_COMPONENT_DEFAULT,
+ ice_ep1_cd1_ch, ice_ep2_cd1_ch));
+ ep2_.cd1_.ch_.reset(CreateChannel(1, ICE_CANDIDATE_COMPONENT_DEFAULT,
+ 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 @@
CreateChannels(default_config, default_config, false);
}
- std::unique_ptr<P2PTransportChannel> CreateChannel(
- int endpoint,
- int component,
- const IceParameters& local_ice,
- const IceParameters& remote_ice) {
- auto channel = P2PTransportChannel::Create(
+ P2PTransportChannel* CreateChannel(int endpoint,
+ int component,
+ const IceParameters& local_ice,
+ const IceParameters& remote_ice) {
+ 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 @@
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,
- kIceParams[0], kIceParams[1]);
+ GetEndpoint(0)->cd1_.ch_.reset(CreateChannel(
+ 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_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,
- kIceParams[0], kIceParams[1]);
- GetEndpoint(1)->cd1_.ch_ = CreateChannel(1, ICE_CANDIDATE_COMPONENT_DEFAULT,
- kIceParams[1], kIceParams[0]);
+ GetEndpoint(0)->cd1_.ch_.reset(CreateChannel(
+ 0, ICE_CANDIDATE_COMPONENT_DEFAULT, kIceParams[0], kIceParams[1]));
+ GetEndpoint(1)->cd1_.ch_.reset(CreateChannel(
+ 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 @@
kDefaultPortAllocatorFlags);
IceConfig config;
config.presume_writable_when_fully_relayed = true;
- GetEndpoint(0)->cd1_.ch_ = CreateChannel(0, ICE_CANDIDATE_COMPONENT_DEFAULT,
- kIceParams[0], kIceParams[1]);
- GetEndpoint(1)->cd1_.ch_ = CreateChannel(1, ICE_CANDIDATE_COMPONENT_DEFAULT,
- kIceParams[1], kIceParams[0]);
+ GetEndpoint(0)->cd1_.ch_.reset(CreateChannel(
+ 0, ICE_CANDIDATE_COMPONENT_DEFAULT, kIceParams[0], kIceParams[1]));
+ GetEndpoint(1)->cd1_.ch_.reset(CreateChannel(
+ 1, ICE_CANDIDATE_COMPONENT_DEFAULT, kIceParams[1], kIceParams[0]));
ep1_ch1()->SetIceConfig(config);
ep2_ch1()->SetIceConfig(config);
ep1_ch1()->MaybeStartGathering();
@@ -2255,8 +2205,8 @@
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,
- kIceParams[0], kIceParams[1]);
+ GetEndpoint(0)->cd1_.ch_.reset(CreateChannel(
+ 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 @@
// 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,
- kIceParams[0], kIceParams[1]);
- GetEndpoint(1)->cd1_.ch_ = CreateChannel(1, ICE_CANDIDATE_COMPONENT_DEFAULT,
- kIceParams[1], kIceParams[0]);
+ GetEndpoint(0)->cd1_.ch_.reset(CreateChannel(
+ 0, ICE_CANDIDATE_COMPONENT_DEFAULT, kIceParams[0], kIceParams[1]));
+ GetEndpoint(1)->cd1_.ch_.reset(CreateChannel(
+ 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 @@
// 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::Create("tn", 0, &allocator, &resolver_fixture);
+ P2PTransportChannel channel("tn", 0, &allocator,
+ &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);
- const RemoteCandidate& candidate = channel->remote_candidates()[0];
+ ASSERT_EQ_WAIT(1u, channel.remote_candidates().size(), kDefaultTimeout);
+ 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 @@
// 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 @@
set_remote_ice_parameter_source(FROM_SETICEPARAMETERS);
GetEndpoint(0)->network_manager_.set_mdns_responder(
std::make_unique<webrtc::FakeMdnsResponder>(rtc::Thread::Current()));
-
- ResolverFactoryFixture resolver_fixture;
- 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.
@@ -4928,7 +4894,6 @@
// 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 @@
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 @@
kMediumTimeout);
EXPECT_EQ(selected_connection, ep2_ch1()->selected_connection());
+ WAIT(destroy_called, kShortTimeout);
DestroyChannels();
}
@@ -4961,9 +4939,13 @@
// address after the resolution completes.
TEST_F(P2PTransportChannelTest,
PeerReflexiveCandidateDuringResolvingHostCandidateWithMdnsName) {
- ResolverFactoryFixture resolver_fixture;
- // Prevent resolution until triggered by FireDelayedResolution.
- resolver_fixture.DelayResolution();
+ auto mock_async_resolver = new NiceMock<rtc::MockAsyncResolver>();
+ ON_CALL(*mock_async_resolver, Destroy).WillByDefault([mock_async_resolver] {
+ 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 @@
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 @@
// 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 @@
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.
-
- resolver_fixture.FireDelayedResolution();
-
+ mock_async_resolver->SignalDone(mock_async_resolver);
EXPECT_EQ_WAIT(LOCAL_PORT_TYPE,
ep2_ch1()->selected_connection()->remote_candidate().type(),
kMediumTimeout);
@@ -5023,7 +5010,10 @@
// 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 @@
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 @@
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 @@
// 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 @@
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 @@
// 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 @@
// 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 @@
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 @@
// 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 @@
// 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,
- kIceParams[0], kIceParams[1]);
+ GetEndpoint(0)->cd1_.ch_.reset(CreateChannel(
+ 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 @@
TEST_F(P2PTransportChannelPingTest, TestForgetLearnedState) {
ForgetLearnedStateControllerFactory factory;
FakePortAllocator pa(rtc::Thread::Current(), nullptr);
- auto ch = P2PTransportChannel::Create("ping sufficiently", 1, &pa, nullptr,
- nullptr, &factory);
- PrepareChannel(ch.get());
- ch->MaybeStartGathering();
- ch->AddRemoteCandidate(CreateUdpCandidate(LOCAL_PORT_TYPE, "1.1.1.1", 1, 1));
- ch->AddRemoteCandidate(CreateUdpCandidate(LOCAL_PORT_TYPE, "2.2.2.2", 2, 2));
+ P2PTransportChannel ch("ping sufficiently", 1, &pa, nullptr, nullptr,
+ &factory);
+ PrepareChannel(&ch);
+ ch.MaybeStartGathering();
+ ch.AddRemoteCandidate(CreateUdpCandidate(LOCAL_PORT_TYPE, "1.1.1.1", 1, 1));
+ ch.AddRemoteCandidate(CreateUdpCandidate(LOCAL_PORT_TYPE, "2.2.2.2", 2, 2));
- Connection* conn1 = WaitForConnectionTo(ch.get(), "1.1.1.1", 1);
- Connection* conn2 = WaitForConnectionTo(ch.get(), "2.2.2.2", 2);
+ Connection* conn1 = WaitForConnectionTo(&ch, "1.1.1.1", 1);
+ 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 @@
auto* ep1 = GetEndpoint(0);
ep1->allocator_->SetCandidateFilter(CF_RELAY);
- std::unique_ptr<webrtc::MockAsyncDnsResolver> mock_async_resolver =
- std::make_unique<webrtc::MockAsyncDnsResolver>();
- // This test expects resolution to not be started.
- EXPECT_CALL(*mock_async_resolver, Start(_, _)).Times(0);
-
- webrtc::MockAsyncDnsResolverFactory mock_async_resolver_factory;
+ rtc::MockAsyncResolver mock_async_resolver;
+ webrtc::MockAsyncResolverFactory mock_async_resolver_factory;
ON_CALL(mock_async_resolver_factory, Create())
- .WillByDefault(
- [&mock_async_resolver]() { return std::move(mock_async_resolver); });
+ .WillByDefault(Return(&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 @@
auto* ep1 = GetEndpoint(0);
ep1->allocator_->SetCandidateFilter(CF_NONE);
- std::unique_ptr<webrtc::MockAsyncDnsResolver> mock_async_resolver =
- std::make_unique<webrtc::MockAsyncDnsResolver>();
- // This test expects resolution to not be started.
- EXPECT_CALL(*mock_async_resolver, Start(_, _)).Times(0);
-
- webrtc::MockAsyncDnsResolverFactory mock_async_resolver_factory;
+ rtc::MockAsyncResolver mock_async_resolver;
+ webrtc::MockAsyncResolverFactory mock_async_resolver_factory;
ON_CALL(mock_async_resolver_factory, Create())
- .WillByDefault(
- [&mock_async_resolver]() { return std::move(mock_async_resolver); });
+ .WillByDefault(Return(&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 @@
auto* ep1 = GetEndpoint(0);
ep1->allocator_->SetCandidateFilter(CF_ALL & ~CF_HOST);
- std::unique_ptr<webrtc::MockAsyncDnsResolver> mock_async_resolver =
- std::make_unique<webrtc::MockAsyncDnsResolver>();
- bool lookup_started = false;
- EXPECT_CALL(*mock_async_resolver, Start(_, _))
- .WillOnce(Assign(&lookup_started, true));
-
- webrtc::MockAsyncDnsResolverFactory mock_async_resolver_factory;
+ rtc::MockAsyncResolver mock_async_resolver;
+ webrtc::MockAsyncResolverFactory mock_async_resolver_factory;
EXPECT_CALL(mock_async_resolver_factory, Create())
- .WillOnce(
- [&mock_async_resolver]() { return std::move(mock_async_resolver); });
+ .WillOnce(Return(&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();
diff --git a/pc/BUILD.gn b/pc/BUILD.gn
index bf97834..4cdefd4 100644
--- a/pc/BUILD.gn
+++ b/pc/BUILD.gn
@@ -77,7 +77,6 @@
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 @@
":video_track",
":video_track_source",
"../api:array_view",
- "../api:async_dns_resolver",
"../api:audio_options_api",
"../api:call_api",
"../api:callfactory_api",
diff --git a/pc/jsep_transport_controller.cc b/pc/jsep_transport_controller.cc
index 757508a..be93cd8 100644
--- a/pc/jsep_transport_controller.cc
+++ b/pc/jsep_transport_controller.cc
@@ -39,11 +39,11 @@
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 @@
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));
diff --git a/pc/jsep_transport_controller.h b/pc/jsep_transport_controller.h
index 5680585..949c9ad 100644
--- a/pc/jsep_transport_controller.h
+++ b/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,11 +140,10 @@
// All the transport related methods are called on the |network_thread|
// and destruction of the JsepTransportController must occur on the
// |network_thread|.
- JsepTransportController(
- rtc::Thread* network_thread,
- cricket::PortAllocator* port_allocator,
- AsyncDnsResolverFactoryInterface* async_dns_resolver_factory,
- Config config);
+ JsepTransportController(rtc::Thread* network_thread,
+ cricket::PortAllocator* port_allocator,
+ AsyncResolverFactory* async_resolver_factory,
+ Config config);
virtual ~JsepTransportController();
// The main method to be called; applies a description at the transport
@@ -462,7 +461,7 @@
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_);
diff --git a/pc/peer_connection.cc b/pc/peer_connection.cc
index 6c8b273..e3a4b27 100644
--- a/pc/peer_connection.cc
+++ b/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 @@
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 @@
is_unified_plan_(is_unified_plan),
event_log_(std::move(event_log)),
event_log_ptr_(event_log_.get()),
- async_dns_resolver_factory_(
- std::move(dependencies.async_dns_resolver_factory)),
+ async_resolver_factory_(std::move(dependencies.async_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 @@
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) {
diff --git a/pc/peer_connection.h b/pc/peer_connection.h
index c49c541..98c5519 100644
--- a/pc/peer_connection.h
+++ b/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 @@
PeerConnectionInterface::RTCConfiguration configuration_
RTC_GUARDED_BY(signaling_thread());
- const std::unique_ptr<AsyncDnsResolverFactoryInterface>
- async_dns_resolver_factory_;
+ // TODO(zstein): |async_resolver_factory_| can currently be nullptr if it
+ // 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.
