Clang format slam.

net/quic/quic_connection_logger.cc

Index: net/quic/quic_connection_logger.cc
diff --git a/net/quic/quic_connection_logger.cc b/net/quic/quic_connection_logger.cc
index cd579ff27ebf63faca39279b41c13490dc65d25c..cfa710ae2118c609c3df8955a1d7daf782245542 100644
--- a/net/quic/quic_connection_logger.cc
+++ b/net/quic/quic_connection_logger.cc
@@ -117,7 +117,8 @@ base::Value* NetLogQuicAckFrameCallback(const QuicAckFrame* frame,
   const SequenceNumberSet& missing_packets =
       frame->received_info.missing_packets;
   for (SequenceNumberSet::const_iterator it = missing_packets.begin();
-       it != missing_packets.end(); ++it) {
+       it != missing_packets.end();
+       ++it) {
     missing->AppendString(base::Uint64ToString(*it));
   }
   return dict;
@@ -134,9 +135,10 @@ base::Value* NetLogQuicCongestionFeedbackFrameCallback(
       dict->Set("received_packets", received);
       for (TimeMap::const_iterator it =
                frame->inter_arrival.received_packet_times.begin();
-           it != frame->inter_arrival.received_packet_times.end(); ++it) {
+           it != frame->inter_arrival.received_packet_times.end();
+           ++it) {
         string value = base::Uint64ToString(it->first) + "@" +
-            base::Uint64ToString(it->second.ToDebuggingValue());
+                       base::Uint64ToString(it->second.ToDebuggingValue());
         received->AppendString(value);
       }
       break;
@@ -183,9 +185,8 @@ base::Value* NetLogQuicWindowUpdateFrameCallback(
   return dict;
 }
 
-base::Value* NetLogQuicBlockedFrameCallback(
-    const QuicBlockedFrame* frame,
-    NetLog::LogLevel /* log_level */) {
+base::Value* NetLogQuicBlockedFrameCallback(const QuicBlockedFrame* frame,
+                                            NetLog::LogLevel /* log_level */) {
   base::DictionaryValue* dict = new base::DictionaryValue();
   dict->SetInteger("stream_id", frame->stream_id);
   return dict;
@@ -209,7 +210,8 @@ base::Value* NetLogQuicVersionNegotiationPacketCallback(
   base::ListValue* versions = new base::ListValue();
   dict->Set("versions", versions);
   for (QuicVersionVector::const_iterator it = packet->versions.begin();
-       it != packet->versions.end(); ++it) {
+       it != packet->versions.end();
+       ++it) {
     versions->AppendString(QuicVersionToString(*it));
   }
   return dict;
@@ -248,7 +250,8 @@ void UpdatePublicResetAddressMismatchHistogram(
     return;
   }
   UMA_HISTOGRAM_ENUMERATION("Net.QuicSession.PublicResetAddressMismatch",
-                            sample, QUIC_ADDRESS_MISMATCH_MAX);
+                            sample,
+                            QUIC_ADDRESS_MISMATCH_MAX);
 }
 
 const char* GetConnectionDescriptionString() {
@@ -296,7 +299,6 @@ const char* GetConnectionDescriptionString() {
   return description;
 }
 
-
 }  // namespace
 
 QuicConnectionLogger::QuicConnectionLogger(const BoundNetLog& net_log)
@@ -327,12 +329,17 @@ QuicConnectionLogger::~QuicConnectionLogger() {
     if (num_packets_received_ < 100) {
       UMA_HISTOGRAM_CUSTOM_COUNTS(
           "Net.QuicSession.StreamFrameDuplicatedShortConnection",
-          duplicate_stream_frame_per_thousand, 1, 1000, 75);
+          duplicate_stream_frame_per_thousand,
+          1,
+          1000,
+          75);
     } else {
       UMA_HISTOGRAM_CUSTOM_COUNTS(
           "Net.QuicSession.StreamFrameDuplicatedLongConnection",
-          duplicate_stream_frame_per_thousand, 1, 1000, 75);
-
+          duplicate_stream_frame_per_thousand,
+          1,
+          1000,
+          75);
     }
   }
 
@@ -364,36 +371,31 @@ void QuicConnectionLogger::OnFrameAddedToPacket(const QuicFrame& frame) {
     case RST_STREAM_FRAME:
       UMA_HISTOGRAM_SPARSE_SLOWLY("Net.QuicSession.RstStreamErrorCodeClient",
                                   frame.rst_stream_frame->error_code);
-      net_log_.AddEvent(
-          NetLog::TYPE_QUIC_SESSION_RST_STREAM_FRAME_SENT,
-          base::Bind(&NetLogQuicRstStreamFrameCallback,
-                     frame.rst_stream_frame));
+      net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_RST_STREAM_FRAME_SENT,
+                        base::Bind(&NetLogQuicRstStreamFrameCallback,
+                                   frame.rst_stream_frame));
       break;
     case CONNECTION_CLOSE_FRAME:
-      net_log_.AddEvent(
-          NetLog::TYPE_QUIC_SESSION_CONNECTION_CLOSE_FRAME_SENT,
-          base::Bind(&NetLogQuicConnectionCloseFrameCallback,
-                     frame.connection_close_frame));
+      net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_CONNECTION_CLOSE_FRAME_SENT,
+                        base::Bind(&NetLogQuicConnectionCloseFrameCallback,
+                                   frame.connection_close_frame));
       break;
     case GOAWAY_FRAME:
       break;
     case WINDOW_UPDATE_FRAME:
