diff --git a/api/BUILD.gn b/api/BUILD.gn
index b2a7947c77..f2d10ec296 100644
--- a/api/BUILD.gn
+++ b/api/BUILD.gn
@@ -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") {
diff --git a/api/async_dns_resolver.h b/api/async_dns_resolver.h
index 82d80de2c3..db02cd185c 100644
--- a/api/async_dns_resolver.h
+++ b/api/async_dns_resolver.h
@@ -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
diff --git a/api/test/mock_async_dns_resolver.h b/api/test/mock_async_dns_resolver.h
index 81132c96a5..26127eb1f6 100644
--- a/api/test/mock_async_dns_resolver.h
+++ b/api/test/mock_async_dns_resolver.h
@@ -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,
diff --git a/api/wrapping_async_dns_resolver.h b/api/wrapping_async_dns_resolver.h
index 5155b0f528..d07f1464c5 100644
--- a/api/wrapping_async_dns_resolver.h
+++ b/api/wrapping_async_dns_resolver.h
@@ -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;
diff --git a/p2p/base/basic_async_resolver_factory.cc b/p2p/base/basic_async_resolver_factory.cc
index b351121cc8..67c81670d2 100644
--- a/p2p/base/basic_async_resolver_factory.cc
+++ b/p2p/base/basic_async_resolver_factory.cc
@@ -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;
diff --git a/p2p/base/basic_async_resolver_factory.h b/p2p/base/basic_async_resolver_factory.h
index 147a71c68c..9c1af6a1e1 100644
--- a/p2p/base/basic_async_resolver_factory.h
+++ b/p2p/base/basic_async_resolver_factory.h
@@ -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;
 
diff --git a/p2p/base/p2p_transport_channel_unittest.cc b/p2p/base/p2p_transport_channel_unittest.cc
index ca8ca8de55..e0b837ca5c 100644
--- a/p2p/base/p2p_transport_channel_unittest.cc
+++ b/p2p/base/p2p_transport_channel_unittest.cc
@@ -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,
diff --git a/p2p/base/stun_port_unittest.cc b/p2p/base/stun_port_unittest.cc
index eb7d25e0b9..bf51151536 100644
--- a/p2p/base/stun_port_unittest.cc
+++ b/p2p/base/stun_port_unittest.cc
@@ -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));
diff --git a/p2p/base/turn_port_unittest.cc b/p2p/base/turn_port_unittest.cc
index c77a8c04f2..a570fc70a7 100644
--- a/p2p/base/turn_port_unittest.cc
+++ b/p2p/base/turn_port_unittest.cc
@@ -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));
diff --git a/pc/test/integration_test_helpers.h b/pc/test/integration_test_helpers.h
index 740e063271..c450ccba26 100644
--- a/pc/test/integration_test_helpers.h
+++ b/pc/test/integration_test_helpers.h
@@ -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(_, _))
diff --git a/rtc_base/async_dns_resolver.cc b/rtc_base/async_dns_resolver.cc
index 5abe9694e2..918eeb74f9 100644
--- a/rtc_base/async_dns_resolver.cc
+++ b/rtc_base/async_dns_resolver.cc
@@ -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)
diff --git a/rtc_base/async_dns_resolver.h b/rtc_base/async_dns_resolver.h
index 75112459b2..f8d60b90e2 100644
--- a/rtc_base/async_dns_resolver.h
+++ b/rtc_base/async_dns_resolver.h
@@ -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