From 6f4b4fa18b50c49a9722d6fa57c41b98b0414ca7 Mon Sep 17 00:00:00 2001 From: Artem Titov Date: Wed, 28 Jul 2021 20:26:13 +0200 Subject: [PATCH] Use backticks not vertical bars to denote variables in comments for /modules/congestion_controller Bug: webrtc:12338 Change-Id: Id46786886f13266177dd7fa8f1fb30c097df1373 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/227094 Reviewed-by: Harald Alvestrand Commit-Queue: Artem Titov Cr-Commit-Position: refs/heads/master@{#34622} --- .../acknowledged_bitrate_estimator_interface.h | 12 ++++++------ .../goog_cc/delay_based_bwe_unittest_helper.cc | 10 +++++----- .../goog_cc/delay_based_bwe_unittest_helper.h | 8 ++++---- .../goog_cc/inter_arrival_delta.cc | 4 ++-- .../goog_cc/inter_arrival_delta.h | 14 +++++++------- .../goog_cc/probe_bitrate_estimator.cc | 4 ++-- .../goog_cc/probe_bitrate_estimator.h | 2 +- .../goog_cc/probe_controller.cc | 14 +++++++------- .../goog_cc/probe_controller.h | 2 +- .../goog_cc/probe_controller_unittest.cc | 2 +- .../goog_cc/send_side_bandwidth_estimation.h | 6 +++--- .../include/receive_side_congestion_controller.h | 2 +- .../receive_side_congestion_controller_unittest.cc | 6 +++--- modules/congestion_controller/remb_throttler.h | 2 +- 14 files changed, 44 insertions(+), 44 deletions(-) diff --git a/modules/congestion_controller/goog_cc/acknowledged_bitrate_estimator_interface.h b/modules/congestion_controller/goog_cc/acknowledged_bitrate_estimator_interface.h index f802191a2c..b6cee43125 100644 --- a/modules/congestion_controller/goog_cc/acknowledged_bitrate_estimator_interface.h +++ b/modules/congestion_controller/goog_cc/acknowledged_bitrate_estimator_interface.h @@ -34,23 +34,23 @@ struct RobustThroughputEstimatorSettings { // The estimator handles delay spikes by removing the largest receive time // gap, but this introduces some bias that may lead to overestimation when - // there isn't any delay spike. If |reduce_bias| is true, we instead replace + // there isn't any delay spike. If `reduce_bias` is true, we instead replace // the largest receive time gap by the second largest. This reduces the bias // at the cost of not completely removing the genuine delay spikes. bool reduce_bias = true; - // If |assume_shared_link| is false, we ignore the size of the first packet + // If `assume_shared_link` is false, we ignore the size of the first packet // when computing the receive rate. Otherwise, we remove half of the first // and last packet's sizes. bool assume_shared_link = false; - // The estimator window keeps at least |min_packets| packets and up to - // kMaxPackets received during the last |window_duration|. + // The estimator window keeps at least `min_packets` packets and up to + // kMaxPackets received during the last `window_duration`. unsigned min_packets = 20; TimeDelta window_duration = TimeDelta::Millis(500); - // The estimator window requires at least |initial_packets| packets received - // over at least |initial_duration|. + // The estimator window requires at least `initial_packets` packets received + // over at least `initial_duration`. unsigned initial_packets = 20; // If audio packets are included in allocation, but not in bandwidth diff --git a/modules/congestion_controller/goog_cc/delay_based_bwe_unittest_helper.cc b/modules/congestion_controller/goog_cc/delay_based_bwe_unittest_helper.cc index 946805ab8a..4c72277aa8 100644 --- a/modules/congestion_controller/goog_cc/delay_based_bwe_unittest_helper.cc +++ b/modules/congestion_controller/goog_cc/delay_based_bwe_unittest_helper.cc @@ -96,7 +96,7 @@ void StreamGenerator::set_capacity_bps(int capacity_bps) { capacity_ = capacity_bps; } -// Divides |bitrate_bps| among all streams. The allocated bitrate per stream +// Divides `bitrate_bps` among all streams. The allocated bitrate per stream // is decided by the current allocation ratios. void StreamGenerator::SetBitrateBps(int bitrate_bps) { ASSERT_GE(streams_.size(), 0u); @@ -253,8 +253,8 @@ bool DelayBasedBweTest::GenerateAndProcessFrame(uint32_t ssrc, return overuse; } -// Run the bandwidth estimator with a stream of |number_of_frames| frames, or -// until it reaches |target_bitrate|. +// Run the bandwidth estimator with a stream of `number_of_frames` frames, or +// until it reaches `target_bitrate`. // Can for instance be used to run the estimator for some time to get it // into a steady state. uint32_t DelayBasedBweTest::SteadyStateRun(uint32_t ssrc, @@ -265,7 +265,7 @@ uint32_t DelayBasedBweTest::SteadyStateRun(uint32_t ssrc, uint32_t target_bitrate) { uint32_t bitrate_bps = start_bitrate; bool bitrate_update_seen = false; - // Produce |number_of_frames| frames and give them to the estimator. + // Produce `number_of_frames` frames and give them to the estimator. for (int i = 0; i < max_number_of_frames; ++i) { bool overuse = GenerateAndProcessFrame(ssrc, bitrate_bps); if (overuse) { @@ -476,7 +476,7 @@ void DelayBasedBweTest::TestTimestampGroupingTestHelper() { const int kTimestampGroupLength = 15; for (int i = 0; i < 100; ++i) { for (int j = 0; j < kTimestampGroupLength; ++j) { - // Insert |kTimestampGroupLength| frames with just 1 timestamp ticks in + // Insert `kTimestampGroupLength` frames with just 1 timestamp ticks in // between. Should be treated as part of the same group by the estimator. IncomingFeedback(clock_.TimeInMilliseconds(), send_time_ms, 100); clock_.AdvanceTimeMilliseconds(kFrameIntervalMs / kTimestampGroupLength); diff --git a/modules/congestion_controller/goog_cc/delay_based_bwe_unittest_helper.h b/modules/congestion_controller/goog_cc/delay_based_bwe_unittest_helper.h index 24e558c2d7..5fb048b7a4 100644 --- a/modules/congestion_controller/goog_cc/delay_based_bwe_unittest_helper.h +++ b/modules/congestion_controller/goog_cc/delay_based_bwe_unittest_helper.h @@ -89,11 +89,11 @@ class StreamGenerator { // Set the link capacity. void set_capacity_bps(int capacity_bps); - // Divides |bitrate_bps| among all streams. The allocated bitrate per stream + // Divides `bitrate_bps` among all streams. The allocated bitrate per stream // is decided by the initial allocation ratios. void SetBitrateBps(int bitrate_bps); - // Set the RTP timestamp offset for the stream identified by |ssrc|. + // Set the RTP timestamp offset for the stream identified by `ssrc`. void set_rtp_timestamp_offset(uint32_t ssrc, uint32_t offset); // TODO(holmer): Break out the channel simulation part from this class to make @@ -138,8 +138,8 @@ class DelayBasedBweTest : public ::testing::TestWithParam { // target bitrate after the call to this function. bool GenerateAndProcessFrame(uint32_t ssrc, uint32_t bitrate_bps); - // Run the bandwidth estimator with a stream of |number_of_frames| frames, or - // until it reaches |target_bitrate|. + // Run the bandwidth estimator with a stream of `number_of_frames` frames, or + // until it reaches `target_bitrate`. // Can for instance be used to run the estimator for some time to get it // into a steady state. uint32_t SteadyStateRun(uint32_t ssrc, diff --git a/modules/congestion_controller/goog_cc/inter_arrival_delta.cc b/modules/congestion_controller/goog_cc/inter_arrival_delta.cc index 791867db67..ecd5742272 100644 --- a/modules/congestion_controller/goog_cc/inter_arrival_delta.cc +++ b/modules/congestion_controller/goog_cc/inter_arrival_delta.cc @@ -102,8 +102,8 @@ bool InterArrivalDelta::ComputeDeltas(Timestamp send_time, return calculated_deltas; } -// Assumes that |timestamp| is not reordered compared to -// |current_timestamp_group_|. +// Assumes that `timestamp` is not reordered compared to +// `current_timestamp_group_`. bool InterArrivalDelta::NewTimestampGroup(Timestamp arrival_time, Timestamp send_time) const { if (current_timestamp_group_.IsFirstPacket()) { diff --git a/modules/congestion_controller/goog_cc/inter_arrival_delta.h b/modules/congestion_controller/goog_cc/inter_arrival_delta.h index 28dc806249..0617e34cdd 100644 --- a/modules/congestion_controller/goog_cc/inter_arrival_delta.h +++ b/modules/congestion_controller/goog_cc/inter_arrival_delta.h @@ -38,12 +38,12 @@ class InterArrivalDelta { // This function returns true if a delta was computed, or false if the current // group is still incomplete or if only one group has been completed. - // |send_time| is the send time. - // |arrival_time| is the time at which the packet arrived. - // |packet_size| is the size of the packet. - // |timestamp_delta| (output) is the computed send time delta. - // |arrival_time_delta_ms| (output) is the computed arrival-time delta. - // |packet_size_delta| (output) is the computed size delta. + // `send_time` is the send time. + // `arrival_time` is the time at which the packet arrived. + // `packet_size` is the size of the packet. + // `timestamp_delta` (output) is the computed send time delta. + // `arrival_time_delta_ms` (output) is the computed arrival-time delta. + // `packet_size_delta` (output) is the computed size delta. bool ComputeDeltas(Timestamp send_time, Timestamp arrival_time, Timestamp system_time, @@ -73,7 +73,7 @@ class InterArrivalDelta { }; // Returns true if the last packet was the end of the current batch and the - // packet with |send_time| is the first of a new batch. + // packet with `send_time` is the first of a new batch. bool NewTimestampGroup(Timestamp arrival_time, Timestamp send_time) const; bool BelongsToBurst(Timestamp arrival_time, Timestamp send_time) const; diff --git a/modules/congestion_controller/goog_cc/probe_bitrate_estimator.cc b/modules/congestion_controller/goog_cc/probe_bitrate_estimator.cc index fdfd531135..a94f653157 100644 --- a/modules/congestion_controller/goog_cc/probe_bitrate_estimator.cc +++ b/modules/congestion_controller/goog_cc/probe_bitrate_estimator.cc @@ -119,14 +119,14 @@ absl::optional ProbeBitrateEstimator::HandleProbeAndEstimateBitrate( } return absl::nullopt; } - // Since the |send_interval| does not include the time it takes to actually + // Since the `send_interval` does not include the time it takes to actually // send the last packet the size of the last sent packet should not be // included when calculating the send bitrate. RTC_DCHECK_GT(cluster->size_total, cluster->size_last_send); DataSize send_size = cluster->size_total - cluster->size_last_send; DataRate send_rate = send_size / send_interval; - // Since the |receive_interval| does not include the time it takes to + // Since the `receive_interval` does not include the time it takes to // actually receive the first packet the size of the first received packet // should not be included when calculating the receive bitrate. RTC_DCHECK_GT(cluster->size_total, cluster->size_first_receive); diff --git a/modules/congestion_controller/goog_cc/probe_bitrate_estimator.h b/modules/congestion_controller/goog_cc/probe_bitrate_estimator.h index 9f2f438ad9..d5a523b7f3 100644 --- a/modules/congestion_controller/goog_cc/probe_bitrate_estimator.h +++ b/modules/congestion_controller/goog_cc/probe_bitrate_estimator.h @@ -45,7 +45,7 @@ class ProbeBitrateEstimator { DataSize size_total = DataSize::Zero(); }; - // Erases old cluster data that was seen before |timestamp|. + // Erases old cluster data that was seen before `timestamp`. void EraseOldClusters(Timestamp timestamp); std::map clusters_; diff --git a/modules/congestion_controller/goog_cc/probe_controller.cc b/modules/congestion_controller/goog_cc/probe_controller.cc index 29b472a873..cb75456fde 100644 --- a/modules/congestion_controller/goog_cc/probe_controller.cc +++ b/modules/congestion_controller/goog_cc/probe_controller.cc @@ -38,7 +38,7 @@ constexpr int kMinProbeDurationMs = 15; // the measured results back. constexpr int64_t kMaxWaitingTimeForProbingResultMs = 1000; -// Value of |min_bitrate_to_probe_further_bps_| that indicates +// Value of `min_bitrate_to_probe_further_bps_` that indicates // further probing is disabled. constexpr int kExponentialProbingDisabled = 0; @@ -46,16 +46,16 @@ constexpr int kExponentialProbingDisabled = 0; // specify max bitrate. constexpr int64_t kDefaultMaxProbingBitrateBps = 5000000; -// If the bitrate drops to a factor |kBitrateDropThreshold| or lower -// and we recover within |kBitrateDropTimeoutMs|, then we'll send -// a probe at a fraction |kProbeFractionAfterDrop| of the original bitrate. +// If the bitrate drops to a factor `kBitrateDropThreshold` or lower +// and we recover within `kBitrateDropTimeoutMs`, then we'll send +// a probe at a fraction `kProbeFractionAfterDrop` of the original bitrate. constexpr double kBitrateDropThreshold = 0.66; constexpr int kBitrateDropTimeoutMs = 5000; constexpr double kProbeFractionAfterDrop = 0.85; // Timeout for probing after leaving ALR. If the bitrate drops significantly, // (as determined by the delay based estimator) and we leave ALR, then we will -// send a probe if we recover within |kLeftAlrTimeoutMs| ms. +// send a probe if we recover within `kLeftAlrTimeoutMs` ms. constexpr int kAlrEndedTimeoutMs = 3000; // The expected uncertainty of probe result (as a fraction of the target probe @@ -155,8 +155,8 @@ std::vector ProbeController::SetBitrates( start_bitrate_bps_ = min_bitrate_bps; } - // The reason we use the variable |old_max_bitrate_pbs| is because we - // need to set |max_bitrate_bps_| before we call InitiateProbing. + // The reason we use the variable `old_max_bitrate_pbs` is because we + // need to set `max_bitrate_bps_` before we call InitiateProbing. int64_t old_max_bitrate_bps = max_bitrate_bps_; max_bitrate_bps_ = max_bitrate_bps; diff --git a/modules/congestion_controller/goog_cc/probe_controller.h b/modules/congestion_controller/goog_cc/probe_controller.h index bcaa293209..7f24ff98c8 100644 --- a/modules/congestion_controller/goog_cc/probe_controller.h +++ b/modules/congestion_controller/goog_cc/probe_controller.h @@ -94,7 +94,7 @@ class ProbeController { void SetMaxBitrate(int64_t max_bitrate_bps); // Resets the ProbeController to a state equivalent to as if it was just - // created EXCEPT for |enable_periodic_alr_probing_|. + // created EXCEPT for `enable_periodic_alr_probing_`. void Reset(int64_t at_time_ms); ABSL_MUST_USE_RESULT std::vector Process( diff --git a/modules/congestion_controller/goog_cc/probe_controller_unittest.cc b/modules/congestion_controller/goog_cc/probe_controller_unittest.cc index e27bf71489..4e9144f54c 100644 --- a/modules/congestion_controller/goog_cc/probe_controller_unittest.cc +++ b/modules/congestion_controller/goog_cc/probe_controller_unittest.cc @@ -279,7 +279,7 @@ TEST_F(ProbeControllerTest, PeriodicProbingAfterReset) { kMaxBitrateBps, NowMs()); EXPECT_EQ(probes.size(), 2u); - // Make sure we use |kStartBitrateBps| as the estimated bitrate + // Make sure we use `kStartBitrateBps` as the estimated bitrate // until SetEstimatedBitrate is called with an updated estimate. clock_.AdvanceTimeMilliseconds(10000); probes = probe_controller_->Process(NowMs()); diff --git a/modules/congestion_controller/goog_cc/send_side_bandwidth_estimation.h b/modules/congestion_controller/goog_cc/send_side_bandwidth_estimation.h index b97b940db0..5917d9b271 100644 --- a/modules/congestion_controller/goog_cc/send_side_bandwidth_estimation.h +++ b/modules/congestion_controller/goog_cc/send_side_bandwidth_estimation.h @@ -134,15 +134,15 @@ class SendSideBandwidthEstimation { // Gets the upper limit for the target bitrate. This is the minimum of the // delay based limit, the receiver limit and the loss based controller limit. DataRate GetUpperLimit() const; - // Prints a warning if |bitrate| if sufficiently long time has past since last + // Prints a warning if `bitrate` if sufficiently long time has past since last // warning. void MaybeLogLowBitrateWarning(DataRate bitrate, Timestamp at_time); // Stores an update to the event log if the loss rate has changed, the target // has changed, or sufficient time has passed since last stored event. void MaybeLogLossBasedEvent(Timestamp at_time); - // Cap |bitrate| to [min_bitrate_configured_, max_bitrate_configured_] and - // set |current_bitrate_| to the capped value and updates the event log. + // Cap `bitrate` to [min_bitrate_configured_, max_bitrate_configured_] and + // set `current_bitrate_` to the capped value and updates the event log. void UpdateTargetBitrate(DataRate bitrate, Timestamp at_time); // Applies lower and upper bounds to the current target rate. // TODO(srte): This seems to be called even when limits haven't changed, that diff --git a/modules/congestion_controller/include/receive_side_congestion_controller.h b/modules/congestion_controller/include/receive_side_congestion_controller.h index 84661c05b7..fdef7f95c8 100644 --- a/modules/congestion_controller/include/receive_side_congestion_controller.h +++ b/modules/congestion_controller/include/receive_side_congestion_controller.h @@ -60,7 +60,7 @@ class ReceiveSideCongestionController : public CallStatsObserver, void OnBitrateChanged(int bitrate_bps); // Ensures the remote party is notified of the receive bitrate no larger than - // |bitrate| using RTCP REMB. + // `bitrate` using RTCP REMB. void SetMaxDesiredReceiveBitrate(DataRate bitrate); // Implements Module. diff --git a/modules/congestion_controller/receive_side_congestion_controller_unittest.cc b/modules/congestion_controller/receive_side_congestion_controller_unittest.cc index 5e03179f42..2aade06cbc 100644 --- a/modules/congestion_controller/receive_side_congestion_controller_unittest.cc +++ b/modules/congestion_controller/receive_side_congestion_controller_unittest.cc @@ -28,9 +28,9 @@ namespace webrtc { namespace { // Helper to convert some time format to resolution used in absolute send time -// header extension, rounded upwards. |t| is the time to convert, in some -// resolution. |denom| is the value to divide |t| by to get whole seconds, -// e.g. |denom| = 1000 if |t| is in milliseconds. +// header extension, rounded upwards. `t` is the time to convert, in some +// resolution. `denom` is the value to divide `t` by to get whole seconds, +// e.g. `denom` = 1000 if `t` is in milliseconds. uint32_t AbsSendTime(int64_t t, int64_t denom) { return (((t << 18) + (denom >> 1)) / denom) & 0x00fffffful; } diff --git a/modules/congestion_controller/remb_throttler.h b/modules/congestion_controller/remb_throttler.h index 67c0280749..2f610c1df9 100644 --- a/modules/congestion_controller/remb_throttler.h +++ b/modules/congestion_controller/remb_throttler.h @@ -30,7 +30,7 @@ class RembThrottler : public RemoteBitrateObserver { RembThrottler(RembSender remb_sender, Clock* clock); // Ensures the remote party is notified of the receive bitrate no larger than - // |bitrate| using RTCP REMB. + // `bitrate` using RTCP REMB. void SetMaxDesiredReceiveBitrate(DataRate bitrate); // Implements RemoteBitrateObserver;