-      net_log_.AddEvent(
-          NetLog::TYPE_QUIC_SESSION_WINDOW_UPDATE_FRAME_SENT,
-          base::Bind(&NetLogQuicWindowUpdateFrameCallback,
-                     frame.window_update_frame));
+      net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_WINDOW_UPDATE_FRAME_SENT,
+                        base::Bind(&NetLogQuicWindowUpdateFrameCallback,
+                                   frame.window_update_frame));
       break;
     case BLOCKED_FRAME:
       net_log_.AddEvent(
           NetLog::TYPE_QUIC_SESSION_BLOCKED_FRAME_SENT,
-          base::Bind(&NetLogQuicBlockedFrameCallback,
-                     frame.blocked_frame));
+          base::Bind(&NetLogQuicBlockedFrameCallback, frame.blocked_frame));
       break;
     case STOP_WAITING_FRAME:
-      net_log_.AddEvent(
-          NetLog::TYPE_QUIC_SESSION_STOP_WAITING_FRAME_SENT,
-          base::Bind(&NetLogQuicStopWaitingFrameCallback,
-                     frame.stop_waiting_frame));
+      net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_STOP_WAITING_FRAME_SENT,
+                        base::Bind(&NetLogQuicStopWaitingFrameCallback,
+                                   frame.stop_waiting_frame));
       break;
     default:
       DCHECK(false) << "Illegal frame type: " << frame.type;
@@ -406,29 +408,33 @@ void QuicConnectionLogger::OnPacketSent(
     TransmissionType transmission_type,
     const QuicEncryptedPacket& packet,
     WriteResult result) {
-  net_log_.AddEvent(
-      NetLog::TYPE_QUIC_SESSION_PACKET_SENT,
-      base::Bind(&NetLogQuicPacketSentCallback, sequence_number, level,
-                 transmission_type, packet.length(), result));
+  net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_PACKET_SENT,
+                    base::Bind(&NetLogQuicPacketSentCallback,
+                               sequence_number,
+                               level,
+                               transmission_type,
+                               packet.length(),
+                               result));
 }
 
