Clang format slam.

net/quic/quic_framer.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_framer.h"
 
 #include "base/containers/hash_tables.h"
 #include "base/stl_util.h"
 #include "net/quic/crypto/crypto_framer.h"
 #include "net/quic/crypto/crypto_handshake_message.h"
@@ skipping 114 matching lines @@
     case PACKET_FLAGS_2BYTE_SEQUENCE:
       return PACKET_2BYTE_SEQUENCE_NUMBER;
     case PACKET_FLAGS_1BYTE_SEQUENCE:
       return PACKET_1BYTE_SEQUENCE_NUMBER;
     default:
       LOG(DFATAL) << "Unreachable case statement.";
       return PACKET_6BYTE_SEQUENCE_NUMBER;
   }
 }
 
-bool CanTruncate(
-    QuicVersion version, const QuicFrame& frame, size_t free_bytes) {
+bool CanTruncate(QuicVersion version,
+                 const QuicFrame& frame,
+                 size_t free_bytes) {
   if ((frame.type == ACK_FRAME || frame.type == CONNECTION_CLOSE_FRAME) &&
       free_bytes >=
           QuicFramer::GetMinAckFrameSize(version,
                                          PACKET_6BYTE_SEQUENCE_NUMBER,
                                          PACKET_6BYTE_SEQUENCE_NUMBER)) {
     return true;
   }
   return false;
 }
 
@@ skipping 20 matching lines @@
       supported_versions_(supported_versions),
       decrypter_level_(ENCRYPTION_NONE),
       alternative_decrypter_level_(ENCRYPTION_NONE),
       alternative_decrypter_latch_(false),
       is_server_(is_server),
       validate_flags_(true),
       creation_time_(creation_time) {
   DCHECK(!supported_versions.empty());
   quic_version_ = supported_versions_[0];
   decrypter_.reset(QuicDecrypter::Create(kNULL));
-  encrypter_[ENCRYPTION_NONE].reset(
-      QuicEncrypter::Create(kNULL));
+  encrypter_[ENCRYPTION_NONE].reset(QuicEncrypter::Create(kNULL));
 }
 
-QuicFramer::~QuicFramer() {}
+QuicFramer::~QuicFramer() {
+}
 
 // static
 size_t QuicFramer::GetMinStreamFrameSize(QuicVersion version,
                                          QuicStreamId stream_id,
                                          QuicStreamOffset offset,
                                          bool last_frame_in_packet,
                                          InFecGroup is_in_fec_group) {
-  bool no_stream_frame_length = last_frame_in_packet &&
-                                is_in_fec_group == NOT_IN_FEC_GROUP;
+  bool no_stream_frame_length =
+      last_frame_in_packet && is_in_fec_group == NOT_IN_FEC_GROUP;
   return kQuicFrameTypeSize + GetStreamIdSize(stream_id) +
-      GetStreamOffsetSize(offset) +
-      (no_stream_frame_length ? 0 : kQuicStreamPayloadLengthSize);
+         GetStreamOffsetSize(offset) +
+         (no_stream_frame_length ? 0 : kQuicStreamPayloadLengthSize);
 }
 
 // static
 size_t QuicFramer::GetMinAckFrameSize(
     QuicVersion version,
     QuicSequenceNumberLength sequence_number_length,
     QuicSequenceNumberLength largest_observed_length) {
-  return kQuicFrameTypeSize + kQuicEntropyHashSize +
-      sequence_number_length + kQuicEntropyHashSize +
-      largest_observed_length + kQuicDeltaTimeLargestObservedSize;
+  return kQuicFrameTypeSize + kQuicEntropyHashSize + sequence_number_length +
+         kQuicEntropyHashSize + largest_observed_length +
+         kQuicDeltaTimeLargestObservedSize;
 }
 
 // static
 size_t QuicFramer::GetStopWaitingFrameSize(
     QuicSequenceNumberLength sequence_number_length) {
-  return kQuicFrameTypeSize + kQuicEntropyHashSize +
-      sequence_number_length;
+  return kQuicFrameTypeSize + kQuicEntropyHashSize + sequence_number_length;
 }
 
 // static
 size_t QuicFramer::GetMinRstStreamFrameSize(QuicVersion quic_version) {
-  return kQuicFrameTypeSize + kQuicMaxStreamIdSize +
-      kQuicMaxStreamOffsetSize + kQuicErrorCodeSize +
-      kQuicErrorDetailsLengthSize;
+  return kQuicFrameTypeSize + kQuicMaxStreamIdSize + kQuicMaxStreamOffsetSize +
+         kQuicErrorCodeSize + kQuicErrorDetailsLengthSize;
 }
 
 // static
 size_t QuicFramer::GetMinConnectionCloseFrameSize() {
   return kQuicFrameTypeSize + kQuicErrorCodeSize + kQuicErrorDetailsLengthSize;
 }
 
 // static
 size_t QuicFramer::GetMinGoAwayFrameSize() {
   return kQuicFrameTypeSize + kQuicErrorCodeSize + kQuicErrorDetailsLengthSize +
-      kQuicMaxStreamIdSize;
+         kQuicMaxStreamIdSize;
 }
 
 // static
 size_t QuicFramer::GetWindowUpdateFrameSize() {
   return kQuicFrameTypeSize + kQuicMaxStreamIdSize + kQuicMaxStreamOffsetSize;
 }
 
 // static
 size_t QuicFramer::GetBlockedFrameSize() {
   return kQuicFrameTypeSize + kQuicMaxStreamIdSize;
@@ skipping 26 matching lines @@
       return i;
     }
   }
   LOG(DFATAL) << "Failed to determine StreamOffsetSize.";
   return 8;
 }
 
 // static
 size_t QuicFramer::GetVersionNegotiationPacketSize(size_t number_versions) {
   return kPublicFlagsSize + PACKET_8BYTE_CONNECTION_ID +
-      number_versions * kQuicVersionSize;
+         number_versions * kQuicVersionSize;
 }
 
 bool QuicFramer::IsSupportedVersion(const QuicVersion version) const {
   for (size_t i = 0; i < supported_versions_.size(); ++i) {
     if (version == supported_versions_[i]) {
       return true;
     }
   }
   return false;
 }
 
 size_t QuicFramer::GetSerializedFrameLength(
     const QuicFrame& frame,
     size_t free_bytes,
     bool first_frame,
     bool last_frame,
     InFecGroup is_in_fec_group,
     QuicSequenceNumberLength sequence_number_length) {
   if (frame.type == PADDING_FRAME) {
     // PADDING implies end of packet.
     return free_bytes;
   }
-  size_t frame_len =
-      ComputeFrameLength(frame, last_frame, is_in_fec_group,
-                         sequence_number_length);
+  size_t frame_len = ComputeFrameLength(
+      frame, last_frame, is_in_fec_group, sequence_number_length);
   if (frame_len > free_bytes) {
     // Only truncate the first frame in a packet, so if subsequent ones go
     // over, stop including more frames.
     if (!first_frame) {
       return 0;
     }
     if (CanTruncate(quic_version_, frame, free_bytes)) {
       // Truncate the frame so the packet will not exceed kMaxPacketSize.
       // Note that we may not use every byte of the writer in this case.
       DVLOG(1) << "Truncating large frame";
       return free_bytes;
     } else if (!FLAGS_quic_allow_oversized_packets_for_test) {
       return 0;
     }
   }
   return frame_len;
 }
 
-QuicFramer::AckFrameInfo::AckFrameInfo() : max_delta(0) { }
+QuicFramer::AckFrameInfo::AckFrameInfo() : max_delta(0) {
+}
 
