Clang format slam.

net/quic/quic_packet_generator.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/quic_packet_generator.h"
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "net/quic/quic_fec_group.h"
 #include "net/quic/quic_utils.h"
@@ skipping 11 matching lines @@
       debug_delegate_(debug_delegate),
       packet_creator_(creator),
       batch_mode_(false),
       should_send_ack_(false),
       should_send_feedback_(false),
       should_send_stop_waiting_(false) {
 }
 
 QuicPacketGenerator::~QuicPacketGenerator() {
   for (QuicFrames::iterator it = queued_control_frames_.begin();
-       it != queued_control_frames_.end(); ++it) {
+       it != queued_control_frames_.end();
+       ++it) {
     switch (it->type) {
       case PADDING_FRAME:
         delete it->padding_frame;
         break;
       case STREAM_FRAME:
         delete it->stream_frame;
         break;
       case ACK_FRAME:
         delete it->ack_frame;
         break;
@@ skipping 55 matching lines @@
 
   size_t total_bytes_consumed = 0;
   bool fin_consumed = false;
 
   if (!packet_creator_->HasRoomForStreamFrame(id, offset)) {
     SerializeAndSendPacket();
   }
 
   IOVector data = data_to_write;
   size_t data_size = data.TotalBufferSize();
-  while (delegate_->ShouldGeneratePacket(NOT_RETRANSMISSION,
-                                         HAS_RETRANSMITTABLE_DATA, handshake)) {
+  while (delegate_->ShouldGeneratePacket(
+      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, handshake)) {
     QuicFrame frame;
     size_t bytes_consumed;
     if (notifier != NULL) {
       // We want to track which packet this stream frame ends up in.
       bytes_consumed = packet_creator_->CreateStreamFrameWithNotifier(
           id, data, offset + total_bytes_consumed, fin, notifier, &frame);
     } else {
       bytes_consumed = packet_creator_->CreateStreamFrame(
           id, data, offset + total_bytes_consumed, fin, &frame);
     }
@@ skipping 34 matching lines @@
   }
 
   DCHECK(InBatchMode() || !packet_creator_->HasPendingFrames());
   return QuicConsumedData(total_bytes_consumed, fin_consumed);
 }
 
 bool QuicPacketGenerator::CanSendWithNextPendingFrameAddition() const {
   DCHECK(HasPendingFrames());
   HasRetransmittableData retransmittable =
       (should_send_ack_ || should_send_feedback_ || should_send_stop_waiting_)
-      ? NO_RETRANSMITTABLE_DATA : HAS_RETRANSMITTABLE_DATA;
+          ? NO_RETRANSMITTABLE_DATA
+          : HAS_RETRANSMITTABLE_DATA;
   if (retransmittable == HAS_RETRANSMITTABLE_DATA) {
-      DCHECK(!queued_control_frames_.empty());  // These are retransmittable.
+    DCHECK(!queued_control_frames_.empty());  // These are retransmittable.
   }
-  return delegate_->ShouldGeneratePacket(NOT_RETRANSMISSION, retransmittable,
-                                         NOT_HANDSHAKE);
+  return delegate_->ShouldGeneratePacket(
+      NOT_RETRANSMISSION, retransmittable, NOT_HANDSHAKE);
 }
 
 void QuicPacketGenerator::SendQueuedFrames(bool flush) {
   // Only add pending frames if we are SURE we can then send the whole packet.
   while (HasPendingFrames() &&
          (flush || CanSendWithNextPendingFrameAddition())) {
     if (!AddNextPendingFrame()) {
       // Packet was full, so serialize and send it.
       SerializeAndSendPacket();
     }
@@ skipping 33 matching lines @@
 void QuicPacketGenerator::FlushAllQueuedFrames() {
   SendQueuedFrames(true);
 }
 
 bool QuicPacketGenerator::HasQueuedFrames() const {
   return packet_creator_->HasPendingFrames() || HasPendingFrames();
 }
 
 bool QuicPacketGenerator::HasPendingFrames() const {
   return should_send_ack_ || should_send_feedback_ ||
-      should_send_stop_waiting_ || !queued_control_frames_.empty();
+         should_send_stop_waiting_ || !queued_control_frames_.empty();
 }
 
 bool QuicPacketGenerator::AddNextPendingFrame() {
   if (should_send_ack_) {
     pending_ack_frame_.reset(delegate_->CreateAckFrame());
     // If we can't this add the frame now, then we still need to do so later.
     should_send_ack_ = !AddFrame(QuicFrame(pending_ack_frame_.get()));
     // Return success if we have cleared out this flag (i.e., added the frame).
     // If we still need to send, then the frame is full, and we have failed.
     return !should_send_ack_;
@@ skipping 44 matching lines @@
   if (packet_creator_->ShouldSendFec(false)) {
     // TODO(jri): SerializeFec can return a NULL packet, and this should
     // cause an early return, with a call to delegate_->OnPacketGenerationError.
     SerializedPacket serialized_fec = packet_creator_->SerializeFec();
     DCHECK(serialized_fec.packet);
     delegate_->OnSerializedPacket(serialized_fec);
   }
 }
 
 }  // namespace net