deprecate FLAGS_quic_disable_pre_34

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 94 matching lines @@
   QuicPacketHeader();
   explicit QuicPacketHeader(const QuicPacketPublicHeader& header);
   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;
 };
 
 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.
@@ skipping 90 matching lines @@
 
 struct NET_EXPORT_PRIVATE QuicStopWaitingFrame {
   QuicStopWaitingFrame();
   ~QuicStopWaitingFrame();
 
   NET_EXPORT_PRIVATE friend std::ostream& operator<<(
       std::ostream& os,
       const QuicStopWaitingFrame& s);
   // Path which this stop waiting frame belongs to.
   QuicPathId path_id;
-  // 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.
   QuicPacketNumber least_unacked;
 };
 
 // A sequence of packet numbers where each number is unique. Intended to be used
 // in a sliding window fashion, where smaller old packet numbers are removed and
 // larger new packet numbers are added, with the occasional random access.
 class NET_EXPORT_PRIVATE PacketNumberQueue {
  public:
   using const_iterator = IntervalSet<QuicPacketNumber>::const_iterator;
@@ skipping 74 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);
 
   // 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,
                  QuicPacketNumber packet_number,
                  QuicPacketNumber peer_least_packet_awaiting_ack);
 
@@ skipping 288 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_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.
   QuicVersionVector filtered_supported_versions_;
 };
 
 struct NET_EXPORT_PRIVATE AckListenerWrapper {
   AckListenerWrapper(QuicAckListenerInterface* listener,
                      QuicPacketLength data_length);
   AckListenerWrapper(const AckListenerWrapper& other);
   ~AckListenerWrapper();
 
   scoped_refptr<QuicAckListenerInterface> ack_listener;
   QuicPacketLength length;
 };
 
 struct NET_EXPORT_PRIVATE SerializedPacket {
   SerializedPacket(QuicPathId path_id,
                    QuicPacketNumber packet_number,
                    QuicPacketNumberLength packet_number_length,
                    const char* encrypted_buffer,
                    QuicPacketLength encrypted_length,
-                   QuicPacketEntropyHash entropy_hash,
                    bool has_ack,
                    bool has_stop_waiting);
   SerializedPacket(const SerializedPacket& other);
   ~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
   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;
 
   // Optional notifiers which will be informed when this packet has been ACKed.
   std::list<AckListenerWrapper> listeners;
 };
 
@@ skipping 75 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_