perf(server): dont record Idle time when not needed

src/http/conn.rs

@@ -1,7 +1,6 @@
 use std::fmt;
 use std::io::{self, Write};
 use std::marker::PhantomData;
-use std::time::Instant;
 
 use futures::{Poll, Async, AsyncSink, Stream, Sink, StartSend};
 use futures::task::Task;
@@ -228,10 +227,7 @@ where I: AsyncRead + AsyncWrite,
 
         let wants_keep_alive = head.should_keep_alive();
         self.state.keep_alive &= wants_keep_alive;
-        let mut buf = Vec::new();
-        let encoder = T::encode(head, &mut buf);
-        //TODO: handle when there isn't enough room to buffer the head
-        assert!(self.io.buffer(buf) > 0);
+        let encoder = T::encode(head, self.io.write_buf_mut());
         self.state.writing = if body {
             Writing::Body(encoder, None)
         } else {
@@ -534,7 +530,7 @@ pub trait KeepAlive: fmt::Debug + ::std::ops::BitAndAssign<bool> {
 
 #[derive(Clone, Copy, Debug)]
 pub enum KA {
-    Idle(Instant),
+    Idle,
     Busy,
     Disabled,
 }
@@ -547,7 +543,7 @@ impl Default for KA {
 
 impl KeepAlive for KA {
     fn idle(&mut self) {
-        *self = KA::Idle(Instant::now());
+        *self = KA::Idle;
     }
 
     fn busy(&mut self) {
@@ -595,7 +591,7 @@ impl<B, K: KeepAlive> State<B, K> {
     }
 
     fn is_idle(&self) -> bool {
-        if let KA::Idle(..) = self.keep_alive.status() {
+        if let KA::Idle = self.keep_alive.status() {
             true
         } else {
             false

src/http/io.rs

@@ -42,6 +42,12 @@ impl<T: AsyncRead + AsyncWrite> Buffered<T> {
         self.read_buf.as_ref()
     }
 
+    pub fn write_buf_mut(&mut self) -> &mut Vec<u8> {
+        self.write_buf.maybe_reset();
+        self.write_buf.maybe_reserve(0);
+        &mut self.write_buf.0.bytes
+    }
+
     pub fn consume_leading_lines(&mut self) {
         if !self.read_buf.is_empty() {
             let mut i = 0;
@@ -133,7 +139,7 @@ impl<T: Write> Write for Buffered<T> {
         } else {
             loop {
                 let n = try!(self.write_buf.write_into(&mut self.io));
-                debug!("flushed {} bytes", n);
+                trace!("flushed {} bytes", n);
                 if self.write_buf.remaining() == 0 {
                     break;
                 }