Clang format slam.

net/quic/quic_protocol.h

 // 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.
 
 #ifndef NET_QUIC_QUIC_PROTOCOL_H_
 #define NET_QUIC_QUIC_PROTOCOL_H_
 
 #include <stddef.h>
 #include <limits>
 #include <map>
@@ skipping 85 matching lines @@
 const QuicHeaderId kMaxHeaderIdDelta = 200;
 
 // Reserved ID for the crypto stream.
 const QuicStreamId kCryptoStreamId = 1;
 
 // Reserved ID for the headers stream.
 const QuicStreamId kHeadersStreamId = 3;
 
 // This is the default network timeout a for connection till the crypto
 // handshake succeeds and the negotiated timeout from the handshake is received.
-const int64 kDefaultInitialTimeoutSecs = 120;  // 2 mins.
-const int64 kDefaultTimeoutSecs = 60 * 10;  // 10 minutes.
+const int64 kDefaultInitialTimeoutSecs = 120;           // 2 mins.
+const int64 kDefaultTimeoutSecs = 60 * 10;              // 10 minutes.
 const int64 kDefaultMaxTimeForCryptoHandshakeSecs = 5;  // 5 secs.
 
 // Default ping timeout.
 const int64 kPingTimeoutSecs = 15;  // 15 secs.
 
 // We define an unsigned 16-bit floating point value, inspired by IEEE floats
 // (http://en.wikipedia.org/wiki/Half_precision_floating-point_format),
 // with 5-bit exponent (bias 1), 11-bit mantissa (effective 12 with hidden
 // bit) and denormals, but without signs, transfinites or fractions. Wire format
 // 16 bits (little-endian byte order) are split into exponent (high 5) and
 // mantissa (low 11) and decoded as:
 //   uint64 value;
 //   if (exponent == 0) value = mantissa;
 //   else value = (mantissa | 1 << 11) << (exponent - 1)
 const int kUFloat16ExponentBits = 5;
-const int kUFloat16MaxExponent = (1 << kUFloat16ExponentBits) - 2;  // 30
-const int kUFloat16MantissaBits = 16 - kUFloat16ExponentBits;  // 11
+const int kUFloat16MaxExponent = (1 << kUFloat16ExponentBits) - 2;     // 30
+const int kUFloat16MantissaBits = 16 - kUFloat16ExponentBits;          // 11
 const int kUFloat16MantissaEffectiveBits = kUFloat16MantissaBits + 1;  // 12
 const uint64 kUFloat16MaxValue =  // 0x3FFC0000000
-    ((GG_UINT64_C(1) << kUFloat16MantissaEffectiveBits) - 1) <<
-    kUFloat16MaxExponent;
+    ((GG_UINT64_C(1) << kUFloat16MantissaEffectiveBits) - 1)
+    << kUFloat16MaxExponent;
 
 enum TransmissionType {
   NOT_RETRANSMISSION,
   FIRST_TRANSMISSION_TYPE = NOT_RETRANSMISSION,
-  HANDSHAKE_RETRANSMISSION,  // Retransmits due to handshake timeouts.
+  HANDSHAKE_RETRANSMISSION,    // Retransmits due to handshake timeouts.
   ALL_UNACKED_RETRANSMISSION,  // Retransmits of all unacked packets.
-  LOSS_RETRANSMISSION,  // Retransmits due to loss detection.
-  RTO_RETRANSMISSION,  // Retransmits due to retransmit time out.
-  TLP_RETRANSMISSION,  // Tail loss probes.
+  LOSS_RETRANSMISSION,         // Retransmits due to loss detection.
+  RTO_RETRANSMISSION,          // Retransmits due to retransmit time out.
+  TLP_RETRANSMISSION,          // Tail loss probes.
   LAST_TRANSMISSION_TYPE = TLP_RETRANSMISSION,
 };
 
