refactor(client): use HttpMessage in Request and Response

BREAKING CHANGE: `hyper::client::request::Response` is no longer generic
over `NetworkStream` types. It no longer requires a generic type
parameter at all.

src/client/request.rs

@@ -1,18 +1,19 @@
 //! Client Requests
 use std::marker::PhantomData;
-use std::io::{self, Write, BufWriter};
+use std::io::{self, Write};
 
 use url::Url;
 
 use method::{self, Method};
 use header::Headers;
-use header::{self, Host};
+use header::Host;
 use net::{NetworkStream, NetworkConnector, HttpConnector, Fresh, Streaming};
-use http::{HttpWriter, LINE_ENDING};
-use http::HttpWriter::{ThroughWriter, ChunkedWriter, SizedWriter, EmptyWriter};
 use version;
 use client::{Response, get_host_and_port};
 
+use message::{HttpMessage, RequestHead};
+use http11::Http11Message;
+
 
 /// A client request to a remote server.
 /// The W type tracks the state of the request, Fresh vs Streaming.
@@ -23,7 +24,7 @@ pub struct Request<W> {
     /// The HTTP version of this request.
     pub version: version::HttpVersion,
 
-    body: HttpWriter<BufWriter<Box<NetworkStream + Send>>>,
+    message: Box<HttpMessage>,
     headers: Headers,
     method: method::Method,
 
@@ -41,6 +42,28 @@ impl<W> Request<W> {
 }
 
 impl Request<Fresh> {
+    /// Create a new `Request<Fresh>` that will use the given `HttpMessage` for its communication
+    /// with the server. This implies that the given `HttpMessage` instance has already been
+    /// properly initialized by the caller (e.g. a TCP connection's already established).
+    pub fn with_message(method: method::Method, url: Url, message: Box<HttpMessage>)
+            -> ::Result<Request<Fresh>> {
+        let (host, port) = try!(get_host_and_port(&url));
+        let mut headers = Headers::new();
+        headers.set(Host {
+            hostname: host,
+            port: Some(port),
+        });
+
+        Ok(Request {
+            method: method,
+            headers: headers,
+            url: url,
+            version: version::HttpVersion::Http11,
+            message: message,
+            _marker: PhantomData,
+        })
+    }
+
     /// Create a new client request.
     pub fn new(method: method::Method, url: Url) -> ::Result<Request<Fresh>> {
         let mut conn = HttpConnector(None);
@@ -53,92 +76,26 @@ impl Request<Fresh> {
         C: NetworkConnector<Stream=S>,
         S: Into<Box<NetworkStream + Send>> {
         let (host, port) = try!(get_host_and_port(&url));
-
         let stream = try!(connector.connect(&*host, port, &*url.scheme)).into();
-        let stream = ThroughWriter(BufWriter::new(stream));
 
-        let mut headers = Headers::new();
-        headers.set(Host {
-            hostname: host,
-            port: Some(port),
-        });
-
-        Ok(Request {
-            method: method,
-            headers: headers,
-            url: url,
-            version: version::HttpVersion::Http11,
-            body: stream,
-            _marker: PhantomData,
-        })
+        Request::with_message(method, url, Box::new(Http11Message::with_stream(stream)))
     }
 
     /// Consume a Fresh Request, writing the headers and method,
     /// returning a Streaming Request.
     pub fn start(mut self) -> ::Result<Request<Streaming>> {
-        let mut uri = self.url.serialize_path().unwrap();
-        if let Some(ref q) = self.url.query {
-            uri.push('?');
-            uri.push_str(&q[..]);
-        }
-
-        debug!("request line: {:?} {:?} {:?}", self.method, uri, self.version);
-        try!(write!(&mut self.body, "{} {} {}{}",
-                    self.method, uri, self.version, LINE_ENDING));
-
-
-        let stream = match self.method {
-            Method::Get | Method::Head => {
-                debug!("headers={:?}", self.headers);
-                try!(write!(&mut self.body, "{}{}", self.headers, LINE_ENDING));
-                EmptyWriter(self.body.into_inner())
-            },
-            _ => {
-                let mut chunked = true;
-                let mut len = 0;
-
-                match self.headers.get::<header::ContentLength>() {
-                    Some(cl) => {
-                        chunked = false;
-                        len = **cl;
-                    },
-                    None => ()
-                };
-
-                // can't do in match above, thanks borrowck
-                if chunked {
-                    let encodings = match self.headers.get_mut::<header::TransferEncoding>() {
-                        Some(&mut header::TransferEncoding(ref mut encodings)) => {
-                            //TODO: check if chunked is already in encodings. use HashSet?
-                            encodings.push(header::Encoding::Chunked);
-                            false
-                        },
-                        None => true
-                    };
-
-                    if encodings {
-                        self.headers.set::<header::TransferEncoding>(
-                            header::TransferEncoding(vec![header::Encoding::Chunked]))
-                    }
-                }
-
-                debug!("headers={:?}", self.headers);
-                try!(write!(&mut self.body, "{}{}", self.headers, LINE_ENDING));
-
-                if chunked {
-                    ChunkedWriter(self.body.into_inner())
-                } else {
-                    SizedWriter(self.body.into_inner(), len)
-                }
-            }
-        };
+        let head = try!(self.message.set_outgoing(RequestHead {
+            headers: self.headers,
+            method: self.method,
+            url: self.url,
+        }));
 
         Ok(Request {
-            method: self.method,
-            headers: self.headers,
-            url: self.url,
+            method: head.method,
+            headers: head.headers,
+            url: head.url,
             version: self.version,
-            body: stream,
+            message: self.message,
             _marker: PhantomData,
         })
     }
@@ -153,20 +110,19 @@ impl Request<Streaming> {
     ///
     /// Consumes the Request.
     pub fn send(self) -> ::Result<Response> {
-        let raw = try!(self.body.end()).into_inner().unwrap(); // end() already flushes
-        Response::new(raw)
+        Response::with_message(self.message)
     }
 }
 
 impl Write for Request<Streaming> {
     #[inline]
     fn write(&mut self, msg: &[u8]) -> io::Result<usize> {
-        self.body.write(msg)
+        self.message.write(msg)
     }
 
     #[inline]
     fn flush(&mut self) -> io::Result<()> {
-        self.body.flush()
+        self.message.flush()
     }
 }
 
@@ -180,11 +136,15 @@ mod tests {
     use header::{ContentLength,TransferEncoding,Encoding};
     use url::form_urlencoded;
     use super::Request;
+    use http11::Http11Message;
 
     fn run_request(req: Request<Fresh>) -> Vec<u8> {
         let req = req.start().unwrap();
-        let stream = *req.body.end().unwrap()
-            .into_inner().unwrap().downcast::<MockStream>().ok().unwrap();
+        let message = req.message;
+        let mut message = message.downcast::<Http11Message>().ok().unwrap();
+        message.flush_outgoing().unwrap();
+        let stream = *message
+            .into_inner().downcast::<MockStream>().ok().unwrap();
         stream.write
     }