admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Deprecating legacy SendSideCongestionController.

Browse Source 
For somewhat similar funtionality, GoogCcNetworkController can
be used via GoogCcNetworkControllerFactory.

Bug: webrtc:9586
Change-Id: I298050184513f50c1b9ef5c21b8c9b7a6ca46fd5
Reviewed-on: https://webrtc-review.googlesource.com/c/114543
Reviewed-by: Niels Moller <nisse@webrtc.org>
Reviewed-by: Erik Språng <sprang@webrtc.org>
Reviewed-by: Danil Chapovalov <danilchap@webrtc.org>
Commit-Queue: Sebastian Jansson <srte@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#26040}
This commit is contained in:
Sebastian Jansson 2018-12-17 11:14:11 +01:00 committed by Commit Bot
parent 4415315b52
commit 7d92de69fe
5 changed files with 72 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
modules/congestion_controller/BUILD.gn
View File

@ -41,6 +41,7 @@ rtc_static_library("congestion_controller") {
"../../api/units:data_rate",
"../../api/units:timestamp",
"../../rtc_base:checks",
"../../rtc_base:deprecation",
"../../rtc_base:ptr_util",
"../../rtc_base:rate_limiter",
"../../rtc_base/network:sent_packet",

23
modules/congestion_controller/include/send_side_congestion_controller.h
View File

@ -24,6 +24,7 @@
#include "modules/pacing/paced_sender.h"
#include "rtc_base/constructormagic.h"
#include "rtc_base/criticalsection.h"
#include "rtc_base/deprecation.h"
#include "rtc_base/networkroute.h"
#include "rtc_base/race_checker.h"
@ -41,15 +42,17 @@ class RateLimiter;
class RtcEventLog;
class CongestionWindowPushbackController;
class SendSideCongestionController
// Deprecated, for somewhat similar funtionality GoogCcNetworkController can be
// used via GoogCcNetworkControllerFactory.
class DEPRECATED_SendSideCongestionController
: public SendSideCongestionControllerInterface {
public:
using Observer = NetworkChangedObserver;
SendSideCongestionController(const Clock* clock,
Observer* observer,
RtcEventLog* event_log,
PacedSender* pacer);
~SendSideCongestionController() override;
DEPRECATED_SendSideCongestionController(const Clock* clock,
Observer* observer,
RtcEventLog* event_log,
PacedSender* pacer);
~DEPRECATED_SendSideCongestionController() override;
void RegisterPacketFeedbackObserver(
PacketFeedbackObserver* observer) override;
@ -169,7 +172,13 @@ class SendSideCongestionController
std::unique_ptr<CongestionWindowPushbackController>
congestion_window_pushback_controller_;
RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(SendSideCongestionController);
RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(DEPRECATED_SendSideCongestionController);
};
class RTC_DEPRECATED SendSideCongestionController
: public DEPRECATED_SendSideCongestionController {
public:
using DEPRECATED_SendSideCongestionController::
DEPRECATED_SendSideCongestionController;
};
} // namespace webrtc

96
modules/congestion_controller/send_side_congestion_controller.cc
View File