-enum RetransmissionType {
-  INITIAL_ENCRYPTION_ONLY,
-  ALL_PACKETS
-};
+enum RetransmissionType { INITIAL_ENCRYPTION_ONLY, ALL_PACKETS };
 
 enum HasRetransmittableData {
   NO_RETRANSMITTABLE_DATA,
   HAS_RETRANSMITTABLE_DATA,
 };
 
-enum IsHandshake {
-  NOT_HANDSHAKE,
-  IS_HANDSHAKE
-};
+enum IsHandshake { NOT_HANDSHAKE, IS_HANDSHAKE };
 
 enum QuicFrameType {
   // Regular frame types. The values set here cannot change without the
   // introduction of a new QUIC version.
   PADDING_FRAME = 0,
   RST_STREAM_FRAME = 1,
   CONNECTION_CLOSE_FRAME = 2,
   GOAWAY_FRAME = 3,
   WINDOW_UPDATE_FRAME = 4,
   BLOCKED_FRAME = 5,
@@ skipping 22 matching lines @@
 
 enum QuicSequenceNumberLength {
   PACKET_1BYTE_SEQUENCE_NUMBER = 1,
   PACKET_2BYTE_SEQUENCE_NUMBER = 2,
   PACKET_4BYTE_SEQUENCE_NUMBER = 4,
   PACKET_6BYTE_SEQUENCE_NUMBER = 6
 };
 
 // Used to indicate a QuicSequenceNumberLength using two flag bits.
 enum QuicSequenceNumberLengthFlags {
-  PACKET_FLAGS_1BYTE_SEQUENCE = 0,  // 00
-  PACKET_FLAGS_2BYTE_SEQUENCE = 1,  // 01
-  PACKET_FLAGS_4BYTE_SEQUENCE = 1 << 1,  // 10
+  PACKET_FLAGS_1BYTE_SEQUENCE = 0,           // 00
+  PACKET_FLAGS_2BYTE_SEQUENCE = 1,           // 01
+  PACKET_FLAGS_4BYTE_SEQUENCE = 1 << 1,      // 10
   PACKET_FLAGS_6BYTE_SEQUENCE = 1 << 1 | 1,  // 11
 };
 
 // The public flags are specified in one byte.
 enum QuicPacketPublicFlags {
   PACKET_PUBLIC_FLAGS_NONE = 0,
 
   // Bit 0: Does the packet header contains version info?
   PACKET_PUBLIC_FLAGS_VERSION = 1 << 0,
 
@@ skipping 43 matching lines @@
 
 // The available versions of QUIC. Guaranteed that the integer value of the enum
 // will match the version number.
 // When adding a new version to this enum you should add it to
 // kSupportedQuicVersions (if appropriate), and also add a new case to the
 // helper methods QuicVersionToQuicTag, QuicTagToQuicVersion, and
 // QuicVersionToString.
 enum QuicVersion {
   // Special case to indicate unknown/unsupported QUIC version.
   QUIC_VERSION_UNSUPPORTED = 0,
-
   QUIC_VERSION_15 = 15,
   QUIC_VERSION_16 = 16,
   QUIC_VERSION_17 = 17,
   QUIC_VERSION_18 = 18,  // Current version.
 };
 
 // This vector contains QUIC versions which we currently support.
 // This should be ordered such that the highest supported version is the first
 // element, with subsequent elements in descending order (versions can be
 // skipped as necessary).
 //
 // IMPORTANT: if you are addding to this list, follow the instructions at
 // http://sites/quic/adding-and-removing-versions
-static const QuicVersion kSupportedQuicVersions[] = {QUIC_VERSION_18,
-                                                     QUIC_VERSION_17,
-                                                     QUIC_VERSION_16,
-                                                     QUIC_VERSION_15};
+static const QuicVersion kSupportedQuicVersions[] = {
+    QUIC_VERSION_18, QUIC_VERSION_17, QUIC_VERSION_16, QUIC_VERSION_15};
 
 typedef std::vector<QuicVersion> QuicVersionVector;
 
 // Returns a vector of QUIC versions in kSupportedQuicVersions.
 NET_EXPORT_PRIVATE QuicVersionVector QuicSupportedVersions();
 
 // QuicTag is written to and read from the wire, but we prefer to use
 // the more readable QuicVersion at other levels.
 // Helper function which translates from a QuicVersion to a QuicTag. Returns 0
 // if QuicVersion is unsupported.
@@ skipping 19 matching lines @@
 // stored in memory as a little endian uint32, we need
 // to reverse the order of the bytes.
 
 // MakeQuicTag returns a value given the four bytes. For example:
 //   MakeQuicTag('C', 'H', 'L', 'O');
 NET_EXPORT_PRIVATE QuicTag MakeQuicTag(char a, char b, char c, char d);
 
 // Size in bytes of the data or fec packet header.
 NET_EXPORT_PRIVATE size_t GetPacketHeaderSize(const QuicPacketHeader& header);
 
-NET_EXPORT_PRIVATE size_t GetPacketHeaderSize(
-    QuicConnectionIdLength connection_id_length,
-    bool include_version,
-    QuicSequenceNumberLength sequence_number_length,
-    InFecGroup is_in_fec_group);
+NET_EXPORT_PRIVATE size_t
+    GetPacketHeaderSize(QuicConnectionIdLength connection_id_length,
+                        bool include_version,
+                        QuicSequenceNumberLength sequence_number_length,
+                        InFecGroup is_in_fec_group);
 
 // Index of the first byte in a QUIC packet of FEC protected data.
-NET_EXPORT_PRIVATE size_t GetStartOfFecProtectedData(
-    QuicConnectionIdLength connection_id_length,
-    bool include_version,
-    QuicSequenceNumberLength sequence_number_length);
+NET_EXPORT_PRIVATE size_t
+    GetStartOfFecProtectedData(QuicConnectionIdLength connection_id_length,
+                               bool include_version,
+                               QuicSequenceNumberLength sequence_number_length);
 // Index of the first byte in a QUIC packet of encrypted data.
-NET_EXPORT_PRIVATE size_t GetStartOfEncryptedData(
-    QuicConnectionIdLength connection_id_length,
-    bool include_version,
-    QuicSequenceNumberLength sequence_number_length);
+NET_EXPORT_PRIVATE size_t
+    GetStartOfEncryptedData(QuicConnectionIdLength connection_id_length,
+                            bool include_version,
+                            QuicSequenceNumberLength sequence_number_length);
 
 enum QuicRstStreamErrorCode {
   QUIC_STREAM_NO_ERROR = 0,
 
   // There was some error which halted stream processing.
   QUIC_ERROR_PROCESSING_STREAM,
   // We got two fin or reset offsets which did not match.
   QUIC_MULTIPLE_TERMINATION_OFFSETS,
   // We got bad payload and can not respond to it at the protocol level.
   QUIC_BAD_APPLICATION_PAYLOAD,
   // Stream closed due to connection error. No reset frame is sent when this
   // happens.
   QUIC_STREAM_CONNECTION_ERROR,
   // GoAway frame sent. No more stream can be created.
   QUIC_STREAM_PEER_GOING_AWAY,
   // The stream has been cancelled.
   QUIC_STREAM_CANCELLED,
   // Sending a RST to allow for proper flow control accounting.
   QUIC_RST_FLOW_CONTROL_ACCOUNTING,
 
   // No error. Used as bound while iterating.
   QUIC_STREAM_LAST_ERROR,
 };
 
 // Because receiving an unknown QuicRstStreamErrorCode results in connection
 // teardown, we use this to make sure any errors predating a given version are
 // downgraded to the most appropriate existing error.
-NET_EXPORT_PRIVATE QuicRstStreamErrorCode AdjustErrorForVersion(
-    QuicRstStreamErrorCode error_code,
-    QuicVersion version);
+NET_EXPORT_PRIVATE QuicRstStreamErrorCode
+    AdjustErrorForVersion(QuicRstStreamErrorCode error_code,
+                          QuicVersion version);
 
 // These values must remain stable as they are uploaded to UMA histograms.
 // To add a new error code, use the current value of QUIC_LAST_ERROR and
 // increment QUIC_LAST_ERROR.
 enum QuicErrorCode {
   QUIC_NO_ERROR = 0,
 
   // Connection has reached an invalid state.
   QUIC_INTERNAL_ERROR = 1,
   // There were data frames after the a fin or reset.
@@ skipping 144 matching lines @@
   bool version_flag;
   QuicSequenceNumberLength sequence_number_length;
   QuicVersionVector versions;
 };
 
 // Header for Data or FEC packets.
 struct NET_EXPORT_PRIVATE QuicPacketHeader {
   QuicPacketHeader();
   explicit QuicPacketHeader(const QuicPacketPublicHeader& header);
 
-  NET_EXPORT_PRIVATE friend std::ostream& operator<<(
-      std::ostream& os, const QuicPacketHeader& s);
+  NET_EXPORT_PRIVATE friend std::ostream& operator<<(std::ostream& os,
+                                                     const QuicPacketHeader& s);
 
   QuicPacketPublicHeader public_header;
   bool fec_flag;
   bool entropy_flag;
   QuicPacketEntropyHash entropy_hash;
   QuicPacketSequenceNumber packet_sequence_number;
   InFecGroup is_in_fec_group;
   QuicFecGroupNumber fec_group;
 };
 
@@ skipping 17 matching lines @@
   NEGOTIATION_IN_PROGRESS,
   // This indicates this endpoint has received a packet from the peer with a
   // version this endpoint supports.  Version negotiation is complete, and the
   // version number will no longer be sent with future packets.
   NEGOTIATED_VERSION
 };
 
 typedef QuicPacketPublicHeader QuicVersionNegotiationPacket;
 
 // A padding frame contains no payload.
-struct NET_EXPORT_PRIVATE QuicPaddingFrame {
-};
+struct NET_EXPORT_PRIVATE QuicPaddingFrame {};
 
 // A ping frame contains no payload, though it is retransmittable,
 // and ACK'd just like other normal frames.
-struct NET_EXPORT_PRIVATE QuicPingFrame {
-};
+struct NET_EXPORT_PRIVATE QuicPingFrame {};
 
 struct NET_EXPORT_PRIVATE QuicStreamFrame {
   QuicStreamFrame();
   QuicStreamFrame(const QuicStreamFrame& frame);
   QuicStreamFrame(QuicStreamId stream_id,
                   bool fin,
                   QuicStreamOffset offset,
                   IOVector data);
 
-  NET_EXPORT_PRIVATE friend std::ostream& operator<<(
-      std::ostream& os, const QuicStreamFrame& s);
+  NET_EXPORT_PRIVATE friend std::ostream& operator<<(std::ostream& os,
+                                                     const QuicStreamFrame& s);
 
   // Returns a copy of the IOVector |data| as a heap-allocated string.
   // Caller must take ownership of the returned string.
   std::string* GetDataAsString() const;
 
   QuicStreamId stream_id;
   bool fin;
   QuicStreamOffset offset;  // Location of this data in the stream.
   IOVector data;
 
   // If this is set, then when this packet is ACKed the AckNotifier will be
   // informed.
   QuicAckNotifier* notifier;
 };
 
 // TODO(ianswett): Re-evaluate the trade-offs of hash_set vs set when framing
 // is finalized.
 typedef std::set<QuicPacketSequenceNumber> SequenceNumberSet;
 // TODO(pwestin): Add a way to enforce the max size of this map.
 typedef std::map<QuicPacketSequenceNumber, QuicTime> TimeMap;
 
 struct NET_EXPORT_PRIVATE ReceivedPacketInfo {
   ReceivedPacketInfo();
   ~ReceivedPacketInfo();
 
   NET_EXPORT_PRIVATE friend std::ostream& operator<<(
-      std::ostream& os, const ReceivedPacketInfo& s);
+      std::ostream& os,
+      const ReceivedPacketInfo& s);
 
   // Entropy hash of all packets up to largest observed not including missing
   // packets.
   QuicPacketEntropyHash entropy_hash;
 
   // The highest packet sequence number we've observed from the peer.
   //
   // In general, this should be the largest packet number we've received.  In
   // the case of truncated acks, we may have to advertise a lower "upper bound"
   // than largest received, to avoid implicitly acking missing packets that
@@ skipping 15 matching lines @@
   bool is_truncated;
 
   // Packets which have been revived via FEC.
   // All of these must also be in missing_packets.
   SequenceNumberSet revived_packets;
 };
 
 // True if the sequence number is greater than largest_observed or is listed
 // as missing.
 // Always returns false for sequence numbers less than least_unacked.
