Land Recent QUIC changes.

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 <stddef.h>
 #include <limits>
 #include <map>
@@ skipping 10 matching lines @@
 #include "net/base/int128.h"
 #include "net/base/net_export.h"
 #include "net/quic/quic_bandwidth.h"
 #include "net/quic/quic_time.h"
 
 namespace net {
 
 using ::operator<<;
 
 class QuicPacket;
+struct QuicPacketHeader;
 
 typedef uint64 QuicGuid;
 typedef uint32 QuicStreamId;
 typedef uint64 QuicStreamOffset;
 typedef uint64 QuicPacketSequenceNumber;
 typedef QuicPacketSequenceNumber QuicFecGroupNumber;
 typedef uint64 QuicPublicResetNonceProof;
 typedef uint8 QuicPacketEntropyHash;
 typedef uint32 QuicHeaderId;
 // QuicTag is the type of a tag in the wire protocol.
 typedef uint32 QuicTag;
 typedef std::vector<QuicTag> QuicTagVector;
 
 // TODO(rch): Consider Quic specific names for these constants.
 // Maximum size in bytes of a QUIC packet.
 const QuicByteCount kMaxPacketSize = 1200;
 
 // Maximum number of open streams per connection.
 const size_t kDefaultMaxStreamsPerConnection = 100;
 
 // Number of bytes reserved for public flags in the packet header.
 const size_t kPublicFlagsSize = 1;
-// Number of bytes reserved for guid in the packet header.
-const size_t kQuicGuidSize = 8;
 // Number of bytes reserved for version number in the packet header.
 const size_t kQuicVersionSize = 4;
 // Number of bytes reserved for sequence number in the packet header.
 const size_t kSequenceNumberSize = 6;
 // Number of bytes reserved for private flags in the packet header.
 const size_t kPrivateFlagsSize = 1;
 // Number of bytes reserved for FEC group in the packet header.
 const size_t kFecGroupSize = 1;
 // Number of bytes reserved for the nonce proof in public reset packet.
 const size_t kPublicResetNonceSize = 8;
 
 // Signifies that the QuicPacket will contain version of the protocol.
 const bool kIncludeVersion = true;
 
-// Size in bytes of the data or fec packet header.
-NET_EXPORT_PRIVATE size_t GetPacketHeaderSize(bool include_version);
-// Size in bytes of the public reset packet.
-NET_EXPORT_PRIVATE size_t GetPublicResetPacketSize();
-
-// Index of the first byte in a QUIC packet of FEC protected data.
-NET_EXPORT_PRIVATE size_t GetStartOfFecProtectedData(bool include_version);
-// Index of the first byte in a QUIC packet of encrypted data.
-NET_EXPORT_PRIVATE size_t GetStartOfEncryptedData(bool include_version);
 // Returns true if |version| is a supported protocol version.
 NET_EXPORT_PRIVATE bool IsSupportedVersion(QuicTag version);
 
 // Index of the first byte in a QUIC packet which is used in hash calculation.
 const size_t kStartOfHashData = 0;
 
 // Limit on the delta between stream IDs.
 const QuicStreamId kMaxStreamIdDelta = 100;
 // Limit on the delta between header IDs.
 const QuicHeaderId kMaxHeaderIdDelta = 100;
 
 // Reserved ID for the crypto stream.
 // TODO(rch): ensure that this is not usable by any other streams.
 const QuicStreamId kCryptoStreamId = 1;
 
-// Value which indicates this packet is not FEC protected.
-const uint8 kNoFecOffset = 0xFF;
-
 // This is the default network timeout a for connection till the crypto
 // handshake succeeds and the negotiated timeout from the handshake is received.
-const int64 kDefaultInitialTimeoutSecs = 30;  // 30 secs.
+const int64 kDefaultInitialTimeoutSecs = 120;  // 2 mins.
 const int64 kDefaultTimeoutSecs = 60 * 10;  // 10 minutes.
+const int64 kDefaultMaxTimeForCryptoHandshakeSecs = 5;  // 5 secs.
 
 enum Retransmission {
   NOT_RETRANSMISSION,
   IS_RETRANSMISSION,
 };
 
 enum HasRetransmittableData {
   NO_RETRANSMITTABLE_DATA,
   HAS_RETRANSMITTABLE_DATA,
 };
 
 enum QuicFrameType {
   PADDING_FRAME = 0,
   STREAM_FRAME,
   ACK_FRAME,
   CONGESTION_FEEDBACK_FRAME,
   RST_STREAM_FRAME,
   CONNECTION_CLOSE_FRAME,
   GOAWAY_FRAME,
   NUM_FRAME_TYPES
 };
 
+enum QuicGuidLength {
+  PACKET_0BYTE_GUID = 0,
+  PACKET_1BYTE_GUID = 1,
+  PACKET_4BYTE_GUID = 4,
+  PACKET_8BYTE_GUID = 8
+};
+
+enum InFecGroup {
+  NOT_IN_FEC_GROUP,
+  IN_FEC_GROUP,
+};
+
 enum QuicPacketPublicFlags {
   PACKET_PUBLIC_FLAGS_NONE = 0,
   PACKET_PUBLIC_FLAGS_VERSION = 1 << 0,  // Packet header contains version info.
   PACKET_PUBLIC_FLAGS_RST = 1 << 1,  // Packet is a public reset packet.
   // Packet header guid length in bytes.
   PACKET_PUBLIC_FLAGS_0BYTE_GUID = 0,
   PACKET_PUBLIC_FLAGS_1BYTE_GUID = 1 << 2,
   PACKET_PUBLIC_FLAGS_4BYTE_GUID = 1 << 3,
   PACKET_PUBLIC_FLAGS_8BYTE_GUID = 1 << 3 | 1 << 2,
   PACKET_PUBLIC_FLAGS_MAX = (1 << 4) - 1  // All bits set.
 };
 
 enum QuicPacketPrivateFlags {
   PACKET_PRIVATE_FLAGS_NONE = 0,
-  PACKET_PRIVATE_FLAGS_FEC = 1 << 0,  // Payload is FEC as opposed to frames.
-  PACKET_PRIVATE_FLAGS_ENTROPY = 1 << 1,
-  PACKET_PRIVATE_FLAGS_FEC_ENTROPY = 1 << 2,
+  PACKET_PRIVATE_FLAGS_ENTROPY = 1 << 0,
+  PACKET_PRIVATE_FLAGS_FEC_GROUP = 1 << 1,  // Payload is part of an FEC group.
+  PACKET_PRIVATE_FLAGS_FEC = 1 << 2,  // Payload is FEC as opposed to frames.
   PACKET_PRIVATE_FLAGS_MAX = (1 << 3) - 1  // All bits set.
 };
 
+// Size in bytes of the data or fec packet header.
+NET_EXPORT_PRIVATE size_t GetPacketHeaderSize(QuicPacketHeader header);
+
+NET_EXPORT_PRIVATE size_t GetPacketHeaderSize(QuicGuidLength guid_length,
+                                              bool include_version,
+                                              InFecGroup is_in_fec_group);
+
+// Size in bytes of the public reset packet.
+NET_EXPORT_PRIVATE size_t GetPublicResetPacketSize();
+
+// Index of the first byte in a QUIC packet of FEC protected data.
+NET_EXPORT_PRIVATE size_t GetStartOfFecProtectedData(QuicGuidLength guid_length,
+                                                     bool include_version);
+// Index of the first byte in a QUIC packet of encrypted data.
+NET_EXPORT_PRIVATE size_t GetStartOfEncryptedData(QuicGuidLength guid_length,
+                                                  bool include_version);
+
 enum QuicRstStreamErrorCode {
   QUIC_STREAM_NO_ERROR = 0,
 
   // There was some server error which halted stream processing.
   QUIC_SERVER_ERROR_PROCESSING_STREAM,
   // We got two fin or reset offsets which did not match.
   QUIC_MULTIPLE_TERMINATION_OFFSETS,
   // We got bad payload and can not respond to it at the protocol level.
   QUIC_BAD_APPLICATION_PAYLOAD,
   // Stream closed due to connection error. No reset frame is sent when this
@@ skipping 119 matching lines @@
 // stored in memory as a little endian uint32, we need
 // to reverse the order of the bytes.
 //
 // The TAG macro is used in header files to ensure that we don't create static
 // initialisers. In normal code, the MakeQuicTag function should be used.
 #define TAG(a, b, c, d) ((d << 24) + (c << 16) + (b << 8) + a)
 const QuicTag kUnsupportedVersion = -1;
 // Each time the wire format changes, this need needs to be incremented.
 // At some point, we will actually freeze the wire format and make an official
 // version number, but this works for now.
-const QuicTag kQuicVersion1 = TAG('Q', '0', '0', '4');
+const QuicTag kQuicVersion1 = TAG('Q', '0', '0', '5');
 #undef TAG
 
 // MakeQuicTag returns a value given the four bytes. For example:
 //   MakeQuicTag('C', 'H', 'L', 'O');
 uint32 NET_EXPORT_PRIVATE MakeQuicTag(char a, char b, char c, char d);
 
 struct NET_EXPORT_PRIVATE QuicPacketPublicHeader {
   QuicPacketPublicHeader();
   explicit QuicPacketPublicHeader(const QuicPacketPublicHeader& other);
   ~QuicPacketPublicHeader();
 
   QuicPacketPublicHeader& operator=(const QuicPacketPublicHeader& other);
 
   // Universal header. All QuicPacket headers will have a guid and public flags.
   QuicGuid guid;
+  QuicGuidLength guid_length;
   bool reset_flag;
   bool version_flag;
   QuicTagVector versions;
 };
 
 // Header for Data or FEC packets.
 struct NET_EXPORT_PRIVATE QuicPacketHeader {
   QuicPacketHeader();
   explicit QuicPacketHeader(const QuicPacketPublicHeader& header);
 
   NET_EXPORT_PRIVATE friend std::ostream& operator<<(
       std::ostream& os, const QuicPacketHeader& s);
 
   QuicPacketPublicHeader public_header;
   bool fec_flag;
-  bool fec_entropy_flag;
   bool entropy_flag;
   QuicPacketEntropyHash entropy_hash;
   QuicPacketSequenceNumber packet_sequence_number;
+  InFecGroup is_in_fec_group;
   QuicFecGroupNumber fec_group;
 };
 
 struct NET_EXPORT_PRIVATE QuicPublicResetPacket {
   QuicPublicResetPacket() {}
   explicit QuicPublicResetPacket(const QuicPacketPublicHeader& header)
       : public_header(header) {}
   QuicPacketPublicHeader public_header;
   QuicPacketSequenceNumber rejected_sequence_number;
   QuicPublicResetNonceProof nonce_proof;
@@ skipping 273 matching lines @@
   bool owns_buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicData);
 };
 
 class NET_EXPORT_PRIVATE QuicPacket : public QuicData {
  public:
   static QuicPacket* NewDataPacket(char* buffer,
                                    size_t length,
                                    bool owns_buffer,
+                                   QuicGuidLength guid_length,
                                    bool includes_version) {
-    return new QuicPacket(buffer, length, owns_buffer, includes_version, false);
+    return new QuicPacket(
+        buffer, length, owns_buffer, guid_length, includes_version, false);
   }
 
   static QuicPacket* NewFecPacket(char* buffer,
                                   size_t length,
                                   bool owns_buffer,
+                                  QuicGuidLength guid_length,
                                   bool includes_version) {
-    return new QuicPacket(buffer, length, owns_buffer, includes_version, true);
+    return new QuicPacket(
+        buffer, length, owns_buffer, guid_length, includes_version, true);
   }
 
   base::StringPiece FecProtectedData() const;
   base::StringPiece AssociatedData() const;
   base::StringPiece BeforePlaintext() const;
   base::StringPiece Plaintext() const;
 
   bool is_fec_packet() const { return is_fec_packet_; }
 
   bool includes_version() const { return includes_version_; }
 
   char* mutable_data() { return buffer_; }
 
  private:
   QuicPacket(char* buffer,
              size_t length,
              bool owns_buffer,
+             QuicGuidLength guid_length,
              bool includes_version,
              bool is_fec_packet)
       : QuicData(buffer, length, owns_buffer),
         buffer_(buffer),
         is_fec_packet_(is_fec_packet),
+        guid_length_(guid_length),
         includes_version_(includes_version) {}
 
   char* buffer_;
   const bool is_fec_packet_;
+  const QuicGuidLength guid_length_;
   const bool includes_version_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicPacket);
 };
 
 class NET_EXPORT_PRIVATE QuicEncryptedPacket : public QuicData {
  public:
   QuicEncryptedPacket(const char* buffer, size_t length)
       : QuicData(buffer, length) {}
 
@@ skipping 69 matching lines @@
   NET_EXPORT_PRIVATE friend std::ostream& operator<<(
       std::ostream& os, const QuicConsumedData& s);
 
   size_t bytes_consumed;
   bool fin_consumed;
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_PROTOCOL_H_