diff --git a/jetty-client/src/main/java/org/eclipse/jetty/client/AbstractHttpClientTransport.java b/jetty-client/src/main/java/org/eclipse/jetty/client/AbstractHttpClientTransport.java
index 46cf76a..fac4bcf 100644
--- a/jetty-client/src/main/java/org/eclipse/jetty/client/AbstractHttpClientTransport.java
+++ b/jetty-client/src/main/java/org/eclipse/jetty/client/AbstractHttpClientTransport.java
@@ -19,24 +19,20 @@
 package org.eclipse.jetty.client;
 
 import java.io.IOException;
-import java.net.ConnectException;
 import java.net.SocketAddress;
-import java.net.SocketException;
 import java.nio.channels.SelectionKey;
 import java.nio.channels.SocketChannel;
-import javax.net.ssl.SSLEngine;
+import java.util.Map;
 
-import org.eclipse.jetty.http.HttpScheme;
-import org.eclipse.jetty.io.Connection;
+import org.eclipse.jetty.client.api.Connection;
 import org.eclipse.jetty.io.EndPoint;
 import org.eclipse.jetty.io.SelectChannelEndPoint;
 import org.eclipse.jetty.io.SelectorManager;
-import org.eclipse.jetty.io.ssl.SslConnection;
+import org.eclipse.jetty.io.ssl.SslClientConnectionFactory;
 import org.eclipse.jetty.util.Promise;
 import org.eclipse.jetty.util.component.ContainerLifeCycle;
 import org.eclipse.jetty.util.log.Log;
 import org.eclipse.jetty.util.log.Logger;
-import org.eclipse.jetty.util.ssl.SslContextFactory;
 
 public abstract class AbstractHttpClientTransport extends ContainerLifeCycle implements HttpClientTransport
 {
@@ -72,12 +68,20 @@
     }
 
     @Override
-    public void connect(HttpDestination destination, SocketAddress address, Promise<org.eclipse.jetty.client.api.Connection> promise)
+    protected void doStop() throws Exception
+    {
+        super.doStop();
+        removeBean(selectorManager);
+    }
+
+    @Override
+    public void connect(SocketAddress address, Map<String, Object> context)
     {
         SocketChannel channel = null;
         try
         {
             channel = SocketChannel.open();
+            HttpDestination destination = (HttpDestination)context.get(HTTP_DESTINATION_CONTEXT_KEY);
             HttpClient client = destination.getHttpClient();
             SocketAddress bindAddress = client.getBindAddress();
             if (bindAddress != null)
@@ -86,8 +90,9 @@
             channel.configureBlocking(false);
             channel.connect(address);
 
-            ConnectionCallback callback = new ConnectionCallback(destination, promise);
-            selectorManager.connect(channel, callback);
+            context.put(SslClientConnectionFactory.SSL_PEER_HOST_CONTEXT_KEY, destination.getHost());
+            context.put(SslClientConnectionFactory.SSL_PEER_PORT_CONTEXT_KEY, destination.getPort());
+            selectorManager.connect(channel, context);
         }
         // Must catch all exceptions, since some like
         // UnresolvedAddressException are not IOExceptions.
@@ -104,12 +109,14 @@
             }
             finally
             {
+                @SuppressWarnings("unchecked")
+                Promise<Connection> promise = (Promise<Connection>)context.get(HTTP_CONNECTION_PROMISE_CONTEXT_KEY);
                 promise.failed(x);
             }
         }
     }
 
-    protected void configure(HttpClient client, SocketChannel channel) throws SocketException
+    protected void configure(HttpClient client, SocketChannel channel) throws IOException
     {
         channel.socket().setTcpNoDelay(client.isTCPNoDelay());
     }
@@ -119,40 +126,6 @@
         return new ClientSelectorManager(client, selectors);
     }
 
-    protected SslConnection createSslConnection(EndPoint endPoint, HttpDestination destination)
-    {
-        HttpClient httpClient = destination.getHttpClient();
-        SslContextFactory sslContextFactory = httpClient.getSslContextFactory();
-        SSLEngine engine = sslContextFactory.newSSLEngine(destination.getHost(), destination.getPort());
-        engine.setUseClientMode(true);
-
-        SslConnection sslConnection = newSslConnection(httpClient, endPoint, engine);
-        sslConnection.setRenegotiationAllowed(sslContextFactory.isRenegotiationAllowed());
-        endPoint.setConnection(sslConnection);
-        EndPoint appEndPoint = sslConnection.getDecryptedEndPoint();
-        Connection connection = newConnection(appEndPoint, destination);
-        appEndPoint.setConnection(connection);
-
-        return sslConnection;
-    }
-
-    protected SslConnection newSslConnection(HttpClient httpClient, EndPoint endPoint, SSLEngine engine)
-    {
-        return new SslConnection(httpClient.getByteBufferPool(), httpClient.getExecutor(), endPoint, engine);
-    }
-
-    protected abstract Connection newConnection(EndPoint endPoint, HttpDestination destination);
-
-    protected org.eclipse.jetty.client.api.Connection tunnel(EndPoint endPoint, HttpDestination destination, org.eclipse.jetty.client.api.Connection connection)
-    {
-        SslConnection sslConnection = createSslConnection(endPoint, destination);
-        Connection result = sslConnection.getDecryptedEndPoint().getConnection();
-        selectorManager.connectionClosed((Connection)connection);
-        selectorManager.connectionOpened(sslConnection);
-        LOG.debug("Tunnelled {} over {}", connection, result);
-        return (org.eclipse.jetty.client.api.Connection)result;
-    }
-
     protected class ClientSelectorManager extends SelectorManager
     {
         private final HttpClient client;
@@ -170,63 +143,21 @@
         }
 
         @Override
-        public Connection newConnection(SocketChannel channel, EndPoint endPoint, Object attachment) throws IOException
+        public org.eclipse.jetty.io.Connection newConnection(SocketChannel channel, EndPoint endPoint, Object attachment) throws IOException
         {
-            ConnectionCallback callback = (ConnectionCallback)attachment;
-            HttpDestination destination = callback.destination;
-
-            SslContextFactory sslContextFactory = client.getSslContextFactory();
-            if (!destination.isProxied() && HttpScheme.HTTPS.is(destination.getScheme()))
-            {
-                if (sslContextFactory == null)
-                {
-                    IOException failure = new ConnectException("Missing " + SslContextFactory.class.getSimpleName() + " for " + destination.getScheme() + " requests");
-                    callback.failed(failure);
-                    throw failure;
-                }
-                else
-                {
-                    SslConnection sslConnection = createSslConnection(endPoint, destination);
-                    callback.succeeded((org.eclipse.jetty.client.api.Connection)sslConnection.getDecryptedEndPoint().getConnection());
-                    return sslConnection;
-                }
-            }
-            else
-            {
-                Connection connection = AbstractHttpClientTransport.this.newConnection(endPoint, destination);
-                callback.succeeded((org.eclipse.jetty.client.api.Connection)connection);
-                return connection;
-            }
+            @SuppressWarnings("unchecked")
+            Map<String, Object> context = (Map<String, Object>)attachment;
+            HttpDestination destination = (HttpDestination)context.get(HTTP_DESTINATION_CONTEXT_KEY);
+            return destination.getClientConnectionFactory().newConnection(endPoint, context);
         }
 
         @Override
-        protected void connectionFailed(SocketChannel channel, Throwable ex, Object attachment)
+        protected void connectionFailed(SocketChannel channel, Throwable x, Object attachment)
         {
-            ConnectionCallback callback = (ConnectionCallback)attachment;
-            callback.failed(ex);
-        }
-    }
-
-    private class ConnectionCallback implements Promise<org.eclipse.jetty.client.api.Connection>
-    {
-        private final HttpDestination destination;
-        private final Promise<org.eclipse.jetty.client.api.Connection> promise;
-
-        private ConnectionCallback(HttpDestination destination, Promise<org.eclipse.jetty.client.api.Connection> promise)
-        {
-            this.destination = destination;
-            this.promise = promise;
-        }
-
-        @Override
-        public void succeeded(org.eclipse.jetty.client.api.Connection result)
-        {
-            promise.succeeded(result);
-        }
-
-        @Override
-        public void failed(Throwable x)
-        {
+            @SuppressWarnings("unchecked")
+            Map<String, Object> context = (Map<String, Object>)attachment;
+            @SuppressWarnings("unchecked")
+            Promise<Connection> promise = (Promise<Connection>)context.get(HTTP_CONNECTION_PROMISE_CONTEXT_KEY);
             promise.failed(x);
         }
     }
diff --git a/jetty-client/src/main/java/org/eclipse/jetty/client/AuthenticationProtocolHandler.java b/jetty-client/src/main/java/org/eclipse/jetty/client/AuthenticationProtocolHandler.java
index 7adcb80..b19c52c 100644
--- a/jetty-client/src/main/java/org/eclipse/jetty/client/AuthenticationProtocolHandler.java
+++ b/jetty-client/src/main/java/org/eclipse/jetty/client/AuthenticationProtocolHandler.java
@@ -109,16 +109,19 @@
                 return;
             }
 
-            URI uri = getAuthenticationURI(request);
             Authentication authentication = null;
             Authentication.HeaderInfo headerInfo = null;
-            for (Authentication.HeaderInfo element : headerInfos)
+            URI uri = getAuthenticationURI(request);
+            if (uri != null)
             {
-                authentication = client.getAuthenticationStore().findAuthentication(element.getType(), uri, element.getRealm());
-                if (authentication != null)
+                for (Authentication.HeaderInfo element : headerInfos)
                 {
-                    headerInfo = element;
-                    break;
+                    authentication = client.getAuthenticationStore().findAuthentication(element.getType(), uri, element.getRealm());
+                    if (authentication != null)
+                    {
+                        headerInfo = element;
+                        break;
+                    }
                 }
             }
             if (authentication == null)
diff --git a/jetty-client/src/main/java/org/eclipse/jetty/client/http/HttpConnectionPool.java b/jetty-client/src/main/java/org/eclipse/jetty/client/ConnectionPool.java
similarity index 95%
rename from jetty-client/src/main/java/org/eclipse/jetty/client/http/HttpConnectionPool.java
rename to jetty-client/src/main/java/org/eclipse/jetty/client/ConnectionPool.java
index a9d9841..9ed8d93 100644
--- a/jetty-client/src/main/java/org/eclipse/jetty/client/http/HttpConnectionPool.java
+++ b/jetty-client/src/main/java/org/eclipse/jetty/client/ConnectionPool.java
@@ -16,7 +16,7 @@
 //  ========================================================================
 //
 
-package org.eclipse.jetty.client.http;
+package org.eclipse.jetty.client;
 
 import java.io.IOException;
 import java.util.concurrent.BlockingDeque;
@@ -33,9 +33,9 @@
 import org.eclipse.jetty.util.log.Log;
 import org.eclipse.jetty.util.log.Logger;
 
