Landing Recent QUIC changes until 9:41 AM, Oct 10, 2016 UTC-7

net/quic/core/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 38 matching lines @@
 // 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.
 const QuicByteCount kDefaultMaxPacketSize = 1350;
 // Default initial maximum size in bytes of a QUIC packet for servers.
 const QuicByteCount kDefaultServerMaxPacketSize = 1000;
-// Minimum size of a QUIC packet, used if a server receives packets from a
-// client with unusual network headers. 1280 - sizeof(eth) - sizeof(ipv6).
-const QuicByteCount kMinimumSupportedPacketSize = 1214;
 // The maximum packet size of any QUIC packet, based on ethernet's max size,
 // minus the IP and UDP headers. IPv6 has a 40 byte header, UDP adds an
 // additional 8 bytes.  This is a total overhead of 48 bytes.  Ethernet's
 // max packet size is 1500 bytes,  1500 - 48 = 1452.
 const QuicByteCount kMaxPacketSize = 1452;
 // Default maximum packet size used in the Linux TCP implementation.
 // Used in QUIC for congestion window computations in bytes.
 const QuicByteCount kDefaultTCPMSS = 1460;
 
 // We match SPDY's use of 32 (since we'd compete with SPDY).
@@ skipping 266 matching lines @@
   PACKET_PUBLIC_FLAGS_MAX = (1 << 7) - 1,
 };
 
 // The private flags are specified in one byte.
 enum QuicPacketPrivateFlags {
   PACKET_PRIVATE_FLAGS_NONE = 0,
 
   // Bit 0: Does this packet contain an entropy bit?
   PACKET_PRIVATE_FLAGS_ENTROPY = 1 << 0,
 
-  // Bit 1: Payload is part of an FEC group?
-  PACKET_PRIVATE_FLAGS_FEC_GROUP = 1 << 1,
-
-  // Bit 2: Payload is FEC as opposed to frames?
-  PACKET_PRIVATE_FLAGS_FEC = 1 << 2,
-
-  // All bits set (bits 3-7 are not currently used): 00000111
-  PACKET_PRIVATE_FLAGS_MAX = (1 << 3) - 1,
-
-  // For version 32 (bits 1-7 are not used): 00000001
-  PACKET_PRIVATE_FLAGS_MAX_VERSION_32 = (1 << 1) - 1
+  // (bits 1-7 are not used): 00000001
+  PACKET_PRIVATE_FLAGS_MAX = (1 << 1) - 1
 };
 
 // The available versions of QUIC. Guaranteed that the integer value of the enum
 // will match the version number.
 // When adding a new version to this enum you should add it to
 // kSupportedQuicVersions (if appropriate), and also add a new case to the
 // helper methods QuicVersionToQuicTag, QuicTagToQuicVersion, and
 // QuicVersionToString.
 enum QuicVersion {
   // Special case to indicate unknown/unsupported QUIC version.
   QUIC_VERSION_UNSUPPORTED = 0,
 
-  QUIC_VERSION_30 = 30,  // Add server side support of cert transparency.
-  QUIC_VERSION_31 = 31,  // Adds a hash of the client hello to crypto proof.
   QUIC_VERSION_32 = 32,  // FEC related fields are removed from wire format.
   QUIC_VERSION_33 = 33,  // Adds diversification nonces.
   QUIC_VERSION_34 = 34,  // Deprecates entropy, removes private flag from packet
                          // header, uses new ack and stop waiting wire format.
   QUIC_VERSION_35 = 35,  // Allows endpoints to independently set stream limit.
   QUIC_VERSION_36 = 36,  // Add support to force HOL blocking.
 
   // IMPORTANT: if you are adding to this std::list, follow the instructions at
   // http://sites/quic/adding-and-removing-versions
 };
 
 // This vector contains QUIC versions which we currently support.
 // This should be ordered such that the highest supported version is the first
 // element, with subsequent elements in descending order (versions can be
 // skipped as necessary).
 //
 // IMPORTANT: if you are adding to this list, follow the instructions at
 // http://sites/quic/adding-and-removing-versions
 static const QuicVersion kSupportedQuicVersions[] = {
     QUIC_VERSION_36, QUIC_VERSION_35, QUIC_VERSION_34, QUIC_VERSION_33,
-    QUIC_VERSION_32, QUIC_VERSION_31, QUIC_VERSION_30};
+    QUIC_VERSION_32};
 
 typedef std::vector<QuicVersion> QuicVersionVector;
 
 // Returns a vector of QUIC versions in kSupportedQuicVersions.
 NET_EXPORT_PRIVATE QuicVersionVector AllSupportedVersions();
 
 // Returns a vector of QUIC versions from kSupportedQuicVersions which exclude
 // any versions which are disabled by flags.
 NET_EXPORT_PRIVATE QuicVersionVector CurrentSupportedVersions();
 
