admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Convert AsyncDnsResolver to use absl::AnyInvocable

Browse Source 
Bug: webrtc:12598
Change-Id: I0950231d6de7cf53116a573dcd97a3cf5514946c
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/318400
Commit-Queue: Harald Alvestrand <hta@webrtc.org>
Reviewed-by: Tomas Gunnarsson <tommi@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#40670}
This commit is contained in:
Harald Alvestrand 2023-08-30 19:39:05 +00:00 committed by WebRTC LUCI CQ
parent 047f656993
commit 96e1882860
12 changed files with 63 additions and 45 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
api/BUILD.gn
View File

@ -410,6 +410,7 @@ rtc_source_set("async_dns_resolver") {
"../rtc_base:socket_address",
"../rtc_base/system:rtc_export",
]
absl_deps = [ "//third_party/abseil-cpp/absl/functional:any_invocable" ]
}
rtc_source_set("wrapping_async_dns_resolver") {

9
api/async_dns_resolver.h
View File

@ -14,6 +14,7 @@
#include <functional>
#include <memory>
#include "absl/functional/any_invocable.h"
#include "rtc_base/checks.h"
#include "rtc_base/socket_address.h"
#include "rtc_base/system/rtc_export.h"
@ -63,11 +64,11 @@ class RTC_EXPORT AsyncDnsResolverInterface {
// Start address resolution of the hostname in `addr`.
virtual void Start(const rtc::SocketAddress& addr,
std::function<void()> callback) = 0;
absl::AnyInvocable<void()> callback) = 0;
// Start address resolution of the hostname in `addr` matching `family`.
virtual void Start(const rtc::SocketAddress& addr,
int family,
std::function<void()> callback) = 0;
absl::AnyInvocable<void()> callback) = 0;
virtual const AsyncDnsResolverResult& result() const = 0;
};
@ -83,7 +84,7 @@ class AsyncDnsResolverFactoryInterface {
// The callback will be called on the sequence that the caller runs on.
virtual std::unique_ptr<webrtc::AsyncDnsResolverInterface> CreateAndResolve(
const rtc::SocketAddress& addr,
std::function<void()> callback) = 0;
absl::AnyInvocable<void()> callback) = 0;
// Creates an AsyncDnsResolver and starts resolving the name to an address
// matching the specified family. The callback will be called when resolution
// is finished. The callback will be called on the sequence that the caller
@ -91,7 +92,7 @@ class AsyncDnsResolverFactoryInterface {
virtual std::unique_ptr<webrtc::AsyncDnsResolverInterface> CreateAndResolve(
const rtc::SocketAddress& addr,
int family,
std::function<void()> callback) = 0;
absl::AnyInvocable<void()> callback) = 0;
// Creates an AsyncDnsResolver and does not start it.
// For backwards compatibility, will be deprecated and removed.
// One has to do a separate Start() call on the

10
api/test/mock_async_dns_resolver.h
View File

