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 42 matching lines @@
 // Default and initial maximum size in bytes of a QUIC packet.
 const QuicByteCount kDefaultMaxPacketSize = 1200;
 // 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, UPD 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;
 
 // Maximum size of the initial congestion window in packets.
 const size_t kDefaultInitialWindow = 10;
-// TODO(ianswett): Temporarily changed to 10 due to a large number of clients
-// mistakenly negotiating 100 initially and suffering the consequences.
-const size_t kMaxInitialWindow = 10;
+const size_t kMaxInitialWindow = 100;
 
 // Maximum size of the congestion window, in packets, for TCP congestion control
 // algorithms.
 const size_t kMaxTcpCongestionWindow = 200;
 
 // Don't allow a client to suggest an RTT longer than 15 seconds.
 const size_t kMaxInitialRoundTripTimeUs = 15 * kNumMicrosPerSecond;
 
 // Maximum number of open streams per connection.
 const size_t kDefaultMaxStreamsPerConnection = 100;
@@ skipping 74 matching lines @@
 
 enum QuicFrameType {
   // Regular frame types. The values set here cannot change without the
   // introduction of a new QUIC version.
   PADDING_FRAME = 0,
   RST_STREAM_FRAME = 1,
   CONNECTION_CLOSE_FRAME = 2,
   GOAWAY_FRAME = 3,
   WINDOW_UPDATE_FRAME = 4,
   BLOCKED_FRAME = 5,
+  STOP_WAITING_FRAME = 6,
 
   // STREAM, ACK, and CONGESTION_FEEDBACK frames are special frames. They are
   // encoded differently on the wire and their values do not need to be stable.
   STREAM_FRAME,
   ACK_FRAME,
   CONGESTION_FEEDBACK_FRAME,
   NUM_FRAME_TYPES
 };
 
 enum QuicGuidLength {
@@ skipping 80 matching lines @@
 // 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_12 = 12,
   QUIC_VERSION_13 = 13,
   QUIC_VERSION_14 = 14,
-  QUIC_VERSION_15 = 15,  // Current version.
+  QUIC_VERSION_15 = 15,
+  QUIC_VERSION_16 = 16,  // Current version.
 };
 
 // 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 addding to this list, follow the instructions at
 // http://sites/quic/adding-and-removing-versions
