Switch to PacketNumberQueue interval iteration and avoid allocations in new ACK frame generation. G…

net/quic/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 393 matching lines @@
     NewAckFrameInfo();
     NewAckFrameInfo(const NewAckFrameInfo& other);
     ~NewAckFrameInfo();
 
     // The maximum ack block length.
     QuicPacketNumber max_block_length;
     // Length of first ack block.
     QuicPacketNumber first_block_length;
     // Ack blocks starting with gaps to next block and ack block lengths.
     std::vector<AckBlock> ack_blocks;
+    // Number of ACK blocks. If |ack_blocks| is generated, must equal
+    // |ack_blocks.size()|.
+    size_t num_ack_blocks;
   };
 
   bool ProcessDataPacket(QuicDataReader* reader,
                          const QuicPacketPublicHeader& public_header,
                          const QuicEncryptedPacket& packet,
                          char* decrypted_buffer,
                          size_t buffer_length);
 
   bool ProcessPublicResetPacket(QuicDataReader* reader,
                                 const QuicPacketPublicHeader& public_header);
@@ skipping 82 matching lines @@
   // 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);
+  static NewAckFrameInfo GetNewAckFrameInfo(const QuicAckFrame& frame,
+                                            bool construct_blocks);
 
   // 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,
@@ skipping 73 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_