Cleanup and doc

src/main/java/io/vertx/core/http/impl/Http2ClientConnection.java

@@ -56,8 +56,7 @@ public Http2ClientConnection(ConnectionListener<HttpClientConnection> listener,
                                HttpClientImpl client,
                                ContextImpl context,
                                VertxHttp2ConnectionHandler connHandler,
-                               HttpClientMetrics metrics,
-                               Handler<AsyncResult<HttpClientConnection>> resultHandler) {
+                               HttpClientMetrics metrics) {
     super(context, connHandler);
     this.metrics = metrics;
     this.queueMetric = queueMetric;

src/main/java/io/vertx/core/http/impl/HttpChannelConnector.java

@@ -42,10 +42,7 @@
 import javax.net.ssl.SSLHandshakeException;
 
 /**
- * The ChannelConnector performs the channel configuration and connection according to the
- * client options and the protocol version.
- * When the channel connects or fails to connect, it calls back the ConnQueue that initiated the
- * connection.
+ * Performs the channel configuration and connection according to the client options and the protocol version.
  */
 class HttpChannelConnector implements ConnectionProvider<HttpClientConnection> {
 
@@ -239,7 +236,7 @@ private void handshakeFailure(Channel ch, Throwable cause, Handler<AsyncResult<H
     connectFailed(ch, handler, sslException);
   }
 
-  private void http1xConnected(ConnectionListener<HttpClientConnection> queue,
+  private void http1xConnected(ConnectionListener<HttpClientConnection> listener,
                                HttpVersion version,
                                String host,
                                int port,
@@ -248,60 +245,57 @@ private void http1xConnected(ConnectionListener<HttpClientConnection> queue,
                                ContextImpl context,
                                Channel ch,
                                Handler<AsyncResult<HttpClientConnection>> handler) {
-    synchronized (this) {
-      ClientHandler clientHandler = new ClientHandler(
-        queue,
-        context,
-        version,
-        host,
-        port,
-        ssl,
-        client,
-        endpointMetric,
-        client.metrics());
-      clientHandler.addHandler(conn -> {
-        handler.handle(Future.succeededFuture(conn));
-      });
-      clientHandler.removeHandler(conn -> {
-        queue.onClose(conn, ch);
-      });
-      ch.pipeline().addLast("handler", clientHandler);
-    }
+    ClientHandler clientHandler = new ClientHandler(
+      listener,
+      context,
+      version,
+      host,
+      port,
+      ssl,
+      client,
+      endpointMetric,
+      client.metrics());
+    clientHandler.addHandler(conn -> {
+      handler.handle(Future.succeededFuture(conn));
+    });
+    clientHandler.removeHandler(conn -> {
+      listener.onClose(conn, ch);
+    });
+    ch.pipeline().addLast("handler", clientHandler);
   }
 
-  private void http2Connected(ConnectionListener<HttpClientConnection> queue, Object endpointMetric, ContextImpl context, Channel ch, Handler<AsyncResult<HttpClientConnection>> resultHandler) {
+  private void http2Connected(ConnectionListener<HttpClientConnection> listener,
+                              Object endpointMetric,
+                              ContextImpl context,
+                              Channel ch,
+                              Handler<AsyncResult<HttpClientConnection>> resultHandler) {
     try {
-      synchronized (this) {
-        boolean upgrade;
-        upgrade = ch.pipeline().get(SslHandler.class) == null && options.isHttp2ClearTextUpgrade();
-        VertxHttp2ConnectionHandler<Http2ClientConnection> handler = new VertxHttp2ConnectionHandlerBuilder<Http2ClientConnection>(ch)
-          .server(false)
-          .clientUpgrade(upgrade)
-          .useCompression(client.getOptions().isTryUseCompression())
-          .initialSettings(client.getOptions().getInitialSettings())
-          .connectionFactory(connHandler -> {
-            Http2ClientConnection conn = new Http2ClientConnection(queue, endpointMetric, client, context, connHandler, metrics, resultHandler);
-            return conn;
-          })
-          .logEnabled(options.getLogActivity())
-          .build();
-        handler.addHandler(conn -> {
-          if (options.getHttp2ConnectionWindowSize() > 0) {
-            conn.setWindowSize(options.getHttp2ConnectionWindowSize());
-          }
-          if (metrics != null) {
-            Object metric = metrics.connected(conn.remoteAddress(), conn.remoteName());
-            conn.metric(metric);
-          }
-          resultHandler.handle(Future.succeededFuture(conn));
-        });
-        handler.removeHandler(conn -> {
-          if (metrics != null) {
-            metrics.endpointDisconnected(endpointMetric, conn.metric());
-          }
-          queue.onClose(conn, ch);
-        });
-      }
+      boolean upgrade;
+      upgrade = ch.pipeline().get(SslHandler.class) == null && options.isHttp2ClearTextUpgrade();
+      VertxHttp2ConnectionHandler<Http2ClientConnection> handler = new VertxHttp2ConnectionHandlerBuilder<Http2ClientConnection>(ch)
+        .server(false)
+        .clientUpgrade(upgrade)
+        .useCompression(client.getOptions().isTryUseCompression())
+        .initialSettings(client.getOptions().getInitialSettings())
+        .connectionFactory(connHandler -> new Http2ClientConnection(listener, endpointMetric, client, context, connHandler, metrics))
+        .logEnabled(options.getLogActivity())
+        .build();
+      handler.addHandler(conn -> {
+        if (options.getHttp2ConnectionWindowSize() > 0) {
+          conn.setWindowSize(options.getHttp2ConnectionWindowSize());
+        }
+        if (metrics != null) {
+          Object metric = metrics.connected(conn.remoteAddress(), conn.remoteName());
+          conn.metric(metric);
+        }
+        resultHandler.handle(Future.succeededFuture(conn));
+      });
+      handler.removeHandler(conn -> {
+        if (metrics != null) {
+          metrics.endpointDisconnected(endpointMetric, conn.metric());
+        }
+        listener.onClose(conn, ch);
+      });
     } catch (Exception e) {
       connectFailed(ch, resultHandler, e);
     }

src/main/java/io/vertx/core/http/impl/HttpClientImpl.java

@@ -159,7 +159,7 @@ public HttpClientImpl(VertxInternal vertx, HttpClientOptions options) {
     }
 
     ConnectionProvider<HttpClientConnection> connector = new HttpChannelConnector(this);
-    Function<SocketAddress, ConnectionPool<HttpClientConnection>> poolFactory = sa -> new HttpClientPool(options.getProtocolVersion(), options, sa.host(), sa.port());
+    Function<SocketAddress, ConnectionPool<HttpClientConnection>> poolFactory = sa -> new HttpConnectionPool(options.getProtocolVersion(), options);
 
     wsCM = new ConnectionManager<>(vertx, metrics, connector, poolFactory, options.getMaxWaitQueueSize());
     httpCM = new ConnectionManager<>(vertx, metrics, connector, poolFactory, options.getMaxWaitQueueSize());

src/main/java/io/vertx/core/http/impl/HttpClientPool.java → src/main/java/io/vertx/core/http/impl/HttpConnectionPool.java

@@ -23,40 +23,33 @@
 
 import java.util.*;
 
-class HttpClientPool implements ConnectionPool<HttpClientConnection> {
+/**
+ * The logic for the connection pool for HTTP:
+ *
+ * - HTTP/1.x pools several connections
+ * - HTTP/2 uses can multiplex on a single connections but can handle several connections
+ * <p/>
+ * When this pool is initialized with an HTTP/2 pool, this pool can be changed to an HTTP/1/1
+ * pool if the remote server does not support HTTP/2 or after ALPN negotiation.
+ * <p/>
+ * In this case further connections will be HTTP/1.1 connections, until the pool is closed.
+ */
+class HttpConnectionPool implements ConnectionPool<HttpClientConnection> {
 
   private ConnectionPool<? extends HttpClientConnection> current;
   private final HttpClientOptions options;
-  private final String host;
-  private final int port;
-  private final boolean ssl;
   private HttpVersion version;
 
-  HttpClientPool(HttpVersion version, HttpClientOptions options, String host, int port) {
+  HttpConnectionPool(HttpVersion version, HttpClientOptions options) {
     this.version = version;
     this.options = options;
-    this.host = host;
-    this.port = port;
-    this.ssl = options.isSsl();
     if (version == HttpVersion.HTTP_2) {
       current =  new Http2();
     } else {
       current = new Http1x();
     }
   }
 
-  String host() {
-    return host;
-  }
-
-  int port() {
-    return port;
-  }
-
-  boolean ssl() {
-    return ssl;
-  }
-
   private void fallbackToHttp1x(HttpVersion version) {
     this.current = new Http1x();
     this.version = version;

src/main/java/io/vertx/core/http/impl/pool/ConnectionListener.java

@@ -17,6 +17,9 @@
 
 import io.netty.channel.Channel;
 
+/**
+ * The listener is used by the {@link ConnectionProvider} to interact with the connection manager.
+ */
 public interface ConnectionListener<C> {
 
   void onRecycle(C conn);

src/main/java/io/vertx/core/http/impl/pool/ConnectionManager.java

@@ -137,13 +137,6 @@ public void close() {
 
   /**
    * The connection queue delegates to the connection pool, the pooling strategy.
-   *
-   * - HTTP/1.x pools several connections
-   * - HTTP/2 uses a single connection
-   *
-   * After a queue is initialized with an HTTP/2 pool, this pool changed to an HTTP/1/1
-   * pool if the server does not support HTTP/2 or after negotiation. In this situation
-   * all waiters on this queue will use HTTP/1.1 connections.
    */
   class ConnQueue implements ConnectionListener<C> {
 

src/main/java/io/vertx/core/http/impl/pool/ConnectionPool.java

@@ -18,7 +18,7 @@
 import io.vertx.core.impl.ContextImpl;
 
 /**
- * The logic for the connection pool because HTTP/1 and HTTP/2 have different pooling logics.
+ * The logic for the connection pool.
  */
 public interface ConnectionPool<C> {
 

src/main/java/io/vertx/core/http/impl/pool/ConnectionProvider.java

@@ -21,6 +21,9 @@
 import io.vertx.core.Handler;
 import io.vertx.core.impl.ContextImpl;
 
+/**
+ * Provides how the connection manager interacts its connections.
+ */
 public interface ConnectionProvider<C> {
 
   void connect(