clang-format QUICHE
Run clang-format on *.h and *.cc file in QUICHE.
Tested:
TAP train for global presubmit queue
http://test/OCL:441019819:BASE:441135378:1649787842683:cfba1c11
PiperOrigin-RevId: 441276183
diff --git a/quiche/quic/core/congestion_control/bandwidth_sampler.cc b/quiche/quic/core/congestion_control/bandwidth_sampler.cc
index 1a8a591..e216d09 100644
--- a/quiche/quic/core/congestion_control/bandwidth_sampler.cc
+++ b/quiche/quic/core/congestion_control/bandwidth_sampler.cc
@@ -188,9 +188,7 @@
BandwidthSampler::~BandwidthSampler() {}
void BandwidthSampler::OnPacketSent(
- QuicTime sent_time,
- QuicPacketNumber packet_number,
- QuicByteCount bytes,
+ QuicTime sent_time, QuicPacketNumber packet_number, QuicByteCount bytes,
QuicByteCount bytes_in_flight,
HasRetransmittableData has_retransmittable_data) {
last_sent_packet_ = packet_number;
@@ -381,8 +379,7 @@
}
BandwidthSample BandwidthSampler::OnPacketAcknowledged(
- QuicTime ack_time,
- QuicPacketNumber packet_number) {
+ QuicTime ack_time, QuicPacketNumber packet_number) {
last_acked_packet_ = packet_number;
ConnectionStateOnSentPacket* sent_packet_pointer =
connection_state_map_.GetEntry(packet_number);
@@ -396,8 +393,7 @@
}
BandwidthSample BandwidthSampler::OnPacketAcknowledgedInner(
- QuicTime ack_time,
- QuicPacketNumber packet_number,
+ QuicTime ack_time, QuicPacketNumber packet_number,
const ConnectionStateOnSentPacket& sent_packet) {
total_bytes_acked_ += sent_packet.size;
total_bytes_sent_at_last_acked_packet_ =
@@ -578,9 +574,7 @@
return total_bytes_neutered_;
}
-bool BandwidthSampler::is_app_limited() const {
- return is_app_limited_;
-}
+bool BandwidthSampler::is_app_limited() const { return is_app_limited_; }
QuicPacketNumber BandwidthSampler::end_of_app_limited_phase() const {
return end_of_app_limited_phase_;
diff --git a/quiche/quic/core/congestion_control/bandwidth_sampler.h b/quiche/quic/core/congestion_control/bandwidth_sampler.h
index 56a3bab..75851e9 100644
--- a/quiche/quic/core/congestion_control/bandwidth_sampler.h
+++ b/quiche/quic/core/congestion_control/bandwidth_sampler.h
@@ -35,10 +35,8 @@
total_bytes_lost(0),
bytes_in_flight(0) {}
- SendTimeState(bool is_app_limited,
- QuicByteCount total_bytes_sent,
- QuicByteCount total_bytes_acked,
- QuicByteCount total_bytes_lost,
+ SendTimeState(bool is_app_limited, QuicByteCount total_bytes_sent,
+ QuicByteCount total_bytes_acked, QuicByteCount total_bytes_lost,
QuicByteCount bytes_in_flight)
: is_valid(true),
is_app_limited(is_app_limited),
@@ -195,9 +193,7 @@
// released from the sampler until it the packet is either acknowledged or
// declared lost.
virtual void OnPacketSent(
- QuicTime sent_time,
- QuicPacketNumber packet_number,
- QuicByteCount bytes,
+ QuicTime sent_time, QuicPacketNumber packet_number, QuicByteCount bytes,
QuicByteCount bytes_in_flight,
HasRetransmittableData has_retransmittable_data) = 0;
@@ -231,10 +227,8 @@
// |est_bandwidth_upper_bound| is an upper bound of estimated bandwidth used
// to calculate extra_acked.
virtual CongestionEventSample OnCongestionEvent(
- QuicTime ack_time,
- const AckedPacketVector& acked_packets,
- const LostPacketVector& lost_packets,
- QuicBandwidth max_bandwidth,
+ QuicTime ack_time, const AckedPacketVector& acked_packets,
+ const LostPacketVector& lost_packets, QuicBandwidth max_bandwidth,
QuicBandwidth est_bandwidth_upper_bound,
QuicRoundTripCount round_trip_count) = 0;
@@ -348,18 +342,14 @@
BandwidthSampler(const BandwidthSampler& other);
~BandwidthSampler() override;
- void OnPacketSent(QuicTime sent_time,
- QuicPacketNumber packet_number,
- QuicByteCount bytes,
- QuicByteCount bytes_in_flight,
+ void OnPacketSent(QuicTime sent_time, QuicPacketNumber packet_number,
+ QuicByteCount bytes, QuicByteCount bytes_in_flight,
HasRetransmittableData has_retransmittable_data) override;
void OnPacketNeutered(QuicPacketNumber packet_number) override;
CongestionEventSample OnCongestionEvent(
- QuicTime ack_time,
- const AckedPacketVector& acked_packets,
- const LostPacketVector& lost_packets,
- QuicBandwidth max_bandwidth,
+ QuicTime ack_time, const AckedPacketVector& acked_packets,
+ const LostPacketVector& lost_packets, QuicBandwidth max_bandwidth,
QuicBandwidth est_bandwidth_upper_bound,
QuicRoundTripCount round_trip_count) override;
QuicByteCount OnAckEventEnd(QuicBandwidth bandwidth_estimate,
@@ -490,8 +480,7 @@
// Snapshot constructor. Records the current state of the bandwidth
// sampler.
// |bytes_in_flight| is the bytes in flight right after the packet is sent.
- ConnectionStateOnSentPacket(QuicTime sent_time,
- QuicByteCount size,
+ ConnectionStateOnSentPacket(QuicTime sent_time, QuicByteCount size,
QuicByteCount bytes_in_flight,
const BandwidthSampler& sampler)
: sent_time(sent_time),
@@ -500,10 +489,8 @@
sampler.total_bytes_sent_at_last_acked_packet_),
last_acked_packet_sent_time(sampler.last_acked_packet_sent_time_),
last_acked_packet_ack_time(sampler.last_acked_packet_ack_time_),
- send_time_state(sampler.is_app_limited_,
- sampler.total_bytes_sent_,
- sampler.total_bytes_acked_,
- sampler.total_bytes_lost_,
+ send_time_state(sampler.is_app_limited_, sampler.total_bytes_sent_,
+ sampler.total_bytes_acked_, sampler.total_bytes_lost_,
bytes_in_flight) {}
// Default constructor. Required to put this structure into
@@ -516,8 +503,7 @@
last_acked_packet_ack_time(QuicTime::Zero()) {}
friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(
- std::ostream& os,
- const ConnectionStateOnSentPacket& p) {
+ std::ostream& os, const ConnectionStateOnSentPacket& p) {
os << "{sent_time:" << p.sent_time << ", size:" << p.size
<< ", total_bytes_sent_at_last_acked_packet:"
<< p.total_bytes_sent_at_last_acked_packet
@@ -608,8 +594,7 @@
// Handles the actual bandwidth calculations, whereas the outer method handles
// retrieving and removing |sent_packet|.
BandwidthSample OnPacketAcknowledgedInner(
- QuicTime ack_time,
- QuicPacketNumber packet_number,
+ QuicTime ack_time, QuicPacketNumber packet_number,
const ConnectionStateOnSentPacket& sent_packet);
MaxAckHeightTracker max_ack_height_tracker_;
diff --git a/quiche/quic/core/congestion_control/bandwidth_sampler_test.cc b/quiche/quic/core/congestion_control/bandwidth_sampler_test.cc
index 6089232..97a0bf3 100644
--- a/quiche/quic/core/congestion_control/bandwidth_sampler_test.cc
+++ b/quiche/quic/core/congestion_control/bandwidth_sampler_test.cc
@@ -3,6 +3,7 @@
// found in the LICENSE file.
#include "quiche/quic/core/congestion_control/bandwidth_sampler.h"
+
#include <cstdint>
#include <set>
@@ -73,8 +74,7 @@
return packet_count * kRegularPacketSize;
}
- void SendPacketInner(uint64_t packet_number,
- QuicByteCount bytes,
+ void SendPacketInner(uint64_t packet_number, QuicByteCount bytes,
HasRetransmittableData has_retransmittable_data) {
sampler_.OnPacketSent(clock_.Now(), QuicPacketNumber(packet_number), bytes,
bytes_in_flight_, has_retransmittable_data);
@@ -180,8 +180,7 @@
};
INSTANTIATE_TEST_SUITE_P(
- BandwidthSamplerTests,
- BandwidthSamplerTest,
+ BandwidthSamplerTests, BandwidthSamplerTest,
testing::Values(TestParameters{/*overestimate_avoidance=*/false},
TestParameters{/*overestimate_avoidance=*/true}),
testing::PrintToStringParamName());
diff --git a/quiche/quic/core/congestion_control/bbr2_drain.cc b/quiche/quic/core/congestion_control/bbr2_drain.cc
index 6fb9c94..c13e9d8 100644
--- a/quiche/quic/core/congestion_control/bbr2_drain.cc
+++ b/quiche/quic/core/congestion_control/bbr2_drain.cc
@@ -10,8 +10,7 @@
namespace quic {
Bbr2Mode Bbr2DrainMode::OnCongestionEvent(
- QuicByteCount /*prior_in_flight*/,
- QuicTime /*event_time*/,
+ QuicByteCount /*prior_in_flight*/, QuicTime /*event_time*/,
const AckedPacketVector& /*acked_packets*/,
const LostPacketVector& /*lost_packets*/,
const Bbr2CongestionEvent& congestion_event) {
@@ -55,8 +54,6 @@
return os;
}
-const Bbr2Params& Bbr2DrainMode::Params() const {
- return sender_->Params();
-}
+const Bbr2Params& Bbr2DrainMode::Params() const { return sender_->Params(); }
} // namespace quic
diff --git a/quiche/quic/core/congestion_control/bbr2_drain.h b/quiche/quic/core/congestion_control/bbr2_drain.h
index 418035c..1d61a41 100644
--- a/quiche/quic/core/congestion_control/bbr2_drain.h
+++ b/quiche/quic/core/congestion_control/bbr2_drain.h
@@ -23,8 +23,7 @@
const Bbr2CongestionEvent* /*congestion_event*/) override {}
Bbr2Mode OnCongestionEvent(
- QuicByteCount prior_in_flight,
- QuicTime event_time,
+ QuicByteCount prior_in_flight, QuicTime event_time,
const AckedPacketVector& acked_packets,
const LostPacketVector& lost_packets,
const Bbr2CongestionEvent& congestion_event) override;
@@ -53,8 +52,7 @@
};
QUIC_EXPORT_PRIVATE std::ostream& operator<<(
- std::ostream& os,
- const Bbr2DrainMode::DebugState& state);
+ std::ostream& os, const Bbr2DrainMode::DebugState& state);
} // namespace quic
diff --git a/quiche/quic/core/congestion_control/bbr2_misc.cc b/quiche/quic/core/congestion_control/bbr2_misc.cc
index a912d5a..bd0851a 100644
--- a/quiche/quic/core/congestion_control/bbr2_misc.cc
+++ b/quiche/quic/core/congestion_control/bbr2_misc.cc
@@ -56,8 +56,7 @@
Bbr2NetworkModel::Bbr2NetworkModel(const Bbr2Params* params,
QuicTime::Delta initial_rtt,
QuicTime initial_rtt_timestamp,
- float cwnd_gain,
- float pacing_gain,
+ float cwnd_gain, float pacing_gain,
const BandwidthSampler* old_sampler)
: params_(params),
bandwidth_sampler_([](QuicRoundTripCount max_height_tracker_window_length,
@@ -84,8 +83,7 @@
}
void Bbr2NetworkModel::OnCongestionEventStart(
- QuicTime event_time,
- const AckedPacketVector& acked_packets,
+ QuicTime event_time, const AckedPacketVector& acked_packets,
const LostPacketVector& lost_packets,
Bbr2CongestionEvent* congestion_event) {
const QuicByteCount prior_bytes_acked = total_bytes_acked();
diff --git a/quiche/quic/core/congestion_control/bbr2_misc.h b/quiche/quic/core/congestion_control/bbr2_misc.h
index a7efaed..cbfc2bd 100644
--- a/quiche/quic/core/congestion_control/bbr2_misc.h
+++ b/quiche/quic/core/congestion_control/bbr2_misc.h
@@ -339,17 +339,12 @@
// bandwidth_(hi|lo), bandwidth and rtt estimates, etc.
class QUIC_EXPORT_PRIVATE Bbr2NetworkModel {
public:
- Bbr2NetworkModel(const Bbr2Params* params,
- QuicTime::Delta initial_rtt,
- QuicTime initial_rtt_timestamp,
- float cwnd_gain,
- float pacing_gain,
- const BandwidthSampler* old_sampler);
+ Bbr2NetworkModel(const Bbr2Params* params, QuicTime::Delta initial_rtt,
+ QuicTime initial_rtt_timestamp, float cwnd_gain,
+ float pacing_gain, const BandwidthSampler* old_sampler);
- void OnPacketSent(QuicTime sent_time,
- QuicByteCount bytes_in_flight,
- QuicPacketNumber packet_number,
- QuicByteCount bytes,
+ void OnPacketSent(QuicTime sent_time, QuicByteCount bytes_in_flight,
+ QuicPacketNumber packet_number, QuicByteCount bytes,
HasRetransmittableData is_retransmittable);
void OnCongestionEventStart(QuicTime event_time,
@@ -641,8 +636,7 @@
const Bbr2CongestionEvent* congestion_event) = 0;
virtual Bbr2Mode OnCongestionEvent(
- QuicByteCount prior_in_flight,
- QuicTime event_time,
+ QuicByteCount prior_in_flight, QuicTime event_time,
const AckedPacketVector& acked_packets,
const LostPacketVector& lost_packets,
const Bbr2CongestionEvent& congestion_event) = 0;
diff --git a/quiche/quic/core/congestion_control/bbr2_probe_bw.h b/quiche/quic/core/congestion_control/bbr2_probe_bw.h
index 972e2ba..7a2448d 100644
--- a/quiche/quic/core/congestion_control/bbr2_probe_bw.h
+++ b/quiche/quic/core/congestion_control/bbr2_probe_bw.h
@@ -26,8 +26,7 @@
const Bbr2CongestionEvent* /*congestion_event*/) override {}
Bbr2Mode OnCongestionEvent(
- QuicByteCount prior_in_flight,
- QuicTime event_time,
+ QuicByteCount prior_in_flight, QuicTime event_time,
const AckedPacketVector& acked_packets,
const LostPacketVector& lost_packets,
const Bbr2CongestionEvent& congestion_event) override;
@@ -80,8 +79,7 @@
AdaptUpperBoundsResult MaybeAdaptUpperBounds(
const Bbr2CongestionEvent& congestion_event);
- void EnterProbeDown(bool probed_too_high,
- bool stopped_risky_probe,
+ void EnterProbeDown(bool probed_too_high, bool stopped_risky_probe,
QuicTime now);
void EnterProbeCruise(QuicTime now);
void EnterProbeRefill(uint64_t probe_up_rounds, QuicTime now);
@@ -130,12 +128,10 @@
};
QUIC_EXPORT_PRIVATE std::ostream& operator<<(
- std::ostream& os,
- const Bbr2ProbeBwMode::DebugState& state);
+ std::ostream& os, const Bbr2ProbeBwMode::DebugState& state);
QUIC_EXPORT_PRIVATE std::ostream& operator<<(
- std::ostream& os,
- const Bbr2ProbeBwMode::CyclePhase phase);
+ std::ostream& os, const Bbr2ProbeBwMode::CyclePhase phase);
} // namespace quic
diff --git a/quiche/quic/core/congestion_control/bbr2_probe_rtt.cc b/quiche/quic/core/congestion_control/bbr2_probe_rtt.cc
index ef5b775..f425fd4 100644
--- a/quiche/quic/core/congestion_control/bbr2_probe_rtt.cc
+++ b/quiche/quic/core/congestion_control/bbr2_probe_rtt.cc
@@ -18,8 +18,7 @@
}
Bbr2Mode Bbr2ProbeRttMode::OnCongestionEvent(
- QuicByteCount /*prior_in_flight*/,
- QuicTime /*event_time*/,
+ QuicByteCount /*prior_in_flight*/, QuicTime /*event_time*/,
const AckedPacketVector& /*acked_packets*/,
const LostPacketVector& /*lost_packets*/,
const Bbr2CongestionEvent& congestion_event) {
@@ -54,8 +53,7 @@
}
Bbr2Mode Bbr2ProbeRttMode::OnExitQuiescence(
- QuicTime now,
- QuicTime /*quiescence_start_time*/) {
+ QuicTime now, QuicTime /*quiescence_start_time*/) {
if (now > exit_time_) {
return Bbr2Mode::PROBE_BW;
}
@@ -76,8 +74,6 @@
return os;
}
-const Bbr2Params& Bbr2ProbeRttMode::Params() const {
- return sender_->Params();
-}
+const Bbr2Params& Bbr2ProbeRttMode::Params() const { return sender_->Params(); }
} // namespace quic
diff --git a/quiche/quic/core/congestion_control/bbr2_probe_rtt.h b/quiche/quic/core/congestion_control/bbr2_probe_rtt.h
index 1640c28..a6edbb3 100644
--- a/quiche/quic/core/congestion_control/bbr2_probe_rtt.h
+++ b/quiche/quic/core/congestion_control/bbr2_probe_rtt.h
@@ -23,8 +23,7 @@
const Bbr2CongestionEvent* /*congestion_event*/) override {}
Bbr2Mode OnCongestionEvent(
- QuicByteCount prior_in_flight,
- QuicTime event_time,
+ QuicByteCount prior_in_flight, QuicTime event_time,
const AckedPacketVector& acked_packets,
const LostPacketVector& lost_packets,
const Bbr2CongestionEvent& congestion_event) override;
@@ -52,8 +51,7 @@
};
QUIC_EXPORT_PRIVATE std::ostream& operator<<(
- std::ostream& os,
- const Bbr2ProbeRttMode::DebugState& state);
+ std::ostream& os, const Bbr2ProbeRttMode::DebugState& state);
} // namespace quic
diff --git a/quiche/quic/core/congestion_control/bbr2_sender.cc b/quiche/quic/core/congestion_control/bbr2_sender.cc
index 6c40e85..71b8f12 100644
--- a/quiche/quic/core/congestion_control/bbr2_sender.cc
+++ b/quiche/quic/core/congestion_control/bbr2_sender.cc
@@ -55,14 +55,11 @@
? (drain_.member_function_call) \
: (probe_rtt_or_die().member_function_call))))
-Bbr2Sender::Bbr2Sender(QuicTime now,
- const RttStats* rtt_stats,
+Bbr2Sender::Bbr2Sender(QuicTime now, const RttStats* rtt_stats,
const QuicUnackedPacketMap* unacked_packets,
QuicPacketCount initial_cwnd_in_packets,
- QuicPacketCount max_cwnd_in_packets,
- QuicRandom* random,
- QuicConnectionStats* stats,
- BbrSender* old_sender)
+ QuicPacketCount max_cwnd_in_packets, QuicRandom* random,
+ QuicConnectionStats* stats, BbrSender* old_sender)
: mode_(Bbr2Mode::STARTUP),
rtt_stats_(rtt_stats),
unacked_packets_(unacked_packets),
@@ -70,8 +67,7 @@
connection_stats_(stats),
params_(kDefaultMinimumCongestionWindow,
max_cwnd_in_packets * kDefaultTCPMSS),
- model_(¶ms_,
- rtt_stats->SmoothedOrInitialRtt(),
+ model_(¶ms_, rtt_stats->SmoothedOrInitialRtt(),
rtt_stats->last_update_time(),
/*cwnd_gain=*/1.0,
/*pacing_gain=*/kInitialPacingGain,
@@ -80,9 +76,9 @@
(old_sender) ? old_sender->GetCongestionWindow()
: (initial_cwnd_in_packets * kDefaultTCPMSS))),
cwnd_(initial_cwnd_),
- pacing_rate_(kInitialPacingGain * QuicBandwidth::FromBytesAndTimeDelta(
- cwnd_,
- rtt_stats->SmoothedOrInitialRtt())),
+ pacing_rate_(kInitialPacingGain *
+ QuicBandwidth::FromBytesAndTimeDelta(
+ cwnd_, rtt_stats->SmoothedOrInitialRtt())),
startup_(this, &model_, now),
drain_(this, &model_),
probe_bw_(this, &model_),
@@ -431,8 +427,7 @@
cwnd_limits().Min());
}
-void Bbr2Sender::OnPacketSent(QuicTime sent_time,
- QuicByteCount bytes_in_flight,
+void Bbr2Sender::OnPacketSent(QuicTime sent_time, QuicByteCount bytes_in_flight,
QuicPacketNumber packet_number,
QuicByteCount bytes,
HasRetransmittableData is_retransmittable) {
diff --git a/quiche/quic/core/congestion_control/bbr2_sender.h b/quiche/quic/core/congestion_control/bbr2_sender.h
index 7529171..b9c0a41 100644
--- a/quiche/quic/core/congestion_control/bbr2_sender.h
+++ b/quiche/quic/core/congestion_control/bbr2_sender.h
@@ -26,14 +26,11 @@
class QUIC_EXPORT_PRIVATE Bbr2Sender final : public SendAlgorithmInterface {
public:
- Bbr2Sender(QuicTime now,
- const RttStats* rtt_stats,
+ Bbr2Sender(QuicTime now, const RttStats* rtt_stats,
const QuicUnackedPacketMap* unacked_packets,
QuicPacketCount initial_cwnd_in_packets,
- QuicPacketCount max_cwnd_in_packets,
- QuicRandom* random,
- QuicConnectionStats* stats,
- BbrSender* old_sender);
+ QuicPacketCount max_cwnd_in_packets, QuicRandom* random,
+ QuicConnectionStats* stats, BbrSender* old_sender);
~Bbr2Sender() override = default;
@@ -57,16 +54,13 @@
void SetInitialCongestionWindowInPackets(
QuicPacketCount congestion_window) override;
- void OnCongestionEvent(bool rtt_updated,
- QuicByteCount prior_in_flight,
+ void OnCongestionEvent(bool rtt_updated, QuicByteCount prior_in_flight,
QuicTime event_time,
const AckedPacketVector& acked_packets,
const LostPacketVector& lost_packets) override;
- void OnPacketSent(QuicTime sent_time,
- QuicByteCount bytes_in_flight,
- QuicPacketNumber packet_number,
- QuicByteCount bytes,
+ void OnPacketSent(QuicTime sent_time, QuicByteCount bytes_in_flight,
+ QuicPacketNumber packet_number, QuicByteCount bytes,
HasRetransmittableData is_retransmittable) override;
void OnPacketNeutered(QuicPacketNumber packet_number) override;
@@ -214,8 +208,7 @@
};
QUIC_EXPORT_PRIVATE std::ostream& operator<<(
- std::ostream& os,
- const Bbr2Sender::DebugState& state);
+ std::ostream& os, const Bbr2Sender::DebugState& state);
} // namespace quic
diff --git a/quiche/quic/core/congestion_control/bbr2_simulator_test.cc b/quiche/quic/core/congestion_control/bbr2_simulator_test.cc
index 6eec232..6a0e581 100644
--- a/quiche/quic/core/congestion_control/bbr2_simulator_test.cc
+++ b/quiche/quic/core/congestion_control/bbr2_simulator_test.cc
@@ -161,16 +161,10 @@
class Bbr2DefaultTopologyTest : public Bbr2SimulatorTest {
protected:
Bbr2DefaultTopologyTest()
- : sender_endpoint_(&simulator_,
- "Sender",
- "Receiver",
- Perspective::IS_CLIENT,
- TestConnectionId(42)),
- receiver_endpoint_(&simulator_,
- "Receiver",
- "Sender",
- Perspective::IS_SERVER,
- TestConnectionId(42)) {
+ : sender_endpoint_(&simulator_, "Sender", "Receiver",
+ Perspective::IS_CLIENT, TestConnectionId(42)),
+ receiver_endpoint_(&simulator_, "Receiver", "Sender",
+ Perspective::IS_SERVER, TestConnectionId(42)) {
sender_ = SetupBbr2Sender(&sender_endpoint_, /*old_sender=*/nullptr);
}
@@ -265,10 +259,8 @@
// Send |bytes|-sized bursts of data |number_of_bursts| times, waiting for
// |wait_time| between each burst.
- void SendBursts(const DefaultTopologyParams& params,
- size_t number_of_bursts,
- QuicByteCount bytes,
- QuicTime::Delta wait_time) {
+ void SendBursts(const DefaultTopologyParams& params, size_t number_of_bursts,
+ QuicByteCount bytes, QuicTime::Delta wait_time) {
ASSERT_EQ(0u, sender_endpoint_.bytes_to_transfer());
for (size_t i = 0; i < number_of_bursts; i++) {
sender_endpoint_.AddBytesToTransfer(bytes);
diff --git a/quiche/quic/core/congestion_control/bbr2_startup.cc b/quiche/quic/core/congestion_control/bbr2_startup.cc
index 7091353..6910cb0 100644
--- a/quiche/quic/core/congestion_control/bbr2_startup.cc
+++ b/quiche/quic/core/congestion_control/bbr2_startup.cc
@@ -15,8 +15,7 @@
namespace quic {
Bbr2StartupMode::Bbr2StartupMode(const Bbr2Sender* sender,
- Bbr2NetworkModel* model,
- QuicTime now)
+ Bbr2NetworkModel* model, QuicTime now)
: Bbr2ModeBase(sender, model) {
// Increment, instead of reset startup stats, so we don't lose data recorded
// before QuicConnection switched send algorithm to BBRv2.
@@ -42,8 +41,7 @@
}
Bbr2Mode Bbr2StartupMode::OnCongestionEvent(
- QuicByteCount /*prior_in_flight*/,
- QuicTime /*event_time*/,
+ QuicByteCount /*prior_in_flight*/, QuicTime /*event_time*/,
const AckedPacketVector& /*acked_packets*/,
const LostPacketVector& /*lost_packets*/,
const Bbr2CongestionEvent& congestion_event) {
@@ -150,8 +148,6 @@
return os;
}
-const Bbr2Params& Bbr2StartupMode::Params() const {
- return sender_->Params();
-}
+const Bbr2Params& Bbr2StartupMode::Params() const { return sender_->Params(); }
} // namespace quic
diff --git a/quiche/quic/core/congestion_control/bbr2_startup.h b/quiche/quic/core/congestion_control/bbr2_startup.h
index a041178..b246b3c 100644
--- a/quiche/quic/core/congestion_control/bbr2_startup.h
+++ b/quiche/quic/core/congestion_control/bbr2_startup.h
@@ -16,8 +16,7 @@
class Bbr2Sender;
class QUIC_EXPORT_PRIVATE Bbr2StartupMode final : public Bbr2ModeBase {
public:
- Bbr2StartupMode(const Bbr2Sender* sender,
- Bbr2NetworkModel* model,
+ Bbr2StartupMode(const Bbr2Sender* sender, Bbr2NetworkModel* model,
QuicTime now);
void Enter(QuicTime now,
@@ -26,8 +25,7 @@
const Bbr2CongestionEvent* congestion_event) override;
Bbr2Mode OnCongestionEvent(
- QuicByteCount prior_in_flight,
- QuicTime event_time,
+ QuicByteCount prior_in_flight, QuicTime event_time,
const AckedPacketVector& acked_packets,
const LostPacketVector& lost_packets,
const Bbr2CongestionEvent& congestion_event) override;
@@ -63,8 +61,7 @@
};
QUIC_EXPORT_PRIVATE std::ostream& operator<<(
- std::ostream& os,
- const Bbr2StartupMode::DebugState& state);
+ std::ostream& os, const Bbr2StartupMode::DebugState& state);
} // namespace quic
diff --git a/quiche/quic/core/congestion_control/bbr_sender.cc b/quiche/quic/core/congestion_control/bbr_sender.cc
index 022f225..aa121d4 100644
--- a/quiche/quic/core/congestion_control/bbr_sender.cc
+++ b/quiche/quic/core/congestion_control/bbr_sender.cc
@@ -69,13 +69,11 @@
BbrSender::DebugState::DebugState(const DebugState& state) = default;
-BbrSender::BbrSender(QuicTime now,
- const RttStats* rtt_stats,
+BbrSender::BbrSender(QuicTime now, const RttStats* rtt_stats,
const QuicUnackedPacketMap* unacked_packets,
QuicPacketCount initial_tcp_congestion_window,
QuicPacketCount max_tcp_congestion_window,
- QuicRandom* random,
- QuicConnectionStats* stats)
+ QuicRandom* random, QuicConnectionStats* stats)
: rtt_stats_(rtt_stats),
unacked_packets_(unacked_packets),
random_(random),
@@ -147,12 +145,9 @@
}
}
-bool BbrSender::InSlowStart() const {
- return mode_ == STARTUP;
-}
+bool BbrSender::InSlowStart() const { return mode_ == STARTUP; }
-void BbrSender::OnPacketSent(QuicTime sent_time,
- QuicByteCount bytes_in_flight,
+void BbrSender::OnPacketSent(QuicTime sent_time, QuicByteCount bytes_in_flight,
QuicPacketNumber packet_number,
QuicByteCount bytes,
HasRetransmittableData is_retransmittable) {
@@ -203,9 +198,7 @@
return congestion_window_;
}
-QuicByteCount BbrSender::GetSlowStartThreshold() const {
- return 0;
-}
+QuicByteCount BbrSender::GetSlowStartThreshold() const { return 0; }
bool BbrSender::InRecovery() const {
return recovery_state_ != NOT_IN_RECOVERY;
@@ -640,8 +633,7 @@
return false;
}
-void BbrSender::MaybeEnterOrExitProbeRtt(QuicTime now,
- bool is_round_start,
+void BbrSender::MaybeEnterOrExitProbeRtt(QuicTime now, bool is_round_start,
bool min_rtt_expired) {
if (min_rtt_expired && !exiting_quiescence_ && mode_ != PROBE_RTT) {
if (InSlowStart()) {
@@ -686,8 +678,7 @@
}
void BbrSender::UpdateRecoveryState(QuicPacketNumber last_acked_packet,
- bool has_losses,
- bool is_round_start) {
+ bool has_losses, bool is_round_start) {
// Disable recovery in startup, if loss-based exit is enabled.
if (!is_at_full_bandwidth_) {
return;
diff --git a/quiche/quic/core/congestion_control/bbr_sender.h b/quiche/quic/core/congestion_control/bbr_sender.h
index 1b9afc3..9fe1199 100644
--- a/quiche/quic/core/congestion_control/bbr_sender.h
+++ b/quiche/quic/core/congestion_control/bbr_sender.h
@@ -88,12 +88,10 @@
QuicPacketNumber end_of_app_limited_phase;
};
- BbrSender(QuicTime now,
- const RttStats* rtt_stats,
+ BbrSender(QuicTime now, const RttStats* rtt_stats,
const QuicUnackedPacketMap* unacked_packets,
QuicPacketCount initial_tcp_congestion_window,
- QuicPacketCount max_tcp_congestion_window,
- QuicRandom* random,
+ QuicPacketCount max_tcp_congestion_window, QuicRandom* random,
QuicConnectionStats* stats);
BbrSender(const BbrSender&) = delete;
BbrSender& operator=(const BbrSender&) = delete;
@@ -111,15 +109,12 @@
void AdjustNetworkParameters(const NetworkParams& params) override;
void SetInitialCongestionWindowInPackets(
QuicPacketCount congestion_window) override;
- void OnCongestionEvent(bool rtt_updated,
- QuicByteCount prior_in_flight,
+ void OnCongestionEvent(bool rtt_updated, QuicByteCount prior_in_flight,
QuicTime event_time,
const AckedPacketVector& acked_packets,
const LostPacketVector& lost_packets) override;
- void OnPacketSent(QuicTime sent_time,
- QuicByteCount bytes_in_flight,
- QuicPacketNumber packet_number,
- QuicByteCount bytes,
+ void OnPacketSent(QuicTime sent_time, QuicByteCount bytes_in_flight,
+ QuicPacketNumber packet_number, QuicByteCount bytes,
HasRetransmittableData is_retransmittable) override;
void OnPacketNeutered(QuicPacketNumber packet_number) override;
void OnRetransmissionTimeout(bool /*packets_retransmitted*/) override {}
@@ -178,15 +173,13 @@
// For switching send algorithm mid connection.
friend class Bbr2Sender;
- using MaxBandwidthFilter = WindowedFilter<QuicBandwidth,
- MaxFilter<QuicBandwidth>,
- QuicRoundTripCount,
- QuicRoundTripCount>;
+ using MaxBandwidthFilter =
+ WindowedFilter<QuicBandwidth, MaxFilter<QuicBandwidth>,
+ QuicRoundTripCount, QuicRoundTripCount>;
- using MaxAckHeightFilter = WindowedFilter<QuicByteCount,
- MaxFilter<QuicByteCount>,
- QuicRoundTripCount,
- QuicRoundTripCount>;
+ using MaxAckHeightFilter =
+ WindowedFilter<QuicByteCount, MaxFilter<QuicByteCount>,
+ QuicRoundTripCount, QuicRoundTripCount>;
// Computes the target congestion window using the specified gain.
QuicByteCount GetTargetCongestionWindow(float gain) const;
@@ -204,8 +197,7 @@
bool UpdateRoundTripCounter(QuicPacketNumber last_acked_packet);
// Updates the current gain used in PROBE_BW mode.
- void UpdateGainCyclePhase(QuicTime now,
- QuicByteCount prior_in_flight,
+ void UpdateGainCyclePhase(QuicTime now, QuicByteCount prior_in_flight,
bool has_losses);
// Tracks for how many round-trips the bandwidth has not increased
// significantly.
@@ -214,13 +206,11 @@
// appropriate.
void MaybeExitStartupOrDrain(QuicTime now);
// Decides whether to enter or exit PROBE_RTT.
- void MaybeEnterOrExitProbeRtt(QuicTime now,
- bool is_round_start,
+ void MaybeEnterOrExitProbeRtt(QuicTime now, bool is_round_start,
bool min_rtt_expired);
// Determines whether BBR needs to enter, exit or advance state of the
// recovery.
- void UpdateRecoveryState(QuicPacketNumber last_acked_packet,
- bool has_losses,
+ void UpdateRecoveryState(QuicPacketNumber last_acked_packet, bool has_losses,
bool is_round_start);
// Updates the ack aggregation max filter in bytes.
@@ -391,8 +381,7 @@
QUIC_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
const BbrSender::Mode& mode);
QUIC_EXPORT_PRIVATE std::ostream& operator<<(
- std::ostream& os,
- const BbrSender::DebugState& state);
+ std::ostream& os, const BbrSender::DebugState& state);
} // namespace quic
diff --git a/quiche/quic/core/congestion_control/bbr_sender_test.cc b/quiche/quic/core/congestion_control/bbr_sender_test.cc
index 62abb7a..199d322 100644
--- a/quiche/quic/core/congestion_control/bbr_sender_test.cc
+++ b/quiche/quic/core/congestion_control/bbr_sender_test.cc
@@ -86,25 +86,16 @@
protected:
BbrSenderTest()
: simulator_(&random_),
- bbr_sender_(&simulator_,
- "BBR sender",
- "Receiver",
+ bbr_sender_(&simulator_, "BBR sender", "Receiver",
Perspective::IS_CLIENT,
/*connection_id=*/TestConnectionId(42)),
- competing_sender_(&simulator_,
- "Competing sender",
- "Competing receiver",
+ competing_sender_(&simulator_, "Competing sender", "Competing receiver",
Perspective::IS_CLIENT,
/*connection_id=*/TestConnectionId(43)),
- receiver_(&simulator_,
- "Receiver",
- "BBR sender",
- Perspective::IS_SERVER,
+ receiver_(&simulator_, "Receiver", "BBR sender", Perspective::IS_SERVER,
/*connection_id=*/TestConnectionId(42)),
- competing_receiver_(&simulator_,
- "Competing receiver",
- "Competing sender",
- Perspective::IS_SERVER,
+ competing_receiver_(&simulator_, "Competing receiver",
+ "Competing sender", Perspective::IS_SERVER,
/*connection_id=*/TestConnectionId(43)),
receiver_multiplexer_("Receiver multiplexer",
{&receiver_, &competing_receiver_}) {
@@ -258,8 +249,7 @@
// Send |bytes|-sized bursts of data |number_of_bursts| times, waiting for
// |wait_time| between each burst.
- void SendBursts(size_t number_of_bursts,
- QuicByteCount bytes,
+ void SendBursts(size_t number_of_bursts, QuicByteCount bytes,
QuicTime::Delta wait_time) {
ASSERT_EQ(0u, bbr_sender_.bytes_to_transfer());
for (size_t i = 0; i < number_of_bursts; i++) {
@@ -471,9 +461,8 @@
// Test a simple long data transfer with 2 rtts of aggregation.
// TODO(b/172302465) Re-enable this test.
-TEST_F(BbrSenderTest,
- QUIC_TEST_DISABLED_IN_CHROME(
- SimpleTransfer2RTTAggregationBytes20RTTWindow)) {
+TEST_F(BbrSenderTest, QUIC_TEST_DISABLED_IN_CHROME(
+ SimpleTransfer2RTTAggregationBytes20RTTWindow)) {
SetConnectionOption(kBSAO);
CreateDefaultSetup();
SetConnectionOption(kBBR4);
diff --git a/quiche/quic/core/congestion_control/cubic_bytes.cc b/quiche/quic/core/congestion_control/cubic_bytes.cc
index f3f9d37..4890425 100644
--- a/quiche/quic/core/congestion_control/cubic_bytes.cc
+++ b/quiche/quic/core/congestion_control/cubic_bytes.cc
@@ -73,7 +73,7 @@
}
void CubicBytes::ResetCubicState() {
- epoch_ = QuicTime::Zero(); // Reset time.
+ epoch_ = QuicTime::Zero(); // Reset time.
last_max_congestion_window_ = 0;
acked_bytes_count_ = 0;
estimated_tcp_congestion_window_ = 0;
@@ -114,10 +114,8 @@
}
QuicByteCount CubicBytes::CongestionWindowAfterAck(
- QuicByteCount acked_bytes,
- QuicByteCount current_congestion_window,
- QuicTime::Delta delay_min,
- QuicTime event_time) {
+ QuicByteCount acked_bytes, QuicByteCount current_congestion_window,
+ QuicTime::Delta delay_min, QuicTime event_time) {
acked_bytes_count_ += acked_bytes;
if (!epoch_.IsInitialized()) {
diff --git a/quiche/quic/core/congestion_control/general_loss_algorithm.cc b/quiche/quic/core/congestion_control/general_loss_algorithm.cc
index 38557a1..b92dc09 100644
--- a/quiche/quic/core/congestion_control/general_loss_algorithm.cc
+++ b/quiche/quic/core/congestion_control/general_loss_algorithm.cc
@@ -13,8 +13,7 @@
namespace quic {
namespace {
-float DetectionResponseTime(QuicTime::Delta rtt,
- QuicTime send_time,
+float DetectionResponseTime(QuicTime::Delta rtt, QuicTime send_time,
QuicTime detection_time) {
if (detection_time <= send_time || rtt.IsZero()) {
// Time skewed, assume a very fast detection where |detection_time| is
@@ -34,12 +33,9 @@
// Uses nack counts to decide when packets are lost.
LossDetectionInterface::DetectionStats GeneralLossAlgorithm::DetectLosses(
- const QuicUnackedPacketMap& unacked_packets,
- QuicTime time,
- const RttStats& rtt_stats,
- QuicPacketNumber largest_newly_acked,
- const AckedPacketVector& packets_acked,
- LostPacketVector* packets_lost) {
+ const QuicUnackedPacketMap& unacked_packets, QuicTime time,
+ const RttStats& rtt_stats, QuicPacketNumber largest_newly_acked,
+ const AckedPacketVector& packets_acked, LostPacketVector* packets_lost) {
DetectionStats detection_stats;
loss_detection_timeout_ = QuicTime::Zero();
@@ -149,10 +145,8 @@
}
void GeneralLossAlgorithm::SpuriousLossDetected(
- const QuicUnackedPacketMap& unacked_packets,
- const RttStats& rtt_stats,
- QuicTime ack_receive_time,
- QuicPacketNumber packet_number,
+ const QuicUnackedPacketMap& unacked_packets, const RttStats& rtt_stats,
+ QuicTime ack_receive_time, QuicPacketNumber packet_number,
QuicPacketNumber previous_largest_acked) {
if (use_adaptive_time_threshold_ && reordering_shift_ > 0) {
// Increase reordering fraction such that the packet would not have been
diff --git a/quiche/quic/core/congestion_control/general_loss_algorithm.h b/quiche/quic/core/congestion_control/general_loss_algorithm.h
index 701b2dc..7e58616 100644
--- a/quiche/quic/core/congestion_control/general_loss_algorithm.h
+++ b/quiche/quic/core/congestion_control/general_loss_algorithm.h
@@ -32,8 +32,7 @@
// Uses |largest_acked| and time to decide when packets are lost.
DetectionStats DetectLosses(const QuicUnackedPacketMap& unacked_packets,
- QuicTime time,
- const RttStats& rtt_stats,
+ QuicTime time, const RttStats& rtt_stats,
QuicPacketNumber largest_newly_acked,
const AckedPacketVector& packets_acked,
LostPacketVector* packets_lost) override;
diff --git a/quiche/quic/core/congestion_control/general_loss_algorithm_test.cc b/quiche/quic/core/congestion_control/general_loss_algorithm_test.cc
index 3b67c65..5ef6aeb 100644
--- a/quiche/quic/core/congestion_control/general_loss_algorithm_test.cc
+++ b/quiche/quic/core/congestion_control/general_loss_algorithm_test.cc
@@ -66,8 +66,7 @@
}
void VerifyLosses(
- uint64_t largest_newly_acked,
- const AckedPacketVector& packets_acked,
+ uint64_t largest_newly_acked, const AckedPacketVector& packets_acked,
const std::vector<uint64_t>& losses_expected,
absl::optional<QuicPacketCount> max_sequence_reordering_expected,
absl::optional<QuicPacketCount>
diff --git a/quiche/quic/core/congestion_control/hybrid_slow_start.h b/quiche/quic/core/congestion_control/hybrid_slow_start.h
index 9ea130c..73c7670 100644
--- a/quiche/quic/core/congestion_control/hybrid_slow_start.h
+++ b/quiche/quic/core/congestion_control/hybrid_slow_start.h
@@ -39,8 +39,7 @@
// rtt: the RTT for this ack packet.
// min_rtt: is the lowest delay (RTT) we have seen during the session.
// congestion_window: the congestion window in packets.
- bool ShouldExitSlowStart(QuicTime::Delta rtt,
- QuicTime::Delta min_rtt,
+ bool ShouldExitSlowStart(QuicTime::Delta rtt, QuicTime::Delta min_rtt,
QuicPacketCount congestion_window);
// Start a new slow start phase.
diff --git a/quiche/quic/core/congestion_control/loss_detection_interface.h b/quiche/quic/core/congestion_control/loss_detection_interface.h
index 76aa2df..c81702e 100644
--- a/quiche/quic/core/congestion_control/loss_detection_interface.h
+++ b/quiche/quic/core/congestion_control/loss_detection_interface.h
@@ -37,10 +37,8 @@
// Called when a new ack arrives or the loss alarm fires.
virtual DetectionStats DetectLosses(
- const QuicUnackedPacketMap& unacked_packets,
- QuicTime time,
- const RttStats& rtt_stats,
- QuicPacketNumber largest_newly_acked,
+ const QuicUnackedPacketMap& unacked_packets, QuicTime time,
+ const RttStats& rtt_stats, QuicPacketNumber largest_newly_acked,
const AckedPacketVector& packets_acked,
LostPacketVector* packets_lost) = 0;
@@ -50,10 +48,8 @@
// Called when |packet_number| was detected lost but gets acked later.
virtual void SpuriousLossDetected(
- const QuicUnackedPacketMap& unacked_packets,
- const RttStats& rtt_stats,
- QuicTime ack_receive_time,
- QuicPacketNumber packet_number,
+ const QuicUnackedPacketMap& unacked_packets, const RttStats& rtt_stats,
+ QuicTime ack_receive_time, QuicPacketNumber packet_number,
QuicPacketNumber previous_largest_acked) = 0;
virtual void OnConfigNegotiated() = 0;
diff --git a/quiche/quic/core/congestion_control/pacing_sender.cc b/quiche/quic/core/congestion_control/pacing_sender.cc
index 9eede85..fb3f514 100644
--- a/quiche/quic/core/congestion_control/pacing_sender.cc
+++ b/quiche/quic/core/congestion_control/pacing_sender.cc
@@ -54,10 +54,8 @@
}
void PacingSender::OnPacketSent(
- QuicTime sent_time,
- QuicByteCount bytes_in_flight,
- QuicPacketNumber packet_number,
- QuicByteCount bytes,
+ QuicTime sent_time, QuicByteCount bytes_in_flight,
+ QuicPacketNumber packet_number, QuicByteCount bytes,
HasRetransmittableData has_retransmittable_data) {
QUICHE_DCHECK(sender_ != nullptr);
sender_->OnPacketSent(sent_time, bytes_in_flight, packet_number, bytes,
@@ -135,8 +133,7 @@
}
QuicTime::Delta PacingSender::TimeUntilSend(
- QuicTime now,
- QuicByteCount bytes_in_flight) const {
+ QuicTime now, QuicByteCount bytes_in_flight) const {
QUICHE_DCHECK(sender_ != nullptr);
if (!sender_->CanSend(bytes_in_flight)) {
diff --git a/quiche/quic/core/congestion_control/pacing_sender.h b/quiche/quic/core/congestion_control/pacing_sender.h
index c7be125..94cbfaa 100644
--- a/quiche/quic/core/congestion_control/pacing_sender.h
+++ b/quiche/quic/core/congestion_control/pacing_sender.h
@@ -50,16 +50,13 @@
QuicBandwidth max_pacing_rate() const { return max_pacing_rate_; }
- void OnCongestionEvent(bool rtt_updated,
- QuicByteCount bytes_in_flight,
+ void OnCongestionEvent(bool rtt_updated, QuicByteCount bytes_in_flight,
QuicTime event_time,
const AckedPacketVector& acked_packets,
const LostPacketVector& lost_packets);
- void OnPacketSent(QuicTime sent_time,
- QuicByteCount bytes_in_flight,
- QuicPacketNumber packet_number,
- QuicByteCount bytes,
+ void OnPacketSent(QuicTime sent_time, QuicByteCount bytes_in_flight,
+ QuicPacketNumber packet_number, QuicByteCount bytes,
HasRetransmittableData has_retransmittable_data);
// Called when application throttles the sending, so that pacing sender stops
diff --git a/quiche/quic/core/congestion_control/pacing_sender_test.cc b/quiche/quic/core/congestion_control/pacing_sender_test.cc
index 9e28c75..2bc7c94 100644
--- a/quiche/quic/core/congestion_control/pacing_sender_test.cc
+++ b/quiche/quic/core/congestion_control/pacing_sender_test.cc
@@ -77,8 +77,7 @@
void CheckPacketIsSentImmediately(HasRetransmittableData retransmittable_data,
QuicByteCount prior_in_flight,
- bool in_recovery,
- QuicPacketCount cwnd) {
+ bool in_recovery, QuicPacketCount cwnd) {
// In order for the packet to be sendable, the underlying sender must
// permit it to be sent immediately.
for (int i = 0; i < 2; ++i) {
diff --git a/quiche/quic/core/congestion_control/prr_sender.h b/quiche/quic/core/congestion_control/prr_sender.h
index f55069b..4e17840 100644
--- a/quiche/quic/core/congestion_control/prr_sender.h
+++ b/quiche/quic/core/congestion_control/prr_sender.h
@@ -22,8 +22,7 @@
void OnPacketLost(QuicByteCount prior_in_flight);
void OnPacketSent(QuicByteCount sent_bytes);
void OnPacketAcked(QuicByteCount acked_bytes);
- bool CanSend(QuicByteCount congestion_window,
- QuicByteCount bytes_in_flight,
+ bool CanSend(QuicByteCount congestion_window, QuicByteCount bytes_in_flight,
QuicByteCount slowstart_threshold) const;
private:
diff --git a/quiche/quic/core/congestion_control/rtt_stats.cc b/quiche/quic/core/congestion_control/rtt_stats.cc
index 90a9efe..74b5c85 100644
--- a/quiche/quic/core/congestion_control/rtt_stats.cc
+++ b/quiche/quic/core/congestion_control/rtt_stats.cc
@@ -39,8 +39,7 @@
}
// Updates the RTT based on a new sample.
-void RttStats::UpdateRtt(QuicTime::Delta send_delta,
- QuicTime::Delta ack_delay,
+void RttStats::UpdateRtt(QuicTime::Delta send_delta, QuicTime::Delta ack_delay,
QuicTime now) {
if (send_delta.IsInfinite() || send_delta <= QuicTime::Delta::Zero()) {
QUIC_LOG_FIRST_N(WARNING, 3)
@@ -112,8 +111,7 @@
}
void RttStats::StandardDeviationCaculator::OnNewRttSample(
- QuicTime::Delta rtt_sample,
- QuicTime::Delta smoothed_rtt) {
+ QuicTime::Delta rtt_sample, QuicTime::Delta smoothed_rtt) {
double new_value = rtt_sample.ToMicroseconds();
if (smoothed_rtt.IsZero()) {
return;
diff --git a/quiche/quic/core/congestion_control/rtt_stats.h b/quiche/quic/core/congestion_control/rtt_stats.h
index 6b6569a..c9dcab0 100644
--- a/quiche/quic/core/congestion_control/rtt_stats.h
+++ b/quiche/quic/core/congestion_control/rtt_stats.h
@@ -47,8 +47,7 @@
// Updates the RTT from an incoming ack which is received |send_delta| after
// the packet is sent and the peer reports the ack being delayed |ack_delay|.
- void UpdateRtt(QuicTime::Delta send_delta,
- QuicTime::Delta ack_delay,
+ void UpdateRtt(QuicTime::Delta send_delta, QuicTime::Delta ack_delay,
QuicTime now);
// Causes the smoothed_rtt to be increased to the latest_rtt if the latest_rtt
diff --git a/quiche/quic/core/congestion_control/send_algorithm_interface.cc b/quiche/quic/core/congestion_control/send_algorithm_interface.cc
index f8be8d9..c8c7d5b 100644
--- a/quiche/quic/core/congestion_control/send_algorithm_interface.cc
+++ b/quiche/quic/core/congestion_control/send_algorithm_interface.cc
@@ -19,13 +19,10 @@
// Factory for send side congestion control algorithm.
SendAlgorithmInterface* SendAlgorithmInterface::Create(
- const QuicClock* clock,
- const RttStats* rtt_stats,
+ const QuicClock* clock, const RttStats* rtt_stats,
const QuicUnackedPacketMap* unacked_packets,
- CongestionControlType congestion_control_type,
- QuicRandom* random,
- QuicConnectionStats* stats,
- QuicPacketCount initial_congestion_window,
+ CongestionControlType congestion_control_type, QuicRandom* random,
+ QuicConnectionStats* stats, QuicPacketCount initial_congestion_window,
SendAlgorithmInterface* old_send_algorithm) {
QuicPacketCount max_congestion_window =
GetQuicFlag(FLAGS_quic_max_congestion_window);
diff --git a/quiche/quic/core/congestion_control/send_algorithm_interface.h b/quiche/quic/core/congestion_control/send_algorithm_interface.h
index ed85d2f..75c69a2 100644
--- a/quiche/quic/core/congestion_control/send_algorithm_interface.h
+++ b/quiche/quic/core/congestion_control/send_algorithm_interface.h
@@ -59,12 +59,9 @@
};
static SendAlgorithmInterface* Create(
- const QuicClock* clock,
- const RttStats* rtt_stats,
- const QuicUnackedPacketMap* unacked_packets,
- CongestionControlType type,
- QuicRandom* random,
- QuicConnectionStats* stats,
+ const QuicClock* clock, const RttStats* rtt_stats,
+ const QuicUnackedPacketMap* unacked_packets, CongestionControlType type,
+ QuicRandom* random, QuicConnectionStats* stats,
QuicPacketCount initial_congestion_window,
SendAlgorithmInterface* old_send_algorithm);
@@ -95,10 +92,8 @@
// retransmittable. |bytes_in_flight| is the number of bytes in flight before
// the packet was sent.
// Note: this function must be called for every packet sent to the wire.
- virtual void OnPacketSent(QuicTime sent_time,
- QuicByteCount bytes_in_flight,
- QuicPacketNumber packet_number,
- QuicByteCount bytes,
+ virtual void OnPacketSent(QuicTime sent_time, QuicByteCount bytes_in_flight,
+ QuicPacketNumber packet_number, QuicByteCount bytes,
HasRetransmittableData is_retransmittable) = 0;
// Inform that |packet_number| has been neutered.
diff --git a/quiche/quic/core/congestion_control/send_algorithm_test.cc b/quiche/quic/core/congestion_control/send_algorithm_test.cc
index f55d363..21af4f1 100644
--- a/quiche/quic/core/congestion_control/send_algorithm_test.cc
+++ b/quiche/quic/core/congestion_control/send_algorithm_test.cc
@@ -154,16 +154,10 @@
protected:
SendAlgorithmTest()
: simulator_(),
- quic_sender_(&simulator_,
- "QUIC sender",
- "Receiver",
- Perspective::IS_CLIENT,
- TestConnectionId()),
- receiver_(&simulator_,
- "Receiver",
- "QUIC sender",
- Perspective::IS_SERVER,
- TestConnectionId()) {
+ quic_sender_(&simulator_, "QUIC sender", "Receiver",
+ Perspective::IS_CLIENT, TestConnectionId()),
+ receiver_(&simulator_, "Receiver", "QUIC sender",
+ Perspective::IS_SERVER, TestConnectionId()) {
rtt_stats_ = quic_sender_.connection()->sent_packet_manager().GetRttStats();
sender_ = SendAlgorithmInterface::Create(
simulator_.GetClock(), rtt_stats_,
@@ -209,10 +203,8 @@
<< quic_sender_.bytes_to_transfer();
}
- void SendBursts(size_t number_of_bursts,
- QuicByteCount bytes,
- QuicTime::Delta rtt,
- QuicTime::Delta wait_time) {
+ void SendBursts(size_t number_of_bursts, QuicByteCount bytes,
+ QuicTime::Delta rtt, QuicTime::Delta wait_time) {
ASSERT_EQ(0u, quic_sender_.bytes_to_transfer());
for (size_t i = 0; i < number_of_bursts; i++) {
quic_sender_.AddBytesToTransfer(bytes);
@@ -232,8 +224,7 @@
// Estimates the elapsed time for a given transfer size, given the
// bottleneck bandwidth and link propagation delay.
QuicTime::Delta EstimatedElapsedTime(
- QuicByteCount transfer_size_bytes,
- QuicBandwidth test_link_bandwidth,
+ QuicByteCount transfer_size_bytes, QuicBandwidth test_link_bandwidth,
const QuicTime::Delta& test_link_delay) const {
return test_link_bandwidth.TransferTime(transfer_size_bytes) +
2 * test_link_delay;
@@ -271,8 +262,7 @@
SendAlgorithmInterface* sender_;
};
-INSTANTIATE_TEST_SUITE_P(SendAlgorithmTests,
- SendAlgorithmTest,
+INSTANTIATE_TEST_SUITE_P(SendAlgorithmTests, SendAlgorithmTest,
::testing::ValuesIn(GetTestParams()),
TestParamToString);
diff --git a/quiche/quic/core/congestion_control/tcp_cubic_sender_bytes.cc b/quiche/quic/core/congestion_control/tcp_cubic_sender_bytes.cc
index 44afb90..966a000 100644
--- a/quiche/quic/core/congestion_control/tcp_cubic_sender_bytes.cc
+++ b/quiche/quic/core/congestion_control/tcp_cubic_sender_bytes.cc
@@ -28,12 +28,9 @@
} // namespace
TcpCubicSenderBytes::TcpCubicSenderBytes(
- const QuicClock* clock,
- const RttStats* rtt_stats,
- bool reno,
+ const QuicClock* clock, const RttStats* rtt_stats, bool reno,
QuicPacketCount initial_tcp_congestion_window,
- QuicPacketCount max_congestion_window,
- QuicConnectionStats* stats)
+ QuicPacketCount max_congestion_window, QuicConnectionStats* stats)
: rtt_stats_(rtt_stats),
stats_(stats),
reno_(reno),
@@ -121,9 +118,7 @@
}
void TcpCubicSenderBytes::OnCongestionEvent(
- bool rtt_updated,
- QuicByteCount prior_in_flight,
- QuicTime event_time,
+ bool rtt_updated, QuicByteCount prior_in_flight, QuicTime event_time,
const AckedPacketVector& acked_packets,
const LostPacketVector& lost_packets) {
if (rtt_updated && InSlowStart() &&
@@ -162,10 +157,8 @@
}
void TcpCubicSenderBytes::OnPacketSent(
- QuicTime /*sent_time*/,
- QuicByteCount /*bytes_in_flight*/,
- QuicPacketNumber packet_number,
- QuicByteCount bytes,
+ QuicTime /*sent_time*/, QuicByteCount /*bytes_in_flight*/,
+ QuicPacketNumber packet_number, QuicByteCount bytes,
HasRetransmittableData is_retransmittable) {
if (InSlowStart()) {
++(stats_->slowstart_packets_sent);
@@ -240,9 +233,7 @@
largest_acked_packet_number_ <= largest_sent_at_last_cutback_;
}
-bool TcpCubicSenderBytes::ShouldSendProbingPacket() const {
- return false;
-}
+bool TcpCubicSenderBytes::ShouldSendProbingPacket() const { return false; }
void TcpCubicSenderBytes::OnRetransmissionTimeout(bool packets_retransmitted) {
largest_sent_at_last_cutback_.Clear();
@@ -253,16 +244,13 @@
HandleRetransmissionTimeout();
}
-std::string TcpCubicSenderBytes::GetDebugState() const {
- return "";
-}
+std::string TcpCubicSenderBytes::GetDebugState() const { return ""; }
void TcpCubicSenderBytes::OnApplicationLimited(
QuicByteCount /*bytes_in_flight*/) {}
void TcpCubicSenderBytes::SetCongestionWindowFromBandwidthAndRtt(
- QuicBandwidth bandwidth,
- QuicTime::Delta rtt) {
+ QuicBandwidth bandwidth, QuicTime::Delta rtt) {
QuicByteCount new_congestion_window = bandwidth.ToBytesPerPeriod(rtt);
// Limit new CWND if needed.
congestion_window_ =
@@ -357,10 +345,8 @@
// Called when we receive an ack. Normal TCP tracks how many packets one ack
// represents, but quic has a separate ack for each packet.
void TcpCubicSenderBytes::MaybeIncreaseCwnd(
- QuicPacketNumber /*acked_packet_number*/,
- QuicByteCount acked_bytes,
- QuicByteCount prior_in_flight,
- QuicTime event_time) {
+ QuicPacketNumber /*acked_packet_number*/, QuicByteCount acked_bytes,
+ QuicByteCount prior_in_flight, QuicTime event_time) {
QUIC_BUG_IF(quic_bug_10439_1, InRecovery())
<< "Never increase the CWND during recovery.";
// Do not increase the congestion window unless the sender is close to using
diff --git a/quiche/quic/core/congestion_control/tcp_cubic_sender_bytes.h b/quiche/quic/core/congestion_control/tcp_cubic_sender_bytes.h
index aac0c0a..a30f78d 100644
--- a/quiche/quic/core/congestion_control/tcp_cubic_sender_bytes.h
+++ b/quiche/quic/core/congestion_control/tcp_cubic_sender_bytes.h
@@ -33,10 +33,8 @@
class QUIC_EXPORT_PRIVATE TcpCubicSenderBytes : public SendAlgorithmInterface {
public:
- TcpCubicSenderBytes(const QuicClock* clock,
- const RttStats* rtt_stats,
- bool reno,
- QuicPacketCount initial_tcp_congestion_window,
+ TcpCubicSenderBytes(const QuicClock* clock, const RttStats* rtt_stats,
+ bool reno, QuicPacketCount initial_tcp_congestion_window,
QuicPacketCount max_congestion_window,
QuicConnectionStats* stats);
TcpCubicSenderBytes(const TcpCubicSenderBytes&) = delete;
@@ -53,15 +51,12 @@
void SetInitialCongestionWindowInPackets(
QuicPacketCount congestion_window) override;
void OnConnectionMigration() override;
- void OnCongestionEvent(bool rtt_updated,
- QuicByteCount prior_in_flight,
+ void OnCongestionEvent(bool rtt_updated, QuicByteCount prior_in_flight,
QuicTime event_time,
const AckedPacketVector& acked_packets,
const LostPacketVector& lost_packets) override;
- void OnPacketSent(QuicTime sent_time,
- QuicByteCount bytes_in_flight,
- QuicPacketNumber packet_number,
- QuicByteCount bytes,
+ void OnPacketSent(QuicTime sent_time, QuicByteCount bytes_in_flight,
+ QuicPacketNumber packet_number, QuicByteCount bytes,
HasRetransmittableData is_retransmittable) override;
void OnPacketNeutered(QuicPacketNumber /*packet_number*/) override {}
void OnRetransmissionTimeout(bool packets_retransmitted) override;
@@ -90,8 +85,7 @@
// TODO(ianswett): Remove these and migrate to OnCongestionEvent.
void OnPacketAcked(QuicPacketNumber acked_packet_number,
- QuicByteCount acked_bytes,
- QuicByteCount prior_in_flight,
+ QuicByteCount acked_bytes, QuicByteCount prior_in_flight,
QuicTime event_time);
void SetCongestionWindowFromBandwidthAndRtt(QuicBandwidth bandwidth,
QuicTime::Delta rtt);
@@ -101,8 +95,7 @@
QuicByteCount prior_in_flight);
void MaybeIncreaseCwnd(QuicPacketNumber acked_packet_number,
QuicByteCount acked_bytes,
- QuicByteCount prior_in_flight,
- QuicTime event_time);
+ QuicByteCount prior_in_flight, QuicTime event_time);
void HandleRetransmissionTimeout();
private:
diff --git a/quiche/quic/core/congestion_control/tcp_cubic_sender_bytes_test.cc b/quiche/quic/core/congestion_control/tcp_cubic_sender_bytes_test.cc
index bac568a..330b24b 100644
--- a/quiche/quic/core/congestion_control/tcp_cubic_sender_bytes_test.cc
+++ b/quiche/quic/core/congestion_control/tcp_cubic_sender_bytes_test.cc
@@ -34,12 +34,9 @@
class TcpCubicSenderBytesPeer : public TcpCubicSenderBytes {
public:
TcpCubicSenderBytesPeer(const QuicClock* clock, bool reno)
- : TcpCubicSenderBytes(clock,
- &rtt_stats_,
- reno,
+ : TcpCubicSenderBytes(clock, &rtt_stats_, reno,
kInitialCongestionWindowPackets,
- kMaxCongestionWindowPackets,
- &stats_) {}
+ kMaxCongestionWindowPackets, &stats_) {}
const HybridSlowStart& hybrid_slow_start() const {
return hybrid_slow_start_;
diff --git a/quiche/quic/core/congestion_control/uber_loss_algorithm.cc b/quiche/quic/core/congestion_control/uber_loss_algorithm.cc
index 9fd4b8c..cdd8547 100644
--- a/quiche/quic/core/congestion_control/uber_loss_algorithm.cc
+++ b/quiche/quic/core/congestion_control/uber_loss_algorithm.cc
@@ -28,12 +28,9 @@
}
LossDetectionInterface::DetectionStats UberLossAlgorithm::DetectLosses(
- const QuicUnackedPacketMap& unacked_packets,
- QuicTime time,
- const RttStats& rtt_stats,
- QuicPacketNumber /*largest_newly_acked*/,
- const AckedPacketVector& packets_acked,
- LostPacketVector* packets_lost) {
+ const QuicUnackedPacketMap& unacked_packets, QuicTime time,
+ const RttStats& rtt_stats, QuicPacketNumber /*largest_newly_acked*/,
+ const AckedPacketVector& packets_acked, LostPacketVector* packets_lost) {
DetectionStats overall_stats;
for (int8_t i = INITIAL_DATA; i < NUM_PACKET_NUMBER_SPACES; ++i) {
@@ -80,10 +77,8 @@
}
void UberLossAlgorithm::SpuriousLossDetected(
- const QuicUnackedPacketMap& unacked_packets,
- const RttStats& rtt_stats,
- QuicTime ack_receive_time,
- QuicPacketNumber packet_number,
+ const QuicUnackedPacketMap& unacked_packets, const RttStats& rtt_stats,
+ QuicTime ack_receive_time, QuicPacketNumber packet_number,
QuicPacketNumber previous_largest_acked) {
general_loss_algorithms_[unacked_packets.GetPacketNumberSpace(packet_number)]
.SpuriousLossDetected(unacked_packets, rtt_stats, ack_receive_time,
diff --git a/quiche/quic/core/congestion_control/uber_loss_algorithm.h b/quiche/quic/core/congestion_control/uber_loss_algorithm.h
index ff79536..febea73 100644
--- a/quiche/quic/core/congestion_control/uber_loss_algorithm.h
+++ b/quiche/quic/core/congestion_control/uber_loss_algorithm.h
@@ -53,8 +53,7 @@
// Detects lost packets.
DetectionStats DetectLosses(const QuicUnackedPacketMap& unacked_packets,
- QuicTime time,
- const RttStats& rtt_stats,
+ QuicTime time, const RttStats& rtt_stats,
QuicPacketNumber largest_newly_acked,
const AckedPacketVector& packets_acked,
LostPacketVector* packets_lost) override;
diff --git a/quiche/quic/core/congestion_control/uber_loss_algorithm_test.cc b/quiche/quic/core/congestion_control/uber_loss_algorithm_test.cc
index 1a1bbe5..73d01d7 100644
--- a/quiche/quic/core/congestion_control/uber_loss_algorithm_test.cc
+++ b/quiche/quic/core/congestion_control/uber_loss_algorithm_test.cc
@@ -73,8 +73,7 @@
}
void VerifyLosses(
- uint64_t largest_newly_acked,
- const AckedPacketVector& packets_acked,
+ uint64_t largest_newly_acked, const AckedPacketVector& packets_acked,
const std::vector<uint64_t>& losses_expected,
absl::optional<QuicPacketCount> max_sequence_reordering_expected) {
LostPacketVector lost_packets;
diff --git a/quiche/quic/core/congestion_control/windowed_filter_test.cc b/quiche/quic/core/congestion_control/windowed_filter_test.cc
index f2edad0..e984cf8 100644
--- a/quiche/quic/core/congestion_control/windowed_filter_test.cc
+++ b/quiche/quic/core/congestion_control/windowed_filter_test.cc
@@ -18,11 +18,9 @@
// Set the window to 99ms, so 25ms is more than a quarter rtt.
WindowedFilterTest()
: windowed_min_rtt_(QuicTime::Delta::FromMilliseconds(99),
- QuicTime::Delta::Zero(),
- QuicTime::Zero()),
+ QuicTime::Delta::Zero(), QuicTime::Zero()),
windowed_max_bw_(QuicTime::Delta::FromMilliseconds(99),
- QuicBandwidth::Zero(),
- QuicTime::Zero()) {}
+ QuicBandwidth::Zero(), QuicTime::Zero()) {}
// Sets up windowed_min_rtt_ to have the following values:
// Best = 20ms, recorded at 25ms
@@ -75,14 +73,10 @@
}
protected:
- WindowedFilter<QuicTime::Delta,
- MinFilter<QuicTime::Delta>,
- QuicTime,
+ WindowedFilter<QuicTime::Delta, MinFilter<QuicTime::Delta>, QuicTime,
QuicTime::Delta>
windowed_min_rtt_;
- WindowedFilter<QuicBandwidth,
- MaxFilter<QuicBandwidth>,
- QuicTime,
+ WindowedFilter<QuicBandwidth, MaxFilter<QuicBandwidth>, QuicTime,
QuicTime::Delta>
windowed_max_bw_;
};
@@ -92,8 +86,7 @@
// to ensure that it is not susceptible to noise.
void UpdateWithIrrelevantSamples(
WindowedFilter<uint64_t, MaxFilter<uint64_t>, uint64_t, uint64_t>* filter,
- uint64_t max_value,
- uint64_t time) {
+ uint64_t max_value, uint64_t time) {
for (uint64_t i = 0; i < 1000; i++) {
filter->Update(i % max_value, time);
}
