Clang format slam.

net/quic/congestion_control/hybrid_slow_start.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/quic/congestion_control/hybrid_slow_start.h"
 
 #include <algorithm>
 
 using std::max;
 using std::min;
@@ skipping 16 matching lines @@
       hystart_found_(NOT_FOUND),
       last_sent_sequence_number_(0),
       round_start_(QuicTime::Zero()),
       end_sequence_number_(0),
       last_close_ack_pair_time_(QuicTime::Zero()),
       rtt_sample_count_(0),
       current_min_rtt_(QuicTime::Delta::Zero()) {
 }
 
 void HybridSlowStart::OnPacketAcked(
-    QuicPacketSequenceNumber acked_sequence_number, bool in_slow_start) {
+    QuicPacketSequenceNumber acked_sequence_number,
+    bool in_slow_start) {
   // OnPacketAcked gets invoked after ShouldExitSlowStart, so it's best to end
   // the round when the final packet of the burst is received and start it on
   // the next incoming ack.
   if (in_slow_start && IsEndOfRound(acked_sequence_number)) {
     started_ = false;
   }
 }
 
 void HybridSlowStart::OnPacketSent(QuicPacketSequenceNumber sequence_number) {
   last_sent_sequence_number_ = sequence_number;
@@ skipping 35 matching lines @@
   // spread out more then half the minimum RTT packets are being spread out
   // more than the capacity.
   // This first trigger will not come into play until we hit roughly 9.6 Mbps
   // with delayed acks (or 4.8Mbps without delayed acks)
   // TODO(ianswett): QUIC always uses delayed acks, even at the beginning, so
   // this should likely be at least 4ms.
   // TODO(pwestin): we need to make sure our pacing don't trigger this detector.
   // TODO(ianswett): Pacing or other cases could be handled by checking the send
   // time of the first acked packet in a receive round.
   if (current_time.Subtract(last_close_ack_pair_time_).ToMicroseconds() <=
-          kHybridStartDelayMinThresholdUs) {
+      kHybridStartDelayMinThresholdUs) {
     last_close_ack_pair_time_ = current_time;
     if (current_time.Subtract(round_start_).ToMicroseconds() >=
-            min_rtt.ToMicroseconds() >> 1) {
+        min_rtt.ToMicroseconds() >> 1) {
       hystart_found_ = ACK_TRAIN;
     }
   } else if (last_close_ack_pair_time_ == round_start_) {
     // If the previous ack wasn't close, then move forward the round start time
     // to the incoming ack.
     last_close_ack_pair_time_ = round_start_ = current_time;
   }
   // Second detection parameter - delay increase detection.
   // Compare the minimum delay (current_min_rtt_) of the current
   // burst of packets relative to the minimum delay during the session.
   // Note: we only look at the first few(8) packets in each burst, since we
   // only want to compare the lowest RTT of the burst relative to previous
   // bursts.
   rtt_sample_count_++;
   if (rtt_sample_count_ <= kHybridStartMinSamples) {
     if (current_min_rtt_.IsZero() || current_min_rtt_ > latest_rtt) {
       current_min_rtt_ = latest_rtt;
     }
   }
   // We only need to check this once per round.
   if (rtt_sample_count_ == kHybridStartMinSamples) {
     // Divide min_rtt by 16 to get a rtt increase threshold for exiting.
-    int min_rtt_increase_threshold_us = min_rtt.ToMicroseconds() >>
-        kHybridStartDelayFactorExp;
+    int min_rtt_increase_threshold_us =
+        min_rtt.ToMicroseconds() >> kHybridStartDelayFactorExp;
     // Ensure the rtt threshold is never less than 2ms or more than 16ms.
-    min_rtt_increase_threshold_us = min(min_rtt_increase_threshold_us,
-                                        kHybridStartDelayMaxThresholdUs);
+    min_rtt_increase_threshold_us =
+        min(min_rtt_increase_threshold_us, kHybridStartDelayMaxThresholdUs);
     QuicTime::Delta min_rtt_increase_threshold =
         QuicTime::Delta::FromMicroseconds(max(min_rtt_increase_threshold_us,
                                               kHybridStartDelayMinThresholdUs));
 
     if (current_min_rtt_ > min_rtt.Add(min_rtt_increase_threshold)) {
-      hystart_found_= DELAY;
+      hystart_found_ = DELAY;
     }
   }
   // Exit from slow start if the cwnd is greater than 16 and an ack train or
   // increasing delay are found.
   return congestion_window >= kHybridStartLowWindow &&
-      hystart_found_ != NOT_FOUND;
+         hystart_found_ != NOT_FOUND;
 }
 
 }  // namespace net