Change RtpTransport and DsctTransport to receives packets through ReceivedPacketCallback

Instead of using PacketTransportInternal::SignalReadPacket.

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

media/BUILD.gn

@@ -622,6 +622,7 @@ if (rtc_build_dcsctp) {
       "../rtc_base:stringutils",
       "../rtc_base:threading",
       "../rtc_base/containers:flat_map",
+      "../rtc_base/network:received_packet",
       "../rtc_base/third_party/sigslot:sigslot",
       "../system_wrappers",
     ]

media/base/rtp_utils.cc

@@ -12,6 +12,7 @@
 
 #include <string.h>
 
+#include <cstdint>
 #include <vector>
 
 // PacketTimeUpdateParams is defined in asyncpacketsocket.h.
@@ -172,12 +173,11 @@ absl::string_view RtpPacketTypeToString(RtpPacketType packet_type) {
   RTC_CHECK_NOTREACHED();
 }
 
-RtpPacketType InferRtpPacketType(rtc::ArrayView<const char> packet) {
+RtpPacketType InferRtpPacketType(rtc::ArrayView<const uint8_t> packet) {
-  if (webrtc::IsRtcpPacket(
+  if (webrtc::IsRtcpPacket(packet)) {
-          rtc::reinterpret_array_view<const uint8_t>(packet))) {
     return RtpPacketType::kRtcp;
   }
-  if (webrtc::IsRtpPacket(rtc::reinterpret_array_view<const uint8_t>(packet))) {
+  if (webrtc::IsRtpPacket(packet)) {
     return RtpPacketType::kRtp;
   }
   return RtpPacketType::kUnknown;

media/base/rtp_utils.h

@@ -11,6 +11,8 @@
 #ifndef MEDIA_BASE_RTP_UTILS_H_
 #define MEDIA_BASE_RTP_UTILS_H_
 
+#include <cstdint>
+
 #include "absl/strings/string_view.h"
 #include "api/array_view.h"
 #include "rtc_base/byte_order.h"
@@ -46,7 +48,7 @@ bool GetRtcpType(const void* data, size_t len, int* value);
 bool GetRtcpSsrc(const void* data, size_t len, uint32_t* value);
 
 // Checks the packet header to determine if it can be an RTP or RTCP packet.
-RtpPacketType InferRtpPacketType(rtc::ArrayView<const char> packet);
+RtpPacketType InferRtpPacketType(rtc::ArrayView<const uint8_t> packet);
 // True if |payload type| is 0-127.
 bool IsValidRtpPayloadType(int payload_type);
 

media/base/rtp_utils_unittest.cc

@@ -72,15 +72,12 @@ static const int kAstIndexInOneByteRtpMsg = 21;
 // and in message `kRtpMsgWithTwoByteAbsSendTimeExtension`.
 static const int kAstIndexInTwoByteRtpMsg = 21;
 
-static const rtc::ArrayView<const char> kPcmuFrameArrayView =
+static const rtc::ArrayView<const uint8_t> kPcmuFrameArrayView =
-    rtc::MakeArrayView(reinterpret_cast<const char*>(kPcmuFrame),
+    rtc::MakeArrayView(kPcmuFrame, sizeof(kPcmuFrame));
-                       sizeof(kPcmuFrame));
+static const rtc::ArrayView<const uint8_t> kRtcpReportArrayView =
-static const rtc::ArrayView<const char> kRtcpReportArrayView =
+    rtc::MakeArrayView(kRtcpReport, sizeof(kRtcpReport));
-    rtc::MakeArrayView(reinterpret_cast<const char*>(kRtcpReport),
+static const rtc::ArrayView<const uint8_t> kInvalidPacketArrayView =
-                       sizeof(kRtcpReport));
+    rtc::MakeArrayView(kInvalidPacket, sizeof(kInvalidPacket));
-static const rtc::ArrayView<const char> kInvalidPacketArrayView =
-    rtc::MakeArrayView(reinterpret_cast<const char*>(kInvalidPacket),
-                       sizeof(kInvalidPacket));
 
 TEST(RtpUtilsTest, GetRtcp) {
   int pt;

media/sctp/dcsctp_transport.cc

@@ -27,6 +27,7 @@
 #include "p2p/base/packet_transport_internal.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
+#include "rtc_base/network/received_packet.h"
 #include "rtc_base/socket.h"
 #include "rtc_base/strings/string_builder.h"
 #include "rtc_base/thread.h"
@@ -605,8 +606,11 @@ void DcSctpTransport::ConnectTransportSignals() {
   }
   transport_->SignalWritableState.connect(
       this, &DcSctpTransport::OnTransportWritableState);
-  transport_->SignalReadPacket.connect(this,
+  transport_->RegisterReceivedPacketCallback(
-                                       &DcSctpTransport::OnTransportReadPacket);
+      this, [&](rtc::PacketTransportInternal* transport,
+                const rtc::ReceivedPacket& packet) {
+        OnTransportReadPacket(transport, packet);
+      });
   transport_->SignalClosed.connect(this, &DcSctpTransport::OnTransportClosed);
 }
 
@@ -616,7 +620,7 @@ void DcSctpTransport::DisconnectTransportSignals() {
     return;
   }
   transport_->SignalWritableState.disconnect(this);
-  transport_->SignalReadPacket.disconnect(this);
+  transport_->DeregisterReceivedPacketCallback(this);
   transport_->SignalClosed.disconnect(this);
 }
 
@@ -632,21 +636,17 @@ void DcSctpTransport::OnTransportWritableState(
 
 void DcSctpTransport::OnTransportReadPacket(
     rtc::PacketTransportInternal* transport,
-    const char* data,
+    const rtc::ReceivedPacket& packet) {
-    size_t length,
-    const int64_t& /* packet_time_us */,
-    int flags) {
   RTC_DCHECK_RUN_ON(network_thread_);
-  if (flags) {
+  if (packet.decryption_info() != rtc::ReceivedPacket::kDtlsDecrypted) {
     // We are only interested in SCTP packets.
     return;
   }
 
-  RTC_DLOG(LS_VERBOSE) << debug_name_
+  RTC_DLOG(LS_VERBOSE) << debug_name_ << "->OnTransportReadPacket(), length="
-                       << "->OnTransportReadPacket(), length=" << length;
+                       << packet.payload().size();
   if (socket_) {
-    socket_->ReceivePacket(rtc::ArrayView<const uint8_t>(
+    socket_->ReceivePacket(packet.payload());
-        reinterpret_cast<const uint8_t*>(data), length));
   }
 }
 

media/sctp/dcsctp_transport.h

@@ -27,6 +27,7 @@
 #include "p2p/base/packet_transport_internal.h"
 #include "rtc_base/containers/flat_map.h"
 #include "rtc_base/copy_on_write_buffer.h"
+#include "rtc_base/network/received_packet.h"
 #include "rtc_base/random.h"
 #include "rtc_base/third_party/sigslot/sigslot.h"
 #include "rtc_base/thread.h"
@@ -94,10 +95,7 @@ class DcSctpTransport : public cricket::SctpTransportInternal,
   void DisconnectTransportSignals();
   void OnTransportWritableState(rtc::PacketTransportInternal* transport);
   void OnTransportReadPacket(rtc::PacketTransportInternal* transport,
-                             const char* data,
+                             const rtc::ReceivedPacket& packet);
-                             size_t length,
-                             const int64_t& /* packet_time_us */,
-                             int flags);
   void OnTransportClosed(rtc::PacketTransportInternal* transport);
 
   void MaybeConnectSocket();

p2p/BUILD.gn

@@ -1100,6 +1100,7 @@ if (rtc_include_tests) {
       "../rtc_base:socket_server",
       "../rtc_base:ssl",
       "../rtc_base:threading",
+      "../rtc_base/network:received_packet",
       "../rtc_base/third_party/sigslot",
       "../test:test_support",
     ]

p2p/base/fake_dtls_transport.h

@@ -22,6 +22,7 @@
 #include "p2p/base/dtls_transport_internal.h"
 #include "p2p/base/fake_ice_transport.h"
 #include "rtc_base/fake_ssl_identity.h"
+#include "rtc_base/network/received_packet.h"
 #include "rtc_base/rtc_certificate.h"
 
 namespace cricket {
@@ -37,8 +38,11 @@ class FakeDtlsTransport : public DtlsTransportInternal {
         component_(ice_transport->component()),
         dtls_fingerprint_("", nullptr) {
     RTC_DCHECK(ice_transport_);
-    ice_transport_->SignalReadPacket.connect(
+    ice_transport_->RegisterReceivedPacketCallback(
-        this, &FakeDtlsTransport::OnIceTransportReadPacket);
+        this, [&](rtc::PacketTransportInternal* transport,
+                  const rtc::ReceivedPacket& packet) {
+          OnIceTransportReadPacket(transport, packet);
+        });
     ice_transport_->SignalNetworkRouteChanged.connect(
         this, &FakeDtlsTransport::OnNetworkRouteChanged);
   }
@@ -49,8 +53,11 @@ class FakeDtlsTransport : public DtlsTransportInternal {
         component_(owned_ice_transport_->component()),
         dtls_fingerprint_("", rtc::ArrayView<const uint8_t>()) {
     ice_transport_ = owned_ice_transport_.get();
-    ice_transport_->SignalReadPacket.connect(
+    ice_transport_->RegisterReceivedPacketCallback(
-        this, &FakeDtlsTransport::OnIceTransportReadPacket);
+        this, [&](rtc::PacketTransportInternal* transport,
+                  const rtc::ReceivedPacket& packet) {
+          OnIceTransportReadPacket(transport, packet);
+        });
     ice_transport_->SignalNetworkRouteChanged.connect(
         this, &FakeDtlsTransport::OnNetworkRouteChanged);
   }
@@ -71,6 +78,7 @@ class FakeDtlsTransport : public DtlsTransportInternal {
     if (dest_ && dest_->dest_ == this) {
       dest_->dest_ = nullptr;
     }
+    ice_transport_->DeregisterReceivedPacketCallback(this);
   }
 
   // Get inner fake ICE transport.
@@ -264,11 +272,8 @@ class FakeDtlsTransport : public DtlsTransportInternal {
 
  private:
   void OnIceTransportReadPacket(PacketTransportInternal* ice_,
-                                const char* data,
+                                const rtc::ReceivedPacket& packet) {
-                                size_t len,
+    NotifyPacketReceived(packet);
-                                const int64_t& packet_time_us,
-                                int flags) {
-    SignalReadPacket(this, data, len, packet_time_us, flags);
   }
 
   void set_receiving(bool receiving) {

pc/BUILD.gn

@@ -2121,6 +2121,7 @@ if (rtc_include_tests && !build_with_chromium) {
       "../rtc_base:threading",
       "../rtc_base:unique_id_generator",
       "../rtc_base/containers:flat_set",
+      "../rtc_base/network:received_packet",
       "../rtc_base/third_party/sigslot",
       "../system_wrappers:metrics",
       "../test:explicit_key_value_config",

pc/channel_unittest.cc

@@ -152,6 +152,19 @@ class ChannelTest : public ::testing::Test, public sigslot::has_slots<> {
       SendTask(network_thread_, [this]() {
         network_thread_safety_->SetNotAlive();
         DeinitChannels();
+
+        // Transports must be created and destroyed on the network thread.
+        fake_rtp_dtls_transport1_ = nullptr;
+        fake_rtcp_dtls_transport1_ = nullptr;
+        fake_rtp_dtls_transport2_ = nullptr;
+        fake_rtcp_dtls_transport2_ = nullptr;
+        fake_rtp_packet_transport1_ = nullptr;
+        fake_rtcp_packet_transport1_ = nullptr;
+        fake_rtp_packet_transport2_ = nullptr;
+        fake_rtcp_packet_transport2_ = nullptr;
+        rtp_transport1_ = nullptr;
+        rtp_transport2_ = nullptr;
+        new_rtp_transport_ = nullptr;
       });
     }
   }
@@ -187,66 +200,70 @@ class ChannelTest : public ::testing::Test, public sigslot::has_slots<> {
     // channels.
     RTC_DCHECK_EQ(flags1 & RAW_PACKET_TRANSPORT, flags2 & RAW_PACKET_TRANSPORT);
     rtc::Thread* worker_thread = rtc::Thread::Current();
-    // Based on flags, create fake DTLS or raw packet transports.
+
-    if (flags1 & RAW_PACKET_TRANSPORT) {
+    network_thread_->BlockingCall([&] {
-      fake_rtp_packet_transport1_.reset(
+      // Based on flags, create fake DTLS or raw packet transports.
-          new rtc::FakePacketTransport("channel1_rtp"));
+
-      if (!(flags1 & RTCP_MUX)) {
+      if (flags1 & RAW_PACKET_TRANSPORT) {
-        fake_rtcp_packet_transport1_.reset(
+        fake_rtp_packet_transport1_.reset(
-            new rtc::FakePacketTransport("channel1_rtcp"));
+            new rtc::FakePacketTransport("channel1_rtp"));
-      }
+        if (!(flags1 & RTCP_MUX)) {
-    } else {
+          fake_rtcp_packet_transport1_.reset(
-      // Confirmed to work with KT_RSA and KT_ECDSA.
+              new rtc::FakePacketTransport("channel1_rtcp"));
-      fake_rtp_dtls_transport1_.reset(new cricket::FakeDtlsTransport(
+        }
-          "channel1", cricket::ICE_CANDIDATE_COMPONENT_RTP, network_thread_));
+      } else {
-      if (!(flags1 & RTCP_MUX)) {
+        // Confirmed to work with KT_RSA and KT_ECDSA.
-        fake_rtcp_dtls_transport1_.reset(new cricket::FakeDtlsTransport(
+        fake_rtp_dtls_transport1_.reset(new cricket::FakeDtlsTransport(
-            "channel1", cricket::ICE_CANDIDATE_COMPONENT_RTCP,
+            "channel1", cricket::ICE_CANDIDATE_COMPONENT_RTP, network_thread_));
-            network_thread_));
+        if (!(flags1 & RTCP_MUX)) {
-      }
+          fake_rtcp_dtls_transport1_.reset(new cricket::FakeDtlsTransport(
-      if (flags1 & DTLS) {
+              "channel1", cricket::ICE_CANDIDATE_COMPONENT_RTCP,
-        auto cert1 = rtc::RTCCertificate::Create(
+              network_thread_));
-            rtc::SSLIdentity::Create("session1", rtc::KT_DEFAULT));
+        }
-        fake_rtp_dtls_transport1_->SetLocalCertificate(cert1);
+        if (flags1 & DTLS) {
-        if (fake_rtcp_dtls_transport1_) {
+          auto cert1 = rtc::RTCCertificate::Create(
-          fake_rtcp_dtls_transport1_->SetLocalCertificate(cert1);
+              rtc::SSLIdentity::Create("session1", rtc::KT_DEFAULT));
+          fake_rtp_dtls_transport1_->SetLocalCertificate(cert1);
+          if (fake_rtcp_dtls_transport1_) {
+            fake_rtcp_dtls_transport1_->SetLocalCertificate(cert1);
+          }
         }
       }
-    }
+      // Based on flags, create fake DTLS or raw packet transports.
-    // Based on flags, create fake DTLS or raw packet transports.
+      if (flags2 & RAW_PACKET_TRANSPORT) {
-    if (flags2 & RAW_PACKET_TRANSPORT) {
+        fake_rtp_packet_transport2_.reset(
-      fake_rtp_packet_transport2_.reset(
+            new rtc::FakePacketTransport("channel2_rtp"));
-          new rtc::FakePacketTransport("channel2_rtp"));
+        if (!(flags2 & RTCP_MUX)) {
-      if (!(flags2 & RTCP_MUX)) {
+          fake_rtcp_packet_transport2_.reset(
-        fake_rtcp_packet_transport2_.reset(
+              new rtc::FakePacketTransport("channel2_rtcp"));
-            new rtc::FakePacketTransport("channel2_rtcp"));
+        }
-      }
+      } else {
-    } else {
+        // Confirmed to work with KT_RSA and KT_ECDSA.
-      // Confirmed to work with KT_RSA and KT_ECDSA.
+        fake_rtp_dtls_transport2_.reset(new cricket::FakeDtlsTransport(
-      fake_rtp_dtls_transport2_.reset(new cricket::FakeDtlsTransport(
+            "channel2", cricket::ICE_CANDIDATE_COMPONENT_RTP, network_thread_));
-          "channel2", cricket::ICE_CANDIDATE_COMPONENT_RTP, network_thread_));
+        if (!(flags2 & RTCP_MUX)) {
-      if (!(flags2 & RTCP_MUX)) {
+          fake_rtcp_dtls_transport2_.reset(new cricket::FakeDtlsTransport(
-        fake_rtcp_dtls_transport2_.reset(new cricket::FakeDtlsTransport(
+              "channel2", cricket::ICE_CANDIDATE_COMPONENT_RTCP,
-            "channel2", cricket::ICE_CANDIDATE_COMPONENT_RTCP,
+              network_thread_));
-            network_thread_));
+        }
-      }
+        if (flags2 & DTLS) {
-      if (flags2 & DTLS) {
+          auto cert2 = rtc::RTCCertificate::Create(
-        auto cert2 = rtc::RTCCertificate::Create(
+              rtc::SSLIdentity::Create("session2", rtc::KT_DEFAULT));
-            rtc::SSLIdentity::Create("session2", rtc::KT_DEFAULT));
+          fake_rtp_dtls_transport2_->SetLocalCertificate(cert2);
-        fake_rtp_dtls_transport2_->SetLocalCertificate(cert2);
+          if (fake_rtcp_dtls_transport2_) {
-        if (fake_rtcp_dtls_transport2_) {
+            fake_rtcp_dtls_transport2_->SetLocalCertificate(cert2);
-          fake_rtcp_dtls_transport2_->SetLocalCertificate(cert2);
+          }
         }
       }
-    }
+      rtp_transport1_ = CreateRtpTransportBasedOnFlags(
-    rtp_transport1_ = CreateRtpTransportBasedOnFlags(
+          fake_rtp_packet_transport1_.get(), fake_rtcp_packet_transport1_.get(),
-        fake_rtp_packet_transport1_.get(), fake_rtcp_packet_transport1_.get(),
+          fake_rtp_dtls_transport1_.get(), fake_rtcp_dtls_transport1_.get(),
-        fake_rtp_dtls_transport1_.get(), fake_rtcp_dtls_transport1_.get(),
+          flags1);
-        flags1);
+      rtp_transport2_ = CreateRtpTransportBasedOnFlags(
-    rtp_transport2_ = CreateRtpTransportBasedOnFlags(
+          fake_rtp_packet_transport2_.get(), fake_rtcp_packet_transport2_.get(),
-        fake_rtp_packet_transport2_.get(), fake_rtcp_packet_transport2_.get(),
+          fake_rtp_dtls_transport2_.get(), fake_rtcp_dtls_transport2_.get(),
-        fake_rtp_dtls_transport2_.get(), fake_rtcp_dtls_transport2_.get(),
+          flags2);
-        flags2);
+    });
 
     channel1_ = CreateChannel(worker_thread, network_thread_, std::move(ch1s),
                               std::move(ch1r), rtp_transport1_.get(), flags1);
@@ -1351,12 +1368,11 @@ class ChannelTest : public ::testing::Test, public sigslot::has_slots<> {
 
     CreateChannels(DTLS, DTLS);
 
-    new_rtp_transport_ = CreateDtlsSrtpTransport(
-        fake_rtp_dtls_transport2_.get(), fake_rtcp_dtls_transport2_.get());
-
     bool rcv_success, send_success;
     int rcv_buf, send_buf;
     SendTask(network_thread_, [&] {
+      new_rtp_transport_ = CreateDtlsSrtpTransport(
+          fake_rtp_dtls_transport2_.get(), fake_rtcp_dtls_transport2_.get());
       channel1_->SetOption(cricket::BaseChannel::ST_RTP,
                            rtc::Socket::Option::OPT_SNDBUF, kSndBufSize);
       channel2_->SetOption(cricket::BaseChannel::ST_RTP,

pc/jsep_transport_unittest.cc

@@ -31,6 +31,7 @@
 #include "rtc_base/helpers.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/net_helper.h"
+#include "rtc_base/network/received_packet.h"
 #include "rtc_base/socket_address.h"
 #include "rtc_base/ssl_certificate.h"
 #include "rtc_base/ssl_identity.h"
@@ -1039,42 +1040,44 @@ class JsepTransport2HeaderExtensionTest
     auto fake_dtls2 =
         static_cast<FakeDtlsTransport*>(jsep_transport2_->rtp_dtls_transport());
 
-    fake_dtls1->fake_ice_transport()->SignalReadPacket.connect(
+    fake_dtls1->fake_ice_transport()->RegisterReceivedPacketCallback(
-        this, &JsepTransport2HeaderExtensionTest::OnReadPacket1);
+        this, [&](rtc::PacketTransportInternal* transport,
-    fake_dtls2->fake_ice_transport()->SignalReadPacket.connect(
+                  const rtc::ReceivedPacket& packet) {
-        this, &JsepTransport2HeaderExtensionTest::OnReadPacket2);
+          OnReadPacket1(transport, packet);
+        });
+    fake_dtls2->fake_ice_transport()->RegisterReceivedPacketCallback(
+        this, [&](rtc::PacketTransportInternal* transport,
+                  const rtc::ReceivedPacket& packet) {
+          OnReadPacket2(transport, packet);
+        });
 
-      auto cert1 = rtc::RTCCertificate::Create(
+    auto cert1 = rtc::RTCCertificate::Create(
-          rtc::SSLIdentity::Create("session1", rtc::KT_DEFAULT));
+        rtc::SSLIdentity::Create("session1", rtc::KT_DEFAULT));
-      jsep_transport1_->rtp_dtls_transport()->SetLocalCertificate(cert1);
+    jsep_transport1_->rtp_dtls_transport()->SetLocalCertificate(cert1);
-      auto cert2 = rtc::RTCCertificate::Create(
+    auto cert2 = rtc::RTCCertificate::Create(
-          rtc::SSLIdentity::Create("session1", rtc::KT_DEFAULT));
+        rtc::SSLIdentity::Create("session1", rtc::KT_DEFAULT));
-      jsep_transport2_->rtp_dtls_transport()->SetLocalCertificate(cert2);
+    jsep_transport2_->rtp_dtls_transport()->SetLocalCertificate(cert2);
   }
 
   void OnReadPacket1(rtc::PacketTransportInternal* transport,
-                     const char* data,
+                     const rtc::ReceivedPacket& packet) {
-                     size_t size,
-                     const int64_t& /* packet_time_us */,
-                     int flags) {
     RTC_LOG(LS_INFO) << "JsepTransport 1 Received a packet.";
     CompareHeaderExtensions(
         reinterpret_cast<const char*>(kPcmuFrameWithExtensions),
-        sizeof(kPcmuFrameWithExtensions), data, size, recv_encrypted_headers1_,
+        sizeof(kPcmuFrameWithExtensions),
-        false);
+        reinterpret_cast<const char*>(packet.payload().data()),
+        packet.payload().size(), recv_encrypted_headers1_, false);
     received_packet_count_++;
   }
 
   void OnReadPacket2(rtc::PacketTransportInternal* transport,
-                     const char* data,
+                     const rtc::ReceivedPacket& packet) {
-                     size_t size,
-                     const int64_t& /* packet_time_us */,
-                     int flags) {
     RTC_LOG(LS_INFO) << "JsepTransport 2 Received a packet.";
     CompareHeaderExtensions(
         reinterpret_cast<const char*>(kPcmuFrameWithExtensions),
-        sizeof(kPcmuFrameWithExtensions), data, size, recv_encrypted_headers2_,
+        sizeof(kPcmuFrameWithExtensions),
-        false);
+        reinterpret_cast<const char*>(packet.payload().data()),
+        packet.payload().size(), recv_encrypted_headers2_, false);
     received_packet_count_++;
   }
 

pc/rtp_transport.cc

@@ -54,7 +54,7 @@ void RtpTransport::SetRtpPacketTransport(
   }
   if (rtp_packet_transport_) {
     rtp_packet_transport_->SignalReadyToSend.disconnect(this);
-    rtp_packet_transport_->SignalReadPacket.disconnect(this);
+    rtp_packet_transport_->DeregisterReceivedPacketCallback(this);
     rtp_packet_transport_->SignalNetworkRouteChanged.disconnect(this);
     rtp_packet_transport_->SignalWritableState.disconnect(this);
     rtp_packet_transport_->SignalSentPacket.disconnect(this);
@@ -64,8 +64,11 @@ void RtpTransport::SetRtpPacketTransport(
   if (new_packet_transport) {
     new_packet_transport->SignalReadyToSend.connect(
         this, &RtpTransport::OnReadyToSend);
-    new_packet_transport->SignalReadPacket.connect(this,
+    new_packet_transport->RegisterReceivedPacketCallback(
-                                                   &RtpTransport::OnReadPacket);
+        this, [&](rtc::PacketTransportInternal* transport,
+                  const rtc::ReceivedPacket& packet) {
+          OnReadPacket(transport, packet);
+        });
     new_packet_transport->SignalNetworkRouteChanged.connect(
         this, &RtpTransport::OnNetworkRouteChanged);
     new_packet_transport->SignalWritableState.connect(
@@ -90,7 +93,7 @@ void RtpTransport::SetRtcpPacketTransport(
   }
   if (rtcp_packet_transport_) {
     rtcp_packet_transport_->SignalReadyToSend.disconnect(this);
-    rtcp_packet_transport_->SignalReadPacket.disconnect(this);
+    rtcp_packet_transport_->DeregisterReceivedPacketCallback(this);
     rtcp_packet_transport_->SignalNetworkRouteChanged.disconnect(this);
     rtcp_packet_transport_->SignalWritableState.disconnect(this);
     rtcp_packet_transport_->SignalSentPacket.disconnect(this);
@@ -100,8 +103,11 @@ void RtpTransport::SetRtcpPacketTransport(
   if (new_packet_transport) {
     new_packet_transport->SignalReadyToSend.connect(
         this, &RtpTransport::OnReadyToSend);
-    new_packet_transport->SignalReadPacket.connect(this,
+    new_packet_transport->RegisterReceivedPacketCallback(
-                                                   &RtpTransport::OnReadPacket);
+        this, [&](rtc::PacketTransportInternal* transport,
+                  const rtc::ReceivedPacket& packet) {
+          OnReadPacket(transport, packet);
+        });
     new_packet_transport->SignalNetworkRouteChanged.connect(
         this, &RtpTransport::OnNetworkRouteChanged);
     new_packet_transport->SignalWritableState.connect(
@@ -251,30 +257,34 @@ void RtpTransport::OnRtcpPacketReceived(rtc::CopyOnWriteBuffer packet,
 }
 
 void RtpTransport::OnReadPacket(rtc::PacketTransportInternal* transport,
-                                const char* data,
+                                const rtc::ReceivedPacket& received_packet) {
-                                size_t len,
-                                const int64_t& packet_time_us,
-                                int flags) {
   TRACE_EVENT0("webrtc", "RtpTransport::OnReadPacket");
 
   // When using RTCP multiplexing we might get RTCP packets on the RTP
   // transport. We check the RTP payload type to determine if it is RTCP.
-  auto array_view = rtc::MakeArrayView(data, len);
+  cricket::RtpPacketType packet_type =
-  cricket::RtpPacketType packet_type = cricket::InferRtpPacketType(array_view);
+      cricket::InferRtpPacketType(received_packet.payload());
   // Filter out the packet that is neither RTP nor RTCP.
   if (packet_type == cricket::RtpPacketType::kUnknown) {
     return;
   }
 
   // Protect ourselves against crazy data.
-  if (!cricket::IsValidRtpPacketSize(packet_type, len)) {
+  if (!cricket::IsValidRtpPacketSize(packet_type,
+                                     received_packet.payload().size())) {
     RTC_LOG(LS_ERROR) << "Dropping incoming "
                       << cricket::RtpPacketTypeToString(packet_type)
-                      << " packet: wrong size=" << len;
+                      << " packet: wrong size="
+                      << received_packet.payload().size();
     return;
   }
 
-  rtc::CopyOnWriteBuffer packet(data, len);
+  rtc::CopyOnWriteBuffer packet(received_packet.payload());
+  int64_t packet_time_us = received_packet.arrival_time()
+                               ? received_packet.arrival_time()->us()
+                               : -1;
+  // TODO(bugs.webrtc.org/15368): Propagate timestamp and received packet
+  // metadata further.
   if (packet_type == cricket::RtpPacketType::kRtcp) {
     OnRtcpPacketReceived(std::move(packet), packet_time_us);
   } else {

pc/rtp_transport.h

@@ -113,10 +113,7 @@ class RtpTransport : public RtpTransportInternal {
   void OnSentPacket(rtc::PacketTransportInternal* packet_transport,
                     const rtc::SentPacket& sent_packet);
   void OnReadPacket(rtc::PacketTransportInternal* transport,
-                    const char* data,
+                    const rtc::ReceivedPacket& received_packet);
-                    size_t len,
-                    const int64_t& packet_time_us,
-                    int flags);
 
   // Updates "ready to send" for an individual channel and fires
   // SignalReadyToSend.