diff --git a/p2p/BUILD.gn b/p2p/BUILD.gn
index 7c5433b..c0384f1 100644
--- a/p2p/BUILD.gn
+++ b/p2p/BUILD.gn
@@ -634,6 +634,7 @@
     "../rtc_base:checks",
     "../rtc_base:crypto_random",
     "../rtc_base:network",
+    "../rtc_base:sigslot_trampoline",
     "../rtc_base:socket_address",
     "../rtc_base:ssl",
     "../rtc_base:threading",
diff --git a/p2p/base/p2p_transport_channel.cc b/p2p/base/p2p_transport_channel.cc
index 1b12cbc..466b932 100644
--- a/p2p/base/p2p_transport_channel.cc
+++ b/p2p/base/p2p_transport_channel.cc
@@ -255,16 +255,35 @@
   RTC_DCHECK_RUN_ON(network_thread_);
 
   session->set_generation(static_cast<uint32_t>(allocator_sessions_.size()));
-  session->SignalPortReady.connect(this, &P2PTransportChannel::OnPortReady);
-  session->SignalPortsPruned.connect(this, &P2PTransportChannel::OnPortsPruned);
-  session->SignalCandidatesReady.connect(
-      this, &P2PTransportChannel::OnCandidatesReady);
-  session->SignalCandidateError.connect(this,
-                                        &P2PTransportChannel::OnCandidateError);
-  session->SignalCandidatesRemoved.connect(
-      this, &P2PTransportChannel::OnCandidatesRemoved);
-  session->SignalCandidatesAllocationDone.connect(
-      this, &P2PTransportChannel::OnCandidatesAllocationDone);
+  session->SubscribePortReady(
+      [this](PortAllocatorSession* session, PortInterface* port) {
+        OnPortReady(session, port);
+      });
+
+  session->SubscribePortsPruned(
+      [this](PortAllocatorSession* session,
+             const std::vector<PortInterface*>& ports) {
+        OnPortsPruned(session, ports);
+      });
+
+  session->SubscribeCandidatesReady(
+      [this](PortAllocatorSession* session,
+             const std::vector<Candidate>& candidate) {
+        OnCandidatesReady(session, candidate);
+      });
+  session->SubscribeCandidateError([this](PortAllocatorSession* session,
+                                          const IceCandidateErrorEvent& event) {
+    OnCandidateError(session, event);
+  });
+  session->SubscribeCandidatesRemoved(
+      [this](PortAllocatorSession* session,
+             const std::vector<Candidate>& candidates) {
+        OnCandidatesRemoved(session, candidates);
+      });
+  session->SubscribeCandidatesAllocationDone(
+      [this](PortAllocatorSession* session) {
+        OnCandidatesAllocationDone(session);
+      });
   if (!allocator_sessions_.empty()) {
     allocator_session()->PruneAllPorts();
   }
diff --git a/p2p/base/p2p_transport_channel_unittest.cc b/p2p/base/p2p_transport_channel_unittest.cc
index 58d5b505..ed80899 100644
--- a/p2p/base/p2p_transport_channel_unittest.cc
+++ b/p2p/base/p2p_transport_channel_unittest.cc
@@ -465,10 +465,16 @@
     ep2_.cd1_.ch_->SetIceConfig(ep2_config);
     ep1_.cd1_.ch_->MaybeStartGathering();
     ep2_.cd1_.ch_->MaybeStartGathering();
