Update from https://crrev.com/312398

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 196 matching lines @@
   // 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,
   PING_FRAME = 7,
 
-  // 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 and ACK 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 QuicConnectionIdLength {
   PACKET_0BYTE_CONNECTION_ID = 0,
   PACKET_1BYTE_CONNECTION_ID = 1,
   PACKET_4BYTE_CONNECTION_ID = 4,
   PACKET_8BYTE_CONNECTION_ID = 8
 };
 
@@ skipping 71 matching lines @@
 // 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_21 = 21,  // Headers/crypto streams are flow controlled.
-  QUIC_VERSION_22 = 22,  // Send Server Config Update messages on crypto stream.
   QUIC_VERSION_23 = 23,  // Timestamp in the ack frame.
+  QUIC_VERSION_24 = 24,  // SPDY/4 header compression.
 };
 
 // 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_23,
-                                                     QUIC_VERSION_22};
+static const QuicVersion kSupportedQuicVersions[] = {QUIC_VERSION_24,
+                                                     QUIC_VERSION_23};
 
 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
 // the more readable QuicVersion at other levels.
 // Helper function which translates from a QuicVersion to a QuicTag. Returns 0
 // if QuicVersion is unsupported.
@@ skipping 107 matching lines @@
   // 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,
+
+  // deprecated: 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,
   // There was an error encrypting.
   QUIC_ENCRYPTION_FAILURE = 13,
   // The packet exceeded kMaxPacketSize.
   QUIC_PACKET_TOO_LARGE = 14,
@@ skipping 269 matching lines @@
 bool NET_EXPORT_PRIVATE IsAwaitingPacket(
     const QuicAckFrame& ack_frame,
     QuicPacketSequenceNumber sequence_number);
 
 // Inserts missing packets between [lower, higher).
 void NET_EXPORT_PRIVATE InsertMissingPacketsBetween(
     QuicAckFrame* ack_frame,
     QuicPacketSequenceNumber lower,
     QuicPacketSequenceNumber higher);
 
-// 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.
-// TODO(cyr): Remove this when removing QUIC_VERSION_22.
-enum CongestionFeedbackType {
-  kTCP,  // Used to mimic TCP.
-};
-
 // Defines for all types of congestion control algorithms that can be used in
 // QUIC. Note that this is separate from the congestion feedback type -
 // some congestion control algorithms may use the same feedback type
 // (Reno and Cubic are the classic example for that).
 enum CongestionControlType {
   kCubic,
   kReno,
   kBBR,
 };
 
 enum LossDetectionType {
   kNack,  // Used to mimic TCP's loss detection.
   kTime,  // Time based loss detection.
 };
 
-// TODO(cyr): Remove this when removing QUIC_VERSION_22.
-struct NET_EXPORT_PRIVATE CongestionFeedbackMessageTCP {
-  CongestionFeedbackMessageTCP();
-
-  QuicByteCount receive_window;
-};
-
-// TODO(cyr): Remove this when removing QUIC_VERSION_22.
-struct NET_EXPORT_PRIVATE QuicCongestionFeedbackFrame {
-  QuicCongestionFeedbackFrame();
-  ~QuicCongestionFeedbackFrame();
-
-  NET_EXPORT_PRIVATE friend std::ostream& operator<<(
-      std::ostream& os, const QuicCongestionFeedbackFrame& c);
-
-  CongestionFeedbackType type;
-  // This should really be a union, but since the timestamp struct
-  // is non-trivial, C++ prohibits it.
-  CongestionFeedbackMessageTCP tcp;
-};
-
 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, const QuicRstStreamFrame& r);
 
   QuicStreamId stream_id;
@@ skipping 79 matching lines @@
 
   NUM_ENCRYPTION_LEVELS,
 };
 
 struct NET_EXPORT_PRIVATE QuicFrame {
   QuicFrame();
   explicit QuicFrame(QuicPaddingFrame* padding_frame);
   explicit QuicFrame(QuicStreamFrame* stream_frame);
   explicit QuicFrame(QuicAckFrame* frame);
 
-  // TODO(cyr): Remove this when removing QUIC_VERSION_22.
-  explicit QuicFrame(QuicCongestionFeedbackFrame* frame);
-
   explicit QuicFrame(QuicRstStreamFrame* frame);
   explicit QuicFrame(QuicConnectionCloseFrame* frame);
   explicit QuicFrame(QuicStopWaitingFrame* frame);
   explicit QuicFrame(QuicPingFrame* 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;
 
-    // TODO(cyr): Remove this when removing QUIC_VERSION_22.
-    QuicCongestionFeedbackFrame* congestion_feedback_frame;
     QuicStopWaitingFrame* stop_waiting_frame;
 
     QuicPingFrame* ping_frame;
     QuicRstStreamFrame* rst_stream_frame;
     QuicConnectionCloseFrame* connection_close_frame;
     QuicGoAwayFrame* goaway_frame;
     QuicWindowUpdateFrame* window_update_frame;
     QuicBlockedFrame* blocked_frame;
   };
 };
@@ skipping 178 matching lines @@
   bool in_flight;
   // True if the packet can never be acked, so it can be removed.
   bool is_unackable;
   // True if the packet is an FEC packet.
   bool is_fec_packet;
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_PROTOCOL_H_