Move PacedSender ownership to RtpTransportControllerSend.

BUG=webrtc:8089
R=nisse@webrtc.org, terelius@webrtc.org

Review-Url: https://codereview.webrtc.org/3000773002 .
Cr-Commit-Position: refs/heads/master@{#19451}

webrtc/audio/audio_send_stream_unittest.cc

@@ -22,7 +22,7 @@
 #include "webrtc/modules/audio_processing/include/mock_audio_processing.h"
 #include "webrtc/modules/congestion_controller/include/mock/mock_congestion_observer.h"
 #include "webrtc/modules/congestion_controller/include/send_side_congestion_controller.h"
-#include "webrtc/modules/pacing/paced_sender.h"
+#include "webrtc/modules/pacing/mock/mock_paced_sender.h"
 #include "webrtc/modules/rtp_rtcp/mocks/mock_rtcp_rtt_stats.h"
 #include "webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h"
 #include "webrtc/rtc_base/ptr_util.h"
@@ -139,8 +139,8 @@ struct ConfigHelper {
             &simulated_clock_,
             nullptr /* observer */,
             &event_log_,
-            &packet_router_)),
+            &pacer_)),
-        fake_transport_(&packet_router_, send_side_cc_.get()),
+        fake_transport_(&packet_router_, &pacer_, send_side_cc_.get()),
         bitrate_allocator_(&limit_observer_),
         worker_queue_("ConfigHelper_worker_queue"),
         audio_encoder_(nullptr) {
@@ -335,6 +335,7 @@ struct ConfigHelper {
   AudioProcessing::AudioProcessingStatistics audio_processing_stats_;
   SimulatedClock simulated_clock_;
   PacketRouter packet_router_;
+  testing::NiceMock<MockPacedSender> pacer_;
   std::unique_ptr<SendSideCongestionController> send_side_cc_;
   FakeRtpTransportControllerSend fake_transport_;
   MockRtcEventLog event_log_;

webrtc/call/call.cc

@@ -30,7 +30,6 @@
 #include "webrtc/logging/rtc_event_log/rtc_event_log.h"
 #include "webrtc/modules/bitrate_controller/include/bitrate_controller.h"
 #include "webrtc/modules/congestion_controller/include/receive_side_congestion_controller.h"
-#include "webrtc/modules/pacing/paced_sender.h"
 #include "webrtc/modules/rtp_rtcp/include/flexfec_receiver.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_header_extension_map.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h"
@@ -438,8 +437,7 @@ 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_->send_side_cc()->pacer(),
+  pacer_thread_->RegisterModule(transport_send_->pacer(), RTC_FROM_HERE);
-                                RTC_FROM_HERE);
   pacer_thread_->RegisterModule(
       receive_side_cc_.GetRemoteBitrateEstimator(true), RTC_FROM_HERE);
   pacer_thread_->Start();
@@ -466,7 +464,7 @@ Call::~Call() {
   // the pacer thread is stopped.
   module_process_thread_->DeRegisterModule(transport_send_->send_side_cc());
   pacer_thread_->Stop();
-  pacer_thread_->DeRegisterModule(transport_send_->send_side_cc()->pacer());
+  pacer_thread_->DeRegisterModule(transport_send_->pacer());
   pacer_thread_->DeRegisterModule(
       receive_side_cc_.GetRemoteBitrateEstimator(true));
   module_process_thread_->DeRegisterModule(&receive_side_cc_);
@@ -1198,8 +1196,8 @@ void Call::OnNetworkChanged(uint32_t target_bitrate_bps,
 
 void Call::OnAllocationLimitsChanged(uint32_t min_send_bitrate_bps,
                                      uint32_t max_padding_bitrate_bps) {
-  transport_send_->send_side_cc()->SetAllocatedSendBitrateLimits(
+  transport_send_->SetAllocatedSendBitrateLimits(min_send_bitrate_bps,
-      min_send_bitrate_bps, max_padding_bitrate_bps);
+                                                 max_padding_bitrate_bps);
   rtc::CritScope lock(&bitrate_crit_);
   min_allocated_send_bitrate_bps_ = min_send_bitrate_bps;
   configured_max_padding_bitrate_bps_ = max_padding_bitrate_bps;

webrtc/call/call_unittest.cc

@@ -21,6 +21,7 @@
 #include "webrtc/modules/audio_device/include/mock_audio_device.h"
 #include "webrtc/modules/audio_mixer/audio_mixer_impl.h"
 #include "webrtc/modules/congestion_controller/include/mock/mock_send_side_congestion_controller.h"
+#include "webrtc/modules/pacing/mock/mock_paced_sender.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h"
 #include "webrtc/rtc_base/ptr_util.h"
 #include "webrtc/test/fake_encoder.h"
@@ -324,12 +325,12 @@ struct CallBitrateHelper {
   CallBitrateHelper() : CallBitrateHelper(Call::Config::BitrateConfig()) {}
 
   explicit CallBitrateHelper(const Call::Config::BitrateConfig& bitrate_config)
-      : mock_cc_(Clock::GetRealTimeClock(), &event_log_, &packet_router_) {
+      : mock_cc_(Clock::GetRealTimeClock(), &event_log_, &pacer_) {
     Call::Config config(&event_log_);
     config.bitrate_config = bitrate_config;
     call_.reset(
         Call::Create(config, rtc::MakeUnique<FakeRtpTransportControllerSend>(
-                                 &packet_router_, &mock_cc_)));
+                                 &packet_router_, &pacer_, &mock_cc_)));
   }
 
   webrtc::Call* operator->() { return call_.get(); }
@@ -340,6 +341,7 @@ struct CallBitrateHelper {
  private:
   webrtc::RtcEventLogNullImpl event_log_;
   PacketRouter packet_router_;
+  testing::NiceMock<MockPacedSender> pacer_;
   testing::NiceMock<test::MockSendSideCongestionController> mock_cc_;
   std::unique_ptr<Call> call_;
 };

webrtc/call/fake_rtp_transport_controller_send.h

@@ -23,8 +23,11 @@ class FakeRtpTransportControllerSend
  public:
   explicit FakeRtpTransportControllerSend(
       PacketRouter* packet_router,
+      PacedSender* paced_sender,
       SendSideCongestionController* send_side_cc)
-      : packet_router_(packet_router), send_side_cc_(send_side_cc) {
+      : packet_router_(packet_router),
+        paced_sender_(paced_sender),
+        send_side_cc_(send_side_cc) {
     RTC_DCHECK(send_side_cc);
   }
 
@@ -38,18 +41,24 @@ class FakeRtpTransportControllerSend
     return send_side_cc_;
   }
 
-  RtpPacketSender* packet_sender() override { return send_side_cc_->pacer(); }
+  PacedSender* pacer() override { return paced_sender_; }
+
+  RtpPacketSender* packet_sender() override { return paced_sender_; }
 
   const RtpKeepAliveConfig& keepalive_config() const override {
     return keepalive_;
   }
 
+  void SetAllocatedSendBitrateLimits(int min_send_bitrate_bps,
+                                     int max_padding_bitrate_bps) override {}
+
   void set_keepalive_config(const RtpKeepAliveConfig& keepalive_config) {
     keepalive_ = keepalive_config;
   }
 
  private:
   PacketRouter* packet_router_;
+  PacedSender* paced_sender_;
   SendSideCongestionController* send_side_cc_;
   RtpKeepAliveConfig keepalive_;
 };

webrtc/call/rtp_transport_controller_send.cc

@@ -15,13 +15,17 @@ namespace webrtc {
 RtpTransportControllerSend::RtpTransportControllerSend(
     Clock* clock,
     webrtc::RtcEventLog* event_log)
-    : send_side_cc_(clock, nullptr /* observer */, event_log, &packet_router_) {
+    : pacer_(clock, &packet_router_, event_log),
-}
+      send_side_cc_(clock, nullptr /* observer */, event_log, &pacer_) {}
 
 PacketRouter* RtpTransportControllerSend::packet_router() {
   return &packet_router_;
 }
 
+PacedSender* RtpTransportControllerSend::pacer() {
+  return &pacer_;
+}
+
 SendSideCongestionController* RtpTransportControllerSend::send_side_cc() {
   return &send_side_cc_;
 }
@@ -32,13 +36,19 @@ RtpTransportControllerSend::transport_feedback_observer() {
 }
 
 RtpPacketSender* RtpTransportControllerSend::packet_sender() {
-  return send_side_cc_.pacer();
+  return &pacer_;
 }
 
 const RtpKeepAliveConfig& RtpTransportControllerSend::keepalive_config() const {
   return keepalive_;
 }
 
+void RtpTransportControllerSend::SetAllocatedSendBitrateLimits(
+    int min_send_bitrate_bps,
+    int max_padding_bitrate_bps) {
+  pacer_.SetSendBitrateLimits(min_send_bitrate_bps, max_padding_bitrate_bps);
+}
+
 void RtpTransportControllerSend::SetKeepAliveConfig(
     const RtpKeepAliveConfig& config) {
   keepalive_ = config;

webrtc/call/rtp_transport_controller_send.h

@@ -29,15 +29,24 @@ 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;
   SendSideCongestionController* send_side_cc() override;
   TransportFeedbackObserver* transport_feedback_observer() override;
   RtpPacketSender* packet_sender() override;
   const RtpKeepAliveConfig& keepalive_config() const override;
 
+  void SetAllocatedSendBitrateLimits(int min_send_bitrate_bps,
+                                     int max_padding_bitrate_bps) override;
+
   void SetKeepAliveConfig(const RtpKeepAliveConfig& config);
 
  private:
   PacketRouter packet_router_;
+  PacedSender pacer_;
   SendSideCongestionController send_side_cc_;
   RtpKeepAliveConfig keepalive_;
 

webrtc/call/rtp_transport_controller_send_interface.h

@@ -13,6 +13,7 @@
 
 namespace webrtc {
 
+class PacedSender;
 class PacketRouter;
 class RtpPacketSender;
 struct RtpKeepAliveConfig;
@@ -46,12 +47,25 @@ class RtpTransportControllerSendInterface {
  public:
   virtual ~RtpTransportControllerSendInterface() {}
   virtual PacketRouter* packet_router() = 0;
+  virtual PacedSender* pacer() = 0;
   // Currently returning the same pointer, but with different types.
   virtual SendSideCongestionController* send_side_cc() = 0;
   virtual TransportFeedbackObserver* transport_feedback_observer() = 0;
 
   virtual RtpPacketSender* packet_sender() = 0;
   virtual const RtpKeepAliveConfig& keepalive_config() const = 0;
+
+  // SetAllocatedSendBitrateLimits sets bitrates limits imposed by send codec
+  // settings.
+  // |min_send_bitrate_bps| is the total minimum send bitrate required by all
+  // sending streams.  This is the minimum bitrate the PacedSender will use.
+  // Note that SendSideCongestionController::OnNetworkChanged can still be
+  // called with a lower bitrate estimate. |max_padding_bitrate_bps| is the max
+  // bitrate the send streams request for padding. This can be higher than the
+  // current network estimate and tells the PacedSender how much it should max
+  // pad unless there is real packets to send.
+  virtual void SetAllocatedSendBitrateLimits(int min_send_bitrate_bps,
+                                             int max_padding_bitrate_bps) = 0;
 };
 
 }  // namespace webrtc

webrtc/modules/congestion_controller/include/mock/mock_send_side_congestion_controller.h

@@ -21,11 +21,11 @@ class MockSendSideCongestionController : public SendSideCongestionController {
  public:
   MockSendSideCongestionController(const Clock* clock,
                                    RtcEventLog* event_log,
-                                   PacketRouter* packet_router)
+                                   PacedSender* paced_sender)
       : SendSideCongestionController(clock,
                                      nullptr /* observer */,
                                      event_log,
-                                     packet_router) {}
+                                     paced_sender) {}
 
   MOCK_METHOD3(SetBweBitrates,
                void(int min_bitrate_bps,

webrtc/modules/congestion_controller/include/send_side_congestion_controller.h

@@ -58,16 +58,17 @@ class SendSideCongestionController : public CallStatsObserver,
    protected:
     virtual ~Observer() {}
   };
+  // TODO(holmer): Delete after fixing upstream projects.
+  RTC_DEPRECATED SendSideCongestionController(const Clock* clock,
+                                              Observer* observer,
+                                              RtcEventLog* event_log,
+                                              PacketRouter* packet_router);
   // TODO(nisse): Consider deleting the |observer| argument to constructors
   // once CongestionController is deleted.
   SendSideCongestionController(const Clock* clock,
                                Observer* observer,
                                RtcEventLog* event_log,
-                               PacketRouter* packet_router);
+                               PacedSender* pacer);
-  SendSideCongestionController(const Clock* clock,
-                               Observer* observer,
-                               RtcEventLog* event_log,
-                               std::unique_ptr<PacedSender> pacer);
   ~SendSideCongestionController() override;
 
   void RegisterPacketFeedbackObserver(PacketFeedbackObserver* observer);
@@ -91,26 +92,12 @@ class SendSideCongestionController : public CallStatsObserver,
   virtual BitrateController* GetBitrateController() const;
   virtual int64_t GetPacerQueuingDelayMs() const;
   virtual int64_t GetFirstPacketTimeMs() const;
-  // TODO(nisse): Delete this accessor function. The pacer should be
+
-  // internal to the congestion controller.
-  virtual PacedSender* pacer();
   virtual TransportFeedbackObserver* GetTransportFeedbackObserver();
 
   RateLimiter* GetRetransmissionRateLimiter();
   void EnablePeriodicAlrProbing(bool enable);
 
-  // SetAllocatedSendBitrateLimits sets bitrates limits imposed by send codec
-  // settings.
-  // |min_send_bitrate_bps| is the total minimum send bitrate required by all
-  // sending streams.  This is the minimum bitrate the PacedSender will use.
-  // Note that SendSideCongestionController::OnNetworkChanged can still be
-  // called with a lower bitrate estimate. |max_padding_bitrate_bps| is the max
-  // bitrate the send streams request for padding. This can be higher than the
-  // current network estimate and tells the PacedSender how much it should max
-  // pad unless there is real packets to send.
-  void SetAllocatedSendBitrateLimits(int min_send_bitrate_bps,
-                                     int max_padding_bitrate_bps);
-
   virtual void OnSentPacket(const rtc::SentPacket& sent_packet);
 
   // Implements CallStatsObserver.
@@ -141,7 +128,8 @@ class SendSideCongestionController : public CallStatsObserver,
   rtc::CriticalSection observer_lock_;
   Observer* observer_ GUARDED_BY(observer_lock_);
   RtcEventLog* const event_log_;
-  const std::unique_ptr<PacedSender> pacer_;
+  std::unique_ptr<PacedSender> owned_pacer_;
+  PacedSender* pacer_;
   const std::unique_ptr<BitrateController> bitrate_controller_;
   std::unique_ptr<AcknowledgedBitrateEstimator> acknowledged_bitrate_estimator_;
   const std::unique_ptr<ProbeController> probe_controller_;

webrtc/modules/congestion_controller/send_side_congestion_controller.cc

@@ -98,27 +98,54 @@ SendSideCongestionController::SendSideCongestionController(
     Observer* observer,
     RtcEventLog* event_log,
     PacketRouter* packet_router)
-    : SendSideCongestionController(
+    : clock_(clock),
-          clock,
+      observer_(observer),
-          observer,
+      event_log_(event_log),
-          event_log,
+      owned_pacer_(
-          std::unique_ptr<PacedSender>(
+          rtc::MakeUnique<PacedSender>(clock, packet_router, event_log)),
-              new PacedSender(clock, packet_router, event_log))) {}
+      pacer_(owned_pacer_.get()),
+      bitrate_controller_(
+          BitrateController::CreateBitrateController(clock_, event_log)),
+      acknowledged_bitrate_estimator_(
+          rtc::MakeUnique<AcknowledgedBitrateEstimator>()),
+      probe_controller_(new ProbeController(pacer_, clock_)),
+      retransmission_rate_limiter_(
+          new RateLimiter(clock, kRetransmitWindowSizeMs)),
+      transport_feedback_adapter_(clock_),
+      last_reported_bitrate_bps_(0),
+      last_reported_fraction_loss_(0),
+      last_reported_rtt_(0),
+      network_state_(kNetworkUp),
+      pause_pacer_(false),
+      pacer_paused_(false),
+      min_bitrate_bps_(congestion_controller::GetMinBitrateBps()),
+      delay_based_bwe_(new DelayBasedBwe(event_log_, clock_)),
+      in_cwnd_experiment_(CwndExperimentEnabled()),
+      accepted_queue_ms_(kDefaultAcceptedQueueMs),
+      was_in_alr_(0) {
+  delay_based_bwe_->SetMinBitrate(min_bitrate_bps_);
+  if (in_cwnd_experiment_ &&
+      !ReadCwndExperimentParameter(&accepted_queue_ms_)) {
+    LOG(LS_WARNING) << "Failed to parse parameters for CwndExperiment "
+                       "from field trial string. Experiment disabled.";
+    in_cwnd_experiment_ = false;
+  }
+}
 
 SendSideCongestionController::SendSideCongestionController(
     const Clock* clock,
     Observer* observer,
     RtcEventLog* event_log,
-    std::unique_ptr<PacedSender> pacer)
+    PacedSender* pacer)
     : clock_(clock),
       observer_(observer),
       event_log_(event_log),
-      pacer_(std::move(pacer)),
+      pacer_(pacer),
       bitrate_controller_(
           BitrateController::CreateBitrateController(clock_, event_log)),
       acknowledged_bitrate_estimator_(
           rtc::MakeUnique<AcknowledgedBitrateEstimator>()),
-      probe_controller_(new ProbeController(pacer_.get(), clock_)),
+      probe_controller_(new ProbeController(pacer_, clock_)),
       retransmission_rate_limiter_(
           new RateLimiter(clock, kRetransmitWindowSizeMs)),
       transport_feedback_adapter_(clock_),
@@ -229,12 +256,6 @@ void SendSideCongestionController::EnablePeriodicAlrProbing(bool enable) {
   probe_controller_->EnablePeriodicAlrProbing(enable);
 }
 
-void SendSideCongestionController::SetAllocatedSendBitrateLimits(
-    int min_send_bitrate_bps,
-    int max_padding_bitrate_bps) {
-  pacer_->SetSendBitrateLimits(min_send_bitrate_bps, max_padding_bitrate_bps);
-}
-
 int64_t SendSideCongestionController::GetPacerQueuingDelayMs() const {
   return IsNetworkDown() ? 0 : pacer_->QueueInMs();
 }
@@ -243,10 +264,6 @@ int64_t SendSideCongestionController::GetFirstPacketTimeMs() const {
   return pacer_->FirstSentPacketTimeMs();
 }
 
-PacedSender* SendSideCongestionController::pacer() {
-  return pacer_.get();
-}
-
 TransportFeedbackObserver*
 SendSideCongestionController::GetTransportFeedbackObserver() {
   return this;

webrtc/modules/congestion_controller/send_side_congestion_controller_unittest.cc

@@ -54,10 +54,9 @@ class SendSideCongestionControllerTest : public ::testing::Test {
   ~SendSideCongestionControllerTest() override {}
 
   void SetUp() override {
-    pacer_ = new NiceMock<MockPacedSender>();
+    pacer_.reset(new NiceMock<MockPacedSender>());
-    std::unique_ptr<PacedSender> pacer(pacer_);  // Passes ownership.
     controller_.reset(new SendSideCongestionController(
-        &clock_, &observer_, &event_log_, std::move(pacer)));
+        &clock_, &observer_, &event_log_, pacer_.get()));
     bandwidth_observer_.reset(
         controller_->GetBitrateController()->CreateRtcpBandwidthObserver());
 
@@ -73,9 +72,9 @@ class SendSideCongestionControllerTest : public ::testing::Test {
   // Custom setup - use an observer that tracks the target bitrate, without
   // prescribing on which iterations it must change (like a mock would).
   void TargetBitrateTrackingSetup() {
-    std::unique_ptr<PacedSender> pacer(new NiceMock<MockPacedSender>());
+    pacer_.reset(new NiceMock<MockPacedSender>());
     controller_.reset(new SendSideCongestionController(
-        &clock_, &target_bitrate_observer_, &event_log_, std::move(pacer)));
+        &clock_, &target_bitrate_observer_, &event_log_, pacer_.get()));
     controller_->SetBweBitrates(0, kInitialBitrateBps, 5 * kInitialBitrateBps);
   }
 
@@ -138,9 +137,10 @@ class SendSideCongestionControllerTest : public ::testing::Test {
   SimulatedClock clock_;
   StrictMock<MockCongestionObserver> observer_;
   TargetBitrateObserver target_bitrate_observer_;
-  NiceMock<MockPacedSender>* pacer_;
   NiceMock<MockRtcEventLog> event_log_;
   std::unique_ptr<RtcpBandwidthObserver> bandwidth_observer_;
+  PacketRouter packet_router_;
+  std::unique_ptr<NiceMock<MockPacedSender>> pacer_;
   std::unique_ptr<SendSideCongestionController> controller_;
 
   rtc::Optional<uint32_t> target_bitrate_bps_;
@@ -216,7 +216,7 @@ TEST_F(SendSideCongestionControllerTest, SignalNetworkState) {
 
 TEST_F(SendSideCongestionControllerTest, OnNetworkRouteChanged) {
   int new_bitrate = 200000;
-  testing::Mock::VerifyAndClearExpectations(pacer_);
+  testing::Mock::VerifyAndClearExpectations(pacer_.get());
   EXPECT_CALL(observer_, OnNetworkChanged(new_bitrate, _, _, _));
   EXPECT_CALL(*pacer_, SetEstimatedBitrate(new_bitrate));
   rtc::NetworkRoute route;
@@ -236,7 +236,7 @@ TEST_F(SendSideCongestionControllerTest, OnNetworkRouteChanged) {
 
 TEST_F(SendSideCongestionControllerTest, OldFeedback) {
   int new_bitrate = 200000;
-  testing::Mock::VerifyAndClearExpectations(pacer_);
+  testing::Mock::VerifyAndClearExpectations(pacer_.get());
   EXPECT_CALL(observer_, OnNetworkChanged(new_bitrate, _, _, _));
   EXPECT_CALL(*pacer_, SetEstimatedBitrate(new_bitrate));
 
@@ -334,7 +334,7 @@ TEST_F(SendSideCongestionControllerTest, GetProbingInterval) {
 }
 
 TEST_F(SendSideCongestionControllerTest, ProbeOnRouteChange) {
-  testing::Mock::VerifyAndClearExpectations(pacer_);
+  testing::Mock::VerifyAndClearExpectations(pacer_.get());
   EXPECT_CALL(*pacer_, CreateProbeCluster(kInitialBitrateBps * 6));
   EXPECT_CALL(*pacer_, CreateProbeCluster(kInitialBitrateBps * 12));
   EXPECT_CALL(observer_, OnNetworkChanged(kInitialBitrateBps * 2, _, _, _));

webrtc/modules/pacing/mock/mock_paced_sender.h

@@ -36,6 +36,7 @@ class MockPacedSender : public PacedSender {
   MOCK_CONST_METHOD0(ExpectedQueueTimeMs, int64_t());
   MOCK_CONST_METHOD0(GetApplicationLimitedRegionStartTime,
                      rtc::Optional<int64_t>());
+  MOCK_METHOD0(Process, void());
 };
 
 }  // namespace webrtc

webrtc/rtc_tools/DEPS

@@ -9,6 +9,7 @@ include_rules = [
   "+webrtc/modules/audio_processing",
   "+webrtc/modules/bitrate_controller",
   "+webrtc/modules/congestion_controller",
+  "+webrtc/modules/pacing",
   "+webrtc/modules/rtp_rtcp",
   "+webrtc/system_wrappers",
   "+webrtc/p2p",

webrtc/rtc_tools/event_log_visualizer/analyzer.cc

@@ -1126,8 +1126,8 @@ void EventLogAnalyzer::CreateBweSimulationGraph(Plot* plot) {
   BitrateObserver observer;
   RtcEventLogNullImpl null_event_log;
   PacketRouter packet_router;
-  SendSideCongestionController cc(&clock, &observer, &null_event_log,
+  PacedSender pacer(&clock, &packet_router, &null_event_log);
-                                  &packet_router);
+  SendSideCongestionController cc(&clock, &observer, &null_event_log, &pacer);
   // TODO(holmer): Log the call config and use that here instead.
   static const uint32_t kDefaultStartBitrateBps = 300000;
   cc.SetBweBitrates(0, kDefaultStartBitrateBps, -1);

webrtc/video/video_send_stream.cc

@@ -715,10 +715,8 @@ VideoSendStreamImpl::VideoSendStreamImpl(
   }
   if (alr_settings) {
     transport->send_side_cc()->EnablePeriodicAlrProbing(true);
-    transport->send_side_cc()->pacer()->SetPacingFactor(
+    transport->pacer()->SetPacingFactor(alr_settings->pacing_factor);
-        alr_settings->pacing_factor);
+    transport->pacer()->SetQueueTimeLimit(alr_settings->max_paced_queue_time);
-    transport->send_side_cc()->pacer()->SetQueueTimeLimit(
-        alr_settings->max_paced_queue_time);
   }
 
   if (config_->periodic_alr_bandwidth_probing) {