timer: Reduce size of Delay struct (#554)

* Remove `counted` field on `timer::Entry`.

It turns out that a better indicator of whether or not the number of
active timeouts should be decremented is if the `Entry` has been
associated with a timer. In other words, if `Entry::inner` can be
upgraded, then the count should be decremented on drop.

* timer: Tweak link between `Delay` and the driver

This tweaks the struct layout / details regarding how a `Delay` instance
is linked to a driver (timer instance). Instead of lazily allocating the
`Entry` (node shared between `Delay` and the timer), `Entry` is
allocated immediately when `Delay` is created. This allows using the
entry store data used by `Delay`.

This is in anticipation of further timer improvements that would
otherwise require the size of `Delay` to grow further. Since an
allocation is already made, the idea is to shrink the size of the
`Delay` struct.

tokio-timer/src/delay.rs

@@ -1,5 +1,5 @@
 use Error;
-use timer::Registration;
+use timer::{Registration, HandlePriv};
 
 use futures::{Future, Poll};
 
@@ -16,19 +16,10 @@ use std::time::Instant;
 /// [`new`]: #method.new
 #[derive(Debug)]
 pub struct Delay {
-    /// The instant at which the future completes.
-    deadline: Instant,
-
     /// The link between the `Delay` instance at the timer that drives it.
     ///
-    /// When `Delay` is created with `new`, this is initialized to `None` and is
-    /// lazily set in `poll`. When `poll` is called, the default for the current
-    /// execution context is used (obtained via `Handle::current`).
-    ///
-    /// When `delay` is created with `new_with_registration`, the value is set.
-    ///
-    /// Once `registration` is set to `Some`, it is never changed.
-    registration: Option<Registration>,
+    /// This also stores the `deadline` value.
+    registration: Registration,
 }
 
 impl Delay {
@@ -38,34 +29,28 @@ impl Delay {
     /// as to how the sub-millisecond portion of `deadline` will be handled.
     /// `Delay` should not be used for high-resolution timer use cases.
     pub fn new(deadline: Instant) -> Delay {
-        Delay {
-            deadline,
-            registration: None,
-        }
+        let registration = Registration::new(deadline);
+
+        Delay { registration }
     }
 
-    pub(crate) fn new_with_registration(
-        deadline: Instant,
-        registration: Registration) -> Delay
-    {
-        Delay {
-            deadline,
-            registration: Some(registration),
-        }
+    pub(crate) fn new_with_handle(deadline: Instant, handle: HandlePriv) -> Delay {
+        let mut registration = Registration::new(deadline);
+        registration.register_with(handle);
+
+        Delay { registration }
     }
 
     /// Returns the instant at which the future will complete.
     pub fn deadline(&self) -> Instant {
-        self.deadline
+        self.registration.deadline()
     }
 
     /// Returns true if the `Delay` has elapsed
     ///
     /// A `Delay` is elapsed when the requested duration has elapsed.
     pub fn is_elapsed(&self) -> bool {
-        self.registration.as_ref()
-            .map(|r| r.is_elapsed())
-            .unwrap_or(false)
+        self.registration.is_elapsed()
     }
 
     /// Reset the `Delay` instance to a new deadline.
@@ -76,21 +61,13 @@ impl Delay {
     /// This function can be called both before and after the future has
     /// completed.
     pub fn reset(&mut self, deadline: Instant) {
-        self.deadline = deadline;
-
-        if let Some(registration) = self.registration.as_ref() {
-            registration.reset(deadline);
-        }
+        self.registration.reset(deadline);
     }
 
     /// Register the delay with the timer instance for the current execution
     /// context.
     fn register(&mut self) {
-        if self.registration.is_some() {
-            return;
-        }
-
-        self.registration = Some(Registration::new(self.deadline));
+        self.registration.register();
     }
 }
 
@@ -102,7 +79,6 @@ impl Future for Delay {
         // Ensure the `Delay` instance is associated with a timer.
         self.register();
 
-        self.registration.as_ref().unwrap()
-            .poll_elapsed()
+        self.registration.poll_elapsed()
     }
 }