-public class HttpConnectionPool implements Dumpable
+public class ConnectionPool implements Dumpable
 {
-    private static final Logger LOG = Log.getLogger(HttpConnectionPool.class);
+    private static final Logger LOG = Log.getLogger(ConnectionPool.class);
 
     private final AtomicInteger connectionCount = new AtomicInteger();
     private final Destination destination;
@@ -44,7 +44,7 @@
     private final BlockingDeque<Connection> idleConnections;
     private final BlockingQueue<Connection> activeConnections;
 
-    public HttpConnectionPool(Destination destination, int maxConnections, Promise<Connection> connectionPromise)
+    public ConnectionPool(Destination destination, int maxConnections, Promise<Connection> connectionPromise)
     {
         this.destination = destination;
         this.maxConnections = maxConnections;
diff --git a/jetty-client/src/main/java/org/eclipse/jetty/client/HttpClient.java b/jetty-client/src/main/java/org/eclipse/jetty/client/HttpClient.java
index ef1fc0f..cfabe91 100644
--- a/jetty-client/src/main/java/org/eclipse/jetty/client/HttpClient.java
+++ b/jetty-client/src/main/java/org/eclipse/jetty/client/HttpClient.java
@@ -27,10 +27,12 @@
 import java.nio.channels.SocketChannel;
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Locale;
+import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
@@ -44,7 +46,6 @@
 import org.eclipse.jetty.client.api.Connection;
 import org.eclipse.jetty.client.api.ContentResponse;
 import org.eclipse.jetty.client.api.Destination;
-import org.eclipse.jetty.client.api.ProxyConfiguration;
 import org.eclipse.jetty.client.api.Request;
 import org.eclipse.jetty.client.api.Response;
 import org.eclipse.jetty.client.http.HttpClientTransportOverHTTP;
@@ -57,7 +58,6 @@
 import org.eclipse.jetty.util.Jetty;
 import org.eclipse.jetty.util.Promise;
 import org.eclipse.jetty.util.SocketAddressResolver;
-import org.eclipse.jetty.util.URIUtil;
 import org.eclipse.jetty.util.component.ContainerLifeCycle;
 import org.eclipse.jetty.util.log.Log;
 import org.eclipse.jetty.util.log.Logger;
@@ -104,12 +104,13 @@
 {
     private static final Logger LOG = Log.getLogger(HttpClient.class);
 
-    private final ConcurrentMap<String, HttpDestination> destinations = new ConcurrentHashMap<>();
+    private final ConcurrentMap<Origin, HttpDestination> destinations = new ConcurrentHashMap<>();
     private final ConcurrentMap<Long, HttpConversation> conversations = new ConcurrentHashMap<>();
     private final List<ProtocolHandler> handlers = new ArrayList<>();
     private final List<Request.Listener> requestListeners = new ArrayList<>();
     private final AuthenticationStore authenticationStore = new HttpAuthenticationStore();
     private final Set<ContentDecoder.Factory> decoderFactories = new ContentDecoderFactorySet();
+    private final ProxyConfiguration proxyConfig = new ProxyConfiguration();
     private final HttpClientTransport transport;
     private final SslContextFactory sslContextFactory;
     private volatile CookieManager cookieManager;
@@ -132,7 +133,6 @@
     private volatile boolean tcpNoDelay = true;
     private volatile boolean dispatchIO = true;
     private volatile boolean strictEventOrdering = false;
-    private volatile ProxyConfiguration proxyConfig;
     private volatile HttpField encodingField;
 
     /**
@@ -359,7 +359,7 @@
      */
     public Request newRequest(String host, int port)
     {
-        return newRequest(address("http", host, port));
+        return newRequest(new Origin("http", host, port).asString());
     }
 
     /**
@@ -417,13 +417,6 @@
         return newRequest;
     }
 
-    public String address(String scheme, String host, int port)
-    {
-        StringBuilder result = new StringBuilder();
-        URIUtil.appendSchemeHostPort(result, scheme, host, port);
-        return result.toString();
-    }
-
     /**
      * Returns a {@link Destination} for the given scheme, host and port.
      * Applications may use {@link Destination}s to create {@link Connection}s
@@ -446,20 +439,20 @@
     {
         port = normalizePort(scheme, port);
 
-        String address = address(scheme, host, port);
-        HttpDestination destination = destinations.get(address);
+        Origin origin = new Origin(scheme, host, port);
+        HttpDestination destination = destinations.get(origin);
         if (destination == null)
         {
-            destination = transport.newHttpDestination(scheme, host, port);
+            destination = transport.newHttpDestination(origin);
             if (isRunning())
             {
-                HttpDestination existing = destinations.putIfAbsent(address, destination);
+                HttpDestination existing = destinations.putIfAbsent(origin, destination);
                 if (existing != null)
                     destination = existing;
                 else
                     LOG.debug("Created {}", destination);
                 if (!isRunning())
-                    destinations.remove(address);
+                    destinations.remove(origin);
             }
 
         }
@@ -486,13 +479,16 @@
 
     protected void newConnection(final HttpDestination destination, final Promise<Connection> promise)
     {
-        Destination.Address address = destination.getConnectAddress();
+        Origin.Address address = destination.getConnectAddress();
         resolver.resolve(address.getHost(), address.getPort(), new Promise<SocketAddress>()
         {
             @Override
             public void succeeded(SocketAddress socketAddress)
             {
-                transport.connect(destination, socketAddress, promise);
+                Map<String, Object> context = new HashMap<>();
+                context.put(HttpClientTransport.HTTP_DESTINATION_CONTEXT_KEY, destination);
+                context.put(HttpClientTransport.HTTP_CONNECTION_PROMISE_CONTEXT_KEY, promise);
+                transport.connect(socketAddress, context);
             }
 
             @Override
@@ -881,14 +877,6 @@
         return proxyConfig;
     }
 
-    /**
-     * @param proxyConfig the forward proxy configuration
-     */
-    public void setProxyConfiguration(ProxyConfiguration proxyConfig)
-    {
-        this.proxyConfig = proxyConfig;
-    }
-
     protected HttpField getAcceptEncodingField()
     {
         return encodingField;
diff --git a/jetty-client/src/main/java/org/eclipse/jetty/client/HttpClientTransport.java b/jetty-client/src/main/java/org/eclipse/jetty/client/HttpClientTransport.java
index de943a6..f6a21ef 100644
--- a/jetty-client/src/main/java/org/eclipse/jetty/client/HttpClientTransport.java
+++ b/jetty-client/src/main/java/org/eclipse/jetty/client/HttpClientTransport.java
@@ -19,9 +19,9 @@
 package org.eclipse.jetty.client;
 
 import java.net.SocketAddress;
+import java.util.Map;
 
-import org.eclipse.jetty.client.api.Connection;
-import org.eclipse.jetty.util.Promise;
+import org.eclipse.jetty.io.ClientConnectionFactory;
 
 /**
  * {@link HttpClientTransport} represents what transport implementations should provide
@@ -34,8 +34,11 @@
  * but the HTTP exchange may also be carried using the SPDY protocol or the FCGI protocol or, in future,
  * other protocols.
  */
-public interface HttpClientTransport
+public interface HttpClientTransport extends ClientConnectionFactory
 {
+    public static final String HTTP_DESTINATION_CONTEXT_KEY = "http.destination";
+    public static final String HTTP_CONNECTION_PROMISE_CONTEXT_KEY = "http.connection.promise";
+
     /**
      * Sets the {@link HttpClient} instance on this transport.
      * <p />
@@ -53,27 +56,16 @@
      * {@link HttpDestination} controls the destination-connection cardinality: protocols like
      * HTTP have 1-N cardinality, while multiplexed protocols like SPDY have a 1-1 cardinality.
      *
-     * @param scheme the destination scheme
-     * @param host the destination host
-     * @param port the destination port
+     * @param origin the destination origin
      * @return a new, transport-specific, {@link HttpDestination} object
      */
-    public HttpDestination newHttpDestination(String scheme, String host, int port);
+    public HttpDestination newHttpDestination(Origin origin);
 
     /**
      * Establishes a physical connection to the given {@code address}.
      *
-     * @param destination the destination
      * @param address the address to connect to
-     * @param promise the promise to notify when the connection succeeds or fails
+     * @param context the context information to establish the connection
      */
-    public void connect(HttpDestination destination, SocketAddress address, Promise<Connection> promise);
-
-    /**
-     * Establishes an encrypted tunnel over the given {@code connection}
-     *
-     * @param connection the connection to tunnel
-     * @return the tunnelled connection
-     */
-    public Connection tunnel(Connection connection);
+    public void connect(SocketAddress address, Map<String, Object> context);
 }
diff --git a/jetty-client/src/main/java/org/eclipse/jetty/client/HttpConnection.java b/jetty-client/src/main/java/org/eclipse/jetty/client/HttpConnection.java
index e09079b..c9bbacf 100644
--- a/jetty-client/src/main/java/org/eclipse/jetty/client/HttpConnection.java
+++ b/jetty-client/src/main/java/org/eclipse/jetty/client/HttpConnection.java
@@ -83,6 +83,7 @@
         HttpVersion version = request.getVersion();
         HttpFields headers = request.getHeaders();
         ContentProvider content = request.getContent();
+        ProxyConfiguration.Proxy proxy = destination.getProxy();
 
         // Make sure the path is there
         String path = request.getPath();
@@ -91,7 +92,7 @@
             path = "/";
             request.path(path);
         }
-        if (destination.isProxied() && !HttpMethod.CONNECT.is(method))
+        if (proxy != null && !HttpMethod.CONNECT.is(method))
         {
             path = request.getURI().toString();
             request.path(path);
@@ -136,9 +137,12 @@
             request.header(HttpHeader.COOKIE.asString(), cookieString.toString());
 
         // Authorization
-        URI authenticationURI = destination.isProxied() ? destination.getProxyURI() : request.getURI();
-        Authentication.Result authnResult = getHttpClient().getAuthenticationStore().findAuthenticationResult(authenticationURI);
-        if (authnResult != null)
-            authnResult.apply(request);
+        URI authenticationURI = proxy != null ? proxy.getURI() : request.getURI();
+        if (authenticationURI != null)
+        {
+            Authentication.Result authnResult = getHttpClient().getAuthenticationStore().findAuthenticationResult(authenticationURI);
+            if (authnResult != null)
+                authnResult.apply(request);
+        }
     }
 }
diff --git a/jetty-client/src/main/java/org/eclipse/jetty/client/HttpDestination.java b/jetty-client/src/main/java/org/eclipse/jetty/client/HttpDestination.java
index cf4c2df..534f248 100644
--- a/jetty-client/src/main/java/org/eclipse/jetty/client/HttpDestination.java
+++ b/jetty-client/src/main/java/org/eclipse/jetty/client/HttpDestination.java
@@ -20,51 +20,45 @@
 
 import java.io.Closeable;
 import java.io.IOException;
-import java.net.URI;
 import java.nio.channels.AsynchronousCloseException;
 import java.util.List;
 import java.util.Queue;
 import java.util.concurrent.RejectedExecutionException;
-import java.util.concurrent.TimeUnit;
 
 import org.eclipse.jetty.client.api.Connection;
 import org.eclipse.jetty.client.api.Destination;
-import org.eclipse.jetty.client.api.ProxyConfiguration;
 import org.eclipse.jetty.client.api.Request;
 import org.eclipse.jetty.client.api.Response;
 import org.eclipse.jetty.client.api.Result;
 import org.eclipse.jetty.http.HttpField;
 import org.eclipse.jetty.http.HttpHeader;
-import org.eclipse.jetty.http.HttpMethod;
 import org.eclipse.jetty.http.HttpScheme;
+import org.eclipse.jetty.io.ClientConnectionFactory;
+import org.eclipse.jetty.io.ssl.SslClientConnectionFactory;
 import org.eclipse.jetty.util.BlockingArrayQueue;
 import org.eclipse.jetty.util.Promise;
 import org.eclipse.jetty.util.component.ContainerLifeCycle;
 import org.eclipse.jetty.util.component.Dumpable;
 import org.eclipse.jetty.util.log.Log;
 import org.eclipse.jetty.util.log.Logger;
-import org.eclipse.jetty.util.ssl.SslContextFactory;
 
 public abstract class HttpDestination implements Destination, Closeable, Dumpable
 {
     protected static final Logger LOG = Log.getLogger(HttpDestination.class);
 
     private final HttpClient client;
-    private final String scheme;
-    private final String host;
-    private final Address address;
+    private final Origin origin;
     private final Queue<HttpExchange> exchanges;
     private final RequestNotifier requestNotifier;
     private final ResponseNotifier responseNotifier;
-    private final Address proxyAddress;
+    private final ProxyConfiguration.Proxy proxy;
+    private final ClientConnectionFactory connectionFactory;
     private final HttpField hostField;
 
-    public HttpDestination(HttpClient client, String scheme, String host, int port)
+    public HttpDestination(HttpClient client, Origin origin)
     {
         this.client = client;
-        this.scheme = scheme;
-        this.host = host;
-        this.address = new Address(host, port);
+        this.origin = origin;
 
         this.exchanges = new BlockingArrayQueue<>(client.getMaxRequestsQueuedPerDestination());
 
@@ -72,19 +66,40 @@
         this.responseNotifier = new ResponseNotifier(client);
 
         ProxyConfiguration proxyConfig = client.getProxyConfiguration();
-        proxyAddress = proxyConfig != null && proxyConfig.matches(host, port) ?
-                new Address(proxyConfig.getHost(), proxyConfig.getPort()) : null;
+        proxy = proxyConfig.match(origin);
+        ClientConnectionFactory connectionFactory = client.getTransport();
+        if (proxy != null)
+        {
+            connectionFactory = proxy.newClientConnectionFactory(connectionFactory);
+        }
+        else
+        {
+            if (HttpScheme.HTTPS.is(getScheme()))
+                connectionFactory = newSslClientConnectionFactory(connectionFactory);
+        }
+        this.connectionFactory = connectionFactory;
 
-        if (!client.isDefaultPort(scheme, port))
-            host += ":" + port;
+        String host = getHost();
+        if (!client.isDefaultPort(getScheme(), getPort()))
+            host += ":" + getPort();
         hostField = new HttpField(HttpHeader.HOST, host);
     }
 
+    protected ClientConnectionFactory newSslClientConnectionFactory(ClientConnectionFactory connectionFactory)
+    {
+        return new SslClientConnectionFactory(client.getSslContextFactory(), client.getByteBufferPool(), client.getExecutor(), connectionFactory);
+    }
+
     public HttpClient getHttpClient()
     {
         return client;
     }
 
+    public Origin getOrigin()
+    {
+        return origin;
+    }
+
     public Queue<HttpExchange> getHttpExchanges()
     {
         return exchanges;
@@ -100,10 +115,20 @@
         return responseNotifier;
     }
 
+    public ProxyConfiguration.Proxy getProxy()
+    {
+        return proxy;
+    }
+
+    public ClientConnectionFactory getClientConnectionFactory()
+    {
+        return connectionFactory;
+    }
+
     @Override
     public String getScheme()
     {
-        return scheme;
+        return origin.getScheme();
     }
 
     @Override
@@ -111,32 +136,18 @@
     {
         // InetSocketAddress.getHostString() transforms the host string
         // in case of IPv6 addresses, so we return the original host string
-        return host;
+        return origin.getAddress().getHost();
     }
 
     @Override
     public int getPort()
     {
-        return address.getPort();
+        return origin.getAddress().getPort();
     }
 
-    public Address getConnectAddress()
+    public Origin.Address getConnectAddress()
     {
-        return isProxied() ? proxyAddress : address;
-    }
-
-    public boolean isProxied()
-    {
-        return proxyAddress != null;
-    }
-
-    public URI getProxyURI()
-    {
-        ProxyConfiguration proxyConfiguration = client.getProxyConfiguration();
-        String uri = getScheme() + "://" + proxyConfiguration.getHost();
-        if (!client.isDefaultPort(getScheme(), proxyConfiguration.getPort()))
-            uri += ":" + proxyConfiguration.getPort();
-        return URI.create(uri);
+        return proxy == null ? origin.getAddress() : proxy.getAddress();
     }
 
     public HttpField getHostField()
@@ -146,7 +157,7 @@
 
     protected void send(Request request, List<Response.ResponseListener> listeners)
     {
-        if (!scheme.equals(request.getScheme()))
+        if (!getScheme().equals(request.getScheme()))
             throw new IllegalArgumentException("Invalid request scheme " + request.getScheme() + " for destination " + this);
         if (!getHost().equals(request.getHost()))
             throw new IllegalArgumentException("Invalid request host " + request.getHost() + " for destination " + this);
@@ -188,7 +199,7 @@
 
     public void newConnection(Promise<Connection> promise)
     {
-        createConnection(new ProxyPromise(promise));
+        createConnection(promise);
     }
 
     protected void createConnection(Promise<Connection> promise)
@@ -236,18 +247,6 @@
         getResponseNotifier().notifyComplete(listeners, new Result(request, cause, response, cause));
     }
 
-    protected void tunnelSucceeded(Connection connection, Promise<Connection> promise)
-    {
-        // Wrap the connection with TLS
-        promise.succeeded(client.getTransport().tunnel(connection));
-    }
-
-    protected void tunnelFailed(Connection connection, Promise<Connection> promise, Throwable failure)
-    {
-        promise.failed(failure);
-        connection.close();
-    }
-
     @Override
     public String dump()
     {
@@ -262,7 +261,7 @@
 
     public String asString()
     {
-        return client.address(getScheme(), getHost(), getPort());
+        return origin.asString();
     }
 
     @Override
@@ -271,84 +270,6 @@
         return String.format("%s(%s)%s",
                 HttpDestination.class.getSimpleName(),
                 asString(),
-                proxyAddress == null ? "" : " via " + proxyAddress.getHost() + ":" + proxyAddress.getPort());
-    }
-
-    /**
-     * Decides whether to establish a proxy tunnel using HTTP CONNECT.
-     * It is implemented as a promise because it needs to establish the tunnel
-     * when the TCP connection is succeeded, and needs to notify another
-     * promise when the tunnel is established (or failed).
-     */
-    private class ProxyPromise implements Promise<Connection>
-    {
-        private final Promise<Connection> delegate;
-
-        private ProxyPromise(Promise<Connection> delegate)
-        {
-            this.delegate = delegate;
-        }
-
-        @Override
-        public void succeeded(Connection connection)
-        {
-            if (isProxied() && HttpScheme.HTTPS.is(getScheme()))
-            {
-                if (client.getSslContextFactory() != null)
-                {
-                    tunnel(connection);
-                }
-                else
-                {
-                    String message = String.format("Cannot perform requests over SSL, no %s in %s",
-                            SslContextFactory.class.getSimpleName(), HttpClient.class.getSimpleName());
-                    delegate.failed(new IllegalStateException(message));
-                }
-            }
-            else
-            {
-                delegate.succeeded(connection);
-            }
-        }
-
-        @Override
-        public void failed(Throwable x)
-        {
-            delegate.failed(x);
-        }
-
-        private void tunnel(final Connection connection)
-        {
-            String target = address.getHost() + ":" + address.getPort();
-            Request connect = client.newRequest(proxyAddress.getHost(), proxyAddress.getPort())
-                    .scheme(HttpScheme.HTTP.asString())
-                    .method(HttpMethod.CONNECT)
-                    .path(target)
-                    .header(HttpHeader.HOST, target)
-                    .timeout(client.getConnectTimeout(), TimeUnit.MILLISECONDS);
-            connection.send(connect, new Response.CompleteListener()
-            {
-                @Override
-                public void onComplete(Result result)
-                {
-                    if (result.isFailed())
-                    {
-                        tunnelFailed(connection, delegate, result.getFailure());
-                    }
-                    else
-                    {
-                        Response response = result.getResponse();
-                        if (response.getStatus() == 200)
-                        {
-                            tunnelSucceeded(connection, delegate);
-                        }
-                        else
-                        {
-                            tunnelFailed(connection, delegate, new HttpResponseException("Received " + response + " for " + result.getRequest(), response));
-                        }
-                    }
-                }
-            });
-        }
+                proxy == null ? "" : " via " + proxy);
     }
 }
diff --git a/jetty-client/src/main/java/org/eclipse/jetty/client/HttpProxy.java b/jetty-client/src/main/java/org/eclipse/jetty/client/HttpProxy.java
new file mode 100644
index 0000000..23cc2d2
--- /dev/null
+++ b/jetty-client/src/main/java/org/eclipse/jetty/client/HttpProxy.java
@@ -0,0 +1,200 @@
+//
+//  ========================================================================
+//  Copyright (c) 1995-2013 Mort Bay Consulting Pty. Ltd.
+//  ------------------------------------------------------------------------
+//  All rights reserved. This program and the accompanying materials
+//  are made available under the terms of the Eclipse Public License v1.0
+//  and Apache License v2.0 which accompanies this distribution.
+//
+//      The Eclipse Public License is available at
+//      http://www.eclipse.org/legal/epl-v10.html
+//
+//      The Apache License v2.0 is available at
+//      http://www.opensource.org/licenses/apache2.0.php
+//
+//  You may elect to redistribute this code under either of these licenses.
+//  ========================================================================
+//
+
+package org.eclipse.jetty.client;
+
+import java.io.IOException;
+import java.net.URI;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+
+import org.eclipse.jetty.client.api.Connection;
+import org.eclipse.jetty.client.api.Request;
+import org.eclipse.jetty.client.api.Response;
+import org.eclipse.jetty.client.api.Result;
+import org.eclipse.jetty.http.HttpHeader;
+import org.eclipse.jetty.http.HttpMethod;
+import org.eclipse.jetty.http.HttpScheme;
+import org.eclipse.jetty.io.ClientConnectionFactory;
+import org.eclipse.jetty.io.EndPoint;
+import org.eclipse.jetty.io.ssl.SslClientConnectionFactory;
+import org.eclipse.jetty.util.Promise;
+import org.eclipse.jetty.util.log.Log;
+import org.eclipse.jetty.util.log.Logger;
+import org.eclipse.jetty.util.ssl.SslContextFactory;
+
+public class HttpProxy extends ProxyConfiguration.Proxy
+{
+    public HttpProxy(String host, int port)
+    {
+        this(new Origin.Address(host, port), false);
+    }
+
+    public HttpProxy(Origin.Address address, boolean secure)
+    {
+        super(address, secure);
+    }
+
+    @Override
+    public ClientConnectionFactory newClientConnectionFactory(ClientConnectionFactory connectionFactory)
+    {
+        return new HttpProxyClientConnectionFactory(connectionFactory);
+    }
+
+    @Override
+    public URI getURI()
+    {
+        String scheme = isSecure() ? HttpScheme.HTTPS.asString() : HttpScheme.HTTP.asString();
+        return URI.create(new Origin(scheme, getAddress()).asString());
+    }
+
+    public static class HttpProxyClientConnectionFactory implements ClientConnectionFactory
+    {
+        private static final Logger LOG = Log.getLogger(HttpProxyClientConnectionFactory.class);
+        private final ClientConnectionFactory connectionFactory;
+
+        public HttpProxyClientConnectionFactory(ClientConnectionFactory connectionFactory)
+        {
+            this.connectionFactory = connectionFactory;
+        }
+
+        @Override
+        public org.eclipse.jetty.io.Connection newConnection(EndPoint endPoint, Map<String, Object> context) throws IOException
+        {
+            @SuppressWarnings("unchecked")
+            Promise<Connection> promise = (Promise<Connection>)context.get(HttpClientTransport.HTTP_CONNECTION_PROMISE_CONTEXT_KEY);
+            final ProxyPromise proxyPromise = new ProxyPromise(endPoint, promise, context);
+            // Replace the promise with the proxy one
+            context.put(HttpClientTransport.HTTP_CONNECTION_PROMISE_CONTEXT_KEY, proxyPromise);
+            return connectionFactory.newConnection(endPoint, context);
+        }
+
+        /**
+         * Decides whether to establish a proxy tunnel using HTTP CONNECT.
+         * It is implemented as a promise because it needs to establish the
+         * tunnel after the TCP connection is succeeded, and needs to notify
+         * the nested promise when the tunnel is established (or failed).
+         */
+        private class ProxyPromise implements Promise<Connection>
+        {
+            private final EndPoint endPoint;
+            private final Promise<Connection> promise;
+            private final Map<String, Object> context;
+
+            private ProxyPromise(EndPoint endPoint, Promise<Connection> promise, Map<String, Object> context)
+            {
+                this.endPoint = endPoint;
+                this.promise = promise;
+                this.context = context;
+            }
+
+            @Override
+            public void succeeded(Connection connection)
+            {
+                HttpDestination destination = (HttpDestination)context.get(HttpClientTransport.HTTP_DESTINATION_CONTEXT_KEY);
+                if (HttpScheme.HTTPS.is(destination.getScheme()))
+                {
+                    SslContextFactory sslContextFactory = destination.getHttpClient().getSslContextFactory();
+                    if (sslContextFactory != null)
+                    {
+                        tunnel(destination, connection);
+                    }
+                    else
+                    {
+                        String message = String.format("Cannot perform requests over SSL, no %s in %s",
+                                SslContextFactory.class.getSimpleName(), HttpClient.class.getSimpleName());
+                        promise.failed(new IllegalStateException(message));
+                    }
+                }
+                else
+                {
+                    promise.succeeded(connection);
+                }
+            }
+
+            @Override
+            public void failed(Throwable x)
+            {
+                promise.failed(x);
+            }
+
+            private void tunnel(HttpDestination destination, final Connection connection)
+            {
+                String target = destination.getOrigin().getAddress().asString();
+                Origin.Address proxyAddress = destination.getConnectAddress();
+                HttpClient httpClient = destination.getHttpClient();
+                Request connect = httpClient.newRequest(proxyAddress.getHost(), proxyAddress.getPort())
+                        .scheme(HttpScheme.HTTP.asString())
+                        .method(HttpMethod.CONNECT)
+                        .path(target)
+                        .header(HttpHeader.HOST, target)
+                        .timeout(httpClient.getConnectTimeout(), TimeUnit.MILLISECONDS);
+
+                connection.send(connect, new Response.CompleteListener()
+                {
+                    @Override
+                    public void onComplete(Result result)
+                    {
+                        if (result.isFailed())
+                        {
+                            tunnelFailed(result.getFailure());
+                        }
+                        else
+                        {
+                            Response response = result.getResponse();
+                            if (response.getStatus() == 200)
+                            {
+                                tunnelSucceeded();
+                            }
+                            else
+                            {
+                                tunnelFailed(new HttpResponseException("Received " + response + " for " + result.getRequest(), response));
+                            }
+                        }
+                    }
+                });
+            }
+
+            private void tunnelSucceeded()
+            {
+                try
+                {
+                    // Replace the promise back with the original
+                    context.put(HttpClientTransport.HTTP_CONNECTION_PROMISE_CONTEXT_KEY, promise);
+                    HttpDestination destination = (HttpDestination)context.get(HttpClientTransport.HTTP_DESTINATION_CONTEXT_KEY);
+                    HttpClient client = destination.getHttpClient();
+                    ClientConnectionFactory sslConnectionFactory = new SslClientConnectionFactory(client.getSslContextFactory(), client.getByteBufferPool(), client.getExecutor(), connectionFactory);
+                    org.eclipse.jetty.io.Connection oldConnection = endPoint.getConnection();
+                    org.eclipse.jetty.io.Connection newConnection = sslConnectionFactory.newConnection(endPoint, context);
+                    Helper.replaceConnection(oldConnection, newConnection);
+                    LOG.debug("HTTP tunnel established: {} over {}", oldConnection, newConnection);
+                }
+                catch (Throwable x)
+                {
+                    tunnelFailed(x);
+                }
+            }
+
+            private void tunnelFailed(Throwable failure)
+            {
+                endPoint.close();
+                failed(failure);
+            }
+        }
+    }
+}
diff --git a/jetty-client/src/main/java/org/eclipse/jetty/client/HttpRequest.java b/jetty-client/src/main/java/org/eclipse/jetty/client/HttpRequest.java
index ee86fc2..d8d9f55 100644
--- a/jetty-client/src/main/java/org/eclipse/jetty/client/HttpRequest.java
+++ b/jetty-client/src/main/java/org/eclipse/jetty/client/HttpRequest.java
@@ -589,7 +589,7 @@
             path += "?" + query;
         URI result = URI.create(path);
         if (!result.isAbsolute() && !result.isOpaque())
-            result = URI.create(client.address(getScheme(), getHost(), getPort()) + path);
+            result = URI.create(new Origin(getScheme(), getHost(), getPort()).asString() + path);
         return result;
     }
 
