proto: Internally use SendStream::new

Makes it so that SendStream is always constructed with SendStream::new.
This is in preparation for subsequent commit which will make constructor
non-trivial.

Previously, `new` was `#[cfg(fuzzing)] pub`. Now, the `#[cfg(fuzzing)]`
is removed and `pub` is changed to `pub(super)`. Fuzz code is modified
to call a new `#[cfg(fuzzing)] pub fn new_for_fuzzing` delegate method.

Author: gretchenfrage

fuzz/fuzz_targets/streams.rs

@@ -50,15 +50,16 @@ fuzz_target!(|input: (StreamParams, Vec<Operation>)| {
                 Streams::new(&mut state, &conn_state).accept(dir);
             }
             Operation::Finish(id) => {
-                let _ = SendStream::new(id, &mut state, &mut pending, &conn_state).finish();
+                let _ =
+                    SendStream::new_for_fuzzing(id, &mut state, &mut pending, &conn_state).finish();
             }
             Operation::ReceivedStopSending(sid, err_code) => {
                 Streams::new(&mut state, &conn_state)
                     .state()
                     .received_stop_sending(sid, err_code);
             }
             Operation::ReceivedReset(rs) => {
-                let _ = Streams::new(&mut state, &conn_state)
+                let _ = Streams::new_for_fuzzing(&mut state, &conn_state)
                     .state()
                     .received_reset(rs);
             }

quinn-proto/src/connection/mod.rs

@@ -426,12 +426,12 @@ impl Connection {
     #[must_use]
     pub fn send_stream(&mut self, id: StreamId) -> SendStream<'_> {
         assert!(id.dir() == Dir::Bi || id.initiator() == self.side.side());
-        SendStream {
+        SendStream::new(
             id,
-            state: &mut self.streams,
-            pending: &mut self.spaces[SpaceId::Data].pending,
-            conn_state: &self.state,
-        }
+            &mut self.streams,
+            &mut self.spaces[SpaceId::Data].pending,
+            &self.state,
+        )
     }
 
     /// Returns packets to transmit

quinn-proto/src/connection/streams/mod.rs

@@ -203,7 +203,16 @@ pub struct SendStream<'a> {
 #[allow(clippy::needless_lifetimes)] // Needed for cfg(fuzzing)
 impl<'a> SendStream<'a> {
     #[cfg(fuzzing)]
-    pub fn new(
+    pub fn new_for_fuzzing(
+        id: StreamId,
+        state: &'a mut StreamsState,
+        pending: &'a mut Retransmits,
+        conn_state: &'a super::State,
+    ) -> Self {
+        Self::new(id, state, pending, conn_state)
+    }
+
+    pub(super) fn new(
         id: StreamId,
         state: &'a mut StreamsState,
         pending: &'a mut Retransmits,

quinn-proto/src/connection/streams/state.rs

@@ -1290,12 +1290,7 @@ mod tests {
         .open(Dir::Uni)
         .unwrap();
 
-        let mut stream = SendStream {
-            id,
-            state: &mut server,
-            pending: &mut pending,
-            conn_state: &state,
-        };
+        let mut stream = SendStream::new(id, &mut server, &mut pending, &state);
 
         let error_code = 0u32.into();
         stream.state.received_stop_sending(id, error_code);
@@ -1353,29 +1348,14 @@ mod tests {
         let id_mid = streams.open(Dir::Bi).unwrap();
         let id_low = streams.open(Dir::Bi).unwrap();
 
-        let mut mid = SendStream {
-            id: id_mid,
-            state: &mut server,
-            pending: &mut pending,
-            conn_state: &state,
-        };
+        let mut mid = SendStream::new(id_mid, &mut server, &mut pending, &state);
         mid.write(b"mid").unwrap();
 
-        let mut low = SendStream {
-            id: id_low,
-            state: &mut server,
-            pending: &mut pending,
-            conn_state: &state,
-        };
+        let mut low = SendStream::new(id_low, &mut server, &mut pending, &state);
         low.set_priority(-1).unwrap();
         low.write(b"low").unwrap();
 
-        let mut high = SendStream {
-            id: id_high,
-            state: &mut server,
-            pending: &mut pending,
-            conn_state: &state,
-        };
+        let mut high = SendStream::new(id_high, &mut server, &mut pending, &state);
         high.set_priority(1).unwrap();
         high.write(b"high").unwrap();
 
@@ -1408,34 +1388,19 @@ mod tests {
         let id_high = streams.open(Dir::Bi).unwrap();
         let id_mid = streams.open(Dir::Bi).unwrap();
 
-        let mut mid = SendStream {
-            id: id_mid,
-            state: &mut server,
-            pending: &mut pending,
-            conn_state: &state,
-        };
+        let mut mid = SendStream::new(id_mid, &mut server, &mut pending, &state);
         assert_eq!(mid.write(b"mid").unwrap(), 3);
         assert_eq!(server.pending.len(), 1);
 
-        let mut high = SendStream {
-            id: id_high,
-            state: &mut server,
-            pending: &mut pending,
-            conn_state: &state,
-        };
+        let mut high = SendStream::new(id_high, &mut server, &mut pending, &state);
         high.set_priority(1).unwrap();
         assert_eq!(high.write(&[0; 200]).unwrap(), 200);
         assert_eq!(server.pending.len(), 2);
 
         // Requeue the high priority stream to lowest priority. The initial send
         // still uses high priority since it's queued that way. After that it will
         // switch to low priority
-        let mut high = SendStream {
-            id: id_high,
-            state: &mut server,
-            pending: &mut pending,
-            conn_state: &state,
-        };
+        let mut high = SendStream::new(id_high, &mut server, &mut pending, &state);
         high.set_priority(-1).unwrap();
 
         let mut buf = Vec::with_capacity(1000);
@@ -1478,28 +1443,13 @@ mod tests {
             let id_b = streams.open(Dir::Bi).unwrap();
             let id_c = streams.open(Dir::Bi).unwrap();
 
-            let mut stream_a = SendStream {
-                id: id_a,
-                state: &mut server,
-                pending: &mut pending,
-                conn_state: &state,
-            };
+            let mut stream_a = SendStream::new(id_a, &mut server, &mut pending, &state);
             stream_a.write(&[b'a'; 100]).unwrap();
 
-            let mut stream_b = SendStream {
-                id: id_b,
-                state: &mut server,
-                pending: &mut pending,
-                conn_state: &state,
-            };
+            let mut stream_b = SendStream::new(id_b, &mut server, &mut pending, &state);
             stream_b.write(&[b'b'; 100]).unwrap();
 
-            let mut stream_c = SendStream {
-                id: id_c,
-                state: &mut server,
-                pending: &mut pending,
-                conn_state: &state,
-            };
+            let mut stream_c = SendStream::new(id_c, &mut server, &mut pending, &state);
             stream_c.write(&[b'c'; 100]).unwrap();
 
             let mut metas = vec![];
@@ -1558,20 +1508,10 @@ mod tests {
         let id_b = streams.open(Dir::Bi).unwrap();
         let id_c = streams.open(Dir::Bi).unwrap();
 
-        let mut stream_a = SendStream {
-            id: id_a,
-            state: &mut server,
-            pending: &mut pending,
-            conn_state: &state,
-        };
+        let mut stream_a = SendStream::new(id_a, &mut server, &mut pending, &state);
         stream_a.write(&[b'a'; 100]).unwrap();
 
-        let mut stream_b = SendStream {
-            id: id_b,
-            state: &mut server,
-            pending: &mut pending,
-            conn_state: &state,
-        };
+        let mut stream_b = SendStream::new(id_b, &mut server, &mut pending, &state);
         stream_b.write(&[b'b'; 100]).unwrap();
 
         let mut metas = vec![];
@@ -1584,12 +1524,7 @@ mod tests {
         metas.extend(meta);
 
         // Queue stream_c which has higher priority
-        let mut stream_c = SendStream {
-            id: id_c,
-            state: &mut server,
-            pending: &mut pending,
-            conn_state: &state,
-        };
+        let mut stream_c = SendStream::new(id_c, &mut server, &mut pending, &state);
         stream_c.set_priority(1).unwrap();
         stream_c.write(&[b'b'; 100]).unwrap();
 
@@ -1658,12 +1593,7 @@ mod tests {
         };
 
         let id = streams.open(Dir::Uni).unwrap();
-        let mut stream = SendStream {
-            id,
-            state: &mut server,
-            pending: &mut pending,
-            conn_state: &state,
-        };
+        let mut stream = SendStream::new(id, &mut server, &mut pending, &state);
         stream.write(b"hello").unwrap();
         stream.reset(0u32.into()).unwrap();