Remove AsyncPacketSocket::SignalReadPacket

Bug: webrtc:11943
Change-Id: I064a5252ed08e7d06695d03364326fa7f4c562a7
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/331301
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Commit-Queue: Per Kjellander <perkj@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#41385}

rtc_base/BUILD.gn

@@ -1982,6 +1982,7 @@ if (rtc_include_tests) {
         "containers:flat_map",
         "containers:unittests",
         "memory:unittests",
+        "network:received_packet",
         "synchronization:mutex",
         "task_utils:repeating_task",
         "third_party/base64",
@@ -2143,6 +2144,7 @@ if (rtc_include_tests) {
         "../test:test_main",
         "../test:test_support",
         "memory:fifo_buffer",
+        "network:received_packet",
         "synchronization:mutex",
         "third_party/sigslot",
       ]

rtc_base/async_packet_socket.cc

@@ -45,13 +45,11 @@ void AsyncPacketSocket::RegisterReceivedPacketCallback(
         received_packet_callback) {
   RTC_DCHECK_RUN_ON(&network_checker_);
   RTC_CHECK(!received_packet_callback_);
-  SignalReadPacket.connect(this, &AsyncPacketSocket::NotifyPacketReceived);
   received_packet_callback_ = std::move(received_packet_callback);
 }
 
 void AsyncPacketSocket::DeregisterReceivedPacketCallback() {
   RTC_DCHECK_RUN_ON(&network_checker_);
-  SignalReadPacket.disconnect(this);
   received_packet_callback_ = nullptr;
 }
 
@@ -62,17 +60,6 @@ void AsyncPacketSocket::NotifyPacketReceived(
     received_packet_callback_(this, packet);
     return;
   }
-  if (SignalReadPacket.is_empty()) {
-    RTC_DCHECK_NOTREACHED() << " No listener registered";
-    return;
-  }
-  // TODO(bugs.webrtc.org:15368): Remove. This code path is only used if
-  // SignalReadyPacket is used  by clients to get notification of received
-  // packets but actual socket implementation use NotifyPacketReceived to
-  // trigger the notification.
-  SignalReadPacket(this, reinterpret_cast<const char*>(packet.payload().data()),
-                   packet.payload().size(), packet.source_address(),
-                   packet.arrival_time() ? packet.arrival_time()->us() : -1);
 }
 
 void CopySocketInformationToPacketInfo(size_t packet_size_bytes,

rtc_base/async_packet_socket.h

@@ -122,18 +122,6 @@ class RTC_EXPORT AsyncPacketSocket : public sigslot::has_slots<> {
           received_packet_callback);
   void DeregisterReceivedPacketCallback();
 
-  // Emitted each time a packet is read. Used only for UDP and
-  // connected TCP sockets.
-  // TODO(bugs.webrtc.org:15368): Deprecate and remove.
-  sigslot::signal5<AsyncPacketSocket*,
-                   const char*,
-                   size_t,
-                   const SocketAddress&,
-                   // TODO(bugs.webrtc.org/9584): Change to passing the int64_t
-                   // timestamp by value.
-                   const int64_t&>
-      SignalReadPacket;
-
   // Emitted each time a packet is sent.
   sigslot::signal2<AsyncPacketSocket*, const SentPacket&> SignalSentPacket;
 

rtc_base/async_packet_socket_unittest.cc

@@ -63,48 +63,5 @@ TEST(AsyncPacketSocket, RegisteredCallbackReceivePacketsFromNotify) {
   mock_socket.NotifyPacketReceived();
 }
 
-TEST(AsyncPacketSocket, RegisteredCallbackReceivePacketsFromSignalReadPacket) {
-  MockAsyncPacketSocket mock_socket;
-  MockFunction<void(AsyncPacketSocket*, const rtc::ReceivedPacket&)>
-      received_packet;
-
-  EXPECT_CALL(received_packet, Call);
-  mock_socket.RegisterReceivedPacketCallback(received_packet.AsStdFunction());
-  char data[1] = {'a'};
-  mock_socket.SignalReadPacket(&mock_socket, data, 1, SocketAddress(), -1);
-}
-
-TEST(AsyncPacketSocket, SignalReadPacketTriggeredByNotifyPacketReceived) {
-  class SigslotPacketReceiver : public sigslot::has_slots<> {
-   public:
-    explicit SigslotPacketReceiver(rtc::AsyncPacketSocket& socket) {
-      socket.SignalReadPacket.connect(this,
-                                      &SigslotPacketReceiver::OnPacketReceived);
-    }
-
-    bool packet_received() const { return packet_received_; }
-
-   private:
-    void OnPacketReceived(AsyncPacketSocket*,
-                          const char*,
-                          size_t,
-                          const SocketAddress&,
-                          // TODO(bugs.webrtc.org/9584): Change to passing the
-                          // int64_t timestamp by value.
-                          const int64_t&) {
-      packet_received_ = true;
-    }
-
-    bool packet_received_ = false;
-  };
-
-  MockAsyncPacketSocket mock_socket;
-  SigslotPacketReceiver receiver(mock_socket);
-  ASSERT_FALSE(receiver.packet_received());
-
-  mock_socket.NotifyPacketReceived();
-  EXPECT_TRUE(receiver.packet_received());
-}
-
 }  // namespace
 }  // namespace rtc

