integrate with updated actix-{codec, utils} (#1634)

actix-http/src/h1/client.rs

@@ -173,13 +173,12 @@ impl Decoder for ClientPayloadCodec {
     }
 }
 
-impl Encoder for ClientCodec {
-    type Item = Message<(RequestHeadType, BodySize)>;
+impl Encoder<Message<(RequestHeadType, BodySize)>> for ClientCodec {
     type Error = io::Error;
 
     fn encode(
         &mut self,
-        item: Self::Item,
+        item: Message<(RequestHeadType, BodySize)>,
         dst: &mut BytesMut,
     ) -> Result<(), Self::Error> {
         match item {

actix-http/src/h1/codec.rs

@@ -144,13 +144,12 @@ impl Decoder for Codec {
     }
 }
 
-impl Encoder for Codec {
-    type Item = Message<(Response<()>, BodySize)>;
+impl Encoder<Message<(Response<()>, BodySize)>> for Codec {
     type Error = io::Error;
 
     fn encode(
         &mut self,
-        item: Self::Item,
+        item: Message<(Response<()>, BodySize)>,
         dst: &mut BytesMut,
     ) -> Result<(), Self::Error> {
         match item {

actix-http/src/h1/service.rs

@@ -548,10 +548,12 @@ where
 }
 
 #[doc(hidden)]
+#[pin_project::pin_project]
 pub struct OneRequestServiceResponse<T>
 where
     T: AsyncRead + AsyncWrite + Unpin,
 {
+    #[pin]
     framed: Option<Framed<T, Codec>>,
 }
 
@@ -562,16 +564,18 @@ where
     type Output = Result<(Request, Framed<T, Codec>), ParseError>;
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        match self.framed.as_mut().unwrap().next_item(cx) {
-            Poll::Ready(Some(Ok(req))) => match req {
+        let this = self.as_mut().project();
+
+        match ready!(this.framed.as_pin_mut().unwrap().next_item(cx)) {
+            Some(Ok(req)) => match req {
                 Message::Item(req) => {
-                    Poll::Ready(Ok((req, self.framed.take().unwrap())))
+                    let mut this = self.as_mut().project();
+                    Poll::Ready(Ok((req, this.framed.take().unwrap())))
                 }
                 Message::Chunk(_) => unreachable!("Something is wrong"),
             },
-            Poll::Ready(Some(Err(err))) => Poll::Ready(Err(err)),
-            Poll::Ready(None) => Poll::Ready(Err(ParseError::Incomplete)),
-            Poll::Pending => Poll::Pending,
+            Some(Err(err)) => Poll::Ready(Err(err)),
+            None => Poll::Ready(Err(ParseError::Incomplete)),
         }
     }
 }

actix-http/src/h1/utils.rs

@@ -9,12 +9,13 @@ use crate::error::Error;
 use crate::h1::{Codec, Message};
 use crate::response::Response;
 
-/// Send http/1 response
+/// Send HTTP/1 response
 #[pin_project::pin_project]
 pub struct SendResponse<T, B> {
     res: Option<Message<(Response<()>, BodySize)>>,
     #[pin]
     body: Option<ResponseBody<B>>,
+    #[pin]
     framed: Option<Framed<T, Codec>>,
 }
 
@@ -35,23 +36,30 @@ where
 
 impl<T, B> Future for SendResponse<T, B>
 where
-    T: AsyncRead + AsyncWrite,
+    T: AsyncRead + AsyncWrite + Unpin,
     B: MessageBody + Unpin,
 {
     type Output = Result<Framed<T, Codec>, Error>;
 
     // TODO: rethink if we need loops in polls
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let mut this = self.project();
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let mut this = self.as_mut().project();
 
         let mut body_done = this.body.is_none();
         loop {
             let mut body_ready = !body_done;
-            let framed = this.framed.as_mut().unwrap();
 
             // send body
             if this.res.is_none() && body_ready {
-                while body_ready && !body_done && !framed.is_write_buf_full() {
+                while body_ready
+                    && !body_done
+                    && !this
+                        .framed
+                        .as_ref()
+                        .as_pin_ref()
+                        .unwrap()
+                        .is_write_buf_full()
+                {
                     match this.body.as_mut().as_pin_mut().unwrap().poll_next(cx)? {
                         Poll::Ready(item) => {
                             // body is done when item is None
@@ -59,6 +67,7 @@ where
                             if body_done {
                                 let _ = this.body.take();
                             }
+                            let framed = this.framed.as_mut().as_pin_mut().unwrap();
                             framed.write(Message::Chunk(item))?;
                         }
                         Poll::Pending => body_ready = false,
@@ -66,6 +75,8 @@ where
                 }
             }
 
+            let framed = this.framed.as_mut().as_pin_mut().unwrap();
+
             // flush write buffer
             if !framed.is_write_buf_empty() {
                 match framed.flush(cx)? {
@@ -96,6 +107,9 @@ where
                 break;
             }
         }
-        Poll::Ready(Ok(this.framed.take().unwrap()))
+
+        let framed = this.framed.take().unwrap();
+
+        Poll::Ready(Ok(framed))
     }
 }