diff --git a/p2p/base/async_stun_tcp_socket.cc b/p2p/base/async_stun_tcp_socket.cc
index 4a35903..4f07676 100644
--- a/p2p/base/async_stun_tcp_socket.cc
+++ b/p2p/base/async_stun_tcp_socket.cc
@@ -14,9 +14,15 @@
 #include <stdint.h>
 #include <string.h>
 
+#include <cstddef>
+#include <cstdint>
+
+#include "api/array_view.h"
 #include "api/transport/stun.h"
+#include "api/units/timestamp.h"
 #include "rtc_base/byte_order.h"
 #include "rtc_base/checks.h"
+#include "rtc_base/network/received_packet.h"
 #include "rtc_base/network/sent_packet.h"
 #include "rtc_base/time_utils.h"
 
@@ -89,7 +95,7 @@
   return static_cast<int>(cb);
 }
 
-void AsyncStunTCPSocket::ProcessInput(char* data, size_t* len) {
+size_t AsyncStunTCPSocket::ProcessInput(rtc::ArrayView<const uint8_t> data) {
   rtc::SocketAddress remote_addr(GetRemoteAddress());
   // STUN packet - First 4 bytes. Total header size is 20 bytes.
   // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
@@ -101,26 +107,26 @@
   // |         Channel Number        |            Length             |
   // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 
+  size_t processed_bytes = 0;
   while (true) {
     // We need at least 4 bytes to read the STUN or ChannelData packet length.
-    if (*len < kPacketLenOffset + kPacketLenSize)
-      return;
+    if (data.size() - processed_bytes < kPacketLenOffset + kPacketLenSize)
+      return processed_bytes;
 
     int pad_bytes;
-    size_t expected_pkt_len = GetExpectedLength(data, *len, &pad_bytes);
+    size_t expected_pkt_len =
+        GetExpectedLength(data.data(), data.size(), &pad_bytes);
     size_t actual_length = expected_pkt_len + pad_bytes;
 
-    if (*len < actual_length) {
-      return;
+    if (data.size() - processed_bytes < actual_length) {
+      return processed_bytes;
     }
 
-    SignalReadPacket(this, data, expected_pkt_len, remote_addr,
-                     rtc::TimeMicros());
-
-    *len -= actual_length;
-    if (*len > 0) {
-      memmove(data, data + actual_length, *len);
-    }
+    rtc::ReceivedPacket received_packet(
+        data.subview(processed_bytes, expected_pkt_len), remote_addr,
+        webrtc::Timestamp::Micros(rtc::TimeMicros()));
+    NotifyPacketReceived(received_packet);
+    processed_bytes += actual_length;
   }
 }
 
diff --git a/p2p/base/async_stun_tcp_socket.h b/p2p/base/async_stun_tcp_socket.h
index f0df42b..2c43d55 100644
--- a/p2p/base/async_stun_tcp_socket.h
+++ b/p2p/base/async_stun_tcp_socket.h
@@ -37,7 +37,7 @@
   int Send(const void* pv,
            size_t cb,
            const rtc::PacketOptions& options) override;
-  void ProcessInput(char* data, size_t* len) override;
+  size_t ProcessInput(rtc::ArrayView<const uint8_t> data) override;
 
  private:
   // This method returns the message hdr + length written in the header.
diff --git a/p2p/base/async_stun_tcp_socket_unittest.cc b/p2p/base/async_stun_tcp_socket_unittest.cc
index 72d6a7f..4e29f01 100644
--- a/p2p/base/async_stun_tcp_socket_unittest.cc
+++ b/p2p/base/async_stun_tcp_socket_unittest.cc
@@ -19,6 +19,7 @@
 #include <utility>
 
 #include "absl/memory/memory.h"
+#include "rtc_base/network/received_packet.h"
 #include "rtc_base/network/sent_packet.h"
 #include "rtc_base/socket.h"
 #include "rtc_base/third_party/sigslot/sigslot.h"
@@ -96,11 +97,10 @@
   }
 
   void OnReadPacket(rtc::AsyncPacketSocket* socket,
-                    const char* data,
-                    size_t len,
-                    const rtc::SocketAddress& remote_addr,
-                    const int64_t& /* packet_time_us */) {
-    recv_packets_.push_back(std::string(data, len));
+                    const rtc::ReceivedPacket& packet) {
+    recv_packets_.push_back(
+        std::string(reinterpret_cast<const char*>(packet.payload().data()),
+                    packet.payload().size()));
   }
 
   void OnSentPacket(rtc::AsyncPacketSocket* socket,
@@ -111,8 +111,10 @@
   void OnNewConnection(rtc::AsyncListenSocket* /*server*/,
                        rtc::AsyncPacketSocket* new_socket) {
     recv_socket_ = absl::WrapUnique(new_socket);
-    new_socket->SignalReadPacket.connect(this,
-                                         &AsyncStunTCPSocketTest::OnReadPacket);
+    new_socket->RegisterReceivedPacketCallback(
+        [&](rtc::AsyncPacketSocket* socket, const rtc::ReceivedPacket& packet) {
+          OnReadPacket(socket, packet);
+        });
   }
 
   bool Send(const void* data, size_t len) {
diff --git a/rtc_base/async_tcp_socket.cc b/rtc_base/async_tcp_socket.cc
index eed4a31..d51f78c 100644
--- a/rtc_base/async_tcp_socket.cc
+++ b/rtc_base/async_tcp_socket.cc
@@ -14,6 +14,8 @@
 #include <string.h>
 
 #include <algorithm>
+#include <cstddef>
+#include <cstdint>
 #include <memory>
 
 #include "api/array_view.h"
@@ -209,15 +211,17 @@
     return;
   }
 
-  size_t size = inbuf_.size();
-  ProcessInput(inbuf_.data<char>(), &size);
-
-  if (size > inbuf_.size()) {
+  size_t processed = ProcessInput(inbuf_);
+  size_t bytes_remaining = inbuf_.size() - processed;
+  if (processed > inbuf_.size()) {
     RTC_LOG(LS_ERROR) << "input buffer overflow";
     RTC_DCHECK_NOTREACHED();
     inbuf_.Clear();
   } else {
-    inbuf_.SetSize(size);
+    if (bytes_remaining > 0) {
+      memmove(inbuf_.data(), inbuf_.data() + processed, bytes_remaining);
+    }
+    inbuf_.SetSize(bytes_remaining);
   }
 }
 
@@ -283,24 +287,23 @@
   return static_cast<int>(cb);
 }
 
-void AsyncTCPSocket::ProcessInput(char* data, size_t* len) {
+size_t AsyncTCPSocket::ProcessInput(rtc::ArrayView<const uint8_t> data) {
   SocketAddress remote_addr(GetRemoteAddress());
 
+  size_t processed_bytes = 0;
   while (true) {
-    if (*len < kPacketLenSize)
-      return;
+    if (data.size() - processed_bytes < kPacketLenSize)
+      return processed_bytes;
 
-    PacketLength pkt_len = rtc::GetBE16(data);
-    if (*len < kPacketLenSize + pkt_len)
-      return;
+    PacketLength pkt_len = rtc::GetBE16(data.data());
+    if (data.size() - processed_bytes < kPacketLenSize + pkt_len)
+      return processed_bytes;
 
-    NotifyPacketReceived(rtc::ReceivedPacket::CreateFromLegacy(
-        data + kPacketLenSize, pkt_len, rtc::TimeMicros(), remote_addr));
-
-    *len -= kPacketLenSize + pkt_len;
-    if (*len > 0) {
-      memmove(data, data + kPacketLenSize + pkt_len, *len);
-    }
+    rtc::ReceivedPacket received_packet(
+        data.subview(processed_bytes + kPacketLenSize, pkt_len), remote_addr,
+        webrtc::Timestamp::Micros(rtc::TimeMicros()));
+    NotifyPacketReceived(received_packet);
+    processed_bytes += kPacketLenSize + pkt_len;
   }
 }
 
diff --git a/rtc_base/async_tcp_socket.h b/rtc_base/async_tcp_socket.h
index 90f77d6..d3aff60 100644
--- a/rtc_base/async_tcp_socket.h
+++ b/rtc_base/async_tcp_socket.h
@@ -16,6 +16,7 @@
 #include <cstdint>
 #include <memory>
 
+#include "api/array_view.h"
 #include "rtc_base/async_packet_socket.h"
 #include "rtc_base/buffer.h"
 #include "rtc_base/socket.h"
@@ -38,7 +39,8 @@
   int Send(const void* pv,
            size_t cb,
            const rtc::PacketOptions& options) override = 0;
-  virtual void ProcessInput(char* data, size_t* len) = 0;
+  // Must return the number of bytes processed.
+  virtual size_t ProcessInput(rtc::ArrayView<const uint8_t> data) = 0;
 
   SocketAddress GetLocalAddress() const override;
   SocketAddress GetRemoteAddress() const override;
@@ -100,7 +102,7 @@
   int Send(const void* pv,
            size_t cb,
            const rtc::PacketOptions& options) override;
-  void ProcessInput(char* data, size_t* len) override;
+  size_t ProcessInput(rtc::ArrayView<const uint8_t>) override;
 };
 
 class AsyncTcpListenSocket : public AsyncListenSocket {