Land Recent QUIC changes.

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/hash_tables.h"
 #include "net/quic/crypto/quic_decrypter.h"
 #include "net/quic/crypto/quic_encrypter.h"
 #include "net/quic/quic_data_reader.h"
 #include "net/quic/quic_data_writer.h"
 #include "net/quic/quic_utils.h"
 
 using base::StringPiece;
 using std::make_pair;
 using std::map;
 using std::numeric_limits;
 using std::string;
 
 namespace net {
 
 namespace {
 
 // Mask to select the lowest 48 bits of a sequence number.
-const QuicPacketSequenceNumber kSequenceNumberMask =
+const QuicPacketSequenceNumber k6ByteSequenceNumberMask =
     GG_UINT64_C(0x0000FFFFFFFFFFFF);
+const QuicPacketSequenceNumber k4ByteSequenceNumberMask =
+    GG_UINT64_C(0x00000000FFFFFFFF);
+const QuicPacketSequenceNumber k2ByteSequenceNumberMask =
+    GG_UINT64_C(0x000000000000FFFF);
+const QuicPacketSequenceNumber k1ByteSequenceNumberMask =
+    GG_UINT64_C(0x00000000000000FF);
 
 const QuicGuid k1ByteGuidMask = GG_UINT64_C(0x00000000000000FF);
 const QuicGuid k4ByteGuidMask = GG_UINT64_C(0x00000000FFFFFFFF);
 
 const uint32 kInvalidDeltaTime = 0xffffffff;
 
 // Returns the absolute value of the difference between |a| and |b|.
 QuicPacketSequenceNumber Delta(QuicPacketSequenceNumber a,
                                QuicPacketSequenceNumber b) {
   // Since these are unsigned numbers, we can't just return abs(a - b)
@@ skipping 39 matching lines @@
 }
 
 // static
 size_t QuicFramer::GetMinStreamFrameSize() {
   return kQuicFrameTypeSize + kQuicStreamIdSize +
       kQuicStreamFinSize + kQuicStreamOffsetSize + kQuicStreamPayloadLengthSize;
 }
 
 // static
 size_t QuicFramer::GetMinAckFrameSize() {
-  return kQuicFrameTypeSize + kQuicEntropyHashSize + kSequenceNumberSize +
-      kQuicEntropyHashSize + kSequenceNumberSize +
-      kQuicDeltaTimeLargestObservedSize + kNumberOfMissingPacketsSize;
+  return kQuicFrameTypeSize + kQuicEntropyHashSize +
+      PACKET_6BYTE_SEQUENCE_NUMBER + kQuicEntropyHashSize +
+      PACKET_6BYTE_SEQUENCE_NUMBER + kQuicDeltaTimeLargestObservedSize +
+      kNumberOfMissingPacketsSize;
 }
 
 // static
 size_t QuicFramer::GetMinRstStreamFrameSize() {
   return kQuicFrameTypeSize + kQuicStreamIdSize + kQuicErrorCodeSize +
       kQuicErrorDetailsLengthSize;
 }
 
 // static
 size_t QuicFramer::GetMinConnectionCloseFrameSize() {
   return kQuicFrameTypeSize + kQuicErrorCodeSize + kQuicErrorDetailsLengthSize +
       GetMinAckFrameSize();
 }
 
 // static
 size_t QuicFramer::GetMinGoAwayFrameSize() {
   return kQuicFrameTypeSize + kQuicErrorCodeSize + kQuicErrorDetailsLengthSize +
       kQuicStreamIdSize;
 }
 
 // static
 // TODO(satyamshekhar): 16 - Crypto hash for integrity. Not a static value. Use
 // QuicEncrypter::GetMaxPlaintextSize.
 // 16 is a conservative estimate in the case of AEAD_AES_128_GCM_12, which uses
 // 12-byte tags.
 size_t QuicFramer::GetMaxUnackedPackets(QuicPacketHeader header) {
   return (kMaxPacketSize - GetPacketHeaderSize(header) -
-          GetMinAckFrameSize() - 16) / kSequenceNumberSize;
+          GetMinAckFrameSize() - 16) / PACKET_6BYTE_SEQUENCE_NUMBER;
 }
 
 bool QuicFramer::IsSupportedVersion(QuicTag version) {
   return version == kQuicVersion1;
 }
 
 size_t QuicFramer::GetVersionNegotiationPacketSize(size_t number_versions) {
   return kPublicFlagsSize + PACKET_8BYTE_GUID +
       number_versions * kQuicVersionSize;
 }
@@ skipping 107 matching lines @@
     }
   }
 
   // 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.guid_length,