-bool NET_EXPORT_PRIVATE IsAwaitingPacket(
-    const ReceivedPacketInfo& received_info,
-    QuicPacketSequenceNumber sequence_number);
+bool NET_EXPORT_PRIVATE
+    IsAwaitingPacket(const ReceivedPacketInfo& received_info,
+                     QuicPacketSequenceNumber sequence_number);
 
 // Inserts missing packets between [lower, higher).
-void NET_EXPORT_PRIVATE InsertMissingPacketsBetween(
-    ReceivedPacketInfo* received_info,
-    QuicPacketSequenceNumber lower,
-    QuicPacketSequenceNumber higher);
+void NET_EXPORT_PRIVATE
+    InsertMissingPacketsBetween(ReceivedPacketInfo* received_info,
+                                QuicPacketSequenceNumber lower,
+                                QuicPacketSequenceNumber higher);
 
 struct NET_EXPORT_PRIVATE QuicStopWaitingFrame {
   QuicStopWaitingFrame();
   ~QuicStopWaitingFrame();
 
   NET_EXPORT_PRIVATE friend std::ostream& operator<<(
-      std::ostream& os, const QuicStopWaitingFrame& s);
+      std::ostream& os,
+      const QuicStopWaitingFrame& s);
 
   // Entropy hash of all packets up to, but not including, the least unacked
   // packet.
   QuicPacketEntropyHash entropy_hash;
   // The lowest packet we've sent which is unacked, and we expect an ack for.
   QuicPacketSequenceNumber least_unacked;
 };
 
 struct NET_EXPORT_PRIVATE QuicAckFrame {
   QuicAckFrame();
 
-  NET_EXPORT_PRIVATE friend std::ostream& operator<<(
-      std::ostream& os, const QuicAckFrame& s);
+  NET_EXPORT_PRIVATE friend std::ostream& operator<<(std::ostream& os,
+                                                     const QuicAckFrame& s);
 
   QuicStopWaitingFrame sent_info;
   ReceivedPacketInfo received_info;
 };
 
 // Defines for all types of congestion feedback that will be negotiated in QUIC,
 // kTCP MUST be supported by all QUIC implementations to guarantee 100%
 // compatibility.
 enum CongestionFeedbackType {
-  kTCP,  // Used to mimic TCP.
+  kTCP,           // Used to mimic TCP.
   kInterArrival,  // Use additional inter arrival information.
-  kFixRate,  // Provided for testing.
+  kFixRate,       // Provided for testing.
 };
 
 enum LossDetectionType {
   kNack,  // Used to mimic TCP's loss detection.
   kTime,  // Time based loss detection.
 };
 
 struct NET_EXPORT_PRIVATE CongestionFeedbackMessageTCP {
   CongestionFeedbackMessageTCP();
 
@@ skipping 12 matching lines @@
 struct NET_EXPORT_PRIVATE CongestionFeedbackMessageFixRate {
   CongestionFeedbackMessageFixRate();
   QuicBandwidth bitrate;
 };
 
 struct NET_EXPORT_PRIVATE QuicCongestionFeedbackFrame {
   QuicCongestionFeedbackFrame();
   ~QuicCongestionFeedbackFrame();
 
   NET_EXPORT_PRIVATE friend std::ostream& operator<<(
-      std::ostream& os, const QuicCongestionFeedbackFrame& c);
+      std::ostream& os,
+      const QuicCongestionFeedbackFrame& c);
 
   CongestionFeedbackType type;
   // This should really be a union, but since the inter arrival struct
   // is non-trivial, C++ prohibits it.
   CongestionFeedbackMessageTCP tcp;
   CongestionFeedbackMessageInterArrival inter_arrival;
   CongestionFeedbackMessageFixRate fix_rate;
 };
 
 struct NET_EXPORT_PRIVATE QuicRstStreamFrame {
   QuicRstStreamFrame();
   QuicRstStreamFrame(QuicStreamId stream_id,
                      QuicRstStreamErrorCode error_code,
                      QuicStreamOffset bytes_written);
 
   NET_EXPORT_PRIVATE friend std::ostream& operator<<(
-      std::ostream& os, const QuicRstStreamFrame& r);
+      std::ostream& os,
+      const QuicRstStreamFrame& r);
 
   QuicStreamId stream_id;
   QuicRstStreamErrorCode error_code;
   std::string error_details;
 
   // Used to update flow control windows. On termination of a stream, both
   // endpoints must inform the peer of the number of bytes they have sent on
   // that stream. This can be done through normal termination (data packet with
   // FIN) or through a RST.
   QuicStreamOffset byte_offset;
 };
 
 struct NET_EXPORT_PRIVATE QuicConnectionCloseFrame {
   QuicConnectionCloseFrame();
 
   NET_EXPORT_PRIVATE friend std::ostream& operator<<(
-      std::ostream& os, const QuicConnectionCloseFrame& c);
+      std::ostream& os,
+      const QuicConnectionCloseFrame& c);
 
   QuicErrorCode error_code;
   std::string error_details;
 };
 
 struct NET_EXPORT_PRIVATE QuicGoAwayFrame {
   QuicGoAwayFrame();
   QuicGoAwayFrame(QuicErrorCode error_code,
                   QuicStreamId last_good_stream_id,
                   const std::string& reason);
 
-  NET_EXPORT_PRIVATE friend std::ostream& operator<<(
-      std::ostream& os, const QuicGoAwayFrame& g);
+  NET_EXPORT_PRIVATE friend std::ostream& operator<<(std::ostream& os,
+                                                     const QuicGoAwayFrame& g);
 
   QuicErrorCode error_code;
   QuicStreamId last_good_stream_id;
   std::string reason_phrase;
 };
 
 // Flow control updates per-stream and at the connection levoel.
 // Based on SPDY's WINDOW_UPDATE frame, but uses an absolute byte offset rather
 // than a window delta.
 // TODO(rjshade): A possible future optimization is to make stream_id and
 //                byte_offset variable length, similar to stream frames.
 struct NET_EXPORT_PRIVATE QuicWindowUpdateFrame {
   QuicWindowUpdateFrame() {}
   QuicWindowUpdateFrame(QuicStreamId stream_id, QuicStreamOffset byte_offset);
 
   NET_EXPORT_PRIVATE friend std::ostream& operator<<(
-      std::ostream& os, const QuicWindowUpdateFrame& w);
+      std::ostream& os,
+      const QuicWindowUpdateFrame& w);
 
   // The stream this frame applies to.  0 is a special case meaning the overall
   // connection rather than a specific stream.
   QuicStreamId stream_id;
 
   // Byte offset in the stream or connection. The receiver of this frame must
   // not send data which would result in this offset being exceeded.
   QuicStreamOffset byte_offset;
 };
 
 // The BLOCKED frame is used to indicate to the remote endpoint that this
 // endpoint believes itself to be flow-control blocked but otherwise ready to
 // send data. The BLOCKED frame is purely advisory and optional.
 // Based on SPDY's BLOCKED frame (undocumented as of 2014-01-28).
 struct NET_EXPORT_PRIVATE QuicBlockedFrame {
   QuicBlockedFrame() {}
   explicit QuicBlockedFrame(QuicStreamId stream_id);
 
-  NET_EXPORT_PRIVATE friend std::ostream& operator<<(
-      std::ostream& os, const QuicBlockedFrame& b);
+  NET_EXPORT_PRIVATE friend std::ostream& operator<<(std::ostream& os,
+                                                     const QuicBlockedFrame& b);
 
   // The stream this frame applies to.  0 is a special case meaning the overall
   // connection rather than a specific stream.
   QuicStreamId stream_id;
 };
 
 // EncryptionLevel enumerates the stages of encryption that a QUIC connection
 // progresses through. When retransmitting a packet, the encryption level needs
 // to be specified so that it is retransmitted at a level which the peer can
 // understand.
 enum EncryptionLevel {
   ENCRYPTION_NONE = 0,
   ENCRYPTION_INITIAL = 1,
   ENCRYPTION_FORWARD_SECURE = 2,
-
   NUM_ENCRYPTION_LEVELS,
 };
 
 struct NET_EXPORT_PRIVATE QuicFrame {
   QuicFrame();
   explicit QuicFrame(QuicPaddingFrame* padding_frame);
   explicit QuicFrame(QuicStreamFrame* stream_frame);
   explicit QuicFrame(QuicAckFrame* frame);
   explicit QuicFrame(QuicCongestionFeedbackFrame* frame);
   explicit QuicFrame(QuicRstStreamFrame* frame);
   explicit QuicFrame(QuicConnectionCloseFrame* frame);
   explicit QuicFrame(QuicStopWaitingFrame* frame);
   explicit QuicFrame(QuicPingFrame* frame);
   explicit QuicFrame(QuicGoAwayFrame* frame);
   explicit QuicFrame(QuicWindowUpdateFrame* frame);
   explicit QuicFrame(QuicBlockedFrame* frame);
 
-  NET_EXPORT_PRIVATE friend std::ostream& operator<<(
-      std::ostream& os, const QuicFrame& frame);
+  NET_EXPORT_PRIVATE friend std::ostream& operator<<(std::ostream& os,
+                                                     const QuicFrame& frame);
 
   QuicFrameType type;
   union {
     QuicPaddingFrame* padding_frame;
     QuicStreamFrame* stream_frame;
     QuicAckFrame* ack_frame;
     QuicCongestionFeedbackFrame* congestion_feedback_frame;
     QuicStopWaitingFrame* stop_waiting_frame;
     QuicPingFrame* ping_frame;
     QuicRstStreamFrame* rst_stream_frame;
@@ skipping 39 matching lines @@
 
 class NET_EXPORT_PRIVATE QuicPacket : public QuicData {
  public:
   static QuicPacket* NewDataPacket(
       char* buffer,
       size_t length,
       bool owns_buffer,
       QuicConnectionIdLength connection_id_length,
       bool includes_version,
       QuicSequenceNumberLength sequence_number_length) {
-    return new QuicPacket(buffer, length, owns_buffer, connection_id_length,
-                          includes_version, sequence_number_length, false);
+    return new QuicPacket(buffer,
+                          length,
+                          owns_buffer,
+                          connection_id_length,
+                          includes_version,
+                          sequence_number_length,
+                          false);
   }
 
   static QuicPacket* NewFecPacket(
       char* buffer,
       size_t length,
       bool owns_buffer,
       QuicConnectionIdLength connection_id_length,
       bool includes_version,
       QuicSequenceNumberLength sequence_number_length) {
-    return new QuicPacket(buffer, length, owns_buffer, connection_id_length,
-                          includes_version, sequence_number_length, true);
+    return new QuicPacket(buffer,
+                          length,
+                          owns_buffer,
+                          connection_id_length,
+                          includes_version,
+                          sequence_number_length,
+                          true);
   }
 
   base::StringPiece FecProtectedData() const;
   base::StringPiece AssociatedData() const;
   base::StringPiece BeforePlaintext() const;
   base::StringPiece Plaintext() const;
 
   bool is_fec_packet() const { return is_fec_packet_; }
 
   char* mutable_data() { return buffer_; }
@@ skipping 22 matching lines @@
   QuicEncryptedPacket(char* buffer, size_t length, bool owns_buffer);
 
   // Clones the packet into a new packet which owns the buffer.
   QuicEncryptedPacket* Clone() const;
 
   // By default, gtest prints the raw bytes of an object. The bool data
   // member (in the base class QuicData) causes this object to have padding
   // bytes, which causes the default gtest object printer to read
   // uninitialize memory. So we need to teach gtest how to print this object.
   NET_EXPORT_PRIVATE friend std::ostream& operator<<(
-      std::ostream& os, const QuicEncryptedPacket& s);
+      std::ostream& os,
+      const QuicEncryptedPacket& s);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(QuicEncryptedPacket);
 };
 
 class NET_EXPORT_PRIVATE RetransmittableFrames {
  public:
   RetransmittableFrames();
   ~RetransmittableFrames();
 
   // Allocates a local copy of the referenced StringPiece has QuicStreamFrame
   // use it.
   // Takes ownership of |stream_frame|.
   const QuicFrame& AddStreamFrame(QuicStreamFrame* stream_frame);
   // Takes ownership of the frame inside |frame|.
   const QuicFrame& AddNonStreamFrame(const QuicFrame& frame);
   const QuicFrames& frames() const { return frames_; }
 
   IsHandshake HasCryptoHandshake() const;
 
   void set_encryption_level(EncryptionLevel level);
-  EncryptionLevel encryption_level() const {
-    return encryption_level_;
-  }
+  EncryptionLevel encryption_level() const { return encryption_level_; }
 
  private:
   QuicFrames frames_;
   EncryptionLevel encryption_level_;
   // Data referenced by the StringPiece of a QuicStreamFrame.
   std::vector<std::string*> stream_data_;
 
   DISALLOW_COPY_AND_ASSIGN(RetransmittableFrames);
 };
 
@@ skipping 16 matching lines @@
 };
 
 // A struct for functions which consume data payloads and fins.
 struct NET_EXPORT_PRIVATE QuicConsumedData {
   QuicConsumedData(size_t bytes_consumed, bool fin_consumed);
 
   // By default, gtest prints the raw bytes of an object. The bool data
   // member causes this object to have padding bytes, which causes the
   // default gtest object printer to read uninitialize memory. So we need
   // to teach gtest how to print this object.
-  NET_EXPORT_PRIVATE friend std::ostream& operator<<(
-      std::ostream& os, const QuicConsumedData& s);
+  NET_EXPORT_PRIVATE friend std::ostream& operator<<(std::ostream& os,
+                                                     const QuicConsumedData& s);
 
   // How many bytes were consumed.
   size_t bytes_consumed;
 
   // True if an incoming fin was consumed.
   bool fin_consumed;
 };
 
 enum WriteStatus {
   WRITE_STATUS_OK,
   WRITE_STATUS_BLOCKED,
   WRITE_STATUS_ERROR,
 };
 
 // A struct used to return the result of write calls including either the number
 // of bytes written or the error code, depending upon the status.
 struct NET_EXPORT_PRIVATE WriteResult {
   WriteResult(WriteStatus status, int bytes_written_or_error_code);
   WriteResult();
 
   WriteStatus status;
   union {
     int bytes_written;  // only valid when status is OK
-    int error_code;  // only valid when status is ERROR
+    int error_code;     // only valid when status is ERROR
   };
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_PROTOCOL_H_