Updated to use new upstream tokio-io.

Author: illegalprime

Cargo.toml

@@ -33,8 +33,7 @@ bytes = { version = "^0.4", optional = true }
 native-tls = { version = "^0.1.2", optional = true }
 
 [replace."tokio-io:0.1.1"]
-git = "https://github.com/illegalprime/tokio-io.git"
-rev = "18be60c56b0e932265a9e0301d14d5084577ca33"
+git = "https://github.com/tokio-rs/tokio-io.git"
 
 [features]
 default = ["ssl", "async", "async-ssl"]

src/client/builder.rs

@@ -31,6 +31,7 @@ use super::Client;
 #[cfg(feature="async")]
 mod async_imports {
 	pub use super::super::async;
+	pub use tokio_io::codec::Framed;
 	pub use tokio_core::net::TcpStreamNew;
 	pub use tokio_core::reactor::Handle;
 	pub use futures::{Future, Sink};
@@ -576,8 +577,7 @@ impl<'u> ClientBuilder<'u> {
           // output the final client and metadata
           .map(|(message, stream)| {
               let codec = MessageCodec::default(Context::Client);
-              let (client, buffer) = stream.into_parts();
-              let client = ::tokio_io::codec::framed_with_buf(client, codec, buffer);
+              let client = Framed::from_parts(stream.into_parts(), codec);
               (client, message.headers)
           });
 

src/server/upgrade/async.rs

@@ -1,5 +1,6 @@
 use super::{Buffer, HyperIntoWsError, WsUpgrade, Request, validate};
 use std::io::{self, ErrorKind};
+use tokio_io::codec::FramedParts;
 use hyper::header::Headers;
 use stream::AsyncStream;
 use futures::{Stream, Future};
@@ -56,21 +57,21 @@ impl<S> AsyncIntoWs for S
 		let future = self.framed(HttpServerCodec)
           .into_future()
           .map_err(|(e, s)| {
-              let (stream, buffer) = s.into_parts();
-              (stream, None, Some(buffer), e.into())
+              let FramedParts { inner, readbuf, .. } = s.into_parts();
+              (inner, None, Some(readbuf), e.into())
           })
           .and_then(|(m, s)| {
-              let (stream, buffer) = s.into_parts();
+              let FramedParts { inner, readbuf, .. } = s.into_parts();
               if let Some(msg) = m {
                   match validate(&msg.subject.0, &msg.version, &msg.headers) {
-                      Ok(()) => Ok((msg, stream, buffer)),
-                      Err(e) => Err((stream, None, Some(buffer), e)),
+                      Ok(()) => Ok((msg, inner, readbuf)),
+                      Err(e) => Err((inner, None, Some(readbuf), e)),
                   }
               } else {
                   let err = HyperIntoWsError::Io(io::Error::new(
                       ErrorKind::ConnectionReset,
                   "Connection dropped before handshake could be read"));
-                  Err((stream, None, Some(buffer), err))
+                  Err((inner, None, Some(readbuf), err))
               }
           })
           .map(|(m, stream, buffer)| {