Hoist creation of transport parameters out of TLS code

src/client.rs

@@ -2,6 +2,7 @@ use futures::{Async, Future, Poll};
 
 use super::{QuicError, QuicResult};
 use endpoint::Endpoint;
+use parameters::ClientTransportParameters;
 use tls;
 use types::Side;
 
@@ -18,7 +19,7 @@ pub struct Client {
 
 impl Client {
     pub fn connect(server: &str, port: u16) -> QuicResult<ClientFuture> {
-        let tls = tls::client_session(None, server)?;
+        let tls = tls::client_session(None, server, &ClientTransportParameters::default())?;
         let endpoint = Endpoint::new(tls, Side::Client, None);
         connect(endpoint, server, port)
     }

src/server.rs

@@ -4,6 +4,7 @@ use super::{QuicError, QuicResult};
 use crypto::Secret;
 use endpoint::Endpoint;
 use packet::{LongType, Packet};
+use parameters::ServerTransportParameters;
 use tls;
 use types::{ConnectionId, Side};
 
@@ -54,7 +55,7 @@ impl Future for Server {
 
             let cid = if partial.header.ptype() == Some(LongType::Initial) {
                 let mut endpoint = Endpoint::new(
-                    tls::server_session(&self.tls_config),
+                    tls::server_session(&self.tls_config, &ServerTransportParameters::default()),
                     Side::Server,
                     Some(Secret::Handshake(dst_cid)),
                 );

src/tests.rs

@@ -13,6 +13,7 @@ use client;
 use crypto::Secret;
 use endpoint::Endpoint;
 use packet::Packet;
+use parameters::{ClientTransportParameters, ServerTransportParameters};
 use server::Server;
 use tls;
 use types::{ConnectionId, Side};
@@ -85,7 +86,10 @@ fn test_handshake() {
 
 fn server_endpoint(hs_cid: ConnectionId) -> Endpoint<tls::ServerSession> {
     Endpoint::new(
-        tls::server_session(&Arc::new(build_server_config())),
+        tls::server_session(
+            &Arc::new(build_server_config()),
+            &ServerTransportParameters::default(),
+        ),
         Side::Server,
         Some(Secret::Handshake(hs_cid)),
     )
@@ -117,7 +121,11 @@ fn client_endpoint() -> Endpoint<tls::ClientSession> {
             webpki::trust_anchor_util::cert_der_as_trust_anchor(Input::from(&bytes)).unwrap();
         let anchor_vec = vec![anchor];
         let config = tls::build_client_config(Some(&webpki::TLSServerTrustAnchors(&anchor_vec)));
-        tls::client_session(Some(config), "localhost").unwrap()
+        tls::client_session(
+            Some(config),
+            "localhost",
+            &ClientTransportParameters::default(),
+        ).unwrap()
     };
 
     Endpoint::new(tls, Side::Client, None)

src/tls.rs

@@ -14,13 +14,17 @@ use webpki_roots;
 
 pub use rustls::{Certificate, ClientSession, PrivateKey, ServerConfig, ServerSession, Session};
 
-pub fn client_session(config: Option<ClientConfig>, hostname: &str) -> QuicResult<ClientSession> {
+pub fn client_session(
+    config: Option<ClientConfig>,
+    hostname: &str,
+    params: &ClientTransportParameters,
+) -> QuicResult<ClientSession> {
     let pki_server_name = DNSNameRef::try_from_ascii_str(hostname)
         .map_err(|_| QuicError::InvalidDnsName(hostname.into()))?;
     Ok(ClientSession::new_quic(
         &Arc::new(config.unwrap_or(build_client_config(None))),
         pki_server_name,
-        to_vec(ClientTransportParameters::default()),
+        to_vec(params),
     ))
 }
 
@@ -33,8 +37,11 @@ pub fn build_client_config(anchors: Option<&TLSServerTrustAnchors>) -> ClientCon
     config
 }
 
-pub fn server_session(config: &Arc<ServerConfig>) -> ServerSession {
-    ServerSession::new_quic(config, to_vec(ServerTransportParameters::default()))
+pub fn server_session(
+    config: &Arc<ServerConfig>,
+    params: &ServerTransportParameters,
+) -> ServerSession {
+    ServerSession::new_quic(config, to_vec(params))
 }
 
 pub fn build_server_config(cert_chain: Vec<Certificate>, key: PrivateKey) -> ServerConfig {
@@ -93,7 +100,7 @@ where
 
 type TlsResult = (Vec<u8>, Option<Secret>);
 
-fn to_vec<T: Codec>(val: T) -> Vec<u8> {
+fn to_vec<T: Codec>(val: &T) -> Vec<u8> {
     let mut bytes = Vec::new();
     val.encode(&mut bytes);
     bytes