flush is useless

src/pipeline.rs

@@ -575,16 +575,6 @@ impl<S: 'static, H> ProcessResponse<S, H> {
         if self.running == RunningState::Paused || self.drain.is_some() {
             match io.poll_completed(false) {
                 Ok(Async::Ready(_)) => {
-                    match io.flush() {
-                        Ok(Async::Ready(_)) => (),
-                        Ok(Async::NotReady) => return Err(PipelineState::Response(self)),
-                        Err(err) => {
-                            debug!("Error sending data: {}", err);
-                            info.error = Some(err.into());
-                            return Ok(FinishingMiddlewares::init(info, self.resp))
-                        }
-                    }
-
                     self.running.resume();
 
                     // resolve drain futures

src/server/encoding.rs

@@ -535,14 +535,10 @@ impl ContentEncoder {
     #[inline]
     pub fn is_eof(&self) -> bool {
         match *self {
-            ContentEncoder::Br(ref encoder) =>
+            ContentEncoder::Br(ref encoder) => encoder.get_ref().is_eof(),
-                encoder.get_ref().is_eof(),
+            ContentEncoder::Deflate(ref encoder) => encoder.get_ref().is_eof(),
-            ContentEncoder::Deflate(ref encoder) =>
+            ContentEncoder::Gzip(ref encoder) => encoder.get_ref().is_eof(),
-                encoder.get_ref().is_eof(),
+            ContentEncoder::Identity(ref encoder) => encoder.is_eof(),
-            ContentEncoder::Gzip(ref encoder) =>
-                encoder.get_ref().is_eof(),
-            ContentEncoder::Identity(ref encoder) =>
-                encoder.is_eof(),
         }
     }
 
@@ -710,6 +706,7 @@ impl TransferEncoding {
                     let mut buf = BytesMut::new();
                     write!(&mut buf, "{:X}\r\n", msg.len())
                         .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
+                    self.buffer.reserve(buf.len() + msg.len() + 2);
                     self.buffer.extend(buf.into());
                     self.buffer.extend(msg);
                     self.buffer.extend_from_slice(b"\r\n");

src/server/h1writer.rs

@@ -66,6 +66,10 @@ impl<T: AsyncWrite> H1Writer<T> {
     fn write_to_stream(&mut self) -> io::Result<WriterState> {
         while !self.buffer.is_empty() {
             match self.stream.write(self.buffer.as_ref()) {
+                Ok(0) => {
+                    self.disconnected();
+                    return Ok(WriterState::Done);
+                },
                 Ok(n) => {
                     let _ = self.buffer.split_to(n);
                 },
@@ -90,20 +94,6 @@ impl<T: AsyncWrite> Writer for H1Writer<T> {
         self.written
     }
 
-    #[inline]
-    fn flush(&mut self) -> Poll<(), io::Error> {
-        match self.stream.flush() {
-            Ok(_) => Ok(Async::Ready(())),
-            Err(e) => {
-                if e.kind() == io::ErrorKind::WouldBlock {
-                    Ok(Async::NotReady)
-                } else {
-                    Err(e)
-                }
-            }
-        }
-    }
-
     fn start(&mut self, req: &mut HttpMessage, msg: &mut HttpResponse) -> io::Result<WriterState> {
         // prepare task
         self.flags.insert(Flags::STARTED);

src/server/h2writer.rs

@@ -108,11 +108,6 @@ impl Writer for H2Writer {
         self.written
     }
 
-    #[inline]
-    fn flush(&mut self) -> Poll<(), io::Error> {
-        Ok(Async::Ready(()))
-    }
-
     fn start(&mut self, req: &mut HttpMessage, msg: &mut HttpResponse) -> io::Result<WriterState> {
         // prepare response
         self.flags.insert(Flags::STARTED);

src/server/mod.rs

@@ -104,8 +104,6 @@ pub trait Writer {
 
     fn write_eof(&mut self) -> io::Result<WriterState>;
 
-    fn flush(&mut self) -> Poll<(), io::Error>;
-
     fn poll_completed(&mut self, shutdown: bool) -> Poll<(), io::Error>;
 }
 

src/server/shared.rs

@@ -90,6 +90,11 @@ impl SharedBytes {
         self.get_mut().take()
     }
 
+    #[inline]
+    pub fn reserve(&self, cnt: usize) {
+        self.get_mut().reserve(cnt)
+    }
+
     #[inline]
     #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
     pub fn extend(&self, data: Binary) {