Remove sigslot from AsyncPacketSocket

Bug: webrtc:42222066
Change-Id: I47b45a1e06cbeb24aa5f385911a3e8b45646fb3d
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/427440
Commit-Queue: Tomas Gunnarsson <tommi@webrtc.org>
Auto-Submit: Harald Alvestrand <hta@webrtc.org>
Reviewed-by: Tomas Gunnarsson <tommi@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#46256}

rtc_base/BUILD.gn

@@ -1392,7 +1392,6 @@ rtc_library("async_packet_socket") {
     ":checks",
     ":dscp",
     ":macromagic",
-    ":sigslot_trampoline",
     ":socket",
     ":socket_address",
     ":timeutils",
@@ -1401,7 +1400,6 @@ rtc_library("async_packet_socket") {
     "network:sent_packet",
     "system:no_unique_address",
     "system:rtc_export",
-    "third_party/sigslot",
     "//third_party/abseil-cpp/absl/functional:any_invocable",
   ]
 }

rtc_base/async_packet_socket.cc

@@ -76,7 +76,7 @@ void AsyncPacketSocket::SubscribeSentPacket(
     void* tag,
     absl::AnyInvocable<void(AsyncPacketSocket*, const SentPacketInfo&)>
         callback) {
-  sent_packet_trampoline_.Subscribe(tag, std::move(callback));
+  sent_packet_callbacks_.AddReceiver(tag, std::move(callback));
 }
 
 void CopySocketInformationToPacketInfo(size_t packet_size_bytes,

rtc_base/async_packet_socket.h

@@ -20,16 +20,13 @@
 #include "absl/functional/any_invocable.h"
 #include "api/sequence_checker.h"
 #include "rtc_base/callback_list.h"
-#include "rtc_base/checks.h"
 #include "rtc_base/dscp.h"
 #include "rtc_base/network/received_packet.h"
 #include "rtc_base/network/sent_packet.h"
-#include "rtc_base/sigslot_trampoline.h"
 #include "rtc_base/socket.h"
 #include "rtc_base/socket_address.h"
 #include "rtc_base/system/no_unique_address.h"
 #include "rtc_base/system/rtc_export.h"
-#include "rtc_base/third_party/sigslot/sigslot.h"
 #include "rtc_base/thread_annotations.h"
 
 namespace webrtc {
@@ -89,11 +86,7 @@ class RTC_EXPORT AsyncPacketSocket {
     STATE_CONNECTED
   };
 
-  AsyncPacketSocket()
-      : connect_trampoline_(this),
-        sent_packet_trampoline_(this),
-        ready_to_send_trampoline_(this),
-        address_ready_trampoline_(this) {}
+  AsyncPacketSocket() = default;
   virtual ~AsyncPacketSocket();
 
   AsyncPacketSocket(const AsyncPacketSocket&) = delete;
@@ -147,23 +140,23 @@ class RTC_EXPORT AsyncPacketSocket {
       absl::AnyInvocable<void(AsyncPacketSocket*, const SentPacketInfo&)>
           callback);
   void UnsubscribeSentPacket(void* tag) {
-    sent_packet_trampoline_.Unsubscribe(tag);
+    sent_packet_callbacks_.RemoveReceivers(tag);
   }
   void NotifySentPacket(AsyncPacketSocket* socket, const SentPacketInfo& info) {
-    SignalSentPacket(socket, info);
+    sent_packet_callbacks_.Send(socket, info);
   }
 
   // Emitted when the socket is currently able to send.
   void SubscribeReadyToSend(
       void* tag,
       absl::AnyInvocable<void(AsyncPacketSocket*)> callback) {
-    ready_to_send_trampoline_.Subscribe(tag, std::move(callback));
+    ready_to_send_callbacks_.AddReceiver(tag, std::move(callback));
   }
   void UnsubscribeReadyToSend(void* tag) {
-    ready_to_send_trampoline_.Unsubscribe(tag);
+    ready_to_send_callbacks_.RemoveReceivers(tag);
   }
   void NotifyReadyToSend(AsyncPacketSocket* socket) {
-    SignalReadyToSend(socket);
+    ready_to_send_callbacks_.Send(socket);
   }
 
   // Emitted after address for the socket is allocated, i.e. binding
@@ -173,37 +166,35 @@ class RTC_EXPORT AsyncPacketSocket {
       void* tag,
       absl::AnyInvocable<void(AsyncPacketSocket*, const SocketAddress&)>
           callback) {
-    address_ready_trampoline_.Subscribe(tag, std::move(callback));
+    address_ready_callbacks_.AddReceiver(tag, std::move(callback));
   }
   void UnsubscribeAddressReady(void* tag) {
-    address_ready_trampoline_.Unsubscribe(tag);
+    address_ready_callbacks_.RemoveReceivers(tag);
   }
   void NotifyAddressReady(AsyncPacketSocket* socket,
                           const SocketAddress& address) {
-    SignalAddressReady(socket, address);
+    address_ready_callbacks_.Send(socket, address);
   }
 
   // Emitted for client TCP sockets when state is changed from
   // CONNECTING to CONNECTED.
-  void NotifyConnect(AsyncPacketSocket* socket) { SignalConnect(socket); }
+  void NotifyConnect(AsyncPacketSocket* socket) {
+    connect_callbacks_.Send(socket);
+  }
   void SubscribeConnect(absl::AnyInvocable<void(AsyncPacketSocket*)> callback) {
-    connect_trampoline_.Subscribe(std::move(callback));
+    connect_callbacks_.AddReceiver(std::move(callback));
   }
   void SubscribeConnect(void* tag,
                         absl::AnyInvocable<void(AsyncPacketSocket*)> callback) {
-    connect_trampoline_.Subscribe(tag, std::move(callback));
+    connect_callbacks_.AddReceiver(tag, std::move(callback));
+  }
+  void UnsubscribeConnect(void* tag) {
+    connect_callbacks_.RemoveReceivers(tag);
   }
-  void UnsubscribeConnect(void* tag) { connect_trampoline_.Unsubscribe(tag); }
 
   void NotifyClosedForTest(int err) { NotifyClosed(err); }
 
  protected:
-  // TODO(bugs.webrtc.org/11943): Remove after updating downstream code.
-  void SignalClose(AsyncPacketSocket* s, int err) {
-    RTC_DCHECK_EQ(s, this);
-    NotifyClosed(err);
-  }
-
   void NotifyClosed(int err) {
     RTC_DCHECK_RUN_ON(&network_checker_);
     on_close_.Send(this, err);
@@ -219,18 +210,12 @@ class RTC_EXPORT AsyncPacketSocket {
       RTC_GUARDED_BY(&network_checker_);
   absl::AnyInvocable<void(AsyncPacketSocket*, const ReceivedIpPacket&)>
       received_packet_callback_ RTC_GUARDED_BY(&network_checker_);
-  sigslot::signal1<AsyncPacketSocket*> SignalConnect;
-  SignalTrampoline<AsyncPacketSocket, &AsyncPacketSocket::SignalConnect>
-      connect_trampoline_;
-  sigslot::signal2<AsyncPacketSocket*, const SentPacketInfo&> SignalSentPacket;
-  SignalTrampoline<AsyncPacketSocket, &AsyncPacketSocket::SignalSentPacket>
-      sent_packet_trampoline_;
-  sigslot::signal1<AsyncPacketSocket*> SignalReadyToSend;
-  SignalTrampoline<AsyncPacketSocket, &AsyncPacketSocket::SignalReadyToSend>
-      ready_to_send_trampoline_;
-  sigslot::signal2<AsyncPacketSocket*, const SocketAddress&> SignalAddressReady;
-  SignalTrampoline<AsyncPacketSocket, &AsyncPacketSocket::SignalAddressReady>
-      address_ready_trampoline_;
+  CallbackList<AsyncPacketSocket*> connect_callbacks_;
+  CallbackList<AsyncPacketSocket*, const SentPacketInfo&>
+      sent_packet_callbacks_;
+  CallbackList<AsyncPacketSocket*> ready_to_send_callbacks_;
+  CallbackList<AsyncPacketSocket*, const SocketAddress&>
+      address_ready_callbacks_;
 };
 
 // Listen socket, producing an AsyncPacketSocket when a peer connects.
@@ -241,7 +226,7 @@ class RTC_EXPORT AsyncListenSocket {
     kBound,
   };
 
-  AsyncListenSocket() : new_connection_trampoline_(this) {}
+  AsyncListenSocket() = default;
   virtual ~AsyncListenSocket() = default;
 
   // Returns current state of the socket.
@@ -255,20 +240,19 @@ class RTC_EXPORT AsyncListenSocket {
       void* tag,
       absl::AnyInvocable<void(AsyncListenSocket*, AsyncPacketSocket*)>
           callback) {
-    new_connection_trampoline_.Subscribe(tag, std::move(callback));
+    new_connection_callbacks_.AddReceiver(tag, std::move(callback));
   }
   void UnsubscribeNewConnection(void* tag) {
-    new_connection_trampoline_.Unsubscribe(tag);
+    new_connection_callbacks_.RemoveReceivers(tag);
   }
   void NotifyNewConnection(AsyncListenSocket* listen_socket,
                            AsyncPacketSocket* packet_socket) {
-    SignalNewConnection(listen_socket, packet_socket);
+    new_connection_callbacks_.Send(listen_socket, packet_socket);
   }
 
  private:
-  sigslot::signal2<AsyncListenSocket*, AsyncPacketSocket*> SignalNewConnection;
-  SignalTrampoline<AsyncListenSocket, &AsyncListenSocket::SignalNewConnection>
-      new_connection_trampoline_;
+  CallbackList<AsyncListenSocket*, AsyncPacketSocket*>
+      new_connection_callbacks_;
 };
 
 void CopySocketInformationToPacketInfo(size_t packet_size_bytes,