diff --git a/webrtc/modules/audio_coding/acm2/acm_receiver.cc b/webrtc/modules/audio_coding/acm2/acm_receiver.cc
index 2438bc8ea9..f6f1786f5e 100644
--- a/webrtc/modules/audio_coding/acm2/acm_receiver.cc
+++ b/webrtc/modules/audio_coding/acm2/acm_receiver.cc
@@ -104,8 +104,8 @@ int AcmReceiver::InsertPacket(const WebRtcRTPHeader& rtp_header,
     }
   }  // |crit_sect_| is released.
 
-  if (neteq_->InsertPacket(rtp_header, incoming_payload, receive_timestamp) <
-      0) {
+  if (neteq_->InsertPacket(rtp_header.header, incoming_payload,
+                           receive_timestamp) < 0) {
     LOG(LERROR) << "AcmReceiver::InsertPacket "
                 << static_cast<int>(header->payloadType)
                 << " Failed to insert packet";
diff --git a/webrtc/modules/audio_coding/neteq/include/neteq.h b/webrtc/modules/audio_coding/neteq/include/neteq.h
index 450318e456..322a86fe7c 100644
--- a/webrtc/modules/audio_coding/neteq/include/neteq.h
+++ b/webrtc/modules/audio_coding/neteq/include/neteq.h
@@ -26,7 +26,6 @@ namespace webrtc {
 
 // Forward declarations.
 class AudioFrame;
-struct WebRtcRTPHeader;
 class AudioDecoderFactory;
 
 struct NetEqNetworkStatistics {
@@ -141,7 +140,7 @@ class NetEq {
   // of the time when the packet was received, and should be measured with
   // the same tick rate as the RTP timestamp of the current payload.
   // Returns 0 on success, -1 on failure.
-  virtual int InsertPacket(const WebRtcRTPHeader& rtp_header,
+  virtual int InsertPacket(const RTPHeader& rtp_header,
                            rtc::ArrayView<const uint8_t> payload,
                            uint32_t receive_timestamp) = 0;
 
diff --git a/webrtc/modules/audio_coding/neteq/neteq_external_decoder_unittest.cc b/webrtc/modules/audio_coding/neteq/neteq_external_decoder_unittest.cc
index 4b3c0b7afb..0ccba6d774 100644
--- a/webrtc/modules/audio_coding/neteq/neteq_external_decoder_unittest.cc
+++ b/webrtc/modules/audio_coding/neteq/neteq_external_decoder_unittest.cc
@@ -210,8 +210,8 @@ class NetEqExternalVsInternalDecoderTest : public NetEqExternalDecoderUnitTest,
                     rtc::ArrayView<const uint8_t> payload,
                     uint32_t receive_timestamp) override {
     // Insert packet in internal decoder.
-    ASSERT_EQ(NetEq::kOK, neteq_internal_->InsertPacket(rtp_header, payload,
-                                                        receive_timestamp));
+    ASSERT_EQ(NetEq::kOK, neteq_internal_->InsertPacket(
+                              rtp_header.header, payload, receive_timestamp));
 
     // Insert packet in external decoder instance.
     NetEqExternalDecoderUnitTest::InsertPacket(rtp_header, payload,
diff --git a/webrtc/modules/audio_coding/neteq/neteq_impl.cc b/webrtc/modules/audio_coding/neteq/neteq_impl.cc
index 501e5672d1..89bddeccf8 100644
--- a/webrtc/modules/audio_coding/neteq/neteq_impl.cc
+++ b/webrtc/modules/audio_coding/neteq/neteq_impl.cc
@@ -131,7 +131,7 @@ NetEqImpl::NetEqImpl(const NetEq::Config& config,
 
 NetEqImpl::~NetEqImpl() = default;
 
-int NetEqImpl::InsertPacket(const WebRtcRTPHeader& rtp_header,
+int NetEqImpl::InsertPacket(const RTPHeader& rtp_header,
                             rtc::ArrayView<const uint8_t> payload,
                             uint32_t receive_timestamp) {
   rtc::MsanCheckInitialized(payload);
@@ -581,7 +581,7 @@ Operations NetEqImpl::last_operation_for_test() const {
 
 // Methods below this line are private.
 
-int NetEqImpl::InsertPacketInternal(const WebRtcRTPHeader& rtp_header,
+int NetEqImpl::InsertPacketInternal(const RTPHeader& rtp_header,
                                     rtc::ArrayView<const uint8_t> payload,
                                     uint32_t receive_timestamp) {
   if (payload.empty()) {
@@ -594,24 +594,24 @@ int NetEqImpl::InsertPacketInternal(const WebRtcRTPHeader& rtp_header,
   packet_list.push_back([&rtp_header, &payload] {
     // Convert to Packet.
     Packet packet;
-    packet.payload_type = rtp_header.header.payloadType;
-    packet.sequence_number = rtp_header.header.sequenceNumber;
-    packet.timestamp = rtp_header.header.timestamp;
+    packet.payload_type = rtp_header.payloadType;
+    packet.sequence_number = rtp_header.sequenceNumber;
+    packet.timestamp = rtp_header.timestamp;
     packet.payload.SetData(payload.data(), payload.size());
     // Waiting time will be set upon inserting the packet in the buffer.
     RTC_DCHECK(!packet.waiting_time);
     return packet;
   }());
 
-  bool update_sample_rate_and_channels = first_packet_ ||
-    (rtp_header.header.ssrc != ssrc_);
+  bool update_sample_rate_and_channels =
+      first_packet_ || (rtp_header.ssrc != ssrc_);
 
   if (update_sample_rate_and_channels) {
     // Reset timestamp scaling.
     timestamp_scaler_->Reset();
   }
 
-  if (!decoder_database_->IsRed(rtp_header.header.payloadType)) {
+  if (!decoder_database_->IsRed(rtp_header.payloadType)) {
     // Scale timestamp to internal domain (only for some codecs).
     timestamp_scaler_->ToInternal(&packet_list);
   }
@@ -627,14 +627,14 @@ int NetEqImpl::InsertPacketInternal(const WebRtcRTPHeader& rtp_header,
     // Note: |first_packet_| will be cleared further down in this method, once
     // the packet has been successfully inserted into the packet buffer.
 
-    rtcp_.Init(rtp_header.header.sequenceNumber);
+    rtcp_.Init(rtp_header.sequenceNumber);
 
     // Flush the packet buffer and DTMF buffer.
     packet_buffer_->Flush();
     dtmf_buffer_->Flush();
 
     // Store new SSRC.
-    ssrc_ = rtp_header.header.ssrc;
+    ssrc_ = rtp_header.ssrc;
 
     // Update audio buffer timestamp.
     sync_buffer_->IncreaseEndTimestamp(main_timestamp - timestamp_);
@@ -644,19 +644,19 @@ int NetEqImpl::InsertPacketInternal(const WebRtcRTPHeader& rtp_header,
   }
 
   // Update RTCP statistics, only for regular packets.
-  rtcp_.Update(rtp_header.header, receive_timestamp);
+  rtcp_.Update(rtp_header, receive_timestamp);
 
   if (nack_enabled_) {
     RTC_DCHECK(nack_);
     if (update_sample_rate_and_channels) {
       nack_->Reset();
     }
-    nack_->UpdateLastReceivedPacket(rtp_header.header.sequenceNumber,
-                                    rtp_header.header.timestamp);
+    nack_->UpdateLastReceivedPacket(rtp_header.sequenceNumber,
+                                    rtp_header.timestamp);
   }
 
   // Check for RED payload type, and separate payloads into several packets.
-  if (decoder_database_->IsRed(rtp_header.header.payloadType)) {
+  if (decoder_database_->IsRed(rtp_header.payloadType)) {
     if (!red_payload_splitter_->SplitRed(&packet_list)) {
       return kRedundancySplitError;
     }
@@ -675,7 +675,7 @@ int NetEqImpl::InsertPacketInternal(const WebRtcRTPHeader& rtp_header,
 
   // Update main_timestamp, if new packets appear in the list
   // after RED splitting.
-  if (decoder_database_->IsRed(rtp_header.header.payloadType)) {
+  if (decoder_database_->IsRed(rtp_header.payloadType)) {
     timestamp_scaler_->ToInternal(&packet_list);
     main_timestamp = packet_list.front().timestamp;
     main_payload_type = packet_list.front().payload_type;
diff --git a/webrtc/modules/audio_coding/neteq/neteq_impl.h b/webrtc/modules/audio_coding/neteq/neteq_impl.h
index 88c0308f68..863bfbbec3 100644
--- a/webrtc/modules/audio_coding/neteq/neteq_impl.h
+++ b/webrtc/modules/audio_coding/neteq/neteq_impl.h
@@ -105,7 +105,7 @@ class NetEqImpl : public webrtc::NetEq {
   // of the time when the packet was received, and should be measured with
   // the same tick rate as the RTP timestamp of the current payload.
   // Returns 0 on success, -1 on failure.
-  int InsertPacket(const WebRtcRTPHeader& rtp_header,
+  int InsertPacket(const RTPHeader& rtp_header,
                    rtc::ArrayView<const uint8_t> payload,
                    uint32_t receive_timestamp) override;
 
@@ -222,7 +222,7 @@ class NetEqImpl : public webrtc::NetEq {
   // Inserts a new packet into NetEq. This is used by the InsertPacket method
   // above. Returns 0 on success, otherwise an error code.
   // TODO(hlundin): Merge this with InsertPacket above?
-  int InsertPacketInternal(const WebRtcRTPHeader& rtp_header,
+  int InsertPacketInternal(const RTPHeader& rtp_header,
                            rtc::ArrayView<const uint8_t> payload,
                            uint32_t receive_timestamp)
       EXCLUSIVE_LOCKS_REQUIRED(crit_sect_);
diff --git a/webrtc/modules/audio_coding/neteq/neteq_impl_unittest.cc b/webrtc/modules/audio_coding/neteq/neteq_impl_unittest.cc
index 47c2847004..9897f691af 100644
--- a/webrtc/modules/audio_coding/neteq/neteq_impl_unittest.cc
+++ b/webrtc/modules/audio_coding/neteq/neteq_impl_unittest.cc
@@ -193,7 +193,7 @@ class NetEqImplTest : public ::testing::Test {
 
     // Insert first packet.
     EXPECT_EQ(NetEq::kOK,
-              neteq_->InsertPacket(rtp_header, payload, kReceiveTime));
+              neteq_->InsertPacket(rtp_header.header, payload, kReceiveTime));
 
     // Pull audio once.
     const size_t kMaxOutputSize =
@@ -384,12 +384,12 @@ TEST_F(NetEqImplTest, InsertPacket) {
   }
 
   // Insert first packet.
-  neteq_->InsertPacket(rtp_header, payload, kFirstReceiveTime);
+  neteq_->InsertPacket(rtp_header.header, payload, kFirstReceiveTime);
 
   // Insert second packet.
   rtp_header.header.timestamp += 160;
   rtp_header.header.sequenceNumber += 1;
-  neteq_->InsertPacket(rtp_header, payload, kFirstReceiveTime + 155);
+  neteq_->InsertPacket(rtp_header.header, payload, kFirstReceiveTime + 155);
 }
 
 TEST_F(NetEqImplTest, InsertPacketsUntilBufferIsFull) {
@@ -413,7 +413,7 @@ TEST_F(NetEqImplTest, InsertPacketsUntilBufferIsFull) {
   // Insert packets. The buffer should not flush.
   for (size_t i = 1; i <= config_.max_packets_in_buffer; ++i) {
     EXPECT_EQ(NetEq::kOK,
-              neteq_->InsertPacket(rtp_header, payload, kReceiveTime));
+              neteq_->InsertPacket(rtp_header.header, payload, kReceiveTime));
     rtp_header.header.timestamp += kPayloadLengthSamples;
     rtp_header.header.sequenceNumber += 1;
     EXPECT_EQ(i, packet_buffer_->NumPacketsInBuffer());
@@ -422,7 +422,7 @@ TEST_F(NetEqImplTest, InsertPacketsUntilBufferIsFull) {
   // Insert one more packet and make sure the buffer got flushed. That is, it
   // should only hold one single packet.
   EXPECT_EQ(NetEq::kOK,
-            neteq_->InsertPacket(rtp_header, payload, kReceiveTime));
+            neteq_->InsertPacket(rtp_header.header, payload, kReceiveTime));
   EXPECT_EQ(1u, packet_buffer_->NumPacketsInBuffer());
   const Packet* test_packet = packet_buffer_->PeekNextPacket();
   EXPECT_EQ(rtp_header.header.timestamp, test_packet->timestamp);
@@ -502,7 +502,7 @@ TEST_F(NetEqImplTest, VerifyTimestampPropagation) {
 
   // Insert one packet.
   EXPECT_EQ(NetEq::kOK,
-            neteq_->InsertPacket(rtp_header, payload, kReceiveTime));
+            neteq_->InsertPacket(rtp_header.header, payload, kReceiveTime));
 
   // Pull audio once.
   const size_t kMaxOutputSize = static_cast<size_t>(10 * kSampleRateHz / 1000);
@@ -583,7 +583,7 @@ TEST_F(NetEqImplTest, ReorderedPacket) {
 
   // Insert one packet.
   EXPECT_EQ(NetEq::kOK,
-            neteq_->InsertPacket(rtp_header, payload, kReceiveTime));
+            neteq_->InsertPacket(rtp_header.header, payload, kReceiveTime));
 
   // Pull audio once.
   const size_t kMaxOutputSize = static_cast<size_t>(10 * kSampleRateHz / 1000);
@@ -600,12 +600,12 @@ TEST_F(NetEqImplTest, ReorderedPacket) {
   rtp_header.header.timestamp -= kPayloadLengthSamples;
   payload[0] = 1;
   EXPECT_EQ(NetEq::kOK,
-            neteq_->InsertPacket(rtp_header, payload, kReceiveTime));
+            neteq_->InsertPacket(rtp_header.header, payload, kReceiveTime));
   rtp_header.header.sequenceNumber += 2;
   rtp_header.header.timestamp += 2 * kPayloadLengthSamples;
   payload[0] = 2;
   EXPECT_EQ(NetEq::kOK,
-            neteq_->InsertPacket(rtp_header, payload, kReceiveTime));
+            neteq_->InsertPacket(rtp_header.header, payload, kReceiveTime));
 
   // Expect only the second packet to be decoded (the one with "2" as the first
   // payload byte).
@@ -651,7 +651,7 @@ TEST_F(NetEqImplTest, FirstPacketUnknown) {
   // Insert one packet. Note that we have not registered any payload type, so
   // this packet will be rejected.
   EXPECT_EQ(NetEq::kFail,
-            neteq_->InsertPacket(rtp_header, payload, kReceiveTime));
+            neteq_->InsertPacket(rtp_header.header, payload, kReceiveTime));
   EXPECT_EQ(NetEq::kUnknownRtpPayloadType, neteq_->LastError());
 
   // Pull audio once.
@@ -673,7 +673,7 @@ TEST_F(NetEqImplTest, FirstPacketUnknown) {
     rtp_header.header.sequenceNumber++;
     rtp_header.header.timestamp += kPayloadLengthSamples;
     EXPECT_EQ(NetEq::kOK,
-              neteq_->InsertPacket(rtp_header, payload, kReceiveTime));
+              neteq_->InsertPacket(rtp_header.header, payload, kReceiveTime));
     EXPECT_EQ(i + 1, packet_buffer_->NumPacketsInBuffer());
   }
 
@@ -760,14 +760,14 @@ TEST_F(NetEqImplTest, CodecInternalCng) {
 
   // Insert one packet (decoder will return speech).
   EXPECT_EQ(NetEq::kOK,
-            neteq_->InsertPacket(rtp_header, payload, kReceiveTime));
+            neteq_->InsertPacket(rtp_header.header, payload, kReceiveTime));
 
   // Insert second packet (decoder will return CNG).
   payload[0] = 1;
   rtp_header.header.sequenceNumber++;
   rtp_header.header.timestamp += kPayloadLengthSamples;
   EXPECT_EQ(NetEq::kOK,
-            neteq_->InsertPacket(rtp_header, payload, kReceiveTime));
+            neteq_->InsertPacket(rtp_header.header, payload, kReceiveTime));
 
   const size_t kMaxOutputSize = static_cast<size_t>(10 * kSampleRateKhz);
   AudioFrame output;
@@ -818,7 +818,7 @@ TEST_F(NetEqImplTest, CodecInternalCng) {
   rtp_header.header.sequenceNumber += 2;
   rtp_header.header.timestamp += 2 * kPayloadLengthSamples;
   EXPECT_EQ(NetEq::kOK,
-            neteq_->InsertPacket(rtp_header, payload, kReceiveTime));
+            neteq_->InsertPacket(rtp_header.header, payload, kReceiveTime));
 
   for (size_t i = 6; i < 8; ++i) {
     ASSERT_EQ(kMaxOutputSize, output.samples_per_channel_);
@@ -896,7 +896,7 @@ TEST_F(NetEqImplTest, UnsupportedDecoder) {
   // Insert one packet.
   payload[0] = kFirstPayloadValue;  // This will make Decode() fail.
   EXPECT_EQ(NetEq::kOK,
-            neteq_->InsertPacket(rtp_header, payload, kReceiveTime));
+            neteq_->InsertPacket(rtp_header.header, payload, kReceiveTime));
 
   // Insert another packet.
   payload[0] = kSecondPayloadValue;  // This will make Decode() successful.
@@ -905,7 +905,7 @@ TEST_F(NetEqImplTest, UnsupportedDecoder) {
   // the second packet get decoded.
   rtp_header.header.timestamp += 3 * kPayloadLengthSamples;
   EXPECT_EQ(NetEq::kOK,
-            neteq_->InsertPacket(rtp_header, payload, kReceiveTime));
+            neteq_->InsertPacket(rtp_header.header, payload, kReceiveTime));
 
   AudioFrame output;
   bool muted;
@@ -957,7 +957,7 @@ TEST_F(NetEqImplTest, FloodBufferAndGetNetworkStats) {
   for (size_t i = 0; i <= config_.max_packets_in_buffer; ++i) {
     EXPECT_EQ(i, packet_buffer_->NumPacketsInBuffer());
     EXPECT_EQ(NetEq::kOK,
-              neteq_->InsertPacket(rtp_header, payload, kReceiveTime));
+              neteq_->InsertPacket(rtp_header.header, payload, kReceiveTime));
     rtp_header.header.timestamp +=
         rtc::checked_cast<uint32_t>(kPayloadLengthSamples);
     ++rtp_header.header.sequenceNumber;
@@ -1013,7 +1013,7 @@ TEST_F(NetEqImplTest, DecodedPayloadTooShort) {
 
   // Insert one packet.
   EXPECT_EQ(NetEq::kOK,
-            neteq_->InsertPacket(rtp_header, payload, kReceiveTime));
+            neteq_->InsertPacket(rtp_header.header, payload, kReceiveTime));
 
   EXPECT_EQ(5u, neteq_->sync_buffer_for_test()->FutureLength());
 
@@ -1109,7 +1109,7 @@ TEST_F(NetEqImplTest, DecodingError) {
     rtp_header.header.sequenceNumber += 1;
     rtp_header.header.timestamp += kFrameLengthSamples;
     EXPECT_EQ(NetEq::kOK,
-              neteq_->InsertPacket(rtp_header, payload, kReceiveTime));
+              neteq_->InsertPacket(rtp_header.header, payload, kReceiveTime));
   }
 
   // Pull audio.
@@ -1221,7 +1221,7 @@ TEST_F(NetEqImplTest, DecodingErrorDuringInternalCng) {
     rtp_header.header.sequenceNumber += 1;
     rtp_header.header.timestamp += kFrameLengthSamples;
     EXPECT_EQ(NetEq::kOK,
-              neteq_->InsertPacket(rtp_header, payload, kReceiveTime));
+              neteq_->InsertPacket(rtp_header.header, payload, kReceiveTime));
   }
 
   // Pull audio.
@@ -1341,7 +1341,7 @@ class NetEqImplTest120ms : public NetEqImplTest {
     rtp_header.header.ssrc = 15;
     const size_t kPayloadLengthBytes = 1;  // This can be arbitrary.
     uint8_t payload[kPayloadLengthBytes] = {0};
-    EXPECT_EQ(NetEq::kOK, neteq_->InsertPacket(rtp_header, payload, 10));
+    EXPECT_EQ(NetEq::kOK, neteq_->InsertPacket(rtp_header.header, payload, 10));
     sequence_number_++;
   }
 
diff --git a/webrtc/modules/audio_coding/neteq/neteq_stereo_unittest.cc b/webrtc/modules/audio_coding/neteq/neteq_stereo_unittest.cc
index 0d15f8876a..73c25a4570 100644
--- a/webrtc/modules/audio_coding/neteq/neteq_stereo_unittest.cc
+++ b/webrtc/modules/audio_coding/neteq/neteq_stereo_unittest.cc
@@ -197,16 +197,17 @@ class NetEqStereoTest : public ::testing::TestWithParam<TestParameters> {
       while (time_now >= next_arrival_time) {
         // Insert packet in mono instance.
         ASSERT_EQ(NetEq::kOK,
-                  neteq_mono_->InsertPacket(rtp_header_mono_,
+                  neteq_mono_->InsertPacket(rtp_header_mono_.header,
                                             rtc::ArrayView<const uint8_t>(
                                                 encoded_, payload_size_bytes_),
                                             next_arrival_time));
         // Insert packet in multi-channel instance.
-        ASSERT_EQ(NetEq::kOK, neteq_->InsertPacket(
-                                  rtp_header_, rtc::ArrayView<const uint8_t>(
-                                                   encoded_multi_channel_,
-                                                   multi_payload_size_bytes_),
-                                  next_arrival_time));
+        ASSERT_EQ(NetEq::kOK,
+                  neteq_->InsertPacket(
+                      rtp_header_.header,
+                      rtc::ArrayView<const uint8_t>(encoded_multi_channel_,
+                                                    multi_payload_size_bytes_),
+                      next_arrival_time));
         // Get next input packets (mono and multi-channel).
         do {
           next_send_time = GetNewPackets();
diff --git a/webrtc/modules/audio_coding/neteq/neteq_unittest.cc b/webrtc/modules/audio_coding/neteq/neteq_unittest.cc
index 33b4005293..1a54c54c39 100644
--- a/webrtc/modules/audio_coding/neteq/neteq_unittest.cc
+++ b/webrtc/modules/audio_coding/neteq/neteq_unittest.cc
@@ -324,12 +324,13 @@ void NetEqDecodingTest::Process() {
       // Ignore payload type 104 (iSAC-swb) if ISAC is not supported.
       if (rtp_header.header.payloadType != 104)
 #endif
-      ASSERT_EQ(0, neteq_->InsertPacket(
-                       rtp_header,
-                       rtc::ArrayView<const uint8_t>(
-                           packet_->payload(), packet_->payload_length_bytes()),
-                       static_cast<uint32_t>(packet_->time_ms() *
-                                             (output_sample_rate_ / 1000))));
+        ASSERT_EQ(0,
+                  neteq_->InsertPacket(
+                      rtp_header.header,
+                      rtc::ArrayView<const uint8_t>(
+                          packet_->payload(), packet_->payload_length_bytes()),
+                      static_cast<uint32_t>(packet_->time_ms() *
+                                            (output_sample_rate_ / 1000))));
     }
     // Get next packet.
     packet_ = rtp_source_->NextPacket();
@@ -526,7 +527,7 @@ TEST_F(NetEqDecodingTestFaxMode, TestFrameWaitingTimeStatistics) {
     rtp_info.header.ssrc = 0x1234;  // Just an arbitrary SSRC.
     rtp_info.header.payloadType = 94;  // PCM16b WB codec.
     rtp_info.header.markerBit = 0;
-    ASSERT_EQ(0, neteq_->InsertPacket(rtp_info, payload, 0));
+    ASSERT_EQ(0, neteq_->InsertPacket(rtp_info.header, payload, 0));
   }
   // Pull out all data.
   for (size_t i = 0; i < num_frames; ++i) {
@@ -567,7 +568,7 @@ TEST_F(NetEqDecodingTest, TestAverageInterArrivalTimeNegative) {
       uint8_t payload[kPayloadBytes] = {0};
       WebRtcRTPHeader rtp_info;
       PopulateRtpInfo(frame_index, frame_index * kSamples, &rtp_info);
-      ASSERT_EQ(0, neteq_->InsertPacket(rtp_info, payload, 0));
+      ASSERT_EQ(0, neteq_->InsertPacket(rtp_info.header, payload, 0));
       ++frame_index;
     }
 
@@ -595,7 +596,7 @@ TEST_F(NetEqDecodingTest, TestAverageInterArrivalTimePositive) {
       uint8_t payload[kPayloadBytes] = {0};
       WebRtcRTPHeader rtp_info;
       PopulateRtpInfo(frame_index, frame_index * kSamples, &rtp_info);
-      ASSERT_EQ(0, neteq_->InsertPacket(rtp_info, payload, 0));
+      ASSERT_EQ(0, neteq_->InsertPacket(rtp_info.header, payload, 0));
       ++frame_index;
     }
 
@@ -633,7 +634,7 @@ void NetEqDecodingTest::LongCngWithClockDrift(double drift_factor,
       uint8_t payload[kPayloadBytes] = {0};
       WebRtcRTPHeader rtp_info;
       PopulateRtpInfo(seq_no, timestamp, &rtp_info);
-      ASSERT_EQ(0, neteq_->InsertPacket(rtp_info, payload, 0));
+      ASSERT_EQ(0, neteq_->InsertPacket(rtp_info.header, payload, 0));
       ++seq_no;
       timestamp += kSamples;
       next_input_time_ms += static_cast<double>(kFrameSizeMs) * drift_factor;
@@ -661,7 +662,7 @@ void NetEqDecodingTest::LongCngWithClockDrift(double drift_factor,
       WebRtcRTPHeader rtp_info;
       PopulateCng(seq_no, timestamp, &rtp_info, payload, &payload_len);
       ASSERT_EQ(0, neteq_->InsertPacket(
-                       rtp_info,
+                       rtp_info.header,
                        rtc::ArrayView<const uint8_t>(payload, payload_len), 0));
       ++seq_no;
       timestamp += kCngPeriodSamples;
@@ -704,7 +705,7 @@ void NetEqDecodingTest::LongCngWithClockDrift(double drift_factor,
       WebRtcRTPHeader rtp_info;
       PopulateCng(seq_no, timestamp, &rtp_info, payload, &payload_len);
       ASSERT_EQ(0, neteq_->InsertPacket(
-                       rtp_info,
+                       rtp_info.header,
                        rtc::ArrayView<const uint8_t>(payload, payload_len), 0));
       ++seq_no;
       timestamp += kCngPeriodSamples;
@@ -721,7 +722,7 @@ void NetEqDecodingTest::LongCngWithClockDrift(double drift_factor,
       uint8_t payload[kPayloadBytes] = {0};
       WebRtcRTPHeader rtp_info;
       PopulateRtpInfo(seq_no, timestamp, &rtp_info);
-      ASSERT_EQ(0, neteq_->InsertPacket(rtp_info, payload, 0));
+      ASSERT_EQ(0, neteq_->InsertPacket(rtp_info.header, payload, 0));
       ++seq_no;
       timestamp += kSamples;
       next_input_time_ms += kFrameSizeMs * drift_factor;
@@ -833,7 +834,7 @@ TEST_F(NetEqDecodingTest, UnknownPayloadType) {
   WebRtcRTPHeader rtp_info;
   PopulateRtpInfo(0, 0, &rtp_info);
   rtp_info.header.payloadType = 1;  // Not registered as a decoder.
-  EXPECT_EQ(NetEq::kFail, neteq_->InsertPacket(rtp_info, payload, 0));
+  EXPECT_EQ(NetEq::kFail, neteq_->InsertPacket(rtp_info.header, payload, 0));
   EXPECT_EQ(NetEq::kUnknownRtpPayloadType, neteq_->LastError());
 }
 
@@ -849,7 +850,7 @@ TEST_F(NetEqDecodingTest, MAYBE_DecoderError) {
   WebRtcRTPHeader rtp_info;
   PopulateRtpInfo(0, 0, &rtp_info);
   rtp_info.header.payloadType = 103;  // iSAC, but the payload is invalid.
-  EXPECT_EQ(0, neteq_->InsertPacket(rtp_info, payload, 0));
+  EXPECT_EQ(0, neteq_->InsertPacket(rtp_info.header, payload, 0));
   // Set all of |out_data_| to 1, and verify that it was set to 0 by the call
   // to GetAudio.
   for (size_t i = 0; i < AudioFrame::kMaxDataSizeSamples; ++i) {
@@ -956,9 +957,10 @@ class NetEqBgnTest : public NetEqDecodingTest {
           WebRtcPcm16b_Encode(block.data(), block.size(), payload);
       ASSERT_EQ(enc_len_bytes, expected_samples_per_channel * 2);
 
-      ASSERT_EQ(0, neteq_->InsertPacket(rtp_info, rtc::ArrayView<const uint8_t>(
-                                                      payload, enc_len_bytes),
-                                        receive_timestamp));
+      ASSERT_EQ(0, neteq_->InsertPacket(
+                       rtp_info.header,
+                       rtc::ArrayView<const uint8_t>(payload, enc_len_bytes),
+                       receive_timestamp));
       output.Reset();
       ASSERT_EQ(0, neteq_->GetAudio(&output, &muted));
       ASSERT_EQ(1u, output.num_channels_);
@@ -1092,8 +1094,8 @@ void NetEqDecodingTest::WrapTest(uint16_t start_seq_no,
       PopulateRtpInfo(seq_no, timestamp, &rtp_info);
       if (drop_seq_numbers.find(seq_no) == drop_seq_numbers.end()) {
         // This sequence number was not in the set to drop. Insert it.
-        ASSERT_EQ(0,
-                  neteq_->InsertPacket(rtp_info, payload, receive_timestamp));
+        ASSERT_EQ(0, neteq_->InsertPacket(rtp_info.header, payload,
+                                          receive_timestamp));
         ++packets_inserted;
       }
       NetEqNetworkStatistics network_stats;
@@ -1181,7 +1183,7 @@ void NetEqDecodingTest::DuplicateCng() {
   bool muted;
   for (int i = 0; i < 3; ++i) {
     PopulateRtpInfo(seq_no, timestamp, &rtp_info);
-    ASSERT_EQ(0, neteq_->InsertPacket(rtp_info, payload, 0));
+    ASSERT_EQ(0, neteq_->InsertPacket(rtp_info.header, payload, 0));
     ++seq_no;
     timestamp += kSamples;
 
@@ -1198,9 +1200,9 @@ void NetEqDecodingTest::DuplicateCng() {
   size_t payload_len;
   PopulateCng(seq_no, timestamp, &rtp_info, payload, &payload_len);
   // This is the first time this CNG packet is inserted.
-  ASSERT_EQ(
-      0, neteq_->InsertPacket(
-             rtp_info, rtc::ArrayView<const uint8_t>(payload, payload_len), 0));
+  ASSERT_EQ(0, neteq_->InsertPacket(
+                   rtp_info.header,
+                   rtc::ArrayView<const uint8_t>(payload, payload_len), 0));
 
   // Pull audio once and make sure CNG is played.
   ASSERT_EQ(0, neteq_->GetAudio(&out_frame_, &muted));
@@ -1212,9 +1214,9 @@ void NetEqDecodingTest::DuplicateCng() {
 
   // Insert the same CNG packet again. Note that at this point it is old, since
   // we have already decoded the first copy of it.
-  ASSERT_EQ(
-      0, neteq_->InsertPacket(
-             rtp_info, rtc::ArrayView<const uint8_t>(payload, payload_len), 0));
+  ASSERT_EQ(0, neteq_->InsertPacket(
+                   rtp_info.header,
+                   rtc::ArrayView<const uint8_t>(payload, payload_len), 0));
 
   // Pull audio until we have played |kCngPeriodMs| of CNG. Start at 10 ms since
   // we have already pulled out CNG once.
@@ -1231,7 +1233,7 @@ void NetEqDecodingTest::DuplicateCng() {
   ++seq_no;
   timestamp += kCngPeriodSamples;
   PopulateRtpInfo(seq_no, timestamp, &rtp_info);
-  ASSERT_EQ(0, neteq_->InsertPacket(rtp_info, payload, 0));
+  ASSERT_EQ(0, neteq_->InsertPacket(rtp_info.header, payload, 0));
 
   // Pull audio once and verify that the output is speech again.
   ASSERT_EQ(0, neteq_->GetAudio(&out_frame_, &muted));
@@ -1264,10 +1266,10 @@ TEST_F(NetEqDecodingTest, CngFirst) {
   WebRtcRTPHeader rtp_info;
 
   PopulateCng(seq_no, timestamp, &rtp_info, payload, &payload_len);
-  ASSERT_EQ(
-      NetEq::kOK,
-      neteq_->InsertPacket(
-          rtp_info, rtc::ArrayView<const uint8_t>(payload, payload_len), 0));
+  ASSERT_EQ(NetEq::kOK,
+            neteq_->InsertPacket(
+                rtp_info.header,
+                rtc::ArrayView<const uint8_t>(payload, payload_len), 0));
   ++seq_no;
   timestamp += kCngPeriodSamples;
 
@@ -1283,7 +1285,7 @@ TEST_F(NetEqDecodingTest, CngFirst) {
   do {
     ASSERT_LT(timeout_counter++, 20) << "Test timed out";
     PopulateRtpInfo(seq_no, timestamp, &rtp_info);
-    ASSERT_EQ(0, neteq_->InsertPacket(rtp_info, payload, 0));
+    ASSERT_EQ(0, neteq_->InsertPacket(rtp_info.header, payload, 0));
     ++seq_no;
     timestamp += kSamples;
 
@@ -1309,7 +1311,7 @@ class NetEqDecodingTestWithMutedState : public NetEqDecodingTest {
     uint8_t payload[kPayloadBytes] = {0};
     WebRtcRTPHeader rtp_info;
     PopulateRtpInfo(0, rtp_timestamp, &rtp_info);
-    EXPECT_EQ(0, neteq_->InsertPacket(rtp_info, payload, 0));
+    EXPECT_EQ(0, neteq_->InsertPacket(rtp_info.header, payload, 0));
   }
 
   void InsertCngPacket(uint32_t rtp_timestamp) {
@@ -1317,10 +1319,10 @@ class NetEqDecodingTestWithMutedState : public NetEqDecodingTest {
     WebRtcRTPHeader rtp_info;
     size_t payload_len;
     PopulateCng(0, rtp_timestamp, &rtp_info, payload, &payload_len);
-    EXPECT_EQ(
-        NetEq::kOK,
-        neteq_->InsertPacket(
-            rtp_info, rtc::ArrayView<const uint8_t>(payload, payload_len), 0));
+    EXPECT_EQ(NetEq::kOK,
+              neteq_->InsertPacket(
+                  rtp_info.header,
+                  rtc::ArrayView<const uint8_t>(payload, payload_len), 0));
   }
 
   bool GetAudioReturnMuted() {
@@ -1545,8 +1547,8 @@ TEST_F(NetEqDecodingTestTwoInstances, CompareMutedStateOnOff) {
   uint8_t payload[kPayloadBytes] = {0};
   WebRtcRTPHeader rtp_info;
   PopulateRtpInfo(0, 0, &rtp_info);
-  EXPECT_EQ(0, neteq_->InsertPacket(rtp_info, payload, 0));
-  EXPECT_EQ(0, neteq2_->InsertPacket(rtp_info, payload, 0));
+  EXPECT_EQ(0, neteq_->InsertPacket(rtp_info.header, payload, 0));
+  EXPECT_EQ(0, neteq2_->InsertPacket(rtp_info.header, payload, 0));
 
   AudioFrame out_frame1, out_frame2;
   bool muted;
@@ -1568,8 +1570,8 @@ TEST_F(NetEqDecodingTestTwoInstances, CompareMutedStateOnOff) {
   // Insert new data. Timestamp is corrected for the time elapsed since the last
   // packet.
   PopulateRtpInfo(0, kSamples * 1000, &rtp_info);
-  EXPECT_EQ(0, neteq_->InsertPacket(rtp_info, payload, 0));
-  EXPECT_EQ(0, neteq2_->InsertPacket(rtp_info, payload, 0));
+  EXPECT_EQ(0, neteq_->InsertPacket(rtp_info.header, payload, 0));
+  EXPECT_EQ(0, neteq2_->InsertPacket(rtp_info.header, payload, 0));
 
   int counter = 0;
   while (out_frame1.speech_type_ != AudioFrame::kNormalSpeech) {
diff --git a/webrtc/modules/audio_coding/neteq/tools/neteq_external_decoder_test.cc b/webrtc/modules/audio_coding/neteq/tools/neteq_external_decoder_test.cc
index ed5127927b..95fdb04b44 100644
--- a/webrtc/modules/audio_coding/neteq/tools/neteq_external_decoder_test.cc
+++ b/webrtc/modules/audio_coding/neteq/tools/neteq_external_decoder_test.cc
@@ -40,8 +40,8 @@ void NetEqExternalDecoderTest::InsertPacket(
     WebRtcRTPHeader rtp_header,
     rtc::ArrayView<const uint8_t> payload,
     uint32_t receive_timestamp) {
-  ASSERT_EQ(NetEq::kOK,
-            neteq_->InsertPacket(rtp_header, payload, receive_timestamp));
+  ASSERT_EQ(NetEq::kOK, neteq_->InsertPacket(rtp_header.header, payload,
+                                             receive_timestamp));
 }
 
 void NetEqExternalDecoderTest::GetOutputAudio(AudioFrame* output) {
diff --git a/webrtc/modules/audio_coding/neteq/tools/neteq_performance_test.cc b/webrtc/modules/audio_coding/neteq/tools/neteq_performance_test.cc
index 4349a70390..df14081feb 100644
--- a/webrtc/modules/audio_coding/neteq/tools/neteq_performance_test.cc
+++ b/webrtc/modules/audio_coding/neteq/tools/neteq_performance_test.cc
@@ -88,7 +88,7 @@ int64_t NetEqPerformanceTest::Run(int runtime_ms,
       if (!lost) {
         // Insert packet.
         int error =
-            neteq->InsertPacket(rtp_header, input_payload,
+            neteq->InsertPacket(rtp_header.header, input_payload,
                                 packet_input_time_ms * kSampRateHz / 1000);
         if (error != NetEq::kOK)
           return -1;
diff --git a/webrtc/modules/audio_coding/neteq/tools/neteq_quality_test.cc b/webrtc/modules/audio_coding/neteq/tools/neteq_quality_test.cc
index 7b3a35b676..732c7b8c8e 100644
--- a/webrtc/modules/audio_coding/neteq/tools/neteq_quality_test.cc
+++ b/webrtc/modules/audio_coding/neteq/tools/neteq_quality_test.cc
@@ -380,7 +380,7 @@ int NetEqQualityTest::Transmit() {
   if (payload_size_bytes_ > 0) {
     if (!PacketLost()) {
       int ret = neteq_->InsertPacket(
-          rtp_header_,
+          rtp_header_.header,
           rtc::ArrayView<const uint8_t>(payload_.data(), payload_size_bytes_),
           packet_input_time_ms * in_sampling_khz_);
       if (ret != NetEq::kOK)
diff --git a/webrtc/modules/audio_coding/neteq/tools/neteq_test.cc b/webrtc/modules/audio_coding/neteq/tools/neteq_test.cc
index cc88b38fdf..13b11e8c7f 100644
--- a/webrtc/modules/audio_coding/neteq/tools/neteq_test.cc
+++ b/webrtc/modules/audio_coding/neteq/tools/neteq_test.cc
@@ -70,7 +70,7 @@ int64_t NetEqTest::Run() {
       std::unique_ptr<NetEqInput::PacketData> packet_data = input_->PopPacket();
       RTC_CHECK(packet_data);
       int error = neteq_->InsertPacket(
-          packet_data->header,
+          packet_data->header.header,
           rtc::ArrayView<const uint8_t>(packet_data->payload),
           static_cast<uint32_t>(packet_data->time_ms * sample_rate_hz_ / 1000));
       if (error != NetEq::kOK && error_callback_) {