diff --git a/jetty-client/src/main/java/org/eclipse/jetty/client/MultiplexHttpDestination.java b/jetty-client/src/main/java/org/eclipse/jetty/client/MultiplexHttpDestination.java
index aa2106e..02687d9 100644
--- a/jetty-client/src/main/java/org/eclipse/jetty/client/MultiplexHttpDestination.java
+++ b/jetty-client/src/main/java/org/eclipse/jetty/client/MultiplexHttpDestination.java
@@ -29,9 +29,9 @@
     private final AtomicReference<ConnectState> connect = new AtomicReference<>(ConnectState.DISCONNECTED);
     private C connection;
 
-    protected MultiplexHttpDestination(HttpClient client, String scheme, String host, int port)
+    protected MultiplexHttpDestination(HttpClient client, Origin origin)
     {
-        super(client, scheme, host, port);
+        super(client, origin);
     }
 
     @Override
diff --git a/jetty-client/src/main/java/org/eclipse/jetty/client/Origin.java b/jetty-client/src/main/java/org/eclipse/jetty/client/Origin.java
new file mode 100644
index 0000000..93c4a33
--- /dev/null
+++ b/jetty-client/src/main/java/org/eclipse/jetty/client/Origin.java
@@ -0,0 +1,122 @@
+//
+//  ========================================================================
+//  Copyright (c) 1995-2013 Mort Bay Consulting Pty. Ltd.
+//  ------------------------------------------------------------------------
+//  All rights reserved. This program and the accompanying materials
+//  are made available under the terms of the Eclipse Public License v1.0
+//  and Apache License v2.0 which accompanies this distribution.
+//
+//      The Eclipse Public License is available at
+//      http://www.eclipse.org/legal/epl-v10.html
+//
+//      The Apache License v2.0 is available at
+//      http://www.opensource.org/licenses/apache2.0.php
+//
+//  You may elect to redistribute this code under either of these licenses.
+//  ========================================================================
+//
+
+package org.eclipse.jetty.client;
+
+import org.eclipse.jetty.util.URIUtil;
+
+public class Origin
+{
+    private final String scheme;
+    private final Address address;
+
+    public Origin(String scheme, String host, int port)
+    {
+        this(scheme, new Address(host, port));
+    }
+
+    public Origin(String scheme, Address address)
+    {
+        this.scheme = scheme;
+        this.address = address;
+    }
+
+    public String getScheme()
+    {
+        return scheme;
+    }
+
+    public Address getAddress()
+    {
+        return address;
+    }
+
+    public String asString()
+    {
+        StringBuilder result = new StringBuilder();
+        URIUtil.appendSchemeHostPort(result, scheme, address.host, address.port);
+        return result.toString();
+    }
+
+    @Override
+    public boolean equals(Object obj)
+    {
+        if (this == obj) return true;
+        if (obj == null || getClass() != obj.getClass()) return false;
+        Origin that = (Origin)obj;
+        return scheme.equals(that.scheme) && address.equals(that.address);
+    }
+
+    @Override
+    public int hashCode()
+    {
+        int result = scheme.hashCode();
+        result = 31 * result + address.hashCode();
+        return result;
+    }
+
+    public static class Address
+    {
+        private final String host;
+        private final int port;
+
+        public Address(String host, int port)
+        {
+            this.host = host;
+            this.port = port;
+        }
+
+        public String getHost()
+        {
+            return host;
+        }
+
+        public int getPort()
+        {
+            return port;
+        }
+
+        @Override
+        public boolean equals(Object obj)
+        {
+            if (this == obj) return true;
+            if (obj == null || getClass() != obj.getClass()) return false;
+            Address that = (Address)obj;
+            return host.equals(that.host) && port == that.port;
+        }
+
+        @Override
+        public int hashCode()
+        {
+            int result = host.hashCode();
+            result = 31 * result + port;
+            return result;
+        }
+
+        public String asString()
+        {
+            return String.format("%s:%d", host, port);
+        }
+
+        @Override
+        public String toString()
+        {
+            return asString();
+        }
+    }
+}
diff --git a/jetty-client/src/main/java/org/eclipse/jetty/client/ProxyAuthenticationProtocolHandler.java b/jetty-client/src/main/java/org/eclipse/jetty/client/ProxyAuthenticationProtocolHandler.java
index 841c661..d7e96f3 100644
--- a/jetty-client/src/main/java/org/eclipse/jetty/client/ProxyAuthenticationProtocolHandler.java
+++ b/jetty-client/src/main/java/org/eclipse/jetty/client/ProxyAuthenticationProtocolHandler.java
@@ -59,6 +59,7 @@
     protected URI getAuthenticationURI(Request request)
     {
         HttpDestination destination = getHttpClient().destinationFor(request.getScheme(), request.getHost(), request.getPort());
-        return destination.isProxied() ? destination.getProxyURI() : request.getURI();
+        ProxyConfiguration.Proxy proxy = destination.getProxy();
+        return proxy != null ? proxy.getURI() : request.getURI();
     }
 }
diff --git a/jetty-client/src/main/java/org/eclipse/jetty/client/ProxyConfiguration.java b/jetty-client/src/main/java/org/eclipse/jetty/client/ProxyConfiguration.java
new file mode 100644
index 0000000..153d33a
--- /dev/null
+++ b/jetty-client/src/main/java/org/eclipse/jetty/client/ProxyConfiguration.java
@@ -0,0 +1,137 @@
+//
+//  ========================================================================
+//  Copyright (c) 1995-2013 Mort Bay Consulting Pty. Ltd.
+//  ------------------------------------------------------------------------
+//  All rights reserved. This program and the accompanying materials
+//  are made available under the terms of the Eclipse Public License v1.0
+//  and Apache License v2.0 which accompanies this distribution.
+//
+//      The Eclipse Public License is available at
+//      http://www.eclipse.org/legal/epl-v10.html
+//
+//      The Apache License v2.0 is available at
+//      http://www.opensource.org/licenses/apache2.0.php
+//
+//  You may elect to redistribute this code under either of these licenses.
+//  ========================================================================
+//
+
+package org.eclipse.jetty.client;
+
+import java.net.URI;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import org.eclipse.jetty.io.ClientConnectionFactory;
+
+/**
+ * The configuration of the forward proxy to use with {@link org.eclipse.jetty.client.HttpClient}.
+ * <p />
+ * Applications add subclasses of {@link Proxy} to this configuration via:
+ * <pre>
+ * ProxyConfiguration proxyConfig = httpClient.getProxyConfiguration();
+ * proxyConfig.getProxies().add(new HttpProxy(proxyHost, 8080));
+ * </pre>
+ *
+ * @see HttpClient#getProxyConfiguration()
+ */
+public class ProxyConfiguration
+{
+    private final List<Proxy> proxies = new ArrayList<>();
+
+    public List<Proxy> getProxies()
+    {
+        return proxies;
+    }
+
+    public Proxy match(Origin origin)
+    {
+        for (Proxy proxy : getProxies())
+        {
+            if (proxy.matches(origin))
+                return proxy;
+        }
+        return null;
+    }
+
+    public static abstract class Proxy
+    {
+        private final Set<Origin> included = new HashSet<>();
+        private final Set<Origin> excluded = new HashSet<>();
+        private final Origin.Address address;
+        private final boolean secure;
+
+        protected Proxy(Origin.Address address, boolean secure)
+        {
+            this.address = address;
+            this.secure = secure;
+        }
+
+        /**
+         * @return the address of this proxy
+         */
+        public Origin.Address getAddress()
+        {
+            return address;
+        }
+
+        /**
+         * @return whether the connection to the proxy must be secured via TLS
+         */
+        public boolean isSecure()
+        {
+            return secure;
+        }
+
+        /**
+         * @return the list of origins that must be proxied
+         */
+        public Set<Origin> getIncludedOrigins()
+        {
+            return included;
+        }
+
+        /**
+         * @return the list of origins that must not be proxied.
+         */
+        public Set<Origin> getExcludedOrigins()
+        {
+            return excluded;
+        }
+
+        /**
+         * @return an URI representing this proxy, or null if no URI can represent this proxy
+         */
+        public URI getURI()
+        {
+            return null;
+        }
+
+        /**
+         * Matches the given {@code origin} with the included and excluded origins,
+         * returning true if the given {@code origin} is to be proxied.
+         *
+         * @param origin the origin to test for proxying
+         * @return true if the origin must be proxied, false otherwise
+         */
+        public boolean matches(Origin origin)
+        {
+            return included.contains(origin) || !excluded.contains(origin);
+        }
+
+        /**
+         * @param connectionFactory the nested {@link ClientConnectionFactory}
+         * @return a new {@link ClientConnectionFactory} for this {@link Proxy}
+         */
+        public abstract ClientConnectionFactory newClientConnectionFactory(ClientConnectionFactory connectionFactory);
+
+        @Override
+        public String toString()
+        {
+            return address.toString();
+        }
+    }
+
+}
diff --git a/jetty-client/src/main/java/org/eclipse/jetty/client/Socks4Proxy.java b/jetty-client/src/main/java/org/eclipse/jetty/client/Socks4Proxy.java
new file mode 100644
index 0000000..e06d3f2
--- /dev/null
+++ b/jetty-client/src/main/java/org/eclipse/jetty/client/Socks4Proxy.java
@@ -0,0 +1,190 @@
+//
+//  ========================================================================
+//  Copyright (c) 1995-2013 Mort Bay Consulting Pty. Ltd.
+//  ------------------------------------------------------------------------
+//  All rights reserved. This program and the accompanying materials
+//  are made available under the terms of the Eclipse Public License v1.0
+//  and Apache License v2.0 which accompanies this distribution.
+//
+//      The Eclipse Public License is available at
+//      http://www.eclipse.org/legal/epl-v10.html
+//
+//      The Apache License v2.0 is available at
+//      http://www.opensource.org/licenses/apache2.0.php
+//
+//  You may elect to redistribute this code under either of these licenses.
+//  ========================================================================
+//
+
+package org.eclipse.jetty.client;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.charset.Charset;
+import java.util.Map;
+import java.util.concurrent.Executor;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.eclipse.jetty.client.api.Connection;
+import org.eclipse.jetty.http.HttpScheme;
+import org.eclipse.jetty.io.AbstractConnection;
+import org.eclipse.jetty.io.ClientConnectionFactory;
+import org.eclipse.jetty.io.EndPoint;
+import org.eclipse.jetty.io.ssl.SslClientConnectionFactory;
+import org.eclipse.jetty.util.BufferUtil;
+import org.eclipse.jetty.util.Callback;
+import org.eclipse.jetty.util.Promise;
+import org.eclipse.jetty.util.log.Log;
+import org.eclipse.jetty.util.log.Logger;
+
+public class Socks4Proxy extends ProxyConfiguration.Proxy
+{
+    public Socks4Proxy(String host, int port)
+    {
+        this(new Origin.Address(host, port), false);
+    }
+
+    public Socks4Proxy(Origin.Address address, boolean secure)
+    {
+        super(address, secure);
+    }
+
+    @Override
+    public ClientConnectionFactory newClientConnectionFactory(ClientConnectionFactory connectionFactory)
+    {
+        return new Socks4ProxyClientConnectionFactory(connectionFactory);
+    }
+
+    public static class Socks4ProxyClientConnectionFactory implements ClientConnectionFactory
+    {
+        private final ClientConnectionFactory connectionFactory;
+
+        public Socks4ProxyClientConnectionFactory(ClientConnectionFactory connectionFactory)
+        {
+            this.connectionFactory = connectionFactory;
+        }
+
+        @Override
+        public org.eclipse.jetty.io.Connection newConnection(EndPoint endPoint, Map<String, Object> context) throws IOException
+        {
+            HttpDestination destination = (HttpDestination)context.get(HttpClientTransport.HTTP_DESTINATION_CONTEXT_KEY);
+            Executor executor = destination.getHttpClient().getExecutor();
+            return new Socks4ProxyConnection(endPoint, executor, connectionFactory, context);
+        }
+    }
+
+    private static class Socks4ProxyConnection extends AbstractConnection implements Callback
+    {
+        private static final Pattern IPv4_PATTERN = Pattern.compile("(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})");
+        private static final Logger LOG = Log.getLogger(Socks4ProxyConnection.class);
+
+        private final ClientConnectionFactory connectionFactory;
+        private final Map<String, Object> context;
+
+        public Socks4ProxyConnection(EndPoint endPoint, Executor executor, ClientConnectionFactory connectionFactory, Map<String, Object> context)
+        {
+            super(endPoint, executor);
+            this.connectionFactory = connectionFactory;
+            this.context = context;
+        }
+
+        @Override
+        public void onOpen()
+        {
+            super.onOpen();
+            writeSocks4Connect();
+        }
+
+        /**
+         * Writes the SOCKS "connect" bytes, differentiating between SOCKS 4 and 4A;
+         * the former sends an IPv4 address, the latter the full domain name.
+         */
+        private void writeSocks4Connect()
+        {
+            HttpDestination destination = (HttpDestination)context.get(HttpClientTransport.HTTP_DESTINATION_CONTEXT_KEY);
+            String host = destination.getHost();
+            short port = (short)destination.getPort();
+            Matcher matcher = IPv4_PATTERN.matcher(host);
+            if (matcher.matches())
+            {
+                // SOCKS 4
+                ByteBuffer buffer = ByteBuffer.allocate(9);
+                buffer.put((byte)4).put((byte)1).putShort(port);
+                for (int i = 1; i <= 4; ++i)
+                    buffer.put((byte)Integer.parseInt(matcher.group(i)));
+                buffer.put((byte)0);
+                buffer.flip();
+                getEndPoint().write(this, buffer);
+            }
+            else
+            {
+                // SOCKS 4A
+                byte[] hostBytes = host.getBytes(Charset.forName("UTF-8"));
+                ByteBuffer buffer = ByteBuffer.allocate(9 + hostBytes.length + 1);
+                buffer.put((byte)4).put((byte)1).putShort(port);
+                buffer.put((byte)0).put((byte)0).put((byte)0).put((byte)1).put((byte)0);
+                buffer.put(hostBytes).put((byte)0);
+                buffer.flip();
+                getEndPoint().write(this, buffer);
+            }
+        }
+
+        @Override
+        public void succeeded()
+        {
+            LOG.debug("Written SOCKS4 connect request");
+            fillInterested();
+        }
+
+        @Override
+        public void failed(Throwable x)
+        {
+            close();
+            @SuppressWarnings("unchecked")
+            Promise<Connection> promise = (Promise<Connection>)context.get(HttpClientTransport.HTTP_CONNECTION_PROMISE_CONTEXT_KEY);
+            promise.failed(x);
+        }
+
+        @Override
+        public void onFillable()
+        {
+            try
+            {
+                ByteBuffer buffer = BufferUtil.allocate(8);
+                int filled = getEndPoint().fill(buffer);
+                LOG.debug("Read SOCKS4 connect response, {} bytes", filled);
+                if (filled != 8)
+                    throw new IOException("Invalid response from SOCKS4 proxy");
+                int result = buffer.get(1);
+                if (result == 0x5A)
+                    tunnel();
+                else
+                    throw new IOException("SOCKS4 tunnel failed with code " + result);
+            }
+            catch (Throwable x)
+            {
+                failed(x);
+            }
+        }
+
+        private void tunnel()
+        {
+            try
+            {
+                HttpDestination destination = (HttpDestination)context.get(HttpClientTransport.HTTP_DESTINATION_CONTEXT_KEY);
+                HttpClient client = destination.getHttpClient();
+                ClientConnectionFactory connectionFactory = this.connectionFactory;
+                if (HttpScheme.HTTPS.is(destination.getScheme()))
+                    connectionFactory = new SslClientConnectionFactory(client.getSslContextFactory(), client.getByteBufferPool(), client.getExecutor(), connectionFactory);
+                org.eclipse.jetty.io.Connection connection = connectionFactory.newConnection(getEndPoint(), context);
+                ClientConnectionFactory.Helper.replaceConnection(this, connection);
+                LOG.debug("SOCKS4 tunnel established: {} over {}", this, connection);
+            }
+            catch (Throwable x)
+            {
+                failed(x);
+            }
+        }
+    }
+}
diff --git a/jetty-client/src/main/java/org/eclipse/jetty/client/api/Destination.java b/jetty-client/src/main/java/org/eclipse/jetty/client/api/Destination.java
index 03cece3..736a14b 100644
--- a/jetty-client/src/main/java/org/eclipse/jetty/client/api/Destination.java
+++ b/jetty-client/src/main/java/org/eclipse/jetty/client/api/Destination.java
@@ -63,43 +63,4 @@
      * @param promise the promise of a new, unpooled, {@link Connection}
      */
     void newConnection(Promise<Connection> promise);
-
-    public static class Address
-    {
-        private final String host;
-        private final int port;
-
-        public Address(String host, int port)
-        {
-            this.host = host;
-            this.port = port;
-        }
-
-        public String getHost()
-        {
-            return host;
-        }
-
-        public int getPort()
-        {
-            return port;
-        }
-
-        @Override
-        public boolean equals(Object obj)
-        {
-            if (this == obj) return true;
-            if (obj == null || getClass() != obj.getClass()) return false;
-            Address that = (Address)obj;
-            return host.equals(that.host) && port == that.port;
-        }
-
-        @Override
-        public int hashCode()
-        {
-            int result = host.hashCode();
-            result = 31 * result + port;
-            return result;
-        }
-    }
 }
diff --git a/jetty-client/src/main/java/org/eclipse/jetty/client/api/ProxyConfiguration.java b/jetty-client/src/main/java/org/eclipse/jetty/client/api/ProxyConfiguration.java
deleted file mode 100644
index 4b84557..0000000
--- a/jetty-client/src/main/java/org/eclipse/jetty/client/api/ProxyConfiguration.java
+++ /dev/null
@@ -1,81 +0,0 @@
-//
-//  ========================================================================
-//  Copyright (c) 1995-2013 Mort Bay Consulting Pty. Ltd.
-//  ------------------------------------------------------------------------
-//  All rights reserved. This program and the accompanying materials
-//  are made available under the terms of the Eclipse Public License v1.0
-//  and Apache License v2.0 which accompanies this distribution.
-//
-//      The Eclipse Public License is available at
-//      http://www.eclipse.org/legal/epl-v10.html
-//
-//      The Apache License v2.0 is available at
-//      http://www.opensource.org/licenses/apache2.0.php
-//
-//  You may elect to redistribute this code under either of these licenses.
-//  ========================================================================
-//
-
-package org.eclipse.jetty.client.api;
-
-import java.util.HashSet;
-import java.util.Set;
-
-/**
- * The configuration of the forward proxy to use with {@link org.eclipse.jetty.client.HttpClient}.
- * <p />
- * Configuration parameters include the host and port of the forward proxy, and a list of
- * {@link #getExcludedOrigins() origins} that are excluded from being proxied.
- *
- * @see org.eclipse.jetty.client.HttpClient#setProxyConfiguration(ProxyConfiguration)
- */
-public class ProxyConfiguration
-{
-    private final Set<String> excluded = new HashSet<>();
-    private final String host;
-    private final int port;
-
-    public ProxyConfiguration(String host, int port)
-    {
-        this.host = host;
-        this.port = port;
-    }
-
-    /**
-     * @return the host name of the forward proxy
-     */
-    public String getHost()
-    {
-        return host;
-    }
-
-    /**
-     * @return the port of the forward proxy
-     */
-    public int getPort()
-    {
-        return port;
-    }
-
-    /**
-     * Matches the given {@code host} and {@code port} with the list of excluded origins,
-     * returning true if the origin is to be proxied, false if it is excluded from proxying.
-     * @param host the host to match
-     * @param port the port to match
-     * @return true if the origin made of {@code host} and {@code port} is to be proxied,
-     * false if it is excluded from proxying.
-     */
-    public boolean matches(String host, int port)
-    {
-        String hostPort = host + ":" + port;
-        return !getExcludedOrigins().contains(hostPort);
-    }
-
-    /**
-     * @return the list of origins to exclude from proxying, in the form "host:port".
-     */
-    public Set<String> getExcludedOrigins()
-    {
-        return excluded;
-    }
-}
diff --git a/jetty-client/src/main/java/org/eclipse/jetty/client/http/HttpClientTransportOverHTTP.java b/jetty-client/src/main/java/org/eclipse/jetty/client/http/HttpClientTransportOverHTTP.java
index 2f752ff..d2383b0 100644
--- a/jetty-client/src/main/java/org/eclipse/jetty/client/http/HttpClientTransportOverHTTP.java
+++ b/jetty-client/src/main/java/org/eclipse/jetty/client/http/HttpClientTransportOverHTTP.java
@@ -18,16 +18,21 @@
 
 package org.eclipse.jetty.client.http;
 
