Clang format slam.

net/quic/quic_ack_notifier_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_ack_notifier_manager.h"
 
 #include <stddef.h>
 #include <list>
 #include <map>
 #include <utility>
 #include <vector>
 
 #include "base/stl_util.h"
 #include "net/quic/quic_ack_notifier.h"
 #include "net/quic/quic_protocol.h"
 
 namespace net {
 
-AckNotifierManager::AckNotifierManager() {}
+AckNotifierManager::AckNotifierManager() {
+}
 
 AckNotifierManager::~AckNotifierManager() {
   STLDeleteElements(&ack_notifiers_);
 }
 
-void AckNotifierManager::OnPacketAcked(
-    QuicPacketSequenceNumber sequence_number,
-    QuicTime::Delta delta_largest_observed) {
+void AckNotifierManager::OnPacketAcked(QuicPacketSequenceNumber sequence_number,
+                                       QuicTime::Delta delta_largest_observed) {
   // Inform all the registered AckNotifiers of the new ACK.
   AckNotifierMap::iterator map_it = ack_notifier_map_.find(sequence_number);
   if (map_it == ack_notifier_map_.end()) {
     // No AckNotifier is interested in this sequence number.
     return;
   }
 
   // One or more AckNotifiers are registered as interested in this sequence
   // number. Iterate through them and call OnAck on each.
   for (AckNotifierSet::iterator set_it = map_it->second.begin();
-       set_it != map_it->second.end(); ++set_it) {
+       set_it != map_it->second.end();
+       ++set_it) {
     QuicAckNotifier* ack_notifier = *set_it;
     ack_notifier->OnAck(sequence_number, delta_largest_observed);
 
     // If this has resulted in an empty AckNotifer, erase it.
     if (ack_notifier->IsEmpty()) {
       delete ack_notifier;
       ack_notifiers_.erase(ack_notifier);
     }
   }
 
   // Remove the sequence number from the map as we have notified all the
   // registered AckNotifiers, and we won't see it again.
   ack_notifier_map_.erase(map_it);
 }
 
 void AckNotifierManager::UpdateSequenceNumber(
     QuicPacketSequenceNumber old_sequence_number,
     QuicPacketSequenceNumber new_sequence_number) {
   AckNotifierMap::iterator map_it = ack_notifier_map_.find(old_sequence_number);
   if (map_it != ack_notifier_map_.end()) {
     // We will add an entry to the map for the new sequence number, and move
     // the
     // list of AckNotifiers over.
     AckNotifierSet new_set;
     for (AckNotifierSet::iterator notifier_it = map_it->second.begin();
-         notifier_it != map_it->second.end(); ++notifier_it) {
+         notifier_it != map_it->second.end();
+         ++notifier_it) {
       (*notifier_it)
           ->UpdateSequenceNumber(old_sequence_number, new_sequence_number);
       new_set.insert(*notifier_it);
     }
     ack_notifier_map_[new_sequence_number] = new_set;
     ack_notifier_map_.erase(map_it);
   }
 }
 
 void AckNotifierManager::OnSerializedPacket(
     const SerializedPacket& serialized_packet) {
   // Run through all the frames and if any of them are stream frames and have
   // an AckNotifier registered, then inform the AckNotifier that it should be
   // interested in this packet's sequence number.
 
   RetransmittableFrames* frames = serialized_packet.retransmittable_frames;
 
   // AckNotifiers can only be attached to retransmittable frames.
   if (!frames) {
     return;
   }
 
   for (QuicFrames::const_iterator it = frames->frames().begin();
-       it != frames->frames().end(); ++it) {
+       it != frames->frames().end();
+       ++it) {
     if (it->type == STREAM_FRAME && it->stream_frame->notifier != NULL) {
       QuicAckNotifier* notifier = it->stream_frame->notifier;
 
       // The AckNotifier needs to know it is tracking this packet's sequence
       // number.
       notifier->AddSequenceNumber(serialized_packet.sequence_number,
                                   serialized_packet.packet->length());
 
       // Update the mapping in the other direction, from sequence
       // number to AckNotifier.
       ack_notifier_map_[serialized_packet.sequence_number].insert(notifier);
 
       // Take ownership of the AckNotifier.
       ack_notifiers_.insert(notifier);
     }
   }
 }
 
 }  // namespace net