Reland "Use the new DNS resolver API in PeerConnection"

This reverts commit 5a40b3710545edfd8a634341df3de26f57d79281.

Reason for revert: Fixed the bug and ran layout tests.

Original change's description:
> 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}

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

Bug: webrtc:12598
Change-Id: Ief7867f2f23de66504877cdab1b23a11df2d5de4
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/214120
Commit-Queue: Harald Alvestrand <hta@webrtc.org>
Reviewed-by: Tommi <tommi@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#33647}

p2p/base/basic_async_resolver_factory.cc

diff --git a/p2p/base/basic_async_resolver_factory.cc b/p2p/base/basic_async_resolver_factory.cc
index 67dd18f..7f26a98 100644
--- a/p2p/base/basic_async_resolver_factory.cc
+++ b/p2p/base/basic_async_resolver_factory.cc
@@ -16,6 +16,7 @@
 #include "absl/memory/memory.h"
 #include "api/async_dns_resolver.h"
 #include "rtc_base/async_resolver.h"
+#include "rtc_base/logging.h"
 
 namespace webrtc {
 
@@ -46,11 +47,19 @@
   explicit WrappingAsyncDnsResolver(rtc::AsyncResolverInterface* wrapped)
       : wrapped_(absl::WrapUnique(wrapped)), result_(this) {}
 
-  ~WrappingAsyncDnsResolver() override { wrapped_.release()->Destroy(false); }
+  ~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(state_ == State::kNotStarted);
+    RTC_DCHECK_RUN_ON(&sequence_checker_);
+    RTC_DCHECK_EQ(State::kNotStarted, state_);
     state_ = State::kStarted;
     callback_ = callback;
     wrapped_->SignalDone.connect(this,
@@ -59,27 +68,39 @@
   }
 
   const AsyncDnsResolverResult& result() const override {
-    RTC_DCHECK(state_ == State::kResolved);
+    RTC_DCHECK_RUN_ON(&sequence_checker_);
+    RTC_DCHECK_EQ(State::kResolved, state_);
     return result_;
   }
 
-  // For use by WrappingAsyncDnsResolverResult
-  rtc::AsyncResolverInterface* wrapped() const { return wrapped_.get(); }
-
  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 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;
   }
 
-  std::function<void()> callback_;
-  std::unique_ptr<rtc::AsyncResolverInterface> wrapped_;
-  State state_ = State::kNotStarted;
-  WrappingAsyncDnsResolverResult result_;
+  // 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;
 };
 
 bool WrappingAsyncDnsResolverResult::GetResolvedAddress(