+import java.io.IOException;
+import java.util.Map;
+
 import org.eclipse.jetty.client.AbstractHttpClientTransport;
 import org.eclipse.jetty.client.HttpDestination;
-import org.eclipse.jetty.io.Connection;
+import org.eclipse.jetty.client.Origin;
+import org.eclipse.jetty.client.api.Connection;
 import org.eclipse.jetty.io.EndPoint;
+import org.eclipse.jetty.util.Promise;
 
 public class HttpClientTransportOverHTTP extends AbstractHttpClientTransport
 {
     public HttpClientTransportOverHTTP()
     {
-        this(Runtime.getRuntime().availableProcessors());
+        this(Math.max(1, Runtime.getRuntime().availableProcessors() / 2));
     }
 
     public HttpClientTransportOverHTTP(int selectors)
@@ -36,21 +41,20 @@
     }
 
     @Override
-    public HttpDestination newHttpDestination(String scheme, String host, int port)
+    public HttpDestination newHttpDestination(Origin origin)
     {
-        return new HttpDestinationOverHTTP(getHttpClient(), scheme, host, port);
+        return new HttpDestinationOverHTTP(getHttpClient(), origin);
     }
 
     @Override
-    protected Connection newConnection(EndPoint endPoint, HttpDestination destination)
+    public org.eclipse.jetty.io.Connection newConnection(EndPoint endPoint, Map<String, Object> context) throws IOException
     {
-        return new HttpConnectionOverHTTP(endPoint, destination);
-    }
 
-    @Override
-    public org.eclipse.jetty.client.api.Connection tunnel(org.eclipse.jetty.client.api.Connection connection)
-    {
-        HttpConnectionOverHTTP httpConnection = (HttpConnectionOverHTTP)connection;
-        return tunnel(httpConnection.getEndPoint(), httpConnection.getHttpDestination(), connection);
+        HttpDestination destination = (HttpDestination)context.get(HTTP_DESTINATION_CONTEXT_KEY);
+        HttpConnectionOverHTTP connection = new HttpConnectionOverHTTP(endPoint, destination);
+        @SuppressWarnings("unchecked")
+        Promise<Connection> promise = (Promise<Connection>)context.get(HTTP_CONNECTION_PROMISE_CONTEXT_KEY);
+        promise.succeeded(connection);
+        return connection;
     }
 }
diff --git a/jetty-client/src/main/java/org/eclipse/jetty/client/http/HttpDestinationOverHTTP.java b/jetty-client/src/main/java/org/eclipse/jetty/client/http/HttpDestinationOverHTTP.java
index e7f4f19..8419199 100644
--- a/jetty-client/src/main/java/org/eclipse/jetty/client/http/HttpDestinationOverHTTP.java
+++ b/jetty-client/src/main/java/org/eclipse/jetty/client/http/HttpDestinationOverHTTP.java
@@ -21,30 +21,32 @@
 import java.io.IOException;
 import java.util.Arrays;
 
+import org.eclipse.jetty.client.ConnectionPool;
 import org.eclipse.jetty.client.HttpClient;
 import org.eclipse.jetty.client.HttpDestination;
 import org.eclipse.jetty.client.HttpExchange;
+import org.eclipse.jetty.client.Origin;
 import org.eclipse.jetty.client.api.Connection;
 import org.eclipse.jetty.client.api.Request;
 import org.eclipse.jetty.util.Promise;
 import org.eclipse.jetty.util.component.ContainerLifeCycle;
 
-public class HttpDestinationOverHTTP extends HttpDestination  implements Promise<Connection>
+public class HttpDestinationOverHTTP extends HttpDestination implements Promise<Connection>
 {
-    private final HttpConnectionPool connectionPool;
+    private final ConnectionPool connectionPool;
 
-    public HttpDestinationOverHTTP(HttpClient client, String scheme, String host, int port)
+    public HttpDestinationOverHTTP(HttpClient client, Origin origin)
     {
-        super(client, scheme, host, port);
-        this.connectionPool = newHttpConnectionPool(client);
+        super(client, origin);
+        this.connectionPool = newConnectionPool(client);
     }
 
-    protected HttpConnectionPool newHttpConnectionPool(HttpClient client)
+    protected ConnectionPool newConnectionPool(HttpClient client)
     {
-        return new HttpConnectionPool(this, client.getMaxConnectionsPerDestination(), this);
+        return new ConnectionPool(this, client.getMaxConnectionsPerDestination(), this);
     }
 
-    public HttpConnectionPool getHttpConnectionPool()
+    public ConnectionPool getConnectionPool()
     {
         return connectionPool;
     }
diff --git a/jetty-client/src/test/java/org/eclipse/jetty/client/HttpClientCustomProxyTest.java b/jetty-client/src/test/java/org/eclipse/jetty/client/HttpClientCustomProxyTest.java
new file mode 100644
index 0000000..b60de3a
--- /dev/null
+++ b/jetty-client/src/test/java/org/eclipse/jetty/client/HttpClientCustomProxyTest.java
@@ -0,0 +1,245 @@
+//
+//  ========================================================================
+//  Copyright (c) 1995-2013 Mort Bay Consulting Pty. Ltd.
+//  ------------------------------------------------------------------------
+//  All rights reserved. This program and the accompanying materials
+//  are made available under the terms of the Eclipse Public License v1.0
+//  and Apache License v2.0 which accompanies this distribution.
+//
+//      The Eclipse Public License is available at
+//      http://www.eclipse.org/legal/epl-v10.html
+//
+//      The Apache License v2.0 is available at
+//      http://www.opensource.org/licenses/apache2.0.php
+//
+//  You may elect to redistribute this code under either of these licenses.
+//  ========================================================================
+//
+
+package org.eclipse.jetty.client;
+
+import java.io.IOException;
+import java.net.URI;
+import java.nio.ByteBuffer;
+import java.util.Map;
+import java.util.concurrent.Executor;
+import java.util.concurrent.TimeUnit;
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.eclipse.jetty.client.api.Connection;
+import org.eclipse.jetty.client.api.ContentResponse;
+import org.eclipse.jetty.http.HttpStatus;
+import org.eclipse.jetty.io.AbstractConnection;
+import org.eclipse.jetty.io.ClientConnectionFactory;
+import org.eclipse.jetty.io.EndPoint;
+import org.eclipse.jetty.server.AbstractConnectionFactory;
+import org.eclipse.jetty.server.Connector;
+import org.eclipse.jetty.server.Handler;
+import org.eclipse.jetty.server.HttpConnectionFactory;
+import org.eclipse.jetty.server.Server;
+import org.eclipse.jetty.server.ServerConnector;
+import org.eclipse.jetty.server.handler.AbstractHandler;
+import org.eclipse.jetty.util.BufferUtil;
+import org.eclipse.jetty.util.Callback;
+import org.eclipse.jetty.util.Promise;
+import org.eclipse.jetty.util.thread.QueuedThreadPool;
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class HttpClientCustomProxyTest
+{
+    public static final byte[] CAFE_BABE = new byte[]{(byte)0xCA, (byte)0xFE, (byte)0xBA, (byte)0xBE};
+
+    private Server server;
+    private ServerConnector connector;
+    private HttpClient client;
+
+    public void prepare(Handler handler) throws Exception
+    {
+        server = new Server();
+        connector = new ServerConnector(server, new CAFEBABEServerConnectionFactory(new HttpConnectionFactory()));
+        server.addConnector(connector);
+        server.setHandler(handler);
+        server.start();
+
+        QueuedThreadPool executor = new QueuedThreadPool();
+        executor.setName(executor.getName() + "-client");
+        client = new HttpClient();
+        client.setExecutor(executor);
+        client.start();
+    }
+
+    @After
+    public void dispose() throws Exception
+    {
+        if (client != null)
+            client.stop();
+        if (server != null)
+            server.stop();
+    }
+
+    @Test
+    public void testCustomProxy() throws Exception
+    {
+        final String serverHost = "server";
+        final int status = HttpStatus.NO_CONTENT_204;
+        prepare(new AbstractHandler()
+        {
+            @Override
+            public void handle(String target, org.eclipse.jetty.server.Request baseRequest, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException
+            {
+                baseRequest.setHandled(true);
+                if (!URI.create(baseRequest.getUri().toString()).isAbsolute())
+                    response.setStatus(HttpServletResponse.SC_USE_PROXY);
+                else if (serverHost.equals(request.getServerName()))
+                    response.setStatus(status);
+                else
+                    response.setStatus(HttpServletResponse.SC_NOT_ACCEPTABLE);
+            }
+        });
+
+        // Setup the custom proxy
+        int proxyPort = connector.getLocalPort();
+        int serverPort = proxyPort + 1; // Any port will do for these tests - just not the same as the proxy
+        client.getProxyConfiguration().getProxies().add(new CAFEBABEProxy(new Origin.Address("localhost", proxyPort), false));
+
+        ContentResponse response = client.newRequest(serverHost, serverPort)
+                .timeout(5, TimeUnit.SECONDS)
+                .send();
+
+        Assert.assertEquals(status, response.getStatus());
+    }
+
+    private class CAFEBABEProxy extends ProxyConfiguration.Proxy
+    {
+        private CAFEBABEProxy(Origin.Address address, boolean secure)
+        {
+            super(address, secure);
+        }
+
+        @Override
+        public ClientConnectionFactory newClientConnectionFactory(ClientConnectionFactory connectionFactory)
+        {
+            return new CAFEBABEClientConnectionFactory(connectionFactory);
+        }
+    }
+
+    private class CAFEBABEClientConnectionFactory implements ClientConnectionFactory
+    {
+        private final ClientConnectionFactory connectionFactory;
+
+        private CAFEBABEClientConnectionFactory(ClientConnectionFactory connectionFactory)
+        {
+            this.connectionFactory = connectionFactory;
+        }
+
+        @Override
+        public org.eclipse.jetty.io.Connection newConnection(EndPoint endPoint, Map<String, Object> context) throws IOException
+        {
+            HttpDestination destination = (HttpDestination)context.get(HttpClientTransport.HTTP_DESTINATION_CONTEXT_KEY);
+            Executor executor = destination.getHttpClient().getExecutor();
+            return new CAFEBABEConnection(endPoint, executor, connectionFactory, context);
+        }
+    }
+
+    private class CAFEBABEConnection extends AbstractConnection
+    {
+        private final ClientConnectionFactory connectionFactory;
+        private final Map<String, Object> context;
+
+        public CAFEBABEConnection(EndPoint endPoint, Executor executor, ClientConnectionFactory connectionFactory, Map<String, Object> context)
+        {
+            super(endPoint, executor);
+            this.connectionFactory = connectionFactory;
+            this.context = context;
+        }
+
+        @Override
+        public void onOpen()
+        {
+            super.onOpen();
+            fillInterested();
+            getEndPoint().write(new Callback.Adapter(), ByteBuffer.wrap(CAFE_BABE));
+        }
+
+        @Override
+        public void onFillable()
+        {
+            try
+            {
+                ByteBuffer buffer = BufferUtil.allocate(4);
+                int filled = getEndPoint().fill(buffer);
+                Assert.assertEquals(4, filled);
+                Assert.assertArrayEquals(CAFE_BABE, buffer.array());
+
+                // We are good, upgrade the connection
+                ClientConnectionFactory.Helper.replaceConnection(this, connectionFactory.newConnection(getEndPoint(), context));
+            }
+            catch (Throwable x)
+            {
+                close();
+                @SuppressWarnings("unchecked")
+                Promise<Connection> promise = (Promise<Connection>)context.get(HttpClientTransport.HTTP_CONNECTION_PROMISE_CONTEXT_KEY);
+                promise.failed(x);
+            }
+        }
+    }
+
+    private class CAFEBABEServerConnectionFactory extends AbstractConnectionFactory
+    {
+        private final org.eclipse.jetty.server.ConnectionFactory connectionFactory;
+
+        private CAFEBABEServerConnectionFactory(org.eclipse.jetty.server.ConnectionFactory connectionFactory)
+        {
+            super("cafebabe");
+            this.connectionFactory = connectionFactory;
+        }
+
+        @Override
+        public org.eclipse.jetty.io.Connection newConnection(Connector connector, EndPoint endPoint)
+        {
+            return new CAFEBABEServerConnection(connector, endPoint, connectionFactory);
+        }
+    }
+
+    private class CAFEBABEServerConnection extends AbstractConnection
+    {
+        private final org.eclipse.jetty.server.ConnectionFactory connectionFactory;
+
+        public CAFEBABEServerConnection(Connector connector, EndPoint endPoint, org.eclipse.jetty.server.ConnectionFactory connectionFactory)
+        {
+            super(endPoint, connector.getExecutor());
+            this.connectionFactory = connectionFactory;
+        }
+
+        @Override
+        public void onOpen()
+        {
+            super.onOpen();
+            fillInterested();
+        }
+
+        @Override
+        public void onFillable()
+        {
+            try
+            {
+                ByteBuffer buffer = BufferUtil.allocate(4);
+                int filled = getEndPoint().fill(buffer);
+                Assert.assertEquals(4, filled);
+                Assert.assertArrayEquals(CAFE_BABE, buffer.array());
+                getEndPoint().write(new Callback.Adapter(), buffer);
+
+                // We are good, upgrade the connection
+                ClientConnectionFactory.Helper.replaceConnection(this, connectionFactory.newConnection(connector, getEndPoint()));
+            }
+            catch (Throwable x)
+            {
+                close();
+            }
+        }
+    }
+}
diff --git a/jetty-client/src/test/java/org/eclipse/jetty/client/HttpClientExplicitConnectionTest.java b/jetty-client/src/test/java/org/eclipse/jetty/client/HttpClientExplicitConnectionTest.java
index 6b7acc6..7260ae6 100644
--- a/jetty-client/src/test/java/org/eclipse/jetty/client/HttpClientExplicitConnectionTest.java
+++ b/jetty-client/src/test/java/org/eclipse/jetty/client/HttpClientExplicitConnectionTest.java
@@ -25,7 +25,6 @@
 import org.eclipse.jetty.client.api.Destination;
 import org.eclipse.jetty.client.api.Request;
 import org.eclipse.jetty.client.http.HttpConnectionOverHTTP;
-import org.eclipse.jetty.client.http.HttpConnectionPool;
 import org.eclipse.jetty.client.http.HttpDestinationOverHTTP;
 import org.eclipse.jetty.client.util.FutureResponseListener;
 import org.eclipse.jetty.toolchain.test.annotation.Slow;
@@ -60,7 +59,7 @@
             Assert.assertEquals(200, response.getStatus());
 
             HttpDestinationOverHTTP httpDestination = (HttpDestinationOverHTTP)destination;
-            HttpConnectionPool connectionPool = httpDestination.getHttpConnectionPool();
+            ConnectionPool connectionPool = httpDestination.getConnectionPool();
             Assert.assertTrue(connectionPool.getActiveConnections().isEmpty());
             Assert.assertTrue(connectionPool.getIdleConnections().isEmpty());
         }
@@ -92,7 +91,7 @@
         Assert.assertFalse(httpConnection.getEndPoint().isOpen());
 
         HttpDestinationOverHTTP httpDestination = (HttpDestinationOverHTTP)destination;
-        HttpConnectionPool connectionPool = httpDestination.getHttpConnectionPool();
+        ConnectionPool connectionPool = httpDestination.getConnectionPool();
         Assert.assertTrue(connectionPool.getActiveConnections().isEmpty());
         Assert.assertTrue(connectionPool.getIdleConnections().isEmpty());
     }
diff --git a/jetty-client/src/test/java/org/eclipse/jetty/client/HttpClientLoadTest.java b/jetty-client/src/test/java/org/eclipse/jetty/client/HttpClientLoadTest.java
index 1ac4ae4..41213c2 100644
--- a/jetty-client/src/test/java/org/eclipse/jetty/client/HttpClientLoadTest.java
+++ b/jetty-client/src/test/java/org/eclipse/jetty/client/HttpClientLoadTest.java
@@ -37,7 +37,6 @@
 import org.eclipse.jetty.client.api.Response;
 import org.eclipse.jetty.client.api.Result;
 import org.eclipse.jetty.client.http.HttpConnectionOverHTTP;
-import org.eclipse.jetty.client.http.HttpConnectionPool;
 import org.eclipse.jetty.client.http.HttpDestinationOverHTTP;
 import org.eclipse.jetty.client.util.BytesContentProvider;
 import org.eclipse.jetty.http.HttpHeader;
@@ -85,7 +84,7 @@
         }
 
         // Re-run after warmup
