MessageBody::boxed (#2520)

Co-authored-by: Rob Ede <robjtede@icloud.com>

actix-http/src/body/boxed.rs

@@ -14,7 +14,11 @@ use crate::Error;
 pub struct BoxBody(Pin<Box<dyn MessageBody<Error = Box<dyn StdError>>>>);
 
 impl BoxBody {
-    /// Boxes a `MessageBody` and any errors it generates.
+    /// Same as `MessageBody::boxed`.
+    ///
+    /// If the body type to wrap is unknown or generic it is better to use [`MessageBody::boxed`] to
+    /// avoid double boxing.
+    #[inline]
     pub fn new<B>(body: B) -> Self
     where
         B: MessageBody + 'static,
@@ -24,6 +28,7 @@ impl BoxBody {
     }
 
     /// Returns a mutable pinned reference to the inner message body type.
+    #[inline]
     pub fn as_pin_mut(&mut self) -> Pin<&mut (dyn MessageBody<Error = Box<dyn StdError>>)> {
         self.0.as_mut()
     }
@@ -38,10 +43,12 @@ impl fmt::Debug for BoxBody {
 impl MessageBody for BoxBody {
     type Error = Error;
 
+    #[inline]
     fn size(&self) -> BodySize {
         self.0.size()
     }
 
+    #[inline]
     fn poll_next(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
@@ -52,13 +59,20 @@ impl MessageBody for BoxBody {
             .map_err(|err| Error::new_body().with_cause(err))
     }
 
+    #[inline]
     fn is_complete_body(&self) -> bool {
         self.0.is_complete_body()
     }
 
+    #[inline]
     fn take_complete_body(&mut self) -> Bytes {
         self.0.take_complete_body()
     }
+
+    #[inline]
+    fn boxed(self) -> BoxBody {
+        self
+    }
 }
 
 #[cfg(test)]

actix-http/src/body/either.rs

@@ -88,6 +88,14 @@ where
             EitherBody::Right { body } => body.take_complete_body(),
         }
     }
+
+    #[inline]
+    fn boxed(self) -> BoxBody {
+        match self {
+            EitherBody::Left { body } => body.boxed(),
+            EitherBody::Right { body } => body.boxed(),
+        }
+    }
 }
 
 #[cfg(test)]

actix-http/src/body/message_body.rs

@@ -12,7 +12,7 @@ use bytes::{Bytes, BytesMut};
 use futures_core::ready;
 use pin_project_lite::pin_project;
 
-use super::BodySize;
+use super::{BodySize, BoxBody};
 
 /// An interface types that can converted to bytes and used as response bodies.
 // TODO: examples
@@ -77,6 +77,15 @@ pub trait MessageBody {
             std::any::type_name::<Self>()
         );
     }
+
+    /// Converts this body into `BoxBody`.
+    #[inline]
+    fn boxed(self) -> BoxBody
+    where
+        Self: Sized + 'static,
+    {
+        BoxBody::new(self)
+    }
 }
 
 mod foreign_impls {
@@ -656,7 +665,7 @@ mod tests {
         assert_eq!(body.take_complete_body(), b"test".as_ref());
 
         // subsequent poll_next returns None
-        let waker = futures_util::task::noop_waker();
+        let waker = futures_task::noop_waker();
         let mut cx = Context::from_waker(&waker);
         assert!(Pin::new(&mut body).poll_next(&mut cx).map_err(drop) == Poll::Ready(None));
     }

actix-http/src/response.rs

@@ -194,7 +194,7 @@ impl<B> Response<B> {
     where
         B: MessageBody + 'static,
     {
-        self.map_body(|_, body| BoxBody::new(body))
+        self.map_body(|_, body| body.boxed())
     }
 
     /// Returns body, consuming this response.