Land Recent QUIC changes.

net/quic/quic_protocol.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_protocol.h"
 #include "base/stl_util.h"
 
 using base::StringPiece;
 using std::map;
 using std::numeric_limits;
 using std::ostream;
 using std::string;
 
 namespace net {
 
-size_t GetPacketHeaderSize(bool include_version) {
-  return kPublicFlagsSize + kQuicGuidSize +
+size_t GetPacketHeaderSize(QuicPacketHeader header) {
+  return GetPacketHeaderSize(header.public_header.guid_length,
+                             header.public_header.version_flag,
+                             header.is_in_fec_group);
+}
+
+size_t GetPacketHeaderSize(QuicGuidLength guid_length,
+                           bool include_version,
+                           InFecGroup is_in_fec_group) {
+  return kPublicFlagsSize + guid_length +
       (include_version ? kQuicVersionSize : 0) + kSequenceNumberSize +
-      kPrivateFlagsSize + kFecGroupSize;
+      kPrivateFlagsSize + (is_in_fec_group == IN_FEC_GROUP ? kFecGroupSize : 0);
 }
 
 size_t GetPublicResetPacketSize() {
-  return kPublicFlagsSize + kQuicGuidSize + kPublicResetNonceSize +
+  return kPublicFlagsSize + PACKET_8BYTE_GUID + kPublicResetNonceSize +
       kSequenceNumberSize;
 }
 
-size_t GetStartOfFecProtectedData(bool include_version) {
-  return GetPacketHeaderSize(include_version);
+size_t GetStartOfFecProtectedData(QuicGuidLength guid_length,
+                                  bool include_version) {
+  return GetPacketHeaderSize(guid_length, include_version, IN_FEC_GROUP);
 }
 
-size_t GetStartOfEncryptedData(bool include_version) {
-  return GetPacketHeaderSize(include_version) - kPrivateFlagsSize -
-      kFecGroupSize;
+size_t GetStartOfEncryptedData(QuicGuidLength guid_length,
+                               bool include_version) {
+  // Don't include the fec size, since encryption starts before private flags.
+  return GetPacketHeaderSize(guid_length, include_version, NOT_IN_FEC_GROUP) -
+      kPrivateFlagsSize;
 }
 
 uint32 MakeQuicTag(char a, char b, char c, char d) {
   return static_cast<uint32>(a) |
          static_cast<uint32>(b) << 8 |
          static_cast<uint32>(c) << 16 |
          static_cast<uint32>(d) << 24;
 }
 
 QuicPacketPublicHeader::QuicPacketPublicHeader()
     : guid(0),
+      guid_length(PACKET_8BYTE_GUID),
       reset_flag(false),
       version_flag(false) {
 }
 
 QuicPacketPublicHeader::QuicPacketPublicHeader(
     const QuicPacketPublicHeader& other)
     : guid(other.guid),
+      guid_length(other.guid_length),
       reset_flag(other.reset_flag),
       version_flag(other.version_flag),
       versions(other.versions) {
 }
 
 QuicPacketPublicHeader::~QuicPacketPublicHeader() {}
 
 QuicPacketPublicHeader& QuicPacketPublicHeader::operator=(
     const QuicPacketPublicHeader& other) {
   guid = other.guid;
   reset_flag = other.reset_flag;
   version_flag = other.version_flag;
   versions = other.versions;
   return *this;
 }
 
 QuicPacketHeader::QuicPacketHeader()
     : fec_flag(false),
-      fec_entropy_flag(false),
       entropy_flag(false),
       entropy_hash(0),
       packet_sequence_number(0),
+      is_in_fec_group(NOT_IN_FEC_GROUP),
       fec_group(0) {
 }
 
 QuicPacketHeader::QuicPacketHeader(const QuicPacketPublicHeader& header)
     : public_header(header),
       fec_flag(false),
-      fec_entropy_flag(false),
       entropy_flag(false),
       entropy_hash(0),
       packet_sequence_number(0),
+      is_in_fec_group(NOT_IN_FEC_GROUP),
       fec_group(0) {
 }
 
 QuicStreamFrame::QuicStreamFrame() {}
 
 QuicStreamFrame::QuicStreamFrame(QuicStreamId stream_id,
                                  bool fin,
                                  QuicStreamOffset offset,
                                  StringPiece data)
     : stream_id(stream_id),
       fin(fin),
       offset(offset),
       data(data) {
 }
 
 ostream& operator<<(ostream& os, const QuicPacketHeader& header) {
   os << "{ guid: " << header.public_header.guid
+     << ", guid_length:" << header.public_header.guid_length
      << ", reset_flag: " << header.public_header.reset_flag
      << ", version_flag: " << header.public_header.version_flag;
   if (header.public_header.version_flag) {
     os << " version: ";
     for (size_t i = 0; i < header.public_header.versions.size(); ++i) {
       os << header.public_header.versions[0] << " ";
     }
   }
   os << ", fec_flag: " << header.fec_flag
      << ", entropy_flag: " << header.entropy_flag
      << ", entropy hash: " << static_cast<int>(header.entropy_hash)
      << ", sequence_number: " << header.packet_sequence_number
+     << ", is_in_fec_group:" << header.is_in_fec_group
      << ", fec_group: " << header.fec_group<< "}\n";
   return os;
 }
 
 // TODO(ianswett): Initializing largest_observed to 0 should not be necessary.
 ReceivedPacketInfo::ReceivedPacketInfo()
     : largest_observed(0),
       delta_time_largest_observed(QuicTime::Delta::Infinite()) {
 }
 
@@ skipping 123 matching lines @@
   return true;
 }
 
 QuicData::~QuicData() {
   if (owns_buffer_) {
     delete [] const_cast<char*>(buffer_);
   }
 }
 
 StringPiece QuicPacket::FecProtectedData() const {
-  const size_t start_of_fec = GetStartOfFecProtectedData(includes_version_);
+  const size_t start_of_fec = GetStartOfFecProtectedData(guid_length_,
+                                                         includes_version_);
   return StringPiece(data() + start_of_fec, length() - start_of_fec);
 }
 
 StringPiece QuicPacket::AssociatedData() const {
   return StringPiece(data() + kStartOfHashData,
-                     GetStartOfEncryptedData(includes_version_) -
+                     GetStartOfEncryptedData(guid_length_, includes_version_) -
                      kStartOfHashData);
 }
 
 StringPiece QuicPacket::BeforePlaintext() const {
-  return StringPiece(data(), GetStartOfEncryptedData(includes_version_));
+  return StringPiece(data(), GetStartOfEncryptedData(guid_length_,
+                                                     includes_version_));
 }
 
 StringPiece QuicPacket::Plaintext() const {
   const size_t start_of_encrypted_data =
-      GetStartOfEncryptedData(includes_version_);
+      GetStartOfEncryptedData(guid_length_, includes_version_);
   return StringPiece(data() + start_of_encrypted_data,
                      length() - start_of_encrypted_data);
 }
 
 RetransmittableFrames::RetransmittableFrames()
     : encryption_level_(NUM_ENCRYPTION_LEVELS) {
 }
 
 RetransmittableFrames::~RetransmittableFrames() {
   for (QuicFrames::iterator it = frames_.begin(); it != frames_.end(); ++it) {
@@ skipping 54 matching lines @@
   return os;
 }
 
 ostream& operator<<(ostream& os, const QuicConsumedData& s) {
   os << "bytes_consumed: " << s.bytes_consumed
      << " fin_consumed: " << s.fin_consumed;
   return os;
 }
 
 }  // namespace net