-        iterations = 50_000;
+        iterations = 5_000;
         for (int i = 0; i < runs; ++i)
         {
             run(random, iterations);
@@ -111,7 +110,7 @@
                 for (String host : Arrays.asList("localhost", "127.0.0.1"))
                 {
                     HttpDestinationOverHTTP destination = (HttpDestinationOverHTTP)client.getDestination(scheme, host, connector.getLocalPort());
-                    HttpConnectionPool connectionPool = destination.getHttpConnectionPool();
+                    ConnectionPool connectionPool = destination.getConnectionPool();
                     for (Connection connection : new ArrayList<>(connectionPool.getActiveConnections()))
                     {
                         HttpConnectionOverHTTP active = (HttpConnectionOverHTTP)connection;
diff --git a/jetty-client/src/test/java/org/eclipse/jetty/client/HttpClientProxyTest.java b/jetty-client/src/test/java/org/eclipse/jetty/client/HttpClientProxyTest.java
index 9f7ff33..78d9784 100644
--- a/jetty-client/src/test/java/org/eclipse/jetty/client/HttpClientProxyTest.java
+++ b/jetty-client/src/test/java/org/eclipse/jetty/client/HttpClientProxyTest.java
@@ -27,7 +27,6 @@
 import javax.servlet.http.HttpServletResponse;
 
 import org.eclipse.jetty.client.api.ContentResponse;
-import org.eclipse.jetty.client.api.ProxyConfiguration;
 import org.eclipse.jetty.client.api.Request;
 import org.eclipse.jetty.client.util.BasicAuthentication;
 import org.eclipse.jetty.http.HttpHeader;
@@ -68,7 +67,7 @@
 
         int proxyPort = connector.getLocalPort();
         int serverPort = proxyPort + 1; // Any port will do for these tests - just not the same as the proxy
-        client.setProxyConfiguration(new ProxyConfiguration("localhost", proxyPort));
+        client.getProxyConfiguration().getProxies().add(new HttpProxy("localhost", proxyPort));
 
         ContentResponse response = client.newRequest(serverHost, serverPort)
                 .scheme(scheme)
@@ -115,7 +114,7 @@
         String proxyHost = "localhost";
         int proxyPort = connector.getLocalPort();
         int serverPort = proxyPort + 1; // Any port will do for these tests - just not the same as the proxy
-        client.setProxyConfiguration(new ProxyConfiguration(proxyHost, proxyPort));
+        client.getProxyConfiguration().getProxies().add(new HttpProxy(proxyHost, proxyPort));
 
         ContentResponse response1 = client.newRequest(serverHost, serverPort)
                 .scheme(scheme)
diff --git a/jetty-client/src/test/java/org/eclipse/jetty/client/HttpClientTest.java b/jetty-client/src/test/java/org/eclipse/jetty/client/HttpClientTest.java
index 974dad8..d261af5 100644
--- a/jetty-client/src/test/java/org/eclipse/jetty/client/HttpClientTest.java
+++ b/jetty-client/src/test/java/org/eclipse/jetty/client/HttpClientTest.java
@@ -51,7 +51,6 @@
 import org.eclipse.jetty.client.api.Response;
 import org.eclipse.jetty.client.api.Result;
 import org.eclipse.jetty.client.http.HttpConnectionOverHTTP;
-import org.eclipse.jetty.client.http.HttpConnectionPool;
 import org.eclipse.jetty.client.http.HttpDestinationOverHTTP;
 import org.eclipse.jetty.client.util.BytesContentProvider;
 import org.eclipse.jetty.http.HttpField;
@@ -85,7 +84,7 @@
         Assert.assertEquals(200, response.getStatus());
 
         HttpDestinationOverHTTP destination = (HttpDestinationOverHTTP)client.getDestination(scheme, host, port);
-        HttpConnectionPool connectionPool = destination.getHttpConnectionPool();
+        ConnectionPool connectionPool = destination.getConnectionPool();
 
         long start = System.nanoTime();
         HttpConnectionOverHTTP connection = null;
@@ -637,7 +636,7 @@
                     public void onBegin(Request request)
                     {
                         HttpDestinationOverHTTP destination = (HttpDestinationOverHTTP)client.getDestination(scheme, host, port);
-                        destination.getHttpConnectionPool().getActiveConnections().peek().close();
+                        destination.getConnectionPool().getActiveConnections().peek().close();
                     }
                 })
                 .send(new Response.Listener.Adapter()
diff --git a/jetty-client/src/test/java/org/eclipse/jetty/client/HttpClientTimeoutTest.java b/jetty-client/src/test/java/org/eclipse/jetty/client/HttpClientTimeoutTest.java
index ccb4842..2b5a822 100644
--- a/jetty-client/src/test/java/org/eclipse/jetty/client/HttpClientTimeoutTest.java
+++ b/jetty-client/src/test/java/org/eclipse/jetty/client/HttpClientTimeoutTest.java
@@ -21,6 +21,7 @@
 import java.io.ByteArrayInputStream;
 import java.io.IOException;
 import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.Executor;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicBoolean;
@@ -35,9 +36,13 @@
 import org.eclipse.jetty.client.api.Response;
 import org.eclipse.jetty.client.api.Result;
 import org.eclipse.jetty.client.http.HttpClientTransportOverHTTP;
+import org.eclipse.jetty.client.http.HttpDestinationOverHTTP;
 import org.eclipse.jetty.client.util.BufferingResponseListener;
 import org.eclipse.jetty.client.util.InputStreamContentProvider;
+import org.eclipse.jetty.io.ByteBufferPool;
+import org.eclipse.jetty.io.ClientConnectionFactory;
 import org.eclipse.jetty.io.EndPoint;
+import org.eclipse.jetty.io.ssl.SslClientConnectionFactory;
 import org.eclipse.jetty.io.ssl.SslConnection;
 import org.eclipse.jetty.server.handler.AbstractHandler;
 import org.eclipse.jetty.toolchain.test.annotation.Slow;
@@ -244,15 +249,30 @@
         client = new HttpClient(new HttpClientTransportOverHTTP()
         {
             @Override
-            protected SslConnection newSslConnection(HttpClient httpClient, EndPoint endPoint, SSLEngine engine)
+            public HttpDestination newHttpDestination(Origin origin)
             {
-                return new SslConnection(httpClient.getByteBufferPool(), httpClient.getExecutor(), endPoint, engine)
+                return new HttpDestinationOverHTTP(getHttpClient(), origin)
                 {
                     @Override
-                    protected boolean onReadTimeout()
+                    protected ClientConnectionFactory newSslClientConnectionFactory(ClientConnectionFactory connectionFactory)
                     {
-                        sslIdle.set(true);
-                        return super.onReadTimeout();
+                        HttpClient client = getHttpClient();
+                        return new SslClientConnectionFactory(client.getSslContextFactory(), client.getByteBufferPool(), client.getExecutor(), connectionFactory)
+                        {
+                            @Override
+                            protected SslConnection newSslConnection(ByteBufferPool byteBufferPool, Executor executor, EndPoint endPoint, SSLEngine engine)
+                            {
+                                return new SslConnection(byteBufferPool, executor, endPoint, engine)
+                                {
+                                    @Override
+                                    protected boolean onReadTimeout()
+                                    {
+                                        sslIdle.set(true);
+                                        return super.onReadTimeout();
+                                    }
+                                };
+                            }
+                        };
                     }
                 };
             }
diff --git a/jetty-client/src/test/java/org/eclipse/jetty/client/HttpConnectionLifecycleTest.java b/jetty-client/src/test/java/org/eclipse/jetty/client/HttpConnectionLifecycleTest.java
index 9fcf5d0..f22bc5e 100644
--- a/jetty-client/src/test/java/org/eclipse/jetty/client/HttpConnectionLifecycleTest.java
+++ b/jetty-client/src/test/java/org/eclipse/jetty/client/HttpConnectionLifecycleTest.java
@@ -33,7 +33,6 @@
 import org.eclipse.jetty.client.api.Request;
 import org.eclipse.jetty.client.api.Response;
 import org.eclipse.jetty.client.api.Result;
-import org.eclipse.jetty.client.http.HttpConnectionPool;
 import org.eclipse.jetty.client.http.HttpDestinationOverHTTP;
 import org.eclipse.jetty.client.util.ByteBufferContentProvider;
 import org.eclipse.jetty.http.HttpHeader;
@@ -68,7 +67,7 @@
         String host = "localhost";
         int port = connector.getLocalPort();
         HttpDestinationOverHTTP destination = (HttpDestinationOverHTTP)client.getDestination(scheme, host, port);
-        HttpConnectionPool connectionPool = destination.getHttpConnectionPool();
+        ConnectionPool connectionPool = destination.getConnectionPool();
 
         final BlockingQueue<Connection> idleConnections = connectionPool.getIdleConnections();
         Assert.assertEquals(0, idleConnections.size());
@@ -129,7 +128,7 @@
         String host = "localhost";
         int port = connector.getLocalPort();
         HttpDestinationOverHTTP destination = (HttpDestinationOverHTTP)client.getDestination(scheme, host, port);
-        HttpConnectionPool connectionPool = destination.getHttpConnectionPool();
+        ConnectionPool connectionPool = destination.getConnectionPool();
 
         final BlockingQueue<Connection> idleConnections = connectionPool.getIdleConnections();
         Assert.assertEquals(0, idleConnections.size());
@@ -180,7 +179,7 @@
         String host = "localhost";
         int port = connector.getLocalPort();
         HttpDestinationOverHTTP destination = (HttpDestinationOverHTTP)client.getDestination(scheme, host, port);
-        HttpConnectionPool connectionPool = destination.getHttpConnectionPool();
+        ConnectionPool connectionPool = destination.getConnectionPool();
 
         final BlockingQueue<Connection> idleConnections = connectionPool.getIdleConnections();
         Assert.assertEquals(0, idleConnections.size());
@@ -240,7 +239,7 @@
         String host = "localhost";
         int port = connector.getLocalPort();
         HttpDestinationOverHTTP destination = (HttpDestinationOverHTTP)client.getDestination(scheme, host, port);
-        HttpConnectionPool connectionPool = destination.getHttpConnectionPool();
+        ConnectionPool connectionPool = destination.getConnectionPool();
 
         final BlockingQueue<Connection> idleConnections = connectionPool.getIdleConnections();
         Assert.assertEquals(0, idleConnections.size());
@@ -313,7 +312,7 @@
         String host = "localhost";
         int port = connector.getLocalPort();
         HttpDestinationOverHTTP destination = (HttpDestinationOverHTTP)client.getDestination(scheme, host, port);
-        HttpConnectionPool connectionPool = destination.getHttpConnectionPool();
+        ConnectionPool connectionPool = destination.getConnectionPool();
 
         final BlockingQueue<Connection> idleConnections = connectionPool.getIdleConnections();
         Assert.assertEquals(0, idleConnections.size());
@@ -366,7 +365,7 @@
         String host = "localhost";
         int port = connector.getLocalPort();
         HttpDestinationOverHTTP destination = (HttpDestinationOverHTTP)client.getDestination(scheme, host, port);
-        HttpConnectionPool connectionPool = destination.getHttpConnectionPool();
+        ConnectionPool connectionPool = destination.getConnectionPool();
 
         final BlockingQueue<Connection> idleConnections = connectionPool.getIdleConnections();
         Assert.assertEquals(0, idleConnections.size());
@@ -416,7 +415,7 @@
             String host = "localhost";
             int port = connector.getLocalPort();
             HttpDestinationOverHTTP destination = (HttpDestinationOverHTTP)client.getDestination(scheme, host, port);
-            HttpConnectionPool connectionPool = destination.getHttpConnectionPool();
+            ConnectionPool connectionPool = destination.getConnectionPool();
 
             final BlockingQueue<Connection> idleConnections = connectionPool.getIdleConnections();
             Assert.assertEquals(0, idleConnections.size());
@@ -466,7 +465,7 @@
         String host = "localhost";
         int port = connector.getLocalPort();
         HttpDestinationOverHTTP destination = (HttpDestinationOverHTTP)client.getDestination(scheme, host, port);
-        HttpConnectionPool connectionPool = destination.getHttpConnectionPool();
+        ConnectionPool connectionPool = destination.getConnectionPool();
 
         final BlockingQueue<Connection> idleConnections = connectionPool.getIdleConnections();
         Assert.assertEquals(0, idleConnections.size());
diff --git a/jetty-client/src/test/java/org/eclipse/jetty/client/http/HttpDestinationOverHTTPTest.java b/jetty-client/src/test/java/org/eclipse/jetty/client/http/HttpDestinationOverHTTPTest.java
index 611335f..f7ed4c9 100644
--- a/jetty-client/src/test/java/org/eclipse/jetty/client/http/HttpDestinationOverHTTPTest.java
+++ b/jetty-client/src/test/java/org/eclipse/jetty/client/http/HttpDestinationOverHTTPTest.java
@@ -24,6 +24,7 @@
 
 import org.eclipse.jetty.client.AbstractHttpClientServerTest;
 import org.eclipse.jetty.client.EmptyServerHandler;
+import org.eclipse.jetty.client.Origin;
 import org.eclipse.jetty.client.api.Connection;
 import org.eclipse.jetty.client.api.ContentResponse;
 import org.eclipse.jetty.client.api.Request;
@@ -52,12 +53,12 @@
     @Test
     public void test_FirstAcquire_WithEmptyQueue() throws Exception
     {
-        HttpDestinationOverHTTP destination = new HttpDestinationOverHTTP(client, "http", "localhost", connector.getLocalPort());
+        HttpDestinationOverHTTP destination = new HttpDestinationOverHTTP(client, new Origin("http", "localhost", connector.getLocalPort()));
         Connection connection = destination.acquire();
         if (connection == null)
         {
             // There are no queued requests, so the newly created connection will be idle
-            connection = destination.getHttpConnectionPool().getIdleConnections().poll(5, TimeUnit.SECONDS);
+            connection = destination.getConnectionPool().getIdleConnections().poll(5, TimeUnit.SECONDS);
         }
         Assert.assertNotNull(connection);
     }
@@ -65,7 +66,7 @@
     @Test
     public void test_SecondAcquire_AfterFirstAcquire_WithEmptyQueue_ReturnsSameConnection() throws Exception
     {
-        HttpDestinationOverHTTP destination = new HttpDestinationOverHTTP(client, "http", "localhost", connector.getLocalPort());
+        HttpDestinationOverHTTP destination = new HttpDestinationOverHTTP(client, new Origin("http", "localhost", connector.getLocalPort()));
         Connection connection1 = destination.acquire();
         if (connection1 == null)
         {
@@ -74,7 +75,7 @@
             while (connection1 == null && TimeUnit.NANOSECONDS.toSeconds(System.nanoTime() - start) < 5)
             {
                 TimeUnit.MILLISECONDS.sleep(50);
-                connection1 = destination.getHttpConnectionPool().getIdleConnections().peek();
+                connection1 = destination.getConnectionPool().getIdleConnections().peek();
             }
             Assert.assertNotNull(connection1);
 
@@ -87,7 +88,7 @@
     public void test_SecondAcquire_ConcurrentWithFirstAcquire_WithEmptyQueue_CreatesTwoConnections() throws Exception
     {
         final CountDownLatch latch = new CountDownLatch(1);
-        HttpDestinationOverHTTP destination = new HttpDestinationOverHTTP(client, "http", "localhost", connector.getLocalPort())
+        HttpDestinationOverHTTP destination = new HttpDestinationOverHTTP(client, new Origin("http", "localhost", connector.getLocalPort()))
         {
             @Override
             protected void process(HttpConnectionOverHTTP connection, boolean dispatch)
@@ -115,23 +116,23 @@
         latch.countDown();
 
         // There must be 2 idle connections
-        Connection connection = destination.getHttpConnectionPool().getIdleConnections().poll(5, TimeUnit.SECONDS);
+        Connection connection = destination.getConnectionPool().getIdleConnections().poll(5, TimeUnit.SECONDS);
         Assert.assertNotNull(connection);
-        connection = destination.getHttpConnectionPool().getIdleConnections().poll(5, TimeUnit.SECONDS);
+        connection = destination.getConnectionPool().getIdleConnections().poll(5, TimeUnit.SECONDS);
         Assert.assertNotNull(connection);
     }
 
     @Test
     public void test_Acquire_Process_Release_Acquire_ReturnsSameConnection() throws Exception
     {
-        HttpDestinationOverHTTP destination = new HttpDestinationOverHTTP(client, "http", "localhost", connector.getLocalPort());
+        HttpDestinationOverHTTP destination = new HttpDestinationOverHTTP(client, new Origin("http", "localhost", connector.getLocalPort()));
         HttpConnectionOverHTTP connection1 = destination.acquire();
 
         long start = System.nanoTime();
         while (connection1 == null && TimeUnit.NANOSECONDS.toSeconds(System.nanoTime() - start) < 5)
         {
             TimeUnit.MILLISECONDS.sleep(50);
-            connection1 = (HttpConnectionOverHTTP)destination.getHttpConnectionPool().getIdleConnections().peek();
+            connection1 = (HttpConnectionOverHTTP)destination.getConnectionPool().getIdleConnections().peek();
         }
         Assert.assertNotNull(connection1);
 
@@ -152,7 +153,7 @@
         long idleTimeout = 1000;
         client.setIdleTimeout(idleTimeout);
 
-        HttpDestinationOverHTTP destination = new HttpDestinationOverHTTP(client, "http", "localhost", connector.getLocalPort());
+        HttpDestinationOverHTTP destination = new HttpDestinationOverHTTP(client, new Origin("http", "localhost", connector.getLocalPort()));
         Connection connection1 = destination.acquire();
         if (connection1 == null)
         {
@@ -161,13 +162,13 @@
             while (connection1 == null && TimeUnit.NANOSECONDS.toSeconds(System.nanoTime() - start) < 5)
             {
                 TimeUnit.MILLISECONDS.sleep(50);
-                connection1 = destination.getHttpConnectionPool().getIdleConnections().peek();
+                connection1 = destination.getConnectionPool().getIdleConnections().peek();
             }
             Assert.assertNotNull(connection1);
 
             TimeUnit.MILLISECONDS.sleep(2 * idleTimeout);
 
-            connection1 = destination.getHttpConnectionPool().getIdleConnections().poll();
+            connection1 = destination.getConnectionPool().getIdleConnections().poll();
             Assert.assertNull(connection1);
         }
     }
diff --git a/jetty-io/src/main/java/org/eclipse/jetty/io/ClientConnectionFactory.java b/jetty-io/src/main/java/org/eclipse/jetty/io/ClientConnectionFactory.java
new file mode 100644
index 0000000..075e261
--- /dev/null
+++ b/jetty-io/src/main/java/org/eclipse/jetty/io/ClientConnectionFactory.java
@@ -0,0 +1,89 @@
+//
+//  ========================================================================
+//  Copyright (c) 1995-2013 Mort Bay Consulting Pty. Ltd.
+//  ------------------------------------------------------------------------
+//  All rights reserved. This program and the accompanying materials
+//  are made available under the terms of the Eclipse Public License v1.0
+//  and Apache License v2.0 which accompanies this distribution.
+//
+//      The Eclipse Public License is available at
+//      http://www.eclipse.org/legal/epl-v10.html
+//
+//      The Apache License v2.0 is available at
+//      http://www.opensource.org/licenses/apache2.0.php
+//
+//  You may elect to redistribute this code under either of these licenses.
+//  ========================================================================
+//
+
+package org.eclipse.jetty.io;
+
+import java.io.IOException;
+import java.util.Map;
+
+import org.eclipse.jetty.util.log.Log;
+import org.eclipse.jetty.util.log.Logger;
+
+/**
+ * Factory for client-side {@link Connection} instances.
+ */
+public interface ClientConnectionFactory
+{
+    /**
+     *
+     * @param endPoint the {@link org.eclipse.jetty.io.EndPoint} to link the newly created connection to
+     * @param context the context data to create the connection
+     * @return a new {@link Connection}
+     * @throws IOException if the connection cannot be created
+     */
+    public Connection newConnection(EndPoint endPoint, Map<String, Object> context) throws IOException;
+
+    public static class Helper
+    {
+        private static Logger LOG = Log.getLogger(Helper.class);
+
+        private Helper()
+        {
+        }
+
+        /**
+         * Replaces the given {@code oldConnection} with the given {@code newConnection} on the
+         * {@link EndPoint} associated with {@code oldConnection}, performing connection lifecycle management.
+         * <p />
+         * The {@code oldConnection} will be closed by invoking {@link org.eclipse.jetty.io.Connection#onClose()}
+         * and the {@code newConnection} will be opened by invoking {@link org.eclipse.jetty.io.Connection#onOpen()}.
+         * @param oldConnection the old connection to replace
+         * @param newConnection the new connection replacement
+         */
+        public static void replaceConnection(Connection oldConnection, Connection newConnection)
+        {
+            close(oldConnection);
+            oldConnection.getEndPoint().setConnection(newConnection);
+            open(newConnection);
+        }
+
+        private static void open(Connection connection)
+        {
+            try
+            {
+                connection.onOpen();
+            }
+            catch (Throwable x)
+            {
+                LOG.debug(x);
+            }
+        }
+
+        private static void close(Connection connection)
+        {
+            try
+            {
+                connection.onClose();
+            }
+            catch (Throwable x)
+            {
+                LOG.debug(x);
+            }
+        }
+    }
+}
diff --git a/jetty-io/src/main/java/org/eclipse/jetty/io/ssl/SslClientConnectionFactory.java b/jetty-io/src/main/java/org/eclipse/jetty/io/ssl/SslClientConnectionFactory.java
new file mode 100644
index 0000000..1289c59
--- /dev/null
+++ b/jetty-io/src/main/java/org/eclipse/jetty/io/ssl/SslClientConnectionFactory.java
@@ -0,0 +1,72 @@
+//
+//  ========================================================================
+//  Copyright (c) 1995-2013 Mort Bay Consulting Pty. Ltd.
+//  ------------------------------------------------------------------------
+//  All rights reserved. This program and the accompanying materials
+//  are made available under the terms of the Eclipse Public License v1.0
+//  and Apache License v2.0 which accompanies this distribution.
+//
+//      The Eclipse Public License is available at
+//      http://www.eclipse.org/legal/epl-v10.html
+//
+//      The Apache License v2.0 is available at
+//      http://www.opensource.org/licenses/apache2.0.php
+//
+//  You may elect to redistribute this code under either of these licenses.
+//  ========================================================================
+//
+
+package org.eclipse.jetty.io.ssl;
+
+import java.io.IOException;
+import java.util.Map;
+import java.util.concurrent.Executor;
+import javax.net.ssl.SSLEngine;
+
+import org.eclipse.jetty.io.ByteBufferPool;
+import org.eclipse.jetty.io.ClientConnectionFactory;
+import org.eclipse.jetty.io.EndPoint;
+import org.eclipse.jetty.util.ssl.SslContextFactory;
+
+public class SslClientConnectionFactory implements ClientConnectionFactory
+{
+    public static final String SSL_PEER_HOST_CONTEXT_KEY = "ssl.peer.host";
+    public static final String SSL_PEER_PORT_CONTEXT_KEY = "ssl.peer.port";
+    public static final String SSL_ENGINE_CONTEXT_KEY = "ssl.engine";
+
+    private final SslContextFactory sslContextFactory;
+    private final ByteBufferPool byteBufferPool;
+    private final Executor executor;
+    private final ClientConnectionFactory connectionFactory;
+
+    public SslClientConnectionFactory(SslContextFactory sslContextFactory, ByteBufferPool byteBufferPool, Executor executor, ClientConnectionFactory connectionFactory)
+    {
+        this.sslContextFactory = sslContextFactory;
+        this.byteBufferPool = byteBufferPool;
+        this.executor = executor;
+        this.connectionFactory = connectionFactory;
+    }
+
+    @Override
+    public org.eclipse.jetty.io.Connection newConnection(EndPoint endPoint, Map<String, Object> context) throws IOException
+    {
+        String host = (String)context.get(SSL_PEER_HOST_CONTEXT_KEY);
+        int port = (Integer)context.get(SSL_PEER_PORT_CONTEXT_KEY);
+        SSLEngine engine = sslContextFactory.newSSLEngine(host, port);
+        engine.setUseClientMode(true);
+        context.put(SSL_ENGINE_CONTEXT_KEY, engine);
+
+        SslConnection sslConnection = newSslConnection(byteBufferPool, executor, endPoint, engine);
+        sslConnection.setRenegotiationAllowed(sslContextFactory.isRenegotiationAllowed());
+        endPoint.setConnection(sslConnection);
+        EndPoint appEndPoint = sslConnection.getDecryptedEndPoint();
+        appEndPoint.setConnection(connectionFactory.newConnection(appEndPoint, context));
+
+        return sslConnection;
+    }
+
+    protected SslConnection newSslConnection(ByteBufferPool byteBufferPool, Executor executor, EndPoint endPoint, SSLEngine engine)
+    {
+        return new SslConnection(byteBufferPool, executor, endPoint, engine);
+    }
+}
diff --git a/jetty-proxy/src/test/java/org/eclipse/jetty/proxy/ProxyServletTest.java b/jetty-proxy/src/test/java/org/eclipse/jetty/proxy/ProxyServletTest.java
index 2d356ed..45c871e 100644
--- a/jetty-proxy/src/test/java/org/eclipse/jetty/proxy/ProxyServletTest.java
+++ b/jetty-proxy/src/test/java/org/eclipse/jetty/proxy/ProxyServletTest.java
@@ -48,8 +48,9 @@
 
 import org.eclipse.jetty.client.HttpClient;
 import org.eclipse.jetty.client.HttpContentResponse;
+import org.eclipse.jetty.client.HttpProxy;
+import org.eclipse.jetty.client.Origin;
 import org.eclipse.jetty.client.api.ContentResponse;
-import org.eclipse.jetty.client.api.ProxyConfiguration;
 import org.eclipse.jetty.client.api.Request;
 import org.eclipse.jetty.client.api.Response;
 import org.eclipse.jetty.client.api.Result;
@@ -110,7 +111,7 @@
     private HttpClient prepareClient() throws Exception
     {
         HttpClient result = new HttpClient();
-        result.setProxyConfiguration(new ProxyConfiguration("localhost", proxyConnector.getLocalPort()));
+        result.getProxyConfiguration().getProxies().add(new HttpProxy("localhost", proxyConnector.getLocalPort()));
         result.start();
         return result;
     }
@@ -236,7 +237,7 @@
         prepareProxy(new ProxyServlet());
 
         HttpClient result = new HttpClient();
-        result.setProxyConfiguration(new ProxyConfiguration("localhost", proxyConnector.getLocalPort()));
+        result.getProxyConfiguration().getProxies().add(new HttpProxy("localhost", proxyConnector.getLocalPort()));
         QueuedThreadPool threadPool = new QueuedThreadPool();
         threadPool.setName("foo");
         threadPool.setMaxThreads(20);
@@ -631,7 +632,7 @@
             }
         });
         int port = serverConnector.getLocalPort();
-        client.getProxyConfiguration().getExcludedOrigins().add("127.0.0.1:" + port);
+        client.getProxyConfiguration().getProxies().get(0).getExcludedOrigins().add(new Origin("http", "127.0.0.1", port));
 
         // Try with a proxied host
         ContentResponse response = client.newRequest("localhost", port)
@@ -865,7 +866,7 @@
             }
         });
 
-        ContentResponse response = client.newRequest("localhost", serverConnector.getLocalPort())
+        client.newRequest("localhost", serverConnector.getLocalPort())
                 .timeout(5, TimeUnit.SECONDS)
                 .send();
 
diff --git a/jetty-proxy/src/test/java/org/eclipse/jetty/proxy/ProxyTunnellingTest.java b/jetty-proxy/src/test/java/org/eclipse/jetty/proxy/ProxyTunnellingTest.java
index 01fa377..d7b55b4 100644
--- a/jetty-proxy/src/test/java/org/eclipse/jetty/proxy/ProxyTunnellingTest.java
+++ b/jetty-proxy/src/test/java/org/eclipse/jetty/proxy/ProxyTunnellingTest.java
@@ -26,17 +26,16 @@
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicReference;
-
 import javax.servlet.ServletException;
 import javax.servlet.ServletOutputStream;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 
 import org.eclipse.jetty.client.HttpClient;
+import org.eclipse.jetty.client.HttpProxy;
 import org.eclipse.jetty.client.api.Connection;
 import org.eclipse.jetty.client.api.ContentResponse;
 import org.eclipse.jetty.client.api.Destination;
-import org.eclipse.jetty.client.api.ProxyConfiguration;
 import org.eclipse.jetty.client.util.FutureResponseListener;
 import org.eclipse.jetty.client.util.StringContentProvider;
 import org.eclipse.jetty.http.HttpHeader;
@@ -143,7 +142,7 @@
         startProxy();
 
         HttpClient httpClient = new HttpClient(sslContextFactory);
-        httpClient.setProxyConfiguration(new ProxyConfiguration("localhost", proxyPort()));
+        httpClient.getProxyConfiguration().getProxies().add(new HttpProxy("localhost", proxyPort()));
         httpClient.start();
 
         try
@@ -172,7 +171,7 @@
         startProxy();
 
         HttpClient httpClient = new HttpClient(sslContextFactory);
-        httpClient.setProxyConfiguration(new ProxyConfiguration("localhost", proxyPort()));
+        httpClient.getProxyConfiguration().getProxies().add(new HttpProxy("localhost", proxyPort()));
         httpClient.start();
 
         try
@@ -215,7 +214,7 @@
         startProxy();
 
         final HttpClient httpClient = new HttpClient(sslContextFactory);
-        httpClient.setProxyConfiguration(new ProxyConfiguration("localhost", proxyPort()));
+        httpClient.getProxyConfiguration().getProxies().add(new HttpProxy("localhost", proxyPort()));
         httpClient.start();
 
         try
@@ -285,7 +284,7 @@
         stopProxy();
 
         HttpClient httpClient = new HttpClient(sslContextFactory);
-        httpClient.setProxyConfiguration(new ProxyConfiguration("localhost", proxyPort));
+        httpClient.getProxyConfiguration().getProxies().add(new HttpProxy("localhost", proxyPort));
         httpClient.start();
 
         try
@@ -317,7 +316,7 @@
         startProxy();
 
         HttpClient httpClient = new HttpClient(sslContextFactory);
-        httpClient.setProxyConfiguration(new ProxyConfiguration("localhost", proxyPort()));
+        httpClient.getProxyConfiguration().getProxies().add(new HttpProxy("localhost", proxyPort()));
         httpClient.start();
 
         try
@@ -354,7 +353,7 @@
         });
 
         HttpClient httpClient = new HttpClient(sslContextFactory);
