assume timer is always global

Signed-off-by: Yoshua Wuyts <yoshuawuyts@gmail.com>

Author: yoshuawuyts

src/delay.rs

@@ -5,7 +5,6 @@
 
 use std::fmt;
 use std::future::Future;
-use std::io;
 use std::pin::Pin;
 use std::sync::atomic::AtomicUsize;
 use std::sync::atomic::Ordering::SeqCst;
@@ -51,8 +50,7 @@ impl Delay {
     ///
     /// The returned instance of `Delay` will be bound to the timer specified by
     /// the `handle` argument.
-    #[doc(hidden)]
-    pub fn new_handle(at: Instant, handle: TimerHandle) -> Delay {
+    pub(crate) fn new_handle(at: Instant, handle: TimerHandle) -> Delay {
         let inner = match handle.inner.upgrade() {
             Some(i) => i,
             None => {
@@ -138,19 +136,16 @@ impl Delay {
 }
 
 impl Future for Delay {
-    type Output = io::Result<()>;
+    type Output = ();
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let state = match self.state {
             Some(ref state) => state,
-            None => {
-                let err = Err(io::Error::new(io::ErrorKind::Other, "timer has gone away"));
-                return Poll::Ready(err);
-            }
+            None => panic!("timer has gone away"),
         };
 
         if state.state.load(SeqCst) & 1 != 0 {
-            return Poll::Ready(Ok(()));
+            return Poll::Ready(());
         }
 
         state.waker.register(&cx.waker());
@@ -159,11 +154,8 @@ impl Future for Delay {
         // state. If we've fired the first bit is set, and if we've been
         // invalidated the second bit is set.
         match state.state.load(SeqCst) {
-            n if n & 0b01 != 0 => Poll::Ready(Ok(())),
-            n if n & 0b10 != 0 => Poll::Ready(Err(io::Error::new(
-                io::ErrorKind::Other,
-                "timer has gone away",
-            ))),
+            n if n & 0b01 != 0 => Poll::Ready(()),
+            n if n & 0b10 != 0 => panic!("timer has gone away"),
             _ => Poll::Pending,
         }
     }

src/lib.rs

@@ -27,9 +27,6 @@ mod timer;
 use arc_list::{ArcList, Node};
 use heap::{Heap, Slot};
 use heap_timer::HeapTimer;
-use timer::{ScheduledTimer, TimerHandle};
-
-#[doc(hidden)]
-pub use timer::Timer;
+use timer::{ScheduledTimer, Timer, TimerHandle};
 
 pub use self::delay::Delay;

tests/smoke.rs

@@ -1,17 +1,8 @@
-use std::time::{Duration, Instant};
-
-use futures::future::poll_fn;
-use futures_timer::{Delay, Timer};
-
 use std::error::Error;
 use std::pin::Pin;
-use std::task::Poll;
-
-use futures::prelude::*;
+use std::time::{Duration, Instant};
 
-fn far_future() -> Instant {
-    Instant::now() + Duration::new(5000, 0)
-}
+use futures_timer::Delay;
 
 #[runtime::test]
 async fn works() {
@@ -21,59 +12,20 @@ async fn works() {
     assert!(i.elapsed() > dur);
 }
 
-#[runtime::test]
-async fn error_after_inert() {
-    let t = Timer::new();
-    let handle = t.handle();
-    drop(t);
-    let res = Delay::new_handle(far_future(), handle).await;
-    assert!(res.is_err());
-}
-
-#[runtime::test]
-async fn drop_makes_inert() {
-    let t = Timer::new();
-    let handle = t.handle();
-    let timeout = Delay::new_handle(far_future(), handle);
-    drop(t);
-    let res = timeout.await;
-    assert!(res.is_err());
-}
-
 #[runtime::test]
 async fn reset() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
     let i = Instant::now();
     let dur = Duration::from_millis(100);
     let mut d = Delay::new(dur);
 
     // Allow us to re-use a future
-    Pin::new(&mut d).await?;
+    Pin::new(&mut d).await;
 
     assert!(i.elapsed() > dur);
 
     let i = Instant::now();
     d.reset(dur);
-    d.await?;
+    d.await;
     assert!(i.elapsed() > dur);
     Ok(())
 }
-
-#[runtime::test]
-async fn drop_timer_wakes() {
-    let t = Timer::new();
-    let handle = t.handle();
-    let mut timeout = Delay::new_handle(far_future(), handle);
-    let mut t = Some(t);
-    let f = poll_fn(move |cx| {
-        let timeout = unsafe { Pin::new_unchecked(&mut timeout) };
-        match TryFuture::try_poll(timeout, cx) {
-            Poll::Pending => {}
-            other => return other,
-        }
-        drop(t.take());
-        Poll::Pending
-    });
-
-    let res = f.await;
-    assert_eq!("timer has gone away", res.unwrap_err().description());
-}

tests/timeout.rs

@@ -7,15 +7,15 @@ use futures_timer::Delay;
 async fn smoke() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
     let dur = Duration::from_millis(10);
     let start = Instant::now();
-    Delay::new(dur).await?;
+    Delay::new(dur).await;
     assert!(start.elapsed() >= (dur / 2));
     Ok(())
 }
 
 #[runtime::test]
 async fn two() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
     let dur = Duration::from_millis(10);
-    Delay::new(dur).await?;
-    Delay::new(dur).await?;
+    Delay::new(dur).await;
+    Delay::new(dur).await;
     Ok(())
 }