Landing 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 <list>
@@ skipping 90 matching lines @@
 
 // Reserved ID for the crypto stream.
 const QuicStreamId kCryptoStreamId = 1;
 
 // Reserved ID for the headers stream.
 const QuicStreamId kHeadersStreamId = 3;
 
 // Maximum delayed ack time, in ms.
 const int kMaxDelayedAckTimeMs = 25;
 
-// This is the default network timeout a for connection till the crypto
-// handshake succeeds and the negotiated timeout from the handshake is received.
+// The default idle timeout before the crypto handshake succeeds.
 const int64 kDefaultInitialTimeoutSecs = 120;  // 2 mins.
-const int64 kDefaultTimeoutSecs = 60 * 10;  // 10 minutes.
-const int64 kDefaultMaxTimeForCryptoHandshakeSecs = 5;  // 5 secs.
+// The maximum idle timeout that can be negotiated.
+const int64 kMaximumIdleTimeoutSecs = 60 * 10;  // 10 minutes.
+// The default timeout for a connection until the crypto handshake succeeds.
+const int64 kDefaultMaxTimeForCryptoHandshakeSecs = 10;  // 10 secs.
 
 // Default ping timeout.
 const int64 kPingTimeoutSecs = 15;  // 15 secs.
 
 // Minimum number of RTTs between Server Config Updates (SCUP) sent to client.
 const int kMinIntervalBetweenServerConfigUpdatesRTTs = 10;
 
 // Minimum time between Server Config Updates (SCUP) sent to client.
 const int kMinIntervalBetweenServerConfigUpdatesMs = 1000;
 
+// Multiplier that allows server to accept slightly more streams than
+// negotiated in handshake.
+const float kMaxStreamsMultiplier = 1.1f;
+
 // We define an unsigned 16-bit floating point value, inspired by IEEE floats
 // (http://en.wikipedia.org/wiki/Half_precision_floating-point_format),
 // with 5-bit exponent (bias 1), 11-bit mantissa (effective 12 with hidden
 // bit) and denormals, but without signs, transfinites or fractions. Wire format
 // 16 bits (little-endian byte order) are split into exponent (high 5) and
 // mantissa (low 11) and decoded as:
 //   uint64 value;
 //   if (exponent == 0) value = mantissa;
 //   else value = (mantissa | 1 << 11) << (exponent - 1)
 const int kUFloat16ExponentBits = 5;
 const int kUFloat16MaxExponent = (1 << kUFloat16ExponentBits) - 2;  // 30
 const int kUFloat16MantissaBits = 16 - kUFloat16ExponentBits;  // 11
 const int kUFloat16MantissaEffectiveBits = kUFloat16MantissaBits + 1;  // 12
 const uint64 kUFloat16MaxValue =  // 0x3FFC0000000
     ((GG_UINT64_C(1) << kUFloat16MantissaEffectiveBits) - 1) <<
     kUFloat16MaxExponent;
 
 enum TransmissionType {
   NOT_RETRANSMISSION,
   FIRST_TRANSMISSION_TYPE = NOT_RETRANSMISSION,
   HANDSHAKE_RETRANSMISSION,  // Retransmits due to handshake timeouts.
-  ALL_UNACKED_RETRANSMISSION,  // Retransmits of all unacked packets.
+  ALL_UNACKED_RETRANSMISSION,  // Retransmits all unacked packets.
+  ALL_INITIAL_RETRANSMISSION,  // Retransmits all initially encrypted packets.
   LOSS_RETRANSMISSION,  // Retransmits due to loss detection.
   RTO_RETRANSMISSION,  // Retransmits due to retransmit time out.
   TLP_RETRANSMISSION,  // Tail loss probes.
   LAST_TRANSMISSION_TYPE = TLP_RETRANSMISSION,
 };
 
-enum RetransmissionType {
-  INITIAL_ENCRYPTION_ONLY,
-  ALL_PACKETS
-};
-
 enum HasRetransmittableData {
   NO_RETRANSMITTABLE_DATA,
   HAS_RETRANSMITTABLE_DATA,
 };
 
 enum IsHandshake {
   NOT_HANDSHAKE,
   IS_HANDSHAKE
 };
 
@@ skipping 296 matching lines @@
   // deprecated: QUIC_STREAM_RST_BEFORE_HEADERS_DECOMPRESSED = 21
 
   // The Header ID for a stream was too far from the previous.
   QUIC_INVALID_HEADER_ID = 22,
   // Negotiable parameter received during handshake had invalid value.
   QUIC_INVALID_NEGOTIATED_VALUE = 23,
   // There was an error decompressing data.
   QUIC_DECOMPRESSION_FAILURE = 24,
   // We hit our prenegotiated (or default) timeout
   QUIC_CONNECTION_TIMED_OUT = 25,
+  // We hit our overall connection timeout
+  QUIC_CONNECTION_OVERALL_TIMED_OUT = 67,
   // There was an error encountered migrating addresses
   QUIC_ERROR_MIGRATING_ADDRESS = 26,
   // There was an error while writing to the socket.
   QUIC_PACKET_WRITE_ERROR = 27,
   // There was an error while reading from the socket.
   QUIC_PACKET_READ_ERROR = 51,
   // We received a STREAM_FRAME with no data and no fin flag set.
   QUIC_INVALID_STREAM_FRAME = 50,
   // We received invalid data on the headers stream.
   QUIC_INVALID_HEADERS_STREAM_DATA = 56,
@@ skipping 55 matching lines @@
   // A handshake message arrived, but we are still validating the
   // previous handshake message.
   QUIC_CRYPTO_MESSAGE_WHILE_VALIDATING_CLIENT_HELLO = 54,
   // A server config update arrived before the handshake is complete.
   QUIC_CRYPTO_UPDATE_BEFORE_HANDSHAKE_COMPLETE = 65,
   // This connection involved a version negotiation which appears to have been
   // tampered with.
   QUIC_VERSION_NEGOTIATION_MISMATCH = 55,
 
   // No error. Used as bound while iterating.
-  QUIC_LAST_ERROR = 67,
+  QUIC_LAST_ERROR = 68,
 };
 
 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 508 matching lines @@
   // Zero when the packet is serialized, non-zero once it's sent.
   QuicByteCount bytes_sent;
   size_t nack_count;
   // Reason why this packet was transmitted.
   TransmissionType transmission_type;
   // Stores the sequence numbers of all transmissions of this packet.
   // Must always be NULL or have multiple elements.
   SequenceNumberList* all_transmissions;
   // 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.
+  bool is_unackable;
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_PROTOCOL_H_