diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 17:32:43 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 17:32:43 +0000 |
commit | 6bf0a5cb5034a7e684dcc3500e841785237ce2dd (patch) | |
tree | a68f146d7fa01f0134297619fbe7e33db084e0aa /third_party/libwebrtc/api/wrapping_async_dns_resolver.h | |
parent | Initial commit. (diff) | |
download | thunderbird-upstream.tar.xz thunderbird-upstream.zip |
Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'third_party/libwebrtc/api/wrapping_async_dns_resolver.h')
-rw-r--r-- | third_party/libwebrtc/api/wrapping_async_dns_resolver.h | 131 |
1 files changed, 131 insertions, 0 deletions
diff --git a/third_party/libwebrtc/api/wrapping_async_dns_resolver.h b/third_party/libwebrtc/api/wrapping_async_dns_resolver.h new file mode 100644 index 0000000000..5155b0f528 --- /dev/null +++ b/third_party/libwebrtc/api/wrapping_async_dns_resolver.h @@ -0,0 +1,131 @@ +/* + * 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_WRAPPING_ASYNC_DNS_RESOLVER_H_ +#define API_WRAPPING_ASYNC_DNS_RESOLVER_H_ + +#include <functional> +#include <memory> +#include <utility> + +#include "absl/memory/memory.h" +#include "api/async_dns_resolver.h" +#include "api/sequence_checker.h" +#include "rtc_base/async_resolver.h" +#include "rtc_base/async_resolver_interface.h" +#include "rtc_base/checks.h" +#include "rtc_base/socket_address.h" +#include "rtc_base/third_party/sigslot/sigslot.h" +#include "rtc_base/thread_annotations.h" + +// This file defines a DNS resolver that wraps an old-style +// AsyncResolver. +// It is part of the conversion to the newer interface, and will go away +// once conversion is finished. +// TODO(bugs.webrtc.org/12598): Delete this API. + +namespace webrtc { + +class WrappingAsyncDnsResolver; + +class RTC_EXPORT WrappingAsyncDnsResolverResult + : public AsyncDnsResolverResult { + public: + explicit WrappingAsyncDnsResolverResult(WrappingAsyncDnsResolver* owner) + : owner_(owner) {} + ~WrappingAsyncDnsResolverResult() {} + + // Note: Inline declaration not possible, since it refers to + // WrappingAsyncDnsResolver. + bool GetResolvedAddress(int family, rtc::SocketAddress* addr) const override; + int GetError() const override; + + private: + WrappingAsyncDnsResolver* const owner_; +}; + +class RTC_EXPORT WrappingAsyncDnsResolver : public AsyncDnsResolverInterface, + public sigslot::has_slots<> { + public: + explicit WrappingAsyncDnsResolver(rtc::AsyncResolverInterface* wrapped) + : wrapped_(absl::WrapUnique(wrapped)), result_(this) {} + + ~WrappingAsyncDnsResolver() override { + // Workaround to get around the fact that sigslot-using objects can't be + // destroyed from within their callback: Alert class users early. + // TODO(bugs.webrtc.org/12651): Delete this class once the sigslot users are + // gone. + RTC_CHECK(!within_resolve_result_); + wrapped_.release()->Destroy(false); + } + + void Start(const rtc::SocketAddress& addr, + std::function<void()> callback) override { + RTC_DCHECK_RUN_ON(&sequence_checker_); + PrepareToResolve(std::move(callback)); + wrapped_->Start(addr); + } + + void Start(const rtc::SocketAddress& addr, + int family, + std::function<void()> callback) override { + RTC_DCHECK_RUN_ON(&sequence_checker_); + PrepareToResolve(std::move(callback)); + wrapped_->Start(addr, family); + } + + const AsyncDnsResolverResult& result() const override { + RTC_DCHECK_RUN_ON(&sequence_checker_); + RTC_DCHECK_EQ(State::kResolved, state_); + return result_; + } + + private: + enum class State { kNotStarted, kStarted, kResolved }; + + friend class WrappingAsyncDnsResolverResult; + // For use by WrappingAsyncDnsResolverResult + rtc::AsyncResolverInterface* wrapped() const { + RTC_DCHECK_RUN_ON(&sequence_checker_); + return wrapped_.get(); + } + + void PrepareToResolve(std::function<void()> callback) { + RTC_DCHECK_RUN_ON(&sequence_checker_); + RTC_DCHECK_EQ(State::kNotStarted, state_); + state_ = State::kStarted; + callback_ = std::move(callback); + wrapped_->SignalDone.connect(this, + &WrappingAsyncDnsResolver::OnResolveResult); + } + + void OnResolveResult(rtc::AsyncResolverInterface* ref) { + RTC_DCHECK_RUN_ON(&sequence_checker_); + RTC_DCHECK(state_ == State::kStarted); + RTC_DCHECK_EQ(ref, wrapped_.get()); + state_ = State::kResolved; + within_resolve_result_ = true; + callback_(); + within_resolve_result_ = false; + } + + // The class variables need to be accessed on a single thread. + SequenceChecker sequence_checker_; + std::function<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; + WrappingAsyncDnsResolverResult result_ RTC_GUARDED_BY(sequence_checker_); + bool within_resolve_result_ RTC_GUARDED_BY(sequence_checker_) = false; +}; + +} // namespace webrtc + +#endif // API_WRAPPING_ASYNC_DNS_RESOLVER_H_ |