Refactor the I/O driver, extracting slab to tokio::util. (#1792)

The I/O driver is made private and moved to `tokio::io::driver`. `Registration` is
moved to `tokio::io::Registration` and `PollEvented` is moved to `tokio::io::PollEvented`.

Additionally, the concurrent slab used by the I/O driver is cleaned up and extracted to
`tokio::util::slab`, allowing it to eventually be used by other types.

tokio/tests/io_driver.rs

@@ -1,7 +1,7 @@
 #![warn(rust_2018_idioms)]
 
-use tokio::net::driver::Reactor;
 use tokio::net::TcpListener;
+use tokio::runtime;
 use tokio_test::{assert_ok, assert_pending};
 
 use futures::task::{waker_ref, ArcWake};
@@ -44,7 +44,8 @@ fn test_drop_on_notify() {
     // shutting down. Then, when the task handle is dropped, the task itself is
     // dropped.
 
-    let mut reactor = assert_ok!(Reactor::new());
+    let mut rt = runtime::Builder::new().basic_scheduler().build().unwrap();
+
     let (addr_tx, addr_rx) = mpsc::channel();
 
     // Define a task that just drains the listener
@@ -62,11 +63,11 @@ fn test_drop_on_notify() {
     }));
 
     {
-        let handle = reactor.handle();
-        let _reactor = tokio::net::driver::set_default(&handle);
-        let waker = waker_ref(&task);
-        let mut cx = Context::from_waker(&waker);
-        assert_pending!(task.future.lock().unwrap().as_mut().poll(&mut cx));
+        rt.enter(|| {
+            let waker = waker_ref(&task);
+            let mut cx = Context::from_waker(&waker);
+            assert_pending!(task.future.lock().unwrap().as_mut().poll(&mut cx));
+        });
     }
 
     // Get the address
@@ -77,5 +78,6 @@ fn test_drop_on_notify() {
     // Establish a connection to the acceptor
     let _s = TcpStream::connect(&addr).unwrap();
 
-    reactor.turn(None).unwrap();
+    // Force the reactor to turn
+    rt.block_on(async {});
 }

tokio/tests/io_driver_drop.rs

@@ -0,0 +1,44 @@
+#![warn(rust_2018_idioms)]
+
+use tokio::net::TcpListener;
+use tokio::runtime;
+use tokio_test::{assert_err, assert_pending, assert_ready, task};
+
+#[test]
+fn tcp_doesnt_block() {
+    let rt = runtime::Builder::new().basic_scheduler().build().unwrap();
+
+    let mut listener = rt.enter(|| {
+        let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
+        TcpListener::from_std(listener).unwrap()
+    });
+
+    drop(rt);
+
+    let mut task = task::spawn(async move {
+        assert_err!(listener.accept().await);
+    });
+
+    assert_ready!(task.poll());
+}
+
+#[test]
+fn drop_wakes() {
+    let rt = runtime::Builder::new().basic_scheduler().build().unwrap();
+
+    let mut listener = rt.enter(|| {
+        let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
+        TcpListener::from_std(listener).unwrap()
+    });
+
+    let mut task = task::spawn(async move {
+        assert_err!(listener.accept().await);
+    });
+
+    assert_pending!(task.poll());
+
+    drop(rt);
+
+    assert!(task.is_woken());
+    assert_ready!(task.poll());
+}

tokio/tests/net_driver_drop.rs

@@ -1,47 +0,0 @@
-#![warn(rust_2018_idioms)]
-
-use tokio::net::driver::{self, Reactor};
-use tokio::net::TcpListener;
-use tokio_test::{assert_err, assert_pending, assert_ready, task};
-
-#[test]
-fn tcp_doesnt_block() {
-    let reactor = Reactor::new().unwrap();
-    let handle = reactor.handle();
-
-    // Set the current reactor for this thread
-    let _reactor_guard = driver::set_default(&handle);
-
-    let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
-    let mut listener = TcpListener::from_std(listener).unwrap();
-    drop(reactor);
-
-    let mut task = task::spawn(async move {
-        assert_err!(listener.accept().await);
-    });
-
-    assert_ready!(task.poll());
-}
-
-#[test]
-fn drop_wakes() {
-    let reactor = Reactor::new().unwrap();
-    let handle = reactor.handle();
-
-    // Set the current reactor for this thread
-    let _reactor_guard = driver::set_default(&handle);
-
-    let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
-    let mut listener = TcpListener::from_std(listener).unwrap();
-
-    let mut task = task::spawn(async move {
-        assert_err!(listener.accept().await);
-    });
-
-    assert_pending!(task.poll());
-
-    drop(reactor);
-
-    assert!(task.is_woken());
-    assert_ready!(task.poll());
-}