diff --git a/modules/rtp_rtcp/source/rtp_rtcp_impl2_unittest.cc b/modules/rtp_rtcp/source/rtp_rtcp_impl2_unittest.cc
index 40a002a116..00f8edb468 100644
--- a/modules/rtp_rtcp/source/rtp_rtcp_impl2_unittest.cc
+++ b/modules/rtp_rtcp/source/rtp_rtcp_impl2_unittest.cc
@@ -51,6 +51,12 @@ const uint8_t kPayloadType = 100;
 const int kWidth = 320;
 const int kHeight = 100;
 
+// RTP header extension ids.
+enum : int {
+  kAbsoluteSendTimeExtensionId = 1,
+  kTransportSequenceNumberExtensionId,
+};
+
 class RtcpRttStatsTestImpl : public RtcpRttStats {
  public:
   RtcpRttStatsTestImpl() : rtt_ms_(0) {}
@@ -68,7 +74,8 @@ class SendTransport : public Transport {
         time_controller_(nullptr),
         delay_ms_(0),
         rtp_packets_sent_(0),
-        rtcp_packets_sent_(0) {}
+        rtcp_packets_sent_(0),
+        last_packet_(&header_extensions_) {}
 
   void SetRtpRtcpModule(ModuleRtpRtcpImpl2* receiver) { receiver_ = receiver; }
   void SimulateNetworkDelay(int64_t delay_ms, TimeController* time_controller) {
@@ -78,11 +85,8 @@ class SendTransport : public Transport {
   bool SendRtp(const uint8_t* data,
                size_t len,
                const PacketOptions& options) override {
-    RTPHeader header;
-    std::unique_ptr<RtpHeaderParser> parser(RtpHeaderParser::CreateForTest());
-    EXPECT_TRUE(parser->Parse(static_cast<const uint8_t*>(data), len, &header));
+    EXPECT_TRUE(last_packet_.Parse(data, len));
     ++rtp_packets_sent_;
-    last_rtp_header_ = header;
     return true;
   }
   bool SendRtcp(const uint8_t* data, size_t len) override {
@@ -106,8 +110,9 @@ class SendTransport : public Transport {
   int64_t delay_ms_;
   int rtp_packets_sent_;
   size_t rtcp_packets_sent_;
-  RTPHeader last_rtp_header_;
   std::vector<uint16_t> last_nack_list_;
+  RtpHeaderExtensionMap header_extensions_;
+  RtpPacketReceived last_packet_;
 };
 
 struct TestConfig {
@@ -187,9 +192,7 @@ class RtpRtcpModule : public RtcpPacketTypeCounterObserver {
     return counter_map_[impl_->SSRC()];
   }
   int RtpSent() { return transport_.rtp_packets_sent_; }
-  uint16_t LastRtpSequenceNumber() {
-    return transport_.last_rtp_header_.sequenceNumber;
-  }
+  uint16_t LastRtpSequenceNumber() { return last_packet().SequenceNumber(); }
   std::vector<uint16_t> LastNackListSent() {
     return transport_.last_nack_list_;
   }
@@ -197,6 +200,12 @@ class RtpRtcpModule : public RtcpPacketTypeCounterObserver {
     rtcp_report_interval_ms_ = rtcp_report_interval_ms;
     CreateModuleImpl();
   }
+  const RtpPacketReceived& last_packet() { return transport_.last_packet_; }
+  void RegisterHeaderExtension(absl::string_view uri, int id) {
+    impl_->RegisterRtpHeaderExtension(uri, id);
+    transport_.header_extensions_.RegisterByUri(id, uri);
+    transport_.last_packet_.IdentifyExtensions(transport_.header_extensions_);
+  }
 
  private:
   void CreateModuleImpl() {
@@ -863,8 +872,8 @@ TEST_P(RtpRtcpImpl2Test, PaddingTimestampMatchesMedia) {
 
   EXPECT_TRUE(
       SendFrame(&sender_, sender_video_.get(), kBaseLayerTid, kTimestamp));
-  EXPECT_EQ(sender_.transport_.last_rtp_header_.timestamp, kTimestamp);
-  uint16_t media_seq = sender_.transport_.last_rtp_header_.sequenceNumber;
+  EXPECT_EQ(sender_.last_packet().Timestamp(), kTimestamp);
+  uint16_t media_seq = sender_.last_packet().SequenceNumber();
 
   // Generate and send padding.
   auto padding = sender_.impl_->GeneratePadding(kPaddingSize);
@@ -874,8 +883,36 @@ TEST_P(RtpRtcpImpl2Test, PaddingTimestampMatchesMedia) {
   }
 
   // Verify we sent a new packet, but with the same timestamp.
-  EXPECT_NE(sender_.transport_.last_rtp_header_.sequenceNumber, media_seq);
-  EXPECT_EQ(sender_.transport_.last_rtp_header_.timestamp, kTimestamp);
+  EXPECT_NE(sender_.last_packet().SequenceNumber(), media_seq);
+  EXPECT_EQ(sender_.last_packet().Timestamp(), kTimestamp);
+}
+
+TEST_P(RtpRtcpImpl2Test, AssignsTransportSequenceNumber) {
+  sender_.RegisterHeaderExtension(TransportSequenceNumber::kUri,
+                                  kTransportSequenceNumberExtensionId);
+
+  EXPECT_TRUE(
+      SendFrame(&sender_, sender_video_.get(), kBaseLayerTid, /*timestamp=*/0));
+  uint16_t first_transport_seq = 0;
+  EXPECT_TRUE(sender_.last_packet().GetExtension<TransportSequenceNumber>(
+      &first_transport_seq));
+
+  EXPECT_TRUE(
+      SendFrame(&sender_, sender_video_.get(), kBaseLayerTid, /*timestamp=*/0));
+  uint16_t second_transport_seq = 0;
+  EXPECT_TRUE(sender_.last_packet().GetExtension<TransportSequenceNumber>(
+      &second_transport_seq));
+
+  EXPECT_EQ(first_transport_seq + 1, second_transport_seq);
+}
+
+TEST_P(RtpRtcpImpl2Test, AssignsAbsoluteSendTime) {
+  sender_.RegisterHeaderExtension(AbsoluteSendTime::kUri,
+                                  kAbsoluteSendTimeExtensionId);
+
+  EXPECT_TRUE(
+      SendFrame(&sender_, sender_video_.get(), kBaseLayerTid, /*timestamp=*/0));
+  EXPECT_NE(sender_.last_packet().GetExtension<AbsoluteSendTime>(), 0u);
 }
 
 INSTANTIATE_TEST_SUITE_P(WithAndWithoutOverhead,
diff --git a/modules/rtp_rtcp/source/rtp_sender_unittest.cc b/modules/rtp_rtcp/source/rtp_sender_unittest.cc
index e28cd596cf..ff1bb4105d 100644
--- a/modules/rtp_rtcp/source/rtp_sender_unittest.cc
+++ b/modules/rtp_rtcp/source/rtp_sender_unittest.cc
@@ -545,45 +545,6 @@ TEST_P(RtpSenderTest, PaddingAlwaysAllowedOnAudio) {
   EXPECT_EQ(kMinPaddingSize, GenerateAndSendPadding(kMinPaddingSize - 5));
 }
 
-TEST_P(RtpSenderTestWithoutPacer, SendsPacketsWithTransportSequenceNumber) {
-  RtpRtcpInterface::Configuration config;
-  config.clock = clock_;
-  config.outgoing_transport = &transport_;
-  config.local_media_ssrc = kSsrc;
-  config.transport_feedback_callback = &feedback_observer_;
-  config.event_log = &mock_rtc_event_log_;
-  config.send_packet_observer = &send_packet_observer_;
-  config.retransmission_rate_limiter = &retransmission_rate_limiter_;
-  rtp_sender_context_ =
-      std::make_unique<RtpSenderContext>(config, &time_controller_);
-
-  EXPECT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
-      TransportSequenceNumber::kUri, kTransportSequenceNumberExtensionId));
-
-  EXPECT_CALL(send_packet_observer_,
-              OnSendPacket(kTransportSequenceNumber, _, _))
-      .Times(1);
-
-  EXPECT_CALL(feedback_observer_,
-              OnAddPacket(AllOf(
-                  Field(&RtpPacketSendInfo::ssrc, rtp_sender()->SSRC()),
-                  Field(&RtpPacketSendInfo::transport_sequence_number,
-                        kTransportSequenceNumber),
-                  Field(&RtpPacketSendInfo::rtp_sequence_number,
-                        rtp_sender()->SequenceNumber()),
-                  Field(&RtpPacketSendInfo::pacing_info, PacedPacketInfo()))))
-      .Times(1);
-
-  SendGenericPacket();
-
-  const auto& packet = transport_.last_sent_packet();
-  uint16_t transport_seq_no;
-  ASSERT_TRUE(packet.GetExtension<TransportSequenceNumber>(&transport_seq_no));
-  EXPECT_EQ(kTransportSequenceNumber, transport_seq_no);
-  EXPECT_EQ(transport_.last_options_.packet_id, transport_seq_no);
-  EXPECT_TRUE(transport_.last_options_.included_in_allocation);
-}
-
 TEST_P(RtpSenderTestWithoutPacer, PacketOptionsNoRetransmission) {
   RtpRtcpInterface::Configuration config;
   config.clock = clock_;