@ -32,11 +32,13 @@ class MockAsyncDnsResolver : public AsyncDnsResolverInterface {
public:
MOCK_METHOD(void,
Start,
(const rtc::SocketAddress&, std::function<void()>),
(const rtc::SocketAddress&, absl::AnyInvocable<void()>),
(override));
MOCK_METHOD(void,
Start,
(const rtc::SocketAddress&, int family, std::function<void()>),
(const rtc::SocketAddress&,
int family,
absl::AnyInvocable<void()>),
(override));
MOCK_METHOD(AsyncDnsResolverResult&, result, (), (const, override));
};
@ -45,11 +47,11 @@ class MockAsyncDnsResolverFactory : public AsyncDnsResolverFactoryInterface {
public:
MOCK_METHOD(std::unique_ptr<webrtc::AsyncDnsResolverInterface>,
CreateAndResolve,
(const rtc::SocketAddress&, std::function<void()>),
(const rtc::SocketAddress&, absl::AnyInvocable<void()>),
(override));
MOCK_METHOD(std::unique_ptr<webrtc::AsyncDnsResolverInterface>,
CreateAndResolve,
(const rtc::SocketAddress&, int, std::function<void()>),
(const rtc::SocketAddress&, int, absl::AnyInvocable<void()>),
(override));
MOCK_METHOD(std::unique_ptr<webrtc::AsyncDnsResolverInterface>,
Create,

8
api/wrapping_async_dns_resolver.h
View File

@ -67,7 +67,7 @@ class RTC_EXPORT WrappingAsyncDnsResolver : public AsyncDnsResolverInterface,
}
void Start(const rtc::SocketAddress& addr,
std::function<void()> callback) override {
absl::AnyInvocable<void()> callback) override {
RTC_DCHECK_RUN_ON(&sequence_checker_);
PrepareToResolve(std::move(callback));
wrapped_->Start(addr);
@ -75,7 +75,7 @@ class RTC_EXPORT WrappingAsyncDnsResolver : public AsyncDnsResolverInterface,
void Start(const rtc::SocketAddress& addr,
int family,
std::function<void()> callback) override {
absl::AnyInvocable<void()> callback) override {
RTC_DCHECK_RUN_ON(&sequence_checker_);
PrepareToResolve(std::move(callback));
wrapped_->Start(addr, family);
@ -97,7 +97,7 @@ class RTC_EXPORT WrappingAsyncDnsResolver : public AsyncDnsResolverInterface,
return wrapped_.get();
}
void PrepareToResolve(std::function<void()> callback) {
void PrepareToResolve(absl::AnyInvocable<void()> callback) {
RTC_DCHECK_RUN_ON(&sequence_checker_);
RTC_DCHECK_EQ(State::kNotStarted, state_);
state_ = State::kStarted;
@ -118,7 +118,7 @@ class RTC_EXPORT WrappingAsyncDnsResolver : public AsyncDnsResolverInterface,
// The class variables need to be accessed on a single thread.
SequenceChecker sequence_checker_;
std::function<void()> callback_ RTC_GUARDED_BY(sequence_checker_);
absl::AnyInvocable<void()> callback_ RTC_GUARDED_BY(sequence_checker_);
std::unique_ptr<rtc::AsyncResolverInterface> wrapped_
RTC_GUARDED_BY(sequence_checker_);
State state_ RTC_GUARDED_BY(sequence_checker_) = State::kNotStarted;

16
p2p/base/basic_async_resolver_factory.cc
View File

@ -32,17 +32,19 @@ BasicAsyncDnsResolverFactory::Create() {
}
std::unique_ptr<webrtc::AsyncDnsResolverInterface>
BasicAsyncDnsResolverFactory::CreateAndResolve(const rtc::SocketAddress& addr,
std::function<void()> callback) {
BasicAsyncDnsResolverFactory::CreateAndResolve(
const rtc::SocketAddress& addr,
absl::AnyInvocable<void()> callback) {
std::unique_ptr<webrtc::AsyncDnsResolverInterface> resolver = Create();
resolver->Start(addr, std::move(callback));
return resolver;
}
std::unique_ptr<webrtc::AsyncDnsResolverInterface>
BasicAsyncDnsResolverFactory::CreateAndResolve(const rtc::SocketAddress& addr,
int family,
std::function<void()> callback) {
BasicAsyncDnsResolverFactory::CreateAndResolve(
const rtc::SocketAddress& addr,
int family,
absl::AnyInvocable<void()> callback) {
std::unique_ptr<webrtc::AsyncDnsResolverInterface> resolver = Create();
resolver->Start(addr, family, std::move(callback));
return resolver;
@ -56,7 +58,7 @@ WrappingAsyncDnsResolverFactory::Create() {
std::unique_ptr<webrtc::AsyncDnsResolverInterface>
WrappingAsyncDnsResolverFactory::CreateAndResolve(
const rtc::SocketAddress& addr,
std::function<void()> callback) {
absl::AnyInvocable<void()> callback) {
std::unique_ptr<webrtc::AsyncDnsResolverInterface> resolver = Create();
resolver->Start(addr, std::move(callback));
return resolver;
@ -66,7 +68,7 @@ std::unique_ptr<webrtc::AsyncDnsResolverInterface>
WrappingAsyncDnsResolverFactory::CreateAndResolve(
const rtc::SocketAddress& addr,
int family,
std::function<void()> callback) {
absl::AnyInvocable<void()> callback) {
std::unique_ptr<webrtc::AsyncDnsResolverInterface> resolver = Create();
resolver->Start(addr, family, std::move(callback));
return resolver;

8
p2p/base/basic_async_resolver_factory.h
View File

@ -34,12 +34,12 @@ class BasicAsyncDnsResolverFactory final
std::unique_ptr<webrtc::AsyncDnsResolverInterface> CreateAndResolve(
const rtc::SocketAddress& addr,
std::function<void()> callback) override;
absl::AnyInvocable<void()> callback) override;
std::unique_ptr<webrtc::AsyncDnsResolverInterface> CreateAndResolve(
const rtc::SocketAddress& addr,
int family,
std::function<void()> callback) override;
absl::AnyInvocable<void()> callback) override;
std::unique_ptr<webrtc::AsyncDnsResolverInterface> Create() override;
};
@ -61,12 +61,12 @@ class WrappingAsyncDnsResolverFactory final
std::unique_ptr<webrtc::AsyncDnsResolverInterface> CreateAndResolve(
const rtc::SocketAddress& addr,
std::function<void()> callback) override;
absl::AnyInvocable<void()> callback) override;
std::unique_ptr<webrtc::AsyncDnsResolverInterface> CreateAndResolve(
const rtc::SocketAddress& addr,
int family,
std::function<void()> callback) override;
absl::AnyInvocable<void()> callback) override;
std::unique_ptr<webrtc::AsyncDnsResolverInterface> Create() override;

12
p2p/base/p2p_transport_channel_unittest.cc
View File

@ -63,7 +63,6 @@ using ::testing::Combine;
using ::testing::Contains;
using ::testing::DoAll;
using ::testing::InSequence;
using ::testing::InvokeArgument;
using ::testing::InvokeWithoutArgs;
using ::testing::MockFunction;
using ::testing::Return;
@ -203,7 +202,9 @@ class ResolverFactoryFixture : public webrtc::MockAsyncDnsResolverFactory {
ResolverFactoryFixture() {
mock_async_dns_resolver_ = std::make_unique<webrtc::MockAsyncDnsResolver>();
EXPECT_CALL(*mock_async_dns_resolver_, Start(_, _))
.WillRepeatedly(InvokeArgument<1>());
.WillRepeatedly(
[](const rtc::SocketAddress& addr,
absl::AnyInvocable<void()> callback) { callback(); });
EXPECT_CALL(*mock_async_dns_resolver_, result())
.WillOnce(ReturnRef(mock_async_dns_resolver_result_));
@ -227,7 +228,10 @@ class ResolverFactoryFixture : public webrtc::MockAsyncDnsResolverFactory {
// 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_));
.WillOnce([this](const rtc::SocketAddress& addr,
absl::AnyInvocable<void()> callback) {
saved_callback_ = std::move(callback);
});
}
void FireDelayedResolution() {
// This function must be called after Create().
@ -238,7 +242,7 @@ class ResolverFactoryFixture : public webrtc::MockAsyncDnsResolverFactory {
private:
std::unique_ptr<webrtc::MockAsyncDnsResolver> mock_async_dns_resolver_;
webrtc::MockAsyncDnsResolverResult mock_async_dns_resolver_result_;
std::function<void()> saved_callback_;
absl::AnyInvocable<void()> saved_callback_;
};
bool HasLocalAddress(const cricket::CandidatePairInterface* pair,

15
p2p/base/stun_port_unittest.cc
View File

@ -30,7 +30,6 @@ using cricket::ServerAddresses;
using rtc::SocketAddress;
using ::testing::_;
using ::testing::DoAll;
using ::testing::InvokeArgument;
using ::testing::Return;
using ::testing::ReturnPointee;
using ::testing::SetArgPointee;
@ -318,7 +317,9 @@ TEST_F(StunPortWithMockDnsResolverTest, TestPrepareAddressHostname) {
[](webrtc::MockAsyncDnsResolver* resolver,
webrtc::MockAsyncDnsResolverResult* resolver_result) {
EXPECT_CALL(*resolver, Start(kValidHostnameAddr, /*family=*/AF_INET, _))
.WillOnce(InvokeArgument<2>());
.WillOnce([](const rtc::SocketAddress& addr, int family,
absl::AnyInvocable<void()> callback) { callback(); });
EXPECT_CALL(*resolver, result)
.WillRepeatedly(ReturnPointee(resolver_result));
EXPECT_CALL(*resolver_result, GetError).WillOnce(Return(0));
@ -342,7 +343,8 @@ TEST_F(StunPortWithMockDnsResolverTest,
[](webrtc::MockAsyncDnsResolver* resolver,
webrtc::MockAsyncDnsResolverResult* resolver_result) {
EXPECT_CALL(*resolver, Start(kValidHostnameAddr, /*family=*/AF_INET, _))
.WillOnce(InvokeArgument<2>());
.WillOnce([](const rtc::SocketAddress& addr, int family,
absl::AnyInvocable<void()> callback) { callback(); });
EXPECT_CALL(*resolver, result)
.WillRepeatedly(ReturnPointee(resolver_result));
EXPECT_CALL(*resolver_result, GetError).WillOnce(Return(0));
@ -693,7 +695,9 @@ TEST_F(StunIPv6PortTestWithMockDnsResolver, TestPrepareAddressHostname) {
webrtc::MockAsyncDnsResolverResult* resolver_result) {
EXPECT_CALL(*resolver,
Start(kValidHostnameAddr, /*family=*/AF_INET6, _))
.WillOnce(InvokeArgument<2>());
.WillOnce([](const rtc::SocketAddress& addr, int family,
absl::AnyInvocable<void()> callback) { callback(); });
EXPECT_CALL(*resolver, result)
.WillRepeatedly(ReturnPointee(resolver_result));
EXPECT_CALL(*resolver_result, GetError).WillOnce(Return(0));
@ -719,7 +723,8 @@ TEST_F(StunIPv6PortTestWithMockDnsResolver,
webrtc::MockAsyncDnsResolverResult* resolver_result) {
EXPECT_CALL(*resolver,
Start(kValidHostnameAddr, /*family=*/AF_INET6, _))
.WillOnce(InvokeArgument<2>());
.WillOnce([](const rtc::SocketAddress& addr, int family,
absl::AnyInvocable<void()> callback) { callback(); });
EXPECT_CALL(*resolver, result)
.WillRepeatedly(ReturnPointee(resolver_result));
EXPECT_CALL(*resolver_result, GetError).WillOnce(Return(0));

7
p2p/base/turn_port_unittest.cc
View File

@ -50,7 +50,6 @@ using rtc::SocketAddress;
using ::testing::_;
using ::testing::DoAll;
using ::testing::InvokeArgument;
using ::testing::Return;
using ::testing::ReturnPointee;
using ::testing::SetArgPointee;
@ -1913,7 +1912,8 @@ TEST_F(TurnPortWithMockDnsResolverTest, TestHostnameResolved) {
[](webrtc::MockAsyncDnsResolver* resolver,
webrtc::MockAsyncDnsResolverResult* resolver_result) {
EXPECT_CALL(*resolver, Start(kTurnValidAddr, /*family=*/AF_INET, _))
.WillOnce(InvokeArgument<2>());
.WillOnce([](const rtc::SocketAddress& addr, int family,
absl::AnyInvocable<void()> callback) { callback(); });
EXPECT_CALL(*resolver, result)
.WillRepeatedly(ReturnPointee(resolver_result));
EXPECT_CALL(*resolver_result, GetError).WillRepeatedly(Return(0));
@ -1933,7 +1933,8 @@ TEST_F(TurnPortWithMockDnsResolverTest, TestHostnameResolvedIPv6Network) {
[](webrtc::MockAsyncDnsResolver* resolver,
webrtc::MockAsyncDnsResolverResult* resolver_result) {
EXPECT_CALL(*resolver, Start(kTurnValidAddr, /*family=*/AF_INET6, _))
.WillOnce(InvokeArgument<2>());
.WillOnce([](const rtc::SocketAddress& addr, int family,
absl::AnyInvocable<void()> callback) { callback(); });
EXPECT_CALL(*resolver, result)
.WillRepeatedly(ReturnPointee(resolver_result));
EXPECT_CALL(*resolver_result, GetError).WillRepeatedly(Return(0));

3
pc/test/integration_test_helpers.h
View File

@ -1132,7 +1132,8 @@ class PeerConnectionIntegrationWrapper : public webrtc::PeerConnectionObserver,
remote_async_dns_resolved_addr_ = local_candidate.address();
remote_async_dns_resolved_addr_.SetResolvedIP(resolved_ip);
EXPECT_CALL(*remote_async_dns_resolver_, Start(_, _))
.WillOnce(InvokeArgument<1>());
.WillOnce([](const rtc::SocketAddress& addr,
absl::AnyInvocable<void()> callback) { callback(); });
EXPECT_CALL(*remote_async_dns_resolver_, result())
.WillOnce(ReturnRef(remote_async_dns_resolver_result_));
EXPECT_CALL(remote_async_dns_resolver_result_, GetResolvedAddress(_, _))

14
rtc_base/async_dns_resolver.cc
View File

@ -99,28 +99,28 @@ void PostTaskToGlobalQueue(
} // namespace
void AsyncDnsResolver::Start(const rtc::SocketAddress& addr,
std::function<void()> callback) {
absl::AnyInvocable<void()> callback) {
Start(addr, addr.family(), std::move(callback));
}
// Start address resolution of the hostname in `addr` matching `family`.
void AsyncDnsResolver::Start(const rtc::SocketAddress& addr,
int family,
std::function<void()> callback) {
absl::AnyInvocable<void()> callback) {
RTC_DCHECK_RUN_ON(&result_.sequence_checker_);
result_.addr_ = addr;
callback_ = std::move(callback);
auto thread_function = [this, addr, family, flag = safety_.flag(),
caller_task_queue = webrtc::TaskQueueBase::Current(),
callback = std::move(callback)] {
caller_task_queue =
webrtc::TaskQueueBase::Current()] {
std::vector<rtc::IPAddress> addresses;
int error = ResolveHostname(addr.hostname(), family, addresses);
caller_task_queue->PostTask(
SafeTask(flag, [this, error, addresses = std::move(addresses),
callback = std::move(callback)] {
SafeTask(flag, [this, error, addresses = std::move(addresses)] {
RTC_DCHECK_RUN_ON(&result_.sequence_checker_);
result_.addresses_ = addresses;
result_.error_ = error;
callback();
callback_();
}));
};
#if defined(WEBRTC_MAC) || defined(WEBRTC_IOS)

5
rtc_base/async_dns_resolver.h
View File

@ -40,16 +40,17 @@ class AsyncDnsResolver : public AsyncDnsResolverInterface {
public:
// Start address resolution of the hostname in `addr`.
void Start(const rtc::SocketAddress& addr,
std::function<void()> callback) override;
absl::AnyInvocable<void()> callback) override;
// Start address resolution of the hostname in `addr` matching `family`.
void Start(const rtc::SocketAddress& addr,
int family,
std::function<void()> callback) override;
absl::AnyInvocable<void()> callback) override;
const AsyncDnsResolverResult& result() const override;
private:
ScopedTaskSafety safety_;
AsyncDnsResolverResultImpl result_;
absl::AnyInvocable<void()> callback_;
};
} // namespace webrtc