Clang format slam.

net/quic/quic_packet_creator.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_creator.h"
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "net/quic/crypto/quic_random.h"
 #include "net/quic/quic_ack_notifier.h"
 #include "net/quic/quic_fec_group.h"
 #include "net/quic/quic_utils.h"
 
 using base::StringPiece;
 using std::make_pair;
 using std::max;
 using std::min;
 using std::pair;
 using std::vector;
 
 namespace net {
 
 // A QuicRandom wrapper that gets a bucket of entropy and distributes it
 // bit-by-bit. Replenishes the bucket as needed. Not thread-safe. Expose this
 // class if single bit randomness is needed elsewhere.
 class QuicRandomBoolSource {
  public:
   // random: Source of entropy. Not owned.
   explicit QuicRandomBoolSource(QuicRandom* random)
-      : random_(random),
-        bit_bucket_(0),
-        bit_mask_(0) {}
+      : random_(random), bit_bucket_(0), bit_mask_(0) {}
 
   ~QuicRandomBoolSource() {}
 
   // Returns the next random bit from the bucket.
   bool RandBool() {
     if (bit_mask_ == 0) {
       bit_bucket_ = random_->RandUint64();
       bit_mask_ = 1;
     }
     bool result = ((bit_bucket_ & bit_mask_) != 0);
@@ skipping 25 matching lines @@
       send_version_in_packet_(!is_server),
       sequence_number_length_(options_.send_sequence_number_length),
       packet_size_(0) {
   framer_->set_fec_builder(this);
 }
 
 QuicPacketCreator::~QuicPacketCreator() {
 }
 
 void QuicPacketCreator::OnBuiltFecProtectedPayload(
-    const QuicPacketHeader& header, StringPiece payload) {
+    const QuicPacketHeader& header,
+    StringPiece payload) {
   if (fec_group_.get()) {
     DCHECK_NE(0u, header.fec_group);
     fec_group_->Update(header, payload);
   }
 }
 
 bool QuicPacketCreator::ShouldSendFec(bool force_close) const {
   return fec_group_.get() != NULL && fec_group_->NumReceivedPackets() > 0 &&
-      (force_close ||
-       fec_group_->NumReceivedPackets() >= options_.max_packets_per_fec_group);
+         (force_close ||
+          fec_group_->NumReceivedPackets() >=
+              options_.max_packets_per_fec_group);
 }
 
 InFecGroup QuicPacketCreator::MaybeStartFEC() {
   if (IsFecEnabled() && fec_group_.get() == NULL) {
     DCHECK(queued_frames_.empty());
     // Set the fec group number to the sequence number of the next packet.
     fec_group_number_ = sequence_number() + 1;
     fec_group_.reset(new QuicFecGroup());
   }
   return fec_group_.get() == NULL ? NOT_IN_FEC_GROUP : IN_FEC_GROUP;
 }
 
 // Stops serializing version of the protocol in packets sent after this call.
 // A packet that is already open might send kQuicVersionSize bytes less than the
 // maximum packet size if we stop sending version before it is serialized.
 void QuicPacketCreator::StopSendingVersion() {
   DCHECK(send_version_in_packet_);
   send_version_in_packet_ = false;
   if (packet_size_ > 0) {
     DCHECK_LT(kQuicVersionSize, packet_size_);
     packet_size_ -= kQuicVersionSize;
   }
 }
 
 void QuicPacketCreator::UpdateSequenceNumberLength(
-      QuicPacketSequenceNumber least_packet_awaited_by_peer,
-      QuicByteCount congestion_window) {
+    QuicPacketSequenceNumber least_packet_awaited_by_peer,
+    QuicByteCount congestion_window) {
   DCHECK_LE(least_packet_awaited_by_peer, sequence_number_ + 1);
   // Since the packet creator will not change sequence number length mid FEC
   // group, include the size of an FEC group to be safe.
   const QuicPacketSequenceNumber current_delta =
-      options_.max_packets_per_fec_group + sequence_number_ + 1
-      - least_packet_awaited_by_peer;
+      options_.max_packets_per_fec_group + sequence_number_ + 1 -
+      least_packet_awaited_by_peer;
   const uint64 congestion_window_packets =
       congestion_window / options_.max_packet_length;
   const uint64 delta = max(current_delta, congestion_window_packets);
   options_.send_sequence_number_length =
       QuicFramer::GetMinSequenceNumberLength(delta * 4);
 }
 
 bool QuicPacketCreator::HasRoomForStreamFrame(QuicStreamId id,
                                               QuicStreamOffset offset) const {
   // TODO(jri): This is a simple safe decision for now, but make
   // is_in_fec_group a parameter. Same as with all public methods in
   // QuicPacketCreator.
   return BytesFree() >
-      QuicFramer::GetMinStreamFrameSize(framer_->version(), id, offset, true,
-                                        IsFecEnabled());
+         QuicFramer::GetMinStreamFrameSize(
+             framer_->version(), id, offset, true, IsFecEnabled());
 }
 
 // static
 size_t QuicPacketCreator::StreamFramePacketOverhead(
     QuicVersion version,
     QuicConnectionIdLength connection_id_length,
     bool include_version,
     QuicSequenceNumberLength sequence_number_length,
     InFecGroup is_in_fec_group) {
-  return GetPacketHeaderSize(connection_id_length, include_version,
-                             sequence_number_length, is_in_fec_group) +
-      // Assumes this is a stream with a single lone packet.
-      QuicFramer::GetMinStreamFrameSize(version, 1u, 0u, true, is_in_fec_group);
+  return GetPacketHeaderSize(connection_id_length,
+                             include_version,
+                             sequence_number_length,
+                             is_in_fec_group) +
+         // Assumes this is a stream with a single lone packet.
+         QuicFramer::GetMinStreamFrameSize(
+             version, 1u, 0u, true, is_in_fec_group);
 }
 
 size_t QuicPacketCreator::CreateStreamFrame(QuicStreamId id,
                                             const IOVector& data,
                                             QuicStreamOffset offset,
                                             bool fin,
                                             QuicFrame* frame) {
   DCHECK_GT(options_.max_packet_length,
-            StreamFramePacketOverhead(
-                framer_->version(), PACKET_8BYTE_CONNECTION_ID, kIncludeVersion,
-                PACKET_6BYTE_SEQUENCE_NUMBER, IN_FEC_GROUP));
+            StreamFramePacketOverhead(framer_->version(),
+                                      PACKET_8BYTE_CONNECTION_ID,
+                                      kIncludeVersion,
+                                      PACKET_6BYTE_SEQUENCE_NUMBER,
+                                      IN_FEC_GROUP));
   InFecGroup is_in_fec_group = MaybeStartFEC();
 
   LOG_IF(DFATAL, !HasRoomForStreamFrame(id, offset))
       << "No room for Stream frame, BytesFree: " << BytesFree()
       << " MinStreamFrameSize: "
       << QuicFramer::GetMinStreamFrameSize(
-          framer_->version(), id, offset, true, is_in_fec_group);
+             framer_->version(), id, offset, true, is_in_fec_group);
 
   if (data.Empty()) {
-    LOG_IF(DFATAL, !fin)
-        << "Creating a stream frame with no data or fin.";
+    LOG_IF(DFATAL, !fin) << "Creating a stream frame with no data or fin.";
     // Create a new packet for the fin, if necessary.
     *frame = QuicFrame(new QuicStreamFrame(id, true, offset, data));
     return 0;
   }
 
   const size_t data_size = data.TotalBufferSize();
-  size_t min_frame_size = QuicFramer::GetMinStreamFrameSize(
-      framer_->version(), id, offset, /*last_frame_in_packet=*/ true,
-      is_in_fec_group);
+  size_t min_frame_size =
+      QuicFramer::GetMinStreamFrameSize(framer_->version(),
+                                        id,
+                                        offset,
+                                        /*last_frame_in_packet=*/true,
+                                        is_in_fec_group);
   size_t bytes_consumed = min<size_t>(BytesFree() - min_frame_size, data_size);
 
   bool set_fin = fin && bytes_consumed == data_size;  // Last frame.
   IOVector frame_data;
-  frame_data.AppendIovecAtMostBytes(data.iovec(), data.Size(),
-                                    bytes_consumed);
+  frame_data.AppendIovecAtMostBytes(data.iovec(), data.Size(), bytes_consumed);
   DCHECK_EQ(frame_data.TotalBufferSize(), bytes_consumed);
   *frame = QuicFrame(new QuicStreamFrame(id, set_fin, offset, frame_data));
   return bytes_consumed;
 }
 
 size_t QuicPacketCreator::CreateStreamFrameWithNotifier(
     QuicStreamId id,
     const IOVector& data,
     QuicStreamOffset offset,
     bool fin,
@@ skipping 34 matching lines @@
 
   return serialized_packet;
 }
 
 SerializedPacket QuicPacketCreator::SerializeAllFrames(
     const QuicFrames& frames) {
   // TODO(satyamshekhar): Verify that this DCHECK won't fail. What about queued
   // frames from SendStreamData()[send_stream_should_flush_ == false &&
   // data.empty() == true] and retransmit due to RTO.
   DCHECK_EQ(0u, queued_frames_.size());
-  LOG_IF(DFATAL, frames.empty())
-      << "Attempt to serialize empty packet";
+  LOG_IF(DFATAL, frames.empty()) << "Attempt to serialize empty packet";
   for (size_t i = 0; i < frames.size(); ++i) {
     bool success = AddFrame(frames[i], false);
     DCHECK(success);
   }
   SerializedPacket packet = SerializePacket();
   DCHECK(packet.retransmittable_frames == NULL);
   return packet;
 }
 
 bool QuicPacketCreator::HasPendingFrames() {
   return !queued_frames_.empty();
 }
 
 size_t QuicPacketCreator::ExpansionOnNewFrame() const {
   // If packet is FEC protected, there's no expansion.
   if (fec_group_.get() != NULL) {
-      return 0;
+    return 0;
   }
   // If the last frame in the packet is a stream frame, then it will expand to
   // include the stream_length field when a new frame is added.
   bool has_trailing_stream_frame =
       !queued_frames_.empty() && queued_frames_.back().type == STREAM_FRAME;
   return has_trailing_stream_frame ? kQuicStreamPayloadLengthSize : 0;
 }
 
 size_t QuicPacketCreator::BytesFree() const {
   const size_t max_plaintext_size =
       framer_->GetMaxPlaintextSize(options_.max_packet_length);
   DCHECK_GE(max_plaintext_size, PacketSize());
-  return max_plaintext_size - min(max_plaintext_size, PacketSize()
-                                  + ExpansionOnNewFrame());
+  return max_plaintext_size -
+         min(max_plaintext_size, PacketSize() + ExpansionOnNewFrame());
 }
 
 InFecGroup QuicPacketCreator::IsFecEnabled() const {
-  return (options_.max_packets_per_fec_group == 0) ?
-          NOT_IN_FEC_GROUP : IN_FEC_GROUP;
+  return (options_.max_packets_per_fec_group == 0) ? NOT_IN_FEC_GROUP
+                                                   : IN_FEC_GROUP;
 }
 
 size_t QuicPacketCreator::PacketSize() const {
   if (queued_frames_.empty()) {
     // Only adjust the sequence number length when the FEC group is not open,
     // to ensure no packets in a group are too large.
-    if (fec_group_.get() == NULL ||
-        fec_group_->NumReceivedPackets() == 0) {
+    if (fec_group_.get() == NULL || fec_group_->NumReceivedPackets() == 0) {
       sequence_number_length_ = options_.send_sequence_number_length;
     }
     packet_size_ = GetPacketHeaderSize(options_.send_connection_id_length,
                                        send_version_in_packet_,
                                        sequence_number_length_,
                                        IsFecEnabled());
   }
   return packet_size_;
 }
 
 bool QuicPacketCreator::AddSavedFrame(const QuicFrame& frame) {
   return AddFrame(frame, true);
 }
 
 SerializedPacket QuicPacketCreator::SerializePacket() {
-  LOG_IF(DFATAL, queued_frames_.empty())
-      << "Attempt to serialize empty packet";
+  LOG_IF(DFATAL, queued_frames_.empty()) << "Attempt to serialize empty packet";
   QuicPacketHeader header;
   FillPacketHeader(fec_group_number_, false, &header);
 
   MaybeAddPadding();
 
   size_t max_plaintext_size =
       framer_->GetMaxPlaintextSize(options_.max_packet_length);
   DCHECK_GE(max_plaintext_size, packet_size_);
   // ACK and CONNECTION_CLOSE Frames will be truncated only if they're
   // the first frame in the packet.  If truncation is to occur, then
   // GetSerializedFrameLength will have returned all bytes free.
   bool possibly_truncated =
-      packet_size_ != max_plaintext_size ||
-      queued_frames_.size() != 1 ||
+      packet_size_ != max_plaintext_size || queued_frames_.size() != 1 ||
       (queued_frames_.back().type == ACK_FRAME ||
        queued_frames_.back().type == CONNECTION_CLOSE_FRAME);
   SerializedPacket serialized =
       framer_->BuildDataPacket(header, queued_frames_, packet_size_);
-  LOG_IF(DFATAL, !serialized.packet)
-      << "Failed to serialize " << queued_frames_.size() << " frames.";
+  LOG_IF(DFATAL, !serialized.packet) << "Failed to serialize "
+                                     << queued_frames_.size() << " frames.";
   // Because of possible truncation, we can't be confident that our
   // packet size calculation worked correctly.
   if (!possibly_truncated)
     DCHECK_EQ(packet_size_, serialized.packet->length());
 
   packet_size_ = 0;
   queued_frames_.clear();
   serialized.retransmittable_frames = queued_retransmittable_frames_.release();
   return serialized;
 }
@@ skipping 66 matching lines @@
       return false;
     default:
       return true;
   }
 }
 
 bool QuicPacketCreator::AddFrame(const QuicFrame& frame,
                                  bool save_retransmittable_frames) {
   DVLOG(1) << "Adding frame: " << frame;
   InFecGroup is_in_fec_group = MaybeStartFEC();
-  size_t frame_len = framer_->GetSerializedFrameLength(
-      frame, BytesFree(), queued_frames_.empty(), true, is_in_fec_group,
-      options()->send_sequence_number_length);
+  size_t frame_len =
+      framer_->GetSerializedFrameLength(frame,
+                                        BytesFree(),
+                                        queued_frames_.empty(),
+                                        true,
+                                        is_in_fec_group,
+                                        options()->send_sequence_number_length);
   if (frame_len == 0) {
     return false;
   }
   DCHECK_LT(0u, packet_size_);
   packet_size_ += ExpansionOnNewFrame() + frame_len;
 
   if (save_retransmittable_frames && ShouldRetransmit(frame)) {
     if (queued_retransmittable_frames_.get() == NULL) {
       queued_retransmittable_frames_.reset(new RetransmittableFrames());
     }
@@ skipping 29 matching lines @@
   if (!is_handshake) {
     return;
   }
 
   QuicPaddingFrame padding;
   bool success = AddFrame(QuicFrame(&padding), false);
   DCHECK(success);
 }
 
 }  // namespace net