hmmmmm two tests are failing... handshake and get_with_204_response

src/proto/connection.rs

@@ -206,7 +206,7 @@ impl<T, P, B> Stream for Connection<T, P, B>
 
     fn poll(&mut self) -> Poll<Option<Self::Item>, ConnectionError> {
         use frame::Frame::*;
-        trace!("Connection::poll");
+        trace!("poll");
 
         loop {
             let frame = match try!(self.inner.poll()) {
@@ -215,7 +215,7 @@ impl<T, P, B> Stream for Connection<T, P, B>
                     // Receiving new frames may depend on ensuring that the write buffer
                     // is clear (e.g. if window updates need to be sent), so `poll_ready`
                     // is called here. 
-                    try_ready!(self.poll_ready());
+                    try_ready!(self.inner.poll_complete());
 
                     // If the snder sink is ready, we attempt to poll the underlying
                     // stream once more because it, may have been made ready by flushing
@@ -224,7 +224,7 @@ impl<T, P, B> Stream for Connection<T, P, B>
                 }
             };
 
-            trace!("received; frame={:?}", frame);
+            trace!("poll; frame={:?}", frame);
             let frame = match frame {
                 Some(Headers(v)) => {
                     // TODO: Update stream state
@@ -304,12 +304,11 @@ impl<T, P, B> Sink for Connection<T, P, B>
         -> StartSend<Self::SinkItem, Self::SinkError>
     {
         use frame::Frame::Headers;
-        trace!("Connection::start_send");
+        trace!("start_send");
 
-        // First ensure that the upstream can process a new item. This ensures, for
+        // Ensure that a pending window update is sent before doing anything further.
-        // instance, that any pending local window updates have been sent to the remote
+        if self.poll_send_window_update()? == Async::NotReady
-        // before sending any other (i.e. DATA) frames.
+        || self.inner.poll_ready()? == Async::NotReady {
-        if try!(self.poll_ready()).is_not_ready() {
             return Ok(AsyncSink::NotReady(item));
         }
         assert!(self.pending_send_window_update.is_none());
@@ -394,7 +393,7 @@ impl<T, P, B> Sink for Connection<T, P, B>
     }
 
     fn poll_complete(&mut self) -> Poll<(), ConnectionError> {
-        trace!("Connection::poll_complete");
+        trace!("poll_complete");
         try_ready!(self.inner.poll_complete());
         self.poll_send_window_update()
     }
@@ -406,7 +405,7 @@ impl<T, P, B> ReadySink for Connection<T, P, B>
           B: IntoBuf,
 {
     fn poll_ready(&mut self) -> Poll<(), Self::SinkError> {
-        trace!("Connection::poll_ready");
+        trace!("poll_ready");
         try_ready!(self.inner.poll_ready());
         self.poll_send_window_update()
     }

src/proto/settings.rs

@@ -66,6 +66,7 @@ impl<T, U> Settings<T>
     }
 
     fn try_send_pending(&mut self) -> Poll<(), ConnectionError> {
+        trace!("try_send_pending; dirty={} acks={}", self.is_dirty, self.remaining_acks);
         if self.is_dirty {
             let frame = frame::Settings::new(self.local.clone());
             try_ready!(self.try_send(frame));
@@ -84,15 +85,13 @@ impl<T, U> Settings<T>
     }
 
     fn try_send(&mut self, item: frame::Settings) -> Poll<(), ConnectionError> {
-        if let AsyncSink::NotReady(_) = try!(self.inner.start_send(item.into())) {
+        trace!("try_send");
-            // TODO: I don't think this is needed actually... It was originally
+        if self.inner.start_send(item.into())?.is_ready() {
-            // done to "satisfy the start_send" contract...
+            Ok(Async::Ready(()))
-            try!(self.inner.poll_complete());
+        } else {
-
+            Ok(Async::NotReady)
-            return Ok(Async::NotReady);
         }
 
-        Ok(Async::Ready(()))
     }
 }
 
@@ -146,7 +145,7 @@ impl<T, U> Sink for Settings<T>
     }
 
     fn poll_complete(&mut self) -> Poll<(), ConnectionError> {
-        trace!("Settings::poll_complete");
+        trace!("poll_complete");
         try_ready!(self.try_send_pending());
         self.inner.poll_complete()
     }
@@ -162,11 +161,9 @@ impl<T, U> ReadySink for Settings<T>
           T: ReadySink,
 {
     fn poll_ready(&mut self) -> Poll<(), ConnectionError> {
-        if try!(self.try_send_pending()).is_ready() {
+        trace!("poll_ready");
-            return self.inner.poll_ready();
+        try_ready!(self.try_send_pending());
-        }
+        self.inner.poll_ready()
-
-        Ok(Async::NotReady)
     }
 }