Add Connection::OnReadPacket(const rtc::PacketReceived&)

Deprecate old version but keep it for the time being.

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

p2p/BUILD.gn

@@ -294,6 +294,7 @@ if (rtc_include_tests) {
       ":p2p_server_utils",
       ":p2p_test_utils",
       ":rtc_p2p",
+      "../api:array_view",
       "../api:candidate",
       "../api:dtls_transport_interface",
       "../api:field_trials_view",
@@ -332,6 +333,7 @@ if (rtc_include_tests) {
       "../rtc_base:testclient",
       "../rtc_base:threading",
       "../rtc_base:timeutils",
+      "../rtc_base/network:received_packet",
       "../rtc_base/network:sent_packet",
       "../rtc_base/third_party/sigslot",
       "../system_wrappers:metrics",

p2p/base/connection.cc

@@ -466,27 +466,25 @@ void Connection::DeregisterReceivedPacketCallback() {
 void Connection::OnReadPacket(const char* data,
                               size_t size,
                               int64_t packet_time_us) {
+  OnReadPacket(
+      rtc::ReceivedPacket::CreateFromLegacy(data, size, packet_time_us));
+}
+void Connection::OnReadPacket(const rtc::ReceivedPacket& packet) {
   RTC_DCHECK_RUN_ON(network_thread_);
   std::unique_ptr<IceMessage> msg;
   std::string remote_ufrag;
   const rtc::SocketAddress& addr(remote_candidate_.address());
-  if (!port_->GetStunMessage(data, size, addr, &msg, &remote_ufrag)) {
+  if (!port_->GetStunMessage(
+          reinterpret_cast<const char*>(packet.payload().data()),
+          packet.payload().size(), addr, &msg, &remote_ufrag)) {
     // The packet did not parse as a valid STUN message
     // This is a data packet, pass it along.
     last_data_received_ = rtc::TimeMillis();
     UpdateReceiving(last_data_received_);
-    recv_rate_tracker_.AddSamples(size);
+    recv_rate_tracker_.AddSamples(packet.payload().size());
     stats_.packets_received++;
     if (received_packet_callback_) {
-      RTC_DCHECK(packet_time_us == -1 || packet_time_us >= 0);
+      received_packet_callback_(this, packet);
-      received_packet_callback_(
-          this, rtc::ReceivedPacket(
-                    rtc::reinterpret_array_view<const uint8_t>(
-                        rtc::MakeArrayView(data, size)),
-                    (packet_time_us >= 0)
-                        ? absl::optional<webrtc::Timestamp>(
-                              webrtc::Timestamp::Micros(packet_time_us))
-                        : absl::nullopt));
     }
     // If timed out sending writability checks, start up again
     if (!pruned_ && (write_state_ == STATE_WRITE_TIMEOUT)) {

p2p/base/connection.h

@@ -156,7 +156,9 @@ class RTC_EXPORT Connection : public CandidatePairInterface {
   sigslot::signal1<Connection*> SignalReadyToSend;
 
   // Called when a packet is received on this connection.
-  void OnReadPacket(const char* data, size_t size, int64_t packet_time_us);
+  void OnReadPacket(const rtc::ReceivedPacket& packet);
+  [[deprecated("Pass a rtc::ReceivedPacket")]] void
+  OnReadPacket(const char* data, size_t size, int64_t packet_time_us);
 
   // Called when the socket is currently able to send.
   void OnReadyToSend();

p2p/base/p2p_transport_channel_unittest.cc

@@ -45,11 +45,13 @@
 #include "rtc_base/mdns_responder_interface.h"
 #include "rtc_base/nat_server.h"
 #include "rtc_base/nat_socket_factory.h"
+#include "rtc_base/network/received_packet.h"
 #include "rtc_base/proxy_server.h"
 #include "rtc_base/socket_address.h"
 #include "rtc_base/ssl_adapter.h"
 #include "rtc_base/strings/string_builder.h"
 #include "rtc_base/thread.h"
+#include "rtc_base/time_utils.h"
 #include "rtc_base/virtual_socket_server.h"
 #include "system_wrappers/include/metrics.h"
 #include "test/scoped_key_value_config.h"
@@ -3595,7 +3597,8 @@ class P2PTransportChannelPingTest : public ::testing::Test,
     msg.AddFingerprint();
     rtc::ByteBufferWriter buf;
     msg.Write(&buf);
-    conn->OnReadPacket(buf.Data(), buf.Length(), rtc::TimeMicros());
+    conn->OnReadPacket(rtc::ReceivedPacket::CreateFromLegacy(
+        buf.Data(), buf.Length(), rtc::TimeMicros()));
   }
 
   void ReceivePingOnConnection(Connection* conn,
@@ -4060,7 +4063,9 @@ TEST_F(P2PTransportChannelPingTest, TestReceivingStateChange) {
 
   clock.AdvanceTime(webrtc::TimeDelta::Seconds(1));
   conn1->ReceivedPing();
-  conn1->OnReadPacket("ABC", 3, rtc::TimeMicros());
+  conn1->OnReadPacket(
+      rtc::ReceivedPacket::CreateFromLegacy("ABC", 3, rtc::TimeMicros()));
+
   EXPECT_TRUE_SIMULATED_WAIT(ch.receiving(), kShortTimeout, clock);
   EXPECT_TRUE_SIMULATED_WAIT(!ch.receiving(), kShortTimeout, clock);
 }
@@ -4370,7 +4375,8 @@ TEST_F(P2PTransportChannelPingTest, TestSelectConnectionBasedOnMediaReceived) {
   Connection* conn2 = WaitForConnectionTo(&ch, "2.2.2.2", 2);
   ASSERT_TRUE(conn2 != nullptr);
   conn2->ReceivedPingResponse(LOW_RTT, "id");  // Become writable and receiving.
-  conn2->OnReadPacket("ABC", 3, rtc::TimeMicros());
+  conn2->OnReadPacket(
+      rtc::ReceivedPacket::CreateFromLegacy("ABC", 3, rtc::TimeMicros()));
   EXPECT_EQ(conn2, ch.selected_connection());
   conn2->ReceivedPingResponse(LOW_RTT, "id");  // Become writable.
 
@@ -4397,7 +4403,8 @@ TEST_F(P2PTransportChannelPingTest, TestSelectConnectionBasedOnMediaReceived) {
   // selected connection was nominated by the controlling side.
   conn2->ReceivedPing();
   conn2->ReceivedPingResponse(LOW_RTT, "id");
-  conn2->OnReadPacket("XYZ", 3, rtc::TimeMicros());
+  conn2->OnReadPacket(
+      rtc::ReceivedPacket::CreateFromLegacy("XYZ", 3, rtc::TimeMicros()));
   EXPECT_EQ_WAIT(conn3, ch.selected_connection(), kDefaultTimeout);
 }
 
@@ -4427,12 +4434,15 @@ TEST_F(P2PTransportChannelPingTest,
   // Advance the clock by 1ms so that the last data receiving timestamp of
   // conn2 is larger.
   SIMULATED_WAIT(false, 1, clock);
-  conn2->OnReadPacket("XYZ", 3, rtc::TimeMicros());
+
+  conn2->OnReadPacket(
+      rtc::ReceivedPacket::CreateFromLegacy("XYZ", 3, rtc::TimeMicros()));
   EXPECT_EQ(1, reset_selected_candidate_pair_switches());
   EXPECT_TRUE(CandidatePairMatchesNetworkRoute(conn2));
 
   // conn1 also receives data; it becomes selected due to priority again.
-  conn1->OnReadPacket("XYZ", 3, rtc::TimeMicros());
+  conn1->OnReadPacket(
+      rtc::ReceivedPacket::CreateFromLegacy("ABC", 3, rtc::TimeMicros()));
   EXPECT_EQ(1, reset_selected_candidate_pair_switches());
   EXPECT_TRUE(CandidatePairMatchesNetworkRoute(conn2));
 
@@ -4441,7 +4451,8 @@ TEST_F(P2PTransportChannelPingTest,
   SIMULATED_WAIT(false, 1, clock);
   // Need to become writable again because it was pruned.
   conn2->ReceivedPingResponse(LOW_RTT, "id");
-  conn2->OnReadPacket("XYZ", 3, rtc::TimeMicros());
+  conn2->OnReadPacket(
+      rtc::ReceivedPacket::CreateFromLegacy("ABC", 3, rtc::TimeMicros()));
   EXPECT_EQ(1, reset_selected_candidate_pair_switches());
   EXPECT_TRUE(CandidatePairMatchesNetworkRoute(conn2));
 
@@ -4472,7 +4483,9 @@ TEST_F(P2PTransportChannelPingTest,
   // conn1 received data; it is the selected connection.
   // Advance the clock to have a non-zero last-data-receiving time.
   SIMULATED_WAIT(false, 1, clock);
-  conn1->OnReadPacket("XYZ", 3, rtc::TimeMicros());
+
+  conn1->OnReadPacket(
+      rtc::ReceivedPacket::CreateFromLegacy("XYZ", 3, rtc::TimeMicros()));
   EXPECT_EQ(1, reset_selected_candidate_pair_switches());
   EXPECT_TRUE(CandidatePairMatchesNetworkRoute(conn1));
 
@@ -4572,7 +4585,8 @@ TEST_F(P2PTransportChannelPingTest, TestEstimatedDisconnectedTime) {
   {
     clock.AdvanceTime(webrtc::TimeDelta::Seconds(1));
     // This will not parse as STUN, and is considered data
-    conn1->OnReadPacket("XYZ", 3, rtc::TimeMicros());
+    conn1->OnReadPacket(
+        rtc::ReceivedPacket::CreateFromLegacy("XYZ", 3, rtc::TimeMicros()));
     clock.AdvanceTime(webrtc::TimeDelta::Seconds(2));
 
     // conn2 is nominated; it becomes selected.
@@ -4584,8 +4598,8 @@ TEST_F(P2PTransportChannelPingTest, TestEstimatedDisconnectedTime) {
 
   {
     clock.AdvanceTime(webrtc::TimeDelta::Seconds(1));
-    conn2->OnReadPacket("XYZ", 3, rtc::TimeMicros());
+    conn2->OnReadPacket(
-
+        rtc::ReceivedPacket::CreateFromLegacy("XYZ", 3, rtc::TimeMicros()));
     clock.AdvanceTime(webrtc::TimeDelta::Seconds(2));
     ReceivePingOnConnection(conn2, kIceUfrag[1], 1, nomination++);
 
@@ -4758,7 +4772,8 @@ TEST_F(P2PTransportChannelPingTest, TestDontPruneHighPriorityConnections) {
   // conn2.
   NominateConnection(conn1);
   SIMULATED_WAIT(false, 1, clock);
-  conn1->OnReadPacket("XYZ", 3, rtc::TimeMicros());
+  conn1->OnReadPacket(
+      rtc::ReceivedPacket::CreateFromLegacy("XYZ", 3, rtc::TimeMicros()));
   SIMULATED_WAIT(conn2->pruned(), 100, clock);
   EXPECT_FALSE(conn2->pruned());
 }

p2p/base/port_unittest.cc

@@ -23,6 +23,7 @@
 #include "absl/memory/memory.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
+#include "api/array_view.h"
 #include "api/candidate.h"
 #include "api/packet_socket_factory.h"
 #include "api/transport/stun.h"
@@ -55,6 +56,7 @@
 #include "rtc_base/nat_types.h"
 #include "rtc_base/net_helper.h"
 #include "rtc_base/network.h"
+#include "rtc_base/network/received_packet.h"
 #include "rtc_base/network/sent_packet.h"
 #include "rtc_base/network_constants.h"
 #include "rtc_base/proxy_info.h"
@@ -162,8 +164,11 @@ class TestPort : public Port {
   using cricket::Port::GetStunMessage;
 
   // The last StunMessage that was sent on this Port.
-  // TODO(?): Make these const; requires changes to SendXXXXResponse.
+  rtc::ArrayView<const uint8_t> last_stun_buf() {
-  rtc::BufferT<uint8_t>* last_stun_buf() { return last_stun_buf_.get(); }
+    if (!last_stun_buf_)
+      return rtc::ArrayView<const uint8_t>();
+    return *last_stun_buf_;
+  }
   IceMessage* last_stun_msg() { return last_stun_msg_.get(); }
   int last_stun_error_code() {
     int code = 0;
@@ -260,14 +265,15 @@ static void SendPingAndReceiveResponse(Connection* lconn,
                                        int64_t ms) {
   lconn->Ping(rtc::TimeMillis());
   ASSERT_TRUE_WAIT(lport->last_stun_msg(), kDefaultTimeout);
-  ASSERT_TRUE(lport->last_stun_buf());
+  ASSERT_GT(lport->last_stun_buf().size(), 0u);
-  rconn->OnReadPacket(lport->last_stun_buf()->data<char>(),
+  rconn->OnReadPacket(
-                      lport->last_stun_buf()->size(), /* packet_time_us */ -1);
+      rtc::ReceivedPacket(lport->last_stun_buf(), absl::nullopt));
+
   clock->AdvanceTime(webrtc::TimeDelta::Millis(ms));
   ASSERT_TRUE_WAIT(rport->last_stun_msg(), kDefaultTimeout);
-  ASSERT_TRUE(rport->last_stun_buf());
+  ASSERT_GT(rport->last_stun_buf().size(), 0u);
-  lconn->OnReadPacket(rport->last_stun_buf()->data<char>(),
+  lconn->OnReadPacket(
-                      rport->last_stun_buf()->size(), /* packet_time_us */ -1);
+      rtc::ReceivedPacket(rport->last_stun_buf(), absl::nullopt));
 }
 
 class TestChannel : public sigslot::has_slots<> {
@@ -1488,8 +1494,8 @@ TEST_F(PortTest, TestLoopbackCall) {
   ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, kDefaultTimeout);
   IceMessage* msg = lport->last_stun_msg();
   EXPECT_EQ(STUN_BINDING_REQUEST, msg->type());
-  conn->OnReadPacket(lport->last_stun_buf()->data<char>(),
+  conn->OnReadPacket(
-                     lport->last_stun_buf()->size(), /* packet_time_us */ -1);
+      rtc::ReceivedPacket(lport->last_stun_buf(), absl::nullopt));
   ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, kDefaultTimeout);
   msg = lport->last_stun_msg();
   EXPECT_EQ(STUN_BINDING_RESPONSE, msg->type());
@@ -1522,7 +1528,10 @@ TEST_F(PortTest, TestLoopbackCall) {
   lport->Reset();
   auto buf = std::make_unique<ByteBufferWriter>();
   WriteStunMessage(*modified_req, buf.get());
-  conn1->OnReadPacket(buf->Data(), buf->Length(), /* packet_time_us */ -1);
+  conn1->OnReadPacket(
+      rtc::ReceivedPacket(rtc::reinterpret_array_view<const uint8_t>(
+                              rtc::MakeArrayView(buf->Data(), buf->Length())),
+                          absl::nullopt));
   ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, kDefaultTimeout);
   msg = lport->last_stun_msg();
   EXPECT_EQ(STUN_BINDING_ERROR_RESPONSE, msg->type());
@@ -1555,8 +1564,8 @@ TEST_F(PortTest, TestIceRoleConflict) {
   IceMessage* msg = rport->last_stun_msg();
   EXPECT_EQ(STUN_BINDING_REQUEST, msg->type());
   // Send rport binding request to lport.
-  lconn->OnReadPacket(rport->last_stun_buf()->data<char>(),
+  lconn->OnReadPacket(
-                      rport->last_stun_buf()->size(), /* packet_time_us */ -1);
+      rtc::ReceivedPacket(rport->last_stun_buf(), absl::nullopt));
 
   ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, kDefaultTimeout);
   EXPECT_EQ(STUN_BINDING_RESPONSE, lport->last_stun_msg()->type());
@@ -1878,7 +1887,8 @@ TEST_F(PortTest, TestSendStunMessage) {
   EXPECT_TRUE(msg->GetByteString(STUN_ATTR_USE_CANDIDATE) != NULL);
   EXPECT_TRUE(msg->GetUInt32(STUN_ATTR_FINGERPRINT) != NULL);
   EXPECT_TRUE(StunMessage::ValidateFingerprint(
-      lport->last_stun_buf()->data<char>(), lport->last_stun_buf()->size()));
+      reinterpret_cast<const char*>(lport->last_stun_buf().data()),
+      lport->last_stun_buf().size()));
 
   // Request should not include ping count.
   ASSERT_TRUE(msg->GetUInt32(STUN_ATTR_RETRANSMIT_COUNT) == NULL);
@@ -1887,14 +1897,15 @@ TEST_F(PortTest, TestSendStunMessage) {
   std::unique_ptr<IceMessage> request = CopyStunMessage(*msg);
 
   // Receive the BINDING-REQUEST and respond with BINDING-RESPONSE.
-  rconn->OnReadPacket(lport->last_stun_buf()->data<char>(),
+  rconn->OnReadPacket(
-                      lport->last_stun_buf()->size(), /* packet_time_us */ -1);
+      rtc::ReceivedPacket(lport->last_stun_buf(), absl::nullopt));
   msg = rport->last_stun_msg();
   ASSERT_TRUE(msg != NULL);
   EXPECT_EQ(STUN_BINDING_RESPONSE, msg->type());
   // Received a BINDING-RESPONSE.
-  lconn->OnReadPacket(rport->last_stun_buf()->data<char>(),
+  lconn->OnReadPacket(
-                      rport->last_stun_buf()->size(), /* packet_time_us */ -1);
+      rtc::ReceivedPacket(rport->last_stun_buf(), absl::nullopt));
+
   // Verify the STUN Stats.
   EXPECT_EQ(1U, lconn->stats().sent_ping_requests_total);
   EXPECT_EQ(1U, lconn->stats().sent_ping_requests_before_first_response);
@@ -1912,7 +1923,8 @@ TEST_F(PortTest, TestSendStunMessage) {
             msg->ValidateMessageIntegrity("rpass"));
   EXPECT_TRUE(msg->GetUInt32(STUN_ATTR_FINGERPRINT) != NULL);
   EXPECT_TRUE(StunMessage::ValidateFingerprint(
-      lport->last_stun_buf()->data<char>(), lport->last_stun_buf()->size()));
+      reinterpret_cast<const char*>(lport->last_stun_buf().data()),
+      lport->last_stun_buf().size()));
   // No USERNAME or PRIORITY in ICE responses.
   EXPECT_TRUE(msg->GetByteString(STUN_ATTR_USERNAME) == NULL);
   EXPECT_TRUE(msg->GetByteString(STUN_ATTR_PRIORITY) == NULL);
@@ -1942,7 +1954,8 @@ TEST_F(PortTest, TestSendStunMessage) {
             msg->ValidateMessageIntegrity("rpass"));
   EXPECT_TRUE(msg->GetUInt32(STUN_ATTR_FINGERPRINT) != NULL);
   EXPECT_TRUE(StunMessage::ValidateFingerprint(
-      lport->last_stun_buf()->data<char>(), lport->last_stun_buf()->size()));
+      reinterpret_cast<const char*>(lport->last_stun_buf().data()),
+      lport->last_stun_buf().size()));
   // No USERNAME with ICE.
   EXPECT_TRUE(msg->GetByteString(STUN_ATTR_USERNAME) == NULL);
   EXPECT_TRUE(msg->GetByteString(STUN_ATTR_PRIORITY) == NULL);
@@ -1971,12 +1984,12 @@ TEST_F(PortTest, TestSendStunMessage) {
 
   // Respond with a BINDING-RESPONSE.
   request = CopyStunMessage(*msg);
-  lconn->OnReadPacket(rport->last_stun_buf()->data<char>(),
+  lconn->OnReadPacket(
-                      rport->last_stun_buf()->size(), /* packet_time_us */ -1);
+      rtc::ReceivedPacket(rport->last_stun_buf(), absl::nullopt));
   msg = lport->last_stun_msg();
   // Receive the BINDING-RESPONSE.
-  rconn->OnReadPacket(lport->last_stun_buf()->data<char>(),
+  rconn->OnReadPacket(
-                      lport->last_stun_buf()->size(), /* packet_time_us */ -1);
+      rtc::ReceivedPacket(lport->last_stun_buf(), absl::nullopt));
 
   // Verify the Stun ping stats.
   EXPECT_EQ(3U, rconn->stats().sent_ping_requests_total);
@@ -2026,9 +2039,10 @@ TEST_F(PortTest, TestNomination) {
   // should set the remote nomination of `rconn`.
   lconn->Ping(0);
   ASSERT_TRUE_WAIT(lport->last_stun_msg(), kDefaultTimeout);
-  ASSERT_TRUE(lport->last_stun_buf());
+  ASSERT_GT(lport->last_stun_buf().size(), 0u);
-  rconn->OnReadPacket(lport->last_stun_buf()->data<char>(),
+  rconn->OnReadPacket(
-                      lport->last_stun_buf()->size(), /* packet_time_us */ -1);
+      rtc::ReceivedPacket(lport->last_stun_buf(), absl::nullopt));
+
   EXPECT_EQ(nomination, rconn->remote_nomination());
   EXPECT_FALSE(lconn->nominated());
   EXPECT_TRUE(rconn->nominated());
@@ -2038,9 +2052,10 @@ TEST_F(PortTest, TestNomination) {
   // This should result in an acknowledgment sent back from `rconn` to `lconn`,
   // updating the acknowledged nomination of `lconn`.
   ASSERT_TRUE_WAIT(rport->last_stun_msg(), kDefaultTimeout);
-  ASSERT_TRUE(rport->last_stun_buf());
+  ASSERT_GT(rport->last_stun_buf().size(), 0u);
-  lconn->OnReadPacket(rport->last_stun_buf()->data<char>(),
+  lconn->OnReadPacket(
-                      rport->last_stun_buf()->size(), /* packet_time_us */ -1);
+      rtc::ReceivedPacket(rport->last_stun_buf(), absl::nullopt));
+
   EXPECT_EQ(nomination, lconn->acked_nomination());
   EXPECT_TRUE(lconn->nominated());
   EXPECT_TRUE(rconn->nominated());
@@ -2166,8 +2181,9 @@ TEST_F(PortTest, TestNetworkCostChange) {
   IceMessage* msg = lport->last_stun_msg();
   EXPECT_EQ(STUN_BINDING_REQUEST, msg->type());
   // Pass the binding request to rport.
-  rconn->OnReadPacket(lport->last_stun_buf()->data<char>(),
+  rconn->OnReadPacket(
-                      lport->last_stun_buf()->size(), /* packet_time_us */ -1);
+      rtc::ReceivedPacket(lport->last_stun_buf(), absl::nullopt));
+
   // Wait until rport sends the response and then check the remote network cost.
   ASSERT_TRUE_WAIT(rport->last_stun_msg() != NULL, kDefaultTimeout);
   EXPECT_EQ(rtc::kNetworkCostHigh, rconn->remote_candidate().network_cost());
@@ -2496,8 +2512,8 @@ TEST_F(PortTest,
   // Send request.
   lconn->Ping(0);
   ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, kDefaultTimeout);
-  rconn->OnReadPacket(lport->last_stun_buf()->data<char>(),
+  rconn->OnReadPacket(
-                      lport->last_stun_buf()->size(), /* packet_time_us */ -1);
+      rtc::ReceivedPacket(lport->last_stun_buf(), absl::nullopt));
 
   // Intercept request and add comprehension required attribute.
   ASSERT_TRUE_WAIT(rport->last_stun_msg() != NULL, kDefaultTimeout);
@@ -2507,7 +2523,10 @@ TEST_F(PortTest,
   modified_response->AddFingerprint();
   ByteBufferWriter buf;
   WriteStunMessage(*modified_response, &buf);
-  lconn->OnReadPacket(buf.Data(), buf.Length(), /* packet_time_us */ -1);
+  lconn->OnReadPacket(
+      rtc::ReceivedPacket(rtc::reinterpret_array_view<const uint8_t>(
+                              rtc::MakeArrayView(buf.Data(), buf.Length())),
+                          absl::nullopt));
   // Response should have been ignored, leaving us unwritable still.
   EXPECT_FALSE(lconn->writable());
 }
@@ -2535,7 +2554,10 @@ TEST_F(PortTest,
   in_msg->AddFingerprint();
   ByteBufferWriter buf;
   WriteStunMessage(*in_msg, &buf);
-  lconn->OnReadPacket(buf.Data(), buf.Length(), /* packet_time_us */ -1);
+  lconn->OnReadPacket(
+      rtc::ReceivedPacket(rtc::reinterpret_array_view<const uint8_t>(
+                              rtc::MakeArrayView(buf.Data(), buf.Length())),
+                          absl::nullopt));
   EXPECT_EQ(0u, lconn->last_ping_received());
 }
 
@@ -2581,8 +2603,9 @@ TEST_F(PortTest, TestHandleStunBindingIndication) {
   IceMessage* msg = rport->last_stun_msg();
   EXPECT_EQ(STUN_BINDING_REQUEST, msg->type());
   // Send rport binding request to lport.
-  lconn->OnReadPacket(rport->last_stun_buf()->data<char>(),
+  lconn->OnReadPacket(
-                      rport->last_stun_buf()->size(), /* packet_time_us */ -1);
+      rtc::ReceivedPacket(rport->last_stun_buf(), absl::nullopt));
+
   ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, kDefaultTimeout);
   EXPECT_EQ(STUN_BINDING_RESPONSE, lport->last_stun_msg()->type());
   int64_t last_ping_received1 = lconn->last_ping_received();
@@ -2590,7 +2613,10 @@ TEST_F(PortTest, TestHandleStunBindingIndication) {
   // Adding a delay of 100ms.
   rtc::Thread::Current()->ProcessMessages(100);
   // Pinging lconn using stun indication message.
-  lconn->OnReadPacket(buf->Data(), buf->Length(), /* packet_time_us */ -1);
+  lconn->OnReadPacket(
+      rtc::ReceivedPacket(rtc::reinterpret_array_view<const uint8_t>(
+                              rtc::MakeArrayView(buf->Data(), buf->Length())),
+                          absl::nullopt));
   int64_t last_ping_received2 = lconn->last_ping_received();
   EXPECT_GT(last_ping_received2, last_ping_received1);
 }
@@ -3087,9 +3113,9 @@ TEST_F(PortTest, TestIceLiteConnectivity) {
   con->SendStunBindingResponse(request.get());
 
   // Feeding the respone message from litemode to the full mode connection.
-  ch1.conn()->OnReadPacket(ice_lite_port->last_stun_buf()->data<char>(),
+  ch1.conn()->OnReadPacket(
-                           ice_lite_port->last_stun_buf()->size(),
+      rtc::ReceivedPacket(ice_lite_port->last_stun_buf(), absl::nullopt));
-                           /* packet_time_us */ -1);
+
   // Verifying full mode connection becomes writable from the response.
   EXPECT_EQ_WAIT(Connection::STATE_WRITABLE, ch1.conn()->write_state(),
                  kDefaultTimeout);
@@ -3205,9 +3231,8 @@ TEST_P(GoogPingTest, TestGoogPingAnnounceEnable) {
                 GetSupportedGoogPingVersion(response) >= kGoogPingVersion);
 
   // Feeding the respone message back.
-  ch1.conn()->OnReadPacket(port2->last_stun_buf()->data<char>(),
+  ch1.conn()->OnReadPacket(
-                           port2->last_stun_buf()->size(),
+      rtc::ReceivedPacket(port2->last_stun_buf(), absl::nullopt));
-                           /* packet_time_us */ -1);
 
   port1->Reset();
   port2->Reset();
@@ -3390,7 +3415,10 @@ TEST_F(PortTest, TestGoogPingUnsupportedVersionInStunBindingResponse) {
   modified_response->Write(&buf);
 
   // Feeding the modified respone message back.
-  ch1.conn()->OnReadPacket(buf.Data(), buf.Length(), /* packet_time_us */ -1);
+  ch1.conn()->OnReadPacket(
+      rtc::ReceivedPacket(rtc::reinterpret_array_view<const uint8_t>(
+                              rtc::MakeArrayView(buf.Data(), buf.Length())),
+                          absl::nullopt));
 
   port1->Reset();
   port2->Reset();
@@ -3462,9 +3490,8 @@ TEST_F(PortTest, TestChangeInAttributeMakesGoogPingFallsbackToStunBinding) {
   ASSERT_TRUE(GetSupportedGoogPingVersion(response) >= kGoogPingVersion);
 
   // Feeding the respone message back.
-  ch1.conn()->OnReadPacket(port2->last_stun_buf()->data<char>(),
+  ch1.conn()->OnReadPacket(
-                           port2->last_stun_buf()->size(),
+      rtc::ReceivedPacket(port2->last_stun_buf(), absl::nullopt));
-                           /* packet_time_us */ -1);
 
   port1->Reset();
   port2->Reset();
@@ -3548,9 +3575,8 @@ TEST_F(PortTest, TestErrorResponseMakesGoogPingFallBackToStunBinding) {
   ASSERT_TRUE(GetSupportedGoogPingVersion(response) >= kGoogPingVersion);
 
   // Feeding the respone message back.
-  ch1.conn()->OnReadPacket(port2->last_stun_buf()->data<char>(),
+  ch1.conn()->OnReadPacket(
-                           port2->last_stun_buf()->size(),
+      rtc::ReceivedPacket(port2->last_stun_buf(), absl::nullopt));
-                           /* packet_time_us */ -1);
 
   port1->Reset();
   port2->Reset();
@@ -3576,8 +3602,10 @@ TEST_F(PortTest, TestErrorResponseMakesGoogPingFallBackToStunBinding) {
   rtc::ByteBufferWriter buf;
   error_response.Write(&buf);
 
-  ch1.conn()->OnReadPacket(buf.Data(), buf.Length(),
+  ch1.conn()->OnReadPacket(
-                           /* packet_time_us */ -1);
+      rtc::ReceivedPacket(rtc::reinterpret_array_view<const uint8_t>(
+                              rtc::MakeArrayView(buf.Data(), buf.Length())),
+                          absl::nullopt));
 
   // And now the third ping...this should be a binding.
   port1->Reset();
@@ -3813,14 +3841,14 @@ class ConnectionTest : public PortTest {
         rconn->PortForTest() == rport_.get() ? rport_.get() : lport_.get();
     lconn->Ping(rtc::TimeMillis());
     ASSERT_TRUE_WAIT(lport->last_stun_msg(), kDefaultTimeout);
-    ASSERT_TRUE(lport->last_stun_buf());
+    ASSERT_GT(lport->last_stun_buf().size(), 0u);
-    rconn->OnReadPacket(lport->last_stun_buf()->data<char>(),
+    rconn->OnReadPacket(
-                        lport->last_stun_buf()->size(),
+        rtc::ReceivedPacket(lport->last_stun_buf(), absl::nullopt));
-                        /* packet_time_us */ -1);
+
     clock_.AdvanceTime(webrtc::TimeDelta::Millis(ms));
     ASSERT_TRUE_WAIT(rport->last_stun_msg(), kDefaultTimeout);
-    ASSERT_TRUE(rport->last_stun_buf());
+    ASSERT_GT(rport->last_stun_buf().size(), 0u);
-    *reply = std::move(*rport->last_stun_buf());
+    reply->SetData(rport->last_stun_buf());
   }
 
   void SendPingAndReceiveResponse(Connection* lconn,
@@ -3828,8 +3856,8 @@ class ConnectionTest : public PortTest {
                                   int64_t ms) {
     rtc::BufferT<uint8_t> reply;
     SendPingAndCaptureReply(lconn, rconn, ms, &reply);
-    lconn->OnReadPacket(reply.data<char>(), reply.size(),
+
-                        /* packet_time_us */ -1);
+    lconn->OnReadPacket(rtc::ReceivedPacket(reply, absl::nullopt));
   }
 
   void OnConnectionStateChange(Connection* connection) { num_state_changes_++; }
@@ -3890,8 +3918,7 @@ TEST_F(ConnectionTest, ConnectionForgetLearnedStateDiscardsPendingPings) {
   EXPECT_FALSE(lconn->writable());
   EXPECT_FALSE(lconn->receiving());
 
-  lconn->OnReadPacket(reply.data<char>(), reply.size(),
+  lconn->OnReadPacket(rtc::ReceivedPacket(reply, absl::nullopt));
-                      /* packet_time_us */ -1);
 
   // That reply was discarded due to the ForgetLearnedState() while it was
   // outstanding.
@@ -3962,16 +3989,17 @@ TEST_F(ConnectionTest, SendReceiveGoogDelta) {
 
   lconn->Ping(rtc::TimeMillis(), std::move(delta));
   ASSERT_TRUE_WAIT(lport_->last_stun_msg(), kDefaultTimeout);
-  ASSERT_TRUE(lport_->last_stun_buf());
+  ASSERT_GT(lport_->last_stun_buf().size(), 0u);
-  rconn->OnReadPacket(lport_->last_stun_buf()->data<char>(),
+  rconn->OnReadPacket(
-                      lport_->last_stun_buf()->size(), /* packet_time_us */ -1);
+      rtc::ReceivedPacket(lport_->last_stun_buf(), absl::nullopt));
   EXPECT_TRUE(received_goog_delta);
 
   clock_.AdvanceTime(webrtc::TimeDelta::Millis(ms));
   ASSERT_TRUE_WAIT(rport_->last_stun_msg(), kDefaultTimeout);
-  ASSERT_TRUE(rport_->last_stun_buf());
+  ASSERT_GT(rport_->last_stun_buf().size(), 0u);
-  lconn->OnReadPacket(rport_->last_stun_buf()->data<char>(),
+  lconn->OnReadPacket(
-                      rport_->last_stun_buf()->size(), /* packet_time_us */ -1);
+      rtc::ReceivedPacket(rport_->last_stun_buf(), absl::nullopt));
+
   EXPECT_TRUE(received_goog_delta_ack);
 }
 
@@ -3999,15 +4027,15 @@ TEST_F(ConnectionTest, SendGoogDeltaNoReply) {
 
   lconn->Ping(rtc::TimeMillis(), std::move(delta));
   ASSERT_TRUE_WAIT(lport_->last_stun_msg(), kDefaultTimeout);
-  ASSERT_TRUE(lport_->last_stun_buf());
+  ASSERT_GT(lport_->last_stun_buf().size(), 0u);
-  rconn->OnReadPacket(lport_->last_stun_buf()->data<char>(),
+  rconn->OnReadPacket(
-                      lport_->last_stun_buf()->size(), /* packet_time_us */ -1);
+      rtc::ReceivedPacket(lport_->last_stun_buf(), absl::nullopt));
 
   clock_.AdvanceTime(webrtc::TimeDelta::Millis(ms));
   ASSERT_TRUE_WAIT(rport_->last_stun_msg(), kDefaultTimeout);
-  ASSERT_TRUE(rport_->last_stun_buf());
+  ASSERT_GT(rport_->last_stun_buf().size(), 0u);
-  lconn->OnReadPacket(rport_->last_stun_buf()->data<char>(),
+  lconn->OnReadPacket(
-                      rport_->last_stun_buf()->size(), /* packet_time_us */ -1);
+      rtc::ReceivedPacket(rport_->last_stun_buf(), absl::nullopt));
   EXPECT_TRUE(received_goog_delta_ack_error);
 }
 

p2p/base/stun_port.cc

@@ -404,7 +404,8 @@ void UDPPort::OnReadPacket(rtc::AsyncPacketSocket* socket,
   }
 
   if (Connection* conn = GetConnection(remote_addr)) {
-    conn->OnReadPacket(data, size, packet_time_us);
+    conn->OnReadPacket(
+        rtc::ReceivedPacket::CreateFromLegacy(data, size, packet_time_us));
   } else {
     Port::OnReadPacket(data, size, remote_addr, PROTO_UDP);
   }

p2p/base/tcp_port.cc

@@ -565,7 +565,8 @@ void TCPConnection::OnReadPacket(rtc::AsyncPacketSocket* socket,
                                  const int64_t& packet_time_us) {
   RTC_DCHECK_RUN_ON(network_thread());
   RTC_DCHECK_EQ(socket, socket_.get());
-  Connection::OnReadPacket(data, size, packet_time_us);
+  Connection::OnReadPacket(
+      rtc::ReceivedPacket::CreateFromLegacy(data, size, packet_time_us));
 }
 
 void TCPConnection::OnReadyToSend(rtc::AsyncPacketSocket* socket) {

p2p/base/turn_port.cc

@@ -1074,7 +1074,8 @@ void TurnPort::DispatchPacket(const char* data,
                               ProtocolType proto,
                               int64_t packet_time_us) {
   if (Connection* conn = GetConnection(remote_addr)) {
-    conn->OnReadPacket(data, size, packet_time_us);
+    conn->OnReadPacket(
+        rtc::ReceivedPacket::CreateFromLegacy(data, size, packet_time_us));
   } else {
     Port::OnReadPacket(data, size, remote_addr, proto);
   }

rtc_base/network/received_packet.cc

@@ -20,4 +20,17 @@ ReceivedPacket::ReceivedPacket(rtc::ArrayView<const uint8_t> payload,
                                absl::optional<webrtc::Timestamp> arrival_time)
     : payload_(payload), arrival_time_(std::move(arrival_time)) {}
 
+// static
+ReceivedPacket ReceivedPacket::CreateFromLegacy(const char* data,
+                                                size_t size,
+                                                int64_t packet_time_us) {
+  RTC_DCHECK(packet_time_us == -1 || packet_time_us >= 0);
+  return ReceivedPacket(rtc::reinterpret_array_view<const uint8_t>(
+                            rtc::MakeArrayView(data, size)),
+                        (packet_time_us >= 0)
+                            ? absl::optional<webrtc::Timestamp>(
+                                  webrtc::Timestamp::Micros(packet_time_us))
+                            : absl::nullopt);
+}
+
 }  // namespace rtc

rtc_base/network/received_packet.h

@@ -38,6 +38,10 @@ class ReceivedPacket {
     return arrival_time_;
   }
 
+  static ReceivedPacket CreateFromLegacy(const char* data,
+                                         size_t size,
+                                         int64_t packet_time_us);
+
  private:
   rtc::ArrayView<const uint8_t> payload_;
   absl::optional<webrtc::Timestamp> arrival_time_;