Change from re-transmitting an packet with a retransmit number to sending a new packet with a new s…

net/quic/quic_protocol.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef NET_QUIC_QUIC_PROTOCOL_H_
 #define NET_QUIC_QUIC_PROTOCOL_H_
 
 #include <limits>
 #include <ostream>
 #include <utility>
@@ skipping 17 matching lines @@
 typedef uint64 QuicTransmissionTime;
 typedef uint8 QuicFecGroupNumber;
 
 // TODO(rch): Consider Quic specific names for these constants.
 const size_t kMaxPacketSize = 1200;  // Maximum size in bytes of a QUIC packet.
 
 // Maximum number of open streams per connection.
 const size_t kDefaultMaxStreamsPerConnection = 100;
 
 // Size in bytes of the packet header common across all packets.
-const size_t kPacketHeaderSize = 25;
+const size_t kPacketHeaderSize = 24;
 // Index of the first byte in a QUIC packet of FEC protected data.
 const size_t kStartOfFecProtectedData = kPacketHeaderSize;
 // Index of the first byte in a QUIC packet of encrypted data.
 const size_t kStartOfEncryptedData = kPacketHeaderSize - 1;
 // Index of the first byte in a QUIC packet which is hashed.
 const size_t kStartOfHashData = 0;
-// Index into the retransmission offset in the header.
-// (After GUID and sequence number.)
-const int kRetransmissionOffset = 14;
+// Index into the sequence number offset in the header.
+const int kSequenceNumberOffset = 8;
 // Index into the transmission time offset in the header.
-const int kTransmissionTimeOffset = 15;
+const int kTransmissionTimeOffset = 14;
+// Index into the flags offset in the header.
+const int kFlagsOffset = 22;
+// Index into the fec group offset in the header.
+const int kFecGroupOffset = 23;
 
 // Size in bytes of all stream frame fields.
 const size_t kMinStreamFrameLength = 15;
 
 // Limit on the delta between stream IDs.
 const QuicStreamId kMaxStreamIdDelta = 100;
 
 // Reserved ID for the crypto stream.
 // TODO(rch): ensure that this is not usable by any other streams.
 const QuicStreamId kCryptoStreamId = 1;
@@ skipping 78 matching lines @@
   // A crypto message was receieved with an illegal message tag.
   QUIC_INVALID_CRYPTO_MESSAGE_TYPE,
 
 };
 
 struct NET_EXPORT_PRIVATE QuicPacketHeader {
   // Includes the ConnectionHeader and CongestionMonitoredHeader
   // from the design docs, as well as some elements of DecryptedData.
   QuicGuid guid;
   QuicPacketSequenceNumber packet_sequence_number;
-  uint8 retransmission_count;
   QuicTransmissionTime transmission_time;
   QuicPacketFlags flags;
   QuicFecGroupNumber fec_group;
 };
 
 struct NET_EXPORT_PRIVATE QuicStreamFrame {
   QuicStreamFrame();
   QuicStreamFrame(QuicStreamId stream_id,
                   bool fin,
                   uint64 offset,
@@ skipping 186 matching lines @@
  private:
   const char* buffer_;
   size_t length_;
   bool owns_buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicData);
 };
 
 class NET_EXPORT_PRIVATE QuicPacket : public QuicData {
  public:
-  QuicPacket(char* buffer, size_t length, bool owns_buffer)
+  QuicPacket(
+      char* buffer, size_t length, bool owns_buffer, QuicPacketFlags flags)
       : QuicData(buffer, length, owns_buffer),
-        buffer_(buffer) { }
+        buffer_(buffer),
+        flags_(flags) { }
 
   base::StringPiece FecProtectedData() const {
     return base::StringPiece(data() + kStartOfFecProtectedData,
                              length() - kStartOfFecProtectedData);
   }
 
   base::StringPiece AssociatedData() const {
     return base::StringPiece(data() + kStartOfHashData, kStartOfEncryptedData);
   }
 
   base::StringPiece Plaintext() const {
     return base::StringPiece(data() + kStartOfEncryptedData,
                              length() - kStartOfEncryptedData);
   }
+
+  bool IsFecPacket() const {
+    return flags_ == PACKET_FLAGS_FEC;
+  }
+
   char* mutable_data() { return buffer_; }
 
  private:
   char* buffer_;
+  const QuicPacketFlags flags_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicPacket);
 };
 
 class NET_EXPORT_PRIVATE QuicEncryptedPacket : public QuicData {
  public:
   QuicEncryptedPacket(const char* buffer, size_t length)
       : QuicData(buffer, length) { }
 
   QuicEncryptedPacket(char* buffer, size_t length, bool owns_buffer)
       : QuicData(buffer, length, owns_buffer) { }
 
   base::StringPiece AssociatedData() const {
     return base::StringPiece(data() + kStartOfHashData, kStartOfEncryptedData);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(QuicEncryptedPacket);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_PROTOCOL_H_