make actix-http compile with std::future

actix-http/src/client/connector.rs

@@ -1,15 +1,18 @@
 use std::fmt;
+use std::future::Future;
 use std::marker::PhantomData;
+use std::pin::Pin;
+use std::task::{Context, Poll};
 use std::time::Duration;
 
 use actix_codec::{AsyncRead, AsyncWrite};
 use actix_connect::{
     default_connector, Connect as TcpConnect, Connection as TcpConnection,
 };
-use actix_service::{apply_fn, Service, ServiceExt};
+use actix_service::{apply_fn, Service};
 use actix_utils::timeout::{TimeoutError, TimeoutService};
 use http::Uri;
-use tokio_tcp::TcpStream;
+use tokio_net::tcp::TcpStream;
 
 use super::connection::Connection;
 use super::error::ConnectError;
@@ -212,7 +215,7 @@ where
     pub fn finish(
         self,
     ) -> impl Service<Request = Connect, Response = impl Connection, Error = ConnectError>
-                 + Clone {
+           + Clone {
         #[cfg(not(any(feature = "ssl", feature = "rust-tls")))]
         {
             let connector = TimeoutService::new(

actix-http/src/client/h1proto.rs

@@ -1,10 +1,13 @@
+use std::future::Future;
 use std::io::Write;
+use std::pin::Pin;
+use std::task::{Context, Poll};
 use std::{io, time};
 
 use actix_codec::{AsyncRead, AsyncWrite, Framed};
 use bytes::{BufMut, Bytes, BytesMut};
 use futures::future::{ok, Either};
-use futures::{Async, Future, Poll, Sink, Stream};
+use futures::{Sink, Stream};
 
 use crate::error::PayloadError;
 use crate::h1;

actix-http/src/client/h2proto.rs

@@ -1,9 +1,11 @@
+use std::future::Future;
+use std::pin::Pin;
+use std::task::{Context, Poll};
 use std::time;
 
 use actix_codec::{AsyncRead, AsyncWrite};
 use bytes::Bytes;
 use futures::future::{err, Either};
-use futures::{Async, Future, Poll};
 use h2::{client::SendRequest, SendStream};
 use http::header::{HeaderValue, CONNECTION, CONTENT_LENGTH, TRANSFER_ENCODING};
 use http::{request::Request, HttpTryFrom, Method, Version};

actix-http/src/client/pool.rs

@@ -1,22 +1,24 @@
 use std::cell::RefCell;
 use std::collections::VecDeque;
+use std::future::Future;
 use std::io;
+use std::pin::Pin;
 use std::rc::Rc;
+use std::task::{Context, Poll};
 use std::time::{Duration, Instant};
 
 use actix_codec::{AsyncRead, AsyncWrite};
 use actix_service::Service;
+use actix_utils::oneshot;
+use actix_utils::task::LocalWaker;
 use bytes::Bytes;
 use futures::future::{err, ok, Either, FutureResult};
-use futures::task::AtomicTask;
-use futures::unsync::oneshot;
-use futures::{Async, Future, Poll};
 use h2::client::{handshake, Handshake};
 use hashbrown::HashMap;
 use http::uri::Authority;
 use indexmap::IndexSet;
 use slab::Slab;
-use tokio_timer::{sleep, Delay};
+use tokio_timer::{delay_for, Delay};
 
 use super::connection::{ConnectionType, IoConnection};
 use super::error::ConnectError;
@@ -140,7 +142,7 @@ where
         // start support future
         if !support {
             self.1.as_ref().borrow_mut().task = Some(AtomicTask::new());
-            tokio_current_thread::spawn(ConnectorPoolSupport {
+            tokio_executor::current_thread::spawn(ConnectorPoolSupport {
                 connector: self.0.clone(),
                 inner: self.1.clone(),
             })
@@ -255,7 +257,7 @@ where
         if let Some(ref mut h2) = self.h2 {
             return match h2.poll() {
                 Ok(Async::Ready((snd, connection))) => {
-                    tokio_current_thread::spawn(connection.map_err(|_| ()));
+                    tokio_executor::current_thread::spawn(connection.map_err(|_| ()));
                     Ok(Async::Ready(IoConnection::new(
                         ConnectionType::H2(snd),
                         Instant::now(),
@@ -373,7 +375,7 @@ where
                 {
                     if let Some(timeout) = self.disconnect_timeout {
                         if let ConnectionType::H1(io) = conn.io {
-                            tokio_current_thread::spawn(CloseConnection::new(
+                            tokio_executor::current_thread::spawn(CloseConnection::new(
                                 io, timeout,
                             ))
                         }
@@ -387,7 +389,7 @@ where
                             Ok(n) if n > 0 => {
                                 if let Some(timeout) = self.disconnect_timeout {
                                     if let ConnectionType::H1(io) = io {
-                                        tokio_current_thread::spawn(
+                                        tokio_executor::current_thread::spawn(
                                             CloseConnection::new(io, timeout),
                                         )
                                     }
@@ -421,7 +423,7 @@ where
         self.acquired -= 1;
         if let Some(timeout) = self.disconnect_timeout {
             if let ConnectionType::H1(io) = io {
-                tokio_current_thread::spawn(CloseConnection::new(io, timeout))
+                tokio_executor::current_thread::spawn(CloseConnection::new(io, timeout))
             }
         }
         self.check_availibility();
@@ -448,7 +450,7 @@ where
     fn new(io: T, timeout: Duration) -> Self {
         CloseConnection {
             io,
-            timeout: sleep(timeout),
+            timeout: delay_for(timeout),
         }
     }
 }
@@ -558,7 +560,7 @@ where
         inner: Rc<RefCell<Inner<Io>>>,
         fut: F,
     ) {
-        tokio_current_thread::spawn(OpenWaitingConnection {
+        tokio_executor::current_thread::spawn(OpenWaitingConnection {
             key,
             fut,
             h2: None,
@@ -593,7 +595,7 @@ where
         if let Some(ref mut h2) = self.h2 {
             return match h2.poll() {
                 Ok(Async::Ready((snd, connection))) => {
-                    tokio_current_thread::spawn(connection.map_err(|_| ()));
+                    tokio_executor::current_thread::spawn(connection.map_err(|_| ()));
                     let rx = self.rx.take().unwrap();
                     let _ = rx.send(Ok(IoConnection::new(
                         ConnectionType::H2(snd),