-static const QuicVersion kSupportedQuicVersions[] = {QUIC_VERSION_15,
+static const QuicVersion kSupportedQuicVersions[] = {QUIC_VERSION_16,
+                                                     QUIC_VERSION_15,
                                                      QUIC_VERSION_14,
                                                      QUIC_VERSION_13,
                                                      QUIC_VERSION_12};
 
 typedef std::vector<QuicVersion> QuicVersionVector;
 
 // Returns a vector of QUIC versions in kSupportedQuicVersions.
 NET_EXPORT_PRIVATE QuicVersionVector QuicSupportedVersions();
 
 // QuicTag is written to and read from the wire, but we prefer to use
@@ skipping 90 matching lines @@
   // RST_STREAM frame data is malformed.
   QUIC_INVALID_RST_STREAM_DATA = 6,
   // CONNECTION_CLOSE frame data is malformed.
   QUIC_INVALID_CONNECTION_CLOSE_DATA = 7,
   // GOAWAY frame data is malformed.
   QUIC_INVALID_GOAWAY_DATA = 8,
   // WINDOW_UPDATE frame data is malformed.
   QUIC_INVALID_WINDOW_UPDATE_DATA = 57,
   // BLOCKED frame data is malformed.
   QUIC_INVALID_BLOCKED_DATA = 58,
+  // STOP_WAITING frame data is malformed.
+  QUIC_INVALID_STOP_WAITING_DATA = 60,
   // ACK frame data is malformed.
   QUIC_INVALID_ACK_DATA = 9,
   // CONGESTION_FEEDBACK frame data is malformed.
   QUIC_INVALID_CONGESTION_FEEDBACK_DATA = 47,
   // Version negotiation packet is malformed.
   QUIC_INVALID_VERSION_NEGOTIATION_PACKET = 10,
   // Public RST packet is malformed.
   QUIC_INVALID_PUBLIC_RST_PACKET = 11,
   // There was an error decrypting.
   QUIC_DECRYPTION_FAILURE = 12,
@@ skipping 85 matching lines @@
   // We failed to setup the symmetric keys for a connection.
   QUIC_CRYPTO_SYMMETRIC_KEY_SETUP_FAILED = 53,
   // A handshake message arrived, but we are still validating the
   // previous handshake message.
   QUIC_CRYPTO_MESSAGE_WHILE_VALIDATING_CLIENT_HELLO = 54,
   // 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 = 60,
+  QUIC_LAST_ERROR = 61,
 };
 
 struct NET_EXPORT_PRIVATE QuicPacketPublicHeader {
   QuicPacketPublicHeader();
   explicit QuicPacketPublicHeader(const QuicPacketPublicHeader& other);
   ~QuicPacketPublicHeader();
 
   // Universal header. All QuicPacket headers will have a guid and public flags.
   QuicGuid guid;
   QuicGuidLength guid_length;
@@ skipping 125 matching lines @@
 bool NET_EXPORT_PRIVATE IsAwaitingPacket(
     const ReceivedPacketInfo& received_info,
     QuicPacketSequenceNumber sequence_number);
 
 // Inserts missing packets between [lower, higher).
 void NET_EXPORT_PRIVATE InsertMissingPacketsBetween(
     ReceivedPacketInfo* received_info,
     QuicPacketSequenceNumber lower,
     QuicPacketSequenceNumber higher);
 
-struct NET_EXPORT_PRIVATE SentPacketInfo {
-  SentPacketInfo();
-  ~SentPacketInfo();
+struct NET_EXPORT_PRIVATE QuicStopWaitingFrame {
+  QuicStopWaitingFrame();
+  ~QuicStopWaitingFrame();
 
   NET_EXPORT_PRIVATE friend std::ostream& operator<<(
-      std::ostream& os, const SentPacketInfo& s);
+      std::ostream& os, const QuicStopWaitingFrame& s);
+
   // Entropy hash of all packets up to, but not including, the least unacked
   // packet.
   QuicPacketEntropyHash entropy_hash;
   // The lowest packet we've sent which is unacked, and we expect an ack for.
   QuicPacketSequenceNumber least_unacked;
 };
 
 struct NET_EXPORT_PRIVATE QuicAckFrame {
   QuicAckFrame();
   // Testing convenience method to construct a QuicAckFrame with all packets
   // from least_unacked to largest_observed acked.
   QuicAckFrame(QuicPacketSequenceNumber largest_observed,
                QuicTime largest_observed_receive_time,
                QuicPacketSequenceNumber least_unacked);
 
   NET_EXPORT_PRIVATE friend std::ostream& operator<<(
       std::ostream& os, const QuicAckFrame& s);
 
-  SentPacketInfo sent_info;
+  QuicStopWaitingFrame sent_info;
   ReceivedPacketInfo received_info;
 };
 
 // Defines for all types of congestion feedback that will be negotiated in QUIC,
 // kTCP MUST be supported by all QUIC implementations to guarantee 100%
 // compatibility.
 enum CongestionFeedbackType {
   kTCP,  // Used to mimic TCP.
   kInterArrival,  // Use additional inter arrival information.
   kFixRate,  // Provided for testing.
@@ skipping 128 matching lines @@
 };
 
 struct NET_EXPORT_PRIVATE QuicFrame {
   QuicFrame();
   explicit QuicFrame(QuicPaddingFrame* padding_frame);
   explicit QuicFrame(QuicStreamFrame* stream_frame);
   explicit QuicFrame(QuicAckFrame* frame);
   explicit QuicFrame(QuicCongestionFeedbackFrame* frame);
   explicit QuicFrame(QuicRstStreamFrame* frame);
   explicit QuicFrame(QuicConnectionCloseFrame* frame);
+  explicit QuicFrame(QuicStopWaitingFrame* frame);
   explicit QuicFrame(QuicGoAwayFrame* frame);
   explicit QuicFrame(QuicWindowUpdateFrame* frame);
   explicit QuicFrame(QuicBlockedFrame* frame);
 
   NET_EXPORT_PRIVATE friend std::ostream& operator<<(
       std::ostream& os, const QuicFrame& frame);
 
   QuicFrameType type;
   union {
     QuicPaddingFrame* padding_frame;
     QuicStreamFrame* stream_frame;
     QuicAckFrame* ack_frame;
     QuicCongestionFeedbackFrame* congestion_feedback_frame;
+    QuicStopWaitingFrame* stop_waiting_frame;
     QuicRstStreamFrame* rst_stream_frame;
     QuicConnectionCloseFrame* connection_close_frame;
     QuicGoAwayFrame* goaway_frame;
     QuicWindowUpdateFrame* window_update_frame;
     QuicBlockedFrame* blocked_frame;
   };
 };
 
 typedef std::vector<QuicFrame> QuicFrames;
 
@@ skipping 177 matching lines @@
   WriteStatus status;
   union {
     int bytes_written;  // only valid when status is OK
     int error_code;  // only valid when status is ERROR
   };
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_PROTOCOL_H_