-      header.public_header.version_flag);
+      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, packet,
                           GetPacketEntropyHash(header), NULL);
 }
 
@@ skipping 12 matching lines @@
   }
 
   if (!writer.WriteBytes(fec.redundancy.data(), fec.redundancy.length())) {
     return kNoPacket;
   }
 
   return SerializedPacket(
       header.packet_sequence_number,
       QuicPacket::NewFecPacket(writer.take(), len, true,
                                header.public_header.guid_length,
-                               header.public_header.version_flag),
+                               header.public_header.version_flag,
+                               header.public_header.sequence_number_length),
       GetPacketEntropyHash(header), NULL);
 }
 
 // static
 QuicEncryptedPacket* QuicFramer::ConstructPublicResetPacket(
     const QuicPublicResetPacket& packet) {
   DCHECK(packet.public_header.reset_flag);
   size_t len = GetPublicResetPacketSize();
   QuicDataWriter writer(len);
 
   uint8 flags = static_cast<uint8>(PACKET_PUBLIC_FLAGS_RST |
-                                   PACKET_PUBLIC_FLAGS_8BYTE_GUID);
+                                   PACKET_PUBLIC_FLAGS_8BYTE_GUID |
+                                   PACKET_PUBLIC_FLAGS_6BYTE_SEQUENCE);
   if (!writer.WriteUInt8(flags)) {
     return NULL;
   }
 
   if (!writer.WriteUInt64(packet.public_header.guid)) {
     return NULL;
   }
 
   if (!writer.WriteUInt64(packet.nonce_proof)) {
     return NULL;
   }
 
