diff --git a/audio/audio_send_stream.cc b/audio/audio_send_stream.cc
index 5de079bb18..16744f9bdf 100644
--- a/audio/audio_send_stream.cc
+++ b/audio/audio_send_stream.cc
@@ -19,7 +19,6 @@
 #include "audio/conversion.h"
 #include "call/rtp_transport_controller_send_interface.h"
 #include "modules/audio_coding/codecs/cng/audio_encoder_cng.h"
-#include "modules/pacing/paced_sender.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/event.h"
 #include "rtc_base/function_view.h"
diff --git a/call/call.cc b/call/call.cc
index 338a135900..ddc43cbbd9 100644
--- a/call/call.cc
+++ b/call/call.cc
@@ -464,7 +464,8 @@ Call::Call(const Call::Config& config,
   // We have to attach the pacer to the pacer thread before starting the
   // module process thread to avoid a race accessing the process thread
   // both from the process thread and the pacer thread.
-  pacer_thread_->RegisterModule(transport_send_->pacer(), RTC_FROM_HERE);
+  pacer_thread_->RegisterModule(transport_send_->GetPacerModule(),
+                                RTC_FROM_HERE);
   pacer_thread_->RegisterModule(
       receive_side_cc_.GetRemoteBitrateEstimator(true), RTC_FROM_HERE);
   pacer_thread_->Start();
@@ -491,7 +492,7 @@ Call::~Call() {
   // the pacer thread is stopped.
   module_process_thread_->DeRegisterModule(transport_send_->GetModule());
   pacer_thread_->Stop();
-  pacer_thread_->DeRegisterModule(transport_send_->pacer());
+  pacer_thread_->DeRegisterModule(transport_send_->GetPacerModule());
   pacer_thread_->DeRegisterModule(
       receive_side_cc_.GetRemoteBitrateEstimator(true));
   module_process_thread_->DeRegisterModule(&receive_side_cc_);
diff --git a/call/fake_rtp_transport_controller_send.h b/call/fake_rtp_transport_controller_send.h
index b797a352bd..ed671f3522 100644
--- a/call/fake_rtp_transport_controller_send.h
+++ b/call/fake_rtp_transport_controller_send.h
@@ -37,8 +37,6 @@ class FakeRtpTransportControllerSend
     return send_side_cc_;
   }
 
-  PacedSender* pacer() override { return paced_sender_; }
-
   RtpPacketSender* packet_sender() override { return paced_sender_; }
 
   const RtpKeepAliveConfig& keepalive_config() const override {
@@ -52,6 +50,13 @@ class FakeRtpTransportControllerSend
     keepalive_ = keepalive_config;
   }
 
+  Module* GetPacerModule() override { return paced_sender_; }
+  void SetPacingFactor(float pacing_factor) override {
+    paced_sender_->SetPacingFactor(pacing_factor);
+  }
+  void SetQueueTimeLimit(int limit_ms) override {
+    paced_sender_->SetQueueTimeLimit(limit_ms);
+  }
   Module* GetModule() override { return send_side_cc_; }
   CallStatsObserver* GetCallStatsObserver() override { return send_side_cc_; }
   void RegisterPacketFeedbackObserver(
diff --git a/call/rtp_transport_controller_send.cc b/call/rtp_transport_controller_send.cc
index f203c4e6f8..70061c1230 100644
--- a/call/rtp_transport_controller_send.cc
+++ b/call/rtp_transport_controller_send.cc
@@ -22,10 +22,6 @@ PacketRouter* RtpTransportControllerSend::packet_router() {
   return &packet_router_;
 }
 
-PacedSender* RtpTransportControllerSend::pacer() {
-  return &pacer_;
-}
-
 TransportFeedbackObserver*
 RtpTransportControllerSend::transport_feedback_observer() {
   return &send_side_cc_;
@@ -49,6 +45,15 @@ void RtpTransportControllerSend::SetKeepAliveConfig(
     const RtpKeepAliveConfig& config) {
   keepalive_ = config;
 }
+Module* RtpTransportControllerSend::GetPacerModule() {
+  return &pacer_;
+}
+void RtpTransportControllerSend::SetPacingFactor(float pacing_factor) {
+  pacer_.SetPacingFactor(pacing_factor);
+}
+void RtpTransportControllerSend::SetQueueTimeLimit(int limit_ms) {
+  pacer_.SetQueueTimeLimit(limit_ms);
+}
 Module* RtpTransportControllerSend::GetModule() {
   return &send_side_cc_;
 }
diff --git a/call/rtp_transport_controller_send.h b/call/rtp_transport_controller_send.h
index 2ae4ce6d39..d0bfa1ca3d 100644
--- a/call/rtp_transport_controller_send.h
+++ b/call/rtp_transport_controller_send.h
@@ -30,11 +30,7 @@ class RtpTransportControllerSend : public RtpTransportControllerSendInterface {
 
   // Implements RtpTransportControllerSendInterface
   PacketRouter* packet_router() override;
-  // TODO(holmer): Temporarily exposed, should be removed and the
-  // appropriate methods should be added to this class instead.
-  // In addition the PacedSender should be driven by this class, either
-  // by owning the process thread, or later by using a task queue.
-  PacedSender* pacer() override;
+
   TransportFeedbackObserver* transport_feedback_observer() override;
   RtpPacketSender* packet_sender() override;
   const RtpKeepAliveConfig& keepalive_config() const override;
@@ -43,6 +39,9 @@ class RtpTransportControllerSend : public RtpTransportControllerSendInterface {
                                      int max_padding_bitrate_bps) override;
 
   void SetKeepAliveConfig(const RtpKeepAliveConfig& config);
+  Module* GetPacerModule() override;
+  void SetPacingFactor(float pacing_factor) override;
+  void SetQueueTimeLimit(int limit_ms) override;
   Module* GetModule() override;
   CallStatsObserver* GetCallStatsObserver() override;
   void RegisterPacketFeedbackObserver(
diff --git a/call/rtp_transport_controller_send_interface.h b/call/rtp_transport_controller_send_interface.h
index d8f58db0e8..284aeec46b 100644
--- a/call/rtp_transport_controller_send_interface.h
+++ b/call/rtp_transport_controller_send_interface.h
@@ -58,7 +58,6 @@ class RtpTransportControllerSendInterface {
  public:
   virtual ~RtpTransportControllerSendInterface() {}
   virtual PacketRouter* packet_router() = 0;
-  virtual PacedSender* pacer() = 0;
   virtual TransportFeedbackObserver* transport_feedback_observer() = 0;
 
   virtual RtpPacketSender* packet_sender() = 0;
@@ -76,6 +75,10 @@ class RtpTransportControllerSendInterface {
   virtual void SetAllocatedSendBitrateLimits(int min_send_bitrate_bps,
                                              int max_padding_bitrate_bps) = 0;
 
+  virtual Module* GetPacerModule() = 0;
+  virtual void SetPacingFactor(float pacing_factor) = 0;
+  virtual void SetQueueTimeLimit(int limit_ms) = 0;
+
   virtual Module* GetModule() = 0;
   virtual CallStatsObserver* GetCallStatsObserver() = 0;
 
diff --git a/video/video_send_stream.cc b/video/video_send_stream.cc
index f49f5a001c..a7b1dc556c 100644
--- a/video/video_send_stream.cc
+++ b/video/video_send_stream.cc
@@ -838,9 +838,9 @@ VideoSendStreamImpl::VideoSendStreamImpl(
     }
     if (alr_settings) {
       transport->EnablePeriodicAlrProbing(true);
-      transport->pacer()->SetPacingFactor(alr_settings->pacing_factor);
+      transport->SetPacingFactor(alr_settings->pacing_factor);
       configured_pacing_factor_ = alr_settings->pacing_factor;
-      transport->pacer()->SetQueueTimeLimit(alr_settings->max_paced_queue_time);
+      transport->SetQueueTimeLimit(alr_settings->max_paced_queue_time);
     }
   }
 
diff --git a/video/video_stream_encoder.cc b/video/video_stream_encoder.cc
index ddf4671694..340bbf4419 100644
--- a/video/video_stream_encoder.cc
+++ b/video/video_stream_encoder.cc
@@ -18,7 +18,6 @@
 #include "api/video/i420_buffer.h"
 #include "common_video/include/video_bitrate_allocator.h"
 #include "common_video/include/video_frame.h"
-#include "modules/pacing/paced_sender.h"
 #include "modules/video_coding/include/video_codec_initializer.h"
 #include "modules/video_coding/include/video_coding.h"
 #include "modules/video_coding/include/video_coding_defines.h"