Remove obsolete fields in quic_protocol and their current usage in QUIC. Reorders QuicAckFrame fie…

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 <stdint.h>
 
@@ skipping 24 matching lines @@
 
 class QuicPacket;
 struct QuicPacketHeader;
 class QuicAckListenerInterface;
 
 typedef uint64_t QuicConnectionId;
 typedef uint32_t QuicStreamId;
 typedef uint64_t QuicStreamOffset;
 typedef uint64_t QuicPacketNumber;
 typedef uint8_t QuicPathId;
-typedef QuicPacketNumber QuicFecGroupNumber;
 typedef uint64_t QuicPublicResetNonceProof;
 typedef uint8_t QuicPacketEntropyHash;
 typedef uint32_t QuicHeaderId;
 // QuicTag is the type of a tag in the wire protocol.
 typedef uint32_t QuicTag;
 typedef std::vector<QuicTag> QuicTagVector;
 typedef std::map<QuicTag, std::string> QuicTagValueMap;
 typedef uint16_t QuicPacketLength;
 
 // Default initial maximum size in bytes of a QUIC packet.
@@ skipping 24 matching lines @@
 
 // Maximum number of tracked packets.
 const QuicPacketCount kMaxTrackedPackets = 10000;
 
 // Default size of the socket receive buffer in bytes.
 const QuicByteCount kDefaultSocketReceiveBuffer = 256 * 1024;
 // Minimum size of the socket receive buffer in bytes.
 // Smaller values are ignored.
 const QuicByteCount kMinSocketReceiveBuffer = 16 * 1024;
 
-// Fraction of the receive buffer that can be used for encrypted bytes.
-// Allows a 5% overhead for IP and UDP framing, as well as ack only packets.
-static const float kUsableRecieveBufferFraction = 0.95f;
 // Fraction of the receive buffer that can be used, based on conservative
 // estimates and testing on Linux.
 // An alternative to kUsableRecieveBufferFraction.
 static const float kConservativeReceiveBufferFraction = 0.6f;
 
 // Don't allow a client to suggest an RTT shorter than 10ms.
 const uint32_t kMinInitialRoundTripTimeUs = 10 * kNumMicrosPerMilli;
 
 // Don't allow a client to suggest an RTT longer than 15 seconds.
 const uint32_t kMaxInitialRoundTripTimeUs = 15 * kNumMicrosPerSecond;
 
 // 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 version number in the packet header.
 const size_t kQuicVersionSize = 4;
 // Number of bytes reserved for path id in the packet header.
 const size_t kQuicPathIdSize = 1;
 // 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;
 
 // Signifies that the QuicPacket will contain version of the protocol.
 const bool kIncludeVersion = true;
 // Signifies that the QuicPacket will contain path id.
 const bool kIncludePathId = true;
 // Signifies that the QuicPacket will include a diversification nonce.
 const bool kIncludeDiversificationNonce = true;
 
 // Stream ID is reserved to denote an invalid ID.
 const QuicStreamId kInvalidStreamId = 0;
@@ skipping 143 matching lines @@
   // The path MTU discovery frame is encoded as a PING frame on the wire.
   MTU_DISCOVERY_FRAME,
   NUM_FRAME_TYPES
 };
 
 enum QuicConnectionIdLength {
   PACKET_0BYTE_CONNECTION_ID = 0,
   PACKET_8BYTE_CONNECTION_ID = 8
 };
 
-enum InFecGroup {
-  NOT_IN_FEC_GROUP,
-  IN_FEC_GROUP,
-};
-
 enum QuicPacketNumberLength : int8_t {
   PACKET_1BYTE_PACKET_NUMBER = 1,
   PACKET_2BYTE_PACKET_NUMBER = 2,
   PACKET_4BYTE_PACKET_NUMBER = 4,
   PACKET_6BYTE_PACKET_NUMBER = 6
 };
 
 // Used to indicate a QuicSequenceNumberLength using two flag bits.
 enum QuicPacketNumberLengthFlags {
   PACKET_FLAGS_1BYTE_PACKET = 0,           // 00
@@ skipping 405 matching lines @@
   // Connection migration was attempted, but there was no new network to
   // migrate to.
   QUIC_CONNECTION_MIGRATION_NO_NEW_NETWORK = 83,
   // Network changed, but connection had one or more non-migratable streams.
   QUIC_CONNECTION_MIGRATION_NON_MIGRATABLE_STREAM = 84,
 
   // No error. Used as bound while iterating.
   QUIC_LAST_ERROR = 91,
 };
 
