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_(&params_,
-             rtt_stats->SmoothedOrInitialRtt(),
+      model_(&params_, 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);
   }