Limit futures dependency to Stream via feature flag (#1774)

In an effort to reach API stability, the `tokio` crate is shedding its
_public_ dependencies on crates that are either a) do not provide a
stable (1.0+) release with longevity guarantees or b) match the `tokio`
release cadence. Of course, implementing `std` traits fits the
requirements.

The on exception, for now, is the `Stream` trait found in `futures_core`.
It is expected that this trait will not change much and be moved into `std.
Since Tokio is not yet going reaching 1.0, I feel that it is acceptable to maintain
a dependency on this trait given how foundational it is.

Since the `Stream` implementation is optional, types that are logically
streams provide `async fn next_*` functions to obtain the next value.
Avoiding the `next()` name prevents fn conflicts with `StreamExt::next()`.

Additionally, some misc cleanup is also done:

- `tokio::io::io` -> `tokio::io::util`.
- `delay` -> `delay_until`.
- `Timeout::new` -> `timeout(...)`.
- `signal::ctrl_c()` returns a future instead of a stream.
- `{tcp,unix}::Incoming` is removed (due to lack of `Stream` trait).
- `time::Throttle` is removed (due to lack of `Stream` trait).
-  Fix: `mpsc::UnboundedSender::send(&self)` (no more conflict with `Sink` fns).

tokio/tests/time_timeout.rs

@@ -1,7 +1,7 @@
 #![warn(rust_2018_idioms)]
 
 use tokio::sync::oneshot;
-use tokio::time::{self, Instant, Timeout};
+use tokio::time::{self, timeout, timeout_at, Instant};
 use tokio_test::*;
 
 use futures::future::pending;
@@ -10,7 +10,7 @@ use std::time::Duration;
 #[tokio::test]
 async fn simultaneous_deadline_future_completion() {
     // Create a future that is immediately ready
-    let mut fut = task::spawn(Timeout::new_at(async {}, Instant::now()));
+    let mut fut = task::spawn(timeout_at(Instant::now(), async {}));
 
     // Ready!
     assert_ready_ok!(fut.poll());
@@ -19,7 +19,7 @@ async fn simultaneous_deadline_future_completion() {
 #[tokio::test]
 async fn completed_future_past_deadline() {
     // Wrap it with a deadline
-    let mut fut = task::spawn(Timeout::new_at(async {}, Instant::now() - ms(1000)));
+    let mut fut = task::spawn(timeout_at(Instant::now() - ms(1000), async {}));
 
     // Ready!
     assert_ready_ok!(fut.poll());
@@ -33,7 +33,7 @@ async fn future_and_deadline_in_future() {
     let (tx, rx) = oneshot::channel();
 
     // Wrap it with a deadline
-    let mut fut = task::spawn(Timeout::new_at(rx, Instant::now() + ms(100)));
+    let mut fut = task::spawn(timeout_at(Instant::now() + ms(100), rx));
 
     assert_pending!(fut.poll());
 
@@ -57,7 +57,7 @@ async fn future_and_timeout_in_future() {
     let (tx, rx) = oneshot::channel();
 
     // Wrap it with a deadline
-    let mut fut = task::spawn(Timeout::new(rx, ms(100)));
+    let mut fut = task::spawn(timeout(ms(100), rx));
 
     // Ready!
     assert_pending!(fut.poll());
@@ -80,7 +80,7 @@ async fn deadline_now_elapses() {
     time::pause();
 
     // Wrap it with a deadline
-    let mut fut = task::spawn(Timeout::new_at(pending::<()>(), Instant::now()));
+    let mut fut = task::spawn(timeout_at(Instant::now(), pending::<()>()));
 
     // Factor in jitter
     // TODO: don't require this
@@ -94,7 +94,7 @@ async fn deadline_future_elapses() {
     time::pause();
 
     // Wrap it with a deadline
-    let mut fut = task::spawn(Timeout::new_at(pending::<()>(), Instant::now() + ms(300)));
+    let mut fut = task::spawn(timeout_at(Instant::now() + ms(300), pending::<()>()));
 
     assert_pending!(fut.poll());
 
@@ -104,63 +104,6 @@ async fn deadline_future_elapses() {
     assert_ready_err!(fut.poll());
 }
 
-#[tokio::test]
-async fn stream_and_timeout_in_future() {
-    use tokio::sync::mpsc;
-
-    time::pause();
-
-    // Not yet complete
-    let (mut tx, rx) = mpsc::unbounded_channel();
-
-    // Wrap it with a deadline
-    let mut stream = task::spawn(Timeout::new(rx, ms(100)));
-
-    // Not ready
-    assert_pending!(stream.poll_next());
-
-    // Turn the timer, it runs for the elapsed time
-    time::advance(ms(90)).await;
-
-    assert_pending!(stream.poll_next());
-
-    // Complete the future
-    tx.try_send(()).unwrap();
-
-    let item = assert_ready!(stream.poll_next());
-    assert!(item.is_some());
-}
-
-#[tokio::test]
-async fn idle_stream_timesout_periodically() {
-    use tokio::sync::mpsc;
-
-    time::pause();
-
-    // Not yet complete
-    let (_tx, rx) = mpsc::unbounded_channel::<()>();
-
-    // Wrap it with a deadline
-    let mut stream = task::spawn(Timeout::new(rx, ms(100)));
-
-    // Not ready
-    assert_pending!(stream.poll_next());
-
-    // Turn the timer, it runs for the elapsed time
-    time::advance(ms(101)).await;
-
-    let v = assert_ready!(stream.poll_next()).unwrap();
-    assert_err!(v);
-
-    // Stream's timeout should reset
-    assert_pending!(stream.poll_next());
-
-    // Turn the timer, it runs for the elapsed time
-    time::advance(ms(101)).await;
-    let v = assert_ready!(stream.poll_next()).unwrap();
-    assert_err!(v);
-}
-
 fn ms(n: u64) -> Duration {
     Duration::from_millis(n)
 }