@@ skipping 363 matching lines @@
   QuicPacketHeader(const QuicPacketHeader& other);
 
   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;
 };
 
 struct NET_EXPORT_PRIVATE QuicPublicResetPacket {
   QuicPublicResetPacket();
   explicit QuicPublicResetPacket(const QuicPacketPublicHeader& header);
 
   QuicPacketPublicHeader public_header;
   QuicPublicResetNonceProof nonce_proof;
+  // TODO(fayang): remove rejected_packet_number when deprecating
+  // FLAGS_quic_remove_packet_number_from_public_reset.
   QuicPacketNumber rejected_packet_number;
   IPEndPoint client_address;
 };
 
 enum QuicVersionNegotiationState {
   START_NEGOTIATION = 0,
   // Server-side this implies we've sent a version negotiation packet and are
   // waiting on the client to select a compatible version.  Client-side this
   // implies we've gotten a version negotiation packet, are retransmitting the
   // initial packets with a supported version and are waiting for our first
@@ skipping 269 matching lines @@
   kCubicBytes,
   kReno,
   kRenoBytes,
   kBBR,
 };
 
 enum LossDetectionType {
   kNack,          // Used to mimic TCP's loss detection.
   kTime,          // Time based loss detection.
   kAdaptiveTime,  // Adaptive time based loss detection.
+  kLazyFack,      // Nack based but with FACK disabled for the first ack.
 };
 
 struct NET_EXPORT_PRIVATE QuicRstStreamFrame {
   QuicRstStreamFrame();
   QuicRstStreamFrame(QuicStreamId stream_id,
                      QuicRstStreamErrorCode error_code,
                      QuicStreamOffset bytes_written);
 
   NET_EXPORT_PRIVATE friend std::ostream& operator<<(
       std::ostream& os,
@@ skipping 239 matching lines @@
  public:
   QuicReceivedPacket(const char* buffer, size_t length, QuicTime receipt_time);
   QuicReceivedPacket(const char* buffer,
                      size_t length,
                      QuicTime receipt_time,
                      bool owns_buffer);
   QuicReceivedPacket(const char* buffer,
                      size_t length,
                      QuicTime receipt_time,
                      bool owns_buffer,
-                     bool potentially_small_mtu,
                      int ttl,
                      bool ttl_valid);
 
   // Clones the packet into a new packet which owns the buffer.
   QuicReceivedPacket* Clone() const;
 
   // Returns the time at which the packet was received.
   QuicTime receipt_time() const { return receipt_time_; }
 
   // This is the TTL of the packet, assuming ttl_vaild_ is true.
   int ttl() const { return ttl_; }
 
-  bool potentially_small_mtu() const { return potentially_small_mtu_; }
-
   // By default, gtest prints the raw bytes of an object. The bool data
   // member (in the base class QuicData) causes this object to have padding
   // bytes, which causes the default gtest object printer to read
   // uninitialize memory. So we need to teach gtest how to print this object.
   NET_EXPORT_PRIVATE friend std::ostream& operator<<(
       std::ostream& os,
       const QuicReceivedPacket& s);
 
  private:
   const QuicTime receipt_time_;
   int ttl_;
-  bool potentially_small_mtu_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicReceivedPacket);
 };
 
 // Pure virtual class to listen for packet acknowledgements.
 class NET_EXPORT_PRIVATE QuicAckListenerInterface
     : public base::RefCounted<QuicAckListenerInterface> {
  public:
   QuicAckListenerInterface() {}
 
@@ skipping 27 matching lines @@
 // Used to generate filtered supported versions based on flags.
 class NET_EXPORT_PRIVATE QuicVersionManager {
  public:
   explicit QuicVersionManager(QuicVersionVector supported_versions);
   ~QuicVersionManager();
 
   // Returns supported versions based on flags.
   const QuicVersionVector& GetSupportedVersions();
 
  private:
-  // FLAGS_quic_disable_pre_32
-  bool disable_pre_32_;
   // FLAGS_quic_disable_pre_34
   bool disable_pre_34_;
   // FLAGS_quic_enable_version_35
   bool enable_version_35_;
   // FLAGS_quic_enable_version_36_v2
   bool enable_version_36_;
   // The list of versions that may be supported.
   QuicVersionVector allowed_supported_versions_;
   // This vector contains QUIC versions which are currently supported based
   // on flags.
@@ skipping 124 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_