rtc_base/thread_unittest.cc

@@ -22,6 +22,7 @@
 #include "rtc_base/fake_clock.h"
 #include "rtc_base/gunit.h"
 #include "rtc_base/internal/default_socket_server.h"
+#include "rtc_base/network/received_packet.h"
 #include "rtc_base/null_socket_server.h"
 #include "rtc_base/physical_socket_server.h"
 #include "rtc_base/ref_counted_object.h"
@@ -84,20 +85,20 @@ class SocketClient : public TestGenerator, public sigslot::has_slots<> {
       : socket_(AsyncUDPSocket::Create(socket, addr)),
         post_thread_(post_thread),
         post_handler_(phandler) {
-    socket_->SignalReadPacket.connect(this, &SocketClient::OnPacket);
+    socket_->RegisterReceivedPacketCallback(
+        [&](rtc::AsyncPacketSocket* socket, const rtc::ReceivedPacket& packet) {
+          OnPacket(socket, packet);
+        });
   }
 
   ~SocketClient() override { delete socket_; }
 
   SocketAddress address() const { return socket_->GetLocalAddress(); }
 
-  void OnPacket(AsyncPacketSocket* socket,
-                const char* buf,
-                size_t size,
-                const SocketAddress& remote_addr,
-                const int64_t& packet_time_us) {
-    EXPECT_EQ(size, sizeof(uint32_t));
-    uint32_t prev = reinterpret_cast<const uint32_t*>(buf)[0];
+  void OnPacket(AsyncPacketSocket* socket, const rtc::ReceivedPacket& packet) {
+    EXPECT_EQ(packet.payload().size(), sizeof(uint32_t));
+    uint32_t prev =
+        reinterpret_cast<const uint32_t*>(packet.payload().data())[0];
     uint32_t result = Next(prev);
 
     post_thread_->PostDelayedTask([post_handler_ = post_handler_,

rtc_base/virtual_socket_unittest.cc

@@ -13,6 +13,8 @@
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
+
+#include "rtc_base/network/received_packet.h"
 #if defined(WEBRTC_POSIX)
 #include <netinet/in.h>
 #endif
@@ -101,7 +103,10 @@ struct Receiver : public sigslot::has_slots<> {
         sum(0),
         sum_sq(0),
         samples(0) {
-    socket->SignalReadPacket.connect(this, &Receiver::OnReadPacket);
+    socket->RegisterReceivedPacketCallback(
+        [&](rtc::AsyncPacketSocket* socket, const rtc::ReceivedPacket& packet) {
+          OnReadPacket(socket, packet);
+        });
     periodic = RepeatingTaskHandle::DelayedStart(
         thread, TimeDelta::Seconds(1), [this] {
           // It is always possible for us to receive more than expected because
@@ -116,18 +121,15 @@ struct Receiver : public sigslot::has_slots<> {
 
   ~Receiver() override { periodic.Stop(); }
 
-  void OnReadPacket(AsyncPacketSocket* s,
-                    const char* data,
-                    size_t size,
-                    const SocketAddress& remote_addr,
-                    const int64_t& /* packet_time_us */) {
+  void OnReadPacket(AsyncPacketSocket* s, const rtc::ReceivedPacket& packet) {
     ASSERT_EQ(socket.get(), s);
-    ASSERT_GE(size, 4U);
+    ASSERT_GE(packet.payload().size(), 4U);
 
-    count += size;
-    sec_count += size;
+    count += packet.payload().size();
+    sec_count += packet.payload().size();
 
-    uint32_t send_time = *reinterpret_cast<const uint32_t*>(data);
+    uint32_t send_time =
+        *reinterpret_cast<const uint32_t*>(packet.payload().data());
     uint32_t recv_time = rtc::TimeMillis();
     uint32_t delay = recv_time - send_time;
     sum += delay;