signal: remove new() constructors in favor of free functions (#1472)

* Also removed any `*_with_handle` related methods in favor of always
using the default reactor

tokio-net/tests/signal_drop_multi_loop.rs

@@ -11,10 +11,10 @@ fn dropping_loops_does_not_cause_starvation() {
         let kind = SignalKind::user_defined1();
 
         let mut first_rt = CurrentThreadRuntime::new().expect("failed to init first runtime");
-        let mut first_signal = Signal::new(kind).expect("failed to register first signal");
+        let mut first_signal = signal(kind).expect("failed to register first signal");
 
         let mut second_rt = CurrentThreadRuntime::new().expect("failed to init second runtime");
-        let mut second_signal = Signal::new(kind).expect("failed to register second signal");
+        let mut second_signal = signal(kind).expect("failed to register second signal");
 
         send_signal(libc::SIGUSR1);
 

tokio-net/tests/signal_drop_then_get_a_signal.rs

@@ -9,11 +9,11 @@ use crate::signal_support::*;
 #[tokio::test]
 async fn drop_then_get_a_signal() {
     let kind = SignalKind::user_defined1();
-    let signal = Signal::new(kind).expect("failed to create first signal");
-    drop(signal);
+    let sig = signal(kind).expect("failed to create first signal");
+    drop(sig);
 
     send_signal(libc::SIGUSR1);
-    let signal = Signal::new(kind).expect("failed to create second signal");
+    let sig = signal(kind).expect("failed to create second signal");
 
-    let _ = with_timeout(signal.into_future()).await;
+    let _ = with_timeout(sig.into_future()).await;
 }

tokio-net/tests/signal_dropping_does_not_deregister_other_instances.rs

@@ -12,15 +12,13 @@ async fn dropping_signal_does_not_deregister_any_other_instances() {
 
     // NB: Testing for issue alexcrichton/tokio-signal#38:
     // signals should not starve based on ordering
-    let first_duplicate_signal =
-        Signal::new(kind).expect("failed to register first duplicate signal");
-    let signal = Signal::new(kind).expect("failed to register signal");
-    let second_duplicate_signal =
-        Signal::new(kind).expect("failed to register second duplicate signal");
+    let first_duplicate_signal = signal(kind).expect("failed to register first duplicate signal");
+    let sig = signal(kind).expect("failed to register signal");
+    let second_duplicate_signal = signal(kind).expect("failed to register second duplicate signal");
 
     drop(first_duplicate_signal);
     drop(second_duplicate_signal);
 
     send_signal(libc::SIGUSR1);
-    let _ = with_timeout(signal.into_future()).await;
+    let _ = with_timeout(sig.into_future()).await;
 }

tokio-net/tests/signal_multi_loop.rs

@@ -20,7 +20,7 @@ fn multi_loop() {
                 let sender = sender.clone();
                 thread::spawn(move || {
                     let mut rt = CurrentThreadRuntime::new().unwrap();
-                    let signal = Signal::new(SignalKind::hangup()).unwrap();
+                    let signal = signal(SignalKind::hangup()).unwrap();
                     sender.send(()).unwrap();
                     let _ = run_with_timeout(&mut rt, signal.into_future());
                 })

tokio-net/tests/signal_notify_both.rs

@@ -9,9 +9,9 @@ use crate::signal_support::*;
 #[tokio::test]
 async fn notify_both() {
     let kind = SignalKind::user_defined2();
-    let signal1 = Signal::new(kind).expect("failed to create signal1");
+    let signal1 = signal(kind).expect("failed to create signal1");
 
-    let signal2 = Signal::new(kind).expect("failed to create signal2");
+    let signal2 = signal(kind).expect("failed to create signal2");
 
     send_signal(libc::SIGUSR2);
     let _ = with_timeout(future::join(signal1.into_future(), signal2.into_future())).await;

tokio-net/tests/signal_simple.rs

@@ -8,7 +8,7 @@ use crate::signal_support::*;
 
 #[tokio::test]
 async fn simple() {
-    let signal = Signal::new(SignalKind::user_defined1()).expect("failed to create signal");
+    let signal = signal(SignalKind::user_defined1()).expect("failed to create signal");
 
     send_signal(libc::SIGUSR1);
 
@@ -19,9 +19,9 @@ async fn simple() {
 #[cfg(unix)]
 async fn ctrl_c() {
     use tokio::sync::oneshot;
-    use tokio_net::signal::CtrlC;
+    use tokio_net::signal::ctrl_c;
 
-    let ctrl_c = CtrlC::new().expect("failed to init ctrl_c");
+    let ctrl_c = ctrl_c().expect("failed to init ctrl_c");
 
     let (fire, wait) = oneshot::channel();
 

tokio-net/tests/signal_support/mod.rs

@@ -3,7 +3,7 @@
 
 pub use tokio::runtime::current_thread::{self, Runtime as CurrentThreadRuntime};
 use tokio::timer::Timeout;
-pub use tokio_net::signal::unix::{Signal, SignalKind};
+pub use tokio_net::signal::unix::{signal, SignalKind};
 
 pub use futures_util::future;
 use futures_util::future::FutureExt;

tokio-net/tests/signal_twice.rs

@@ -9,14 +9,14 @@ use crate::signal_support::*;
 #[tokio::test]
 async fn twice() {
     let kind = SignalKind::user_defined1();
-    let mut signal = Signal::new(kind).expect("failed to get signal");
+    let mut sig = signal(kind).expect("failed to get signal");
 
     for _ in 0..2 {
         send_signal(libc::SIGUSR1);
 
-        let (item, sig) = with_timeout(signal.into_future()).await;
+        let (item, sig_next) = with_timeout(sig.into_future()).await;
         assert_eq!(item, Some(()));
 
-        signal = sig;
+        sig = sig_next;
     }
 }