deprecate FLAGS_quic_disable_pre_34

net/quic/core/quic_framer.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_FRAMER_H_
 #define NET_QUIC_QUIC_FRAMER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 28 matching lines @@
 // Number of bytes reserved to denote the length of error details field.
 const size_t kQuicErrorDetailsLengthSize = 2;
 
 // Maximum number of bytes reserved for stream id.
 const size_t kQuicMaxStreamIdSize = 4;
 // Maximum number of bytes reserved for byte offset in stream frame.
 const size_t kQuicMaxStreamOffsetSize = 8;
 // Number of bytes reserved to store payload length in stream frame.
 const size_t kQuicStreamPayloadLengthSize = 2;
 
-// Size in bytes of the entropy hash sent in ack frames.
-const size_t kQuicEntropyHashSize = 1;
 // Size in bytes reserved for the delta time of the largest observed
 // packet number in ack frames.
 const size_t kQuicDeltaTimeLargestObservedSize = 2;
 // Size in bytes reserved for the number of received packets with timestamps.
 const size_t kQuicNumTimestampsSize = 1;
 // Size in bytes reserved for the number of missing packets in ack frames.
 const size_t kNumberOfNackRangesSize = 1;
 // Size in bytes reserved for the number of ack blocks in ack frames.
 const size_t kNumberOfAckBlocksSize = 1;
 // Maximum number of missing packet ranges that can fit within an ack frame.
@@ skipping 80 matching lines @@
   // Called when a BlockedFrame has been parsed.
   virtual bool OnBlockedFrame(const QuicBlockedFrame& frame) = 0;
 
   // Called when a PathCloseFrame has been parsed.
   virtual bool OnPathCloseFrame(const QuicPathCloseFrame& frame) = 0;
 
   // Called when a packet has been completely processed.
   virtual void OnPacketComplete() = 0;
 };
 
