Move PacedSender ownership to RtpTransportControllerSend.
BUG=webrtc:8089
R=nisse@webrtc.org, terelius@webrtc.org
Review-Url: https://codereview.webrtc.org/3000773002 .
Cr-Original-Commit-Position: refs/heads/master@{#19451}
Cr-Mirrored-From: https://chromium.googlesource.com/external/webrtc
Cr-Mirrored-Commit: 5c8942aee1f2003bd43c8e4427fb74e6f1015fc1
diff --git a/audio/audio_send_stream_unittest.cc b/audio/audio_send_stream_unittest.cc
index bec696b..1308657 100644
--- a/audio/audio_send_stream_unittest.cc
+++ b/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 @@
&simulated_clock_,
nullptr /* observer */,
&event_log_,
- &packet_router_)),
- fake_transport_(&packet_router_, send_side_cc_.get()),
+ &pacer_)),
+ 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 @@
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_;
diff --git a/call/call.cc b/call/call.cc
index 1b5bc45..16ee1cd 100644
--- a/call/call.cc
+++ b/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 @@
// 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(),
- RTC_FROM_HERE);
+ pacer_thread_->RegisterModule(transport_send_->pacer(), RTC_FROM_HERE);
pacer_thread_->RegisterModule(
receive_side_cc_.GetRemoteBitrateEstimator(true), RTC_FROM_HERE);
pacer_thread_->Start();
@@ -466,7 +464,7 @@
// 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::OnAllocationLimitsChanged(uint32_t min_send_bitrate_bps,
uint32_t max_padding_bitrate_bps) {
- transport_send_->send_side_cc()->SetAllocatedSendBitrateLimits(
- min_send_bitrate_bps, max_padding_bitrate_bps);
+ transport_send_->SetAllocatedSendBitrateLimits(min_send_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;
diff --git a/call/call_unittest.cc b/call/call_unittest.cc
index 75e5008..e342dfa 100644
--- a/call/call_unittest.cc
+++ b/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 @@
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 @@
private:
webrtc::RtcEventLogNullImpl event_log_;
PacketRouter packet_router_;
+ testing::NiceMock<MockPacedSender> pacer_;
testing::NiceMock<test::MockSendSideCongestionController> mock_cc_;
std::unique_ptr<Call> call_;
};
diff --git a/call/fake_rtp_transport_controller_send.h b/call/fake_rtp_transport_controller_send.h
index ac612ce..6cff173 100644
--- a/call/fake_rtp_transport_controller_send.h
+++ b/call/fake_rtp_transport_controller_send.h
@@ -23,8 +23,11 @@
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 @@
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_;
};
diff --git a/call/rtp_transport_controller_send.cc b/call/rtp_transport_controller_send.cc
index b8b65a0..ec061d0 100644
--- a/call/rtp_transport_controller_send.cc
+++ b/call/rtp_transport_controller_send.cc
@@ -15,13 +15,17 @@
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 @@
}
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;
diff --git a/call/rtp_transport_controller_send.h b/call/rtp_transport_controller_send.h
index 28e0b2d..766a2e3 100644
--- a/call/rtp_transport_controller_send.h
+++ b/call/rtp_transport_controller_send.h
@@ -29,15 +29,24 @@
// 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_;
diff --git a/call/rtp_transport_controller_send_interface.h b/call/rtp_transport_controller_send_interface.h
index bd71da0..b580421 100644
--- a/call/rtp_transport_controller_send_interface.h
+++ b/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 @@
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
diff --git a/modules/congestion_controller/include/mock/mock_send_side_congestion_controller.h b/modules/congestion_controller/include/mock/mock_send_side_congestion_controller.h
index e71ec8f..899a960 100644
--- a/modules/congestion_controller/include/mock/mock_send_side_congestion_controller.h
+++ b/modules/congestion_controller/include/mock/mock_send_side_congestion_controller.h
@@ -21,11 +21,11 @@
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,
diff --git a/modules/congestion_controller/include/send_side_congestion_controller.h b/modules/congestion_controller/include/send_side_congestion_controller.h
index 1d576aa..490711f 100644
--- a/modules/congestion_controller/include/send_side_congestion_controller.h
+++ b/modules/congestion_controller/include/send_side_congestion_controller.h
@@ -58,16 +58,17 @@
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);
- SendSideCongestionController(const Clock* clock,
- Observer* observer,
- RtcEventLog* event_log,
- std::unique_ptr<PacedSender> pacer);
+ PacedSender* pacer);
~SendSideCongestionController() override;
void RegisterPacketFeedbackObserver(PacketFeedbackObserver* observer);
@@ -91,26 +92,12 @@
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 @@
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_;
diff --git a/modules/congestion_controller/send_side_congestion_controller.cc b/modules/congestion_controller/send_side_congestion_controller.cc
index 77203d6..c8fc990 100644
--- a/modules/congestion_controller/send_side_congestion_controller.cc
+++ b/modules/congestion_controller/send_side_congestion_controller.cc
@@ -98,27 +98,54 @@
Observer* observer,
RtcEventLog* event_log,
PacketRouter* packet_router)
- : SendSideCongestionController(
- clock,
- observer,
- event_log,
- std::unique_ptr<PacedSender>(
- new PacedSender(clock, packet_router, event_log))) {}
+ : clock_(clock),
+ observer_(observer),
+ event_log_(event_log),
+ owned_pacer_(
+ rtc::MakeUnique<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 @@
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 @@
return pacer_->FirstSentPacketTimeMs();
}
-PacedSender* SendSideCongestionController::pacer() {
- return pacer_.get();
-}
-
TransportFeedbackObserver*
SendSideCongestionController::GetTransportFeedbackObserver() {
return this;
diff --git a/modules/congestion_controller/send_side_congestion_controller_unittest.cc b/modules/congestion_controller/send_side_congestion_controller_unittest.cc
index f3f09f3..07c0e39 100644
--- a/modules/congestion_controller/send_side_congestion_controller_unittest.cc
+++ b/modules/congestion_controller/send_side_congestion_controller_unittest.cc
@@ -54,10 +54,9 @@
~SendSideCongestionControllerTest() override {}
void SetUp() override {
- pacer_ = new NiceMock<MockPacedSender>();
- std::unique_ptr<PacedSender> pacer(pacer_); // Passes ownership.
+ pacer_.reset(new NiceMock<MockPacedSender>());
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 @@
// 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 @@
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, 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, 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, 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, _, _, _));
diff --git a/modules/pacing/mock/mock_paced_sender.h b/modules/pacing/mock/mock_paced_sender.h
index aad58c7..d6587b4 100644
--- a/modules/pacing/mock/mock_paced_sender.h
+++ b/modules/pacing/mock/mock_paced_sender.h
@@ -36,6 +36,7 @@
MOCK_CONST_METHOD0(ExpectedQueueTimeMs, int64_t());
MOCK_CONST_METHOD0(GetApplicationLimitedRegionStartTime,
rtc::Optional<int64_t>());
+ MOCK_METHOD0(Process, void());
};
} // namespace webrtc
diff --git a/rtc_tools/DEPS b/rtc_tools/DEPS
index 40fe3cc..c55eb59 100644
--- a/rtc_tools/DEPS
+++ b/rtc_tools/DEPS
@@ -9,6 +9,7 @@
"+webrtc/modules/audio_processing",
"+webrtc/modules/bitrate_controller",
"+webrtc/modules/congestion_controller",
+ "+webrtc/modules/pacing",
"+webrtc/modules/rtp_rtcp",
"+webrtc/system_wrappers",
"+webrtc/p2p",
diff --git a/rtc_tools/event_log_visualizer/analyzer.cc b/rtc_tools/event_log_visualizer/analyzer.cc
index 49be16d..4d485c7 100644
--- a/rtc_tools/event_log_visualizer/analyzer.cc
+++ b/rtc_tools/event_log_visualizer/analyzer.cc
@@ -1126,8 +1126,8 @@
BitrateObserver observer;
RtcEventLogNullImpl null_event_log;
PacketRouter packet_router;
- SendSideCongestionController cc(&clock, &observer, &null_event_log,
- &packet_router);
+ PacedSender pacer(&clock, &packet_router, &null_event_log);
+ 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);
diff --git a/video/video_send_stream.cc b/video/video_send_stream.cc
index 253d11c..e1afdf0 100644
--- a/video/video_send_stream.cc
+++ b/video/video_send_stream.cc
@@ -715,10 +715,8 @@
}
if (alr_settings) {
transport->send_side_cc()->EnablePeriodicAlrProbing(true);
- transport->send_side_cc()->pacer()->SetPacingFactor(
- alr_settings->pacing_factor);
- transport->send_side_cc()->pacer()->SetQueueTimeLimit(
- alr_settings->max_paced_queue_time);
+ transport->pacer()->SetPacingFactor(alr_settings->pacing_factor);
+ transport->pacer()->SetQueueTimeLimit(alr_settings->max_paced_queue_time);
}
if (config_->periodic_alr_bandwidth_probing) {
