Clang format slam.

net/quic/quic_received_packet_manager.cc

 // Copyright 2013 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/quic_received_packet_manager.h"
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "net/base/linked_hash_map.h"
 #include "net/quic/quic_connection_stats.h"
 
 using std::make_pair;
 using std::max;
 using std::min;
 
 namespace net {
 
 namespace {
 
 // The maximum number of packets to ack immediately after a missing packet for
 // fast retransmission to kick in at the sender.  This limit is created to
 // reduce the number of acks sent that have no benefit for fast retransmission.
 // Set to the number of nacks needed for fast retransmit plus one for protection
 // against an ack loss
 const size_t kMaxPacketsAfterNewMissing = 4;
-
 }
 
 QuicReceivedPacketManager::QuicReceivedPacketManager(
     CongestionFeedbackType congestion_type,
     QuicConnectionStats* stats)
     : packets_entropy_hash_(0),
       largest_sequence_number_(0),
       peer_largest_observed_packet_(0),
       least_packet_awaited_by_peer_(1),
       peer_least_packet_awaiting_ack_(0),
       time_largest_observed_(QuicTime::Zero()),
       receive_algorithm_(ReceiveAlgorithmInterface::Create(congestion_type)),
       stats_(stats) {
   received_info_.largest_observed = 0;
   received_info_.entropy_hash = 0;
 }
 
-QuicReceivedPacketManager::~QuicReceivedPacketManager() {}
+QuicReceivedPacketManager::~QuicReceivedPacketManager() {
+}
 
 void QuicReceivedPacketManager::RecordPacketReceived(
     QuicByteCount bytes,
     const QuicPacketHeader& header,
     QuicTime receipt_time) {
   QuicPacketSequenceNumber sequence_number = header.packet_sequence_number;
   DCHECK(IsAwaitingPacket(sequence_number));
 
   InsertMissingPacketsBetween(
       &received_info_,
       max(received_info_.largest_observed + 1, peer_least_packet_awaiting_ack_),
       header.packet_sequence_number);
 
   if (received_info_.largest_observed > header.packet_sequence_number) {
     // We've gotten one of the out of order packets - remove it from our
     // "missing packets" list.
     DVLOG(1) << "Removing " << sequence_number << " from missing list";
     received_info_.missing_packets.erase(sequence_number);
 
     // Record how out of order stats.
     ++stats_->packets_reordered;
     uint32 sequence_gap = received_info_.largest_observed - sequence_number;
     stats_->max_sequence_reordering =
         max(stats_->max_sequence_reordering, sequence_gap);
     uint32 reordering_time_us =
         receipt_time.Subtract(time_largest_observed_).ToMicroseconds();
-    stats_->max_time_reordering_us = max(stats_->max_time_reordering_us,
-                                         reordering_time_us);
+    stats_->max_time_reordering_us =
+        max(stats_->max_time_reordering_us, reordering_time_us);
   }
   if (header.packet_sequence_number > received_info_.largest_observed) {
     received_info_.largest_observed = header.packet_sequence_number;
     time_largest_observed_ = receipt_time;
   }
   RecordPacketEntropyHash(sequence_number, header.entropy_hash);
 
   receive_algorithm_->RecordIncomingPacket(
       bytes, sequence_number, receipt_time);
 }
@@ skipping 135 matching lines @@
       received_info_.missing_packets.lower_bound(least_unacked));
   return missing_packets_count != received_info_.missing_packets.size();
 }
 
 void QuicReceivedPacketManager::UpdatePacketInformationSentByPeer(
     const QuicStopWaitingFrame& stop_waiting) {
   // ValidateAck() should fail if peer_least_packet_awaiting_ack_ shrinks.
   DCHECK_LE(peer_least_packet_awaiting_ack_, stop_waiting.least_unacked);
   if (stop_waiting.least_unacked > peer_least_packet_awaiting_ack_) {
     bool missed_packets = DontWaitForPacketsBefore(stop_waiting.least_unacked);
-    if (missed_packets || stop_waiting.least_unacked >
-            received_info_.largest_observed + 1) {
+    if (missed_packets ||
+        stop_waiting.least_unacked > received_info_.largest_observed + 1) {
       DVLOG(1) << "Updating entropy hashed since we missed packets";
       // There were some missing packets that we won't ever get now. Recalculate
       // the received entropy hash.
       RecalculateEntropyHash(stop_waiting.least_unacked,
                              stop_waiting.entropy_hash);
     }
     peer_least_packet_awaiting_ack_ = stop_waiting.least_unacked;
   }
   DCHECK(received_info_.missing_packets.empty() ||
          *received_info_.missing_packets.begin() >=
              peer_least_packet_awaiting_ack_);
 }
 
 bool QuicReceivedPacketManager::HasMissingPackets() {
   return !received_info_.missing_packets.empty();
 }
 
 bool QuicReceivedPacketManager::HasNewMissingPackets() {
   return HasMissingPackets() &&
-      (received_info_.largest_observed -
-       *received_info_.missing_packets.rbegin()) <= kMaxPacketsAfterNewMissing;
+         (received_info_.largest_observed -
+          *received_info_.missing_packets.rbegin()) <=
+             kMaxPacketsAfterNewMissing;
 }
 
 }  // namespace net