nit

* rename forceConnect into performConnectRequest
* drop performingNextRequest that was no longer used

Author: slandelle

Diff for: client/src/main/java/org/asynchttpclient/netty/request/NettyRequestFactory.java

@@ -123,10 +123,10 @@ public void setProxyAuthorizationHeader(HttpHeaders headers, String proxyAuthori
             headers.set(PROXY_AUTHORIZATION, proxyAuthorizationHeader);
     }
 
-    public NettyRequest newNettyRequest(Request request, boolean forceConnect, ProxyServer proxyServer, Realm realm, Realm proxyRealm) {
+    public NettyRequest newNettyRequest(Request request, boolean performConnectRequest, ProxyServer proxyServer, Realm realm, Realm proxyRealm) {
 
         Uri uri = request.getUri();
-        HttpMethod method = forceConnect ? HttpMethod.CONNECT : HttpMethod.valueOf(request.getMethod());
+        HttpMethod method = performConnectRequest ? HttpMethod.CONNECT : HttpMethod.valueOf(request.getMethod());
         boolean connect = method == HttpMethod.CONNECT;
 
         HttpVersion httpVersion = HttpVersion.HTTP_1_1;

Diff for: client/src/main/java/org/asynchttpclient/netty/request/NettyRequestSender.java

@@ -113,17 +113,15 @@ public <T> ListenableFuture<T> sendRequest(final Request request, //
             // Proxy with HTTPS or WebSocket: CONNECT for sure
             if (future != null && future.isConnectAllowed()) {
                 // Perform CONNECT
-                return sendRequestWithCertainForceConnect(request, asyncHandler, future, performingNextRequest,
-                        proxyServer, true);
+                return sendRequestWithCertainForceConnect(request, asyncHandler, future, proxyServer, true);
             } else {
                 // CONNECT will depend if we can pool or connection or if we have to open a new
                 // one
-                return sendRequestThroughSslProxy(request, asyncHandler, future, performingNextRequest, proxyServer);
+                return sendRequestThroughSslProxy(request, asyncHandler, future, proxyServer);
             }
         } else {
             // no CONNECT for sure
-            return sendRequestWithCertainForceConnect(request, asyncHandler, future, performingNextRequest, proxyServer,
-                    false);
+            return sendRequestWithCertainForceConnect(request, asyncHandler, future, proxyServer, false);
         }
     }
 
@@ -143,57 +141,58 @@ private <T> ListenableFuture<T> sendRequestWithCertainForceConnect(//
             Request request, //
             AsyncHandler<T> asyncHandler, //
             NettyResponseFuture<T> future, //
-            boolean performingNextRequest, //
             ProxyServer proxyServer, //
-            boolean forceConnect) {
+            boolean performConnectRequest) {
 
         NettyResponseFuture<T> newFuture = newNettyRequestAndResponseFuture(request, asyncHandler, future, proxyServer,
-                forceConnect);
+                performConnectRequest);
 
         Channel channel = getOpenChannel(future, request, proxyServer, asyncHandler);
 
-        if (Channels.isChannelActive(channel))
-            return sendRequestWithOpenChannel(request, proxyServer, newFuture, asyncHandler, channel);
-        else
-            return sendRequestWithNewChannel(request, proxyServer, newFuture, asyncHandler, performingNextRequest);
+        return Channels.isChannelActive(channel)
+                ? sendRequestWithOpenChannel(request, proxyServer, newFuture, asyncHandler, channel)
+                : sendRequestWithNewChannel(request, proxyServer, newFuture, asyncHandler);
     }
 
     /**
      * Using CONNECT depends on wither we can fetch a valid channel or not Loop
      * until we get a valid channel from the pool and it's still valid once the
      * request is built @
      */
-    @SuppressWarnings("unused")
     private <T> ListenableFuture<T> sendRequestThroughSslProxy(//
             Request request, //
             AsyncHandler<T> asyncHandler, //
             NettyResponseFuture<T> future, //
-            boolean performingNextRequest, //
             ProxyServer proxyServer) {
 
         NettyResponseFuture<T> newFuture = null;
         for (int i = 0; i < 3; i++) {
             Channel channel = getOpenChannel(future, request, proxyServer, asyncHandler);
-            if (Channels.isChannelActive(channel))
-                if (newFuture == null)
-                    newFuture = newNettyRequestAndResponseFuture(request, asyncHandler, future, proxyServer, false);
 
-            if (Channels.isChannelActive(channel))
-                // if the channel is still active, we can use it, otherwise try
-                // gain
-                return sendRequestWithOpenChannel(request, proxyServer, newFuture, asyncHandler, channel);
-            else
+            if (channel == null) {
                 // pool is empty
                 break;
+            }
+
+            if (newFuture == null) {
+                newFuture = newNettyRequestAndResponseFuture(request, asyncHandler, future, proxyServer, false);
+            }
+
+            if (Channels.isChannelActive(channel)) {
+                // if the channel is still active, we can use it,
+                // otherwise, channel was closed by the time we computed the request, try again
+                return sendRequestWithOpenChannel(request, proxyServer, newFuture, asyncHandler, channel);
+            }
         }
 
+        // couldn't poll an active channel
         newFuture = newNettyRequestAndResponseFuture(request, asyncHandler, future, proxyServer, true);
-        return sendRequestWithNewChannel(request, proxyServer, newFuture, asyncHandler, performingNextRequest);
+        return sendRequestWithNewChannel(request, proxyServer, newFuture, asyncHandler);
     }
 
     private <T> NettyResponseFuture<T> newNettyRequestAndResponseFuture(final Request request,
             final AsyncHandler<T> asyncHandler, NettyResponseFuture<T> originalFuture, ProxyServer proxy,
-            boolean forceConnect) {
+            boolean performConnectRequest) {
 
         Realm realm = null;
         if (originalFuture != null) {
@@ -212,7 +211,8 @@ private <T> NettyResponseFuture<T> newNettyRequestAndResponseFuture(final Reques
             proxyRealm = proxy.getRealm();
         }
 
-        NettyRequest nettyRequest = requestFactory.newNettyRequest(request, forceConnect, proxy, realm, proxyRealm);
+        NettyRequest nettyRequest = requestFactory.newNettyRequest(request, performConnectRequest, proxy, realm,
+                proxyRealm);
 
         if (originalFuture == null) {
             NettyResponseFuture<T> future = newNettyResponseFuture(request, asyncHandler, nettyRequest, proxy);
@@ -284,8 +284,7 @@ private <T> ListenableFuture<T> sendRequestWithNewChannel(//
             Request request, //
             ProxyServer proxy, //
             NettyResponseFuture<T> future, //
-            AsyncHandler<T> asyncHandler, //
-            boolean performingNextRequest) {
+            AsyncHandler<T> asyncHandler) {
 
         // some headers are only set when performing the first request
         HttpHeaders headers = future.getNettyRequest().getHttpRequest().headers();