relax unpin bounds on payload types (#2545)

actix-http/src/h1/dispatcher.rs

@@ -646,10 +646,11 @@ where
                                     Payload is attached to Request and passed to Service::call
                                     where the state can be collected and consumed.
                                     */
-                                    let (ps, pl) = Payload::create(false);
-                                    let (req1, _) = req.replace_payload(crate::Payload::H1(pl));
+                                    let (sender, payload) = Payload::create(false);
+                                    let (req1, _) =
+                                        req.replace_payload(crate::Payload::H1 { payload });
                                     req = req1;
-                                    *this.payload = Some(ps);
+                                    *this.payload = Some(sender);
                                 }
 
                                 // Request has no payload.

actix-http/src/h1/payload.rs

@@ -1,9 +1,12 @@
 //! Payload stream
-use std::cell::RefCell;
-use std::collections::VecDeque;
-use std::pin::Pin;
-use std::rc::{Rc, Weak};
-use std::task::{Context, Poll, Waker};
+
+use std::{
+    cell::RefCell,
+    collections::VecDeque,
+    pin::Pin,
+    rc::{Rc, Weak},
+    task::{Context, Poll, Waker},
+};
 
 use bytes::Bytes;
 use futures_core::Stream;
@@ -22,39 +25,32 @@ pub enum PayloadStatus {
 
 /// Buffered stream of bytes chunks
 ///
-/// Payload stores chunks in a vector. First chunk can be received with
-/// `.readany()` method. Payload stream is not thread safe. Payload does not
-/// notify current task when new data is available.
+/// Payload stores chunks in a vector. First chunk can be received with `poll_next`. Payload does
+/// not notify current task when new data is available.
 ///
-/// Payload stream can be used as `Response` body stream.
+/// Payload can be used as `Response` body stream.
 #[derive(Debug)]
 pub struct Payload {
     inner: Rc<RefCell<Inner>>,
 }
 
 impl Payload {
-    /// Create payload stream.
+    /// Creates a payload stream.
     ///
-    /// This method construct two objects responsible for bytes stream
-    /// generation.
-    ///
-    /// * `PayloadSender` - *Sender* side of the stream
-    ///
-    /// * `Payload` - *Receiver* side of the stream
+    /// This method construct two objects responsible for bytes stream generation:
+    /// - `PayloadSender` - *Sender* side of the stream
+    /// - `Payload` - *Receiver* side of the stream
     pub fn create(eof: bool) -> (PayloadSender, Payload) {
         let shared = Rc::new(RefCell::new(Inner::new(eof)));
 
         (
-            PayloadSender {
-                inner: Rc::downgrade(&shared),
-            },
+            PayloadSender::new(Rc::downgrade(&shared)),
             Payload { inner: shared },
         )
     }
 
-    /// Create empty payload
-    #[doc(hidden)]
-    pub fn empty() -> Payload {
+    /// Creates an empty payload.
+    pub(crate) fn empty() -> Payload {
         Payload {
             inner: Rc::new(RefCell::new(Inner::new(true))),
         }
@@ -77,14 +73,6 @@ impl Payload {
     pub fn unread_data(&mut self, data: Bytes) {
         self.inner.borrow_mut().unread_data(data);
     }
-
-    #[inline]
-    pub fn readany(
-        &mut self,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, PayloadError>>> {
-        self.inner.borrow_mut().readany(cx)
-    }
 }
 
 impl Stream for Payload {
@@ -94,7 +82,7 @@ impl Stream for Payload {
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Option<Result<Bytes, PayloadError>>> {
-        self.inner.borrow_mut().readany(cx)
+        Pin::new(&mut *self.inner.borrow_mut()).poll_next(cx)
     }
 }
 
@@ -104,6 +92,10 @@ pub struct PayloadSender {
 }
 
 impl PayloadSender {
+    fn new(inner: Weak<RefCell<Inner>>) -> Self {
+        Self { inner }
+    }
+
     #[inline]
     pub fn set_error(&mut self, err: PayloadError) {
         if let Some(shared) = self.inner.upgrade() {
@@ -227,7 +219,10 @@ impl Inner {
         self.len
     }
 
-    fn readany(&mut self, cx: &mut Context<'_>) -> Poll<Option<Result<Bytes, PayloadError>>> {
+    fn poll_next(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<Bytes, PayloadError>>> {
         if let Some(data) = self.items.pop_front() {
             self.len -= data.len();
             self.need_read = self.len < MAX_BUFFER_SIZE;
@@ -257,8 +252,18 @@ impl Inner {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
+    use std::panic::{RefUnwindSafe, UnwindSafe};
+
     use actix_utils::future::poll_fn;
+    use static_assertions::{assert_impl_all, assert_not_impl_any};
+
+    use super::*;
+
+    assert_impl_all!(Payload: Unpin);
+    assert_not_impl_any!(Payload: Send, Sync, UnwindSafe, RefUnwindSafe);
+
+    assert_impl_all!(Inner: Unpin, Send, Sync);
+    assert_not_impl_any!(Inner: UnwindSafe, RefUnwindSafe);
 
     #[actix_rt::test]
     async fn test_unread_data() {
@@ -270,7 +275,10 @@ mod tests {
 
         assert_eq!(
             Bytes::from("data"),
-            poll_fn(|cx| payload.readany(cx)).await.unwrap().unwrap()
+            poll_fn(|cx| Pin::new(&mut payload).poll_next(cx))
+                .await
+                .unwrap()
+                .unwrap()
         );
     }
 }

actix-http/src/h1/utils.rs

@@ -45,7 +45,7 @@ where
 impl<T, B> Future for SendResponse<T, B>
 where
     T: AsyncRead + AsyncWrite + Unpin,
-    B: MessageBody + Unpin,
+    B: MessageBody,
     B::Error: Into<Error>,
 {
     type Output = Result<Framed<T, Codec>, Error>;
@@ -81,7 +81,7 @@ where
                             // body is done when item is None
                             body_done = item.is_none();
                             if body_done {
-                                let _ = this.body.take();
+                                this.body.set(None);
                             }
                             let framed = this.framed.as_mut().as_pin_mut().unwrap();
                             framed