-// Must be updated any time a QuicErrorCode is deprecated.
-const int kDeprecatedQuicErrorCount = 4;
-const int kActiveQuicErrorCount = QUIC_LAST_ERROR - kDeprecatedQuicErrorCount;
-
 typedef char DiversificationNonce[32];
 
 struct NET_EXPORT_PRIVATE QuicPacketPublicHeader {
   QuicPacketPublicHeader();
   explicit QuicPacketPublicHeader(const QuicPacketPublicHeader& other);
   ~QuicPacketPublicHeader();
 
   // Universal header. All QuicPacket headers will have a connection_id and
   // public flags.
   QuicConnectionId connection_id;
@@ skipping 19 matching lines @@
 
   NET_EXPORT_PRIVATE friend std::ostream& operator<<(std::ostream& os,
                                                      const QuicPacketHeader& s);
 
   QuicPacketPublicHeader public_header;
   QuicPacketNumber packet_number;
   QuicPathId path_id;
   bool entropy_flag;
   QuicPacketEntropyHash entropy_hash;
   bool fec_flag;
-  InFecGroup is_in_fec_group;
-  QuicFecGroupNumber fec_group;
 };
 
 struct NET_EXPORT_PRIVATE QuicPublicResetPacket {
   QuicPublicResetPacket();
   explicit QuicPublicResetPacket(const QuicPacketPublicHeader& header);
 
   QuicPacketPublicHeader public_header;
   QuicPublicResetNonceProof nonce_proof;
   QuicPacketNumber rejected_packet_number;
   IPEndPoint client_address;
@@ skipping 245 matching lines @@
 };
 
 struct NET_EXPORT_PRIVATE QuicAckFrame {
   QuicAckFrame();
   QuicAckFrame(const QuicAckFrame& other);
   ~QuicAckFrame();
 
   NET_EXPORT_PRIVATE friend std::ostream& operator<<(std::ostream& os,
                                                      const QuicAckFrame& s);
 
-  // Path which this ack belongs to.
-  QuicPathId path_id;
-
-  // Entropy hash of all packets up to largest observed not including missing
-  // packets.
-  QuicPacketEntropyHash entropy_hash;
-
-  // Whether the ack had to be truncated when sent.
-  bool is_truncated;
-
   // The highest packet number we've observed from the peer.
   //
   // In general, this should be the largest packet number we've received.  In
   // the case of truncated acks, we may have to advertise a lower "upper bound"
   // than largest received, to avoid implicitly acking missing packets that
   // don't fit in the missing packet list due to size limitations.  In this
   // case, largest_observed may be a packet which is also in the missing packets
   // list.
   QuicPacketNumber largest_observed;
 
   // Time elapsed since largest_observed was received until this Ack frame was
   // sent.
   QuicTime::Delta ack_delay_time;
 
   // Vector of <packet_number, time> for when packets arrived.
   PacketTimeVector received_packet_times;
 
   // Set of packets.
   PacketNumberQueue packets;
 
+  // Path which this ack belongs to.
+  QuicPathId path_id;
+
+  // Entropy hash of all packets up to largest observed not including missing
+  // packets.
+  QuicPacketEntropyHash entropy_hash;
+
+  // Whether the ack had to be truncated when sent.
+  bool is_truncated;
+
   // If true, |packets| express missing packets. Otherwise, |packets| express
   // received packets.
   bool missing;
 };
 
 // True if the packet number is greater than largest_observed or is listed
 // as missing.
 // Always returns false for packet numbers less than least_unacked.
 bool NET_EXPORT_PRIVATE
 IsAwaitingPacket(const QuicAckFrame& ack_frame,
@@ skipping 337 matching lines @@
   ~SerializedPacket();
 
   // Not owned.
   const char* encrypted_buffer;
   QuicPacketLength encrypted_length;
   QuicFrames retransmittable_frames;
   IsHandshake has_crypto_handshake;
   // -1: full padding to the end of a max-sized packet
   //  0: no padding
   //  otherwise: only pad up to num_padding_bytes bytes
-  int num_padding_bytes;
+  int16_t num_padding_bytes;
   QuicPathId path_id;
   QuicPacketNumber packet_number;
   QuicPacketNumberLength packet_number_length;
   EncryptionLevel encryption_level;
   QuicPacketEntropyHash entropy_hash;
   bool has_ack;
   bool has_stop_waiting;
+  TransmissionType transmission_type;
   QuicPathId original_path_id;
   QuicPacketNumber original_packet_number;
-  TransmissionType transmission_type;
 
   // Optional notifiers which will be informed when this packet has been ACKed.
   std::list<AckListenerWrapper> listeners;
 };
 
 struct NET_EXPORT_PRIVATE TransmissionInfo {
   // Used by STL when assigning into a map.
   TransmissionInfo();
 
   // Constructs a Transmission with a new all_transmissions set
@@ skipping 19 matching lines @@
   TransmissionType transmission_type;
   // In flight packets have not been abandoned or lost.
   bool in_flight;
   // True if the packet can never be acked, so it can be removed.  Occurs when
   // a packet is never sent, after it is acknowledged once, or if it's a crypto
   // packet we never expect to receive an ack for.
   bool is_unackable;
   // True if the packet contains stream data from the crypto stream.
   bool has_crypto_handshake;
   // Non-zero if the packet needs padding if it's retransmitted.
-  int num_padding_bytes;
+  int16_t num_padding_bytes;
   // Stores the packet number of the next retransmission of this packet.
   // Zero if the packet has not been retransmitted.
   QuicPacketNumber retransmission;
   // Non-empty if there is a listener for this packet.
   std::list<AckListenerWrapper> ack_listeners;
 };
 
 // Struct to store the pending retransmission information.
 struct PendingRetransmission {
   PendingRetransmission(QuicPathId path_id,
@@ skipping 30 matching lines @@
       : iov(iov), iov_count(iov_count), total_length(total_length) {}
 
   const struct iovec* iov;
   const int iov_count;
   const size_t total_length;
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_PROTOCOL_H_