Revert 204046 "Land Recent QUIC changes."

trunk/src/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(QuicPacketHeader header) {
   return GetPacketHeaderSize(header.public_header.guid_length,
                              header.public_header.version_flag,
-                             header.public_header.sequence_number_length,
                              header.is_in_fec_group);
 }
 
 size_t GetPacketHeaderSize(QuicGuidLength guid_length,
                            bool include_version,
-                           QuicSequenceNumberLength sequence_number_length,
                            InFecGroup is_in_fec_group) {
   return kPublicFlagsSize + guid_length +
-      (include_version ? kQuicVersionSize : 0) + sequence_number_length +
+      (include_version ? kQuicVersionSize : 0) + kSequenceNumberSize +
       kPrivateFlagsSize + (is_in_fec_group == IN_FEC_GROUP ? kFecGroupSize : 0);
 }
 
 size_t GetPublicResetPacketSize() {
   return kPublicFlagsSize + PACKET_8BYTE_GUID + kPublicResetNonceSize +
-      PACKET_6BYTE_SEQUENCE_NUMBER;
+      kSequenceNumberSize;
 }
 
-size_t GetStartOfFecProtectedData(
-    QuicGuidLength guid_length,
-    bool include_version,
-    QuicSequenceNumberLength sequence_number_length) {
-  return GetPacketHeaderSize(
-      guid_length, include_version, sequence_number_length, IN_FEC_GROUP);
+size_t GetStartOfFecProtectedData(QuicGuidLength guid_length,
+                                  bool include_version) {
+  return GetPacketHeaderSize(guid_length, include_version, IN_FEC_GROUP);
 }
 
-size_t GetStartOfEncryptedData(
-    QuicGuidLength guid_length,
-    bool include_version,
-    QuicSequenceNumberLength sequence_number_length) {
+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, sequence_number_length, NOT_IN_FEC_GROUP) -
+  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),
-      sequence_number_length(PACKET_6BYTE_SEQUENCE_NUMBER) {
+      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),
-      sequence_number_length(other.sequence_number_length),
       versions(other.versions) {
 }
 
 QuicPacketPublicHeader::~QuicPacketPublicHeader() {}
 
 QuicPacketPublicHeader& QuicPacketPublicHeader::operator=(
     const QuicPacketPublicHeader& other) {
   guid = other.guid;
   reset_flag = other.reset_flag;
   version_flag = other.version_flag;
@@ skipping 167 matching lines @@
                                  QuicStreamId last_good_stream_id,
                                  const string& reason)
     : error_code(error_code),
       last_good_stream_id(last_good_stream_id),
       reason_phrase(reason) {
   DCHECK_LE(error_code, numeric_limits<uint8>::max());
 }
 
 QuicFecData::QuicFecData() {}
 
+bool QuicFecData::operator==(const QuicFecData& other) const {
+  if (fec_group != other.fec_group) {
+    return false;
+  }
+  if (redundancy != other.redundancy) {
+    return false;
+  }
+  return true;
+}
+
 QuicData::~QuicData() {
   if (owns_buffer_) {
     delete [] const_cast<char*>(buffer_);
   }
 }
 
 StringPiece QuicPacket::FecProtectedData() const {
-  const size_t start_of_fec = GetStartOfFecProtectedData(
-      guid_length_, includes_version_, sequence_number_length_);
+  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(
-          guid_length_, includes_version_, sequence_number_length_) -
-      kStartOfHashData);
+  return StringPiece(data() + kStartOfHashData,
+                     GetStartOfEncryptedData(guid_length_, includes_version_) -
+                     kStartOfHashData);
 }
 
 StringPiece QuicPacket::BeforePlaintext() const {
   return StringPiece(data(), GetStartOfEncryptedData(guid_length_,
-                                                     includes_version_,
-                                                     sequence_number_length_));
+                                                     includes_version_));
 }
 
 StringPiece QuicPacket::Plaintext() const {
   const size_t start_of_encrypted_data =
-      GetStartOfEncryptedData(
-          guid_length_, includes_version_, sequence_number_length_);
+      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