-QuicFramer::AckFrameInfo::~AckFrameInfo() { }
+QuicFramer::AckFrameInfo::~AckFrameInfo() {
+}
 
 QuicPacketEntropyHash QuicFramer::GetPacketEntropyHash(
     const QuicPacketHeader& header) const {
   return header.entropy_flag << (header.packet_sequence_number % 8);
 }
 
 // Test only.
 SerializedPacket QuicFramer::BuildUnsizedDataPacket(
     const QuicPacketHeader& header,
     const QuicFrames& frames) {
   const size_t max_plaintext_size = GetMaxPlaintextSize(kMaxPacketSize);
   size_t packet_size = GetPacketHeaderSize(header);
   for (size_t i = 0; i < frames.size(); ++i) {
     DCHECK_LE(packet_size, max_plaintext_size);
     bool first_frame = i == 0;
     bool last_frame = i == frames.size() - 1;
-    const size_t frame_size = GetSerializedFrameLength(
-        frames[i], max_plaintext_size - packet_size, first_frame, last_frame,
-        header.is_in_fec_group,
-        header.public_header.sequence_number_length);
+    const size_t frame_size =
+        GetSerializedFrameLength(frames[i],
+                                 max_plaintext_size - packet_size,
+                                 first_frame,
+                                 last_frame,
+                                 header.is_in_fec_group,
+                                 header.public_header.sequence_number_length);
     DCHECK(frame_size);
     packet_size += frame_size;
   }
   return BuildDataPacket(header, frames, packet_size);
 }
 
-SerializedPacket QuicFramer::BuildDataPacket(
-    const QuicPacketHeader& header,
-    const QuicFrames& frames,
-    size_t packet_size) {
+SerializedPacket QuicFramer::BuildDataPacket(const QuicPacketHeader& header,
+                                             const QuicFrames& frames,
+                                             size_t packet_size) {
   QuicDataWriter writer(packet_size);
   const SerializedPacket kNoPacket(
       0, PACKET_1BYTE_SEQUENCE_NUMBER, NULL, 0, NULL);
   if (!AppendPacketHeader(header, &writer)) {
     LOG(DFATAL) << "AppendPacketHeader failed";
     return kNoPacket;
   }
 
   for (size_t i = 0; i < frames.size(); ++i) {
     const QuicFrame& frame = frames[i];
 
     // Determine if we should write stream frame length in header.
     const bool no_stream_frame_length =
         (header.is_in_fec_group == NOT_IN_FEC_GROUP) &&
         (i == frames.size() - 1);
     if (!AppendTypeByte(frame, no_stream_frame_length, &writer)) {
       LOG(DFATAL) << "AppendTypeByte failed";
       return kNoPacket;
     }
 
     switch (frame.type) {
       case PADDING_FRAME:
         writer.WritePadding();
         break;
       case STREAM_FRAME:
         if (!AppendStreamFrame(
-            *frame.stream_frame, no_stream_frame_length, &writer)) {
+                *frame.stream_frame, no_stream_frame_length, &writer)) {
           LOG(DFATAL) << "AppendStreamFrame failed";
           return kNoPacket;
         }
         break;
       case ACK_FRAME:
-        if (!AppendAckFrameAndTypeByte(
-                header, *frame.ack_frame, &writer)) {
+        if (!AppendAckFrameAndTypeByte(header, *frame.ack_frame, &writer)) {
           LOG(DFATAL) << "AppendAckFrameAndTypeByte failed";
           return kNoPacket;
         }
         break;
       case CONGESTION_FEEDBACK_FRAME:
-        if (!AppendCongestionFeedbackFrame(
-                *frame.congestion_feedback_frame, &writer)) {
+        if (!AppendCongestionFeedbackFrame(*frame.congestion_feedback_frame,
+                                           &writer)) {
           LOG(DFATAL) << "AppendCongestionFeedbackFrame failed";
           return kNoPacket;
         }
         break;
       case STOP_WAITING_FRAME:
         if (quic_version_ <= QUIC_VERSION_15) {
           LOG(DFATAL) << "Attempt to add a StopWaitingFrame in "
                       << QuicVersionToString(quic_version_);
           return kNoPacket;
         }
@@ skipping 11 matching lines @@
         }
         // Ping has no payload.
         break;
       case RST_STREAM_FRAME:
         if (!AppendRstStreamFrame(*frame.rst_stream_frame, &writer)) {
           LOG(DFATAL) << "AppendRstStreamFrame failed";
           return kNoPacket;
         }
         break;
       case CONNECTION_CLOSE_FRAME:
-        if (!AppendConnectionCloseFrame(
-                *frame.connection_close_frame, &writer)) {
+        if (!AppendConnectionCloseFrame(*frame.connection_close_frame,
+                                        &writer)) {
           LOG(DFATAL) << "AppendConnectionCloseFrame failed";
           return kNoPacket;
         }
         break;
       case GOAWAY_FRAME:
         if (!AppendGoAwayFrame(*frame.goaway_frame, &writer)) {
           LOG(DFATAL) << "AppendGoAwayFrame failed";
           return kNoPacket;
         }
         break;
@@ skipping 14 matching lines @@
         LOG(DFATAL) << "QUIC_INVALID_FRAME_DATA";
         return kNoPacket;
     }
   }
 
   // Save the length before writing, because take clears it.
   const size_t len = writer.length();
   // Less than or equal because truncated acks end up with max_plaintex_size
   // length, even though they're typically slightly shorter.
   DCHECK_LE(len, packet_size);
-  QuicPacket* packet = QuicPacket::NewDataPacket(
-      writer.take(), len, true, header.public_header.connection_id_length,
-      header.public_header.version_flag,
-      header.public_header.sequence_number_length);
+  QuicPacket* packet =
+      QuicPacket::NewDataPacket(writer.take(),
+                                len,
+                                true,
+                                header.public_header.connection_id_length,
+                                header.public_header.version_flag,
+                                header.public_header.sequence_number_length);
 
   if (fec_builder_) {
     fec_builder_->OnBuiltFecProtectedPayload(header,
                                              packet->FecProtectedData());
   }
 
   return SerializedPacket(header.packet_sequence_number,
-                          header.public_header.sequence_number_length, packet,
-                          GetPacketEntropyHash(header), NULL);
+                          header.public_header.sequence_number_length,
+                          packet,
+                          GetPacketEntropyHash(header),
+                          NULL);
 }
 
 SerializedPacket QuicFramer::BuildFecPacket(const QuicPacketHeader& header,
                                             const QuicFecData& fec) {
   DCHECK_EQ(IN_FEC_GROUP, header.is_in_fec_group);
   DCHECK_NE(0u, header.fec_group);
   size_t len = GetPacketHeaderSize(header);
   len += fec.redundancy.length();
 
   QuicDataWriter writer(len);
   const SerializedPacket kNoPacket(
       0, PACKET_1BYTE_SEQUENCE_NUMBER, NULL, 0, NULL);
   if (!AppendPacketHeader(header, &writer)) {
     LOG(DFATAL) << "AppendPacketHeader failed";
     return kNoPacket;
   }
 
   if (!writer.WriteBytes(fec.redundancy.data(), fec.redundancy.length())) {
     LOG(DFATAL) << "Failed to add FEC";
     return kNoPacket;
   }
 
   return SerializedPacket(
       header.packet_sequence_number,
       header.public_header.sequence_number_length,
-      QuicPacket::NewFecPacket(writer.take(), len, true,
+      QuicPacket::NewFecPacket(writer.take(),
+                               len,
+                               true,
                                header.public_header.connection_id_length,
                                header.public_header.version_flag,
                                header.public_header.sequence_number_length),
-      GetPacketEntropyHash(header), NULL);
+      GetPacketEntropyHash(header),
+      NULL);
 }
 
 // static
 QuicEncryptedPacket* QuicFramer::BuildPublicResetPacket(
     const QuicPublicResetPacket& packet) {
   DCHECK(packet.public_header.reset_flag);
 
   CryptoHandshakeMessage reset;
   reset.set_tag(kPRST);
   reset.SetValue(kRNON, packet.nonce_proof);
@@ skipping 107 matching lines @@
       set_detailed_error("Unable to read supported version in negotiation.");
       return RaiseError(QUIC_INVALID_VERSION_NEGOTIATION_PACKET);
     }
     public_header->versions.push_back(QuicTagToQuicVersion(version));
   } while (!reader_->IsDoneReading());
 
   visitor_->OnVersionNegotiationPacket(*public_header);
   return true;
 }
 