-        httpClient.setProxyConfiguration(new ProxyConfiguration("localhost", proxyPort()));
+        httpClient.getProxyConfiguration().getProxies().add(new HttpProxy("localhost", proxyPort()));
         httpClient.start();
 
         try
@@ -394,7 +393,7 @@
         sslContextFactory.start();
 
         HttpClient httpClient = new HttpClient(sslContextFactory);
-        httpClient.setProxyConfiguration(new ProxyConfiguration(proxyHost, proxyPort));
+        httpClient.getProxyConfiguration().getProxies().add(new HttpProxy(proxyHost, proxyPort));
         httpClient.start();
 
         try
diff --git a/jetty-spdy/spdy-client/src/main/java/org/eclipse/jetty/spdy/client/NextProtoNegoClientConnection.java b/jetty-spdy/spdy-client/src/main/java/org/eclipse/jetty/spdy/client/NPNClientConnection.java
similarity index 73%
rename from jetty-spdy/spdy-client/src/main/java/org/eclipse/jetty/spdy/client/NextProtoNegoClientConnection.java
rename to jetty-spdy/spdy-client/src/main/java/org/eclipse/jetty/spdy/client/NPNClientConnection.java
index cd745f3..66c1aee 100644
--- a/jetty-spdy/spdy-client/src/main/java/org/eclipse/jetty/spdy/client/NextProtoNegoClientConnection.java
+++ b/jetty-spdy/spdy-client/src/main/java/org/eclipse/jetty/spdy/client/NPNClientConnection.java
@@ -19,38 +19,36 @@
 package org.eclipse.jetty.spdy.client;
 
 import java.io.IOException;
-import java.nio.channels.SocketChannel;
 import java.util.List;
-import java.util.concurrent.Executor;
-
+import java.util.Map;
 import javax.net.ssl.SSLEngine;
 
 import org.eclipse.jetty.io.AbstractConnection;
+import org.eclipse.jetty.io.ClientConnectionFactory;
 import org.eclipse.jetty.io.Connection;
 import org.eclipse.jetty.io.EndPoint;
 import org.eclipse.jetty.io.RuntimeIOException;
-import org.eclipse.jetty.io.ssl.SslConnection.DecryptedEndPoint;
 import org.eclipse.jetty.npn.NextProtoNego;
 import org.eclipse.jetty.util.BufferUtil;
 import org.eclipse.jetty.util.log.Log;
 import org.eclipse.jetty.util.log.Logger;
 
-public class NextProtoNegoClientConnection extends AbstractConnection implements NextProtoNego.ClientProvider
+public class NPNClientConnection extends AbstractConnection implements NextProtoNego.ClientProvider
 {
     private final Logger LOG = Log.getLogger(getClass());
-    private final SocketChannel channel;
-    private final Object attachment;
     private final SPDYClient client;
+    private final ClientConnectionFactory connectionFactory;
     private final SSLEngine engine;
+    private final Map<String, Object> context;
     private volatile boolean completed;
 
-    public NextProtoNegoClientConnection(SocketChannel channel, DecryptedEndPoint endPoint, Object attachment, Executor executor, SPDYClient client)
+    public NPNClientConnection(EndPoint endPoint, SPDYClient client, ClientConnectionFactory connectionFactory, SSLEngine sslEngine, Map<String, Object> context)
     {
-        super(endPoint, executor);
-        this.channel = channel;
-        this.attachment = attachment;
+        super(endPoint, client.getFactory().getExecutor());
         this.client = client;
-        this.engine = endPoint.getSslConnection().getSSLEngine();
+        this.connectionFactory = connectionFactory;
+        this.engine = sslEngine;
+        this.context = context;
         NextProtoNego.put(engine, this);
     }
 
@@ -97,7 +95,7 @@
         {
             LOG.debug(x);
             NextProtoNego.remove(engine);
-            getEndPoint().close();
+            close();
             return -1;
         }
     }
@@ -120,16 +118,22 @@
     {
         NextProtoNego.remove(engine);
         completed = true;
-        String protocol = client.selectProtocol(protocols);
-        return protocol == null ? null : protocol;
+        return client.selectProtocol(protocols);
     }
 
     private void replaceConnection()
     {
         EndPoint endPoint = getEndPoint();
-        Connection connection = client.getConnectionFactory().newConnection(channel, endPoint, attachment);
-        endPoint.getConnection().onClose();
-        endPoint.setConnection(connection);
-        connection.onOpen();
+        try
+        {
+            Connection oldConnection = endPoint.getConnection();
+            Connection newConnection = connectionFactory.newConnection(endPoint, context);
+            ClientConnectionFactory.Helper.replaceConnection(oldConnection, newConnection);
+        }
+        catch (Throwable x)
+        {
+            LOG.debug(x);
+            close();
+        }
     }
 }
diff --git a/jetty-spdy/spdy-client/src/main/java/org/eclipse/jetty/spdy/client/NPNClientConnectionFactory.java b/jetty-spdy/spdy-client/src/main/java/org/eclipse/jetty/spdy/client/NPNClientConnectionFactory.java
new file mode 100644
index 0000000..7e2d472
--- /dev/null
+++ b/jetty-spdy/spdy-client/src/main/java/org/eclipse/jetty/spdy/client/NPNClientConnectionFactory.java
@@ -0,0 +1,47 @@
+//
+//  ========================================================================
+//  Copyright (c) 1995-2013 Mort Bay Consulting Pty. Ltd.
+//  ------------------------------------------------------------------------
+//  All rights reserved. This program and the accompanying materials
+//  are made available under the terms of the Eclipse Public License v1.0
+//  and Apache License v2.0 which accompanies this distribution.
+//
+//      The Eclipse Public License is available at
+//      http://www.eclipse.org/legal/epl-v10.html
+//
+//      The Apache License v2.0 is available at
+//      http://www.opensource.org/licenses/apache2.0.php
+//
+//  You may elect to redistribute this code under either of these licenses.
+//  ========================================================================
+//
+
+package org.eclipse.jetty.spdy.client;
+
+import java.io.IOException;
+import java.util.Map;
+import javax.net.ssl.SSLEngine;
+
+import org.eclipse.jetty.io.ClientConnectionFactory;
+import org.eclipse.jetty.io.Connection;
+import org.eclipse.jetty.io.EndPoint;
+import org.eclipse.jetty.io.ssl.SslClientConnectionFactory;
+
+public class NPNClientConnectionFactory implements ClientConnectionFactory
+{
+    private final SPDYClient client;
+    private final ClientConnectionFactory connectionFactory;
+
+    public NPNClientConnectionFactory(SPDYClient client, ClientConnectionFactory connectionFactory)
+    {
+        this.client = client;
+        this.connectionFactory = connectionFactory;
+    }
+
+    @Override
+    public Connection newConnection(EndPoint endPoint, Map<String, Object> context) throws IOException
+    {
+        return new NPNClientConnection(endPoint, client, connectionFactory,
+                (SSLEngine)context.get(SslClientConnectionFactory.SSL_ENGINE_CONTEXT_KEY), context);
+    }
+}
diff --git a/jetty-spdy/spdy-client/src/main/java/org/eclipse/jetty/spdy/client/SPDYClient.java b/jetty-spdy/spdy-client/src/main/java/org/eclipse/jetty/spdy/client/SPDYClient.java
index 80d2286..974b32a 100644
--- a/jetty-spdy/spdy-client/src/main/java/org/eclipse/jetty/spdy/client/SPDYClient.java
+++ b/jetty-spdy/spdy-client/src/main/java/org/eclipse/jetty/spdy/client/SPDYClient.java
@@ -19,26 +19,28 @@
 package org.eclipse.jetty.spdy.client;
 
 import java.io.IOException;
+import java.net.InetSocketAddress;
 import java.net.SocketAddress;
 import java.nio.channels.SelectionKey;
 import java.nio.channels.SocketChannel;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.Queue;
 import java.util.concurrent.ConcurrentLinkedQueue;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Executor;
-import javax.net.ssl.SSLEngine;
 
 import org.eclipse.jetty.io.ByteBufferPool;
+import org.eclipse.jetty.io.ClientConnectionFactory;
 import org.eclipse.jetty.io.Connection;
 import org.eclipse.jetty.io.EndPoint;
 import org.eclipse.jetty.io.MappedByteBufferPool;
 import org.eclipse.jetty.io.SelectChannelEndPoint;
 import org.eclipse.jetty.io.SelectorManager;
-import org.eclipse.jetty.io.ssl.SslConnection;
-import org.eclipse.jetty.io.ssl.SslConnection.DecryptedEndPoint;
+import org.eclipse.jetty.io.ssl.SslClientConnectionFactory;
 import org.eclipse.jetty.spdy.FlowControlStrategy;
 import org.eclipse.jetty.spdy.api.GoAwayInfo;
 import org.eclipse.jetty.spdy.api.Session;
