Improve performance of Response::bytes() (#827)

src/async_impl/decoder.rs

@@ -1,6 +1,3 @@
-pub(crate) use self::imp::Decoder;
-
-mod imp {
 use std::fmt;
 use std::future::Future;
 use std::pin::Pin;
@@ -16,6 +13,7 @@ mod imp {
 use futures_core::Stream;
 use futures_util::stream::Peekable;
 use http::HeaderMap;
+use hyper::body::HttpBody;
 
 use super::super::Body;
 use crate::error;
@@ -36,7 +34,7 @@ mod imp {
 
 enum Inner {
     /// A `PlainText` decoder just returns the response content as is.
-        PlainText(super::super::body::ImplStream),
+    PlainText(super::body::ImplStream),
 
     /// A `Gzip` decoder will uncompress the gzipped response content before returning it.
     #[cfg(feature = "gzip")]
@@ -54,7 +52,7 @@ mod imp {
 /// A future attempt to poll the response body for EOF so we know whether to use gzip or not.
 struct Pending(Peekable<IoStream>, DecoderType);
 
-    struct IoStream(super::super::body::ImplStream);
+struct IoStream(super::body::ImplStream);
 
 impl fmt::Debug for Decoder {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -245,6 +243,34 @@ mod imp {
     }
 }
 
+impl HttpBody for Decoder {
+    type Data = Bytes;
+    type Error = crate::Error;
+
+    fn poll_data(
+        self: Pin<&mut Self>,
+        cx: &mut Context,
+    ) -> Poll<Option<Result<Self::Data, Self::Error>>> {
+        self.poll_next(cx)
+    }
+
+    fn poll_trailers(
+        self: Pin<&mut Self>,
+        _cx: &mut Context,
+    ) -> Poll<Result<Option<http::HeaderMap>, Self::Error>> {
+        Poll::Ready(Ok(None))
+    }
+
+    fn size_hint(&self) -> http_body::SizeHint {
+        match self.inner {
+            Inner::PlainText(ref body) => HttpBody::size_hint(body),
+            // the rest are "unknown", so default
+            #[cfg(any(feature = "brotli", feature = "gzip"))]
+            _ => http_body::SizeHint::default(),
+        }
+    }
+}
+
 impl Future for Pending {
     type Output = Result<Inner, std::io::Error>;
 
@@ -291,4 +317,3 @@ mod imp {
         }
     }
 }
-}

src/async_impl/response.rs

@@ -2,12 +2,11 @@ use std::borrow::Cow;
 use std::fmt;
 use std::net::SocketAddr;
 
-use bytes::{Bytes, BytesMut};
+use bytes::Bytes;
 use encoding_rs::{Encoding, UTF_8};
 use futures_util::stream::StreamExt;
 use http;
 use hyper::client::connect::HttpInfo;
-use hyper::header::CONTENT_LENGTH;
 use hyper::{HeaderMap, StatusCode, Version};
 use mime::Mime;
 #[cfg(feature = "json")]
@@ -89,13 +88,12 @@ impl Response {
     /// Reasons it may not be known:
     ///
     /// - The server didn't send a `content-length` header.
-    /// - The response is gzipped and automatically decoded (thus changing
+    /// - The response is compressed and automatically decoded (thus changing
     ///   the actual decoded length).
     pub fn content_length(&self) -> Option<u64> {
-        self.headers()
+        use hyper::body::HttpBody;
-            .get(CONTENT_LENGTH)
+
-            .and_then(|ct_len| ct_len.to_str().ok())
+        HttpBody::size_hint(&self.body).exact()
-            .and_then(|ct_len| ct_len.parse().ok())
     }
 
     /// Retrieve the cookies contained in the response.
@@ -259,12 +257,8 @@ impl Response {
     /// # Ok(())
     /// # }
     /// ```
-    pub async fn bytes(mut self) -> crate::Result<Bytes> {
+    pub async fn bytes(self) -> crate::Result<Bytes> {
-        let mut buf = BytesMut::new();
+        hyper::body::to_bytes(self.body).await
-        while let Some(chunk) = self.body.next().await {
-            buf.extend(chunk?);
-        }
-        Ok(buf.freeze())
     }
 
     /// Stream a chunk of the response body.

tests/client.rs

@@ -68,10 +68,29 @@ async fn response_text() {
         .send()
         .await
         .expect("Failed to get");
+    assert_eq!(res.content_length(), Some(5));
     let text = res.text().await.expect("Failed to get text");
     assert_eq!("Hello", text);
 }
 
+#[tokio::test]
+async fn response_bytes() {
+    let _ = env_logger::try_init();
+
+    let server = server::http(move |_req| async { http::Response::new("Hello".into()) });
+
+    let client = Client::new();
+
+    let res = client
+        .get(&format!("http://{}/bytes", server.addr()))
+        .send()
+        .await
+        .expect("Failed to get");
+    assert_eq!(res.content_length(), Some(5));
+    let bytes = res.bytes().await.expect("res.bytes()");
+    assert_eq!("Hello", bytes);
+}
+
 #[tokio::test]
 #[cfg(feature = "json")]
 async fn response_json() {