-bool QuicFramer::ProcessDataPacket(
-    const QuicPacketPublicHeader& public_header,
-    const QuicEncryptedPacket& packet) {
+bool QuicFramer::ProcessDataPacket(const QuicPacketPublicHeader& public_header,
+                                   const QuicEncryptedPacket& packet) {
   QuicPacketHeader header(public_header);
   if (!ProcessPacketHeader(&header, packet)) {
     DLOG(WARNING) << "Unable to process data packet header.";
     return false;
   }
 
   if (!visitor_->OnPacketHeader(header)) {
     // The visitor suppresses further processing of the packet.
     return true;
   }
@@ skipping 49 matching lines @@
   if (reset->GetUint64(kRSEQ, &packet.rejected_sequence_number) !=
       QUIC_NO_ERROR) {
     set_detailed_error("Unable to read rejected sequence number.");
     return RaiseError(QUIC_INVALID_PUBLIC_RST_PACKET);
   }
 
   StringPiece address;
   if (reset->GetStringPiece(kCADR, &address)) {
     QuicSocketAddressCoder address_coder;
     if (address_coder.Decode(address.data(), address.length())) {
-      packet.client_address = IPEndPoint(address_coder.ip(),
-                                         address_coder.port());
+      packet.client_address =
+          IPEndPoint(address_coder.ip(), address_coder.port());
     }
   }
 
   visitor_->OnPublicResetPacket(packet);
   return true;
 }
 
 bool QuicFramer::ProcessRevivedPacket(QuicPacketHeader* header,
                                       StringPiece payload) {
   DCHECK(!reader_.get());
@@ skipping 30 matching lines @@
   uint8 public_flags = 0;
   if (header.public_header.reset_flag) {
     public_flags |= PACKET_PUBLIC_FLAGS_RST;
   }
   if (header.public_header.version_flag) {
     public_flags |= PACKET_PUBLIC_FLAGS_VERSION;
   }
 
   public_flags |=
       GetSequenceNumberFlags(header.public_header.sequence_number_length)
-          << kPublicHeaderSequenceNumberShift;
+      << kPublicHeaderSequenceNumberShift;
 
   switch (header.public_header.connection_id_length) {
     case PACKET_0BYTE_CONNECTION_ID:
-      if (!writer->WriteUInt8(
-              public_flags | PACKET_PUBLIC_FLAGS_0BYTE_CONNECTION_ID)) {
+      if (!writer->WriteUInt8(public_flags |
+                              PACKET_PUBLIC_FLAGS_0BYTE_CONNECTION_ID)) {
         return false;
       }
       break;
     case PACKET_1BYTE_CONNECTION_ID:
-      if (!writer->WriteUInt8(
-              public_flags | PACKET_PUBLIC_FLAGS_1BYTE_CONNECTION_ID)) {
-         return false;
+      if (!writer->WriteUInt8(public_flags |
+                              PACKET_PUBLIC_FLAGS_1BYTE_CONNECTION_ID)) {
+        return false;
       }
-      if (!writer->WriteUInt8(
-              header.public_header.connection_id & k1ByteConnectionIdMask)) {
+      if (!writer->WriteUInt8(header.public_header.connection_id &
+                              k1ByteConnectionIdMask)) {
         return false;
       }
       break;
     case PACKET_4BYTE_CONNECTION_ID:
-      if (!writer->WriteUInt8(
-              public_flags | PACKET_PUBLIC_FLAGS_4BYTE_CONNECTION_ID)) {
-         return false;
+      if (!writer->WriteUInt8(public_flags |
+                              PACKET_PUBLIC_FLAGS_4BYTE_CONNECTION_ID)) {
+        return false;
       }
-      if (!writer->WriteUInt32(
-              header.public_header.connection_id & k4ByteConnectionIdMask)) {
+      if (!writer->WriteUInt32(header.public_header.connection_id &
+                               k4ByteConnectionIdMask)) {
         return false;
       }
       break;
     case PACKET_8BYTE_CONNECTION_ID:
-      if (!writer->WriteUInt8(
-              public_flags | PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID)) {
+      if (!writer->WriteUInt8(public_flags |
+                              PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID)) {
         return false;
       }
       if (!writer->WriteUInt64(header.public_header.connection_id)) {
         return false;
       }
       break;
   }
   last_serialized_connection_id_ = header.public_header.connection_id;
 
   if (header.public_header.version_flag) {
     DCHECK(!is_server_);
     writer->WriteUInt32(QuicVersionToQuicTag(quic_version_));
   }
 
   if (!AppendPacketSequenceNumber(header.public_header.sequence_number_length,
-                                  header.packet_sequence_number, writer)) {
+                                  header.packet_sequence_number,
+                                  writer)) {
     return false;
   }
 
   uint8 private_flags = 0;
   if (header.entropy_flag) {
     private_flags |= PACKET_PRIVATE_FLAGS_ENTROPY;
   }
   if (header.is_in_fec_group == IN_FEC_GROUP) {
     private_flags |= PACKET_PRIVATE_FLAGS_FEC_GROUP;
   }
@@ skipping 25 matching lines @@
     QuicSequenceNumberLength sequence_number_length,
     QuicPacketSequenceNumber packet_sequence_number) const {
   // The new sequence number might have wrapped to the next epoch, or
   // it might have reverse wrapped to the previous epoch, or it might
   // remain in the same epoch.  Select the sequence number closest to the
   // next expected sequence number, the previous sequence number plus 1.
 
   // epoch_delta is the delta between epochs the sequence number was serialized
   // with, so the correct value is likely the same epoch as the last sequence
   // number or an adjacent epoch.
-  const QuicPacketSequenceNumber epoch_delta =
-      GG_UINT64_C(1) << (8 * sequence_number_length);
+  const QuicPacketSequenceNumber epoch_delta = GG_UINT64_C(1)
+                                               << (8 * sequence_number_length);
   QuicPacketSequenceNumber next_sequence_number = last_sequence_number_ + 1;
   QuicPacketSequenceNumber epoch = last_sequence_number_ & ~(epoch_delta - 1);
   QuicPacketSequenceNumber prev_epoch = epoch - epoch_delta;
   QuicPacketSequenceNumber next_epoch = epoch + epoch_delta;
 
   return ClosestTo(next_sequence_number,
                    epoch + packet_sequence_number,
                    ClosestTo(next_sequence_number,
                              prev_epoch + packet_sequence_number,
                              next_epoch + packet_sequence_number));
 }
 
-bool QuicFramer::ProcessPublicHeader(
-    QuicPacketPublicHeader* public_header) {
+bool QuicFramer::ProcessPublicHeader(QuicPacketPublicHeader* public_header) {
   uint8 public_flags;
   if (!reader_->ReadBytes(&public_flags, 1)) {
     set_detailed_error("Unable to read public flags.");
     return false;
   }
 
   public_header->reset_flag = (public_flags & PACKET_PUBLIC_FLAGS_RST) != 0;
   public_header->version_flag =
       (public_flags & PACKET_PUBLIC_FLAGS_VERSION) != 0;
 
-  if (validate_flags_ &&
-      !public_header->version_flag && public_flags > PACKET_PUBLIC_FLAGS_MAX) {
+  if (validate_flags_ && !public_header->version_flag &&
+      public_flags > PACKET_PUBLIC_FLAGS_MAX) {
     set_detailed_error("Illegal public flags value.");
     return false;
   }
 
   if (public_header->reset_flag && public_header->version_flag) {
     set_detailed_error("Got version flag in reset packet");
     return false;
   }
 
   switch (public_flags & PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID) {
     case PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID:
       if (!reader_->ReadUInt64(&public_header->connection_id)) {
         set_detailed_error("Unable to read ConnectionId.");
         return false;
       }
       public_header->connection_id_length = PACKET_8BYTE_CONNECTION_ID;
       break;
     case PACKET_PUBLIC_FLAGS_4BYTE_CONNECTION_ID:
       // If the connection_id is truncated, expect to read the last serialized
       // connection_id.
       if (!reader_->ReadBytes(&public_header->connection_id,
                               PACKET_4BYTE_CONNECTION_ID)) {
         set_detailed_error("Unable to read ConnectionId.");
         return false;
       }
       if ((public_header->connection_id & k4ByteConnectionIdMask) !=
           (last_serialized_connection_id_ & k4ByteConnectionIdMask)) {
-        set_detailed_error("Truncated 4 byte ConnectionId does not match "
-                           "previous connection_id.");
+        set_detailed_error(
+            "Truncated 4 byte ConnectionId does not match "
+            "previous connection_id.");
         return false;
       }
       public_header->connection_id_length = PACKET_4BYTE_CONNECTION_ID;
       public_header->connection_id = last_serialized_connection_id_;
       break;
     case PACKET_PUBLIC_FLAGS_1BYTE_CONNECTION_ID:
       if (!reader_->ReadBytes(&public_header->connection_id,
                               PACKET_1BYTE_CONNECTION_ID)) {
         set_detailed_error("Unable to read ConnectionId.");
         return false;
       }
       if ((public_header->connection_id & k1ByteConnectionIdMask) !=
           (last_serialized_connection_id_ & k1ByteConnectionIdMask)) {
-        set_detailed_error("Truncated 1 byte ConnectionId does not match "
-                           "previous connection_id.");
+        set_detailed_error(
+            "Truncated 1 byte ConnectionId does not match "
+            "previous connection_id.");
         return false;
       }
       public_header->connection_id_length = PACKET_1BYTE_CONNECTION_ID;
       public_header->connection_id = last_serialized_connection_id_;
       break;
     case PACKET_PUBLIC_FLAGS_0BYTE_CONNECTION_ID:
       public_header->connection_id_length = PACKET_0BYTE_CONNECTION_ID;
       public_header->connection_id = last_serialized_connection_id_;
       break;
   }
 
-  public_header->sequence_number_length =
-      ReadSequenceNumberLength(
-          public_flags >> kPublicHeaderSequenceNumberShift);
+  public_header->sequence_number_length = ReadSequenceNumberLength(
+      public_flags >> kPublicHeaderSequenceNumberShift);
 
   // Read the version only if the packet is from the client.
   // version flag from the server means version negotiation packet.
   if (public_header->version_flag && is_server_) {
     QuicTag version_tag;
     if (!reader_->ReadUInt32(&version_tag)) {
       set_detailed_error("Unable to read protocol version.");
       return false;
     }
 
@@ skipping 10 matching lines @@
   return true;
 }
 
 // static
 QuicSequenceNumberLength QuicFramer::GetMinSequenceNumberLength(
     QuicPacketSequenceNumber sequence_number) {
   if (sequence_number < 1 << (PACKET_1BYTE_SEQUENCE_NUMBER * 8)) {
     return PACKET_1BYTE_SEQUENCE_NUMBER;
   } else if (sequence_number < 1 << (PACKET_2BYTE_SEQUENCE_NUMBER * 8)) {
     return PACKET_2BYTE_SEQUENCE_NUMBER;
-  } else if (sequence_number <
-             GG_UINT64_C(1) << (PACKET_4BYTE_SEQUENCE_NUMBER * 8)) {
+  } else if (sequence_number < GG_UINT64_C(1)
+                                   << (PACKET_4BYTE_SEQUENCE_NUMBER * 8)) {
     return PACKET_4BYTE_SEQUENCE_NUMBER;
   } else {
     return PACKET_6BYTE_SEQUENCE_NUMBER;
   }
 }
 
 // static
 uint8 QuicFramer::GetSequenceNumberFlags(
     QuicSequenceNumberLength sequence_number_length) {
   switch (sequence_number_length) {
@@ skipping 23 matching lines @@
     size_t cur_range_length = 0;
     SequenceNumberSet::const_iterator iter =
         received_info.missing_packets.begin();
     QuicPacketSequenceNumber last_missing = *iter;
     ++iter;
     for (; iter != received_info.missing_packets.end(); ++iter) {
       if (cur_range_length != numeric_limits<uint8>::max() &&
           *iter == (last_missing + 1)) {
         ++cur_range_length;
       } else {
-        ack_info.nack_ranges[last_missing - cur_range_length]
-            = cur_range_length;
+        ack_info.nack_ranges[last_missing - cur_range_length] =
+            cur_range_length;
         cur_range_length = 0;
       }
       ack_info.max_delta = max(ack_info.max_delta, *iter - last_missing);
       last_missing = *iter;
     }
     // Include the last nack range.
     ack_info.nack_ranges[last_missing - cur_range_length] = cur_range_length;
     // Include the range to the largest observed.
-    ack_info.max_delta = max(ack_info.max_delta,
-                             received_info.largest_observed - last_missing);
+    ack_info.max_delta =
+        max(ack_info.max_delta, received_info.largest_observed - last_missing);
   }
   return ack_info;
 }
 
-bool QuicFramer::ProcessPacketHeader(
-    QuicPacketHeader* header,
-    const QuicEncryptedPacket& packet) {
+bool QuicFramer::ProcessPacketHeader(QuicPacketHeader* header,
+                                     const QuicEncryptedPacket& packet) {
   if (!ProcessPacketSequenceNumber(header->public_header.sequence_number_length,
                                    &header->packet_sequence_number)) {
     set_detailed_error("Unable to read sequence number.");
     return RaiseError(QUIC_INVALID_PACKET_HEADER);
   }
 
   if (header->packet_sequence_number == 0u) {
     set_detailed_error("Packet sequence numbers cannot be 0.");
     return RaiseError(QUIC_INVALID_PACKET_HEADER);
   }
@@ skipping 22 matching lines @@
   header->fec_flag = (private_flags & PACKET_PRIVATE_FLAGS_FEC) != 0;
 
   if ((private_flags & PACKET_PRIVATE_FLAGS_FEC_GROUP) != 0) {
     header->is_in_fec_group = IN_FEC_GROUP;
     uint8 first_fec_protected_packet_offset;
     if (!reader_->ReadBytes(&first_fec_protected_packet_offset, 1)) {
       set_detailed_error("Unable to read first fec protected packet offset.");
       return RaiseError(QUIC_INVALID_PACKET_HEADER);
     }
     if (first_fec_protected_packet_offset >= header->packet_sequence_number) {
-      set_detailed_error("First fec protected packet offset must be less "
-                         "than the sequence number.");
+      set_detailed_error(
+          "First fec protected packet offset must be less "
+          "than the sequence number.");
       return RaiseError(QUIC_INVALID_PACKET_HEADER);
     }
     header->fec_group =
         header->packet_sequence_number - first_fec_protected_packet_offset;
   }
 
   header->entropy_hash = GetPacketEntropyHash(*header);
   // Set the last sequence number after we have decrypted the packet
   // so we are confident is not attacker controlled.
   last_sequence_number_ = header->packet_sequence_number;
   return true;
 }
 
 bool QuicFramer::ProcessPacketSequenceNumber(
     QuicSequenceNumberLength sequence_number_length,
     QuicPacketSequenceNumber* sequence_number) {
   QuicPacketSequenceNumber wire_sequence_number = 0u;
   if (!reader_->ReadBytes(&wire_sequence_number, sequence_number_length)) {
     return false;
   }
 
   // TODO(ianswett): Explore the usefulness of trying multiple sequence numbers
   // in case the first guess is incorrect.
-  *sequence_number =
-      CalculatePacketSequenceNumberFromWire(sequence_number_length,
-                                            wire_sequence_number);
+  *sequence_number = CalculatePacketSequenceNumberFromWire(
+      sequence_number_length, wire_sequence_number);
   return true;
 }
 
 bool QuicFramer::ProcessFrameData(const QuicPacketHeader& header) {
   if (reader_->IsDoneReading()) {
     set_detailed_error("Packet has no frames.");
     return RaiseError(QUIC_MISSING_PAYLOAD);
   }
   while (!reader_->IsDoneReading()) {
     uint8 frame_type;
@@ skipping 41 matching lines @@
           DVLOG(1) << "Visitor asked to stop further processing.";
           // Returning true since there was no parsing error.
           return true;
         }
         continue;
       }
 
       // This was a special frame type that did not match any
       // of the known ones. Error.
       set_detailed_error("Illegal frame type.");
-      DLOG(WARNING) << "Illegal frame type: "
-                    << static_cast<int>(frame_type);
+      DLOG(WARNING) << "Illegal frame type: " << static_cast<int>(frame_type);
       return RaiseError(QUIC_INVALID_FRAME_DATA);
     }
 
     switch (frame_type) {
       case PADDING_FRAME:
         // We're done with the packet.
         return true;
 
       case RST_STREAM_FRAME: {
         QuicRstStreamFrame frame;
@@ skipping 89 matching lines @@
         if (!visitor_->OnPingFrame(ping_frame)) {
           DVLOG(1) << "Visitor asked to stop further processing.";
           // Returning true since there was no parsing error.
           return true;
         }
         continue;
       }
 
       default:
         set_detailed_error("Illegal frame type.");
-        DLOG(WARNING) << "Illegal frame type: "
-                      << static_cast<int>(frame_type);
+        DLOG(WARNING) << "Illegal frame type: " << static_cast<int>(frame_type);
         return RaiseError(QUIC_INVALID_FRAME_DATA);
     }
   }
 
   return true;
 }
 
-bool QuicFramer::ProcessStreamFrame(uint8 frame_type,
-                                    QuicStreamFrame* frame) {
+bool QuicFramer::ProcessStreamFrame(uint8 frame_type, QuicStreamFrame* frame) {
   uint8 stream_flags = frame_type;
 
   stream_flags &= ~kQuicFrameTypeStreamMask;
 
   // Read from right to left: StreamID, Offset, Data Length, Fin.
   const uint8 stream_id_length = (stream_flags & kQuicStreamIDLengthMask) + 1;
   stream_flags >>= kQuicStreamIdShift;
 
   uint8 offset_length = (stream_flags & kQuicStreamOffsetMask);
   // There is no encoding for 1 byte, only 0 and 2 through 8.
@@ skipping 167 matching lines @@
   return true;
 }
 
 bool QuicFramer::ProcessQuicCongestionFeedbackFrame(
     QuicCongestionFeedbackFrame* frame) {
   uint8 feedback_type;
   if (!reader_->ReadBytes(&feedback_type, 1)) {
     set_detailed_error("Unable to read congestion feedback type.");
     return false;
   }
-  frame->type =
-      static_cast<CongestionFeedbackType>(feedback_type);
+  frame->type = static_cast<CongestionFeedbackType>(feedback_type);
 
   switch (frame->type) {
     case kInterArrival: {
       CongestionFeedbackMessageInterArrival* inter_arrival =
           &frame->inter_arrival;
       uint8 num_received_packets;
       if (!reader_->ReadBytes(&num_received_packets, 1)) {
         set_detailed_error("Unable to read num received packets.");
         return false;
       }
@@ skipping 26 matching lines @@
           }
 
           int32 time_delta_us;
           if (!reader_->ReadBytes(&time_delta_us, sizeof(time_delta_us))) {
             set_detailed_error(
                 "Unable to read time delta in received packets.");
             return false;
           }
           QuicPacketSequenceNumber packet = smallest_received + sequence_delta;
           inter_arrival->received_packet_times.insert(
-              make_pair(packet, time_received.Add(
-                  QuicTime::Delta::FromMicroseconds(time_delta_us))));
+              make_pair(packet,
+                        time_received.Add(
+                            QuicTime::Delta::FromMicroseconds(time_delta_us))));
         }
       }
       break;
     }
     case kFixRate: {
       uint32 bitrate = 0;
       if (!reader_->ReadUInt32(&bitrate)) {
         set_detailed_error("Unable to read bitrate.");
         return false;
       }
       frame->fix_rate.bitrate = QuicBandwidth::FromBytesPerSecond(bitrate);
       break;
     }
     case kTCP: {
       CongestionFeedbackMessageTCP* tcp = &frame->tcp;
       // TODO(ianswett): Remove receive window, since it's constant.
       uint16 receive_window = 0;
       if (!reader_->ReadUInt16(&receive_window)) {
         set_detailed_error("Unable to read receive window.");
         return false;
       }
       // Simple bit packing, don't send the 4 least significant bits.
       tcp->receive_window = static_cast<QuicByteCount>(receive_window) << 4;
       break;
     }
     default:
       set_detailed_error("Illegal congestion feedback type.");
-      DLOG(WARNING) << "Illegal congestion feedback type: "
-                    << frame->type;
+      DLOG(WARNING) << "Illegal congestion feedback type: " << frame->type;
       return RaiseError(QUIC_INVALID_FRAME_DATA);
   }
 
   return true;
 }
 
 bool QuicFramer::ProcessRstStreamFrame(QuicRstStreamFrame* frame) {
   if (!reader_->ReadUInt32(&frame->stream_id)) {
     set_detailed_error("Unable to read stream_id.");
     return false;
@@ skipping 28 matching lines @@
   return true;
 }
 
 bool QuicFramer::ProcessConnectionCloseFrame(QuicConnectionCloseFrame* frame) {
   uint32 error_code;
   if (!reader_->ReadUInt32(&error_code)) {
     set_detailed_error("Unable to read connection close error code.");
     return false;
   }
 
-  if (error_code >= QUIC_LAST_ERROR ||
-         error_code < QUIC_NO_ERROR) {
+  if (error_code >= QUIC_LAST_ERROR || error_code < QUIC_NO_ERROR) {
     set_detailed_error("Invalid error code.");
     return false;
   }
 
   frame->error_code = static_cast<QuicErrorCode>(error_code);
 
   StringPiece error_details;
   if (!reader_->ReadStringPiece16(&error_details)) {
     set_detailed_error("Unable to read connection close error details.");
     return false;
   }
   frame->error_details = error_details.as_string();
 
   return true;
 }
 
 bool QuicFramer::ProcessGoAwayFrame(QuicGoAwayFrame* frame) {
   uint32 error_code;
   if (!reader_->ReadUInt32(&error_code)) {
     set_detailed_error("Unable to read go away error code.");
     return false;
   }
   frame->error_code = static_cast<QuicErrorCode>(error_code);
 
-  if (error_code >= QUIC_LAST_ERROR ||
-      error_code < QUIC_NO_ERROR) {
+  if (error_code >= QUIC_LAST_ERROR || error_code < QUIC_NO_ERROR) {
     set_detailed_error("Invalid error code.");
     return false;
   }
 
   uint32 stream_id;
   if (!reader_->ReadUInt32(&stream_id)) {
     set_detailed_error("Unable to read last good stream id.");
     return false;
   }
   frame->last_good_stream_id = static_cast<QuicStreamId>(stream_id);
@@ skipping 31 matching lines @@
   return true;
 }
 
 // static
 StringPiece QuicFramer::GetAssociatedDataFromEncryptedPacket(
     const QuicEncryptedPacket& encrypted,
     QuicConnectionIdLength connection_id_length,
     bool includes_version,
     QuicSequenceNumberLength sequence_number_length) {
   return StringPiece(
-      encrypted.data() + kStartOfHashData, GetStartOfEncryptedData(
-          connection_id_length, includes_version, sequence_number_length)
-      - kStartOfHashData);
+      encrypted.data() + kStartOfHashData,
+      GetStartOfEncryptedData(
+          connection_id_length, includes_version, sequence_number_length) -
+          kStartOfHashData);
 }
 
-void QuicFramer::SetDecrypter(QuicDecrypter* decrypter,
-                              EncryptionLevel level) {
+void QuicFramer::SetDecrypter(QuicDecrypter* decrypter, EncryptionLevel level) {
   DCHECK(alternative_decrypter_.get() == NULL);
   DCHECK_GE(level, decrypter_level_);
   decrypter_.reset(decrypter);
   decrypter_level_ = level;
 }
 
 void QuicFramer::SetAlternativeDecrypter(QuicDecrypter* decrypter,
                                          EncryptionLevel level,
                                          bool latch_once_used) {
   alternative_decrypter_.reset(decrypter);
   alternative_decrypter_level_ = level;
   alternative_decrypter_latch_ = latch_once_used;
 }
 
 const QuicDecrypter* QuicFramer::decrypter() const {
   return decrypter_.get();
 }
 
 const QuicDecrypter* QuicFramer::alternative_decrypter() const {
   return alternative_decrypter_.get();
 }
 
-void QuicFramer::SetEncrypter(EncryptionLevel level,
-                              QuicEncrypter* encrypter) {
+void QuicFramer::SetEncrypter(EncryptionLevel level, QuicEncrypter* encrypter) {
   DCHECK_GE(level, 0);
   DCHECK_LT(level, NUM_ENCRYPTION_LEVELS);
   encrypter_[level].reset(encrypter);
 }
 
 const QuicEncrypter* QuicFramer::encrypter(EncryptionLevel level) const {
   DCHECK_GE(level, 0);
   DCHECK_LT(level, NUM_ENCRYPTION_LEVELS);
   DCHECK(encrypter_[level].get() != NULL);
   return encrypter_[level].get();
 }
 
 QuicEncryptedPacket* QuicFramer::EncryptPacket(
     EncryptionLevel level,
     QuicPacketSequenceNumber packet_sequence_number,
     const QuicPacket& packet) {
   DCHECK(encrypter_[level].get() != NULL);
 
   scoped_ptr<QuicData> out(encrypter_[level]->EncryptPacket(
       packet_sequence_number, packet.AssociatedData(), packet.Plaintext()));
   if (out.get() == NULL) {
     RaiseError(QUIC_ENCRYPTION_FAILURE);
     return NULL;
   }
   StringPiece header_data = packet.BeforePlaintext();
-  size_t len =  header_data.length() + out->length();
+  size_t len = header_data.length() + out->length();
   char* buffer = new char[len];
   // TODO(rch): eliminate this buffer copy by passing in a buffer to Encrypt().
   memcpy(buffer, header_data.data(), header_data.length());
   memcpy(buffer + header_data.length(), out->data(), out->length());
   return new QuicEncryptedPacket(buffer, len, true);
 }
 
 size_t QuicFramer::GetMaxPlaintextSize(size_t ciphertext_size) {
   // In order to keep the code simple, we don't have the current encryption
   // level to hand. Both the NullEncrypter and AES-GCM have a tag length of 12.
@@ skipping 19 matching lines @@
   }
   DCHECK(decrypter_.get() != NULL);
   decrypted_.reset(decrypter_->DecryptPacket(
       header.packet_sequence_number,
       GetAssociatedDataFromEncryptedPacket(
           packet,
           header.public_header.connection_id_length,
           header.public_header.version_flag,
           header.public_header.sequence_number_length),
       encrypted));
-  if  (decrypted_.get() != NULL) {
+  if (decrypted_.get() != NULL) {
     visitor_->OnDecryptedPacket(decrypter_level_);
-  } else if  (alternative_decrypter_.get() != NULL) {
+  } else if (alternative_decrypter_.get() != NULL) {
     decrypted_.reset(alternative_decrypter_->DecryptPacket(
         header.packet_sequence_number,
         GetAssociatedDataFromEncryptedPacket(
             packet,
             header.public_header.connection_id_length,
             header.public_header.version_flag,
             header.public_header.sequence_number_length),
         encrypted));
     if (decrypted_.get() != NULL) {
       visitor_->OnDecryptedPacket(alternative_decrypter_level_);
       if (alternative_decrypter_latch_) {
         // Switch to the alternative decrypter and latch so that we cannot
         // switch back.
         decrypter_.reset(alternative_decrypter_.release());
         decrypter_level_ = alternative_decrypter_level_;
         alternative_decrypter_level_ = ENCRYPTION_NONE;
       } else {
         // Switch the alternative decrypter so that we use it first next time.
         decrypter_.swap(alternative_decrypter_);
         EncryptionLevel level = alternative_decrypter_level_;
         alternative_decrypter_level_ = decrypter_level_;
         decrypter_level_ = level;
       }
     }
   }
 
-  if  (decrypted_.get() == NULL) {
+  if (decrypted_.get() == NULL) {
     DLOG(WARNING) << "DecryptPacket failed for sequence_number:"
                   << header.packet_sequence_number;
     return false;
   }
 
   reader_.reset(new QuicDataReader(decrypted_->data(), decrypted_->length()));
   return true;
 }
 
 size_t QuicFramer::GetAckFrameSize(
     const QuicAckFrame& ack,
     QuicSequenceNumberLength sequence_number_length) {
   AckFrameInfo ack_info = GetAckFrameInfo(ack);
   QuicSequenceNumberLength largest_observed_length =
       GetMinSequenceNumberLength(ack.received_info.largest_observed);
   QuicSequenceNumberLength missing_sequence_number_length =
       GetMinSequenceNumberLength(ack_info.max_delta);
 
-  size_t ack_size = GetMinAckFrameSize(quic_version_,
-                                       sequence_number_length,
-                                       largest_observed_length);
+  size_t ack_size = GetMinAckFrameSize(
+      quic_version_, sequence_number_length, largest_observed_length);
   if (!ack_info.nack_ranges.empty()) {
-    ack_size += kNumberOfMissingPacketsSize  + kNumberOfRevivedPacketsSize;
+    ack_size += kNumberOfMissingPacketsSize + kNumberOfRevivedPacketsSize;
     ack_size += ack_info.nack_ranges.size() *
-      (missing_sequence_number_length + PACKET_1BYTE_SEQUENCE_NUMBER);
+                (missing_sequence_number_length + PACKET_1BYTE_SEQUENCE_NUMBER);
     ack_size +=
         ack.received_info.revived_packets.size() * largest_observed_length;
   }
   return ack_size;
 }
 
 size_t QuicFramer::ComputeFrameLength(
     const QuicFrame& frame,
     bool last_frame_in_packet,
     InFecGroup is_in_fec_group,
     QuicSequenceNumberLength sequence_number_length) {
   switch (frame.type) {
     case STREAM_FRAME:
       return GetMinStreamFrameSize(quic_version_,
                                    frame.stream_frame->stream_id,
                                    frame.stream_frame->offset,
                                    last_frame_in_packet,
                                    is_in_fec_group) +
-          frame.stream_frame->data.TotalBufferSize();
+             frame.stream_frame->data.TotalBufferSize();
     case ACK_FRAME: {
       return GetAckFrameSize(*frame.ack_frame, sequence_number_length);
     }
     case CONGESTION_FEEDBACK_FRAME: {
       size_t len = kQuicFrameTypeSize;
       const QuicCongestionFeedbackFrame& congestion_feedback =
           *frame.congestion_feedback_frame;
       len += 1;  // Congestion feedback type.
 
       switch (congestion_feedback.type) {
         case kInterArrival: {
           const CongestionFeedbackMessageInterArrival& inter_arrival =
               congestion_feedback.inter_arrival;
           len += 1;  // Number received packets.
           if (inter_arrival.received_packet_times.size() > 0) {
             len += PACKET_6BYTE_SEQUENCE_NUMBER;  // Smallest received.
-            len += 8;  // Time.
+            len += 8;                             // Time.
             // 2 bytes per sequence number delta plus 4 bytes per delta time.
             len += PACKET_6BYTE_SEQUENCE_NUMBER *
-                (inter_arrival.received_packet_times.size() - 1);
+                   (inter_arrival.received_packet_times.size() - 1);
           }
           break;
         }
         case kFixRate:
           len += 4;  // Bitrate.
           break;
         case kTCP:
           len += 2;  // Receive window.
           break;
         default:
           set_detailed_error("Illegal feedback type.");
           DVLOG(1) << "Illegal feedback type: " << congestion_feedback.type;
           break;
       }
       return len;
     }
     case STOP_WAITING_FRAME:
       return GetStopWaitingFrameSize(sequence_number_length);
     case PING_FRAME:
       // Ping has no payload.
       return kQuicFrameTypeSize;
     case RST_STREAM_FRAME:
       return GetMinRstStreamFrameSize(quic_version_) +
-          frame.rst_stream_frame->error_details.size();
+             frame.rst_stream_frame->error_details.size();
     case CONNECTION_CLOSE_FRAME:
       return GetMinConnectionCloseFrameSize() +
-          frame.connection_close_frame->error_details.size();
+             frame.connection_close_frame->error_details.size();
     case GOAWAY_FRAME:
       return GetMinGoAwayFrameSize() + frame.goaway_frame->reason_phrase.size();
     case WINDOW_UPDATE_FRAME:
       return GetWindowUpdateFrameSize();
     case BLOCKED_FRAME:
       return GetBlockedFrameSize();
     case PADDING_FRAME:
       DCHECK(false);
       return 0;
     case NUM_FRAME_TYPES:
@@ skipping 13 matching lines @@
   switch (frame.type) {
     case STREAM_FRAME: {
       if (frame.stream_frame == NULL) {
         LOG(DFATAL) << "Failed to append STREAM frame with no stream_frame.";
       }
       // Fin bit.
       type_byte |= frame.stream_frame->fin ? kQuicStreamFinMask : 0;
 
       // Data Length bit.
       type_byte <<= kQuicStreamDataLengthShift;
-      type_byte |= no_stream_frame_length ? 0: kQuicStreamDataLengthMask;
+      type_byte |= no_stream_frame_length ? 0 : kQuicStreamDataLengthMask;
 
       // Offset 3 bits.
       type_byte <<= kQuicStreamOffsetShift;
       const size_t offset_len = GetStreamOffsetSize(frame.stream_frame->offset);
       if (offset_len > 0) {
         type_byte |= offset_len - 1;
       }
 
       // stream id 2 bits.
       type_byte <<= kQuicStreamIdShift;
@@ skipping 21 matching lines @@
     QuicSequenceNumberLength sequence_number_length,
     QuicPacketSequenceNumber packet_sequence_number,
     QuicDataWriter* writer) {
   // Ensure the entire sequence number can be written.
   if (writer->capacity() - writer->length() <
       static_cast<size_t>(sequence_number_length)) {
     return false;
   }
   switch (sequence_number_length) {
     case PACKET_1BYTE_SEQUENCE_NUMBER:
-      return writer->WriteUInt8(
-          packet_sequence_number & k1ByteSequenceNumberMask);
+      return writer->WriteUInt8(packet_sequence_number &
+                                k1ByteSequenceNumberMask);
       break;
     case PACKET_2BYTE_SEQUENCE_NUMBER:
-      return writer->WriteUInt16(
-          packet_sequence_number & k2ByteSequenceNumberMask);
+      return writer->WriteUInt16(packet_sequence_number &
+                                 k2ByteSequenceNumberMask);
       break;
     case PACKET_4BYTE_SEQUENCE_NUMBER:
-      return writer->WriteUInt32(
-          packet_sequence_number & k4ByteSequenceNumberMask);
+      return writer->WriteUInt32(packet_sequence_number &
+                                 k4ByteSequenceNumberMask);
       break;
     case PACKET_6BYTE_SEQUENCE_NUMBER:
-      return writer->WriteUInt48(
-          packet_sequence_number & k6ByteSequenceNumberMask);
+      return writer->WriteUInt48(packet_sequence_number &
+                                 k6ByteSequenceNumberMask);
       break;
     default:
       DCHECK(false) << "sequence_number_length: " << sequence_number_length;
       return false;
   }
 }
 
-bool QuicFramer::AppendStreamFrame(
-    const QuicStreamFrame& frame,
-    bool no_stream_frame_length,
-    QuicDataWriter* writer) {
+bool QuicFramer::AppendStreamFrame(const QuicStreamFrame& frame,
+                                   bool no_stream_frame_length,
+                                   QuicDataWriter* writer) {
   if (!writer->WriteBytes(&frame.stream_id, GetStreamIdSize(frame.stream_id))) {
     LOG(DFATAL) << "Writing stream id size failed.";
     return false;
   }
   if (!writer->WriteBytes(&frame.offset, GetStreamOffsetSize(frame.offset))) {
     LOG(DFATAL) << "Writing offset size failed.";
     return false;
   }
   if (!no_stream_frame_length) {
     if (!writer->WriteUInt16(frame.data.TotalBufferSize())) {
       LOG(DFATAL) << "Writing stream frame length failed";
       return false;
     }
   }
 
   if (!writer->WriteIOVector(frame.data)) {
     LOG(DFATAL) << "Writing frame data failed.";
     return false;
   }
   return true;
 }
 
 // static
 void QuicFramer::set_version(const QuicVersion version) {
   DCHECK(IsSupportedVersion(version)) << QuicVersionToString(version);
   quic_version_ = version;
 }
 
-bool QuicFramer::AppendAckFrameAndTypeByte(
-    const QuicPacketHeader& header,
-    const QuicAckFrame& frame,
-    QuicDataWriter* writer) {
+bool QuicFramer::AppendAckFrameAndTypeByte(const QuicPacketHeader& header,
+                                           const QuicAckFrame& frame,
+                                           QuicDataWriter* writer) {
   AckFrameInfo ack_info = GetAckFrameInfo(frame);
   QuicPacketSequenceNumber ack_largest_observed =
       frame.received_info.largest_observed;
   QuicSequenceNumberLength largest_observed_length =
       GetMinSequenceNumberLength(ack_largest_observed);
   QuicSequenceNumberLength missing_sequence_number_length =
       GetMinSequenceNumberLength(ack_info.max_delta);
   // Determine whether we need to truncate ranges.
-  size_t available_range_bytes = writer->capacity() - writer->length() -
+  size_t available_range_bytes =
+      writer->capacity() - writer->length() -
       GetMinAckFrameSize(quic_version_,
                          header.public_header.sequence_number_length,
-                         largest_observed_length) - kNumberOfRevivedPacketsSize;
-  size_t max_num_ranges = available_range_bytes /
+                         largest_observed_length) -
+      kNumberOfRevivedPacketsSize;
+  size_t max_num_ranges =
+      available_range_bytes /
       (missing_sequence_number_length + PACKET_1BYTE_SEQUENCE_NUMBER);
   max_num_ranges =
       min(static_cast<size_t>(numeric_limits<uint8>::max()), max_num_ranges);
   bool truncated = ack_info.nack_ranges.size() > max_num_ranges;
   DVLOG_IF(1, truncated) << "Truncating ack from "
                          << ack_info.nack_ranges.size() << " ranges to "
                          << max_num_ranges;
 
   // Write out the type byte by setting the low order bits and doing shifts
   // to make room for the next bit flags to be set.
@@ skipping 40 matching lines @@
     ack_largest_observed = ack_iter->first - 1;
     // Also update the entropy so it matches the largest observed.
     ack_entropy_hash = entropy_calculator_->EntropyHash(ack_largest_observed);
     ++ack_iter;
   }
 
   if (!writer->WriteUInt8(ack_entropy_hash)) {
     return false;
   }
 
-  if (!AppendPacketSequenceNumber(largest_observed_length,
-                                  ack_largest_observed, writer)) {
+  if (!AppendPacketSequenceNumber(
+          largest_observed_length, ack_largest_observed, writer)) {
     return false;
   }
 
   uint64 delta_time_largest_observed_us = kUFloat16MaxValue;
   if (!received_info.delta_time_largest_observed.IsInfinite()) {
     DCHECK_LE(0u,
               frame.received_info.delta_time_largest_observed.ToMicroseconds());
     delta_time_largest_observed_us =
         received_info.delta_time_largest_observed.ToMicroseconds();
   }
@@ skipping 11 matching lines @@
   if (!writer->WriteBytes(&num_missing_ranges, 1)) {
     return false;
   }
 
   int num_ranges_written = 0;
   QuicPacketSequenceNumber last_sequence_written = ack_largest_observed;
   for (; ack_iter != ack_info.nack_ranges.rend(); ++ack_iter) {
     // Calculate the delta to the last number in the range.
     QuicPacketSequenceNumber missing_delta =
         last_sequence_written - (ack_iter->first + ack_iter->second);
-    if (!AppendPacketSequenceNumber(missing_sequence_number_length,
-                                    missing_delta, writer)) {
+    if (!AppendPacketSequenceNumber(
+            missing_sequence_number_length, missing_delta, writer)) {
       return false;
     }
-    if (!AppendPacketSequenceNumber(PACKET_1BYTE_SEQUENCE_NUMBER,
-                                    ack_iter->second, writer)) {
+    if (!AppendPacketSequenceNumber(
+            PACKET_1BYTE_SEQUENCE_NUMBER, ack_iter->second, writer)) {
       return false;
     }
     // Subtract 1 so a missing_delta of 0 means an adjacent range.
     last_sequence_written = ack_iter->first - 1;
     ++num_ranges_written;
   }
   DCHECK_EQ(num_missing_ranges, num_ranges_written);
 
   // Append revived packets.
   // If not all the revived packets fit, only mention the ones that do.
   uint8 num_revived_packets =
       min(received_info.revived_packets.size(),
           static_cast<size_t>(numeric_limits<uint8>::max()));
-  num_revived_packets = min(
-      static_cast<size_t>(num_revived_packets),
-      (writer->capacity() - writer->length()) / largest_observed_length);
+  num_revived_packets =
+      min(static_cast<size_t>(num_revived_packets),
+          (writer->capacity() - writer->length()) / largest_observed_length);
   if (!writer->WriteBytes(&num_revived_packets, 1)) {
     return false;
   }
 
   SequenceNumberSet::const_iterator iter =
       received_info.revived_packets.begin();
   for (int i = 0; i < num_revived_packets; ++i, ++iter) {
     LOG_IF(DFATAL, !ContainsKey(received_info.missing_packets, *iter));
-    if (!AppendPacketSequenceNumber(largest_observed_length,
-                                    *iter, writer)) {
+    if (!AppendPacketSequenceNumber(largest_observed_length, *iter, writer)) {
       return false;
     }
   }
 
   return true;
 }
 
 bool QuicFramer::AppendCongestionFeedbackFrame(
     const QuicCongestionFeedbackFrame& frame,
     QuicDataWriter* writer) {
   if (!writer->WriteBytes(&frame.type, 1)) {
     return false;
   }
 
   switch (frame.type) {
     case kInterArrival: {
       const CongestionFeedbackMessageInterArrival& inter_arrival =
           frame.inter_arrival;
       DCHECK_GE(numeric_limits<uint8>::max(),
                 inter_arrival.received_packet_times.size());
       if (inter_arrival.received_packet_times.size() >
           numeric_limits<uint8>::max()) {
         return false;
       }
       // TODO(ianswett): Make num_received_packets a varint.
-      uint8 num_received_packets =
-          inter_arrival.received_packet_times.size();
+      uint8 num_received_packets = inter_arrival.received_packet_times.size();
       if (!writer->WriteBytes(&num_received_packets, 1)) {
         return false;
       }
       if (num_received_packets > 0) {
         TimeMap::const_iterator it =
             inter_arrival.received_packet_times.begin();
 
         QuicPacketSequenceNumber lowest_sequence = it->first;
-        if (!AppendPacketSequenceNumber(PACKET_6BYTE_SEQUENCE_NUMBER,
-                                        lowest_sequence, writer)) {
+        if (!AppendPacketSequenceNumber(
+                PACKET_6BYTE_SEQUENCE_NUMBER, lowest_sequence, writer)) {
           return false;
         }
 
         QuicTime lowest_time = it->second;
         if (!writer->WriteUInt64(
                 lowest_time.Subtract(creation_time_).ToMicroseconds())) {
           return false;
         }
 
         for (++it; it != inter_arrival.received_packet_times.end(); ++it) {
           QuicPacketSequenceNumber sequence_delta = it->first - lowest_sequence;
           DCHECK_GE(numeric_limits<uint16>::max(), sequence_delta);
           if (sequence_delta > numeric_limits<uint16>::max()) {
             return false;
           }
           if (!writer->WriteUInt16(static_cast<uint16>(sequence_delta))) {
             return false;
           }
 
           int32 time_delta_us =
               it->second.Subtract(lowest_time).ToMicroseconds();
           if (!writer->WriteBytes(&time_delta_us, sizeof(time_delta_us))) {
             return false;
           }
         }
       }
       break;
     }
     case kFixRate: {
-      const CongestionFeedbackMessageFixRate& fix_rate =
-          frame.fix_rate;
+      const CongestionFeedbackMessageFixRate& fix_rate = frame.fix_rate;
       if (!writer->WriteUInt32(fix_rate.bitrate.ToBytesPerSecond())) {
         return false;
       }
       break;
     }
     case kTCP: {
       const CongestionFeedbackMessageTCP& tcp = frame.tcp;
       DCHECK_LE(tcp.receive_window, 1u << 20);
       // Simple bit packing, don't send the 4 least significant bits.
       uint16 receive_window = static_cast<uint16>(tcp.receive_window >> 4);
       if (!writer->WriteUInt16(receive_window)) {
         return false;
       }
       break;
     }
     default:
       return false;
   }
 
   return true;
 }
 
-bool QuicFramer::AppendStopWaitingFrame(
-    const QuicPacketHeader& header,
-    const QuicStopWaitingFrame& frame,
-    QuicDataWriter* writer) {
+bool QuicFramer::AppendStopWaitingFrame(const QuicPacketHeader& header,
+                                        const QuicStopWaitingFrame& frame,
+                                        QuicDataWriter* writer) {
   DCHECK_GE(header.packet_sequence_number, frame.least_unacked);
   const QuicPacketSequenceNumber least_unacked_delta =
       header.packet_sequence_number - frame.least_unacked;
   const QuicPacketSequenceNumber length_shift =
       header.public_header.sequence_number_length * 8;
   if (!writer->WriteUInt8(frame.entropy_hash)) {
     LOG(DFATAL) << " hash failed";
     return false;
   }
 
   if (least_unacked_delta >> length_shift > 0) {
     LOG(DFATAL) << "sequence_number_length "
                 << header.public_header.sequence_number_length
                 << " is too small for least_unacked_delta: "
                 << least_unacked_delta;
     return false;
   }
   if (!AppendPacketSequenceNumber(header.public_header.sequence_number_length,
-                                  least_unacked_delta, writer)) {
+                                  least_unacked_delta,
+                                  writer)) {
     LOG(DFATAL) << " seq failed: "
                 << header.public_header.sequence_number_length;
     return false;
   }
 
   return true;
 }
 
-bool QuicFramer::AppendRstStreamFrame(
-        const QuicRstStreamFrame& frame,
-        QuicDataWriter* writer) {
+bool QuicFramer::AppendRstStreamFrame(const QuicRstStreamFrame& frame,
+                                      QuicDataWriter* writer) {
   if (!writer->WriteUInt32(frame.stream_id)) {
     return false;
   }
 
   if (!writer->WriteUInt64(frame.byte_offset)) {
     return false;
   }
 
   uint32 error_code = static_cast<uint32>(frame.error_code);
   if (!writer->WriteUInt32(error_code)) {
@@ skipping 58 matching lines @@
 
 bool QuicFramer::RaiseError(QuicErrorCode error) {
   DVLOG(1) << "Error detail: " << detailed_error_;
   set_error(error);
   visitor_->OnError(this);
   reader_.reset(NULL);
   return false;
 }
 
 }  // namespace net