@@ -55,7 +57,7 @@
 /**
  * A {@link SPDYClient} allows applications to connect to one or more SPDY servers,
  * obtaining {@link Session} objects that can be used to send/receive SPDY frames.
- * <p />
+ * <p/>
  * {@link SPDYClient} instances are created through a {@link Factory}:
  * <pre>
  * SPDYClient.Factory factory = new SPDYClient.Factory();
@@ -70,19 +72,113 @@
  */
 public class SPDYClient
 {
-    private final SPDYClientConnectionFactory connectionFactory = new SPDYClientConnectionFactory();
-    final short version;
-    final Factory factory;
+    private final short version;
+    private final Factory factory;
     private volatile SocketAddress bindAddress;
     private volatile long idleTimeout = -1;
     private volatile int initialWindowSize;
-    private volatile boolean executeOnFillable;
+    private volatile boolean dispatchIO;
+    private volatile ClientConnectionFactory connectionFactory;
 
     protected SPDYClient(short version, Factory factory)
     {
         this.version = version;
         this.factory = factory;
         setInitialWindowSize(65536);
+        setDispatchIO(true);
+        ClientConnectionFactory connectionFactory = new SPDYClientConnectionFactory();
+        if (factory.sslContextFactory != null)
+            connectionFactory = new SslClientConnectionFactory(factory.getSslContextFactory(), factory.getByteBufferPool(), factory.getExecutor(), new NPNClientConnectionFactory(this, connectionFactory));
+        setClientConnectionFactory(connectionFactory);
+    }
+
+    public short getVersion()
+    {
+        return version;
+    }
+
+    public Factory getFactory()
+    {
+        return factory;
+    }
+
+    /**
+     * Equivalent to:
+     * <pre>
+     * Future&lt;Session&gt; promise = new FuturePromise&lt;&gt;();
+     * connect(address, listener, promise);
+     * </pre>
+     *
+     * @param address  the address to connect to
+     * @param listener the session listener that will be notified of session events
+     * @return a {@link Session} when connected
+     */
+    public Session connect(SocketAddress address, SessionFrameListener listener) throws ExecutionException, InterruptedException
+    {
+        FuturePromise<Session> promise = new FuturePromise<>();
+        connect(address, listener, promise);
+        return promise.get();
+    }
+
+    /**
+     * Equivalent to:
+     * <pre>
+     * connect(address, listener, promise, null);
+     * </pre>
+     *
+     * @param address  the address to connect to
+     * @param listener the session listener that will be notified of session events
+     * @param promise  the promise notified of connection success/failure
+     */
+    public void connect(SocketAddress address, SessionFrameListener listener, Promise<Session> promise)
+    {
+        connect(address, listener, promise, new HashMap<String, Object>());
+    }
+
+    /**
+     * Connects to the given {@code address}, binding the given {@code listener} to session events,
+     * and notified the given {@code promise} of the connect result.
+     * <p/>
+     * If the connect operation is successful, the {@code promise} will be invoked with the {@link Session}
+     * object that applications can use to perform SPDY requests.
+     *
+     * @param address  the address to connect to
+     * @param listener the session listener that will be notified of session events
+     * @param promise  the promise notified of connection success/failure
+     * @param context  a context object passed to the {@link #getClientConnectionFactory() ConnectionFactory}
+     *                 for the creation of the connection
+     */
+    public void connect(final SocketAddress address, final SessionFrameListener listener, final Promise<Session> promise, Map<String, Object> context)
+    {
+        if (!factory.isStarted())
+            throw new IllegalStateException(Factory.class.getSimpleName() + " is not started");
+
+        try
+        {
+            SocketChannel channel = SocketChannel.open();
+            if (bindAddress != null)
+                channel.bind(bindAddress);
+            configure(channel);
+            channel.configureBlocking(false);
+            channel.connect(address);
+
+            context.put(SslClientConnectionFactory.SSL_PEER_HOST_CONTEXT_KEY, ((InetSocketAddress)address).getHostString());
+            context.put(SslClientConnectionFactory.SSL_PEER_PORT_CONTEXT_KEY, ((InetSocketAddress)address).getPort());
+            context.put(SPDYClientConnectionFactory.SPDY_CLIENT_CONTEXT_KEY, this);
+            context.put(SPDYClientConnectionFactory.SPDY_SESSION_LISTENER_CONTEXT_KEY, listener);
+            context.put(SPDYClientConnectionFactory.SPDY_SESSION_PROMISE_CONTEXT_KEY, promise);
+
+            factory.selector.connect(channel, context);
+        }
+        catch (IOException x)
+        {
+            promise.failed(x);
+        }
+    }
+
+    protected void configure(SocketChannel channel) throws IOException
+    {
+        channel.socket().setTcpNoDelay(true);
     }
 
     /**
@@ -103,59 +199,6 @@
         this.bindAddress = bindAddress;
     }
 
-    /**
-     * Equivalent to:
-     * <pre>
-     * Future&lt;Session&gt; promise = new FuturePromise&lt;&gt;();
-     * connect(address, listener, promise);
-     * </pre>
-     *
-     * @param address the address to connect to
-     * @param listener the session listener that will be notified of session events
-     * @return a {@link Session} when connected
-     */
-    public Session connect(SocketAddress address, SessionFrameListener listener) throws ExecutionException, InterruptedException
-    {
-        FuturePromise<Session> promise = new FuturePromise<>();
-        connect(address, listener, promise);
-        return promise.get();
-    }
-
-    /**
-     * Connects to the given {@code address}, binding the given {@code listener} to session events,
-     * and notified the given {@code promise} of the connect result.
-     * <p />
-     * If the connect operation is successful, the {@code promise} will be invoked with the {@link Session}
-     * object that applications can use to perform SPDY requests.
-     *
-     * @param address the address to connect to
-     * @param listener the session listener that will be notified of session events
-     * @param promise the promise notified of connection success/failure
-     */
-    public void connect(SocketAddress address, SessionFrameListener listener, Promise<Session> promise)
-    {
-        if (!factory.isStarted())
-            throw new IllegalStateException(Factory.class.getSimpleName() + " is not started");
-
-        try
-        {
-            SocketChannel channel = SocketChannel.open();
-            if (bindAddress != null)
-                channel.bind(bindAddress);
-            channel.socket().setTcpNoDelay(true);
-            channel.configureBlocking(false);
-
-            SessionPromise result = new SessionPromise(promise, channel, this, listener);
-
-            channel.connect(address);
-            factory.selector.connect(channel, result);
-        }
-        catch (IOException x)
-        {
-            promise.failed(x);
-        }
-    }
-
     public long getIdleTimeout()
     {
         return idleTimeout;
@@ -176,14 +219,24 @@
         this.initialWindowSize = initialWindowSize;
     }
 
-    public boolean isExecuteOnFillable()
+    public boolean isDispatchIO()
     {
-        return executeOnFillable;
+        return dispatchIO;
     }
 
-    public void setExecuteOnFillable(boolean executeOnFillable)
+    public void setDispatchIO(boolean dispatchIO)
     {
-        this.executeOnFillable = executeOnFillable;
+        this.dispatchIO = dispatchIO;
+    }
+
+    public ClientConnectionFactory getClientConnectionFactory()
+    {
+        return connectionFactory;
+    }
+
+    public void setClientConnectionFactory(ClientConnectionFactory connectionFactory)
+    {
+        this.connectionFactory = connectionFactory;
     }
 
     protected String selectProtocol(List<String> serverProtocols)
@@ -197,20 +250,6 @@
         return null;
     }
 
-    public SPDYClientConnectionFactory getConnectionFactory()
-    {
-        return connectionFactory;
-    }
-
-    protected SSLEngine newSSLEngine(SslContextFactory sslContextFactory, SocketChannel channel)
-    {
-        String peerHost = channel.socket().getInetAddress().getHostName();
-        int peerPort = channel.socket().getPort();
-        SSLEngine engine = sslContextFactory.newSSLEngine(peerHost, peerPort);
-        engine.setUseClientMode(true);
-        return engine;
-    }
-
     protected FlowControlStrategy newFlowControlStrategy()
     {
         return FlowControlStrategyFactory.newFlowControlStrategy(version);
@@ -225,7 +264,7 @@
         private final SslContextFactory sslContextFactory;
         private final SelectorManager selector;
         private final long idleTimeout;
-        private long connectTimeout = 15000;
+        private long connectTimeout;
 
         public Factory()
         {
@@ -255,6 +294,7 @@
         public Factory(Executor executor, Scheduler scheduler, SslContextFactory sslContextFactory, long idleTimeout)
         {
             this.idleTimeout = idleTimeout;
+            setConnectTimeout(15000);
 
             if (executor == null)
                 executor = new QueuedThreadPool();
@@ -290,6 +330,11 @@
             return executor;
         }
 
+        public SslContextFactory getSslContextFactory()
+        {
+            return sslContextFactory;
+        }
+
         public long getConnectTimeout()
         {
             return connectTimeout;
@@ -347,89 +392,33 @@
             @Override
             protected EndPoint newEndPoint(SocketChannel channel, ManagedSelector selectSet, SelectionKey key) throws IOException
             {
-                SessionPromise attachment = (SessionPromise)key.attachment();
-
-                long clientIdleTimeout = attachment.client.getIdleTimeout();
+                @SuppressWarnings("unchecked")
+                Map<String, Object> context = (Map<String, Object>)key.attachment();
+                SPDYClient client = (SPDYClient)context.get(SPDYClientConnectionFactory.SPDY_CLIENT_CONTEXT_KEY);
+                long clientIdleTimeout = client.getIdleTimeout();
                 if (clientIdleTimeout < 0)
                     clientIdleTimeout = idleTimeout;
-
                 return new SelectChannelEndPoint(channel, selectSet, key, getScheduler(), clientIdleTimeout);
             }
 
             @Override
-            public Connection newConnection(final SocketChannel channel, EndPoint endPoint, final Object attachment)
+            public Connection newConnection(SocketChannel channel, EndPoint endPoint, Object attachment) throws IOException
             {
-                SessionPromise sessionPromise = (SessionPromise)attachment;
-                final SPDYClient client = sessionPromise.client;
-
+                @SuppressWarnings("unchecked")
+                Map<String, Object> context = (Map<String, Object>)attachment;
                 try
                 {
-                    if (sslContextFactory != null)
-                    {
-                        final SSLEngine engine = client.newSSLEngine(sslContextFactory, channel);
-                        SslConnection sslConnection = new SslConnection(bufferPool, getExecutor(), endPoint, engine);
-                        sslConnection.setRenegotiationAllowed(sslContextFactory.isRenegotiationAllowed());
-                        DecryptedEndPoint sslEndPoint = sslConnection.getDecryptedEndPoint();
-                        NextProtoNegoClientConnection connection = new NextProtoNegoClientConnection(channel, sslEndPoint, attachment, getExecutor(), client);
-                        sslEndPoint.setConnection(connection);
-                        return sslConnection;
-                    }
-
-                    SPDYClientConnectionFactory connectionFactory = new SPDYClientConnectionFactory();
-                    return connectionFactory.newConnection(channel, endPoint, attachment);
+                    SPDYClient client = (SPDYClient)context.get(SPDYClientConnectionFactory.SPDY_CLIENT_CONTEXT_KEY);
+                    return client.getClientConnectionFactory().newConnection(endPoint, context);
                 }
-                catch (RuntimeException x)
+                catch (Throwable x)
                 {
-                    sessionPromise.failed(x);
+                    @SuppressWarnings("unchecked")
+                    Promise<Session> promise = (Promise<Session>)context.get(SPDYClientConnectionFactory.SPDY_SESSION_PROMISE_CONTEXT_KEY);
+                    promise.failed(x);
                     throw x;
                 }
             }
         }
     }
-
-    static class SessionPromise extends FuturePromise<Session>
-    {
-        private final SocketChannel channel;
-        private final Promise<Session> wrappedPromise;
-        final SPDYClient client;
-        final SessionFrameListener listener;
-
-        private SessionPromise(Promise<Session> promise, SocketChannel channel, SPDYClient client,
-                               SessionFrameListener listener)
-        {
-            this.channel = channel;
-            this.client = client;
-            this.listener = listener;
-            this.wrappedPromise = promise;
-        }
-
-        @Override
-        public void succeeded(Session result)
-        {
-            wrappedPromise.succeeded(result);
-            super.succeeded(result);
-        }
-
-        @Override
-        public void failed(Throwable cause)
-        {
-            wrappedPromise.failed(cause);
-            super.failed(cause);
-        }
-
-        @Override
-        public boolean cancel(boolean mayInterruptIfRunning)
-        {
-            try
-            {
-                super.cancel(mayInterruptIfRunning);
-                channel.close();
-                return true;
-            }
-            catch (IOException x)
-            {
-                return true;
-            }
-        }
-    }
 }
diff --git a/jetty-spdy/spdy-client/src/main/java/org/eclipse/jetty/spdy/client/SPDYClientConnectionFactory.java b/jetty-spdy/spdy-client/src/main/java/org/eclipse/jetty/spdy/client/SPDYClientConnectionFactory.java
index 18244e8..dae5268 100644
--- a/jetty-spdy/spdy-client/src/main/java/org/eclipse/jetty/spdy/client/SPDYClientConnectionFactory.java
+++ b/jetty-spdy/spdy-client/src/main/java/org/eclipse/jetty/spdy/client/SPDYClientConnectionFactory.java
@@ -18,46 +18,54 @@
 
 package org.eclipse.jetty.spdy.client;
 
-import java.nio.channels.SocketChannel;
+import java.io.IOException;
+import java.util.Map;
 
 import org.eclipse.jetty.io.ByteBufferPool;
+import org.eclipse.jetty.io.ClientConnectionFactory;
 import org.eclipse.jetty.io.Connection;
 import org.eclipse.jetty.io.EndPoint;
 import org.eclipse.jetty.spdy.CompressionFactory;
 import org.eclipse.jetty.spdy.FlowControlStrategy;
 import org.eclipse.jetty.spdy.StandardCompressionFactory;
 import org.eclipse.jetty.spdy.StandardSession;
+import org.eclipse.jetty.spdy.api.Session;
+import org.eclipse.jetty.spdy.api.SessionFrameListener;
 import org.eclipse.jetty.spdy.client.SPDYClient.Factory;
-import org.eclipse.jetty.spdy.client.SPDYClient.SessionPromise;
 import org.eclipse.jetty.spdy.generator.Generator;
 import org.eclipse.jetty.spdy.parser.Parser;
+import org.eclipse.jetty.util.Promise;
 