-// This class calculates the received entropy of the ack packet being
-// framed, should it get truncated.
-class NET_EXPORT_PRIVATE QuicReceivedEntropyHashCalculatorInterface {
- public:
-  virtual ~QuicReceivedEntropyHashCalculatorInterface() {}
-
-  // When an ack frame gets truncated while being framed the received
-  // entropy of the ack frame needs to be calculated since the some of the
-  // missing packets are not added and the largest observed might be lowered.
-  // This should return the received entropy hash of the packets received up to
-  // and including |packet_number|.
-  virtual QuicPacketEntropyHash EntropyHash(
-      QuicPacketNumber packet_number) const = 0;
-};
-
 // Class for parsing and constructing QUIC packets.  It has a
 // QuicFramerVisitorInterface that is called when packets are parsed.
 class NET_EXPORT_PRIVATE QuicFramer {
  public:
   // Constructs a new framer that installs a kNULL QuicEncrypter and
   // QuicDecrypter for level ENCRYPTION_NONE. |supported_versions| specifies the
   // list of supported QUIC versions. |quic_version_| is set to the maximum
   // version in |supported_versions|.
   QuicFramer(const QuicVersionVector& supported_versions,
              QuicTime creation_time,
@@ skipping 17 matching lines @@
   QuicVersion version() const { return quic_version_; }
 
   void set_version(const QuicVersion version);
 
   // Does not DCHECK for supported version. Used by tests to set unsupported
   // version to trigger version negotiation.
   void set_version_for_tests(const QuicVersion version) {
     quic_version_ = version;
   }
 
-  // Set entropy calculator to be called from the framer when it needs the
-  // entropy of a truncated ack frame. An entropy calculator must be set or else
-  // the framer will likely crash. If this is called multiple times, only the
-  // last calculator will be used.
-  void set_received_entropy_calculator(
-      QuicReceivedEntropyHashCalculatorInterface* entropy_calculator) {
-    entropy_calculator_ = entropy_calculator;
-  }
-
   QuicErrorCode error() const { return error_; }
 
   // Pass a UDP packet into the framer for parsing.
   // Return true if the packet was processed succesfully. |packet| must be a
   // single, complete UDP packet (not a frame of a packet).  This packet
   // might be null padded past the end of the payload, which will be correctly
   // ignored.
   bool ProcessPacket(const QuicEncryptedPacket& packet);
 
   // Largest size in bytes of all stream frame fields without the payload.
@@ skipping 134 matching lines @@
 
   void SetSupportedVersions(const QuicVersionVector& versions) {
     supported_versions_ = versions;
     quic_version_ = versions[0];
   }
 
   void set_validate_flags(bool value) { validate_flags_ = value; }
 
   Perspective perspective() const { return perspective_; }
 
-  static QuicPacketEntropyHash GetPacketEntropyHash(
-      const QuicPacketHeader& header);
-
   // Called when a PATH_CLOSED frame has been sent/received on |path_id|.
   void OnPathClosed(QuicPathId path_id);
 
   QuicTag last_version_tag() { return last_version_tag_; }
 
  private:
   friend class test::QuicFramerPeer;
 
   typedef std::map<QuicPacketNumber, uint8_t> NackRangeMap;
 
-  struct AckFrameInfo {
-    AckFrameInfo();
-    AckFrameInfo(const AckFrameInfo& other);
-    ~AckFrameInfo();
-
-    // The maximum delta between ranges.
-    QuicPacketNumber max_delta;
-    // Nack ranges starting with start packet numbers and lengths.
-    NackRangeMap nack_ranges;
-  };
-
-  struct AckBlock {
-    AckBlock(uint8_t gap, QuicPacketNumber length);
-    AckBlock(const AckBlock& other);
-    ~AckBlock();
-
-    // Gap to the next ack block.
-    uint8_t gap;
-    // Length of this ack block.
-    QuicPacketNumber length;
-  };
-
+  // TODO(rch): Rename this to remove "New" from the name here, and elsewhere.
   struct NewAckFrameInfo {
     NewAckFrameInfo();
     NewAckFrameInfo(const NewAckFrameInfo& other);
     ~NewAckFrameInfo();
 
     // The maximum ack block length.
     QuicPacketNumber max_block_length;
     // Length of first ack block.
     QuicPacketNumber first_block_length;
     // Number of ACK blocks needed for the ACK frame.
@@ skipping 13 matching lines @@
                                        QuicPacketPublicHeader* public_header);
 
   bool ProcessPublicHeader(QuicDataReader* reader,
                            QuicPacketPublicHeader* header);
 
   // Processes the unauthenticated portion of the header into |header| from
   // the current QuicDataReader.  Returns true on success, false on failure.
   bool ProcessUnauthenticatedHeader(QuicDataReader* encrypted_reader,
                                     QuicPacketHeader* header);
 
-  // Processes the authenticated portion of the header into |header| from
-  // the current QuicDataReader.  Returns true on success, false on failure.
-  bool ProcessAuthenticatedHeader(QuicDataReader* reader,
-                                  QuicPacketHeader* header);
-
   bool ProcessPathId(QuicDataReader* reader, QuicPathId* path_id);
   bool ProcessPacketSequenceNumber(QuicDataReader* reader,
                                    QuicPacketNumberLength packet_number_length,
                                    QuicPacketNumber base_packet_number,
                                    QuicPacketNumber* packet_number);
   bool ProcessFrameData(QuicDataReader* reader, const QuicPacketHeader& header);
   bool ProcessStreamFrame(QuicDataReader* reader,
                           uint8_t frame_type,
                           QuicStreamFrame* frame);
-  bool ProcessAckFrame(QuicDataReader* reader,
-                       uint8_t frame_type,
-                       QuicAckFrame* frame);
   bool ProcessNewAckFrame(QuicDataReader* reader,
                           uint8_t frame_type,
                           QuicAckFrame* frame);
   bool ProcessTimestampsInAckFrame(QuicDataReader* reader, QuicAckFrame* frame);
   bool ProcessStopWaitingFrame(QuicDataReader* reader,
                                const QuicPacketHeader& public_header,
                                QuicStopWaitingFrame* stop_waiting);
   bool ProcessRstStreamFrame(QuicDataReader* reader, QuicRstStreamFrame* frame);
   bool ProcessConnectionCloseFrame(QuicDataReader* reader,
                                    QuicConnectionCloseFrame* frame);
@@ skipping 27 matching lines @@
       QuicPacketNumber base_packet_number,
       QuicPacketNumber packet_number) const;
 
   // Returns the QuicTime::Delta corresponding to the time from when the framer
   // was created.
   const QuicTime::Delta CalculateTimestampFromWire(uint32_t time_delta_us);
 
   // Computes the wire size in bytes of time stamps in |ack|.
   size_t GetAckFrameTimeStampSize(const QuicAckFrame& ack);
 
-  // Computes the wire size in bytes of the |ack| frame, assuming no truncation.
+  // Computes the wire size in bytes of the |ack| frame.
   size_t GetAckFrameSize(const QuicAckFrame& ack,
                          QuicPacketNumberLength packet_number_length);
 
   // Computes the wire size in bytes of the |ack| frame.
   size_t GetNewAckFrameSize(const QuicAckFrame& ack);
 
   // Computes the wire size in bytes of the payload of |frame|.
   size_t ComputeFrameLength(const QuicFrame& frame,
                             bool last_frame_in_packet,
                             QuicPacketNumberLength packet_number_length);
 
   static bool AppendPacketSequenceNumber(
       QuicPacketNumberLength packet_number_length,
       QuicPacketNumber packet_number,
       QuicDataWriter* writer);
 
   // Appends a single ACK block to |writer| and returns true if the block was
   // successfully appended.
   static bool AppendAckBlock(uint8_t gap,
                              QuicPacketNumberLength length_length,
                              QuicPacketNumber length,
                              QuicDataWriter* writer);
 
   static uint8_t GetSequenceNumberFlags(
       QuicPacketNumberLength packet_number_length);
 
-  static AckFrameInfo GetAckFrameInfo(const QuicAckFrame& frame);
-
   static NewAckFrameInfo GetNewAckFrameInfo(const QuicAckFrame& frame);
 
   // The Append* methods attempt to write the provided header or frame using the
   // |writer|, and return true if successful.
 
-  bool AppendAckFrameAndTypeByte(const QuicPacketHeader& header,
-                                 const QuicAckFrame& frame,
-                                 QuicDataWriter* builder);
   bool AppendNewAckFrameAndTypeByte(const QuicAckFrame& frame,
                                     QuicDataWriter* builder);
   bool AppendTimestampToAckFrame(const QuicAckFrame& frame,
                                  QuicDataWriter* builder);
   bool AppendStopWaitingFrame(const QuicPacketHeader& header,
                               const QuicStopWaitingFrame& frame,
                               QuicDataWriter* builder);
   bool AppendRstStreamFrame(const QuicRstStreamFrame& frame,
                             QuicDataWriter* builder);
   bool AppendConnectionCloseFrame(const QuicConnectionCloseFrame& frame,
                                   QuicDataWriter* builder);
   bool AppendGoAwayFrame(const QuicGoAwayFrame& frame, QuicDataWriter* writer);
   bool AppendWindowUpdateFrame(const QuicWindowUpdateFrame& frame,
                                QuicDataWriter* writer);
   bool AppendBlockedFrame(const QuicBlockedFrame& frame,
                           QuicDataWriter* writer);
   bool AppendPathCloseFrame(const QuicPathCloseFrame& frame,
                             QuicDataWriter* writer);
 
   bool RaiseError(QuicErrorCode error);
 
   void set_error(QuicErrorCode error) { error_ = error; }
 
   void set_detailed_error(const char* error) { detailed_error_ = error; }
 
   std::string detailed_error_;
   QuicFramerVisitorInterface* visitor_;
-  QuicReceivedEntropyHashCalculatorInterface* entropy_calculator_;
   QuicErrorCode error_;
   // Set of closed paths. A path is considered as closed if a PATH_CLOSED frame
   // has been sent/received.
   // TODO(fayang): this set is never cleaned up. A possible improvement is to
   // use intervals.
   std::unordered_set<QuicPathId> closed_paths_;
   // Updated by ProcessPacketHeader when it succeeds.
   QuicPacketNumber last_packet_number_;
   // Map mapping path id to packet number of largest successfully decrypted
   // received packet.
@@ skipping 40 matching lines @@
   QuicTime::Delta last_timestamp_;
   // The diversification nonce from the last received packet.
   DiversificationNonce last_nonce_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicFramer);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_FRAMER_H_