-  if (!AppendPacketSequenceNumber(packet.rejected_sequence_number,
+  if (!AppendPacketSequenceNumber(PACKET_6BYTE_SEQUENCE_NUMBER,
+                                  packet.rejected_sequence_number,
                                   &writer)) {
     return NULL;
   }
 
   return new QuicEncryptedPacket(writer.take(), len, true);
 }
 
 QuicEncryptedPacket* QuicFramer::ConstructVersionNegotiationPacket(
     const QuicPacketPublicHeader& header,
     const QuicTagVector& supported_versions) {
   DCHECK(header.version_flag);
   size_t len = GetVersionNegotiationPacketSize(supported_versions.size());
   QuicDataWriter writer(len);
 
   uint8 flags = static_cast<uint8>(PACKET_PUBLIC_FLAGS_VERSION |
-                                   PACKET_PUBLIC_FLAGS_8BYTE_GUID);
+                                   PACKET_PUBLIC_FLAGS_8BYTE_GUID |
+                                   PACKET_PUBLIC_FLAGS_6BYTE_SEQUENCE);
   if (!writer.WriteUInt8(flags)) {
     return NULL;
   }
 
   if (!writer.WriteUInt64(header.guid)) {
     return NULL;
   }
 
   for (size_t i = 0; i < supported_versions.size(); ++i) {
     if (!writer.WriteUInt32(supported_versions[i])) {
@@ skipping 148 matching lines @@
 bool QuicFramer::WritePacketHeader(const QuicPacketHeader& header,
                                    QuicDataWriter* writer) {
   DCHECK(header.fec_group > 0 || header.is_in_fec_group == NOT_IN_FEC_GROUP);
   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;
   }
+  switch (header.public_header.sequence_number_length) {
+    case PACKET_1BYTE_SEQUENCE_NUMBER:
+      public_flags |= PACKET_PUBLIC_FLAGS_1BYTE_SEQUENCE;
+      break;
+    case PACKET_2BYTE_SEQUENCE_NUMBER:
+      public_flags |= PACKET_PUBLIC_FLAGS_2BYTE_SEQUENCE;
+      break;
+    case PACKET_4BYTE_SEQUENCE_NUMBER:
+      public_flags |= PACKET_PUBLIC_FLAGS_4BYTE_SEQUENCE;
+      break;
+    case PACKET_6BYTE_SEQUENCE_NUMBER:
+      public_flags |= PACKET_PUBLIC_FLAGS_6BYTE_SEQUENCE;
+      break;
+  }
+
   switch (header.public_header.guid_length) {
     case PACKET_0BYTE_GUID:
       if (!writer->WriteUInt8(public_flags | PACKET_PUBLIC_FLAGS_0BYTE_GUID)) {
         return false;
       }
       break;
     case PACKET_1BYTE_GUID:
       if (!writer->WriteUInt8(public_flags | PACKET_PUBLIC_FLAGS_1BYTE_GUID)) {
          return false;
       }
@@ skipping 18 matching lines @@
       }
       break;
   }
   last_serialized_guid_ = header.public_header.guid;
 
   if (header.public_header.version_flag) {
     DCHECK(!is_server_);
     writer->WriteUInt32(quic_version_);
   }
 
-  if (!AppendPacketSequenceNumber(header.packet_sequence_number, writer)) {
+  if (!AppendPacketSequenceNumber(header.public_header.sequence_number_length,
+                                  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 15 matching lines @@
         header.packet_sequence_number - header.fec_group;
     if (!writer->WriteBytes(&first_fec_protected_packet_offset, 1)) {
       return false;
     }
   }
 
   return true;
 }
 
 QuicPacketSequenceNumber QuicFramer::CalculatePacketSequenceNumberFromWire(
+    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
-  // previous sequence number.
-  QuicPacketSequenceNumber epoch = last_sequence_number_ & ~kSequenceNumberMask;
-  QuicPacketSequenceNumber prev_epoch = epoch - (GG_UINT64_C(1) << 48);
-  QuicPacketSequenceNumber next_epoch = epoch + (GG_UINT64_C(1) << 48);
+  // next expected sequence number, the previous sequence number plus 1.
 
-  return ClosestTo(last_sequence_number_,
+  // 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);
+  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(last_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;
   }
 
-  if (public_flags > PACKET_PUBLIC_FLAGS_MAX) {
-    set_detailed_error("Illegal public flags value.");
-    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 (!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_GUID) {
     case PACKET_PUBLIC_FLAGS_8BYTE_GUID:
       if (!reader_->ReadUInt64(&public_header->guid)) {
         set_detailed_error("Unable to read GUID.");
         return false;
@@ skipping 28 matching lines @@
       }
       public_header->guid_length = PACKET_1BYTE_GUID;
       public_header->guid = last_serialized_guid_;
       break;
     case PACKET_PUBLIC_FLAGS_0BYTE_GUID:
       public_header->guid_length = PACKET_0BYTE_GUID;
       public_header->guid = last_serialized_guid_;
       break;
   }
 
+  switch (public_flags & PACKET_PUBLIC_FLAGS_6BYTE_SEQUENCE) {
+    case PACKET_PUBLIC_FLAGS_6BYTE_SEQUENCE:
+      public_header->sequence_number_length = PACKET_6BYTE_SEQUENCE_NUMBER;
+      break;
+    case PACKET_PUBLIC_FLAGS_4BYTE_SEQUENCE:
+      public_header->sequence_number_length = PACKET_4BYTE_SEQUENCE_NUMBER;
+      break;
+    case PACKET_PUBLIC_FLAGS_2BYTE_SEQUENCE:
+      public_header->sequence_number_length = PACKET_2BYTE_SEQUENCE_NUMBER;
+      break;
+    case PACKET_PUBLIC_FLAGS_1BYTE_SEQUENCE:
+      public_header->sequence_number_length = PACKET_1BYTE_SEQUENCE_NUMBER;
+      break;
+  }
+
   if (public_header->version_flag && is_server_) {
     QuicTag version;
     if (!reader_->ReadUInt32(&version)) {
       // Read the version only if the packet is from the client.
       // version flag from the server means version negotiation packet.
       set_detailed_error("Unable to read protocol version.");
       return false;
     }
+    if (version == quic_version_ && public_flags > PACKET_PUBLIC_FLAGS_MAX) {
+      set_detailed_error("Illegal public flags value.");
+      return false;
+    }
     public_header->versions.push_back(version);
   }
   return true;
 }
 
 // static
 bool QuicFramer::ReadGuidFromPacket(const QuicEncryptedPacket& packet,
                                     QuicGuid* guid) {
   QuicDataReader reader(packet.data(), packet.length());
   uint8 public_flags;
   if (!reader.ReadBytes(&public_flags, 1)) {
     return false;
   }
   // Ensure it's an 8 byte guid.
   if ((public_flags & PACKET_PUBLIC_FLAGS_8BYTE_GUID) !=
           PACKET_PUBLIC_FLAGS_8BYTE_GUID) {
     return false;
   }
 
   return reader.ReadUInt64(guid);
 }
 
 bool QuicFramer::ProcessPacketHeader(
     QuicPacketHeader* header,
     const QuicEncryptedPacket& packet) {
-  if (!ProcessPacketSequenceNumber(&header->packet_sequence_number)) {
+  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);
   }
 
-  if (!DecryptPayload(header->packet_sequence_number,
-                      header->public_header.guid_length,
-                      header->public_header.version_flag,
-                      packet)) {
+  if (!DecryptPayload(*header, packet)) {
     set_detailed_error("Unable to decrypt payload.");
     return RaiseError(QUIC_DECRYPTION_FAILURE);
   }
 
   uint8 private_flags;
   if (!reader_->ReadBytes(&private_flags, 1)) {
     set_detailed_error("Unable to read private flags.");
     return RaiseError(QUIC_INVALID_PACKET_HEADER);
   }
 
@@ skipping 17 matching lines @@
   }
 
   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;
-  if (!reader_->ReadUInt48(&wire_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(wire_sequence_number);
+      CalculatePacketSequenceNumberFromWire(sequence_number_length,
+                                            wire_sequence_number);
   return true;
 }
 
 bool QuicFramer::ProcessFrameData() {
   if (reader_->IsDoneReading()) {
     set_detailed_error("Unable to read frame type.");
     return RaiseError(QUIC_INVALID_FRAME_DATA);
   }
   while (!reader_->IsDoneReading()) {
     uint8 frame_type;
@@ skipping 134 matching lines @@
   }
   return true;
 }
 
 bool QuicFramer::ProcessReceivedInfo(ReceivedPacketInfo* received_info) {
   if (!reader_->ReadBytes(&received_info->entropy_hash, 1)) {
     set_detailed_error("Unable to read entropy hash for received packets.");
     return false;
   }
 
-  if (!ProcessPacketSequenceNumber(&received_info->largest_observed)) {
+  if (!ProcessPacketSequenceNumber(PACKET_6BYTE_SEQUENCE_NUMBER,
+                                   &received_info->largest_observed)) {
      set_detailed_error("Unable to read largest observed.");
      return false;
   }
 
   uint32 delta_time_largest_observed_us;
   if (!reader_->ReadUInt32(&delta_time_largest_observed_us)) {
     set_detailed_error("Unable to read delta time largest observed.");
     return false;
   }
 
   if (delta_time_largest_observed_us == kInvalidDeltaTime) {
     received_info->delta_time_largest_observed = QuicTime::Delta::Infinite();
   } else {
     received_info->delta_time_largest_observed =
         QuicTime::Delta::FromMicroseconds(delta_time_largest_observed_us);
   }
 
   uint8 num_missing_packets;
   if (!reader_->ReadBytes(&num_missing_packets, 1)) {
     set_detailed_error("Unable to read num missing packets.");
     return false;
   }
 
   for (int i = 0; i < num_missing_packets; ++i) {
     QuicPacketSequenceNumber sequence_number;
-    if (!ProcessPacketSequenceNumber(&sequence_number)) {
+    if (!ProcessPacketSequenceNumber(PACKET_6BYTE_SEQUENCE_NUMBER,
+                                     &sequence_number)) {
       set_detailed_error("Unable to read sequence number in missing packets.");
       return false;
     }
     received_info->missing_packets.insert(sequence_number);
   }
 
   return true;
 }
 
 bool QuicFramer::ProcessSentInfo(SentPacketInfo* sent_info) {
   if (!reader_->ReadBytes(&sent_info->entropy_hash, 1)) {
     set_detailed_error("Unable to read entropy hash for sent packets.");
     return false;
   }
 
-  if (!ProcessPacketSequenceNumber(&sent_info->least_unacked)) {
+  if (!ProcessPacketSequenceNumber(PACKET_6BYTE_SEQUENCE_NUMBER,
+                                   &sent_info->least_unacked)) {
     set_detailed_error("Unable to read least unacked.");
     return false;
   }
 
   return true;
 }
 
 bool QuicFramer::ProcessQuicCongestionFeedbackFrame(
     QuicCongestionFeedbackFrame* frame) {
   uint8 feedback_type;
@@ skipping 15 matching lines @@
         return false;
       }
       uint8 num_received_packets;
       if (!reader_->ReadBytes(&num_received_packets, 1)) {
         set_detailed_error("Unable to read num received packets.");
         return false;
       }
 
       if (num_received_packets > 0u) {
         uint64 smallest_received;
-        if (!ProcessPacketSequenceNumber(&smallest_received)) {
+        if (!ProcessPacketSequenceNumber(PACKET_6BYTE_SEQUENCE_NUMBER,
+                                         &smallest_received)) {
           set_detailed_error("Unable to read smallest received.");
           return false;
         }
 
         uint64 time_received_us;
         if (!reader_->ReadUInt64(&time_received_us)) {
           set_detailed_error("Unable to read time received.");
           return false;
         }
         QuicTime time_received = creation_time_.Add(
@@ skipping 147 matching lines @@
   }
   frame->reason_phrase = reason_phrase.as_string();
 
   return true;
 }
 
 // static
 StringPiece QuicFramer::GetAssociatedDataFromEncryptedPacket(
     const QuicEncryptedPacket& encrypted,
     QuicGuidLength guid_length,
-    bool includes_version) {
+    bool includes_version,
+    QuicSequenceNumberLength sequence_number_length) {
   return StringPiece(encrypted.data() + kStartOfHashData,
                      GetStartOfEncryptedData(
-                         guid_length, includes_version) - kStartOfHashData);
+                         guid_length, includes_version, sequence_number_length)
+                     - kStartOfHashData);
 }
 
 void QuicFramer::SetDecrypter(QuicDecrypter* decrypter) {
   DCHECK(alternative_decrypter_.get() == NULL);
   decrypter_.reset(decrypter);
 }
 
 void QuicFramer::SetAlternativeDecrypter(QuicDecrypter* decrypter,
                                          bool latch_once_used) {
   alternative_decrypter_.reset(decrypter);
@@ skipping 67 matching lines @@
       size_t size = encrypter_[i]->GetMaxPlaintextSize(ciphertext_size);
       if (size < min_plaintext_size) {
         min_plaintext_size = size;
       }
     }
   }
 
   return min_plaintext_size;
 }
 
-bool QuicFramer::DecryptPayload(QuicPacketSequenceNumber sequence_number,
-                                QuicGuidLength guid_length,
-                                bool version_flag,
+bool QuicFramer::DecryptPayload(const QuicPacketHeader& header,
                                 const QuicEncryptedPacket& packet) {
   StringPiece encrypted;
   if (!reader_->ReadStringPiece(&encrypted, reader_->BytesRemaining())) {
     return false;
   }
   DCHECK(decrypter_.get() != NULL);
   decrypted_.reset(decrypter_->DecryptPacket(
-      sequence_number,
-      GetAssociatedDataFromEncryptedPacket(packet, guid_length, version_flag),
+      header.packet_sequence_number,
+      GetAssociatedDataFromEncryptedPacket(
+          packet,
+          header.public_header.guid_length,
+          header.public_header.version_flag,
+          header.public_header.sequence_number_length),
       encrypted));
   if  (decrypted_.get() == NULL && alternative_decrypter_.get() != NULL) {
     decrypted_.reset(alternative_decrypter_->DecryptPacket(
-        sequence_number,
-        GetAssociatedDataFromEncryptedPacket(packet, guid_length, version_flag),
+        header.packet_sequence_number,
+        GetAssociatedDataFromEncryptedPacket(
+            packet,
+            header.public_header.guid_length,
+            header.public_header.version_flag,
+            header.public_header.sequence_number_length),
         encrypted));
     if (decrypted_.get() != NULL) {
       if (alternative_decrypter_latch_) {
         // Switch to the alternative decrypter and latch so that we cannot
         // switch back.
         decrypter_.reset(alternative_decrypter_.release());
       } else {
         // Switch the alternative decrypter so that we use it first next time.
         decrypter_.swap(alternative_decrypter_);
       }
     }
   }
 
   if  (decrypted_.get() == NULL) {
     return false;
   }
 
   reader_.reset(new QuicDataReader(decrypted_->data(), decrypted_->length()));
   return true;
 }
 
 size_t QuicFramer::ComputeFrameLength(const QuicFrame& frame) {
   switch (frame.type) {
     case STREAM_FRAME:
       return GetMinStreamFrameSize() + frame.stream_frame->data.size();
     case ACK_FRAME: {
       const QuicAckFrame& ack = *frame.ack_frame;
-      return GetMinAckFrameSize() +
-          kSequenceNumberSize * ack.received_info.missing_packets.size();
+      return GetMinAckFrameSize() + PACKET_6BYTE_SEQUENCE_NUMBER *
+          ack.received_info.missing_packets.size();
     }
     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 += 2;
           len += 1;  // Number received packets.
           if (inter_arrival.received_packet_times.size() > 0) {
-            len += kSequenceNumberSize;  // Smallest received.
+            len += PACKET_6BYTE_SEQUENCE_NUMBER;  // Smallest received.
             len += 8;  // Time.
             // 2 bytes per sequence number delta plus 4 bytes per delta time.
-            len += kSequenceNumberSize *
+            len += PACKET_6BYTE_SEQUENCE_NUMBER *
                 (inter_arrival.received_packet_times.size() - 1);
           }
           break;
         }
         case kFixRate:
           len += 4;
           break;
         case kTCP:
           len += 4;
           break;
         default:
           set_detailed_error("Illegal feedback type.");
           DLOG(INFO) << "Illegal feedback type: " << congestion_feedback.type;
           break;
       }
       return len;
     }
     case RST_STREAM_FRAME:
       return GetMinRstStreamFrameSize() +
           frame.rst_stream_frame->error_details.size();
     case CONNECTION_CLOSE_FRAME: {
       const QuicAckFrame& ack = frame.connection_close_frame->ack_frame;
       return GetMinConnectionCloseFrameSize() +
           frame.connection_close_frame->error_details.size() +
-          kSequenceNumberSize * ack.received_info.missing_packets.size();
+          PACKET_6BYTE_SEQUENCE_NUMBER *
+          ack.received_info.missing_packets.size();
     }
     case GOAWAY_FRAME:
       return GetMinGoAwayFrameSize() + frame.goaway_frame->reason_phrase.size();
     case PADDING_FRAME:
       DCHECK(false);
       return 0;
     case NUM_FRAME_TYPES:
       DCHECK(false);
       return 0;
   }
 
   // Not reachable, but some Chrome compilers can't figure that out.  *sigh*
   DCHECK(false);
   return 0;
 }
 
 // static
 bool QuicFramer::AppendPacketSequenceNumber(
+    QuicSequenceNumberLength sequence_number_length,
     QuicPacketSequenceNumber packet_sequence_number,
     QuicDataWriter* writer) {
   // Ensure the entire sequence number can be written.
-  if (writer->capacity() - writer->length() < kSequenceNumberSize) {
+  if (writer->capacity() - writer->length() <
+      static_cast<size_t>( sequence_number_length)) {
     return false;
   }
-  return writer->WriteUInt48(packet_sequence_number & kSequenceNumberMask);
+  switch (sequence_number_length) {
+    case PACKET_1BYTE_SEQUENCE_NUMBER:
+      return writer->WriteUInt8(
+          packet_sequence_number & k1ByteSequenceNumberMask);
+      break;
+    case PACKET_2BYTE_SEQUENCE_NUMBER:
+      return writer->WriteUInt16(
+          packet_sequence_number & k2ByteSequenceNumberMask);
+      break;
+    case PACKET_4BYTE_SEQUENCE_NUMBER:
+      return writer->WriteUInt32(
+          packet_sequence_number & k4ByteSequenceNumberMask);
+      break;
+    case PACKET_6BYTE_SEQUENCE_NUMBER:
+      return writer->WriteUInt48(
+          packet_sequence_number & k6ByteSequenceNumberMask);
+      break;
+    default:
+      NOTREACHED() << "sequence_number_length: " << sequence_number_length;
+      return false;
+  }
 }
 
 bool QuicFramer::AppendStreamFramePayload(
     const QuicStreamFrame& frame,
     QuicDataWriter* writer) {
   if (!writer->WriteUInt32(frame.stream_id)) {
     return false;
   }
   if (!writer->WriteUInt8(frame.fin)) {
     return false;
   }
   if (!writer->WriteUInt64(frame.offset)) {
     return false;
   }
   if (!writer->WriteUInt16(frame.data.size())) {
     return false;
   }
-  if (!writer->WriteBytes(frame.data.data(),
-                           frame.data.size())) {
+  if (!writer->WriteBytes(frame.data.data(), frame.data.size())) {
     return false;
   }
   return true;
 }
 
 QuicPacketSequenceNumber QuicFramer::CalculateLargestObserved(
     const SequenceNumberSet& missing_packets,
     SequenceNumberSet::const_iterator largest_written) {
   SequenceNumberSet::const_iterator it = largest_written;
   QuicPacketSequenceNumber previous_missing = *it;
@@ skipping 12 matching lines @@
 // TODO(ianswett): Use varints or another more compact approach for all deltas.
 bool QuicFramer::AppendAckFramePayload(
     const QuicAckFrame& frame,
     QuicDataWriter* writer) {
   // TODO(satyamshekhar): Decide how often we really should send this
   // entropy_hash update.
   if (!writer->WriteUInt8(frame.sent_info.entropy_hash)) {
     return false;
   }
 
-  if (!AppendPacketSequenceNumber(frame.sent_info.least_unacked, writer)) {
+  if (!AppendPacketSequenceNumber(PACKET_6BYTE_SEQUENCE_NUMBER,
+                                  frame.sent_info.least_unacked, writer)) {
     return false;
   }
 
   size_t received_entropy_offset = writer->length();
   if (!writer->WriteUInt8(frame.received_info.entropy_hash)) {
     return false;
   }
 
   size_t largest_observed_offset = writer->length();
-  if (!AppendPacketSequenceNumber(frame.received_info.largest_observed,
+  if (!AppendPacketSequenceNumber(PACKET_6BYTE_SEQUENCE_NUMBER,
+                                  frame.received_info.largest_observed,
                                   writer)) {
     return false;
   }
   uint32 delta_time_largest_observed_us = kInvalidDeltaTime;
   if (!frame.received_info.delta_time_largest_observed.IsInfinite()) {
     delta_time_largest_observed_us =
         frame.received_info.delta_time_largest_observed.ToMicroseconds();
   }
 
   size_t delta_time_largest_observed_offset = writer->length();
   if (!writer->WriteUInt32(delta_time_largest_observed_us)) {
     return false;
   }
 
   // We don't check for overflowing uint8 here, because we only can fit 192 acks
   // per packet, so if we overflow we will be truncated.
   uint8 num_missing_packets = frame.received_info.missing_packets.size();
   size_t num_missing_packets_offset = writer->length();
   if (!writer->WriteBytes(&num_missing_packets, 1)) {
     return false;
   }
 
   SequenceNumberSet::const_iterator it =
       frame.received_info.missing_packets.begin();
   int num_missing_packets_written = 0;
   for (; it != frame.received_info.missing_packets.end(); ++it) {
-    if (!AppendPacketSequenceNumber(*it, writer)) {
+    if (!AppendPacketSequenceNumber(PACKET_6BYTE_SEQUENCE_NUMBER,
+                                    *it, writer)) {
       // We are truncating.
       QuicPacketSequenceNumber largest_observed =
           CalculateLargestObserved(frame.received_info.missing_packets, --it);
       // Overwrite entropy hash for received packets.
       writer->WriteUInt8ToOffset(
           entropy_calculator_->ReceivedEntropyHash(largest_observed),
           received_entropy_offset);
       // Overwrite largest_observed.
-      writer->WriteUInt48ToOffset(largest_observed & kSequenceNumberMask,
+      writer->WriteUInt48ToOffset(largest_observed & k6ByteSequenceNumberMask,
                                   largest_observed_offset);
       writer->WriteUInt32ToOffset(kInvalidDeltaTime,
                                   delta_time_largest_observed_offset);
       writer->WriteUInt8ToOffset(num_missing_packets_written,
                                  num_missing_packets_offset);
       return true;
     }
     ++num_missing_packets_written;
     DCHECK_GE(numeric_limits<uint8>::max(), num_missing_packets_written);
   }
@@ skipping 26 matching lines @@
       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(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) {
@@ skipping 93 matching lines @@
 
 bool QuicFramer::RaiseError(QuicErrorCode error) {
   DLOG(INFO) << detailed_error_;
   set_error(error);
   visitor_->OnError(this);
   reader_.reset(NULL);
   return false;
 }
 
 }  // namespace net