From 5c8942aee1f2003bd43c8e4427fb74e6f1015fc1 Mon Sep 17 00:00:00 2001 From: Stefan Holmer Date: Tue, 22 Aug 2017 16:16:44 +0200 Subject: [PATCH] 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 | 7 ++- webrtc/call/call.cc | 10 ++-- webrtc/call/call_unittest.cc | 6 +- .../call/fake_rtp_transport_controller_send.h | 13 ++++- webrtc/call/rtp_transport_controller_send.cc | 16 +++++- webrtc/call/rtp_transport_controller_send.h | 9 +++ .../rtp_transport_controller_send_interface.h | 14 +++++ .../mock_send_side_congestion_controller.h | 4 +- .../include/send_side_congestion_controller.h | 30 +++------- .../send_side_congestion_controller.cc | 55 ++++++++++++------- ...end_side_congestion_controller_unittest.cc | 18 +++--- .../modules/pacing/mock/mock_paced_sender.h | 1 + webrtc/rtc_tools/DEPS | 1 + .../event_log_visualizer/analyzer.cc | 4 +- webrtc/video/video_send_stream.cc | 6 +- 15 files changed, 121 insertions(+), 73 deletions(-) diff --git a/webrtc/audio/audio_send_stream_unittest.cc b/webrtc/audio/audio_send_stream_unittest.cc index bec696bd4e..1308657d0e 100644 --- a/webrtc/audio/audio_send_stream_unittest.cc +++ b/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_)), - 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 @@ struct ConfigHelper { AudioProcessing::AudioProcessingStatistics audio_processing_stats_; SimulatedClock simulated_clock_; PacketRouter packet_router_; + testing::NiceMock pacer_; std::unique_ptr send_side_cc_; FakeRtpTransportControllerSend fake_transport_; MockRtcEventLog event_log_; diff --git a/webrtc/call/call.cc b/webrtc/call/call.cc index 1b5bc456b0..16ee1cde78 100644 --- a/webrtc/call/call.cc +++ b/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(), - 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 @@ 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( - 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/webrtc/call/call_unittest.cc b/webrtc/call/call_unittest.cc index 75e5008846..e342dfa977 100644 --- a/webrtc/call/call_unittest.cc +++ b/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( - &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 pacer_; testing::NiceMock mock_cc_; std::unique_ptr call_; }; diff --git a/webrtc/call/fake_rtp_transport_controller_send.h b/webrtc/call/fake_rtp_transport_controller_send.h index ac612ce87e..6cff173203 100644 --- a/webrtc/call/fake_rtp_transport_controller_send.h +++ b/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_; }; diff --git a/webrtc/call/rtp_transport_controller_send.cc b/webrtc/call/rtp_transport_controller_send.cc index b8b65a0d55..ec061d001f 100644 --- a/webrtc/call/rtp_transport_controller_send.cc +++ b/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; diff --git a/webrtc/call/rtp_transport_controller_send.h b/webrtc/call/rtp_transport_controller_send.h index 28e0b2d7a7..766a2e3839 100644 --- a/webrtc/call/rtp_transport_controller_send.h +++ b/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_; diff --git a/webrtc/call/rtp_transport_controller_send_interface.h b/webrtc/call/rtp_transport_controller_send_interface.h index bd71da02e9..b58042197e 100644 --- a/webrtc/call/rtp_transport_controller_send_interface.h +++ b/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 diff --git a/webrtc/modules/congestion_controller/include/mock/mock_send_side_congestion_controller.h b/webrtc/modules/congestion_controller/include/mock/mock_send_side_congestion_controller.h index e71ec8fff4..899a960109 100644 --- a/webrtc/modules/congestion_controller/include/mock/mock_send_side_congestion_controller.h +++ b/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, diff --git a/webrtc/modules/congestion_controller/include/send_side_congestion_controller.h b/webrtc/modules/congestion_controller/include/send_side_congestion_controller.h index 1d576aaf00..490711f54d 100644 --- a/webrtc/modules/congestion_controller/include/send_side_congestion_controller.h +++ b/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); - SendSideCongestionController(const Clock* clock, - Observer* observer, - RtcEventLog* event_log, - std::unique_ptr pacer); + 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 pacer_; + std::unique_ptr owned_pacer_; + PacedSender* pacer_; const std::unique_ptr bitrate_controller_; std::unique_ptr acknowledged_bitrate_estimator_; const std::unique_ptr probe_controller_; diff --git a/webrtc/modules/congestion_controller/send_side_congestion_controller.cc b/webrtc/modules/congestion_controller/send_side_congestion_controller.cc index 77203d6a8b..c8fc990e03 100644 --- a/webrtc/modules/congestion_controller/send_side_congestion_controller.cc +++ b/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, - observer, - event_log, - std::unique_ptr( - new PacedSender(clock, packet_router, event_log))) {} + : clock_(clock), + observer_(observer), + event_log_(event_log), + owned_pacer_( + rtc::MakeUnique(clock, packet_router, event_log)), + pacer_(owned_pacer_.get()), + bitrate_controller_( + BitrateController::CreateBitrateController(clock_, event_log)), + acknowledged_bitrate_estimator_( + rtc::MakeUnique()), + 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 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()), - 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; diff --git a/webrtc/modules/congestion_controller/send_side_congestion_controller_unittest.cc b/webrtc/modules/congestion_controller/send_side_congestion_controller_unittest.cc index f3f09f31cf..07c0e39fc0 100644 --- a/webrtc/modules/congestion_controller/send_side_congestion_controller_unittest.cc +++ b/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(); - std::unique_ptr pacer(pacer_); // Passes ownership. + pacer_.reset(new NiceMock()); 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 pacer(new NiceMock()); + pacer_.reset(new NiceMock()); 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 observer_; TargetBitrateObserver target_bitrate_observer_; - NiceMock* pacer_; NiceMock event_log_; std::unique_ptr bandwidth_observer_; + PacketRouter packet_router_; + std::unique_ptr> pacer_; std::unique_ptr controller_; rtc::Optional 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, _, _, _)); diff --git a/webrtc/modules/pacing/mock/mock_paced_sender.h b/webrtc/modules/pacing/mock/mock_paced_sender.h index aad58c715f..d6587b4b75 100644 --- a/webrtc/modules/pacing/mock/mock_paced_sender.h +++ b/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()); + MOCK_METHOD0(Process, void()); }; } // namespace webrtc diff --git a/webrtc/rtc_tools/DEPS b/webrtc/rtc_tools/DEPS index 40fe3cc28a..c55eb59645 100644 --- a/webrtc/rtc_tools/DEPS +++ b/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", diff --git a/webrtc/rtc_tools/event_log_visualizer/analyzer.cc b/webrtc/rtc_tools/event_log_visualizer/analyzer.cc index 49be16d5c0..4d485c72d1 100644 --- a/webrtc/rtc_tools/event_log_visualizer/analyzer.cc +++ b/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, - &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/webrtc/video/video_send_stream.cc b/webrtc/video/video_send_stream.cc index 253d11cb79..e1afdf0fc2 100644 --- a/webrtc/video/video_send_stream.cc +++ b/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( - 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) {