Improve comments

Author: flub

quinn-proto/src/connection/mod.rs

@@ -547,15 +547,25 @@ impl Connection {
                 && self.peer_supports_ack_frequency();
         }
 
+        // Whether this packet can be coalesced with another one in the same datagram.
         let mut coalesce = true;
+
+        // Whether the last packet in the datagram must be padded to at least
+        // MIN_INITIAL_SIZE.
         let mut pad_datagram = false;
+
+        // Whether congestion control stopped the next packet from being sent. Further
+        // packets could still be built, as e.g. tail-loss probes are not congestion
+        // limited.
         let mut congestion_blocked = false;
+
+        // The packet number of the last built packet.
         let mut last_packet_number = None;
 
         // Iterate over all spaces and find data to send
         //
-        // Each loop builds one packet.  When packets are coalesced a datagram is filled
-        // over multiple loops.
+        // Each loop builds one packet, which is finished before the next iteration of the
+        // loop.  When packets are coalesced a datagram is filled over multiple loops.
         let mut next_space_id = self.next_send_space(SpaceId::Initial, path_id, &buf, close);
         while let Some(space_id) = next_space_id {
             // Whether the next packet will contain ack-eliciting frames.
@@ -867,9 +877,7 @@ impl Connection {
                         // are the only packets for which we might grow `buf_capacity`
                         // by less than `segment_size`.
                         const MAX_PADDING: usize = 16;
-                        let packet_len_unpadded = cmp::max(builder.min_size, builder.buf.len())
-                            - builder.buf.datagram_start_offset()
-                            + builder.tag_len;
+                        let packet_len_unpadded = builder.predict_packet_size();
                         if packet_len_unpadded + MAX_PADDING < builder.buf.segment_size()
                             || builder.buf.datagram_start_offset() + builder.buf.segment_size()
                                 > builder.buf.datagram_max_offset()

quinn-proto/src/connection/packet_builder.rs

@@ -29,10 +29,6 @@ pub(super) struct PacketBuilder<'a, 'b> {
     /// Smallest absolute position in the associated buffer that must be occupied by this packet's
     /// frames
     pub(super) min_size: usize,
-    /// Largest absolute position in the buffer that may be occupied by this packet's frames
-    ///
-    /// This takes the size of the cryptographic tag into account.
-    pub(super) max_size: usize,
     pub(super) tag_len: usize,
     pub(super) _span: tracing::span::EnteredSpan,
 }
@@ -173,7 +169,6 @@ impl<'a, 'b> PacketBuilder<'a, 'b> {
             exact_number,
             short_header: header.is_short(),
             min_size,
-            max_size,
             tag_len,
             ack_eliciting,
             _span: span,
@@ -253,7 +248,7 @@ impl<'a, 'b> PacketBuilder<'a, 'b> {
     /// Encrypt packet, returning the length of the packet and whether padding was added
     pub(super) fn finish(self, conn: &mut Connection) -> (usize, bool) {
         debug_assert!(
-            self.buf.len() <= self.max_size,
+            self.buf.len() <= self.buf.datagram_max_offset() - self.tag_len,
             "packet exceeds maximum size"
         );
         let pad = self.buf.len() < self.min_size;
@@ -304,7 +299,7 @@ impl<'a, 'b> PacketBuilder<'a, 'b> {
     /// This leaves space in the datagram for the cryptographic tag that needs to be written
     /// when the packet is finished.
     pub(super) fn frame_space_remaining(&self) -> usize {
-        debug_assert!(self.max_size >= self.buf.len(), "packet exceeds bounds");
-        self.max_size.saturating_sub(self.buf.len())
+        let max_offset = self.buf.datagram_max_offset() - self.tag_len;
+        max_offset.saturating_sub(self.buf.len())
     }
 }