Remove use of absolute offsets

This completely removes the need for
TransmitBuilder::datagram_start_offset and ::datagram_max_offset, now
that everything can work with the buffer returned by
TransmitBuilder::datagram_mut().  It also removes a now unused field
in the packet builder since it no longer needs to keep track of the
start offset of the datagram: it is always 0 now.

Author: flub

quinn-proto/src/connection/mod.rs

@@ -647,8 +647,7 @@ impl Connection {
                                 - builder.partial_encode.start
                                 + builder.tag_len;
                         if packet_len_unpadded + MAX_PADDING < transmit.segment_size()
-                            || transmit.datagram_start_offset() + transmit.segment_size()
-                                > transmit.datagram_max_offset()
+                            || transmit.datagram_mut().capacity() < transmit.segment_size()
                         {
                             trace!(
                                 "GSO truncated by demand for {} padding bytes or loss probe",
@@ -712,7 +711,7 @@ impl Connection {
                 }
             }
 
-            debug_assert!(transmit.datagram_max_offset() - transmit.len() >= MIN_PACKET_SPACE);
+            debug_assert!(transmit.datagram_mut().remaining_mut() >= MIN_PACKET_SPACE);
 
             //
             // From here on, we've determined that a packet will definitely be sent.
@@ -867,8 +866,7 @@ impl Connection {
                 !(sent.is_ack_only(&self.streams)
                     && !can_send.acks
                     && can_send.other
-                    && (transmit.datagram_max_offset() - builder.datagram_start)
-                        == self.path.current_mtu() as usize
+                    && transmit.datagram_mut().capacity() == self.path.current_mtu() as usize
                     && self.datagrams.outgoing.is_empty()),
                 "SendableFrames was {can_send:?}, but only ACKs have been written"
             );
@@ -911,7 +909,7 @@ impl Connection {
             debug_assert_eq!(transmit.num_datagrams(), 0);
             transmit.start_new_datagram_with_size(probe_size as usize);
 
-            debug_assert_eq!(transmit.datagram_start_offset(), 0);
+            debug_assert!(transmit.datagram().is_empty());
             let mut builder = PacketBuilder::new(
                 now,
                 space_id,
@@ -1003,7 +1001,7 @@ impl Connection {
         // sent once, immediately after migration, when the CID is known to be valid. Even
         // if a post-migration packet caused the CID to be retired, it's fair to pretend
         // this is sent first.
-        debug_assert_eq!(buf.datagram_start_offset(), 0);
+        debug_assert!(buf.datagram().is_empty());
         let mut builder = PacketBuilder::new(now, SpaceId::Data, *prev_cid, buf, false, self)?;
         trace!("validating previous path with PATH_CHALLENGE {:08x}", token);
         buf.datagram_mut().write(frame::FrameType::PATH_CHALLENGE);

quinn-proto/src/connection/packet_builder.rs

@@ -11,7 +11,6 @@ use crate::{
 };
 
 pub(super) struct PacketBuilder {
-    pub(super) datagram_start: usize,
     pub(super) space: SpaceId,
     pub(super) partial_encode: PartialEncode,
     pub(super) ack_eliciting: bool,
@@ -154,7 +153,6 @@ impl PacketBuilder {
         debug_assert!(max_size >= min_size);
 
         Some(Self {
-            datagram_start: buffer.datagram_start_offset(),
             space: space_id,
             partial_encode,
             exact_number,

quinn-proto/src/connection/transmit_builder.rs

@@ -185,27 +185,12 @@ impl<'a> TransmitBuilder<'a> {
         self.max_datagrams
     }
 
-    /// Returns the start offset of the current datagram in the buffer
-    ///
-    /// In other words, this offset contains the first byte of the current datagram.
-    pub(super) fn datagram_start_offset(&self) -> usize {
-        self.datagram_start
-    }
-
-    /// Returns the maximum offset in the buffer allowed for the current datagram
-    ///
-    /// The first and last datagram in a batch are allowed to be smaller then the maximum
-    /// size. All datagrams in between need to be exactly this size.
-    pub(super) fn datagram_max_offset(&self) -> usize {
-        self.buf_capacity
-    }
-
-    /// Returns `true` if the buffer did not have anything written into it
+    /// Returns `true` if there are no datagrams in this transmit
     pub(super) fn is_empty(&self) -> bool {
         self.len() == 0
     }
 
-    /// The number of bytes written into the buffer so far
+    /// Returns the sum of the bytes for all datagrams in the builder
     pub(super) fn len(&self) -> usize {
         self.buf.len()
     }