-    ep1_.cd1_.ch_->allocator_session()->SignalIceRegathering.connect(
-        &ep1_, &Endpoint::OnIceRegathering);
-    ep2_.cd1_.ch_->allocator_session()->SignalIceRegathering.connect(
-        &ep2_, &Endpoint::OnIceRegathering);
+    ep1_.cd1_.ch_->allocator_session()->SubscribeIceRegathering(
+        [this](PortAllocatorSession* allocator_session,
+               IceRegatheringReason reason) {
+          ep1_.OnIceRegathering(allocator_session, reason);
+        });
+    ep2_.cd1_.ch_->allocator_session()->SubscribeIceRegathering(
+        [this](PortAllocatorSession* allocator_session,
+               IceRegatheringReason reason) {
+          ep2_.OnIceRegathering(allocator_session, reason);
+        });
   }
 
   void CreateChannels(const Environment& env) {
diff --git a/p2p/base/port_allocator.cc b/p2p/base/port_allocator.cc
index 7e8b34a..adfcc1d 100644
--- a/p2p/base/port_allocator.cc
+++ b/p2p/base/port_allocator.cc
@@ -77,7 +77,14 @@
       content_name_(content_name),
       component_(component),
       ice_ufrag_(ice_ufrag),
-      ice_pwd_(ice_pwd) {
+      ice_pwd_(ice_pwd),
+      port_ready_trampoline_(this),
+      ports_pruned_trampoline_(this),
+      candidates_ready_trampoline_(this),
+      candidate_error_trampoline_(this),
+      candidates_removed_trampoline_(this),
+      candidates_allocation_done_trampoline_(this),
+      ice_regathering_trampoline_(this) {
   // Pooled sessions are allowed to be created with empty content name,
   // component, ufrag and password.
   RTC_DCHECK(ice_ufrag.empty() == ice_pwd.empty());
diff --git a/p2p/base/port_allocator.h b/p2p/base/port_allocator.h
index f192209..abd9b39 100644
--- a/p2p/base/port_allocator.h
+++ b/p2p/base/port_allocator.h
@@ -15,6 +15,7 @@
 #include <memory>
 #include <optional>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "absl/strings/string_view.h"
@@ -262,24 +263,59 @@
   virtual void PruneAllPorts() {}
 
   sigslot::signal2<PortAllocatorSession*, PortInterface*> SignalPortReady;
+  void SubscribePortReady(absl::AnyInvocable<void(PortAllocatorSession*,
+                                                  PortInterface*)> callback) {
+    port_ready_trampoline_.Subscribe(std::move(callback));
+  }
+
   // Fires this signal when the network of the ports failed (either because the
   // interface is down, or because there is no connection on the interface),
   // or when TURN ports are pruned because a higher-priority TURN port becomes
   // ready(pairable).
   sigslot::signal2<PortAllocatorSession*, const std::vector<PortInterface*>&>
       SignalPortsPruned;
+  void SubscribePortsPruned(
+      absl::AnyInvocable<void(PortAllocatorSession*,
+                              const std::vector<PortInterface*>&)> callback) {
+    ports_pruned_trampoline_.Subscribe(std::move(callback));
+  }
+
   sigslot::signal2<PortAllocatorSession*, const std::vector<Candidate>&>
       SignalCandidatesReady;
+  void SubscribeCandidatesReady(
+      absl::AnyInvocable<void(PortAllocatorSession*,
+                              const std::vector<Candidate>&)> callback) {
+    candidates_ready_trampoline_.Subscribe(std::move(callback));
+  }
   sigslot::signal2<PortAllocatorSession*, const IceCandidateErrorEvent&>
       SignalCandidateError;
+  void SubscribeCandidateError(
+      absl::AnyInvocable<void(PortAllocatorSession*,
+                              const IceCandidateErrorEvent&)> callback) {
+    candidate_error_trampoline_.Subscribe(std::move(callback));
+  }
   // Candidates should be signaled to be removed when the port that generated
   // the candidates is removed.
   sigslot::signal2<PortAllocatorSession*, const std::vector<Candidate>&>
       SignalCandidatesRemoved;
+  void SubscribeCandidatesRemoved(
+      absl::AnyInvocable<void(PortAllocatorSession*,
+                              const std::vector<Candidate>&)> callback) {
+    candidates_removed_trampoline_.Subscribe(std::move(callback));
+  }
   sigslot::signal1<PortAllocatorSession*> SignalCandidatesAllocationDone;
+  void SubscribeCandidatesAllocationDone(
+      absl::AnyInvocable<void(PortAllocatorSession*)> callback) {
+    candidates_allocation_done_trampoline_.Subscribe(std::move(callback));
+  }
 
   sigslot::signal2<PortAllocatorSession*, IceRegatheringReason>
       SignalIceRegathering;
+  void SubscribeIceRegathering(
+      absl::AnyInvocable<void(PortAllocatorSession*, IceRegatheringReason)>
+          callback) {
+    ice_regathering_trampoline_.Subscribe(std::move(callback));
+  }
 
   virtual uint32_t generation();
   virtual void set_generation(uint32_t generation);
@@ -332,6 +368,27 @@
   // SetIceParameters is an implementation detail which only PortAllocator
   // should be able to call.
   friend class PortAllocator;
+  SignalTrampoline<PortAllocatorSession, &PortAllocatorSession::SignalPortReady>
+      port_ready_trampoline_;
+  SignalTrampoline<PortAllocatorSession,
+                   &PortAllocatorSession::SignalPortsPruned>
+      ports_pruned_trampoline_;
+  SignalTrampoline<PortAllocatorSession,
+                   &PortAllocatorSession::SignalCandidatesReady>
+      candidates_ready_trampoline_;
+  SignalTrampoline<PortAllocatorSession,
+                   &PortAllocatorSession::SignalCandidateError>
+      candidate_error_trampoline_;
+  SignalTrampoline<PortAllocatorSession,
+                   &PortAllocatorSession::SignalCandidatesRemoved>
+      candidates_removed_trampoline_;
+  SignalTrampoline<PortAllocatorSession,
+                   &PortAllocatorSession::SignalCandidatesAllocationDone>
+      candidates_allocation_done_trampoline_;
+
+  SignalTrampoline<PortAllocatorSession,
+                   &PortAllocatorSession::SignalIceRegathering>
+      ice_regathering_trampoline_;
 };
 
 // Every method of PortAllocator (including the destructor) must be called on
diff --git a/p2p/base/regathering_controller_unittest.cc b/p2p/base/regathering_controller_unittest.cc
index 51f8214..3243086 100644
--- a/p2p/base/regathering_controller_unittest.cc
+++ b/p2p/base/regathering_controller_unittest.cc
@@ -82,8 +82,11 @@
     // call of StartGettingPorts is blocking. We will not ClearGettingPorts
     // prematurely.
     allocator_session_->StartGettingPorts();
-    allocator_session_->SignalIceRegathering.connect(
-        this, &RegatheringControllerTest::OnIceRegathering);
+    allocator_session_->SubscribeIceRegathering(
+        [this](PortAllocatorSession* allocator_session,
+               IceRegatheringReason reason) {
+          OnIceRegathering(allocator_session, reason);
+        });
     regathering_controller_->set_allocator_session(allocator_session_.get());
   }
 
diff --git a/p2p/client/basic_port_allocator_unittest.cc b/p2p/client/basic_port_allocator_unittest.cc
index 48eaff1..a8ef7cb 100644
--- a/p2p/client/basic_port_allocator_unittest.cc
+++ b/p2p/client/basic_port_allocator_unittest.cc
@@ -288,16 +288,29 @@
       absl::string_view ice_pwd) {
     std::unique_ptr<PortAllocatorSession> session =
         allocator_->CreateSession(content_name, component, ice_ufrag, ice_pwd);
-    session->SignalPortReady.connect(this,
-                                     &BasicPortAllocatorTestBase::OnPortReady);
-    session->SignalPortsPruned.connect(
-        this, &BasicPortAllocatorTestBase::OnPortsPruned);
-    session->SignalCandidatesReady.connect(
-        this, &BasicPortAllocatorTestBase::OnCandidatesReady);
-    session->SignalCandidatesRemoved.connect(
-        this, &BasicPortAllocatorTestBase::OnCandidatesRemoved);
-    session->SignalCandidatesAllocationDone.connect(
-        this, &BasicPortAllocatorTestBase::OnCandidatesAllocationDone);
+    session->SubscribePortReady(
+        [this](PortAllocatorSession* session, PortInterface* port) {
+          OnPortReady(session, port);
+        });
+    session->SubscribePortsPruned(
+        [this](PortAllocatorSession* session,
+               const std::vector<PortInterface*>& ports) {
+          OnPortsPruned(session, ports);
+        });
+    session->SubscribeCandidatesReady(
+        [this](PortAllocatorSession* session,
+               const std::vector<Candidate>& candidate) {
+          OnCandidatesReady(session, candidate);
+        });
+    session->SubscribeCandidatesRemoved(
+        [this](PortAllocatorSession* session,
+               const std::vector<Candidate>& removed_candidates) {
+          OnCandidatesRemoved(session, removed_candidates);
+        });
+    session->SubscribeCandidatesAllocationDone(
+        [this](PortAllocatorSession* session) {
+          OnCandidatesAllocationDone(session);
+        });
     return session;
   }