migrate actix-web to std::future

src/middleware/compress.rs

@@ -1,15 +1,18 @@
 //! `Middleware` for compressing response body.
 use std::cmp;
+use std::future::Future;
 use std::marker::PhantomData;
+use std::pin::Pin;
 use std::str::FromStr;
+use std::task::{Context, Poll};
 
 use actix_http::body::MessageBody;
 use actix_http::encoding::Encoder;
 use actix_http::http::header::{ContentEncoding, ACCEPT_ENCODING};
 use actix_http::{Error, Response, ResponseBuilder};
 use actix_service::{Service, Transform};
-use futures::future::{ok, FutureResult};
-use futures::{Async, Future, Poll};
+use futures::future::{ok, Ready};
+use pin_project::pin_project;
 
 use crate::service::{ServiceRequest, ServiceResponse};
 
@@ -78,7 +81,7 @@ where
     type Error = Error;
     type InitError = ();
     type Transform = CompressMiddleware<S>;
-    type Future = FutureResult<Self::Transform, Self::InitError>;
+    type Future = Ready<Result<Self::Transform, Self::InitError>>;
 
     fn new_transform(&self, service: S) -> Self::Future {
         ok(CompressMiddleware {
@@ -103,8 +106,8 @@ where
     type Error = Error;
     type Future = CompressResponse<S, B>;
 
-    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        self.service.poll_ready()
+    fn poll_ready(&mut self, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
+        self.service.poll_ready(cx)
     }
 
     fn call(&mut self, req: ServiceRequest) -> Self::Future {
@@ -128,11 +131,13 @@ where
 }
 
 #[doc(hidden)]
+#[pin_project]
 pub struct CompressResponse<S, B>
 where
     S: Service,
     B: MessageBody,
 {
+    #[pin]
     fut: S::Future,
     encoding: ContentEncoding,
     _t: PhantomData<(B)>,
@@ -143,21 +148,25 @@ where
     B: MessageBody,
     S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
 {
-    type Item = ServiceResponse<Encoder<B>>;
-    type Error = Error;
+    type Output = Result<ServiceResponse<Encoder<B>>, Error>;
 
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        let resp = futures::try_ready!(self.fut.poll());
+    fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
+        let this = self.project();
 
-        let enc = if let Some(enc) = resp.response().extensions().get::<Enc>() {
-            enc.0
-        } else {
-            self.encoding
-        };
+        match futures::ready!(this.fut.poll(cx)) {
+            Ok(resp) => {
+                let enc = if let Some(enc) = resp.response().extensions().get::<Enc>() {
+                    enc.0
+                } else {
+                    *this.encoding
+                };
 
-        Ok(Async::Ready(resp.map_body(move |head, body| {
-            Encoder::response(enc, head, body)
-        })))
+                Poll::Ready(Ok(
+                    resp.map_body(move |head, body| Encoder::response(enc, head, body))
+                ))
+            }
+            Err(e) => Poll::Ready(Err(e)),
+        }
     }
 }