-public class SPDYClientConnectionFactory
+public class SPDYClientConnectionFactory implements ClientConnectionFactory
 {
-    public Connection newConnection(SocketChannel channel, EndPoint endPoint, Object attachment)
-    {
-        SessionPromise sessionPromise = (SessionPromise)attachment;
-        SPDYClient client = sessionPromise.client;
-        Factory factory = client.factory;
-        ByteBufferPool bufferPool = factory.getByteBufferPool();
+    public static final String SPDY_CLIENT_CONTEXT_KEY = "spdy.client";
+    public static final String SPDY_SESSION_LISTENER_CONTEXT_KEY = "spdy.session.listener";
+    public static final String SPDY_SESSION_PROMISE_CONTEXT_KEY = "spdy.session.promise";
 
+    @Override
+    public Connection newConnection(EndPoint endPoint, Map<String, Object> context) throws IOException
+    {
+        SPDYClient client = (SPDYClient)context.get(SPDY_CLIENT_CONTEXT_KEY);
+        SPDYClient.Factory factory = client.getFactory();
+        ByteBufferPool byteBufferPool = factory.getByteBufferPool();
         CompressionFactory compressionFactory = new StandardCompressionFactory();
         Parser parser = new Parser(compressionFactory.newDecompressor());
-        Generator generator = new Generator(bufferPool, compressionFactory.newCompressor());
+        Generator generator = new Generator(byteBufferPool, compressionFactory.newCompressor());
 
-        SPDYConnection connection = new ClientSPDYConnection(endPoint, bufferPool, parser, factory, client.isExecuteOnFillable());
+        SPDYConnection connection = new ClientSPDYConnection(endPoint, byteBufferPool, parser, factory, client.isDispatchIO());
 
         FlowControlStrategy flowControlStrategy = client.newFlowControlStrategy();
 
-        StandardSession session = new StandardSession(client.version, bufferPool, factory.getExecutor(),
-                factory.getScheduler(), connection, endPoint, connection, 1, sessionPromise.listener, generator,
-                flowControlStrategy);
+        SessionFrameListener listener = (SessionFrameListener)context.get(SPDY_SESSION_LISTENER_CONTEXT_KEY);
+        StandardSession session = new StandardSession(client.getVersion(), byteBufferPool, factory.getExecutor(),
+                factory.getScheduler(), connection, endPoint, connection, 1, listener, generator, flowControlStrategy);
         session.setWindowSize(client.getInitialWindowSize());
         parser.addListener(session);
-        sessionPromise.succeeded(session);
         connection.setSession(session);
 
-        factory.sessionOpened(session);
+        @SuppressWarnings("unchecked")
+        Promise<Session> promise = (Promise<Session>)context.get(SPDY_SESSION_PROMISE_CONTEXT_KEY);
+        promise.succeeded(session);
 
         return connection;
     }
@@ -66,14 +74,20 @@
     {
         private final Factory factory;
 
-        public ClientSPDYConnection(EndPoint endPoint, ByteBufferPool bufferPool, Parser parser, Factory factory,
-                                    boolean executeOnFillable)
+        public ClientSPDYConnection(EndPoint endPoint, ByteBufferPool bufferPool, Parser parser, Factory factory, boolean dispatchIO)
         {
-            super(endPoint, bufferPool, parser, factory.getExecutor(), executeOnFillable);
+            super(endPoint, bufferPool, parser, factory.getExecutor(), dispatchIO);
             this.factory = factory;
         }
 
         @Override
+        public void onOpen()
+        {
+            super.onOpen();
+            factory.sessionOpened(getSession());
+        }
+
+        @Override
         public void onClose()
         {
             super.onClose();
diff --git a/jetty-spdy/spdy-client/src/main/java/org/eclipse/jetty/spdy/client/SPDYConnection.java b/jetty-spdy/spdy-client/src/main/java/org/eclipse/jetty/spdy/client/SPDYConnection.java
index e1217a5..b66edba 100644
--- a/jetty-spdy/spdy-client/src/main/java/org/eclipse/jetty/spdy/client/SPDYConnection.java
+++ b/jetty-spdy/spdy-client/src/main/java/org/eclipse/jetty/spdy/client/SPDYConnection.java
@@ -44,26 +44,20 @@
     private volatile ISession session;
     private volatile boolean idle = false;
 
-    public SPDYConnection(EndPoint endPoint, ByteBufferPool bufferPool, Parser parser, Executor executor,
-                          boolean executeOnFillable)
+    public SPDYConnection(EndPoint endPoint, ByteBufferPool bufferPool, Parser parser, Executor executor, boolean dispatchIO)
     {
-        this(endPoint, bufferPool, parser, executor, executeOnFillable, 8192);
+        this(endPoint, bufferPool, parser, executor, dispatchIO, 8192);
     }
 
-    public SPDYConnection(EndPoint endPoint, ByteBufferPool bufferPool, Parser parser, Executor executor,
-                          boolean executeOnFillable, int bufferSize)
+    public SPDYConnection(EndPoint endPoint, ByteBufferPool bufferPool, Parser parser, Executor executor, boolean dispatchIO, int bufferSize)
     {
         // Since SPDY is multiplexed, onFillable() must never block while calling application code. In fact,
         // the SPDY code always dispatches to a new thread when calling application code,
-        // so here we can safely pass false as last parameter, and avoid to dispatch to onFillable(). The IO
-        // operation (read, parse, etc.) will not block and will be fast in almost all cases. Big uploads to a server
-        // however might block the Selector thread for a long time and therefore block other connections to be read.
-        // This might be a good reason to set executeOnFillable to true.
-        //
-        // Due to a jvm bug we've had a Selector thread being stuck at
-        // sun.nio.ch.FileDispatcherImpl.preClose0(Native Method). That's why we now default executeOnFillable to
-        // true even if for most use cases it is faster to not dispatch the IO events.
-        super(endPoint, executor, executeOnFillable);
+        // so here we can safely pass false as last parameter, and avoid to dispatch to onFillable().
+        // The IO operation (read, parse, etc.) will not block and will be fast in almost all cases.
+        // Big uploads to a server, however, might occupy the Selector thread for a long time and
+        // therefore starve other connections, so by default dispatchIO is true.
+        super(endPoint, executor, dispatchIO);
         this.bufferPool = bufferPool;
         this.parser = parser;
         onIdle(true);
diff --git a/jetty-spdy/spdy-http-client-transport/src/main/java/org/eclipse/jetty/spdy/client/http/HttpClientTransportOverSPDY.java b/jetty-spdy/spdy-http-client-transport/src/main/java/org/eclipse/jetty/spdy/client/http/HttpClientTransportOverSPDY.java
index b2fb3a6..813f550 100644
--- a/jetty-spdy/spdy-http-client-transport/src/main/java/org/eclipse/jetty/spdy/client/http/HttpClientTransportOverSPDY.java
+++ b/jetty-spdy/spdy-http-client-transport/src/main/java/org/eclipse/jetty/spdy/client/http/HttpClientTransportOverSPDY.java
@@ -18,12 +18,17 @@
 
 package org.eclipse.jetty.spdy.client.http;
 
+import java.io.IOException;
 import java.net.SocketAddress;
+import java.util.Map;
 
 import org.eclipse.jetty.client.HttpClient;
 import org.eclipse.jetty.client.HttpClientTransport;
 import org.eclipse.jetty.client.HttpDestination;
+import org.eclipse.jetty.client.Origin;
 import org.eclipse.jetty.client.api.Connection;
+import org.eclipse.jetty.io.ClientConnectionFactory;
+import org.eclipse.jetty.io.EndPoint;
 import org.eclipse.jetty.spdy.api.Session;
 import org.eclipse.jetty.spdy.api.SessionFrameListener;
 import org.eclipse.jetty.spdy.client.SPDYClient;
@@ -32,11 +37,22 @@
 public class HttpClientTransportOverSPDY implements HttpClientTransport
 {
     private final SPDYClient client;
-    private volatile HttpClient httpClient;
+    private final ClientConnectionFactory connectionFactory;
+    private HttpClient httpClient;
 
     public HttpClientTransportOverSPDY(SPDYClient client)
     {
         this.client = client;
+        this.connectionFactory = client.getClientConnectionFactory();
+        client.setClientConnectionFactory(new ClientConnectionFactory()
+        {
+            @Override
+            public org.eclipse.jetty.io.Connection newConnection(EndPoint endPoint, Map<String, Object> context) throws IOException
+            {
+                HttpDestination destination = (HttpDestination)context.get(HTTP_DESTINATION_CONTEXT_KEY);
+                return destination.getClientConnectionFactory().newConnection(endPoint, context);
+            }
+        });
     }
 
     @Override
@@ -46,51 +62,46 @@
     }
 
     @Override
-    public HttpDestination newHttpDestination(String scheme, String host, int port)
+    public HttpDestination newHttpDestination(Origin origin)
     {
-        return new HttpDestinationOverSPDY(httpClient, scheme, host, port);
+        return new HttpDestinationOverSPDY(httpClient, origin);
     }
 
     @Override
-    public void connect(final HttpDestination destination, SocketAddress address, final Promise<Connection> promise)
+    public void connect(SocketAddress address, Map<String, Object> context)
     {
+        final HttpDestination destination = (HttpDestination)context.get(HTTP_DESTINATION_CONTEXT_KEY);
+        @SuppressWarnings("unchecked")
+        final Promise<Connection> promise = (Promise<Connection>)context.get(HTTP_CONNECTION_PROMISE_CONTEXT_KEY);
+
         SessionFrameListener.Adapter listener = new SessionFrameListener.Adapter()
         {
             @Override
             public void onFailure(Session session, Throwable x)
             {
-                // TODO: is this correct ?
-                // TODO: if I get a stream error (e.g. invalid response headers)
-                // TODO: I must abort the *current* exchange, while below I will abort
-                // TODO: the queued exchanges only.
-                // TODO: The problem is that a single destination/connection multiplexes
-                // TODO: several exchanges, so I would need to cancel them all,
-                // TODO: or only the one that failed ?
                 destination.abort(x);
             }
         };
 
         client.connect(address, listener, new Promise<Session>()
-                {
-                    @Override
-                    public void succeeded(Session session)
-                    {
-                        Connection result = new HttpConnectionOverSPDY(destination, session);
-                        promise.succeeded(result);
-                    }
+        {
+            @Override
+            public void succeeded(Session session)
+            {
+                promise.succeeded(new HttpConnectionOverSPDY(destination, session));
+            }
 
-                    @Override
-                    public void failed(Throwable x)
-                    {
-                        promise.failed(x);
-                    }
-                }
-        );
+            @Override
+            public void failed(Throwable x)
+            {
+                promise.failed(x);
+            }
+        }, context);
     }
 
     @Override
-    public Connection tunnel(Connection connection)
+    public org.eclipse.jetty.io.Connection newConnection(EndPoint endPoint, Map<String, Object> context) throws IOException
     {
-        throw new UnsupportedOperationException();
+        return connectionFactory.newConnection(endPoint, context);
     }
 }
diff --git a/jetty-spdy/spdy-http-client-transport/src/main/java/org/eclipse/jetty/spdy/client/http/HttpDestinationOverSPDY.java b/jetty-spdy/spdy-http-client-transport/src/main/java/org/eclipse/jetty/spdy/client/http/HttpDestinationOverSPDY.java
index 321fb99..10ff922 100644
--- a/jetty-spdy/spdy-http-client-transport/src/main/java/org/eclipse/jetty/spdy/client/http/HttpDestinationOverSPDY.java
+++ b/jetty-spdy/spdy-http-client-transport/src/main/java/org/eclipse/jetty/spdy/client/http/HttpDestinationOverSPDY.java
@@ -21,12 +21,13 @@
 import org.eclipse.jetty.client.HttpClient;
 import org.eclipse.jetty.client.HttpExchange;
 import org.eclipse.jetty.client.MultiplexHttpDestination;
+import org.eclipse.jetty.client.Origin;
 
 public class HttpDestinationOverSPDY extends MultiplexHttpDestination<HttpConnectionOverSPDY>
 {
-    public HttpDestinationOverSPDY(HttpClient client, String scheme, String host, int port)
+    public HttpDestinationOverSPDY(HttpClient client, Origin origin)
     {
-        super(client, scheme, host, port);
+        super(client, origin);
     }
 
     @Override
@@ -34,4 +35,12 @@
     {
         connection.send(exchange);
     }
+
+    @Override
+    public void abort(Throwable cause)
+    {
+        // TODO: in case of connection failure, we need to abort also
+        // TODO: all pending exchanges, so we need to track them.
+        super.abort(cause);
+    }
 }
diff --git a/jetty-spdy/spdy-http-client-transport/src/test/java/org/eclipse/jetty/spdy/client/http/HttpClientCustomProxyTest.java b/jetty-spdy/spdy-http-client-transport/src/test/java/org/eclipse/jetty/spdy/client/http/HttpClientCustomProxyTest.java
new file mode 100644
index 0000000..7b06d39
--- /dev/null
+++ b/jetty-spdy/spdy-http-client-transport/src/test/java/org/eclipse/jetty/spdy/client/http/HttpClientCustomProxyTest.java
@@ -0,0 +1,261 @@
+//
+//  ========================================================================
+//  Copyright (c) 1995-2013 Mort Bay Consulting Pty. Ltd.
+//  ------------------------------------------------------------------------
+//  All rights reserved. This program and the accompanying materials
+//  are made available under the terms of the Eclipse Public License v1.0
+//  and Apache License v2.0 which accompanies this distribution.
+//
+//      The Eclipse Public License is available at
+//      http://www.eclipse.org/legal/epl-v10.html
+//
+//      The Apache License v2.0 is available at
+//      http://www.opensource.org/licenses/apache2.0.php
+//
+//  You may elect to redistribute this code under either of these licenses.
+//  ========================================================================
+//
+
+package org.eclipse.jetty.spdy.client.http;
+
+import java.io.IOException;
+import java.net.URI;
+import java.nio.ByteBuffer;
+import java.util.Map;
+import java.util.concurrent.Executor;
+import java.util.concurrent.TimeUnit;
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.eclipse.jetty.client.HttpClient;
+import org.eclipse.jetty.client.HttpClientTransport;
+import org.eclipse.jetty.client.HttpDestination;
+import org.eclipse.jetty.client.Origin;
+import org.eclipse.jetty.client.ProxyConfiguration;
+import org.eclipse.jetty.client.api.Connection;
+import org.eclipse.jetty.client.api.ContentResponse;
+import org.eclipse.jetty.http.HttpStatus;
+import org.eclipse.jetty.io.AbstractConnection;
+import org.eclipse.jetty.io.ClientConnectionFactory;
+import org.eclipse.jetty.io.EndPoint;
+import org.eclipse.jetty.server.AbstractConnectionFactory;
+import org.eclipse.jetty.server.Connector;
+import org.eclipse.jetty.server.Handler;
+import org.eclipse.jetty.server.HttpConfiguration;
+import org.eclipse.jetty.server.Server;
+import org.eclipse.jetty.server.ServerConnector;
+import org.eclipse.jetty.server.handler.AbstractHandler;
+import org.eclipse.jetty.spdy.api.SPDY;
+import org.eclipse.jetty.spdy.client.SPDYClient;
+import org.eclipse.jetty.spdy.server.http.HTTPSPDYServerConnectionFactory;
+import org.eclipse.jetty.spdy.server.http.PushStrategy;
+import org.eclipse.jetty.util.BufferUtil;
+import org.eclipse.jetty.util.Callback;
+import org.eclipse.jetty.util.Promise;
+import org.eclipse.jetty.util.thread.QueuedThreadPool;
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class HttpClientCustomProxyTest
+{
+    public static final byte[] CAFE_BABE = new byte[]{(byte)0xCA, (byte)0xFE, (byte)0xBA, (byte)0xBE};
+
+    private Server server;
+    private ServerConnector connector;
+    private SPDYClient.Factory factory;
+    private HttpClient httpClient;
+
+    public void prepare(Handler handler) throws Exception
+    {
+        server = new Server();
+        connector = new ServerConnector(server, new CAFEBABEServerConnectionFactory(new HTTPSPDYServerConnectionFactory(SPDY.V3, new HttpConfiguration(), new PushStrategy.None())));
+        server.addConnector(connector);
+        server.setHandler(handler);
+        server.start();
+
+        QueuedThreadPool executor = new QueuedThreadPool();
+        executor.setName(executor.getName() + "-client");
+
+        factory = new SPDYClient.Factory(executor);
+        factory.start();
+
+        httpClient = new HttpClient(new HttpClientTransportOverSPDY(factory.newSPDYClient(SPDY.V3)), null);
+        httpClient.setExecutor(executor);
+        httpClient.start();
+    }
+
+    @After
+    public void dispose() throws Exception
+    {
+        if (httpClient != null)
+            httpClient.stop();
+        if (factory != null)
+            factory.stop();
+        if (server != null)
+            server.stop();
+    }
+
+    @Test
+    public void testCustomProxy() throws Exception
+    {
+        final String serverHost = "server";
+        final int status = HttpStatus.NO_CONTENT_204;
+        prepare(new AbstractHandler()
+        {
+            @Override
+            public void handle(String target, org.eclipse.jetty.server.Request baseRequest, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException
+            {
+                baseRequest.setHandled(true);
+                if (!URI.create(baseRequest.getUri().toString()).isAbsolute())
+                    response.setStatus(HttpServletResponse.SC_USE_PROXY);
+                else if (serverHost.equals(request.getServerName()))
+                    response.setStatus(status);
+                else
+                    response.setStatus(HttpServletResponse.SC_NOT_ACCEPTABLE);
+            }
+        });
+
+        // Setup the custom proxy
+        int proxyPort = connector.getLocalPort();
+        int serverPort = proxyPort + 1; // Any port will do for these tests - just not the same as the proxy
+        httpClient.getProxyConfiguration().getProxies().add(new CAFEBABEProxy(new Origin.Address("localhost", proxyPort), false));
+
+        ContentResponse response = httpClient.newRequest(serverHost, serverPort)
+                .timeout(5, TimeUnit.SECONDS)
+                .send();
+
+        Assert.assertEquals(status, response.getStatus());
+    }
+
+    private class CAFEBABEProxy extends ProxyConfiguration.Proxy
+    {
+        private CAFEBABEProxy(Origin.Address address, boolean secure)
+        {
+            super(address, secure);
+        }
+
+        @Override
+        public ClientConnectionFactory newClientConnectionFactory(ClientConnectionFactory connectionFactory)
+        {
+            return new CAFEBABEClientConnectionFactory(connectionFactory);
+        }
+    }
+
+    private static class CAFEBABEClientConnectionFactory implements ClientConnectionFactory
+    {
+        private final ClientConnectionFactory connectionFactory;
+
+        private CAFEBABEClientConnectionFactory(ClientConnectionFactory connectionFactory)
+        {
+            this.connectionFactory = connectionFactory;
+        }
+
+        @Override
+        public org.eclipse.jetty.io.Connection newConnection(EndPoint endPoint, Map<String, Object> context) throws IOException
+        {
+            HttpDestination destination = (HttpDestination)context.get(HttpClientTransport.HTTP_DESTINATION_CONTEXT_KEY);
+            Executor executor = destination.getHttpClient().getExecutor();
+            return new CAFEBABEConnection(endPoint, executor, connectionFactory, context);
+        }
+    }
+
+    private static class CAFEBABEConnection extends AbstractConnection
+    {
+        private final ClientConnectionFactory connectionFactory;
+        private final Map<String, Object> context;
+
+        public CAFEBABEConnection(EndPoint endPoint, Executor executor, ClientConnectionFactory connectionFactory, Map<String, Object> context)
+        {
+            super(endPoint, executor);
+            this.connectionFactory = connectionFactory;
+            this.context = context;
+        }
+
+        @Override
+        public void onOpen()
+        {
+            super.onOpen();
+            fillInterested();
+            getEndPoint().write(new Callback.Adapter(), ByteBuffer.wrap(CAFE_BABE));
+        }
+
+        @Override
+        public void onFillable()
+        {
+            try
+            {
+                ByteBuffer buffer = BufferUtil.allocate(4);
+                int filled = getEndPoint().fill(buffer);
+                Assert.assertEquals(4, filled);
+                Assert.assertArrayEquals(CAFE_BABE, buffer.array());
+
+                // We are good, upgrade the connection
+                ClientConnectionFactory.Helper.replaceConnection(this, connectionFactory.newConnection(getEndPoint(), context));
+            }
+            catch (Throwable x)
+            {
+                close();
+                @SuppressWarnings("unchecked")
+                Promise<Connection> promise = (Promise<Connection>)context.get(HttpClientTransport.HTTP_CONNECTION_PROMISE_CONTEXT_KEY);
+                promise.failed(x);
+            }
+        }
+    }
+
+    private class CAFEBABEServerConnectionFactory extends AbstractConnectionFactory
+    {
+        private final org.eclipse.jetty.server.ConnectionFactory connectionFactory;
+
+        private CAFEBABEServerConnectionFactory(org.eclipse.jetty.server.ConnectionFactory connectionFactory)
+        {
+            super("cafebabe");
+            this.connectionFactory = connectionFactory;
+        }
+
+        @Override
+        public org.eclipse.jetty.io.Connection newConnection(Connector connector, EndPoint endPoint)
+        {
+            return new CAFEBABEServerConnection(connector, endPoint, connectionFactory);
+        }
+    }
+
+    private class CAFEBABEServerConnection extends AbstractConnection
+    {
+        private final org.eclipse.jetty.server.ConnectionFactory connectionFactory;
+
+        public CAFEBABEServerConnection(Connector connector, EndPoint endPoint, org.eclipse.jetty.server.ConnectionFactory connectionFactory)
+        {
+            super(endPoint, connector.getExecutor());
+            this.connectionFactory = connectionFactory;
+        }
+
+        @Override
+        public void onOpen()
+        {
+            super.onOpen();
+            fillInterested();
+        }
+
+        @Override
+        public void onFillable()
+        {
+            try
+            {
+                ByteBuffer buffer = BufferUtil.allocate(4);
+                int filled = getEndPoint().fill(buffer);
+                Assert.assertEquals(4, filled);
+                Assert.assertArrayEquals(CAFE_BABE, buffer.array());
+                getEndPoint().write(new Callback.Adapter(), buffer);
+
+                // We are good, upgrade the connection
+                ClientConnectionFactory.Helper.replaceConnection(this, connectionFactory.newConnection(connector, getEndPoint()));
+            }
+            catch (Throwable x)
+            {
+                close();
+            }
+        }
+    }
+}
diff --git a/jetty-spdy/spdy-server/src/main/java/org/eclipse/jetty/spdy/server/SPDYServerConnectionFactory.java b/jetty-spdy/spdy-server/src/main/java/org/eclipse/jetty/spdy/server/SPDYServerConnectionFactory.java
index 5e6815b..147c03c 100644
--- a/jetty-spdy/spdy-server/src/main/java/org/eclipse/jetty/spdy/server/SPDYServerConnectionFactory.java
+++ b/jetty-spdy/spdy-server/src/main/java/org/eclipse/jetty/spdy/server/SPDYServerConnectionFactory.java
@@ -42,14 +42,10 @@
 import org.eclipse.jetty.util.Callback;
 import org.eclipse.jetty.util.annotation.ManagedAttribute;
 import org.eclipse.jetty.util.annotation.ManagedObject;
-import org.eclipse.jetty.util.log.Log;
-import org.eclipse.jetty.util.log.Logger;
 
 @ManagedObject("SPDY Server Connection Factory")
 public class SPDYServerConnectionFactory extends AbstractConnectionFactory
 {
-    private static final Logger LOG = Log.getLogger(SPDYServerConnectionFactory.class);
-
     // This method is placed here so as to provide a check for NPN before attempting to load any
     // NPN classes.
     public static void checkNPNAvailable()
@@ -66,11 +62,11 @@
         }
     }
 
+    private final Queue<Session> sessions = new ConcurrentLinkedQueue<>();
     private final short version;
     private final ServerSessionFrameListener listener;
     private int initialWindowSize;
-    private boolean executeOnFillable = true;
-    private final Queue<Session> sessions = new ConcurrentLinkedQueue<>();
+    private boolean dispatchIO;
 
     public SPDYServerConnectionFactory(int version)
     {
@@ -83,6 +79,7 @@
         this.version = (short)version;
         this.listener = listener;
         setInitialWindowSize(65536);
+        setDispatchIO(true);
     }
 
     @ManagedAttribute("SPDY version")
@@ -105,14 +102,14 @@
 
         ServerSessionFrameListener listener = provideServerSessionFrameListener(connector, endPoint);
         SPDYConnection connection = new ServerSPDYConnection(connector, endPoint, parser, listener,
-                executeOnFillable, getInputBufferSize());
+                isDispatchIO(), getInputBufferSize());
 
         FlowControlStrategy flowControlStrategy = newFlowControlStrategy(version);
 
         StandardSession session = new StandardSession(getVersion(), connector.getByteBufferPool(),
                 connector.getExecutor(), connector.getScheduler(), connection, endPoint, connection, 2, listener,
                 generator, flowControlStrategy);
-        session.setWindowSize(initialWindowSize);
+        session.setWindowSize(getInitialWindowSize());
         parser.addListener(session);
         connection.setSession(session);
 
@@ -142,15 +139,15 @@
         this.initialWindowSize = initialWindowSize;
     }
 
-    @ManagedAttribute("Execute onFillable")
-    public boolean isExecuteOnFillable()
+    @ManagedAttribute("Dispatch I/O to a pooled thread")
+    public boolean isDispatchIO()
     {
-        return executeOnFillable;
+        return dispatchIO;
     }
 
-    public void setExecuteOnFillable(boolean executeOnFillable)
+    public void setDispatchIO(boolean dispatchIO)
     {
-        this.executeOnFillable = executeOnFillable;
+        this.dispatchIO = dispatchIO;
     }
 
     protected boolean sessionOpened(Session session)
@@ -191,10 +188,10 @@
         private final AtomicBoolean connected = new AtomicBoolean();
 
         private ServerSPDYConnection(Connector connector, EndPoint endPoint, Parser parser,
-                                     ServerSessionFrameListener listener, boolean executeOnFillable, int bufferSize)
+                                     ServerSessionFrameListener listener, boolean dispatchIO, int bufferSize)
         {
             super(endPoint, connector.getByteBufferPool(), parser, connector.getExecutor(),
-                    executeOnFillable, bufferSize);
+                    dispatchIO, bufferSize);
             this.listener = listener;
         }