Clang format slam.

net/quic/congestion_control/tcp_cubic_sender.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/tcp_cubic_sender.h"
 
 #include <algorithm>
 
 #include "base/metrics/histogram.h"
 #include "net/quic/congestion_control/rtt_stats.h"
@@ skipping 45 matching lines @@
   UMA_HISTOGRAM_COUNTS("Net.QuicSession.FinalTcpCwnd", congestion_window_);
 }
 
 bool TcpCubicSender::InSlowStart() const {
   return congestion_window_ < slowstart_threshold_;
 }
 
 void TcpCubicSender::SetFromConfig(const QuicConfig& config, bool is_server) {
   if (is_server && config.HasReceivedInitialCongestionWindow()) {
     // Set the initial window size.
-    congestion_window_ = min(kMaxInitialWindow,
-                             config.ReceivedInitialCongestionWindow());
+    congestion_window_ =
+        min(kMaxInitialWindow, config.ReceivedInitialCongestionWindow());
   }
 }
 
 void TcpCubicSender::OnIncomingQuicCongestionFeedbackFrame(
     const QuicCongestionFeedbackFrame& feedback,
     QuicTime feedback_receive_time) {
   receive_window_ = feedback.tcp.receive_window;
 }
 
 void TcpCubicSender::OnPacketAcked(
-    QuicPacketSequenceNumber acked_sequence_number, QuicByteCount acked_bytes) {
+    QuicPacketSequenceNumber acked_sequence_number,
+    QuicByteCount acked_bytes) {
   DCHECK_GE(bytes_in_flight_, acked_bytes);
   bytes_in_flight_ -= acked_bytes;
-  largest_acked_sequence_number_ = max(acked_sequence_number,
-                                       largest_acked_sequence_number_);
+  largest_acked_sequence_number_ =
+      max(acked_sequence_number, largest_acked_sequence_number_);
   if (InRecovery()) {
     PrrOnPacketAcked(acked_bytes);
     return;
   }
   MaybeIncreaseCwnd(acked_sequence_number);
   // TODO(ianswett): Should this even be called when not in slow start?
   hybrid_slow_start_.OnPacketAcked(acked_sequence_number, InSlowStart());
 }
 
 void TcpCubicSender::OnPacketLost(QuicPacketSequenceNumber sequence_number,
@@ skipping 105 matching lines @@
   return QuicTime::Delta::FromMicroseconds(
       rtt_stats_->SmoothedRtt().ToMicroseconds() +
       4 * rtt_stats_->mean_deviation().ToMicroseconds());
 }
 
 QuicByteCount TcpCubicSender::GetCongestionWindow() const {
   return congestion_window_ * kMaxSegmentSize;
 }
 
 bool TcpCubicSender::IsCwndLimited() const {
-  const QuicByteCount congestion_window_bytes = congestion_window_ *
-      kMaxSegmentSize;
+  const QuicByteCount congestion_window_bytes =
+      congestion_window_ * kMaxSegmentSize;
   if (bytes_in_flight_ >= congestion_window_bytes) {
     return true;
   }
   const QuicByteCount tcp_max_burst = kMaxBurstLength * kMaxSegmentSize;
   const QuicByteCount left = congestion_window_bytes - bytes_in_flight_;
   return left <= tcp_max_burst;
 }
 
 bool TcpCubicSender::InRecovery() const {
   return largest_acked_sequence_number_ <= largest_sent_at_last_cutback_ &&
-      largest_acked_sequence_number_ != 0;
+         largest_acked_sequence_number_ != 0;
 }
 
 // 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 TcpCubicSender::MaybeIncreaseCwnd(
     QuicPacketSequenceNumber acked_sequence_number) {
   LOG_IF(DFATAL, InRecovery()) << "Never increase the CWND during recovery.";
   if (!IsCwndLimited()) {
     // We don't update the congestion window unless we are close to using the
     // window we have available.
@@ skipping 43 matching lines @@
     congestion_window_ = kMinimumCongestionWindow;
   }
 }
 
 void TcpCubicSender::OnRttUpdated(
     QuicPacketSequenceNumber /*largest_observed*/) {
   if (InSlowStart() &&
       hybrid_slow_start_.ShouldExitSlowStart(rtt_stats_->latest_rtt(),
                                              rtt_stats_->min_rtt(),
                                              congestion_window_)) {
-     slowstart_threshold_ = congestion_window_;
+    slowstart_threshold_ = congestion_window_;
   }
 }
 
 void TcpCubicSender::PrrOnPacketLost() {
   prr_out_ = 0;
   bytes_in_flight_before_loss_ = bytes_in_flight_;
   // Since all losses are triggered by an incoming ack currently, and acks are
   // registered before losses by the SentPacketManager, initialize the variables
   // as though one ack was received directly after the loss.  This is too low
   // for stretch acks, but we expect missing packets to be immediately acked.
@@ skipping 18 matching lines @@
     if (prr_delivered_ + ack_count_since_loss_ * kMaxSegmentSize < prr_out_) {
       return QuicTime::Delta::Infinite();
     }
     return QuicTime::Delta::Zero();
   }
   // Implement Proportional Rate Reduction (RFC6937)
   // Checks a simplified version of the PRR formula that doesn't use division:
   // AvailableSendWindow =
   //   CEIL(prr_delivered * ssthresh / BytesInFlightAtLoss) - prr_sent
   if (prr_delivered_ * slowstart_threshold_ * kMaxSegmentSize >
-          prr_out_ * bytes_in_flight_before_loss_) {
+      prr_out_ * bytes_in_flight_before_loss_) {
     return QuicTime::Delta::Zero();
   }
   return QuicTime::Delta::Infinite();
 }
 
 }  // namespace net