diff --git a/modules/rtp_rtcp/source/rtp_rtcp_impl.cc b/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
index c8c05873da..f490439de1 100644
--- a/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
+++ b/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
@@ -38,16 +38,6 @@ const int64_t kRtpRtcpBitrateProcessTimeMs = 10;
 const int64_t kDefaultExpectedRetransmissionTimeMs = 125;
 }  // namespace
 
-ModuleRtpRtcpImpl::RtpSenderContext::RtpSenderContext(
-    const RtpRtcp::Configuration& config)
-    : packet_history_(config.clock),
-      packet_sender_(config, &packet_history_),
-      non_paced_sender_(&packet_sender_),
-      packet_generator_(
-          config,
-          &packet_history_,
-          config.paced_sender ? config.paced_sender : &non_paced_sender_) {}
-
 RtpRtcp::Configuration::Configuration() = default;
 RtpRtcp::Configuration::Configuration(Configuration&& rhs) = default;
 
@@ -72,10 +62,9 @@ ModuleRtpRtcpImpl::ModuleRtpRtcpImpl(const Configuration& configuration)
       rtt_stats_(configuration.rtt_stats),
       rtt_ms_(0) {
   if (!configuration.receiver_only) {
-    rtp_sender_ = std::make_unique<RtpSenderContext>(configuration);
+    rtp_sender_.reset(new RTPSender(configuration));
     // Make sure rtcp sender use same timestamp offset as rtp sender.
-    rtcp_sender_.SetTimestampOffset(
-        rtp_sender_->packet_generator_.TimestampOffset());
+    rtcp_sender_.SetTimestampOffset(rtp_sender_->TimestampOffset());
   }
 
   // Set default packet size limit.
@@ -101,7 +90,7 @@ void ModuleRtpRtcpImpl::Process() {
 
   if (rtp_sender_) {
     if (now >= last_bitrate_process_time_ + kRtpRtcpBitrateProcessTimeMs) {
-      rtp_sender_->packet_sender_.ProcessBitrateAndNotifyObservers();
+      rtp_sender_->ProcessBitrate();
       last_bitrate_process_time_ = now;
       next_process_time_ =
           std::min(next_process_time_, now + kRtpRtcpBitrateProcessTimeMs);
@@ -179,27 +168,25 @@ void ModuleRtpRtcpImpl::Process() {
 }
 
 void ModuleRtpRtcpImpl::SetRtxSendStatus(int mode) {
-  rtp_sender_->packet_generator_.SetRtxStatus(mode);
+  rtp_sender_->SetRtxStatus(mode);
 }
 
 int ModuleRtpRtcpImpl::RtxSendStatus() const {
-  return rtp_sender_ ? rtp_sender_->packet_generator_.RtxStatus() : kRtxOff;
+  return rtp_sender_ ? rtp_sender_->RtxStatus() : kRtxOff;
 }
 
 void ModuleRtpRtcpImpl::SetRtxSendPayloadType(int payload_type,
                                               int associated_payload_type) {
-  rtp_sender_->packet_generator_.SetRtxPayloadType(payload_type,
-                                                   associated_payload_type);
+  rtp_sender_->SetRtxPayloadType(payload_type, associated_payload_type);
 }
 
 absl::optional<uint32_t> ModuleRtpRtcpImpl::RtxSsrc() const {
-  return rtp_sender_ ? rtp_sender_->packet_generator_.RtxSsrc() : absl::nullopt;
+  return rtp_sender_ ? rtp_sender_->RtxSsrc() : absl::nullopt;
 }
 
 absl::optional<uint32_t> ModuleRtpRtcpImpl::FlexfecSsrc() const {
-  if (rtp_sender_) {
-    return rtp_sender_->packet_generator_.FlexfecSsrc();
-  }
+  if (rtp_sender_)
+    return rtp_sender_->FlexfecSsrc();
   return absl::nullopt;
 }
 
@@ -218,54 +205,50 @@ int32_t ModuleRtpRtcpImpl::DeRegisterSendPayload(const int8_t payload_type) {
 }
 
 uint32_t ModuleRtpRtcpImpl::StartTimestamp() const {
-  return rtp_sender_->packet_generator_.TimestampOffset();
+  return rtp_sender_->TimestampOffset();
 }
 
 // Configure start timestamp, default is a random number.
 void ModuleRtpRtcpImpl::SetStartTimestamp(const uint32_t timestamp) {
   rtcp_sender_.SetTimestampOffset(timestamp);
-  rtp_sender_->packet_generator_.SetTimestampOffset(timestamp);
+  rtp_sender_->SetTimestampOffset(timestamp);
 }
 
 uint16_t ModuleRtpRtcpImpl::SequenceNumber() const {
-  return rtp_sender_->packet_generator_.SequenceNumber();
+  return rtp_sender_->SequenceNumber();
 }
 
 // Set SequenceNumber, default is a random number.
 void ModuleRtpRtcpImpl::SetSequenceNumber(const uint16_t seq_num) {
-  rtp_sender_->packet_generator_.SetSequenceNumber(seq_num);
+  rtp_sender_->SetSequenceNumber(seq_num);
 }
 
 void ModuleRtpRtcpImpl::SetRtpState(const RtpState& rtp_state) {
-  rtp_sender_->packet_generator_.SetRtpState(rtp_state);
-  rtp_sender_->packet_sender_.SetMediaHasBeenSent(
-      rtp_state.media_has_been_sent);
+  rtp_sender_->SetRtpState(rtp_state);
   rtcp_sender_.SetTimestampOffset(rtp_state.start_timestamp);
 }
 
 void ModuleRtpRtcpImpl::SetRtxState(const RtpState& rtp_state) {
-  rtp_sender_->packet_generator_.SetRtxRtpState(rtp_state);
+  rtp_sender_->SetRtxRtpState(rtp_state);
 }
 
 RtpState ModuleRtpRtcpImpl::GetRtpState() const {
-  RtpState state = rtp_sender_->packet_generator_.GetRtpState();
-  state.media_has_been_sent = rtp_sender_->packet_sender_.MediaHasBeenSent();
-  return state;
+  return rtp_sender_->GetRtpState();
 }
 
 RtpState ModuleRtpRtcpImpl::GetRtxState() const {
-  return rtp_sender_->packet_generator_.GetRtxRtpState();
+  return rtp_sender_->GetRtxRtpState();
 }
 
 void ModuleRtpRtcpImpl::SetRid(const std::string& rid) {
   if (rtp_sender_) {
-    rtp_sender_->packet_generator_.SetRid(rid);
+    rtp_sender_->SetRid(rid);
   }
 }
 
 void ModuleRtpRtcpImpl::SetMid(const std::string& mid) {
   if (rtp_sender_) {
-    rtp_sender_->packet_generator_.SetMid(mid);
+    rtp_sender_->SetMid(mid);
   }
   // TODO(bugs.webrtc.org/4050): If we end up supporting the MID SDES item for
   // RTCP, this will need to be passed down to the RTCPSender also.
@@ -273,7 +256,7 @@ void ModuleRtpRtcpImpl::SetMid(const std::string& mid) {
 
 void ModuleRtpRtcpImpl::SetCsrcs(const std::vector<uint32_t>& csrcs) {
   rtcp_sender_.SetCsrcs(csrcs);
-  rtp_sender_->packet_generator_.SetCsrcs(csrcs);
+  rtp_sender_->SetCsrcs(csrcs);
 }
 
 // TODO(pbos): Handle media and RTX streams separately (separate RTCP
@@ -285,13 +268,12 @@ RTCPSender::FeedbackState ModuleRtpRtcpImpl::GetFeedbackState() {
   if (rtp_sender_) {
     StreamDataCounters rtp_stats;
     StreamDataCounters rtx_stats;
-    rtp_sender_->packet_sender_.GetDataCounters(&rtp_stats, &rtx_stats);
+    rtp_sender_->GetDataCounters(&rtp_stats, &rtx_stats);
     state.packets_sent =
         rtp_stats.transmitted.packets + rtx_stats.transmitted.packets;
     state.media_bytes_sent = rtp_stats.transmitted.payload_bytes +
                              rtx_stats.transmitted.payload_bytes;
-    state.send_bitrate =
-        rtp_sender_->packet_sender_.SendBitrate().bps<uint32_t>();
+    state.send_bitrate = rtp_sender_->BitrateSent();
   }
   state.module = this;
 
@@ -325,20 +307,19 @@ bool ModuleRtpRtcpImpl::Sending() const {
 // updated.
 void ModuleRtpRtcpImpl::SetSendingMediaStatus(const bool sending) {
   if (rtp_sender_) {
-    rtp_sender_->packet_generator_.SetSendingMediaStatus(sending);
+    rtp_sender_->SetSendingMediaStatus(sending);
   } else {
     RTC_DCHECK(!sending);
   }
 }
 
 bool ModuleRtpRtcpImpl::SendingMedia() const {
-  return rtp_sender_ ? rtp_sender_->packet_generator_.SendingMedia() : false;
+  return rtp_sender_ ? rtp_sender_->SendingMedia() : false;
 }
 
 void ModuleRtpRtcpImpl::SetAsPartOfAllocation(bool part_of_allocation) {
   RTC_CHECK(rtp_sender_);
-  rtp_sender_->packet_sender_.ForceIncludeSendPacketsInAllocation(
-      part_of_allocation);
+  rtp_sender_->SetAsPartOfAllocation(part_of_allocation);
 }
 
 bool ModuleRtpRtcpImpl::OnSendingRtpFrame(uint32_t timestamp,
@@ -358,41 +339,30 @@ bool ModuleRtpRtcpImpl::OnSendingRtpFrame(uint32_t timestamp,
 
 bool ModuleRtpRtcpImpl::TrySendPacket(RtpPacketToSend* packet,
                                       const PacedPacketInfo& pacing_info) {
-  RTC_DCHECK(rtp_sender_);
-  // TODO(sprang): Consider if we can remove this check.
-  if (!rtp_sender_->packet_generator_.SendingMedia()) {
-    return false;
-  }
-  rtp_sender_->packet_sender_.SendPacket(packet, pacing_info);
-  return true;
+  return rtp_sender_->TrySendPacket(packet, pacing_info);
 }
 
 void ModuleRtpRtcpImpl::OnPacketsAcknowledged(
     rtc::ArrayView<const uint16_t> sequence_numbers) {
   RTC_DCHECK(rtp_sender_);
-  rtp_sender_->packet_history_.CullAcknowledgedPackets(sequence_numbers);
+  rtp_sender_->OnPacketsAcknowledged(sequence_numbers);
 }
 
 bool ModuleRtpRtcpImpl::SupportsPadding() const {
-  RTC_DCHECK(rtp_sender_);
-  return rtp_sender_->packet_generator_.SupportsPadding();
+  return rtp_sender_->SupportsPadding();
 }
 
 bool ModuleRtpRtcpImpl::SupportsRtxPayloadPadding() const {
-  RTC_DCHECK(rtp_sender_);
-  return rtp_sender_->packet_generator_.SupportsRtxPayloadPadding();
+  return rtp_sender_->SupportsRtxPayloadPadding();
 }
 
 std::vector<std::unique_ptr<RtpPacketToSend>>
 ModuleRtpRtcpImpl::GeneratePadding(size_t target_size_bytes) {
-  RTC_DCHECK(rtp_sender_);
-  return rtp_sender_->packet_generator_.GeneratePadding(
-      target_size_bytes, rtp_sender_->packet_sender_.MediaHasBeenSent());
+  return rtp_sender_->GeneratePadding(target_size_bytes);
 }
 
 size_t ModuleRtpRtcpImpl::MaxRtpPacketSize() const {
-  RTC_DCHECK(rtp_sender_);
-  return rtp_sender_->packet_generator_.MaxRtpPacketSize();
+  return rtp_sender_->MaxRtpPacketSize();
 }
 
 void ModuleRtpRtcpImpl::SetMaxRtpPacketSize(size_t rtp_packet_size) {
@@ -402,9 +372,8 @@ void ModuleRtpRtcpImpl::SetMaxRtpPacketSize(size_t rtp_packet_size) {
       << "rtp packet size too small: " << rtp_packet_size;
 
   rtcp_sender_.SetMaxRtpPacketSize(rtp_packet_size);
-  if (rtp_sender_) {
-    rtp_sender_->packet_generator_.SetMaxRtpPacketSize(rtp_packet_size);
-  }
+  if (rtp_sender_)
+    rtp_sender_->SetMaxRtpPacketSize(rtp_packet_size);
 }
 
 RtcpMode ModuleRtpRtcpImpl::RTCP() const {
@@ -502,7 +471,7 @@ int32_t ModuleRtpRtcpImpl::DataCountersRTP(size_t* bytes_sent,
                                            uint32_t* packets_sent) const {
   StreamDataCounters rtp_stats;
   StreamDataCounters rtx_stats;
-  rtp_sender_->packet_sender_.GetDataCounters(&rtp_stats, &rtx_stats);
+  rtp_sender_->GetDataCounters(&rtp_stats, &rtx_stats);
 
   if (bytes_sent) {
     // TODO(http://crbug.com/webrtc/10525): Bytes sent should only include
@@ -524,7 +493,7 @@ int32_t ModuleRtpRtcpImpl::DataCountersRTP(size_t* bytes_sent,
 void ModuleRtpRtcpImpl::GetSendStreamDataCounters(
     StreamDataCounters* rtp_counters,
     StreamDataCounters* rtx_counters) const {
-  rtp_sender_->packet_sender_.GetDataCounters(rtp_counters, rtx_counters);
+  rtp_sender_->GetDataCounters(rtp_counters, rtx_counters);
 }
 
 // Received RTCP report.
@@ -549,29 +518,28 @@ void ModuleRtpRtcpImpl::UnsetRemb() {
 }
 
 void ModuleRtpRtcpImpl::SetExtmapAllowMixed(bool extmap_allow_mixed) {
-  rtp_sender_->packet_generator_.SetExtmapAllowMixed(extmap_allow_mixed);
+  rtp_sender_->SetExtmapAllowMixed(extmap_allow_mixed);
 }
 
 int32_t ModuleRtpRtcpImpl::RegisterSendRtpHeaderExtension(
     const RTPExtensionType type,
     const uint8_t id) {
-  return rtp_sender_->packet_generator_.RegisterRtpHeaderExtension(type, id);
+  return rtp_sender_->RegisterRtpHeaderExtension(type, id);
 }
 
 void ModuleRtpRtcpImpl::RegisterRtpHeaderExtension(absl::string_view uri,
                                                    int id) {
-  bool registered =
-      rtp_sender_->packet_generator_.RegisterRtpHeaderExtension(uri, id);
+  bool registered = rtp_sender_->RegisterRtpHeaderExtension(uri, id);
   RTC_CHECK(registered);
 }
 
 int32_t ModuleRtpRtcpImpl::DeregisterSendRtpHeaderExtension(
     const RTPExtensionType type) {
-  return rtp_sender_->packet_generator_.DeregisterRtpHeaderExtension(type);
+  return rtp_sender_->DeregisterRtpHeaderExtension(type);
 }
 void ModuleRtpRtcpImpl::DeregisterSendRtpHeaderExtension(
     absl::string_view uri) {
-  rtp_sender_->packet_generator_.DeregisterRtpHeaderExtension(uri);
+  rtp_sender_->DeregisterRtpHeaderExtension(uri);
 }
 
 // (TMMBR) Temporary Max Media Bit Rate.
@@ -648,15 +616,11 @@ bool ModuleRtpRtcpImpl::TimeToSendFullNackList(int64_t now) const {
 // Store the sent packets, needed to answer to Negative acknowledgment requests.
 void ModuleRtpRtcpImpl::SetStorePacketsStatus(const bool enable,
                                               const uint16_t number_to_store) {
-  rtp_sender_->packet_history_.SetStorePacketsStatus(
-      enable ? RtpPacketHistory::StorageMode::kStoreAndCull
-             : RtpPacketHistory::StorageMode::kDisabled,
-      number_to_store);
+  rtp_sender_->SetStorePacketsStatus(enable, number_to_store);
 }
 
 bool ModuleRtpRtcpImpl::StorePackets() const {
-  return rtp_sender_->packet_history_.GetStorageMode() !=
-         RtpPacketHistory::StorageMode::kDisabled;
+  return rtp_sender_->StorePackets();
 }
 
 void ModuleRtpRtcpImpl::RegisterRtcpStatisticsCallback(
@@ -702,12 +666,12 @@ void ModuleRtpRtcpImpl::BitrateSent(uint32_t* total_rate,
                                     uint32_t* video_rate,
                                     uint32_t* fec_rate,
                                     uint32_t* nack_rate) const {
-  *total_rate = rtp_sender_->packet_sender_.SendBitrate().bps<uint32_t>();
+  *total_rate = rtp_sender_->BitrateSent();
   if (video_rate)
     *video_rate = 0;
   if (fec_rate)
     *fec_rate = 0;
-  *nack_rate = rtp_sender_->packet_sender_.NackOverheadRate().bps<uint32_t>();
+  *nack_rate = rtp_sender_->NackOverheadRate();
 }
 
 void ModuleRtpRtcpImpl::OnRequestSendReport() {
@@ -719,7 +683,7 @@ void ModuleRtpRtcpImpl::OnReceivedNack(
   if (!rtp_sender_)
     return;
 
-  if (!StorePackets() || nack_sequence_numbers.empty()) {
+  if (!rtp_sender_->StorePackets() || nack_sequence_numbers.empty()) {
     return;
   }
   // Use RTT from RtcpRttStats class if provided.
@@ -727,7 +691,7 @@ void ModuleRtpRtcpImpl::OnReceivedNack(
   if (rtt == 0) {
     rtcp_receiver_.RTT(rtcp_receiver_.RemoteSSRC(), NULL, &rtt, NULL, NULL);
   }
-  rtp_sender_->packet_generator_.OnReceivedNack(nack_sequence_numbers, rtt);
+  rtp_sender_->OnReceivedNack(nack_sequence_numbers, rtt);
 }
 
 void ModuleRtpRtcpImpl::OnReceivedRtcpReportBlocks(
@@ -735,18 +699,18 @@ void ModuleRtpRtcpImpl::OnReceivedRtcpReportBlocks(
   if (ack_observer_) {
     uint32_t ssrc = SSRC();
     absl::optional<uint32_t> rtx_ssrc;
-    if (rtp_sender_->packet_generator_.RtxStatus() != kRtxOff) {
-      rtx_ssrc = rtp_sender_->packet_generator_.RtxSsrc();
+    if (rtp_sender_->RtxStatus() != kRtxOff) {
+      rtx_ssrc = rtp_sender_->RtxSsrc();
     }
 
     for (const RTCPReportBlock& report_block : report_blocks) {
       if (ssrc == report_block.source_ssrc) {
-        rtp_sender_->packet_generator_.OnReceivedAckOnSsrc(
+        rtp_sender_->OnReceivedAckOnSsrc(
             report_block.extended_highest_sequence_number);
         ack_observer_->OnReceivedAck(
             report_block.extended_highest_sequence_number);
       } else if (rtx_ssrc && *rtx_ssrc == report_block.source_ssrc) {
-        rtp_sender_->packet_generator_.OnReceivedAckOnRtxSsrc(
+        rtp_sender_->OnReceivedAckOnRtxSsrc(
             report_block.extended_highest_sequence_number);
       }
     }
@@ -778,9 +742,8 @@ std::vector<rtcp::TmmbItem> ModuleRtpRtcpImpl::BoundingSet(bool* tmmbr_owner) {
 void ModuleRtpRtcpImpl::set_rtt_ms(int64_t rtt_ms) {
   rtc::CritScope cs(&critical_section_rtt_);
   rtt_ms_ = rtt_ms;
-  if (rtp_sender_) {
-    rtp_sender_->packet_history_.SetRtt(rtt_ms);
-  }
+  if (rtp_sender_)
+    rtp_sender_->SetRtt(rtt_ms);
 }
 
 int64_t ModuleRtpRtcpImpl::rtt_ms() const {
@@ -794,11 +757,11 @@ void ModuleRtpRtcpImpl::SetVideoBitrateAllocation(
 }
 
 RTPSender* ModuleRtpRtcpImpl::RtpSender() {
-  return rtp_sender_ ? &rtp_sender_->packet_generator_ : nullptr;
+  return rtp_sender_.get();
 }
 
 const RTPSender* ModuleRtpRtcpImpl::RtpSender() const {
-  return rtp_sender_ ? &rtp_sender_->packet_generator_ : nullptr;
+  return rtp_sender_.get();
 }
 
 }  // namespace webrtc
diff --git a/modules/rtp_rtcp/source/rtp_rtcp_impl.h b/modules/rtp_rtcp/source/rtp_rtcp_impl.h
index 0edf1ba1b4..01ef03ad46 100644
--- a/modules/rtp_rtcp/source/rtp_rtcp_impl.h
+++ b/modules/rtp_rtcp/source/rtp_rtcp_impl.h
@@ -29,10 +29,8 @@
 #include "modules/rtp_rtcp/source/rtcp_packet/tmmb_item.h"
 #include "modules/rtp_rtcp/source/rtcp_receiver.h"
 #include "modules/rtp_rtcp/source/rtcp_sender.h"
-#include "modules/rtp_rtcp/source/rtp_packet_history.h"
 #include "modules/rtp_rtcp/source/rtp_packet_to_send.h"
 #include "modules/rtp_rtcp/source/rtp_sender.h"
-#include "modules/rtp_rtcp/source/rtp_sender_egress.h"
 #include "rtc_base/critical_section.h"
 #include "rtc_base/gtest_prod_util.h"
 
@@ -280,12 +278,8 @@ class ModuleRtpRtcpImpl : public RtpRtcp, public RTCPReceiver::ModuleRtpRtcp {
  protected:
   bool UpdateRTCPReceiveInformationTimers();
 
-  RTPSender* rtp_sender() {
-    return rtp_sender_ ? &rtp_sender_->packet_generator_ : nullptr;
-  }
-  const RTPSender* rtp_sender() const {
-    return rtp_sender_ ? &rtp_sender_->packet_generator_ : nullptr;
-  }
+  RTPSender* rtp_sender() { return rtp_sender_.get(); }
+  const RTPSender* rtp_sender() const { return rtp_sender_.get(); }
 
   RTCPSender* rtcp_sender() { return &rtcp_sender_; }
   const RTCPSender* rtcp_sender() const { return &rtcp_sender_; }
@@ -299,26 +293,12 @@ class ModuleRtpRtcpImpl : public RtpRtcp, public RTCPReceiver::ModuleRtpRtcp {
   FRIEND_TEST_ALL_PREFIXES(RtpRtcpImplTest, Rtt);
   FRIEND_TEST_ALL_PREFIXES(RtpRtcpImplTest, RttForReceiverOnly);
 
-  struct RtpSenderContext {
-    explicit RtpSenderContext(const RtpRtcp::Configuration& config);
-    // Storage of packets, for retransmissions and padding, if applicable.
-    RtpPacketHistory packet_history_;
-    // Handles final time timestamping/stats/etc and handover to Transport.
-    RtpSenderEgress packet_sender_;
-    // If no paced sender configured, this class will be used to pass packets
-    // from |packet_generator_| to |packet_sender_|.
-    RtpSenderEgress::NonPacedPacketSender non_paced_sender_;
-    // Handles creation of RTP packets to be sent.
-    RTPSender packet_generator_;
-  };
-
   void set_rtt_ms(int64_t rtt_ms);
   int64_t rtt_ms() const;
 
   bool TimeToSendFullNackList(int64_t now) const;
 
-  std::unique_ptr<RtpSenderContext> rtp_sender_;
-
+  std::unique_ptr<RTPSender> rtp_sender_;
   RTCPSender rtcp_sender_;
   RTCPReceiver rtcp_receiver_;
 
diff --git a/modules/rtp_rtcp/source/rtp_sender_audio_unittest.cc b/modules/rtp_rtcp/source/rtp_sender_audio_unittest.cc
index f4840d1e75..32938fb186 100644
--- a/modules/rtp_rtcp/source/rtp_sender_audio_unittest.cc
+++ b/modules/rtp_rtcp/source/rtp_sender_audio_unittest.cc
@@ -10,7 +10,6 @@
 
 #include "modules/rtp_rtcp/source/rtp_sender_audio.h"
 
-#include <memory>
 #include <vector>
 
 #include "api/transport/field_trial_based_config.h"
@@ -18,6 +17,7 @@
 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 #include "modules/rtp_rtcp/source/rtp_header_extensions.h"
 #include "modules/rtp_rtcp/source/rtp_packet_received.h"
+#include "modules/rtp_rtcp/source/rtp_sender.h"
 #include "test/gmock.h"
 #include "test/gtest.h"
 
@@ -63,21 +63,21 @@ class RtpSenderAudioTest : public ::testing::Test {
  public:
   RtpSenderAudioTest()
       : fake_clock_(kStartTime),
-        rtp_module_(RtpRtcp::Create([&] {
+        rtp_sender_([&] {
           RtpRtcp::Configuration config;
           config.audio = true;
           config.clock = &fake_clock_;
           config.outgoing_transport = &transport_;
           config.local_media_ssrc = kSsrc;
           return config;
-        }())),
-        rtp_sender_audio_(&fake_clock_, rtp_module_->RtpSender()) {
-    rtp_module_->SetSequenceNumber(kSeqNum);
+        }()),
+        rtp_sender_audio_(&fake_clock_, &rtp_sender_) {
+    rtp_sender_.SetSequenceNumber(kSeqNum);
   }
 
   SimulatedClock fake_clock_;
   LoopbackTransportTest transport_;
-  std::unique_ptr<RtpRtcp> rtp_module_;
+  RTPSender rtp_sender_;
   RTPSenderAudio rtp_sender_audio_;
 };
 
@@ -98,8 +98,8 @@ TEST_F(RtpSenderAudioTest, SendAudio) {
 
 TEST_F(RtpSenderAudioTest, SendAudioWithAudioLevelExtension) {
   EXPECT_EQ(0, rtp_sender_audio_.SetAudioLevel(kAudioLevel));
-  rtp_module_->RegisterRtpHeaderExtension(AudioLevel::kUri,
-                                          kAudioLevelExtensionId);
+  EXPECT_EQ(0, rtp_sender_.RegisterRtpHeaderExtension(kRtpExtensionAudioLevel,
+                                                      kAudioLevelExtensionId));
 
   const char payload_name[] = "PAYLOAD_NAME";
   const uint8_t payload_type = 127;
diff --git a/modules/rtp_rtcp/source/rtp_sender_unittest.cc b/modules/rtp_rtcp/source/rtp_sender_unittest.cc
index b51b95b7af..af4ae15cd2 100644
--- a/modules/rtp_rtcp/source/rtp_sender_unittest.cc
+++ b/modules/rtp_rtcp/source/rtp_sender_unittest.cc
@@ -29,7 +29,6 @@
 #include "modules/rtp_rtcp/source/rtp_header_extensions.h"
 #include "modules/rtp_rtcp/source/rtp_packet_received.h"
 #include "modules/rtp_rtcp/source/rtp_packet_to_send.h"
-#include "modules/rtp_rtcp/source/rtp_sender_egress.h"
 #include "modules/rtp_rtcp/source/rtp_sender_video.h"
 #include "modules/rtp_rtcp/source/rtp_utility.h"
 #include "rtc_base/arraysize.h"
@@ -148,6 +147,8 @@ std::string ToFieldTrialString(TestConfig config) {
   return field_trials;
 }
 
+}  // namespace
+
 class MockRtpPacketPacer : public RtpPacketSender {
  public:
   MockRtpPacketPacer() {}
@@ -219,30 +220,12 @@ class StreamDataTestCallback : public StreamDataCountersCallback {
   }
 };
 
-// Mimics ModuleRtpRtcp::RtpSenderContext.
-// TODO(sprang): Split up unit tests and test these components individually
-// wherever possible.
-struct RtpSenderContext {
-  explicit RtpSenderContext(const RtpRtcp::Configuration& config)
-      : packet_history_(config.clock),
-        packet_sender_(config, &packet_history_),
-        non_paced_sender_(&packet_sender_),
-        packet_generator_(
-            config,
-            &packet_history_,
-            config.paced_sender ? config.paced_sender : &non_paced_sender_) {}
-  RtpPacketHistory packet_history_;
-  RtpSenderEgress packet_sender_;
-  RtpSenderEgress::NonPacedPacketSender non_paced_sender_;
-  RTPSender packet_generator_;
-};
-
-}  // namespace
-
 class RtpSenderTest : public ::testing::TestWithParam<TestConfig> {
  protected:
   RtpSenderTest()
       : fake_clock_(kStartTime),
+        mock_rtc_event_log_(),
+        mock_paced_sender_(),
         retransmission_rate_limiter_(&fake_clock_, 1000),
         flexfec_sender_(0,
                         kFlexFecSsrc,
@@ -252,21 +235,13 @@ class RtpSenderTest : public ::testing::TestWithParam<TestConfig> {
                         std::vector<RtpExtensionSize>(),
                         nullptr,
                         &fake_clock_),
+        rtp_sender_(),
+        transport_(),
         kMarkerBit(true),
         field_trials_(ToFieldTrialString(GetParam())) {}
 
   void SetUp() override { SetUpRtpSender(true, false); }
 
-  RTPSender* rtp_sender() {
-    RTC_DCHECK(rtp_sender_context_);
-    return &rtp_sender_context_->packet_generator_;
-  }
-
-  RtpSenderEgress* rtp_egress() {
-    RTC_DCHECK(rtp_sender_context_);
-    return &rtp_sender_context_->packet_sender_;
-  }
-
   void SetUpRtpSender(bool pacer, bool populate_network2) {
     RtpRtcp::Configuration config;
     config.clock = &fake_clock_;
@@ -280,9 +255,9 @@ class RtpSenderTest : public ::testing::TestWithParam<TestConfig> {
     config.paced_sender = pacer ? &mock_paced_sender_ : nullptr;
     config.populate_network2_timestamp = populate_network2;
     config.rtp_stats_callback = &rtp_stats_callback_;
-    rtp_sender_context_ = std::make_unique<RtpSenderContext>(config);
-    rtp_sender()->SetSequenceNumber(kSeqNum);
-    rtp_sender()->SetTimestampOffset(0);
+    rtp_sender_.reset(new RTPSender(config));
+    rtp_sender_->SetSequenceNumber(kSeqNum);
+    rtp_sender_->SetTimestampOffset(0);
   }
 
   SimulatedClock fake_clock_;
@@ -292,9 +267,7 @@ class RtpSenderTest : public ::testing::TestWithParam<TestConfig> {
   StrictMock<MockTransportFeedbackObserver> feedback_observer_;
   RateLimiter retransmission_rate_limiter_;
   FlexfecSender flexfec_sender_;
-
-  std::unique_ptr<RtpSenderContext> rtp_sender_context_;
-
+  std::unique_ptr<RTPSender> rtp_sender_;
   LoopbackTransportTest transport_;
   const bool kMarkerBit;
   test::ScopedFieldTrials field_trials_;
@@ -304,13 +277,13 @@ class RtpSenderTest : public ::testing::TestWithParam<TestConfig> {
                                                   bool marker_bit,
                                                   uint32_t timestamp,
                                                   int64_t capture_time_ms) {
-    auto packet = rtp_sender()->AllocatePacket();
+    auto packet = rtp_sender_->AllocatePacket();
     packet->SetPayloadType(payload_type);
     packet->set_packet_type(RtpPacketToSend::Type::kVideo);
     packet->SetMarker(marker_bit);
     packet->SetTimestamp(timestamp);
     packet->set_capture_time_ms(capture_time_ms);
-    EXPECT_TRUE(rtp_sender()->AssignSequenceNumber(packet.get()));
+    EXPECT_TRUE(rtp_sender_->AssignSequenceNumber(packet.get()));
     return packet;
   }
 
@@ -323,8 +296,8 @@ class RtpSenderTest : public ::testing::TestWithParam<TestConfig> {
     packet->set_allow_retransmission(true);
 
     // Packet should be stored in a send bucket.
-    EXPECT_TRUE(rtp_sender()->SendToNetwork(
-        std::make_unique<RtpPacketToSend>(*packet)));
+    EXPECT_TRUE(
+        rtp_sender_->SendToNetwork(std::make_unique<RtpPacketToSend>(*packet)));
     return packet;
   }
 
@@ -335,10 +308,9 @@ class RtpSenderTest : public ::testing::TestWithParam<TestConfig> {
 
   size_t GenerateAndSendPadding(size_t target_size_bytes) {
     size_t generated_bytes = 0;
-    for (auto& packet :
-         rtp_sender()->GeneratePadding(target_size_bytes, true)) {
+    for (auto& packet : rtp_sender_->GeneratePadding(target_size_bytes)) {
       generated_bytes += packet->payload_size() + packet->padding_size();
-      rtp_egress()->SendPacket(packet.get(), PacedPacketInfo());
+      rtp_sender_->TrySendPacket(packet.get(), PacedPacketInfo());
     }
     return generated_bytes;
   }
@@ -351,27 +323,26 @@ class RtpSenderTest : public ::testing::TestWithParam<TestConfig> {
     // RTX needs to be able to read the source packets from the packet store.
     // Pick a number of packets to store big enough for any unit test.
     constexpr uint16_t kNumberOfPacketsToStore = 100;
-    rtp_sender_context_->packet_history_.SetStorePacketsStatus(
-        RtpPacketHistory::StorageMode::kStoreAndCull, kNumberOfPacketsToStore);
-    rtp_sender()->SetRtxPayloadType(kRtxPayload, kPayload);
-    rtp_sender()->SetRtxStatus(kRtxRetransmitted | kRtxRedundantPayloads);
+    rtp_sender_->SetStorePacketsStatus(true, kNumberOfPacketsToStore);
+    rtp_sender_->SetRtxPayloadType(kRtxPayload, kPayload);
+    rtp_sender_->SetRtxStatus(kRtxRetransmitted | kRtxRedundantPayloads);
   }
 
   // Enable sending of the MID header extension for both the primary SSRC and
   // the RTX SSRC.
   void EnableMidSending(const std::string& mid) {
-    rtp_sender()->RegisterRtpHeaderExtension(kRtpExtensionMid, kMidExtensionId);
-    rtp_sender()->SetMid(mid);
+    rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionMid, kMidExtensionId);
+    rtp_sender_->SetMid(mid);
   }
 
   // Enable sending of the RSID header extension for the primary SSRC and the
   // RRSID header extension for the RTX SSRC.
   void EnableRidSending(const std::string& rid) {
-    rtp_sender()->RegisterRtpHeaderExtension(kRtpExtensionRtpStreamId,
-                                             kRidExtensionId);
-    rtp_sender()->RegisterRtpHeaderExtension(kRtpExtensionRepairedRtpStreamId,
-                                             kRepairedRidExtensionId);
-    rtp_sender()->SetRid(rid);
+    rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionRtpStreamId,
+                                            kRidExtensionId);
+    rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionRepairedRtpStreamId,
+                                            kRepairedRidExtensionId);
+    rtp_sender_->SetRid(rid);
   }
 };
 
@@ -386,32 +357,32 @@ TEST_P(RtpSenderTestWithoutPacer, AllocatePacketSetCsrc) {
   // Configure rtp_sender with csrc.
   std::vector<uint32_t> csrcs;
   csrcs.push_back(0x23456789);
-  rtp_sender()->SetCsrcs(csrcs);
+  rtp_sender_->SetCsrcs(csrcs);
 
-  auto packet = rtp_sender()->AllocatePacket();
+  auto packet = rtp_sender_->AllocatePacket();
 
   ASSERT_TRUE(packet);
-  EXPECT_EQ(rtp_sender()->SSRC(), packet->Ssrc());
+  EXPECT_EQ(rtp_sender_->SSRC(), packet->Ssrc());
   EXPECT_EQ(csrcs, packet->Csrcs());
 }
 
 TEST_P(RtpSenderTestWithoutPacer, AllocatePacketReserveExtensions) {
   // Configure rtp_sender with extensions.
-  ASSERT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension(
+  ASSERT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionTransmissionTimeOffset,
                    kTransmissionTimeOffsetExtensionId));
-  ASSERT_EQ(0,
-            rtp_sender()->RegisterRtpHeaderExtension(
-                kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId));
-  ASSERT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension(
-                   kRtpExtensionAudioLevel, kAudioLevelExtensionId));
-  ASSERT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension(
+  ASSERT_EQ(
+      0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
+                                                 kAbsoluteSendTimeExtensionId));
+  ASSERT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAudioLevel,
+                                                       kAudioLevelExtensionId));
+  ASSERT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionTransportSequenceNumber,
                    kTransportSequenceNumberExtensionId));
-  ASSERT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension(
+  ASSERT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionVideoRotation, kVideoRotationExtensionId));
 
-  auto packet = rtp_sender()->AllocatePacket();
+  auto packet = rtp_sender_->AllocatePacket();
 
   ASSERT_TRUE(packet);
   // Preallocate BWE extensions RtpSender set itself.
@@ -424,39 +395,39 @@ TEST_P(RtpSenderTestWithoutPacer, AllocatePacketReserveExtensions) {
 }
 
 TEST_P(RtpSenderTestWithoutPacer, AssignSequenceNumberAdvanceSequenceNumber) {
-  auto packet = rtp_sender()->AllocatePacket();
+  auto packet = rtp_sender_->AllocatePacket();
   ASSERT_TRUE(packet);
-  const uint16_t sequence_number = rtp_sender()->SequenceNumber();
+  const uint16_t sequence_number = rtp_sender_->SequenceNumber();
 
-  EXPECT_TRUE(rtp_sender()->AssignSequenceNumber(packet.get()));
+  EXPECT_TRUE(rtp_sender_->AssignSequenceNumber(packet.get()));
 
   EXPECT_EQ(sequence_number, packet->SequenceNumber());
-  EXPECT_EQ(sequence_number + 1, rtp_sender()->SequenceNumber());
+  EXPECT_EQ(sequence_number + 1, rtp_sender_->SequenceNumber());
 }
 
 TEST_P(RtpSenderTestWithoutPacer, AssignSequenceNumberFailsOnNotSending) {
-  auto packet = rtp_sender()->AllocatePacket();
+  auto packet = rtp_sender_->AllocatePacket();
   ASSERT_TRUE(packet);
 
-  rtp_sender()->SetSendingMediaStatus(false);
-  EXPECT_FALSE(rtp_sender()->AssignSequenceNumber(packet.get()));
+  rtp_sender_->SetSendingMediaStatus(false);
+  EXPECT_FALSE(rtp_sender_->AssignSequenceNumber(packet.get()));
 }
 
 TEST_P(RtpSenderTestWithoutPacer, AssignSequenceNumberMayAllowPaddingOnVideo) {
   constexpr size_t kPaddingSize = 100;
-  auto packet = rtp_sender()->AllocatePacket();
+  auto packet = rtp_sender_->AllocatePacket();
   ASSERT_TRUE(packet);
 
-  ASSERT_TRUE(rtp_sender()->GeneratePadding(kPaddingSize, true).empty());
+  ASSERT_TRUE(rtp_sender_->GeneratePadding(kPaddingSize).empty());
   packet->SetMarker(false);
-  ASSERT_TRUE(rtp_sender()->AssignSequenceNumber(packet.get()));
+  ASSERT_TRUE(rtp_sender_->AssignSequenceNumber(packet.get()));
   // Packet without marker bit doesn't allow padding on video stream.
-  ASSERT_TRUE(rtp_sender()->GeneratePadding(kPaddingSize, true).empty());
+  ASSERT_TRUE(rtp_sender_->GeneratePadding(kPaddingSize).empty());
 
   packet->SetMarker(true);
-  ASSERT_TRUE(rtp_sender()->AssignSequenceNumber(packet.get()));
+  ASSERT_TRUE(rtp_sender_->AssignSequenceNumber(packet.get()));
   // Packet with marker bit allows send padding.
-  ASSERT_FALSE(rtp_sender()->GeneratePadding(kPaddingSize, true).empty());
+  ASSERT_FALSE(rtp_sender_->GeneratePadding(kPaddingSize).empty());
 }
 
 TEST_P(RtpSenderTest, AssignSequenceNumberAllowsPaddingOnAudio) {
@@ -469,16 +440,15 @@ TEST_P(RtpSenderTest, AssignSequenceNumberAllowsPaddingOnAudio) {
   config.local_media_ssrc = kSsrc;
   config.event_log = &mock_rtc_event_log_;
   config.retransmission_rate_limiter = &retransmission_rate_limiter_;
-  rtp_sender_context_ = std::make_unique<RtpSenderContext>(config);
+  rtp_sender_ = std::make_unique<RTPSender>(config);
 
-  rtp_sender()->SetTimestampOffset(0);
+  rtp_sender_->SetTimestampOffset(0);
 
-  std::unique_ptr<RtpPacketToSend> audio_packet =
-      rtp_sender()->AllocatePacket();
+  std::unique_ptr<RtpPacketToSend> audio_packet = rtp_sender_->AllocatePacket();
   // Padding on audio stream allowed regardless of marker in the last packet.
   audio_packet->SetMarker(false);
   audio_packet->SetPayloadType(kPayload);
-  rtp_sender()->AssignSequenceNumber(audio_packet.get());
+  rtp_sender_->AssignSequenceNumber(audio_packet.get());
 
   const size_t kPaddingSize = 59;
   EXPECT_CALL(transport, SendRtp(_, kPaddingSize + kRtpHeaderSize, _))
@@ -494,13 +464,13 @@ TEST_P(RtpSenderTest, AssignSequenceNumberAllowsPaddingOnAudio) {
 
 TEST_P(RtpSenderTestWithoutPacer, AssignSequenceNumberSetPaddingTimestamps) {
   constexpr size_t kPaddingSize = 100;
-  auto packet = rtp_sender()->AllocatePacket();
+  auto packet = rtp_sender_->AllocatePacket();
   ASSERT_TRUE(packet);
   packet->SetMarker(true);
   packet->SetTimestamp(kTimestamp);
 
-  ASSERT_TRUE(rtp_sender()->AssignSequenceNumber(packet.get()));
-  auto padding_packets = rtp_sender()->GeneratePadding(kPaddingSize, true);
+  ASSERT_TRUE(rtp_sender_->AssignSequenceNumber(packet.get()));
+  auto padding_packets = rtp_sender_->GeneratePadding(kPaddingSize);
 
   ASSERT_EQ(1u, padding_packets.size());
   // Verify padding packet timestamp.
@@ -520,9 +490,9 @@ TEST_P(RtpSenderTestWithoutPacer,
   config.event_log = &mock_rtc_event_log_;
   config.retransmission_rate_limiter = &retransmission_rate_limiter_;
   config.overhead_observer = &mock_overhead_observer;
-  rtp_sender_context_ = std::make_unique<RtpSenderContext>(config);
+  rtp_sender_ = std::make_unique<RTPSender>(config);
 
-  EXPECT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension(
+  EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionTransportSequenceNumber,
                    kTransportSequenceNumberExtensionId));
 
@@ -533,11 +503,11 @@ TEST_P(RtpSenderTestWithoutPacer,
 
   EXPECT_CALL(feedback_observer_,
               OnAddPacket(AllOf(
-                  Field(&RtpPacketSendInfo::ssrc, rtp_sender()->SSRC()),
+                  Field(&RtpPacketSendInfo::ssrc, rtp_sender_->SSRC()),
                   Field(&RtpPacketSendInfo::transport_sequence_number,
                         kTransportSequenceNumber),
                   Field(&RtpPacketSendInfo::rtp_sequence_number,
-                        rtp_sender()->SequenceNumber()),
+                        rtp_sender_->SequenceNumber()),
                   Field(&RtpPacketSendInfo::length, expected_bytes),
                   Field(&RtpPacketSendInfo::pacing_info, PacedPacketInfo()))))
       .Times(1);
@@ -556,9 +526,9 @@ TEST_P(RtpSenderTestWithoutPacer, SendsPacketsWithTransportSequenceNumber) {
   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);
+  rtp_sender_ = std::make_unique<RTPSender>(config);
 
-  EXPECT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension(
+  EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionTransportSequenceNumber,
                    kTransportSequenceNumberExtensionId));
 
@@ -568,11 +538,11 @@ TEST_P(RtpSenderTestWithoutPacer, SendsPacketsWithTransportSequenceNumber) {
 
   EXPECT_CALL(feedback_observer_,
               OnAddPacket(AllOf(
-                  Field(&RtpPacketSendInfo::ssrc, rtp_sender()->SSRC()),
+                  Field(&RtpPacketSendInfo::ssrc, rtp_sender_->SSRC()),
                   Field(&RtpPacketSendInfo::transport_sequence_number,
                         kTransportSequenceNumber),
                   Field(&RtpPacketSendInfo::rtp_sequence_number,
-                        rtp_sender()->SequenceNumber()),
+                        rtp_sender_->SequenceNumber()),
                   Field(&RtpPacketSendInfo::pacing_info, PacedPacketInfo()))))
       .Times(1);
 
@@ -595,7 +565,7 @@ TEST_P(RtpSenderTestWithoutPacer, PacketOptionsNoRetransmission) {
   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);
+  rtp_sender_ = std::make_unique<RTPSender>(config);
 
   SendGenericPacket();
 
@@ -605,8 +575,8 @@ TEST_P(RtpSenderTestWithoutPacer, PacketOptionsNoRetransmission) {
 TEST_P(RtpSenderTestWithoutPacer,
        SetsIncludedInFeedbackWhenTransportSequenceNumberExtensionIsRegistered) {
   SetUpRtpSender(false, false);
-  rtp_sender()->RegisterRtpHeaderExtension(kRtpExtensionTransportSequenceNumber,
-                                           kTransportSequenceNumberExtensionId);
+  rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionTransportSequenceNumber,
+                                          kTransportSequenceNumberExtensionId);
   EXPECT_CALL(send_packet_observer_, OnSendPacket).Times(1);
   SendGenericPacket();
   EXPECT_TRUE(transport_.last_options_.included_in_feedback);
@@ -616,8 +586,8 @@ TEST_P(
     RtpSenderTestWithoutPacer,
     SetsIncludedInAllocationWhenTransportSequenceNumberExtensionIsRegistered) {
   SetUpRtpSender(false, false);
-  rtp_sender()->RegisterRtpHeaderExtension(kRtpExtensionTransportSequenceNumber,
-                                           kTransportSequenceNumberExtensionId);
+  rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionTransportSequenceNumber,
+                                          kTransportSequenceNumberExtensionId);
   EXPECT_CALL(send_packet_observer_, OnSendPacket).Times(1);
   SendGenericPacket();
   EXPECT_TRUE(transport_.last_options_.included_in_allocation);
@@ -626,7 +596,7 @@ TEST_P(
 TEST_P(RtpSenderTestWithoutPacer,
        SetsIncludedInAllocationWhenForcedAsPartOfAllocation) {
   SetUpRtpSender(false, false);
-  rtp_egress()->ForceIncludeSendPacketsInAllocation(true);
+  rtp_sender_->SetAsPartOfAllocation(true);
   SendGenericPacket();
   EXPECT_FALSE(transport_.last_options_.included_in_feedback);
   EXPECT_TRUE(transport_.last_options_.included_in_allocation);
@@ -648,13 +618,13 @@ TEST_P(RtpSenderTestWithoutPacer, OnSendSideDelayUpdated) {
   config.local_media_ssrc = kSsrc;
   config.send_side_delay_observer = &send_side_delay_observer_;
   config.event_log = &mock_rtc_event_log_;
-  rtp_sender_context_ = std::make_unique<RtpSenderContext>(config);
+  rtp_sender_ = std::make_unique<RTPSender>(config);
 
   PlayoutDelayOracle playout_delay_oracle;
   FieldTrialBasedConfig field_trials;
   RTPSenderVideo::Config video_config;
   video_config.clock = &fake_clock_;
-  video_config.rtp_sender = rtp_sender();
+  video_config.rtp_sender = rtp_sender_.get();
   video_config.playout_delay_oracle = &playout_delay_oracle;
   video_config.field_trials = &field_trials;
   RTPSenderVideo rtp_sender_video(video_config);
@@ -720,7 +690,7 @@ TEST_P(RtpSenderTestWithoutPacer, OnSendSideDelayUpdated) {
 }
 
 TEST_P(RtpSenderTestWithoutPacer, OnSendPacketUpdated) {
-  EXPECT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension(
+  EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionTransportSequenceNumber,
                    kTransportSequenceNumberExtensionId));
   EXPECT_CALL(send_packet_observer_,
@@ -740,12 +710,11 @@ TEST_P(RtpSenderTest, SendsPacketsWithTransportSequenceNumber) {
   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);
+  rtp_sender_ = std::make_unique<RTPSender>(config);
 
-  rtp_sender()->SetSequenceNumber(kSeqNum);
-  rtp_sender_context_->packet_history_.SetStorePacketsStatus(
-      RtpPacketHistory::StorageMode::kStoreAndCull, 10);
-  EXPECT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension(
+  rtp_sender_->SetSequenceNumber(kSeqNum);
+  rtp_sender_->SetStorePacketsStatus(true, 10);
+  EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionTransportSequenceNumber,
                    kTransportSequenceNumberExtensionId));
 
@@ -754,11 +723,11 @@ TEST_P(RtpSenderTest, SendsPacketsWithTransportSequenceNumber) {
       .Times(1);
   EXPECT_CALL(feedback_observer_,
               OnAddPacket(AllOf(
-                  Field(&RtpPacketSendInfo::ssrc, rtp_sender()->SSRC()),
+                  Field(&RtpPacketSendInfo::ssrc, rtp_sender_->SSRC()),
                   Field(&RtpPacketSendInfo::transport_sequence_number,
                         kTransportSequenceNumber),
                   Field(&RtpPacketSendInfo::rtp_sequence_number,
-                        rtp_sender()->SequenceNumber()),
+                        rtp_sender_->SequenceNumber()),
                   Field(&RtpPacketSendInfo::pacing_info, PacedPacketInfo()))))
       .Times(1);
 
@@ -769,9 +738,9 @@ TEST_P(RtpSenderTest, SendsPacketsWithTransportSequenceNumber) {
           Pointee(Property(&RtpPacketToSend::SequenceNumber, kSeqNum))))));
   auto packet = SendGenericPacket();
   packet->set_packet_type(RtpPacketToSend::Type::kVideo);
-  // Transport sequence number is set by PacketRouter, before SendPacket().
+  // Transport sequence number is set by PacketRouter, before TrySendPacket().
   packet->SetExtension<TransportSequenceNumber>(kTransportSequenceNumber);
-  rtp_egress()->SendPacket(packet.get(), PacedPacketInfo());
+  rtp_sender_->TrySendPacket(packet.get(), PacedPacketInfo());
 
   uint16_t transport_seq_no;
   EXPECT_TRUE(
@@ -782,19 +751,18 @@ TEST_P(RtpSenderTest, SendsPacketsWithTransportSequenceNumber) {
 }
 
 TEST_P(RtpSenderTest, WritesPacerExitToTimingExtension) {
-  rtp_sender_context_->packet_history_.SetStorePacketsStatus(
-      RtpPacketHistory::StorageMode::kStoreAndCull, 10);
-  EXPECT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension(
+  rtp_sender_->SetStorePacketsStatus(true, 10);
+  EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionVideoTiming, kVideoTimingExtensionId));
   int64_t capture_time_ms = fake_clock_.TimeInMilliseconds();
-  auto packet = rtp_sender()->AllocatePacket();
+  auto packet = rtp_sender_->AllocatePacket();
   packet->SetPayloadType(kPayload);
   packet->SetMarker(true);
   packet->SetTimestamp(kTimestamp);
   packet->set_capture_time_ms(capture_time_ms);
   const VideoSendTiming kVideoTiming = {0u, 0u, 0u, 0u, 0u, 0u, true};
   packet->SetExtension<VideoTimingExtension>(kVideoTiming);
-  EXPECT_TRUE(rtp_sender()->AssignSequenceNumber(packet.get()));
+  EXPECT_TRUE(rtp_sender_->AssignSequenceNumber(packet.get()));
   size_t packet_size = packet->size();
 
   const int kStoredTimeInMs = 100;
@@ -803,9 +771,9 @@ TEST_P(RtpSenderTest, WritesPacerExitToTimingExtension) {
   EXPECT_CALL(mock_paced_sender_, EnqueuePackets(Contains(Pointee(Property(
                                       &RtpPacketToSend::Ssrc, kSsrc)))));
   EXPECT_TRUE(
-      rtp_sender()->SendToNetwork(std::make_unique<RtpPacketToSend>(*packet)));
+      rtp_sender_->SendToNetwork(std::make_unique<RtpPacketToSend>(*packet)));
   fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs);
-  rtp_egress()->SendPacket(packet.get(), PacedPacketInfo());
+  rtp_sender_->TrySendPacket(packet.get(), PacedPacketInfo());
   EXPECT_EQ(1, transport_.packets_sent());
   EXPECT_EQ(packet_size, transport_.last_sent_packet().size());
 
@@ -817,12 +785,11 @@ TEST_P(RtpSenderTest, WritesPacerExitToTimingExtension) {
 
 TEST_P(RtpSenderTest, WritesNetwork2ToTimingExtensionWithPacer) {
   SetUpRtpSender(/*pacer=*/true, /*populate_network2=*/true);
-  rtp_sender_context_->packet_history_.SetStorePacketsStatus(
-      RtpPacketHistory::StorageMode::kStoreAndCull, 10);
-  EXPECT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension(
+  rtp_sender_->SetStorePacketsStatus(true, 10);
+  EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionVideoTiming, kVideoTimingExtensionId));
   int64_t capture_time_ms = fake_clock_.TimeInMilliseconds();
-  auto packet = rtp_sender()->AllocatePacket();
+  auto packet = rtp_sender_->AllocatePacket();
   packet->SetPayloadType(kPayload);
   packet->SetMarker(true);
   packet->SetTimestamp(kTimestamp);
@@ -830,7 +797,7 @@ TEST_P(RtpSenderTest, WritesNetwork2ToTimingExtensionWithPacer) {
   const uint16_t kPacerExitMs = 1234u;
   const VideoSendTiming kVideoTiming = {0u, 0u, 0u, kPacerExitMs, 0u, 0u, true};
   packet->SetExtension<VideoTimingExtension>(kVideoTiming);
-  EXPECT_TRUE(rtp_sender()->AssignSequenceNumber(packet.get()));
+  EXPECT_TRUE(rtp_sender_->AssignSequenceNumber(packet.get()));
   size_t packet_size = packet->size();
 
   const int kStoredTimeInMs = 100;
@@ -839,39 +806,38 @@ TEST_P(RtpSenderTest, WritesNetwork2ToTimingExtensionWithPacer) {
     packet->set_allow_retransmission(true);
     EXPECT_CALL(mock_paced_sender_, EnqueuePackets(Contains(Pointee(Property(
                                         &RtpPacketToSend::Ssrc, kSsrc)))));
-    EXPECT_TRUE(rtp_sender()->SendToNetwork(
-        std::make_unique<RtpPacketToSend>(*packet)));
-    fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs);
-    rtp_egress()->SendPacket(packet.get(), PacedPacketInfo());
-
-    EXPECT_EQ(1, transport_.packets_sent());
-    EXPECT_EQ(packet_size, transport_.last_sent_packet().size());
-
-    VideoSendTiming video_timing;
     EXPECT_TRUE(
-        transport_.last_sent_packet().GetExtension<VideoTimingExtension>(
-            &video_timing));
-    EXPECT_EQ(kStoredTimeInMs, video_timing.network2_timestamp_delta_ms);
-    EXPECT_EQ(kPacerExitMs, video_timing.pacer_exit_delta_ms);
+        rtp_sender_->SendToNetwork(std::make_unique<RtpPacketToSend>(*packet)));
+    fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs);
+    rtp_sender_->TrySendPacket(packet.get(), PacedPacketInfo());
+
+  EXPECT_EQ(1, transport_.packets_sent());
+  EXPECT_EQ(packet_size, transport_.last_sent_packet().size());
+
+  VideoSendTiming video_timing;
+  EXPECT_TRUE(transport_.last_sent_packet().GetExtension<VideoTimingExtension>(
+      &video_timing));
+  EXPECT_EQ(kStoredTimeInMs, video_timing.network2_timestamp_delta_ms);
+  EXPECT_EQ(kPacerExitMs, video_timing.pacer_exit_delta_ms);
 }
 
 TEST_P(RtpSenderTest, WritesNetwork2ToTimingExtensionWithoutPacer) {
   SetUpRtpSender(/*pacer=*/false, /*populate_network2=*/true);
-  EXPECT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension(
+  EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionVideoTiming, kVideoTimingExtensionId));
-  auto packet = rtp_sender()->AllocatePacket();
+  auto packet = rtp_sender_->AllocatePacket();
   packet->SetMarker(true);
   packet->set_capture_time_ms(fake_clock_.TimeInMilliseconds());
   const VideoSendTiming kVideoTiming = {0u, 0u, 0u, 0u, 0u, 0u, true};
   packet->SetExtension<VideoTimingExtension>(kVideoTiming);
   packet->set_allow_retransmission(true);
-  EXPECT_TRUE(rtp_sender()->AssignSequenceNumber(packet.get()));
+  EXPECT_TRUE(rtp_sender_->AssignSequenceNumber(packet.get()));
   packet->set_packet_type(RtpPacketToSend::Type::kVideo);
 
   const int kPropagateTimeMs = 10;
   fake_clock_.AdvanceTimeMilliseconds(kPropagateTimeMs);
 
-  EXPECT_TRUE(rtp_sender()->SendToNetwork(std::move(packet)));
+  EXPECT_TRUE(rtp_sender_->SendToNetwork(std::move(packet)));
 
   EXPECT_EQ(1, transport_.packets_sent());
   absl::optional<VideoSendTiming> video_timing =
@@ -884,14 +850,13 @@ TEST_P(RtpSenderTest, TrafficSmoothingWithExtensions) {
   EXPECT_CALL(mock_rtc_event_log_,
               LogProxy(SameRtcEventTypeAs(RtcEvent::Type::RtpPacketOutgoing)));
 
-  rtp_sender_context_->packet_history_.SetStorePacketsStatus(
-      RtpPacketHistory::StorageMode::kStoreAndCull, 10);
-  EXPECT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension(
+  rtp_sender_->SetStorePacketsStatus(true, 10);
+  EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionTransmissionTimeOffset,
                    kTransmissionTimeOffsetExtensionId));
-  EXPECT_EQ(0,
-            rtp_sender()->RegisterRtpHeaderExtension(
-                kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId));
+  EXPECT_EQ(
+      0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
+                                                 kAbsoluteSendTimeExtensionId));
   int64_t capture_time_ms = fake_clock_.TimeInMilliseconds();
   auto packet =
       BuildRtpPacket(kPayload, kMarkerBit, kTimestamp, capture_time_ms);
@@ -906,10 +871,10 @@ TEST_P(RtpSenderTest, TrafficSmoothingWithExtensions) {
   packet->set_packet_type(RtpPacketToSend::Type::kVideo);
   packet->set_allow_retransmission(true);
   EXPECT_TRUE(
-      rtp_sender()->SendToNetwork(std::make_unique<RtpPacketToSend>(*packet)));
+      rtp_sender_->SendToNetwork(std::make_unique<RtpPacketToSend>(*packet)));
   EXPECT_EQ(0, transport_.packets_sent());
   fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs);
-  rtp_egress()->SendPacket(packet.get(), PacedPacketInfo());
+  rtp_sender_->TrySendPacket(packet.get(), PacedPacketInfo());
 
   // Process send bucket. Packet should now be sent.
   EXPECT_EQ(1, transport_.packets_sent());
@@ -929,14 +894,13 @@ TEST_P(RtpSenderTest, TrafficSmoothingRetransmits) {
   EXPECT_CALL(mock_rtc_event_log_,
               LogProxy(SameRtcEventTypeAs(RtcEvent::Type::RtpPacketOutgoing)));
 
-  rtp_sender_context_->packet_history_.SetStorePacketsStatus(
-      RtpPacketHistory::StorageMode::kStoreAndCull, 10);
-  EXPECT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension(
+  rtp_sender_->SetStorePacketsStatus(true, 10);
+  EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionTransmissionTimeOffset,
                    kTransmissionTimeOffsetExtensionId));
-  EXPECT_EQ(0,
-            rtp_sender()->RegisterRtpHeaderExtension(
-                kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId));
+  EXPECT_EQ(
+      0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
+                                                 kAbsoluteSendTimeExtensionId));
   int64_t capture_time_ms = fake_clock_.TimeInMilliseconds();
   auto packet =
       BuildRtpPacket(kPayload, kMarkerBit, kTimestamp, capture_time_ms);
@@ -951,9 +915,9 @@ TEST_P(RtpSenderTest, TrafficSmoothingRetransmits) {
   packet->set_packet_type(RtpPacketToSend::Type::kVideo);
   packet->set_allow_retransmission(true);
   EXPECT_TRUE(
-      rtp_sender()->SendToNetwork(std::make_unique<RtpPacketToSend>(*packet)));
+      rtp_sender_->SendToNetwork(std::make_unique<RtpPacketToSend>(*packet)));
   // Immediately process send bucket and send packet.
-  rtp_egress()->SendPacket(packet.get(), PacedPacketInfo());
+  rtp_sender_->TrySendPacket(packet.get(), PacedPacketInfo());
 
   EXPECT_EQ(1, transport_.packets_sent());
 
@@ -971,23 +935,22 @@ TEST_P(RtpSenderTest, TrafficSmoothingRetransmits) {
             Pointee(Property(&RtpPacketToSend::Ssrc, kSsrc)),
             Pointee(Property(&RtpPacketToSend::SequenceNumber, kSeqNum))))));
     EXPECT_EQ(static_cast<int>(packet_size),
-              rtp_sender()->ReSendPacket(kSeqNum));
+              rtp_sender_->ReSendPacket(kSeqNum));
     EXPECT_EQ(1, transport_.packets_sent());
-    rtp_egress()->SendPacket(packet.get(), PacedPacketInfo());
+    rtp_sender_->TrySendPacket(packet.get(), PacedPacketInfo());
 
-    // Process send bucket. Packet should now be sent.
-    EXPECT_EQ(2, transport_.packets_sent());
-    EXPECT_EQ(packet_size, transport_.last_sent_packet().size());
+  // Process send bucket. Packet should now be sent.
+  EXPECT_EQ(2, transport_.packets_sent());
+  EXPECT_EQ(packet_size, transport_.last_sent_packet().size());
 
-    webrtc::RTPHeader rtp_header;
-    transport_.last_sent_packet().GetHeader(&rtp_header);
+  webrtc::RTPHeader rtp_header;
+  transport_.last_sent_packet().GetHeader(&rtp_header);
 
-    // Verify transmission time offset.
-    EXPECT_EQ(kStoredTimeInMs * 90,
-              rtp_header.extension.transmissionTimeOffset);
-    uint64_t expected_send_time =
-        ConvertMsToAbsSendTime(fake_clock_.TimeInMilliseconds());
-    EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime);
+  // Verify transmission time offset.
+  EXPECT_EQ(kStoredTimeInMs * 90, rtp_header.extension.transmissionTimeOffset);
+  uint64_t expected_send_time =
+      ConvertMsToAbsSendTime(fake_clock_.TimeInMilliseconds());
+  EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime);
 }
 
 // This test sends 1 regular video packet, then 4 padding packets, and then
@@ -1000,16 +963,15 @@ TEST_P(RtpSenderTest, SendPadding) {
 
   uint16_t seq_num = kSeqNum;
   uint32_t timestamp = kTimestamp;
-  rtp_sender_context_->packet_history_.SetStorePacketsStatus(
-      RtpPacketHistory::StorageMode::kStoreAndCull, 10);
+  rtp_sender_->SetStorePacketsStatus(true, 10);
   size_t rtp_header_len = kRtpHeaderSize;
-  EXPECT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension(
+  EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionTransmissionTimeOffset,
                    kTransmissionTimeOffsetExtensionId));
   rtp_header_len += 4;  // 4 bytes extension.
-  EXPECT_EQ(0,
-            rtp_sender()->RegisterRtpHeaderExtension(
-                kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId));
+  EXPECT_EQ(
+      0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
+                                                 kAbsoluteSendTimeExtensionId));
   rtp_header_len += 4;  // 4 bytes extension.
   rtp_header_len += 4;  // 4 extra bytes common to all extension headers.
 
@@ -1032,10 +994,10 @@ TEST_P(RtpSenderTest, SendPadding) {
   packet->set_packet_type(RtpPacketToSend::Type::kVideo);
   packet->set_allow_retransmission(true);
   EXPECT_TRUE(
-      rtp_sender()->SendToNetwork(std::make_unique<RtpPacketToSend>(*packet)));
+      rtp_sender_->SendToNetwork(std::make_unique<RtpPacketToSend>(*packet)));
   EXPECT_EQ(total_packets_sent, transport_.packets_sent());
   fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs);
-  rtp_egress()->SendPacket(packet.get(), PacedPacketInfo());
+  rtp_sender_->TrySendPacket(packet.get(), PacedPacketInfo());
   ++seq_num;
 
   // Packet should now be sent. This test doesn't verify the regular video
@@ -1085,31 +1047,30 @@ TEST_P(RtpSenderTest, SendPadding) {
         EnqueuePackets(Contains(AllOf(
             Pointee(Property(&RtpPacketToSend::Ssrc, kSsrc)),
             Pointee(Property(&RtpPacketToSend::SequenceNumber, seq_num))))));
-    EXPECT_TRUE(rtp_sender()->SendToNetwork(
-        std::make_unique<RtpPacketToSend>(*packet)));
-    rtp_egress()->SendPacket(packet.get(), PacedPacketInfo());
+    EXPECT_TRUE(
+        rtp_sender_->SendToNetwork(std::make_unique<RtpPacketToSend>(*packet)));
+    rtp_sender_->TrySendPacket(packet.get(), PacedPacketInfo());
 
-    // Process send bucket.
-    EXPECT_EQ(++total_packets_sent, transport_.packets_sent());
-    EXPECT_EQ(packet_size, transport_.last_sent_packet().size());
-    transport_.last_sent_packet().GetHeader(&rtp_header);
+  // Process send bucket.
+  EXPECT_EQ(++total_packets_sent, transport_.packets_sent());
+  EXPECT_EQ(packet_size, transport_.last_sent_packet().size());
+  transport_.last_sent_packet().GetHeader(&rtp_header);
 
-    // Verify sequence number and timestamp.
-    EXPECT_EQ(seq_num, rtp_header.sequenceNumber);
-    EXPECT_EQ(timestamp, rtp_header.timestamp);
-    // Verify transmission time offset. This packet is sent without delay.
-    EXPECT_EQ(0, rtp_header.extension.transmissionTimeOffset);
-    uint64_t expected_send_time =
-        ConvertMsToAbsSendTime(fake_clock_.TimeInMilliseconds());
-    EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime);
+  // Verify sequence number and timestamp.
+  EXPECT_EQ(seq_num, rtp_header.sequenceNumber);
+  EXPECT_EQ(timestamp, rtp_header.timestamp);
+  // Verify transmission time offset. This packet is sent without delay.
+  EXPECT_EQ(0, rtp_header.extension.transmissionTimeOffset);
+  uint64_t expected_send_time =
+      ConvertMsToAbsSendTime(fake_clock_.TimeInMilliseconds());
+  EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime);
 }
 
 TEST_P(RtpSenderTest, OnSendPacketUpdated) {
-  EXPECT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension(
+  EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionTransportSequenceNumber,
                    kTransportSequenceNumberExtensionId));
-  rtp_sender_context_->packet_history_.SetStorePacketsStatus(
-      RtpPacketHistory::StorageMode::kStoreAndCull, 10);
+  rtp_sender_->SetStorePacketsStatus(true, 10);
 
   EXPECT_CALL(send_packet_observer_,
               OnSendPacket(kTransportSequenceNumber, _, _))
@@ -1123,17 +1084,16 @@ TEST_P(RtpSenderTest, OnSendPacketUpdated) {
   auto packet = SendGenericPacket();
   packet->set_packet_type(RtpPacketToSend::Type::kVideo);
   packet->SetExtension<TransportSequenceNumber>(kTransportSequenceNumber);
-  rtp_egress()->SendPacket(packet.get(), PacedPacketInfo());
+  rtp_sender_->TrySendPacket(packet.get(), PacedPacketInfo());
 
   EXPECT_EQ(1, transport_.packets_sent());
 }
 
 TEST_P(RtpSenderTest, OnSendPacketNotUpdatedForRetransmits) {
-  EXPECT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension(
+  EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionTransportSequenceNumber,
                    kTransportSequenceNumberExtensionId));
-  rtp_sender_context_->packet_history_.SetStorePacketsStatus(
-      RtpPacketHistory::StorageMode::kStoreAndCull, 10);
+  rtp_sender_->SetStorePacketsStatus(true, 10);
 
   EXPECT_CALL(send_packet_observer_, OnSendPacket(_, _, _)).Times(0);
 
@@ -1145,7 +1105,7 @@ TEST_P(RtpSenderTest, OnSendPacketNotUpdatedForRetransmits) {
   auto packet = SendGenericPacket();
   packet->set_packet_type(RtpPacketToSend::Type::kRetransmission);
   packet->SetExtension<TransportSequenceNumber>(kTransportSequenceNumber);
-  rtp_egress()->SendPacket(packet.get(), PacedPacketInfo());
+  rtp_sender_->TrySendPacket(packet.get(), PacedPacketInfo());
 
   EXPECT_EQ(1, transport_.packets_sent());
   EXPECT_TRUE(transport_.last_options_.is_retransmit);
@@ -1158,7 +1118,7 @@ TEST_P(RtpSenderTestWithoutPacer, SendGenericVideo) {
   FieldTrialBasedConfig field_trials;
   RTPSenderVideo::Config video_config;
   video_config.clock = &fake_clock_;
-  video_config.rtp_sender = rtp_sender();
+  video_config.rtp_sender = rtp_sender_.get();
   video_config.playout_delay_oracle = &playout_delay_oracle;
   video_config.field_trials = &field_trials;
   RTPSenderVideo rtp_sender_video(video_config);
@@ -1202,7 +1162,7 @@ TEST_P(RtpSenderTestWithoutPacer, SendRawVideo) {
   FieldTrialBasedConfig field_trials;
   RTPSenderVideo::Config video_config;
   video_config.clock = &fake_clock_;
-  video_config.rtp_sender = rtp_sender();
+  video_config.rtp_sender = rtp_sender_.get();
   video_config.playout_delay_oracle = &playout_delay_oracle;
   video_config.field_trials = &field_trials;
   RTPSenderVideo rtp_sender_video(video_config);
@@ -1239,17 +1199,16 @@ TEST_P(RtpSenderTest, SendFlexfecPackets) {
   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);
+  rtp_sender_ = std::make_unique<RTPSender>(config);
 
-  rtp_sender()->SetSequenceNumber(kSeqNum);
-  rtp_sender_context_->packet_history_.SetStorePacketsStatus(
-      RtpPacketHistory::StorageMode::kStoreAndCull, 10);
+  rtp_sender_->SetSequenceNumber(kSeqNum);
+  rtp_sender_->SetStorePacketsStatus(true, 10);
 
   PlayoutDelayOracle playout_delay_oracle;
   FieldTrialBasedConfig field_trials;
   RTPSenderVideo::Config video_config;
   video_config.clock = &fake_clock_;
-  video_config.rtp_sender = rtp_sender();
+  video_config.rtp_sender = rtp_sender_.get();
   video_config.flexfec_sender = &flexfec_sender;
   video_config.playout_delay_oracle = &playout_delay_oracle;
   video_config.field_trials = &field_trials;
@@ -1293,18 +1252,18 @@ TEST_P(RtpSenderTest, SendFlexfecPackets) {
     ASSERT_TRUE(fec_packet != nullptr);
 
     flexfec_seq_num = fec_packet->SequenceNumber();
-    rtp_egress()->SendPacket(media_packet.get(), PacedPacketInfo());
-    rtp_egress()->SendPacket(fec_packet.get(), PacedPacketInfo());
+    rtp_sender_->TrySendPacket(media_packet.get(), PacedPacketInfo());
+    rtp_sender_->TrySendPacket(fec_packet.get(), PacedPacketInfo());
 
-    ASSERT_EQ(2, transport_.packets_sent());
-    const RtpPacketReceived& sent_media_packet = transport_.sent_packets_[0];
-    EXPECT_EQ(kMediaPayloadType, sent_media_packet.PayloadType());
-    EXPECT_EQ(kSeqNum, sent_media_packet.SequenceNumber());
-    EXPECT_EQ(kSsrc, sent_media_packet.Ssrc());
-    const RtpPacketReceived& sent_flexfec_packet = transport_.sent_packets_[1];
-    EXPECT_EQ(kFlexfecPayloadType, sent_flexfec_packet.PayloadType());
-    EXPECT_EQ(flexfec_seq_num, sent_flexfec_packet.SequenceNumber());
-    EXPECT_EQ(kFlexFecSsrc, sent_flexfec_packet.Ssrc());
+  ASSERT_EQ(2, transport_.packets_sent());
+  const RtpPacketReceived& sent_media_packet = transport_.sent_packets_[0];
+  EXPECT_EQ(kMediaPayloadType, sent_media_packet.PayloadType());
+  EXPECT_EQ(kSeqNum, sent_media_packet.SequenceNumber());
+  EXPECT_EQ(kSsrc, sent_media_packet.Ssrc());
+  const RtpPacketReceived& sent_flexfec_packet = transport_.sent_packets_[1];
+  EXPECT_EQ(kFlexfecPayloadType, sent_flexfec_packet.PayloadType());
+  EXPECT_EQ(flexfec_seq_num, sent_flexfec_packet.SequenceNumber());
+  EXPECT_EQ(kFlexFecSsrc, sent_flexfec_packet.Ssrc());
 }
 
 // TODO(ilnik): because of webrtc:7859. Once FEC moved below pacer, this test
@@ -1332,23 +1291,22 @@ TEST_P(RtpSenderTest, NoFlexfecForTimingFrames) {
   config.send_packet_observer = &send_packet_observer_;
   config.retransmission_rate_limiter = &retransmission_rate_limiter_;
   config.local_media_ssrc = kSsrc;
-  rtp_sender_context_ = std::make_unique<RtpSenderContext>(config);
-  rtp_sender()->SetSequenceNumber(kSeqNum);
-  rtp_sender_context_->packet_history_.SetStorePacketsStatus(
-      RtpPacketHistory::StorageMode::kStoreAndCull, 10);
+  rtp_sender_ = std::make_unique<RTPSender>(config);
+  rtp_sender_->SetSequenceNumber(kSeqNum);
+  rtp_sender_->SetStorePacketsStatus(true, 10);
 
   PlayoutDelayOracle playout_delay_oracle;
   FieldTrialBasedConfig field_trials;
   RTPSenderVideo::Config video_config;
   video_config.clock = &fake_clock_;
-  video_config.rtp_sender = rtp_sender();
+  video_config.rtp_sender = rtp_sender_.get();
   video_config.flexfec_sender = &flexfec_sender;
   video_config.playout_delay_oracle = &playout_delay_oracle;
   video_config.field_trials = &field_trials;
   RTPSenderVideo rtp_sender_video(video_config);
 
   // Need extension to be registered for timing frames to be sent.
-  ASSERT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension(
+  ASSERT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionVideoTiming, kVideoTimingExtensionId));
 
   // Parameters selected to generate a single FEC packet per media packet.
@@ -1386,62 +1344,63 @@ TEST_P(RtpSenderTest, NoFlexfecForTimingFrames) {
         kMediaPayloadType, kCodecType, kTimestamp, kCaptureTimeMs, kPayloadData,
         nullptr, video_header, kDefaultExpectedRetransmissionTimeMs));
 
-    rtp_egress()->SendPacket(rtp_packet.get(), PacedPacketInfo());
+    EXPECT_TRUE(
+        rtp_sender_->TrySendPacket(rtp_packet.get(), PacedPacketInfo()));
 
-    ASSERT_EQ(1, transport_.packets_sent());
-    const RtpPacketReceived& sent_media_packet1 = transport_.sent_packets_[0];
-    EXPECT_EQ(kMediaPayloadType, sent_media_packet1.PayloadType());
-    EXPECT_EQ(kSeqNum, sent_media_packet1.SequenceNumber());
-    EXPECT_EQ(kSsrc, sent_media_packet1.Ssrc());
+  ASSERT_EQ(1, transport_.packets_sent());
+  const RtpPacketReceived& sent_media_packet1 = transport_.sent_packets_[0];
+  EXPECT_EQ(kMediaPayloadType, sent_media_packet1.PayloadType());
+  EXPECT_EQ(kSeqNum, sent_media_packet1.SequenceNumber());
+  EXPECT_EQ(kSsrc, sent_media_packet1.Ssrc());
 
-    // Now try to send not a timing frame.
-    uint16_t flexfec_seq_num;
+  // Now try to send not a timing frame.
+  uint16_t flexfec_seq_num;
 
-    EXPECT_CALL(mock_rtc_event_log_,
-                LogProxy(SameRtcEventTypeAs(RtcEvent::Type::RtpPacketOutgoing)))
-        .Times(2);
-    std::unique_ptr<RtpPacketToSend> media_packet2;
-    std::unique_ptr<RtpPacketToSend> fec_packet;
+  EXPECT_CALL(mock_rtc_event_log_,
+              LogProxy(SameRtcEventTypeAs(RtcEvent::Type::RtpPacketOutgoing)))
+      .Times(2);
+  std::unique_ptr<RtpPacketToSend> media_packet2;
+  std::unique_ptr<RtpPacketToSend> fec_packet;
 
-    EXPECT_CALL(mock_paced_sender_, EnqueuePackets)
-        .WillOnce([&](std::vector<std::unique_ptr<RtpPacketToSend>> packets) {
-          for (auto& packet : packets) {
-            if (packet->packet_type() == RtpPacketToSend::Type::kVideo) {
-              EXPECT_EQ(packet->Ssrc(), kSsrc);
-              EXPECT_EQ(packet->SequenceNumber(), kSeqNum + 1);
-              media_packet2 = std::move(packet);
-            } else {
-              EXPECT_EQ(packet->packet_type(),
-                        RtpPacketToSend::Type::kForwardErrorCorrection);
-              EXPECT_EQ(packet->Ssrc(), kFlexFecSsrc);
-              fec_packet = std::move(packet);
-            }
+  EXPECT_CALL(mock_paced_sender_, EnqueuePackets)
+      .WillOnce([&](std::vector<std::unique_ptr<RtpPacketToSend>> packets) {
+        for (auto& packet : packets) {
+          if (packet->packet_type() == RtpPacketToSend::Type::kVideo) {
+            EXPECT_EQ(packet->Ssrc(), kSsrc);
+            EXPECT_EQ(packet->SequenceNumber(), kSeqNum + 1);
+            media_packet2 = std::move(packet);
+          } else {
+            EXPECT_EQ(packet->packet_type(),
+                      RtpPacketToSend::Type::kForwardErrorCorrection);
+            EXPECT_EQ(packet->Ssrc(), kFlexFecSsrc);
+            fec_packet = std::move(packet);
           }
-        });
+        }
+      });
 
-    video_header.video_timing.flags = VideoSendTiming::kInvalid;
-    video_header.frame_type = VideoFrameType::kVideoFrameKey;
-    EXPECT_TRUE(rtp_sender_video.SendVideo(
-        kMediaPayloadType, kCodecType, kTimestamp + 1, kCaptureTimeMs + 1,
-        kPayloadData, nullptr, video_header,
-        kDefaultExpectedRetransmissionTimeMs));
+  video_header.video_timing.flags = VideoSendTiming::kInvalid;
+  video_header.frame_type = VideoFrameType::kVideoFrameKey;
+  EXPECT_TRUE(rtp_sender_video.SendVideo(kMediaPayloadType, kCodecType,
+                                         kTimestamp + 1, kCaptureTimeMs + 1,
+                                         kPayloadData, nullptr, video_header,
+                                         kDefaultExpectedRetransmissionTimeMs));
 
-    ASSERT_TRUE(media_packet2 != nullptr);
-    ASSERT_TRUE(fec_packet != nullptr);
+  ASSERT_TRUE(media_packet2 != nullptr);
+  ASSERT_TRUE(fec_packet != nullptr);
 
-    flexfec_seq_num = fec_packet->SequenceNumber();
-    rtp_egress()->SendPacket(media_packet2.get(), PacedPacketInfo());
-    rtp_egress()->SendPacket(fec_packet.get(), PacedPacketInfo());
+  flexfec_seq_num = fec_packet->SequenceNumber();
+  rtp_sender_->TrySendPacket(media_packet2.get(), PacedPacketInfo());
+  rtp_sender_->TrySendPacket(fec_packet.get(), PacedPacketInfo());
 
-    ASSERT_EQ(3, transport_.packets_sent());
-    const RtpPacketReceived& sent_media_packet2 = transport_.sent_packets_[1];
-    EXPECT_EQ(kMediaPayloadType, sent_media_packet2.PayloadType());
-    EXPECT_EQ(kSeqNum + 1, sent_media_packet2.SequenceNumber());
-    EXPECT_EQ(kSsrc, sent_media_packet2.Ssrc());
-    const RtpPacketReceived& flexfec_packet = transport_.sent_packets_[2];
-    EXPECT_EQ(kFlexfecPayloadType, flexfec_packet.PayloadType());
-    EXPECT_EQ(flexfec_seq_num, flexfec_packet.SequenceNumber());
-    EXPECT_EQ(kFlexFecSsrc, flexfec_packet.Ssrc());
+  ASSERT_EQ(3, transport_.packets_sent());
+  const RtpPacketReceived& sent_media_packet2 = transport_.sent_packets_[1];
+  EXPECT_EQ(kMediaPayloadType, sent_media_packet2.PayloadType());
+  EXPECT_EQ(kSeqNum + 1, sent_media_packet2.SequenceNumber());
+  EXPECT_EQ(kSsrc, sent_media_packet2.Ssrc());
+  const RtpPacketReceived& flexfec_packet = transport_.sent_packets_[2];
+  EXPECT_EQ(kFlexfecPayloadType, flexfec_packet.PayloadType());
+  EXPECT_EQ(flexfec_seq_num, flexfec_packet.SequenceNumber());
+  EXPECT_EQ(kFlexFecSsrc, flexfec_packet.Ssrc());
 }
 
 TEST_P(RtpSenderTestWithoutPacer, SendFlexfecPackets) {
@@ -1464,15 +1423,15 @@ TEST_P(RtpSenderTestWithoutPacer, SendFlexfecPackets) {
   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);
+  rtp_sender_ = std::make_unique<RTPSender>(config);
 
-  rtp_sender()->SetSequenceNumber(kSeqNum);
+  rtp_sender_->SetSequenceNumber(kSeqNum);
 
   PlayoutDelayOracle playout_delay_oracle;
   FieldTrialBasedConfig field_trials;
   RTPSenderVideo::Config video_config;
   video_config.clock = &fake_clock_;
-  video_config.rtp_sender = rtp_sender();
+  video_config.rtp_sender = rtp_sender_.get();
   video_config.flexfec_sender = &flexfec_sender;
   video_config.playout_delay_oracle = &playout_delay_oracle;
   video_config.field_trials = &field_trials;
@@ -1554,7 +1513,7 @@ TEST_P(RtpSenderTestWithoutPacer, RidIncludedOnRtxSentPackets) {
   EXPECT_FALSE(packet.HasExtension<RepairedRtpStreamId>());
 
   uint16_t packet_id = packet.SequenceNumber();
-  rtp_sender()->ReSendPacket(packet_id);
+  rtp_sender_->ReSendPacket(packet_id);
   ASSERT_EQ(2u, transport_.sent_packets_.size());
   const RtpPacketReceived& rtx_packet = transport_.sent_packets_[1];
   ASSERT_TRUE(rtx_packet.GetExtension<RepairedRtpStreamId>(&rid));
@@ -1572,7 +1531,7 @@ TEST_P(RtpSenderTestWithoutPacer, MidAndRidNotIncludedOnSentPacketsAfterAck) {
   // This first packet should include both MID and RID.
   auto first_built_packet = SendGenericPacket();
 
-  rtp_sender()->OnReceivedAckOnSsrc(first_built_packet->SequenceNumber());
+  rtp_sender_->OnReceivedAckOnSsrc(first_built_packet->SequenceNumber());
 
   // The second packet should include neither since an ack was received.
   SendGenericPacket();
@@ -1605,14 +1564,14 @@ TEST_P(RtpSenderTestWithoutPacer, MidAndRidIncludedOnFirstRtxPacket) {
 
   // This first packet will include both MID and RID.
   auto first_built_packet = SendGenericPacket();
-  rtp_sender()->OnReceivedAckOnSsrc(first_built_packet->SequenceNumber());
+  rtp_sender_->OnReceivedAckOnSsrc(first_built_packet->SequenceNumber());
 
   // The second packet will include neither since an ack was received.
   auto second_built_packet = SendGenericPacket();
 
   // The first RTX packet should include MID and RRID.
   ASSERT_LT(0,
-            rtp_sender()->ReSendPacket(second_built_packet->SequenceNumber()));
+            rtp_sender_->ReSendPacket(second_built_packet->SequenceNumber()));
 
   ASSERT_EQ(3u, transport_.sent_packets_.size());
 
@@ -1637,25 +1596,24 @@ TEST_P(RtpSenderTestWithoutPacer, MidAndRidNotIncludedOnRtxPacketsAfterAck) {
 
   // This first packet will include both MID and RID.
   auto first_built_packet = SendGenericPacket();
-  rtp_sender()->OnReceivedAckOnSsrc(first_built_packet->SequenceNumber());
+  rtp_sender_->OnReceivedAckOnSsrc(first_built_packet->SequenceNumber());
 
   // The second packet will include neither since an ack was received.
   auto second_built_packet = SendGenericPacket();
 
   // The first RTX packet will include MID and RRID.
   ASSERT_LT(0,
-            rtp_sender()->ReSendPacket(second_built_packet->SequenceNumber()));
+            rtp_sender_->ReSendPacket(second_built_packet->SequenceNumber()));
 
   ASSERT_EQ(3u, transport_.sent_packets_.size());
   const RtpPacketReceived& first_rtx_packet = transport_.sent_packets_[2];
 
-  rtp_sender()->OnReceivedAckOnRtxSsrc(first_rtx_packet.SequenceNumber());
+  rtp_sender_->OnReceivedAckOnRtxSsrc(first_rtx_packet.SequenceNumber());
 
   // The second and third RTX packets should not include MID nor RRID.
+  ASSERT_LT(0, rtp_sender_->ReSendPacket(first_built_packet->SequenceNumber()));
   ASSERT_LT(0,
-            rtp_sender()->ReSendPacket(first_built_packet->SequenceNumber()));
-  ASSERT_LT(0,
-            rtp_sender()->ReSendPacket(second_built_packet->SequenceNumber()));
+            rtp_sender_->ReSendPacket(second_built_packet->SequenceNumber()));
 
   ASSERT_EQ(5u, transport_.sent_packets_.size());
 
@@ -1678,10 +1636,10 @@ TEST_P(RtpSenderTestWithoutPacer,
   EnableMidSending(kMid);
   EnableRidSending(kRid);
 
-  RtpState state = rtp_sender()->GetRtpState();
+  RtpState state = rtp_sender_->GetRtpState();
   EXPECT_FALSE(state.ssrc_has_acked);
   state.ssrc_has_acked = true;
-  rtp_sender()->SetRtpState(state);
+  rtp_sender_->SetRtpState(state);
 
   SendGenericPacket();
 
@@ -1703,13 +1661,13 @@ TEST_P(RtpSenderTestWithoutPacer,
   EnableMidSending(kMid);
   EnableRidSending(kRid);
 
-  RtpState rtx_state = rtp_sender()->GetRtxRtpState();
+  RtpState rtx_state = rtp_sender_->GetRtxRtpState();
   EXPECT_FALSE(rtx_state.ssrc_has_acked);
   rtx_state.ssrc_has_acked = true;
-  rtp_sender()->SetRtxRtpState(rtx_state);
+  rtp_sender_->SetRtxRtpState(rtx_state);
 
   auto built_packet = SendGenericPacket();
-  ASSERT_LT(0, rtp_sender()->ReSendPacket(built_packet->SequenceNumber()));
+  ASSERT_LT(0, rtp_sender_->ReSendPacket(built_packet->SequenceNumber()));
 
   ASSERT_EQ(2u, transport_.sent_packets_.size());
   const RtpPacketReceived& rtx_packet = transport_.sent_packets_[1];
@@ -1738,15 +1696,15 @@ TEST_P(RtpSenderTest, FecOverheadRate) {
   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);
+  rtp_sender_ = std::make_unique<RTPSender>(config);
 
-  rtp_sender()->SetSequenceNumber(kSeqNum);
+  rtp_sender_->SetSequenceNumber(kSeqNum);
 
   PlayoutDelayOracle playout_delay_oracle;
   FieldTrialBasedConfig field_trials;
   RTPSenderVideo::Config video_config;
   video_config.clock = &fake_clock_;
-  video_config.rtp_sender = rtp_sender();
+  video_config.rtp_sender = rtp_sender_.get();
   video_config.flexfec_sender = &flexfec_sender;
   video_config.playout_delay_oracle = &playout_delay_oracle;
   video_config.field_trials = &field_trials;
@@ -1816,13 +1774,13 @@ TEST_P(RtpSenderTest, BitrateCallbacks) {
   config.local_media_ssrc = kSsrc;
   config.send_bitrate_observer = &callback;
   config.retransmission_rate_limiter = &retransmission_rate_limiter_;
-  rtp_sender_context_ = std::make_unique<RtpSenderContext>(config);
+  rtp_sender_ = std::make_unique<RTPSender>(config);
 
   PlayoutDelayOracle playout_delay_oracle;
   FieldTrialBasedConfig field_trials;
   RTPSenderVideo::Config video_config;
   video_config.clock = &fake_clock_;
-  video_config.rtp_sender = rtp_sender();
+  video_config.rtp_sender = rtp_sender_.get();
   video_config.playout_delay_oracle = &playout_delay_oracle;
   video_config.field_trials = &field_trials;
   RTPSenderVideo rtp_sender_video(video_config);
@@ -1840,12 +1798,11 @@ TEST_P(RtpSenderTest, BitrateCallbacks) {
   const uint32_t kPacketOverhead = 13;
 
   uint8_t payload[] = {47, 11, 32, 93, 89};
-  rtp_sender_context_->packet_history_.SetStorePacketsStatus(
-      RtpPacketHistory::StorageMode::kStoreAndCull, 1);
-  uint32_t ssrc = rtp_sender()->SSRC();
+  rtp_sender_->SetStorePacketsStatus(true, 1);
+  uint32_t ssrc = rtp_sender_->SSRC();
 
   // Initial process call so we get a new time window.
-  rtp_egress()->ProcessBitrateAndNotifyObservers();
+  rtp_sender_->ProcessBitrate();
 
   // Send a few frames.
   RTPVideoHeader video_header;
@@ -1857,7 +1814,7 @@ TEST_P(RtpSenderTest, BitrateCallbacks) {
     fake_clock_.AdvanceTimeMilliseconds(kPacketInterval);
   }
 
-  rtp_egress()->ProcessBitrateAndNotifyObservers();
+  rtp_sender_->ProcessBitrate();
 
   // We get one call for every stats updated, thus two calls since both the
   // stream stats and the retransmit stats are updated once.
@@ -1871,6 +1828,8 @@ TEST_P(RtpSenderTest, BitrateCallbacks) {
       (kExpectedBitsAccumulated * 1000 + (kExpectedWindowMs / 2)) /
       kExpectedWindowMs;
   EXPECT_EQ(kExpectedRateBps, callback.total_bitrate_);
+
+  rtp_sender_.reset();
 }
 
 TEST_P(RtpSenderTestWithoutPacer, StreamDataCountersCallbacks) {
@@ -1880,14 +1839,13 @@ TEST_P(RtpSenderTestWithoutPacer, StreamDataCountersCallbacks) {
   FieldTrialBasedConfig field_trials;
   RTPSenderVideo::Config video_config;
   video_config.clock = &fake_clock_;
-  video_config.rtp_sender = rtp_sender();
+  video_config.rtp_sender = rtp_sender_.get();
   video_config.playout_delay_oracle = &playout_delay_oracle;
   video_config.field_trials = &field_trials;
   RTPSenderVideo rtp_sender_video(video_config);
   uint8_t payload[] = {47, 11, 32, 93, 89};
-  rtp_sender_context_->packet_history_.SetStorePacketsStatus(
-      RtpPacketHistory::StorageMode::kStoreAndCull, 1);
-  uint32_t ssrc = rtp_sender()->SSRC();
+  rtp_sender_->SetStorePacketsStatus(true, 1);
+  uint32_t ssrc = rtp_sender_->SSRC();
 
   // Send a frame.
   RTPVideoHeader video_header;
@@ -1908,8 +1866,8 @@ TEST_P(RtpSenderTestWithoutPacer, StreamDataCountersCallbacks) {
   rtp_stats_callback_.Matches(ssrc, expected);
 
   // Retransmit a frame.
-  uint16_t seqno = rtp_sender()->SequenceNumber() - 1;
-  rtp_sender()->ReSendPacket(seqno);
+  uint16_t seqno = rtp_sender_->SequenceNumber() - 1;
+  rtp_sender_->ReSendPacket(seqno);
   expected.transmitted.payload_bytes = 12;
   expected.transmitted.header_bytes = 24;
   expected.transmitted.packets = 2;
@@ -1937,16 +1895,15 @@ TEST_P(RtpSenderTestWithoutPacer, StreamDataCountersCallbacksUlpfec) {
   FieldTrialBasedConfig field_trials;
   RTPSenderVideo::Config video_config;
   video_config.clock = &fake_clock_;
-  video_config.rtp_sender = rtp_sender();
+  video_config.rtp_sender = rtp_sender_.get();
   video_config.playout_delay_oracle = &playout_delay_oracle;
   video_config.field_trials = &field_trials;
   video_config.red_payload_type = kRedPayloadType;
   video_config.ulpfec_payload_type = kUlpfecPayloadType;
   RTPSenderVideo rtp_sender_video(video_config);
   uint8_t payload[] = {47, 11, 32, 93, 89};
-  rtp_sender_context_->packet_history_.SetStorePacketsStatus(
-      RtpPacketHistory::StorageMode::kStoreAndCull, 1);
-  uint32_t ssrc = rtp_sender()->SSRC();
+  rtp_sender_->SetStorePacketsStatus(true, 1);
+  uint32_t ssrc = rtp_sender_->SSRC();
 
   RTPVideoHeader video_header;
   StreamDataCounters expected;
@@ -1971,8 +1928,8 @@ TEST_P(RtpSenderTestWithoutPacer, StreamDataCountersCallbacksUlpfec) {
 TEST_P(RtpSenderTestWithoutPacer, BytesReportedCorrectly) {
   // XXX const char* kPayloadName = "GENERIC";
   const uint8_t kPayloadType = 127;
-  rtp_sender()->SetRtxPayloadType(kPayloadType - 1, kPayloadType);
-  rtp_sender()->SetRtxStatus(kRtxRetransmitted | kRtxRedundantPayloads);
+  rtp_sender_->SetRtxPayloadType(kPayloadType - 1, kPayloadType);
+  rtp_sender_->SetRtxStatus(kRtxRetransmitted | kRtxRedundantPayloads);
 
   SendGenericPacket();
   // Will send 2 full-size padding packets.
@@ -1981,7 +1938,7 @@ TEST_P(RtpSenderTestWithoutPacer, BytesReportedCorrectly) {
 
   StreamDataCounters rtp_stats;
   StreamDataCounters rtx_stats;
-  rtp_egress()->GetDataCounters(&rtp_stats, &rtx_stats);
+  rtp_sender_->GetDataCounters(&rtp_stats, &rtx_stats);
 
   // Payload
   EXPECT_GT(rtp_stats.first_packet_time_ms, -1);
@@ -2012,9 +1969,8 @@ TEST_P(RtpSenderTestWithoutPacer, RespectsNackBitrateLimit) {
 
   retransmission_rate_limiter_.SetMaxRate(kPacketSize * kNumPackets * 8);
 
-  rtp_sender_context_->packet_history_.SetStorePacketsStatus(
-      RtpPacketHistory::StorageMode::kStoreAndCull, kNumPackets);
-  const uint16_t kStartSequenceNumber = rtp_sender()->SequenceNumber();
+  rtp_sender_->SetStorePacketsStatus(true, kNumPackets);
+  const uint16_t kStartSequenceNumber = rtp_sender_->SequenceNumber();
   std::vector<uint16_t> sequence_numbers;
   for (int32_t i = 0; i < kNumPackets; ++i) {
     sequence_numbers.push_back(kStartSequenceNumber + i);
@@ -2028,14 +1984,14 @@ TEST_P(RtpSenderTestWithoutPacer, RespectsNackBitrateLimit) {
   // Resending should work - brings the bandwidth up to the limit.
   // NACK bitrate is capped to the same bitrate as the encoder, since the max
   // protection overhead is 50% (see MediaOptimization::SetTargetRates).
-  rtp_sender()->OnReceivedNack(sequence_numbers, 0);
+  rtp_sender_->OnReceivedNack(sequence_numbers, 0);
   EXPECT_EQ(kNumPackets * 2, transport_.packets_sent());
 
   // Must be at least 5ms in between retransmission attempts.
   fake_clock_.AdvanceTimeMilliseconds(5);
 
   // Resending should not work, bandwidth exceeded.
-  rtp_sender()->OnReceivedNack(sequence_numbers, 0);
+  rtp_sender_->OnReceivedNack(sequence_numbers, 0);
   EXPECT_EQ(kNumPackets * 2, transport_.packets_sent());
 }
 
@@ -2047,14 +2003,14 @@ TEST_P(RtpSenderTest, OnOverheadChanged) {
   config.local_media_ssrc = kSsrc;
   config.retransmission_rate_limiter = &retransmission_rate_limiter_;
   config.overhead_observer = &mock_overhead_observer;
-  rtp_sender_context_ = std::make_unique<RtpSenderContext>(config);
+  rtp_sender_ = std::make_unique<RTPSender>(config);
 
   // RTP overhead is 12B.
   EXPECT_CALL(mock_overhead_observer, OnOverheadChanged(12)).Times(1);
   SendGenericPacket();
 
-  rtp_sender()->RegisterRtpHeaderExtension(kRtpExtensionTransmissionTimeOffset,
-                                           kTransmissionTimeOffsetExtensionId);
+  rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionTransmissionTimeOffset,
+                                          kTransmissionTimeOffsetExtensionId);
 
   // TransmissionTimeOffset extension has a size of 8B.
   // 12B + 8B = 20B
@@ -2070,14 +2026,14 @@ TEST_P(RtpSenderTest, DoesNotUpdateOverheadOnEqualSize) {
   config.local_media_ssrc = kSsrc;
   config.retransmission_rate_limiter = &retransmission_rate_limiter_;
   config.overhead_observer = &mock_overhead_observer;
-  rtp_sender_context_ = std::make_unique<RtpSenderContext>(config);
+  rtp_sender_ = std::make_unique<RTPSender>(config);
 
   EXPECT_CALL(mock_overhead_observer, OnOverheadChanged(_)).Times(1);
   SendGenericPacket();
   SendGenericPacket();
 }
 
-TEST_P(RtpSenderTest, SendPacketMatchesVideo) {
+TEST_P(RtpSenderTest, TrySendPacketMatchesVideo) {
   std::unique_ptr<RtpPacketToSend> packet =
       BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds());
   packet->set_packet_type(RtpPacketToSend::Type::kVideo);
@@ -2086,11 +2042,11 @@ TEST_P(RtpSenderTest, SendPacketMatchesVideo) {
   packet = BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds());
   packet->SetSsrc(kSsrc);
   packet->set_packet_type(RtpPacketToSend::Type::kVideo);
-  rtp_egress()->SendPacket(packet.get(), PacedPacketInfo());
+  rtp_sender_->TrySendPacket(packet.get(), PacedPacketInfo());
   EXPECT_EQ(transport_.packets_sent(), 1);
 }
 
-TEST_P(RtpSenderTest, SendPacketMatchesAudio) {
+TEST_P(RtpSenderTest, TrySendPacketMatchesAudio) {
   std::unique_ptr<RtpPacketToSend> packet =
       BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds());
   packet->set_packet_type(RtpPacketToSend::Type::kAudio);
@@ -2099,11 +2055,11 @@ TEST_P(RtpSenderTest, SendPacketMatchesAudio) {
   packet = BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds());
   packet->SetSsrc(kSsrc);
   packet->set_packet_type(RtpPacketToSend::Type::kAudio);
-  rtp_egress()->SendPacket(packet.get(), PacedPacketInfo());
+  rtp_sender_->TrySendPacket(packet.get(), PacedPacketInfo());
   EXPECT_EQ(transport_.packets_sent(), 1);
 }
 
-TEST_P(RtpSenderTest, SendPacketMatchesRetransmissions) {
+TEST_P(RtpSenderTest, TrySendPacketMatchesRetransmissions) {
   std::unique_ptr<RtpPacketToSend> packet =
       BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds());
   packet->set_packet_type(RtpPacketToSend::Type::kRetransmission);
@@ -2112,18 +2068,18 @@ TEST_P(RtpSenderTest, SendPacketMatchesRetransmissions) {
   packet = BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds());
   packet->SetSsrc(kSsrc);
   packet->set_packet_type(RtpPacketToSend::Type::kRetransmission);
-  rtp_egress()->SendPacket(packet.get(), PacedPacketInfo());
+  rtp_sender_->TrySendPacket(packet.get(), PacedPacketInfo());
   EXPECT_EQ(transport_.packets_sent(), 1);
 
   // RTX retransmission.
   packet = BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds());
   packet->SetSsrc(kRtxSsrc);
   packet->set_packet_type(RtpPacketToSend::Type::kRetransmission);
-  rtp_egress()->SendPacket(packet.get(), PacedPacketInfo());
+  rtp_sender_->TrySendPacket(packet.get(), PacedPacketInfo());
   EXPECT_EQ(transport_.packets_sent(), 2);
 }
 
-TEST_P(RtpSenderTest, SendPacketMatchesPadding) {
+TEST_P(RtpSenderTest, TrySendPacketMatchesPadding) {
   std::unique_ptr<RtpPacketToSend> packet =
       BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds());
   packet->set_packet_type(RtpPacketToSend::Type::kPadding);
@@ -2132,18 +2088,18 @@ TEST_P(RtpSenderTest, SendPacketMatchesPadding) {
   packet = BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds());
   packet->SetSsrc(kSsrc);
   packet->set_packet_type(RtpPacketToSend::Type::kPadding);
-  rtp_egress()->SendPacket(packet.get(), PacedPacketInfo());
+  rtp_sender_->TrySendPacket(packet.get(), PacedPacketInfo());
   EXPECT_EQ(transport_.packets_sent(), 1);
 
   // RTX padding.
   packet = BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds());
   packet->SetSsrc(kRtxSsrc);
   packet->set_packet_type(RtpPacketToSend::Type::kPadding);
-  rtp_egress()->SendPacket(packet.get(), PacedPacketInfo());
+  rtp_sender_->TrySendPacket(packet.get(), PacedPacketInfo());
   EXPECT_EQ(transport_.packets_sent(), 2);
 }
 
-TEST_P(RtpSenderTest, SendPacketMatchesFlexfec) {
+TEST_P(RtpSenderTest, TrySendPacketMatchesFlexfec) {
   std::unique_ptr<RtpPacketToSend> packet =
       BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds());
   packet->set_packet_type(RtpPacketToSend::Type::kForwardErrorCorrection);
@@ -2152,11 +2108,11 @@ TEST_P(RtpSenderTest, SendPacketMatchesFlexfec) {
   packet = BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds());
   packet->SetSsrc(kFlexFecSsrc);
   packet->set_packet_type(RtpPacketToSend::Type::kForwardErrorCorrection);
-  rtp_egress()->SendPacket(packet.get(), PacedPacketInfo());
+  rtp_sender_->TrySendPacket(packet.get(), PacedPacketInfo());
   EXPECT_EQ(transport_.packets_sent(), 1);
 }
 
-TEST_P(RtpSenderTest, SendPacketMatchesUlpfec) {
+TEST_P(RtpSenderTest, TrySendPacketMatchesUlpfec) {
   std::unique_ptr<RtpPacketToSend> packet =
       BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds());
   packet->set_packet_type(RtpPacketToSend::Type::kForwardErrorCorrection);
@@ -2165,13 +2121,12 @@ TEST_P(RtpSenderTest, SendPacketMatchesUlpfec) {
   packet = BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds());
   packet->SetSsrc(kSsrc);
   packet->set_packet_type(RtpPacketToSend::Type::kForwardErrorCorrection);
-  rtp_egress()->SendPacket(packet.get(), PacedPacketInfo());
+  rtp_sender_->TrySendPacket(packet.get(), PacedPacketInfo());
   EXPECT_EQ(transport_.packets_sent(), 1);
 }
 
-TEST_P(RtpSenderTest, SendPacketHandlesRetransmissionHistory) {
-  rtp_sender_context_->packet_history_.SetStorePacketsStatus(
-      RtpPacketHistory::StorageMode::kStoreAndCull, 10);
+TEST_P(RtpSenderTest, TrySendPacketHandlesRetransmissionHistory) {
+  rtp_sender_->SetStorePacketsStatus(true, 10);
 
   // Build a media packet and send it.
   std::unique_ptr<RtpPacketToSend> packet =
@@ -2179,15 +2134,15 @@ TEST_P(RtpSenderTest, SendPacketHandlesRetransmissionHistory) {
   const uint16_t media_sequence_number = packet->SequenceNumber();
   packet->set_packet_type(RtpPacketToSend::Type::kVideo);
   packet->set_allow_retransmission(true);
-  rtp_egress()->SendPacket(packet.get(), PacedPacketInfo());
+  EXPECT_TRUE(rtp_sender_->TrySendPacket(packet.get(), PacedPacketInfo()));
 
   // Simulate retransmission request.
   fake_clock_.AdvanceTimeMilliseconds(30);
-  EXPECT_GT(rtp_sender()->ReSendPacket(media_sequence_number), 0);
+  EXPECT_GT(rtp_sender_->ReSendPacket(media_sequence_number), 0);
 
   // Packet already pending, retransmission not allowed.
   fake_clock_.AdvanceTimeMilliseconds(30);
-  EXPECT_EQ(rtp_sender()->ReSendPacket(media_sequence_number), 0);
+  EXPECT_EQ(rtp_sender_->ReSendPacket(media_sequence_number), 0);
 
   // Packet exiting pacer, mark as not longer pending.
   packet = BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds());
@@ -2196,26 +2151,26 @@ TEST_P(RtpSenderTest, SendPacketHandlesRetransmissionHistory) {
   packet->SetSsrc(kRtxSsrc);
   packet->set_retransmitted_sequence_number(media_sequence_number);
   packet->set_allow_retransmission(false);
-  rtp_egress()->SendPacket(packet.get(), PacedPacketInfo());
+  EXPECT_TRUE(rtp_sender_->TrySendPacket(packet.get(), PacedPacketInfo()));
 
   // Retransmissions allowed again.
   fake_clock_.AdvanceTimeMilliseconds(30);
-  EXPECT_GT(rtp_sender()->ReSendPacket(media_sequence_number), 0);
+  EXPECT_GT(rtp_sender_->ReSendPacket(media_sequence_number), 0);
 
   // Retransmission of RTX packet should not be allowed.
-  EXPECT_EQ(rtp_sender()->ReSendPacket(packet->SequenceNumber()), 0);
+  EXPECT_EQ(rtp_sender_->ReSendPacket(packet->SequenceNumber()), 0);
 }
 
-TEST_P(RtpSenderTest, SendPacketUpdatesExtensions) {
-  ASSERT_EQ(rtp_sender()->RegisterRtpHeaderExtension(
+TEST_P(RtpSenderTest, TrySendPacketUpdatesExtensions) {
+  ASSERT_EQ(rtp_sender_->RegisterRtpHeaderExtension(
                 kRtpExtensionTransmissionTimeOffset,
                 kTransmissionTimeOffsetExtensionId),
             0);
-  ASSERT_EQ(rtp_sender()->RegisterRtpHeaderExtension(
+  ASSERT_EQ(rtp_sender_->RegisterRtpHeaderExtension(
                 kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId),
             0);
-  ASSERT_EQ(rtp_sender()->RegisterRtpHeaderExtension(kRtpExtensionVideoTiming,
-                                                     kVideoTimingExtensionId),
+  ASSERT_EQ(rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionVideoTiming,
+                                                    kVideoTimingExtensionId),
             0);
 
   std::unique_ptr<RtpPacketToSend> packet =
@@ -2226,7 +2181,7 @@ TEST_P(RtpSenderTest, SendPacketUpdatesExtensions) {
   fake_clock_.AdvanceTimeMilliseconds(kDiffMs);
 
   packet->set_packet_type(RtpPacketToSend::Type::kVideo);
-  rtp_egress()->SendPacket(packet.get(), PacedPacketInfo());
+  EXPECT_TRUE(rtp_sender_->TrySendPacket(packet.get(), PacedPacketInfo()));
 
   const RtpPacketReceived& received_packet = transport_.last_sent_packet();
 
@@ -2240,9 +2195,9 @@ TEST_P(RtpSenderTest, SendPacketUpdatesExtensions) {
   EXPECT_EQ(timing.pacer_exit_delta_ms, kDiffMs);
 }
 
-TEST_P(RtpSenderTest, SendPacketSetsPacketOptions) {
+TEST_P(RtpSenderTest, TrySendPacketSetsPacketOptions) {
   const uint16_t kPacketId = 42;
-  ASSERT_EQ(rtp_sender()->RegisterRtpHeaderExtension(
+  ASSERT_EQ(rtp_sender_->RegisterRtpHeaderExtension(
                 kRtpExtensionTransportSequenceNumber,
                 kTransportSequenceNumberExtensionId),
             0);
@@ -2252,7 +2207,7 @@ TEST_P(RtpSenderTest, SendPacketSetsPacketOptions) {
 
   packet->set_packet_type(RtpPacketToSend::Type::kVideo);
   EXPECT_CALL(send_packet_observer_, OnSendPacket);
-  rtp_egress()->SendPacket(packet.get(), PacedPacketInfo());
+  EXPECT_TRUE(rtp_sender_->TrySendPacket(packet.get(), PacedPacketInfo()));
 
   EXPECT_EQ(transport_.last_options_.packet_id, kPacketId);
   EXPECT_TRUE(transport_.last_options_.included_in_allocation);
@@ -2263,11 +2218,11 @@ TEST_P(RtpSenderTest, SendPacketSetsPacketOptions) {
   packet = BuildRtpPacket(kPayload, true, 0, fake_clock_.TimeInMilliseconds());
   packet->SetExtension<TransportSequenceNumber>(kPacketId + 1);
   packet->set_packet_type(RtpPacketToSend::Type::kRetransmission);
-  rtp_egress()->SendPacket(packet.get(), PacedPacketInfo());
+  EXPECT_TRUE(rtp_sender_->TrySendPacket(packet.get(), PacedPacketInfo()));
   EXPECT_TRUE(transport_.last_options_.is_retransmit);
 }
 
-TEST_P(RtpSenderTest, SendPacketUpdatesStats) {
+TEST_P(RtpSenderTest, TrySendPacketUpdatesStats) {
   const size_t kPayloadSize = 1000;
 
   StrictMock<MockSendSideDelayObserver> send_side_delay_observer;
@@ -2281,8 +2236,8 @@ TEST_P(RtpSenderTest, SendPacketUpdatesStats) {
   config.send_side_delay_observer = &send_side_delay_observer;
   config.event_log = &mock_rtc_event_log_;
   config.send_packet_observer = &send_packet_observer_;
-  rtp_sender_context_ = std::make_unique<RtpSenderContext>(config);
-  ASSERT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension(
+  rtp_sender_ = std::make_unique<RTPSender>(config);
+  ASSERT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionTransportSequenceNumber,
                    kTransportSequenceNumberExtensionId));
 
@@ -2318,20 +2273,20 @@ TEST_P(RtpSenderTest, SendPacketUpdatesStats) {
       SendSideDelayUpdated(kDiffMs, kDiffMs, 2 * kDiffMs, kFlexFecSsrc));
 
   EXPECT_CALL(send_packet_observer_, OnSendPacket(1, capture_time_ms, kSsrc));
-
-  rtp_egress()->SendPacket(video_packet.get(), PacedPacketInfo());
+  EXPECT_TRUE(
+      rtp_sender_->TrySendPacket(video_packet.get(), PacedPacketInfo()));
 
   // Send packet observer not called for padding/retransmissions.
   EXPECT_CALL(send_packet_observer_, OnSendPacket(2, _, _)).Times(0);
-  rtp_egress()->SendPacket(rtx_packet.get(), PacedPacketInfo());
+  EXPECT_TRUE(rtp_sender_->TrySendPacket(rtx_packet.get(), PacedPacketInfo()));
 
   EXPECT_CALL(send_packet_observer_,
               OnSendPacket(3, capture_time_ms, kFlexFecSsrc));
-  rtp_egress()->SendPacket(fec_packet.get(), PacedPacketInfo());
+  EXPECT_TRUE(rtp_sender_->TrySendPacket(fec_packet.get(), PacedPacketInfo()));
 
   StreamDataCounters rtp_stats;
   StreamDataCounters rtx_stats;
-  rtp_egress()->GetDataCounters(&rtp_stats, &rtx_stats);
+  rtp_sender_->GetDataCounters(&rtp_stats, &rtx_stats);
   EXPECT_EQ(rtp_stats.transmitted.packets, 2u);
   EXPECT_EQ(rtp_stats.fec.packets, 1u);
   EXPECT_EQ(rtx_stats.retransmitted.packets, 1u);
@@ -2341,18 +2296,17 @@ TEST_P(RtpSenderTest, GeneratePaddingResendsOldPacketsWithRtx) {
   // Min requested size in order to use RTX payload.
   const size_t kMinPaddingSize = 50;
 
-  rtp_sender()->SetRtxStatus(kRtxRetransmitted | kRtxRedundantPayloads);
-  rtp_sender()->SetRtxPayloadType(kRtxPayload, kPayload);
-  rtp_sender_context_->packet_history_.SetStorePacketsStatus(
-      RtpPacketHistory::StorageMode::kStoreAndCull, 1);
+  rtp_sender_->SetRtxStatus(kRtxRetransmitted | kRtxRedundantPayloads);
+  rtp_sender_->SetRtxPayloadType(kRtxPayload, kPayload);
+  rtp_sender_->SetStorePacketsStatus(true, 1);
 
-  ASSERT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension(
+  ASSERT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionTransmissionTimeOffset,
                    kTransmissionTimeOffsetExtensionId));
-  ASSERT_EQ(0,
-            rtp_sender()->RegisterRtpHeaderExtension(
-                kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId));
-  ASSERT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension(
+  ASSERT_EQ(
+      0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
+                                                 kAbsoluteSendTimeExtensionId));
+  ASSERT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionTransportSequenceNumber,
                    kTransportSequenceNumberExtensionId));
 
@@ -2365,12 +2319,12 @@ TEST_P(RtpSenderTest, GeneratePaddingResendsOldPacketsWithRtx) {
 
   // Send a dummy video packet so it ends up in the packet history.
   EXPECT_CALL(send_packet_observer_, OnSendPacket).Times(1);
-  rtp_egress()->SendPacket(packet.get(), PacedPacketInfo());
+  EXPECT_TRUE(rtp_sender_->TrySendPacket(packet.get(), PacedPacketInfo()));
 
   // Generated padding has large enough budget that the video packet should be
   // retransmitted as padding.
   std::vector<std::unique_ptr<RtpPacketToSend>> generated_packets =
-      rtp_sender()->GeneratePadding(kMinPaddingSize, true);
+      rtp_sender_->GeneratePadding(kMinPaddingSize);
   ASSERT_EQ(generated_packets.size(), 1u);
   auto& padding_packet = generated_packets.front();
   EXPECT_EQ(padding_packet->packet_type(), RtpPacketToSend::Type::kPadding);
@@ -2382,7 +2336,8 @@ TEST_P(RtpSenderTest, GeneratePaddingResendsOldPacketsWithRtx) {
   EXPECT_TRUE(padding_packet->IsExtensionReserved<TransmissionOffset>());
 
   // Verify all header extensions are received.
-  rtp_egress()->SendPacket(padding_packet.get(), PacedPacketInfo());
+  EXPECT_TRUE(
+      rtp_sender_->TrySendPacket(padding_packet.get(), PacedPacketInfo()));
   webrtc::RTPHeader rtp_header;
   transport_.last_sent_packet().GetHeader(&rtp_header);
   EXPECT_TRUE(rtp_header.extension.hasAbsoluteSendTime);
@@ -2393,8 +2348,7 @@ TEST_P(RtpSenderTest, GeneratePaddingResendsOldPacketsWithRtx) {
   const size_t kPaddingBytesRequested = kMinPaddingSize - 1;
 
   size_t padding_bytes_generated = 0;
-  generated_packets =
-      rtp_sender()->GeneratePadding(kPaddingBytesRequested, true);
+  generated_packets = rtp_sender_->GeneratePadding(kPaddingBytesRequested);
   EXPECT_EQ(generated_packets.size(), 1u);
   for (auto& packet : generated_packets) {
     EXPECT_EQ(packet->packet_type(), RtpPacketToSend::Type::kPadding);
@@ -2408,7 +2362,7 @@ TEST_P(RtpSenderTest, GeneratePaddingResendsOldPacketsWithRtx) {
     EXPECT_TRUE(packet->IsExtensionReserved<TransmissionOffset>());
 
     // Verify all header extensions are received.
-    rtp_egress()->SendPacket(packet.get(), PacedPacketInfo());
+    EXPECT_TRUE(rtp_sender_->TrySendPacket(packet.get(), PacedPacketInfo()));
     webrtc::RTPHeader rtp_header;
     transport_.last_sent_packet().GetHeader(&rtp_header);
     EXPECT_TRUE(rtp_header.extension.hasAbsoluteSendTime);
@@ -2420,15 +2374,14 @@ TEST_P(RtpSenderTest, GeneratePaddingResendsOldPacketsWithRtx) {
 }
 
 TEST_P(RtpSenderTest, GeneratePaddingCreatesPurePaddingWithoutRtx) {
-  rtp_sender_context_->packet_history_.SetStorePacketsStatus(
-      RtpPacketHistory::StorageMode::kStoreAndCull, 1);
-  ASSERT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension(
+  rtp_sender_->SetStorePacketsStatus(true, 1);
+  ASSERT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionTransmissionTimeOffset,
                    kTransmissionTimeOffsetExtensionId));
-  ASSERT_EQ(0,
-            rtp_sender()->RegisterRtpHeaderExtension(
-                kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId));
-  ASSERT_EQ(0, rtp_sender()->RegisterRtpHeaderExtension(
+  ASSERT_EQ(
+      0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
+                                                 kAbsoluteSendTimeExtensionId));
+  ASSERT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionTransportSequenceNumber,
                    kTransportSequenceNumberExtensionId));
 
@@ -2441,7 +2394,7 @@ TEST_P(RtpSenderTest, GeneratePaddingCreatesPurePaddingWithoutRtx) {
   packet->SetPayloadSize(kPayloadPacketSize);
   packet->set_packet_type(RtpPacketToSend::Type::kVideo);
   EXPECT_CALL(send_packet_observer_, OnSendPacket).Times(1);
-  rtp_egress()->SendPacket(packet.get(), PacedPacketInfo());
+  EXPECT_TRUE(rtp_sender_->TrySendPacket(packet.get(), PacedPacketInfo()));
 
   // Payload padding not available without RTX, only generate plain padding on
   // the media SSRC.
@@ -2453,7 +2406,7 @@ TEST_P(RtpSenderTest, GeneratePaddingCreatesPurePaddingWithoutRtx) {
       (kPaddingBytesRequested + kMaxPaddingSize - 1) / kMaxPaddingSize;
   size_t padding_bytes_generated = 0;
   std::vector<std::unique_ptr<RtpPacketToSend>> padding_packets =
-      rtp_sender()->GeneratePadding(kPaddingBytesRequested, true);
+      rtp_sender_->GeneratePadding(kPaddingBytesRequested);
   EXPECT_EQ(padding_packets.size(), kExpectedNumPaddingPackets);
   for (auto& packet : padding_packets) {
     EXPECT_EQ(packet->packet_type(), RtpPacketToSend::Type::kPadding);
@@ -2466,7 +2419,7 @@ TEST_P(RtpSenderTest, GeneratePaddingCreatesPurePaddingWithoutRtx) {
     EXPECT_TRUE(packet->IsExtensionReserved<TransmissionOffset>());
 
     // Verify all header extensions are received.
-    rtp_egress()->SendPacket(packet.get(), PacedPacketInfo());
+    EXPECT_TRUE(rtp_sender_->TrySendPacket(packet.get(), PacedPacketInfo()));
     webrtc::RTPHeader rtp_header;
     transport_.last_sent_packet().GetHeader(&rtp_header);
     EXPECT_TRUE(rtp_header.extension.hasAbsoluteSendTime);
@@ -2488,43 +2441,42 @@ TEST_P(RtpSenderTest, SupportsPadding) {
   const int kExtensionsId = 7;
 
   for (bool sending_media : kSendingMediaStats) {
-    rtp_sender()->SetSendingMediaStatus(sending_media);
+    rtp_sender_->SetSendingMediaStatus(sending_media);
     for (bool redundant_payloads : kEnableRedundantPayloads) {
       int rtx_mode = kRtxRetransmitted;
       if (redundant_payloads) {
         rtx_mode |= kRtxRedundantPayloads;
       }
-      rtp_sender()->SetRtxStatus(rtx_mode);
+      rtp_sender_->SetRtxStatus(rtx_mode);
 
       for (auto extension_type : kBweExtensionTypes) {
-        EXPECT_FALSE(rtp_sender()->SupportsPadding());
-        rtp_sender()->RegisterRtpHeaderExtension(extension_type, kExtensionsId);
+        EXPECT_FALSE(rtp_sender_->SupportsPadding());
+        rtp_sender_->RegisterRtpHeaderExtension(extension_type, kExtensionsId);
         if (!sending_media) {
-          EXPECT_FALSE(rtp_sender()->SupportsPadding());
+          EXPECT_FALSE(rtp_sender_->SupportsPadding());
         } else {
-          EXPECT_TRUE(rtp_sender()->SupportsPadding());
+          EXPECT_TRUE(rtp_sender_->SupportsPadding());
           if (redundant_payloads) {
-            EXPECT_TRUE(rtp_sender()->SupportsRtxPayloadPadding());
+            EXPECT_TRUE(rtp_sender_->SupportsRtxPayloadPadding());
           } else {
-            EXPECT_FALSE(rtp_sender()->SupportsRtxPayloadPadding());
+            EXPECT_FALSE(rtp_sender_->SupportsRtxPayloadPadding());
           }
         }
-        rtp_sender()->DeregisterRtpHeaderExtension(extension_type);
-        EXPECT_FALSE(rtp_sender()->SupportsPadding());
+        rtp_sender_->DeregisterRtpHeaderExtension(extension_type);
+        EXPECT_FALSE(rtp_sender_->SupportsPadding());
       }
     }
   }
 }
 
 TEST_P(RtpSenderTest, SetsCaptureTimeAndPopulatesTransmissionOffset) {
-  rtp_sender()->RegisterRtpHeaderExtension(kRtpExtensionTransmissionTimeOffset,
-                                           kTransmissionTimeOffsetExtensionId);
+  rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionTransmissionTimeOffset,
+                                          kTransmissionTimeOffsetExtensionId);
 
-  rtp_sender()->SetSendingMediaStatus(true);
-  rtp_sender()->SetRtxStatus(kRtxRetransmitted | kRtxRedundantPayloads);
-  rtp_sender()->SetRtxPayloadType(kRtxPayload, kPayload);
-  rtp_sender_context_->packet_history_.SetStorePacketsStatus(
-      RtpPacketHistory::StorageMode::kStoreAndCull, 10);
+  rtp_sender_->SetSendingMediaStatus(true);
+  rtp_sender_->SetRtxStatus(kRtxRetransmitted | kRtxRedundantPayloads);
+  rtp_sender_->SetRtxPayloadType(kRtxPayload, kPayload);
+  rtp_sender_->SetStorePacketsStatus(true, 10);
 
   const int64_t kMissingCaptureTimeMs = 0;
   const uint32_t kTimestampTicksPerMs = 90;
@@ -2546,21 +2498,21 @@ TEST_P(RtpSenderTest, SetsCaptureTimeAndPopulatesTransmissionOffset) {
         });
 
     packet->set_allow_retransmission(true);
-    EXPECT_TRUE(rtp_sender()->SendToNetwork(std::move(packet)));
+    EXPECT_TRUE(rtp_sender_->SendToNetwork(std::move(packet)));
 
     fake_clock_.AdvanceTimeMilliseconds(kOffsetMs);
 
-    rtp_egress()->SendPacket(packet_to_pace.get(), PacedPacketInfo());
+    rtp_sender_->TrySendPacket(packet_to_pace.get(), PacedPacketInfo());
 
-    EXPECT_EQ(1, transport_.packets_sent());
-    absl::optional<int32_t> transmission_time_extension =
-        transport_.sent_packets_.back().GetExtension<TransmissionOffset>();
-    ASSERT_TRUE(transmission_time_extension.has_value());
-    EXPECT_EQ(*transmission_time_extension, kOffsetMs * kTimestampTicksPerMs);
+  EXPECT_EQ(1, transport_.packets_sent());
+  absl::optional<int32_t> transmission_time_extension =
+      transport_.sent_packets_.back().GetExtension<TransmissionOffset>();
+  ASSERT_TRUE(transmission_time_extension.has_value());
+  EXPECT_EQ(*transmission_time_extension, kOffsetMs * kTimestampTicksPerMs);
 
-    // Retransmit packet. The RTX packet should get the same capture time as the
-    // original packet, so offset is delta from original packet to now.
-    fake_clock_.AdvanceTimeMilliseconds(kOffsetMs);
+  // Retransmit packet. The RTX packet should get the same capture time as the
+  // original packet, so offset is delta from original packet to now.
+  fake_clock_.AdvanceTimeMilliseconds(kOffsetMs);
 
     std::unique_ptr<RtpPacketToSend> rtx_packet_to_pace;
     EXPECT_CALL(mock_paced_sender_, EnqueuePackets)
@@ -2569,26 +2521,24 @@ TEST_P(RtpSenderTest, SetsCaptureTimeAndPopulatesTransmissionOffset) {
           rtx_packet_to_pace = std::move(packets[0]);
         });
 
-    EXPECT_GT(rtp_sender()->ReSendPacket(kSeqNum), 0);
-    rtp_egress()->SendPacket(rtx_packet_to_pace.get(), PacedPacketInfo());
+    EXPECT_GT(rtp_sender_->ReSendPacket(kSeqNum), 0);
+    rtp_sender_->TrySendPacket(rtx_packet_to_pace.get(), PacedPacketInfo());
 
-    EXPECT_EQ(2, transport_.packets_sent());
-    transmission_time_extension =
-        transport_.sent_packets_.back().GetExtension<TransmissionOffset>();
-    ASSERT_TRUE(transmission_time_extension.has_value());
-    EXPECT_EQ(*transmission_time_extension,
-              2 * kOffsetMs * kTimestampTicksPerMs);
+  EXPECT_EQ(2, transport_.packets_sent());
+  transmission_time_extension =
+      transport_.sent_packets_.back().GetExtension<TransmissionOffset>();
+  ASSERT_TRUE(transmission_time_extension.has_value());
+  EXPECT_EQ(*transmission_time_extension, 2 * kOffsetMs * kTimestampTicksPerMs);
 }
 
 TEST_P(RtpSenderTestWithoutPacer, ClearHistoryOnSequenceNumberCange) {
   const int64_t kRtt = 10;
 
-  rtp_sender()->SetSendingMediaStatus(true);
-  rtp_sender()->SetRtxStatus(kRtxRetransmitted | kRtxRedundantPayloads);
-  rtp_sender()->SetRtxPayloadType(kRtxPayload, kPayload);
-  rtp_sender_context_->packet_history_.SetStorePacketsStatus(
-      RtpPacketHistory::StorageMode::kStoreAndCull, 10);
-  rtp_sender_context_->packet_history_.SetRtt(kRtt);
+  rtp_sender_->SetSendingMediaStatus(true);
+  rtp_sender_->SetRtxStatus(kRtxRetransmitted | kRtxRedundantPayloads);
+  rtp_sender_->SetRtxPayloadType(kRtxPayload, kPayload);
+  rtp_sender_->SetStorePacketsStatus(true, 10);
+  rtp_sender_->SetRtt(kRtt);
 
   // Send a packet and record its sequence numbers.
   SendGenericPacket();
@@ -2598,26 +2548,25 @@ TEST_P(RtpSenderTestWithoutPacer, ClearHistoryOnSequenceNumberCange) {
 
   // Advance time and make sure it can be retransmitted, even if we try to set
   // the ssrc the what it already is.
-  rtp_sender()->SetSequenceNumber(rtp_sender()->SequenceNumber());
+  rtp_sender_->SetSequenceNumber(rtp_sender_->SequenceNumber());
   fake_clock_.AdvanceTimeMilliseconds(kRtt);
-  EXPECT_GT(rtp_sender()->ReSendPacket(packet_seqence_number), 0);
+  EXPECT_GT(rtp_sender_->ReSendPacket(packet_seqence_number), 0);
 
   // Change the sequence number, then move the time and try to retransmit again.
   // The old packet should now be gone.
-  rtp_sender()->SetSequenceNumber(rtp_sender()->SequenceNumber() - 1);
+  rtp_sender_->SetSequenceNumber(rtp_sender_->SequenceNumber() - 1);
   fake_clock_.AdvanceTimeMilliseconds(kRtt);
-  EXPECT_EQ(rtp_sender()->ReSendPacket(packet_seqence_number), 0);
+  EXPECT_EQ(rtp_sender_->ReSendPacket(packet_seqence_number), 0);
 }
 
 TEST_P(RtpSenderTest, IgnoresNackAfterDisablingMedia) {
   const int64_t kRtt = 10;
 
-  rtp_sender()->SetSendingMediaStatus(true);
-  rtp_sender()->SetRtxStatus(kRtxRetransmitted | kRtxRedundantPayloads);
-  rtp_sender()->SetRtxPayloadType(kRtxPayload, kPayload);
-  rtp_sender_context_->packet_history_.SetStorePacketsStatus(
-      RtpPacketHistory::StorageMode::kStoreAndCull, 10);
-  rtp_sender_context_->packet_history_.SetRtt(kRtt);
+  rtp_sender_->SetSendingMediaStatus(true);
+  rtp_sender_->SetRtxStatus(kRtxRetransmitted | kRtxRedundantPayloads);
+  rtp_sender_->SetRtxPayloadType(kRtxPayload, kPayload);
+  rtp_sender_->SetStorePacketsStatus(true, 10);
+  rtp_sender_->SetRtt(kRtt);
 
   // Send a packet so it is in the packet history.
     std::unique_ptr<RtpPacketToSend> packet_to_pace;
@@ -2627,14 +2576,14 @@ TEST_P(RtpSenderTest, IgnoresNackAfterDisablingMedia) {
         });
 
     SendGenericPacket();
-    rtp_egress()->SendPacket(packet_to_pace.get(), PacedPacketInfo());
+    rtp_sender_->TrySendPacket(packet_to_pace.get(), PacedPacketInfo());
 
     ASSERT_EQ(1u, transport_.sent_packets_.size());
 
     // Disable media sending and try to retransmit the packet, it should fail.
-    rtp_sender()->SetSendingMediaStatus(false);
+    rtp_sender_->SetSendingMediaStatus(false);
     fake_clock_.AdvanceTimeMilliseconds(kRtt);
-    EXPECT_LT(rtp_sender()->ReSendPacket(kSeqNum), 0);
+    EXPECT_LT(rtp_sender_->ReSendPacket(kSeqNum), 0);
 }
 
 INSTANTIATE_TEST_SUITE_P(WithAndWithoutOverhead,
diff --git a/modules/rtp_rtcp/source/rtp_sender_video_unittest.cc b/modules/rtp_rtcp/source/rtp_sender_video_unittest.cc
index faf0decf98..17aafeddbb 100644
--- a/modules/rtp_rtcp/source/rtp_sender_video_unittest.cc
+++ b/modules/rtp_rtcp/source/rtp_sender_video_unittest.cc
@@ -17,13 +17,13 @@
 #include "api/video/video_timing.h"
 #include "modules/rtp_rtcp/include/rtp_cvo.h"
 #include "modules/rtp_rtcp/include/rtp_header_extension_map.h"
-#include "modules/rtp_rtcp/include/rtp_rtcp.h"
 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 #include "modules/rtp_rtcp/source/rtp_format_video_generic.h"
 #include "modules/rtp_rtcp/source/rtp_generic_frame_descriptor.h"
 #include "modules/rtp_rtcp/source/rtp_generic_frame_descriptor_extension.h"
 #include "modules/rtp_rtcp/source/rtp_header_extensions.h"
 #include "modules/rtp_rtcp/source/rtp_packet_received.h"
+#include "modules/rtp_rtcp/source/rtp_sender.h"
 #include "rtc_base/arraysize.h"
 #include "rtc_base/rate_limiter.h"
 #include "test/gmock.h"
@@ -142,7 +142,7 @@ class RtpSenderVideoTest : public ::testing::TestWithParam<bool> {
       : field_trials_(GetParam()),
         fake_clock_(kStartTime),
         retransmission_rate_limiter_(&fake_clock_, 1000),
-        rtp_module_(RtpRtcp::Create([&] {
+        rtp_sender_([&] {
           RtpRtcp::Configuration config;
           config.clock = &fake_clock_;
           config.outgoing_transport = &transport_;
@@ -150,13 +150,10 @@ class RtpSenderVideoTest : public ::testing::TestWithParam<bool> {
           config.field_trials = &field_trials_;
           config.local_media_ssrc = kSsrc;
           return config;
-        }())),
-        rtp_sender_video_(&fake_clock_,
-                          rtp_module_->RtpSender(),
-                          nullptr,
-                          field_trials_) {
-    rtp_module_->SetSequenceNumber(kSeqNum);
-    rtp_module_->SetStartTimestamp(0);
+        }()),
+        rtp_sender_video_(&fake_clock_, &rtp_sender_, nullptr, field_trials_) {
+    rtp_sender_.SetSequenceNumber(kSeqNum);
+    rtp_sender_.SetTimestampOffset(0);
   }
 
   void PopulateGenericFrameDescriptor(int version);
@@ -165,19 +162,19 @@ class RtpSenderVideoTest : public ::testing::TestWithParam<bool> {
       int version);
 
  protected:
-  const RtpRtcp::Configuration config_;
   FieldTrials field_trials_;
   SimulatedClock fake_clock_;
   LoopbackTransportTest transport_;
   RateLimiter retransmission_rate_limiter_;
-  std::unique_ptr<RtpRtcp> rtp_module_;
+
+  RTPSender rtp_sender_;
   TestRtpSenderVideo rtp_sender_video_;
 };
 
 TEST_P(RtpSenderVideoTest, KeyFrameHasCVO) {
   uint8_t kFrame[kMaxPacketLength];
-  rtp_module_->RegisterRtpHeaderExtension(VideoOrientation::kUri,
-                                          kVideoRotationExtensionId);
+  EXPECT_EQ(0, rtp_sender_.RegisterRtpHeaderExtension(
+                   kRtpExtensionVideoRotation, kVideoRotationExtensionId));
 
   RTPVideoHeader hdr;
   hdr.rotation = kVideoRotation_0;
@@ -196,8 +193,8 @@ TEST_P(RtpSenderVideoTest, TimingFrameHasPacketizationTimstampSet) {
   const int64_t kPacketizationTimeMs = 100;
   const int64_t kEncodeStartDeltaMs = 10;
   const int64_t kEncodeFinishDeltaMs = 50;
-  rtp_module_->RegisterRtpHeaderExtension(VideoTimingExtension::kUri,
-                                          kVideoTimingExtensionId);
+  EXPECT_EQ(0, rtp_sender_.RegisterRtpHeaderExtension(kRtpExtensionVideoTiming,
+                                                      kVideoTimingExtensionId));
 
   const int64_t kCaptureTimestamp = fake_clock_.TimeInMilliseconds();
 
@@ -221,8 +218,8 @@ TEST_P(RtpSenderVideoTest, TimingFrameHasPacketizationTimstampSet) {
 
 TEST_P(RtpSenderVideoTest, DeltaFrameHasCVOWhenChanged) {
   uint8_t kFrame[kMaxPacketLength];
-  rtp_module_->RegisterRtpHeaderExtension(VideoOrientation::kUri,
-                                          kVideoRotationExtensionId);
+  EXPECT_EQ(0, rtp_sender_.RegisterRtpHeaderExtension(
+                   kRtpExtensionVideoRotation, kVideoRotationExtensionId));
 
   RTPVideoHeader hdr;
   hdr.rotation = kVideoRotation_90;
@@ -245,8 +242,8 @@ TEST_P(RtpSenderVideoTest, DeltaFrameHasCVOWhenChanged) {
 
 TEST_P(RtpSenderVideoTest, DeltaFrameHasCVOWhenNonZero) {
   uint8_t kFrame[kMaxPacketLength];
-  rtp_module_->RegisterRtpHeaderExtension(VideoOrientation::kUri,
-                                          kVideoRotationExtensionId);
+  EXPECT_EQ(0, rtp_sender_.RegisterRtpHeaderExtension(
+                   kRtpExtensionVideoRotation, kVideoRotationExtensionId));
 
   RTPVideoHeader hdr;
   hdr.rotation = kVideoRotation_90;
@@ -268,8 +265,8 @@ TEST_P(RtpSenderVideoTest, DeltaFrameHasCVOWhenNonZero) {
 
 TEST_P(RtpSenderVideoTest, CheckH264FrameMarking) {
   uint8_t kFrame[kMaxPacketLength];
-  rtp_module_->RegisterRtpHeaderExtension(FrameMarkingExtension::kUri,
-                                          kFrameMarkingExtensionId);
+  EXPECT_EQ(0, rtp_sender_.RegisterRtpHeaderExtension(
+                   kRtpExtensionFrameMarking, kFrameMarkingExtensionId));
 
   RTPFragmentationHeader frag;
   frag.VerifyAndAllocateFragmentationHeader(1);
@@ -516,15 +513,15 @@ TEST_P(RtpSenderVideoTest, ConditionalRetransmitLimit) {
 }
 
 void RtpSenderVideoTest::PopulateGenericFrameDescriptor(int version) {
-  const absl::string_view ext_uri =
-      (version == 0) ? RtpGenericFrameDescriptorExtension00::kUri
-                     : RtpGenericFrameDescriptorExtension01::kUri;
+  const RTPExtensionType ext_type =
+      (version == 0) ? RTPExtensionType::kRtpExtensionGenericFrameDescriptor00
+                     : RTPExtensionType::kRtpExtensionGenericFrameDescriptor01;
   const int ext_id =
       (version == 0) ? kGenericDescriptorId00 : kGenericDescriptorId01;
 
   const int64_t kFrameId = 100000;
   uint8_t kFrame[100];
-  rtp_module_->RegisterRtpHeaderExtension(ext_uri, ext_id);
+  EXPECT_EQ(0, rtp_sender_.RegisterRtpHeaderExtension(ext_type, ext_id));
 
   RTPVideoHeader hdr;
   RTPVideoHeader::GenericDescriptorInfo& generic = hdr.generic.emplace();
@@ -572,11 +569,11 @@ void RtpSenderVideoTest::
   uint8_t kFrame[kFrameSize];
 
   if (version == 0) {
-    rtp_module_->RegisterRtpHeaderExtension(
-        RtpGenericFrameDescriptorExtension00::kUri, kGenericDescriptorId00);
+    ASSERT_TRUE(rtp_sender_.RegisterRtpHeaderExtension(
+        RtpGenericFrameDescriptorExtension00::kUri, kGenericDescriptorId00));
   } else {
-    rtp_module_->RegisterRtpHeaderExtension(
-        RtpGenericFrameDescriptorExtension01::kUri, kGenericDescriptorId01);
+    ASSERT_TRUE(rtp_sender_.RegisterRtpHeaderExtension(
+        RtpGenericFrameDescriptorExtension01::kUri, kGenericDescriptorId01));
   }
 
   RTPVideoHeader hdr;