-void QuicConnectionLogger:: OnPacketRetransmitted(
-      QuicPacketSequenceNumber old_sequence_number,
-      QuicPacketSequenceNumber new_sequence_number) {
-  net_log_.AddEvent(
-      NetLog::TYPE_QUIC_SESSION_PACKET_RETRANSMITTED,
-      base::Bind(&NetLogQuicPacketRetransmittedCallback,
-                 old_sequence_number, new_sequence_number));
+void QuicConnectionLogger::OnPacketRetransmitted(
+    QuicPacketSequenceNumber old_sequence_number,
+    QuicPacketSequenceNumber new_sequence_number) {
+  net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_PACKET_RETRANSMITTED,
+                    base::Bind(&NetLogQuicPacketRetransmittedCallback,
+                               old_sequence_number,
+                               new_sequence_number));
 }
 
 void QuicConnectionLogger::OnPacketReceived(const IPEndPoint& self_address,
                                             const IPEndPoint& peer_address,
                                             const QuicEncryptedPacket& packet) {
   last_received_packet_size_ = packet.length();
-  net_log_.AddEvent(
-      NetLog::TYPE_QUIC_SESSION_PACKET_RECEIVED,
-      base::Bind(&NetLogQuicPacketCallback, &self_address, &peer_address,
-                 packet.length()));
+  net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_PACKET_RECEIVED,
+                    base::Bind(&NetLogQuicPacketCallback,
+                               &self_address,
+                               &peer_address,
+                               packet.length()));
 }
 
 void QuicConnectionLogger::OnProtocolVersionMismatch(
@@ -437,14 +443,13 @@ void QuicConnectionLogger::OnProtocolVersionMismatch(
 }
 
 void QuicConnectionLogger::OnPacketHeader(const QuicPacketHeader& header) {
-  net_log_.AddEvent(
-      NetLog::TYPE_QUIC_SESSION_PACKET_HEADER_RECEIVED,
-      base::Bind(&NetLogQuicPacketHeaderCallback, &header));
+  net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_PACKET_HEADER_RECEIVED,
+                    base::Bind(&NetLogQuicPacketHeaderCallback, &header));
   ++num_packets_received_;
   if (largest_received_packet_sequence_number_ <
       header.packet_sequence_number) {
     QuicPacketSequenceNumber delta = header.packet_sequence_number -
-        largest_received_packet_sequence_number_;
+                                     largest_received_packet_sequence_number_;
     if (delta > 1) {
       // There is a gap between the largest packet previously received and
       // the current packet.  This indicates either loss, or out-of-order
@@ -457,23 +462,21 @@ void QuicConnectionLogger::OnPacketHeader(const QuicPacketHeader& header) {
     received_packets_[header.packet_sequence_number] = true;
   if (header.packet_sequence_number < last_received_packet_sequence_number_) {
     ++num_out_of_order_received_packets_;
-    UMA_HISTOGRAM_COUNTS("Net.QuicSession.OutOfOrderGapReceived",
-                         last_received_packet_sequence_number_ -
-                             header.packet_sequence_number);
+    UMA_HISTOGRAM_COUNTS(
+        "Net.QuicSession.OutOfOrderGapReceived",
+        last_received_packet_sequence_number_ - header.packet_sequence_number);
   }
   last_received_packet_sequence_number_ = header.packet_sequence_number;
 }
 
 void QuicConnectionLogger::OnStreamFrame(const QuicStreamFrame& frame) {
-  net_log_.AddEvent(
-      NetLog::TYPE_QUIC_SESSION_STREAM_FRAME_RECEIVED,
-      base::Bind(&NetLogQuicStreamFrameCallback, &frame));
+  net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_STREAM_FRAME_RECEIVED,
+                    base::Bind(&NetLogQuicStreamFrameCallback, &frame));
 }
 
 void QuicConnectionLogger::OnAckFrame(const QuicAckFrame& frame) {
-  net_log_.AddEvent(
-      NetLog::TYPE_QUIC_SESSION_ACK_FRAME_RECEIVED,
-      base::Bind(&NetLogQuicAckFrameCallback, &frame));
+  net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_ACK_FRAME_RECEIVED,
+                    base::Bind(&NetLogQuicAckFrameCallback, &frame));
 
   const size_t kApproximateLargestSoloAckBytes = 100;
   if (last_received_packet_sequence_number_ < received_acks_.size() &&
@@ -515,8 +518,7 @@ void QuicConnectionLogger::OnAckFrame(const QuicAckFrame& frame) {
   if (num_consecutive_missing_packets != 0) {
     UpdatePacketGapSentHistogram(num_consecutive_missing_packets);
   }
-  largest_received_missing_packet_sequence_number_ =
-        *missing_packets.rbegin();
+  largest_received_missing_packet_sequence_number_ = *missing_packets.rbegin();
 }
 
 void QuicConnectionLogger::OnCongestionFeedbackFrame(
@@ -528,17 +530,15 @@ void QuicConnectionLogger::OnCongestionFeedbackFrame(
 
 void QuicConnectionLogger::OnStopWaitingFrame(
     const QuicStopWaitingFrame& frame) {
-  net_log_.AddEvent(
-      NetLog::TYPE_QUIC_SESSION_STOP_WAITING_FRAME_RECEIVED,
-      base::Bind(&NetLogQuicStopWaitingFrameCallback, &frame));
+  net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_STOP_WAITING_FRAME_RECEIVED,
+                    base::Bind(&NetLogQuicStopWaitingFrameCallback, &frame));
 }
 
 void QuicConnectionLogger::OnRstStreamFrame(const QuicRstStreamFrame& frame) {
   UMA_HISTOGRAM_SPARSE_SLOWLY("Net.QuicSession.RstStreamErrorCodeServer",
                               frame.error_code);
-  net_log_.AddEvent(
-      NetLog::TYPE_QUIC_SESSION_RST_STREAM_FRAME_RECEIVED,
-      base::Bind(&NetLogQuicRstStreamFrameCallback, &frame));
+  net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_RST_STREAM_FRAME_RECEIVED,
+                    base::Bind(&NetLogQuicRstStreamFrameCallback, &frame));
 }
 
 void QuicConnectionLogger::OnConnectionCloseFrame(
@@ -622,7 +622,9 @@ base::HistogramBase* QuicConnectionLogger::GetPacketSequenceNumberHistogram(
   string prefix("Net.QuicSession.PacketReceived_");
   return base::LinearHistogram::FactoryGet(
       prefix + statistic_name + connection_description_,
-      1, received_packets_.size(), received_packets_.size() + 1,
+      1,
+      received_packets_.size(),
+      received_packets_.size() + 1,
       base::HistogramBase::kUmaTargetedHistogramFlag);
 }
 
@@ -632,12 +634,15 @@ base::HistogramBase* QuicConnectionLogger::Get6PacketHistogram(
   // received.  As a result, there are 64 possible sample-patterns.
   string prefix("Net.QuicSession.6PacketsPatternsReceived_");
   return base::LinearHistogram::FactoryGet(
-      prefix + which_6 + connection_description_, 1, 64, 65,
+      prefix + which_6 + connection_description_,
+      1,
+      64,
+      65,
       base::HistogramBase::kUmaTargetedHistogramFlag);
 }
 
 base::HistogramBase* QuicConnectionLogger::Get21CumulativeHistogram(
-  const char* which_21) const {
+    const char* which_21) const {
   // This histogram contains, for each sequence of 21 packets, the results from
   // 21 distinct questions about that sequence.  Conceptually the histogtram is
   // broken into 21 distinct ranges, and one sample is added into each of those
@@ -654,7 +659,8 @@ base::HistogramBase* QuicConnectionLogger::Get21CumulativeHistogram(
   string prefix("Net.QuicSession.21CumulativePacketsReceived_");
   return base::LinearHistogram::FactoryGet(
       prefix + which_21 + connection_description_,
-      1, kBoundingSampleInCumulativeHistogram,
+      1,
+      kBoundingSampleInCumulativeHistogram,
       kBoundingSampleInCumulativeHistogram + 1,
       base::HistogramBase::kUmaTargetedHistogramFlag);
 }
@@ -698,7 +704,10 @@ void QuicConnectionLogger::RecordAggregatePacketLossRate() const {
     divisor /= 1000;
   string prefix("Net.QuicSession.PacketLossRate_");
   base::HistogramBase* histogram = base::Histogram::FactoryGet(
-      prefix + connection_description_, 1, 1000, 75,
+      prefix + connection_description_,
+      1,
+      1000,
+      75,
       base::HistogramBase::kUmaTargetedHistogramFlag);
   histogram->Add(numerator / divisor);
 }
@@ -724,7 +733,8 @@ void QuicConnectionLogger::RecordLossHistograms() const {
 
   DCHECK_EQ(received_packets_.size(), received_acks_.size());
   const QuicPacketSequenceNumber last_index =
-      std::min<QuicPacketSequenceNumber>(received_packets_.size() - 1,
+      std::min<QuicPacketSequenceNumber>(
+          received_packets_.size() - 1,
           largest_received_packet_sequence_number_);
   const QuicPacketSequenceNumber index_of_first_21_contribution =
       std::min<QuicPacketSequenceNumber>(21, last_index);
@@ -750,14 +760,14 @@ void QuicConnectionLogger::RecordLossHistograms() const {
     }
 
     if (i == index_of_first_21_contribution) {
-      AddTo21CumulativeHistogram(first_cumulative_packet_histogram,
-                                 packet_pattern_21, i);
+      AddTo21CumulativeHistogram(
+          first_cumulative_packet_histogram, packet_pattern_21, i);
     }
     // We'll just record for non-overlapping ranges, to reduce histogramming
     // cost for now.  Each call does 21 separate histogram additions.
     if (i > 21 || i % 21 == 0) {
-      AddTo21CumulativeHistogram(ongoing_cumulative_packet_histogram,
-                                 packet_pattern_21, 21);
+      AddTo21CumulativeHistogram(
+          ongoing_cumulative_packet_histogram, packet_pattern_21, 21);
     }
 
     if (i < 6)