@ -122,11 +122,11 @@ bool IsPacerPushbackExperimentEnabled() {
} // namespace
SendSideCongestionController::SendSideCongestionController(
const Clock* clock,
Observer* observer,
RtcEventLog* event_log,
PacedSender* pacer)
DEPRECATED_SendSideCongestionController::
DEPRECATED_SendSideCongestionController(const Clock* clock,
Observer* observer,
RtcEventLog* event_log,
PacedSender* pacer)
: clock_(clock),
observer_(observer),
event_log_(event_log),
@ -166,9 +166,10 @@ SendSideCongestionController::SendSideCongestionController(
}
}
SendSideCongestionController::~SendSideCongestionController() {}
DEPRECATED_SendSideCongestionController::
~DEPRECATED_SendSideCongestionController() {}
void SendSideCongestionController::EnableCongestionWindowPushback(
void DEPRECATED_SendSideCongestionController::EnableCongestionWindowPushback(
int64_t accepted_queue_ms,
uint32_t min_pushback_target_bitrate_bps) {
RTC_DCHECK(!congestion_window_pushback_controller_)
@ -185,32 +186,34 @@ void SendSideCongestionController::EnableCongestionWindowPushback(
min_pushback_target_bitrate_bps);
}
void SendSideCongestionController::RegisterPacketFeedbackObserver(
void DEPRECATED_SendSideCongestionController::RegisterPacketFeedbackObserver(
PacketFeedbackObserver* observer) {
transport_feedback_adapter_.RegisterPacketFeedbackObserver(observer);
}
void SendSideCongestionController::DeRegisterPacketFeedbackObserver(
void DEPRECATED_SendSideCongestionController::DeRegisterPacketFeedbackObserver(
PacketFeedbackObserver* observer) {
transport_feedback_adapter_.DeRegisterPacketFeedbackObserver(observer);
}
void SendSideCongestionController::RegisterNetworkObserver(Observer* observer) {
void DEPRECATED_SendSideCongestionController::RegisterNetworkObserver(
Observer* observer) {
rtc::CritScope cs(&observer_lock_);
RTC_DCHECK(observer_ == nullptr);
observer_ = observer;
}
void SendSideCongestionController::DeRegisterNetworkObserver(
void DEPRECATED_SendSideCongestionController::DeRegisterNetworkObserver(
Observer* observer) {
rtc::CritScope cs(&observer_lock_);
RTC_DCHECK_EQ(observer_, observer);
observer_ = nullptr;
}
void SendSideCongestionController::SetBweBitrates(int min_bitrate_bps,
int start_bitrate_bps,
int max_bitrate_bps) {
void DEPRECATED_SendSideCongestionController::SetBweBitrates(
int min_bitrate_bps,
int start_bitrate_bps,
int max_bitrate_bps) {
ClampBitrates(&start_bitrate_bps, &min_bitrate_bps, &max_bitrate_bps);
bitrate_controller_->SetBitrates(start_bitrate_bps, min_bitrate_bps,
max_bitrate_bps);
@ -232,7 +235,7 @@ void SendSideCongestionController::SetBweBitrates(int min_bitrate_bps,
MaybeTriggerOnNetworkChanged();
}
void SendSideCongestionController::SetAllocatedSendBitrateLimits(
void DEPRECATED_SendSideCongestionController::SetAllocatedSendBitrateLimits(
int64_t min_send_bitrate_bps,
int64_t max_padding_bitrate_bps,
int64_t max_total_bitrate_bps) {
@ -245,7 +248,7 @@ void SendSideCongestionController::SetAllocatedSendBitrateLimits(
// TODO(holmer): Split this up and use SetBweBitrates in combination with
// OnNetworkRouteChanged.
void SendSideCongestionController::OnNetworkRouteChanged(
void DEPRECATED_SendSideCongestionController::OnNetworkRouteChanged(
const rtc::NetworkRoute& network_route,
int bitrate_bps,
int min_bitrate_bps,
@ -281,37 +284,41 @@ void SendSideCongestionController::OnNetworkRouteChanged(
MaybeTriggerOnNetworkChanged();
}
bool SendSideCongestionController::AvailableBandwidth(
bool DEPRECATED_SendSideCongestionController::AvailableBandwidth(
uint32_t* bandwidth) const {
return bitrate_controller_->AvailableBandwidth(bandwidth);
}
RtcpBandwidthObserver* SendSideCongestionController::GetBandwidthObserver() {
RtcpBandwidthObserver*
DEPRECATED_SendSideCongestionController::GetBandwidthObserver() {
return bitrate_controller_.get();
}
void SendSideCongestionController::SetPerPacketFeedbackAvailable(
void DEPRECATED_SendSideCongestionController::SetPerPacketFeedbackAvailable(
bool available) {}
void SendSideCongestionController::EnablePeriodicAlrProbing(bool enable) {
void DEPRECATED_SendSideCongestionController::EnablePeriodicAlrProbing(
bool enable) {
rtc::CritScope cs(&probe_lock_);
probe_controller_->EnablePeriodicAlrProbing(enable);
}
int64_t SendSideCongestionController::GetPacerQueuingDelayMs() const {
int64_t DEPRECATED_SendSideCongestionController::GetPacerQueuingDelayMs()
const {
return IsNetworkDown() ? 0 : pacer_->QueueInMs();
}
int64_t SendSideCongestionController::GetFirstPacketTimeMs() const {
int64_t DEPRECATED_SendSideCongestionController::GetFirstPacketTimeMs() const {
return pacer_->FirstSentPacketTimeMs();
}
TransportFeedbackObserver*
SendSideCongestionController::GetTransportFeedbackObserver() {
DEPRECATED_SendSideCongestionController::GetTransportFeedbackObserver() {
return this;
}
void SendSideCongestionController::SignalNetworkState(NetworkState state) {
void DEPRECATED_SendSideCongestionController::SignalNetworkState(
NetworkState state) {
RTC_LOG(LS_INFO) << "SignalNetworkState "
<< (state == kNetworkUp ? "Up" : "Down");
{
@ -330,7 +337,7 @@ void SendSideCongestionController::SignalNetworkState(NetworkState state) {
MaybeTriggerOnNetworkChanged();
}
void SendSideCongestionController::OnSentPacket(
void DEPRECATED_SendSideCongestionController::OnSentPacket(
const rtc::SentPacket& sent_packet) {
// We're not interested in packets without an id, which may be stun packets,
// etc, sent on the same transport.
@ -342,24 +349,24 @@ void SendSideCongestionController::OnSentPacket(
LimitOutstandingBytes(transport_feedback_adapter_.GetOutstandingBytes());
}
void SendSideCongestionController::OnRttUpdate(int64_t avg_rtt_ms,
int64_t max_rtt_ms) {
void DEPRECATED_SendSideCongestionController::OnRttUpdate(int64_t avg_rtt_ms,
int64_t max_rtt_ms) {
rtc::CritScope cs(&bwe_lock_);
delay_based_bwe_->OnRttUpdate(TimeDelta::ms(avg_rtt_ms));
}
int64_t SendSideCongestionController::TimeUntilNextProcess() {
int64_t DEPRECATED_SendSideCongestionController::TimeUntilNextProcess() {
return bitrate_controller_->TimeUntilNextProcess();
}
void SendSideCongestionController::SendProbes(
void DEPRECATED_SendSideCongestionController::SendProbes(
std::vector<ProbeClusterConfig> probe_configs) {
for (auto probe_config : probe_configs) {
pacer_->CreateProbeCluster(probe_config.target_data_rate.bps());
}
}
void SendSideCongestionController::Process() {
void DEPRECATED_SendSideCongestionController::Process() {
bool pause_pacer;
// TODO(holmer): Once this class is running on a task queue we should
// replace this with a task instead.
@ -385,7 +392,7 @@ void SendSideCongestionController::Process() {
MaybeTriggerOnNetworkChanged();
}
void SendSideCongestionController::AddPacket(
void DEPRECATED_SendSideCongestionController::AddPacket(
uint32_t ssrc,
uint16_t sequence_number,
size_t length,
@ -398,7 +405,7 @@ void SendSideCongestionController::AddPacket(
pacing_info);
}
void SendSideCongestionController::OnTransportFeedback(
void DEPRECATED_SendSideCongestionController::OnTransportFeedback(
const rtcp::TransportFeedback& feedback) {
RTC_DCHECK_RUNS_SERIALIZED(&worker_race_);
transport_feedback_adapter_.OnTransportFeedback(feedback);
@ -448,7 +455,7 @@ void SendSideCongestionController::OnTransportFeedback(
}
}
void SendSideCongestionController::LimitOutstandingBytes(
void DEPRECATED_SendSideCongestionController::LimitOutstandingBytes(
size_t num_outstanding_bytes) {
RTC_DCHECK(in_cwnd_experiment_);
rtc::CritScope lock(&network_state_lock_);
@ -474,22 +481,23 @@ void SendSideCongestionController::LimitOutstandingBytes(
}
std::vector<PacketFeedback>
SendSideCongestionController::GetTransportFeedbackVector() const {
DEPRECATED_SendSideCongestionController::GetTransportFeedbackVector() const {
RTC_DCHECK_RUNS_SERIALIZED(&worker_race_);
return transport_feedback_adapter_.GetTransportFeedbackVector();
}
void SendSideCongestionController::SetPacingFactor(float pacing_factor) {
void DEPRECATED_SendSideCongestionController::SetPacingFactor(
float pacing_factor) {
pacer_->SetPacingFactor(pacing_factor);
}
void SendSideCongestionController::SetAllocatedBitrateWithoutFeedback(
uint32_t bitrate_bps) {
void DEPRECATED_SendSideCongestionController::
SetAllocatedBitrateWithoutFeedback(uint32_t bitrate_bps) {
acknowledged_bitrate_estimator_->SetAllocatedBitrateWithoutFeedback(
bitrate_bps);
}
void SendSideCongestionController::MaybeTriggerOnNetworkChanged() {
void DEPRECATED_SendSideCongestionController::MaybeTriggerOnNetworkChanged() {
uint32_t bitrate_bps;
uint8_t fraction_loss;
int64_t rtt;
@ -544,10 +552,10 @@ void SendSideCongestionController::MaybeTriggerOnNetworkChanged() {
}
}
bool SendSideCongestionController::HasNetworkParametersToReportChanged(
uint32_t bitrate_bps,
uint8_t fraction_loss,
int64_t rtt) {
bool DEPRECATED_SendSideCongestionController::
HasNetworkParametersToReportChanged(uint32_t bitrate_bps,
uint8_t fraction_loss,
int64_t rtt) {
rtc::CritScope cs(&network_state_lock_);
bool changed =
last_reported_bitrate_bps_ != bitrate_bps ||
@ -563,11 +571,11 @@ bool SendSideCongestionController::HasNetworkParametersToReportChanged(
return changed;
}
bool SendSideCongestionController::IsSendQueueFull() const {
bool DEPRECATED_SendSideCongestionController::IsSendQueueFull() const {
return pacer_->ExpectedQueueTimeMs() > PacedSender::kMaxQueueLengthMs;
}
bool SendSideCongestionController::IsNetworkDown() const {
bool DEPRECATED_SendSideCongestionController::IsNetworkDown() const {
rtc::CritScope cs(&network_state_lock_);
return network_state_ == kNetworkDown;
}

6
modules/congestion_controller/send_side_congestion_controller_unittest.cc
View File

@ -54,7 +54,7 @@ class LegacySendSideCongestionControllerTest : public ::testing::Test {
void SetUp() override {
pacer_.reset(new NiceMock<MockPacedSender>());
controller_.reset(new SendSideCongestionController(
controller_.reset(new DEPRECATED_SendSideCongestionController(
&clock_, &observer_, &event_log_, pacer_.get()));
bandwidth_observer_ = controller_->GetBandwidthObserver();
@ -71,7 +71,7 @@ class LegacySendSideCongestionControllerTest : public ::testing::Test {
// prescribing on which iterations it must change (like a mock would).
void TargetBitrateTrackingSetup() {
pacer_.reset(new NiceMock<MockPacedSender>());
controller_.reset(new SendSideCongestionController(
controller_.reset(new DEPRECATED_SendSideCongestionController(
&clock_, &target_bitrate_observer_, &event_log_, pacer_.get()));
controller_->SetBweBitrates(0, kInitialBitrateBps, 5 * kInitialBitrateBps);
}
@ -140,7 +140,7 @@ class LegacySendSideCongestionControllerTest : public ::testing::Test {
RtcpBandwidthObserver* bandwidth_observer_;
PacketRouter packet_router_;
std::unique_ptr<NiceMock<MockPacedSender>> pacer_;
std::unique_ptr<SendSideCongestionController> controller_;
std::unique_ptr<DEPRECATED_SendSideCongestionController> controller_;
absl::optional<uint32_t> target_bitrate_bps_;
};

1
video/video_send_stream.h
View File

@ -32,7 +32,6 @@ class VideoSendStreamPeer;
} // namespace test
class CallStats;
class SendSideCongestionController;
class IvfFileWriter;
class ProcessThread;
class RateLimiter;