diff --git a/quiche/binary_http/binary_http_message.cc b/quiche/binary_http/binary_http_message.cc
index 6d333ac..11ae79d 100644
--- a/quiche/binary_http/binary_http_message.cc
+++ b/quiche/binary_http/binary_http_message.cc
@@ -15,6 +15,7 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_join.h"
 #include "absl/strings/string_view.h"
+#include "quiche/common/quiche_callbacks.h"
 #include "quiche/common/quiche_data_reader.h"
 #include "quiche/common/quiche_data_writer.h"
 
@@ -56,10 +57,10 @@
   return control_data;
 }
 
-absl::Status DecodeFields(
-    quiche::QuicheDataReader& reader,
-    const std::function<void(absl::string_view name, absl::string_view value)>&
-        callback) {
+absl::Status DecodeFields(quiche::QuicheDataReader& reader,
+                          quiche::UnretainedCallback<void(
+                              absl::string_view name, absl::string_view value)>
+                              callback) {
   absl::string_view fields;
   if (!reader.ReadStringPieceVarInt62(&fields)) {
     return absl::InvalidArgumentError("Failed to read fields.");
diff --git a/quiche/quic/core/io/event_loop_connecting_client_socket_test.cc b/quiche/quic/core/io/event_loop_connecting_client_socket_test.cc
index 37cb607..b0d4406 100644
--- a/quiche/quic/core/io/event_loop_connecting_client_socket_test.cc
+++ b/quiche/quic/core/io/event_loop_connecting_client_socket_test.cc
@@ -32,6 +32,7 @@
 #include "quiche/common/platform/api/quiche_test.h"
 #include "quiche/common/platform/api/quiche_test_loopback.h"
 #include "quiche/common/platform/api/quiche_thread.h"
+#include "quiche/common/quiche_callbacks.h"
 #include "quiche/common/simple_buffer_allocator.h"
 
 namespace quic::test {
@@ -43,7 +44,7 @@
 
 class TestServerSocketRunner : public quiche::QuicheThread {
  public:
-  using SocketBehavior = std::function<void(
+  using SocketBehavior = quiche::MultiUseCallback<void(
       SocketFd connected_socket, socket_api::SocketProtocol protocol)>;
 
   TestServerSocketRunner(SocketFd server_socket_descriptor,
@@ -80,7 +81,7 @@
   // closes the accepted connection socket.
   TestTcpServerSocketRunner(SocketFd server_socket_descriptor,
                             SocketBehavior behavior)
-      : TestServerSocketRunner(server_socket_descriptor, behavior) {
+      : TestServerSocketRunner(server_socket_descriptor, std::move(behavior)) {
     Start();
   }
 
@@ -119,7 +120,7 @@
   TestUdpServerSocketRunner(SocketFd server_socket_descriptor,
                             SocketBehavior behavior,
                             QuicSocketAddress client_socket_address)
-      : TestServerSocketRunner(server_socket_descriptor, behavior),
+      : TestServerSocketRunner(server_socket_descriptor, std::move(behavior)),
         client_socket_address_(std::move(client_socket_address)) {
     Start();
   }
diff --git a/quiche/quic/qbone/bonnet/tun_device_controller.cc b/quiche/quic/qbone/bonnet/tun_device_controller.cc
index b6e3d76..fe9e2a0 100644
--- a/quiche/quic/qbone/bonnet/tun_device_controller.cc
+++ b/quiche/quic/qbone/bonnet/tun_device_controller.cc
@@ -9,6 +9,7 @@
 #include "absl/time/clock.h"
 #include "quiche/quic/platform/api/quic_logging.h"
 #include "quiche/quic/qbone/qbone_constants.h"
+#include "quiche/common/quiche_callbacks.h"
 
 ABSL_FLAG(bool, qbone_tun_device_replace_default_routing_rules, true,
           "If true, will define a rule that points packets sourced from the "
@@ -169,8 +170,8 @@
 }
 
 void TunDeviceController::RegisterAddressUpdateCallback(
-    const std::function<void(QuicIpAddress)>& cb) {
-  address_update_cbs_.push_back(cb);
+    quiche::MultiUseCallback<void(QuicIpAddress)> cb) {
+  address_update_cbs_.push_back(std::move(cb));
 }
 
 }  // namespace quic
diff --git a/quiche/quic/qbone/bonnet/tun_device_controller.h b/quiche/quic/qbone/bonnet/tun_device_controller.h
index 3043583..350a056 100644
--- a/quiche/quic/qbone/bonnet/tun_device_controller.h
+++ b/quiche/quic/qbone/bonnet/tun_device_controller.h
@@ -5,10 +5,12 @@
 #ifndef QUICHE_QUIC_QBONE_BONNET_TUN_DEVICE_CONTROLLER_H_
 #define QUICHE_QUIC_QBONE_BONNET_TUN_DEVICE_CONTROLLER_H_
 
+#include "quiche/quic/platform/api/quic_ip_address.h"
 #include "quiche/quic/qbone/bonnet/tun_device.h"
 #include "quiche/quic/qbone/platform/netlink_interface.h"
 #include "quiche/quic/qbone/qbone_control.pb.h"
 #include "quiche/quic/qbone/qbone_control_stream.h"
+#include "quiche/common/quiche_callbacks.h"
 
 namespace quic {
 
@@ -50,7 +52,7 @@
       int retries);
 
   virtual void RegisterAddressUpdateCallback(
-      const std::function<void(QuicIpAddress)>& cb);
+      quiche::MultiUseCallback<void(QuicIpAddress)> cb);
 
   virtual QuicIpAddress current_address();
 
@@ -65,7 +67,8 @@
 
   QuicIpAddress current_address_;
 
-  std::vector<std::function<void(QuicIpAddress)>> address_update_cbs_;
+  std::vector<quiche::MultiUseCallback<void(QuicIpAddress)>>
+      address_update_cbs_;
 };
 
 }  // namespace quic
diff --git a/quiche/quic/qbone/qbone_session_test.cc b/quiche/quic/qbone/qbone_session_test.cc
index ab92c1c..46a41d9 100644
--- a/quiche/quic/qbone/qbone_session_test.cc
+++ b/quiche/quic/qbone/qbone_session_test.cc
@@ -26,6 +26,7 @@
 #include "quiche/quic/test_tools/quic_connection_peer.h"
 #include "quiche/quic/test_tools/quic_session_peer.h"
 #include "quiche/quic/test_tools/quic_test_utils.h"
+#include "quiche/common/quiche_callbacks.h"
 
 namespace quic {
 namespace test {
@@ -238,7 +239,7 @@
 
     void Run() {
       if (!cancelled_) {
-        task_();
+        std::move(task_)();
       }
     }
 
@@ -246,7 +247,7 @@
 
    private:
     bool cancelled_ = false;
-    std::function<void()> task_;
+    quiche::SingleUseCallback<void()> task_;
     QuicTime time_;
   };
 
@@ -260,8 +261,9 @@
 
  private:
   using TaskType = std::shared_ptr<InnerTask>;
-  std::priority_queue<TaskType, std::vector<TaskType>,
-                      std::function<bool(const TaskType&, const TaskType&)>>
+  std::priority_queue<
+      TaskType, std::vector<TaskType>,
+      quiche::UnretainedCallback<bool(const TaskType&, const TaskType&)>>
       tasks_;
   MockQuicConnectionHelper* helper_;
 };
diff --git a/quiche/quic/test_tools/qpack/qpack_test_utils.h b/quiche/quic/test_tools/qpack/qpack_test_utils.h
index c6f1c65..4c19d3a 100644
--- a/quiche/quic/test_tools/qpack/qpack_test_utils.h
+++ b/quiche/quic/test_tools/qpack/qpack_test_utils.h
@@ -11,13 +11,14 @@
 #include "absl/strings/string_view.h"
 #include "quiche/quic/core/qpack/qpack_stream_sender_delegate.h"
 #include "quiche/quic/platform/api/quic_test.h"
+#include "quiche/common/quiche_callbacks.h"
 
 namespace quic {
 namespace test {
 
 // Called repeatedly to determine the size of each fragment when encoding or
 // decoding.  Must return a positive value.
-using FragmentSizeGenerator = std::function<size_t()>;
+using FragmentSizeGenerator = quiche::MultiUseCallback<size_t()>;
 
 enum class FragmentMode {
   kSingleChunk,
diff --git a/quiche/quic/test_tools/server_thread.cc b/quiche/quic/test_tools/server_thread.cc
index c0d32ea..5667410 100644
--- a/quiche/quic/test_tools/server_thread.cc
+++ b/quiche/quic/test_tools/server_thread.cc
@@ -9,6 +9,7 @@
 #include "quiche/quic/test_tools/crypto_test_utils.h"
 #include "quiche/quic/test_tools/quic_dispatcher_peer.h"
 #include "quiche/quic/test_tools/quic_server_peer.h"
+#include "quiche/common/quiche_callbacks.h"
 
 namespace quic {
 namespace test {
@@ -62,7 +63,7 @@
   return rc;
 }
 
-void ServerThread::Schedule(std::function<void()> action) {
+void ServerThread::Schedule(quiche::SingleUseCallback<void()> action) {
   QUICHE_DCHECK(!quit_.HasBeenNotified());
   QuicWriterMutexLock lock(&scheduled_actions_lock_);
   scheduled_actions_.push_back(std::move(action));
@@ -72,8 +73,9 @@
   confirmed_.WaitForNotification();
 }
 
-bool ServerThread::WaitUntil(std::function<bool()> termination_predicate,
-                             QuicTime::Delta timeout) {
+bool ServerThread::WaitUntil(
+    quiche::UnretainedCallback<bool()> termination_predicate,
+    QuicTime::Delta timeout) {
   const QuicTime deadline = clock_->Now() + timeout;
   while (clock_->Now() < deadline) {
     QuicNotification done_checking;
@@ -128,13 +130,13 @@
 }
 
 void ServerThread::ExecuteScheduledActions() {
-  quiche::QuicheCircularDeque<std::function<void()>> actions;
+  quiche::QuicheCircularDeque<quiche::SingleUseCallback<void()>> actions;
   {
     QuicWriterMutexLock lock(&scheduled_actions_lock_);
     actions.swap(scheduled_actions_);
   }
   while (!actions.empty()) {
-    actions.front()();
+    std::move(actions.front())();
     actions.pop_front();
   }
 }
diff --git a/quiche/quic/test_tools/server_thread.h b/quiche/quic/test_tools/server_thread.h
index c29d633..baaa693 100644
--- a/quiche/quic/test_tools/server_thread.h
+++ b/quiche/quic/test_tools/server_thread.h
@@ -12,6 +12,7 @@
 #include "quiche/quic/platform/api/quic_socket_address.h"
 #include "quiche/quic/platform/api/quic_thread.h"
 #include "quiche/quic/tools/quic_server.h"
+#include "quiche/common/quiche_callbacks.h"
 
 namespace quic {
 namespace test {
@@ -34,7 +35,7 @@
   void Run() override;
 
   // Schedules the given action for execution in the event loop.
-  void Schedule(std::function<void()> action);
+  void Schedule(quiche::SingleUseCallback<void()> action);
 
   // Waits for the handshake to be confirmed for the first session created.
   void WaitForCryptoHandshakeConfirmed();
@@ -43,7 +44,7 @@
   // reached |timeout|. Must be called from an external thread.
   // Return whether the function returned after |termination_predicate| become
   // true.
-  bool WaitUntil(std::function<bool()> termination_predicate,
+  bool WaitUntil(quiche::UnretainedCallback<bool()> termination_predicate,
                  QuicTime::Delta timeout);
 
   // Pauses execution of the server until Resume() is called.  May only be
@@ -86,8 +87,8 @@
   bool initialized_;
 
   QuicMutex scheduled_actions_lock_;
-  quiche::QuicheCircularDeque<std::function<void()>> scheduled_actions_
-      QUIC_GUARDED_BY(scheduled_actions_lock_);
+  quiche::QuicheCircularDeque<quiche::SingleUseCallback<void()>>
+      scheduled_actions_ QUIC_GUARDED_BY(scheduled_actions_lock_);
 };
 
 }  // namespace test
diff --git a/quiche/quic/tools/quic_simple_client_session.cc b/quiche/quic/tools/quic_simple_client_session.cc
index c2c266f..ab44f5f 100644
--- a/quiche/quic/tools/quic_simple_client_session.cc
+++ b/quiche/quic/tools/quic_simple_client_session.cc
@@ -7,6 +7,7 @@
 #include <utility>
 
 #include "quiche/quic/core/quic_path_validator.h"
+#include "quiche/spdy/core/http2_header_block.h"
 
 namespace quic {
 
@@ -39,7 +40,9 @@
   auto stream = std::make_unique<QuicSimpleClientStream>(
       GetNextOutgoingBidirectionalStreamId(), this, BIDIRECTIONAL,
       drop_response_body_);
-  stream->set_on_interim_headers(on_interim_headers_);
+  stream->set_on_interim_headers([this](const spdy::Http2HeaderBlock& headers) {
+    on_interim_headers_(headers);
+  });
   return stream;
 }
 
diff --git a/quiche/quic/tools/quic_simple_client_session.h b/quiche/quic/tools/quic_simple_client_session.h
index 1017341..9d1b4c7 100644
--- a/quiche/quic/tools/quic_simple_client_session.h
+++ b/quiche/quic/tools/quic_simple_client_session.h
@@ -11,6 +11,7 @@
 #include "quiche/quic/core/http/quic_spdy_client_session.h"
 #include "quiche/quic/tools/quic_client_base.h"
 #include "quiche/quic/tools/quic_simple_client_stream.h"
+#include "quiche/common/quiche_callbacks.h"
 #include "quiche/spdy/core/http2_header_block.h"
 
 namespace quic {
@@ -46,12 +47,14 @@
   bool drop_response_body() const { return drop_response_body_; }
 
   void set_on_interim_headers(
-      std::function<void(const spdy::Http2HeaderBlock&)> on_interim_headers) {
+      quiche::MultiUseCallback<void(const spdy::Http2HeaderBlock&)>
+          on_interim_headers) {
     on_interim_headers_ = std::move(on_interim_headers);
   }
 
  private:
-  std::function<void(const spdy::Http2HeaderBlock&)> on_interim_headers_;
+  quiche::MultiUseCallback<void(const spdy::Http2HeaderBlock&)>
+      on_interim_headers_;
   QuicClientBase::NetworkHelper* network_helper_;
   const bool drop_response_body_;
   const bool enable_web_transport_;
diff --git a/quiche/quic/tools/quic_simple_client_stream.h b/quiche/quic/tools/quic_simple_client_stream.h
index fd7ede4..db7588b 100644
--- a/quiche/quic/tools/quic_simple_client_stream.h
+++ b/quiche/quic/tools/quic_simple_client_stream.h
@@ -9,6 +9,7 @@
 #include <utility>
 
 #include "quiche/quic/core/http/quic_spdy_client_stream.h"
+#include "quiche/common/quiche_callbacks.h"
 
 namespace quic {
 
@@ -21,7 +22,8 @@
   void OnBodyAvailable() override;
 
   void set_on_interim_headers(
-      std::function<void(const spdy::Http2HeaderBlock&)> on_interim_headers) {
+      quiche::MultiUseCallback<void(const spdy::Http2HeaderBlock&)>
+          on_interim_headers) {
     on_interim_headers_ = std::move(on_interim_headers);
   }
 
@@ -29,7 +31,8 @@
   bool ParseAndValidateStatusCode() override;
 
  private:
-  std::function<void(const spdy::Http2HeaderBlock&)> on_interim_headers_;
+  quiche::MultiUseCallback<void(const spdy::Http2HeaderBlock&)>
+      on_interim_headers_;
   const bool drop_response_body_;
 };
 
diff --git a/quiche/quic/tools/web_transport_test_visitors.h b/quiche/quic/tools/web_transport_test_visitors.h
index 5fc3fbd..be7932f 100644
--- a/quiche/quic/tools/web_transport_test_visitors.h
+++ b/quiche/quic/tools/web_transport_test_visitors.h
@@ -12,6 +12,7 @@
 #include "quiche/quic/platform/api/quic_logging.h"
 #include "quiche/common/platform/api/quiche_logging.h"
 #include "quiche/common/platform/api/quiche_mem_slice.h"
+#include "quiche/common/quiche_callbacks.h"
 #include "quiche/common/quiche_circular_deque.h"
 #include "quiche/common/quiche_stream.h"
 #include "quiche/common/simple_buffer_allocator.h"
@@ -111,7 +112,7 @@
 class WebTransportUnidirectionalEchoReadVisitor
     : public WebTransportStreamVisitor {
  public:
-  using Callback = std::function<void(const std::string&)>;
+  using Callback = quiche::MultiUseCallback<void(const std::string&)>;
 
   WebTransportUnidirectionalEchoReadVisitor(WebTransportStream* stream,
                                             Callback callback)