Make some functions less-generic to reduce binary bloat (#503)

* refactor: Extract FramedWrite::buffer to a less generic function

Should cut out another 23 KiB (since I see it duplicated)

* refactor: Extract some duplicated code to a function

* refactor: Extract part of flush into a less generic function

* refactor: Extract a less generic part of connection

* refactor: Factor out a less generic part of Connection::poll2

* refactor: Extract a non-generic part of handshake2

* refactor: Don't duplicate Streams code on Peer (-3.5%)

The `P: Peer` parameter is rarely used and there is already a mechanism
for using it dynamically.

* refactor: Make recv_frame less generic (-2.3%)

* Move out part of Connection::poll

* refactor: Extract parts of Connection

* refactor: Extract a non-generic part of reclaim_frame

* comments

src/proto/streams/prioritize.rs

@@ -545,43 +545,57 @@ impl Prioritize {
 
         // First check if there are any data chunks to take back
         if let Some(frame) = dst.take_last_data_frame() {
-            tracing::trace!(
-                ?frame,
-                sz = frame.payload().inner.get_ref().remaining(),
-                "reclaimed"
-            );
+            self.reclaim_frame_inner(buffer, store, frame)
+        } else {
+            false
+        }
+    }
 
-            let mut eos = false;
-            let key = frame.payload().stream;
+    fn reclaim_frame_inner<B>(
+        &mut self,
+        buffer: &mut Buffer<Frame<B>>,
+        store: &mut Store,
+        frame: frame::Data<Prioritized<B>>,
+    ) -> bool
+    where
+        B: Buf,
+    {
+        tracing::trace!(
+            ?frame,
+            sz = frame.payload().inner.get_ref().remaining(),
+            "reclaimed"
+        );
 
-            match mem::replace(&mut self.in_flight_data_frame, InFlightData::Nothing) {
-                InFlightData::Nothing => panic!("wasn't expecting a frame to reclaim"),
-                InFlightData::Drop => {
-                    tracing::trace!("not reclaiming frame for cancelled stream");
-                    return false;
-                }
-                InFlightData::DataFrame(k) => {
-                    debug_assert_eq!(k, key);
-                }
+        let mut eos = false;
+        let key = frame.payload().stream;
+
+        match mem::replace(&mut self.in_flight_data_frame, InFlightData::Nothing) {
+            InFlightData::Nothing => panic!("wasn't expecting a frame to reclaim"),
+            InFlightData::Drop => {
+                tracing::trace!("not reclaiming frame for cancelled stream");
+                return false;
+            }
+            InFlightData::DataFrame(k) => {
+                debug_assert_eq!(k, key);
+            }
+        }
+
+        let mut frame = frame.map(|prioritized| {
+            // TODO: Ensure fully written
+            eos = prioritized.end_of_stream;
+            prioritized.inner.into_inner()
+        });
+
+        if frame.payload().has_remaining() {
+            let mut stream = store.resolve(key);
+
+            if eos {
+                frame.set_end_stream(true);
             }
 
-            let mut frame = frame.map(|prioritized| {
-                // TODO: Ensure fully written
-                eos = prioritized.end_of_stream;
-                prioritized.inner.into_inner()
-            });
+            self.push_back_frame(frame.into(), buffer, &mut stream);
 
-            if frame.payload().has_remaining() {
-                let mut stream = store.resolve(key);
-
-                if eos {
-                    frame.set_end_stream(true);
-                }
-
-                self.push_back_frame(frame.into(), buffer, &mut stream);
-
-                return true;
-            }
+            return true;
         }
 
         false