fix(http1): poll_loop writes when ready

Author: lthiery

src/proto/h1/dispatch.rs

@@ -171,8 +171,13 @@ where
         for _ in 0..16 {
             let _ = self.poll_read(cx)?;
             let _ = self.poll_write(cx)?;
-            let _ = self.poll_flush(cx)?;
+            let conn_ready = self.poll_flush(cx)?.is_ready();
 
+            // If we can write more body and the connection is ready, we should
+            // write again. If we return `Ready(Ok(())` here, we will yield
+            // without a guaranteed wakeup from the write side of the connection.
+            // This would lead to a deadlock if we also don't expect reads.
+            let wants_write_again = self.can_write_again() && conn_ready;
             // This could happen if reading paused before blocking on IO,
             // such as getting to the end of a framed message, but then
             // writing/flushing set the state back to Init. In that case,
@@ -181,7 +186,10 @@ where
             //
             // Using this instead of task::current() and notify() inside
             // the Conn is noticeably faster in pipelined benchmarks.
-            if !self.conn.wants_read_again() {
+            let wants_read_again = self.conn.wants_read_again();
+            // If we cannot write or read again, we yield and rely on the
+            // wakeup from the connection futures.
+            if !(wants_write_again || wants_read_again) {
                 //break;
                 return Poll::Ready(Ok(()));
             }
@@ -433,6 +441,11 @@ where
         self.conn.close_write();
     }
 
+    /// If there is pending data in body_rx, we can make progress writing if the connection is ready.
+    fn can_write_again(&mut self) -> bool {
+        self.body_rx.is_some()
+    }
+
     fn is_done(&self) -> bool {
         if self.is_closing {
             return true;