/*
    * ====================================================================
    * Licensed to the Apache Software Foundation (ASF) under one
    * or more contributor license agreements.  See the NOTICE file
    * distributed with this work for additional information
    * regarding copyright ownership.  The ASF licenses this file
    * to you under the Apache License, Version 2.0 (the
    * "License"); you may not use this file except in compliance
    * with the License.  You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing,
   * software distributed under the License is distributed on an
   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
   * KIND, either express or implied.  See the License for the
   * specific language governing permissions and limitations
   * under the License.
   * ====================================================================
   *
   * This software consists of voluntary contributions made by many
   * individuals on behalf of the Apache Software Foundation.  For more
   * information on the Apache Software Foundation, please see
   * <http://www.apache.org/>.
   *
   */
  
  package org.apache.http.impl.client;
  
  import java.io.Closeable;
  import java.net.ProxySelector;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.LinkedList;
  import java.util.List;
  
  import javax.net.ssl.SSLContext;
  
  import org.apache.http.ConnectionReuseStrategy;
  import org.apache.http.Header;
  import org.apache.http.HttpHost;
  import org.apache.http.HttpRequestInterceptor;
  import org.apache.http.HttpResponseInterceptor;
  import org.apache.http.annotation.NotThreadSafe;
  import org.apache.http.auth.AuthSchemeProvider;
  import org.apache.http.client.AuthenticationStrategy;
  import org.apache.http.client.BackoffManager;
  import org.apache.http.client.ConnectionBackoffStrategy;
  import org.apache.http.client.CookieStore;
  import org.apache.http.client.CredentialsProvider;
  import org.apache.http.client.HttpClient;
  import org.apache.http.client.HttpRequestRetryHandler;
  import org.apache.http.client.RedirectStrategy;
  import org.apache.http.client.ServiceUnavailableRetryStrategy;
  import org.apache.http.client.UserTokenHandler;
  import org.apache.http.client.config.AuthSchemes;
  import org.apache.http.client.config.CookieSpecs;
  import org.apache.http.client.config.RequestConfig;
  import org.apache.http.client.protocol.RequestAcceptEncoding;
  import org.apache.http.client.protocol.RequestAddCookies;
  import org.apache.http.client.protocol.RequestAuthCache;
  import org.apache.http.client.protocol.RequestClientConnControl;
  import org.apache.http.client.protocol.RequestDefaultHeaders;
  import org.apache.http.client.protocol.RequestExpectContinue;
  import org.apache.http.client.protocol.ResponseContentEncoding;
  import org.apache.http.client.protocol.ResponseProcessCookies;
  import org.apache.http.config.ConnectionConfig;
  import org.apache.http.config.Lookup;
  import org.apache.http.config.RegistryBuilder;
  import org.apache.http.config.SocketConfig;
  import org.apache.http.conn.ConnectionKeepAliveStrategy;
  import org.apache.http.conn.HttpClientConnectionManager;
  import org.apache.http.conn.SchemePortResolver;
  import org.apache.http.conn.routing.HttpRoutePlanner;
  import org.apache.http.conn.socket.ConnectionSocketFactory;
  import org.apache.http.conn.socket.LayeredConnectionSocketFactory;
  import org.apache.http.conn.socket.PlainSocketFactory;
  import org.apache.http.conn.ssl.SSLSocketFactory;
  import org.apache.http.cookie.CookieSpecProvider;
  import org.apache.http.impl.DefaultConnectionReuseStrategy;
  import org.apache.http.impl.NoConnectionReuseStrategy;
  import org.apache.http.impl.auth.BasicSchemeFactory;
  import org.apache.http.impl.auth.DigestSchemeFactory;
  import org.apache.http.impl.auth.KerberosSchemeFactory;
  import org.apache.http.impl.auth.NTLMSchemeFactory;
  import org.apache.http.impl.auth.SPNegoSchemeFactory;
  import org.apache.http.impl.conn.DefaultProxyRoutePlanner;
  import org.apache.http.impl.conn.DefaultRoutePlanner;
  import org.apache.http.impl.conn.DefaultSchemePortResolver;
  import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
  import org.apache.http.impl.conn.SystemDefaultRoutePlanner;
  import org.apache.http.impl.cookie.BestMatchSpecFactory;
  import org.apache.http.impl.cookie.BrowserCompatSpecFactory;
  import org.apache.http.impl.cookie.IgnoreSpecFactory;
  import org.apache.http.impl.cookie.NetscapeDraftSpecFactory;
  import org.apache.http.impl.cookie.RFC2109SpecFactory;
  import org.apache.http.impl.cookie.RFC2965SpecFactory;
  import org.apache.http.impl.execchain.BackoffStrategyExec;
  import org.apache.http.impl.execchain.ClientExecChain;
 import org.apache.http.impl.execchain.MainClientExec;
 import org.apache.http.impl.execchain.ProtocolExec;
 import org.apache.http.impl.execchain.RedirectExec;
 import org.apache.http.impl.execchain.RetryExec;
 import org.apache.http.impl.execchain.ServiceUnavailableRetryExec;
 import org.apache.http.protocol.HttpProcessor;
 import org.apache.http.protocol.HttpProcessorBuilder;
 import org.apache.http.protocol.HttpRequestExecutor;
 import org.apache.http.protocol.RequestContent;
 import org.apache.http.protocol.RequestTargetHost;
 import org.apache.http.protocol.RequestUserAgent;
 import org.apache.http.util.VersionInfo;
 
 /**
  * {@link HttpClient} builder.
  * <p>
  * The following system properties are taken into account by this class
  *  if the {@link #useSystemProperties()} method is called.
  * <ul>
  *  <li>ssl.TrustManagerFactory.algorithm</li>
  *  <li>javax.net.ssl.trustStoreType</li>
  *  <li>javax.net.ssl.trustStore</li>
  *  <li>javax.net.ssl.trustStoreProvider</li>
  *  <li>javax.net.ssl.trustStorePassword</li>
  *  <li>java.home</li>
  *  <li>ssl.KeyManagerFactory.algorithm</li>
  *  <li>javax.net.ssl.keyStoreType</li>
  *  <li>javax.net.ssl.keyStore</li>
  *  <li>javax.net.ssl.keyStoreProvider</li>
  *  <li>javax.net.ssl.keyStorePassword</li>
  *  <li>http.proxyHost</li>
  *  <li>http.proxyPort</li>
  *  <li>http.nonProxyHosts</li>
  *  <li>http.keepAlive</li>
  *  <li>http.maxConnections</li>
  *  <li>http.agent</li>
  * </ul>
  * </p>
  *
  * @since 4.3
  */
 @NotThreadSafe
 public class HttpClientBuilder {
 
     private HttpRequestExecutor requestExec;
     private LayeredConnectionSocketFactory sslSocketFactory;
     private SSLContext sslcontext;
     private HttpClientConnectionManager connManager;
     private SchemePortResolver schemePortResolver;
     private ConnectionReuseStrategy reuseStrategy;
     private ConnectionKeepAliveStrategy keepAliveStrategy;
     private AuthenticationStrategy targetAuthStrategy;
     private AuthenticationStrategy proxyAuthStrategy;
     private UserTokenHandler userTokenHandler;
     private HttpProcessor httpprocessor;
 
     private LinkedList<HttpRequestInterceptor> requestFirst;
     private LinkedList<HttpRequestInterceptor> requestLast;
     private LinkedList<HttpResponseInterceptor> responseFirst;
     private LinkedList<HttpResponseInterceptor> responseLast;
 
     private HttpRequestRetryHandler retryHandler;
     private HttpRoutePlanner routePlanner;
     private RedirectStrategy redirectStrategy;
     private ConnectionBackoffStrategy connectionBackoffStrategy;
     private BackoffManager backoffManager;
     private ServiceUnavailableRetryStrategy serviceUnavailStrategy;
     private Lookup<AuthSchemeProvider> authSchemeRegistry;
     private Lookup<CookieSpecProvider> cookieSpecRegistry;
     private CookieStore cookieStore;
     private CredentialsProvider credentialsProvider;
     private String userAgent;
     private HttpHost proxy;
     private Collection<? extends Header> defaultHeaders;
     private SocketConfig defaultSocketConfig;
     private ConnectionConfig defaultConnectionConfig;
     private RequestConfig defaultRequestConfig;
 
     private boolean systemProperties;
     private boolean redirectHandlingDisabled;
     private boolean automaticRetriesDisabled;
     private boolean contentCompressionDisabled;
     private boolean cookieManagementDisabled;
     private boolean authCachingDisabled;
     private boolean connectionStateDisabled;
 
     private int maxConnTotal = 0;
     private int maxConnPerRoute = 0;
 
     private List<Closeable> closeables;
 
     public static HttpClientBuilder create() {
         return new HttpClientBuilder();
     }
 
     protected HttpClientBuilder() {
         super();
     }
 
     public final HttpClientBuilder setRequestExecutor(final HttpRequestExecutor requestExec) {
         this.requestExec = requestExec;
         return this;
     }
 
     public final HttpClientBuilder setSSLSocketFactory(
             final LayeredConnectionSocketFactory sslSocketFactory) {
         this.sslSocketFactory = sslSocketFactory;
         return this;
     }
 
     public final HttpClientBuilder setConnectionManager(
             final HttpClientConnectionManager connManager) {
         this.connManager = connManager;
         return this;
     }
 
     public final HttpClientBuilder setSchemePortResolver(
             final SchemePortResolver schemePortResolver) {
         this.schemePortResolver = schemePortResolver;
         return this;
     }
 
     public final HttpClientBuilder setMaxConnTotal(final int maxConnTotal) {
         this.maxConnTotal = maxConnTotal;
         return this;
     }
 
     public final HttpClientBuilder setMaxConnPerRoute(final int maxConnPerRoute) {
         this.maxConnPerRoute = maxConnPerRoute;
         return this;
     }
 
     public final HttpClientBuilder setConnectionReuseStrategy(
             final ConnectionReuseStrategy reuseStrategy) {
         this.reuseStrategy = reuseStrategy;
         return this;
     }
 
     public final HttpClientBuilder setKeepAliveStrategy(
             final ConnectionKeepAliveStrategy keepAliveStrategy) {
         this.keepAliveStrategy = keepAliveStrategy;
         return this;
     }
 
     public final HttpClientBuilder setUserTokenHandler(final UserTokenHandler userTokenHandler) {
         this.userTokenHandler = userTokenHandler;
         return this;
     }
 
     public final HttpClientBuilder setTargetAuthenticationStrategy(
             final AuthenticationStrategy targetAuthStrategy) {
         this.targetAuthStrategy = targetAuthStrategy;
         return this;
     }
 
     public final HttpClientBuilder setProxyAuthenticationStrategy(
             final AuthenticationStrategy proxyAuthStrategy) {
         this.proxyAuthStrategy = proxyAuthStrategy;
         return this;
     }
 
     public final HttpClientBuilder setHttpProcessor(final HttpProcessor httpprocessor) {
         this.httpprocessor = httpprocessor;
         return this;
     }
 
     public final HttpClientBuilder addInterceptorFirst(final HttpResponseInterceptor itcp) {
         if (itcp == null) {
             return this;
         }
         if (responseFirst == null) {
             responseFirst = new LinkedList<HttpResponseInterceptor>();
         }
         responseFirst.addFirst(itcp);
         return this;
     }
 
     public final HttpClientBuilder addInterceptorLast(final HttpResponseInterceptor itcp) {
         if (itcp == null) {
             return this;
         }
         if (responseLast == null) {
             responseLast = new LinkedList<HttpResponseInterceptor>();
         }
         responseLast.addLast(itcp);
         return this;
     }
 
     public final HttpClientBuilder addInterceptorFirst(final HttpRequestInterceptor itcp) {
         if (itcp == null) {
             return this;
         }
         if (requestFirst == null) {
             requestFirst = new LinkedList<HttpRequestInterceptor>();
         }
         requestFirst.addFirst(itcp);
         return this;
     }
 
     public final HttpClientBuilder addInterceptorLast(final HttpRequestInterceptor itcp) {
         if (itcp == null) {
             return this;
         }
         if (requestLast == null) {
             requestLast = new LinkedList<HttpRequestInterceptor>();
         }
         requestLast.addLast(itcp);
         return this;
     }
 
     public final HttpClientBuilder setRetryHandler(final HttpRequestRetryHandler retryHandler) {
         this.retryHandler = retryHandler;
         return this;
     }
 
     public final HttpClientBuilder setRoutePlanner(final HttpRoutePlanner routePlanner) {
         this.routePlanner = routePlanner;
         return this;
     }
 
     public final HttpClientBuilder setRedirectStrategy(final RedirectStrategy redirectStrategy) {
         this.redirectStrategy = redirectStrategy;
         return this;
     }
 
     public final HttpClientBuilder setConnectionBackoffStrategy(
             final ConnectionBackoffStrategy connectionBackoffStrategy) {
         this.connectionBackoffStrategy = connectionBackoffStrategy;
         return this;
     }
 
     public final HttpClientBuilder setBackoffManager(final BackoffManager backoffManager) {
         this.backoffManager = backoffManager;
         return this;
     }
 
     public final HttpClientBuilder setServiceUnavailableRetryStrategy(
             final ServiceUnavailableRetryStrategy serviceUnavailStrategy) {
         this.serviceUnavailStrategy = serviceUnavailStrategy;
         return this;
     }
 
     public final HttpClientBuilder setDefaultCookieStore(final CookieStore cookieStore) {
         this.cookieStore = cookieStore;
         return this;
     }
 
     public final HttpClientBuilder setDefaultCredentialsProvider(
             final CredentialsProvider credentialsProvider) {
         this.credentialsProvider = credentialsProvider;
         return this;
     }
 
     public final HttpClientBuilder setDefaultAuthSchemeRegistry(
             final Lookup<AuthSchemeProvider> authSchemeRegistry) {
         this.authSchemeRegistry = authSchemeRegistry;
         return this;
     }
 
     public final HttpClientBuilder setDefaultCookieSpecRegistry(
             final Lookup<CookieSpecProvider> cookieSpecRegistry) {
         this.cookieSpecRegistry = cookieSpecRegistry;
         return this;
     }
 
     public final HttpClientBuilder setUserAgent(final String userAgent) {
         this.userAgent = userAgent;
         return this;
     }
 
     public final HttpClientBuilder setProxy(final HttpHost proxy) {
         this.proxy = proxy;
         return this;
     }
 
     public final HttpClientBuilder setDefaultHeaders(final Collection<? extends Header> defaultHeaders) {
         this.defaultHeaders = defaultHeaders;
         return this;
     }
 
     public final HttpClientBuilder setDefaultSocketConfig(final SocketConfig config) {
         this.defaultSocketConfig = config;
         return this;
     }
 
     public final HttpClientBuilder setDefaultConnectionConfig(final ConnectionConfig config) {
         this.defaultConnectionConfig = config;
         return this;
     }
 
     public final HttpClientBuilder setDefaultRequestConfig(final RequestConfig config) {
         this.defaultRequestConfig = config;
         return this;
     }
 
     public final HttpClientBuilder disableRedirectHandling() {
         redirectHandlingDisabled = true;
         return this;
     }
 
     public final HttpClientBuilder disableAutomaticRetries() {
         automaticRetriesDisabled = true;
         return this;
     }
 
     public final HttpClientBuilder disableConnectionState() {
         connectionStateDisabled = true;
         return this;
     }
 
     public final HttpClientBuilder disableContentCompression() {
         contentCompressionDisabled = true;
         return this;
     }
 
     public final HttpClientBuilder useSystemProperties() {
         systemProperties = true;
         return this;
     }
 
     protected ClientExecChain decorateMainExec(final ClientExecChain mainExec) {
         return mainExec;
     }
 
     protected ClientExecChain decorateProtocolExec(final ClientExecChain protocolExec) {
         return protocolExec;
     }
 
     protected void addCloseable(final Closeable closeable) {
         if (closeable == null) {
             return;
         }
         if (closeables == null) {
             closeables = new ArrayList<Closeable>();
         }
         closeables.add(closeable);
     }
 
 
     public CloseableHttpClient build() {
         // Create main request executor
         HttpRequestExecutor requestExec = this.requestExec;
         if (requestExec == null) {
             requestExec = new HttpRequestExecutor();
         }
         HttpClientConnectionManager connManager = this.connManager;
         if (connManager == null) {
             LayeredConnectionSocketFactory sslSocketFactory = this.sslSocketFactory;
             if (sslSocketFactory == null) {
                 if (sslcontext != null) {
                     sslSocketFactory = new SSLSocketFactory(sslcontext);
                 } else {
                     if (systemProperties) {
                         sslSocketFactory = SSLSocketFactory.getSystemSocketFactory();
                     } else {
                         sslSocketFactory = SSLSocketFactory.getSocketFactory();
                     }
                 }
             }
             final PoolingHttpClientConnectionManager poolingmgr = new PoolingHttpClientConnectionManager(
                     RegistryBuilder.<ConnectionSocketFactory>create()
                         .register("http", PlainSocketFactory.getSocketFactory())
                         .register("https", sslSocketFactory)
                         .build());
             if (defaultSocketConfig != null) {
                 poolingmgr.setDefaultSocketConfig(defaultSocketConfig);
             }
             if (defaultConnectionConfig != null) {
                 poolingmgr.setDefaultConnectionConfig(defaultConnectionConfig);
             }
             if (systemProperties) {
                 String s = System.getProperty("http.keepAlive", "true");
                 if ("true".equalsIgnoreCase(s)) {
                     s = System.getProperty("http.maxConnections", "5");
                     final int max = Integer.parseInt(s);
                     poolingmgr.setDefaultMaxPerRoute(max);
                     poolingmgr.setMaxTotal(2 * max);
                 }
             } else {
                 if (maxConnTotal > 0) {
                     poolingmgr.setMaxTotal(maxConnTotal);
                 }
                 if (maxConnPerRoute > 0) {
                     poolingmgr.setDefaultMaxPerRoute(maxConnPerRoute);
                 }
             }
             connManager = poolingmgr;
         }
         ConnectionReuseStrategy reuseStrategy = this.reuseStrategy;
         if (reuseStrategy == null) {
             if (systemProperties) {
                 final String s = System.getProperty("http.keepAlive", "true");
                 if ("true".equalsIgnoreCase(s)) {
                     reuseStrategy = DefaultConnectionReuseStrategy.INSTANCE;
                 } else {
                     reuseStrategy = NoConnectionReuseStrategy.INSTANCE;
                 }
             } else {
                 reuseStrategy = DefaultConnectionReuseStrategy.INSTANCE;
             }
         }
         ConnectionKeepAliveStrategy keepAliveStrategy = this.keepAliveStrategy;
         if (keepAliveStrategy == null) {
             keepAliveStrategy = DefaultConnectionKeepAliveStrategy.INSTANCE;
         }
         AuthenticationStrategy targetAuthStrategy = this.targetAuthStrategy;
         if (targetAuthStrategy == null) {
             targetAuthStrategy = TargetAuthenticationStrategy.INSTANCE;
         }
         AuthenticationStrategy proxyAuthStrategy = this.proxyAuthStrategy;
         if (proxyAuthStrategy == null) {
             proxyAuthStrategy = ProxyAuthenticationStrategy.INSTANCE;
         }
         UserTokenHandler userTokenHandler = this.userTokenHandler;
         if (userTokenHandler == null) {
             if (!connectionStateDisabled) {
                 userTokenHandler = DefaultUserTokenHandler.INSTANCE;
             } else {
                 userTokenHandler = NoopUserTokenHandler.INSTANCE;
             }
         }
         SchemePortResolver schemePortResolver = this.schemePortResolver;
         if (schemePortResolver == null) {
             schemePortResolver = DefaultSchemePortResolver.INSTANCE;
         }
 
         ClientExecChain execChain = new MainClientExec(
                 requestExec,
                 connManager,
                 reuseStrategy,
                 keepAliveStrategy,
                 targetAuthStrategy,
                 proxyAuthStrategy,
                 userTokenHandler);
 
         execChain = decorateMainExec(execChain);
 
         HttpProcessor httpprocessor = this.httpprocessor;
         if (httpprocessor == null) {
 
             String userAgent = this.userAgent;
             if (userAgent == null) {
                 if (systemProperties) {
                     userAgent = System.getProperty("http.agent");
                 } else {
                     final VersionInfo vi = VersionInfo.loadVersionInfo("org.apache.http.client",
                             HttpClientBuilder.class.getClassLoader());
                     final String release = vi != null ? vi.getRelease() : VersionInfo.UNAVAILABLE;
                     userAgent = "Apache-HttpClient/" + release + " (java 1.5)";
                 }
             }
 
             final HttpProcessorBuilder b = HttpProcessorBuilder.create();
             if (requestFirst != null) {
                 for (final HttpRequestInterceptor i: requestFirst) {
                     b.addFirst(i);
                 }
             }
             if (responseFirst != null) {
                 for (final HttpResponseInterceptor i: responseFirst) {
                     b.addFirst(i);
                 }
             }
             b.addAll(
                     new RequestDefaultHeaders(defaultHeaders),
                     new RequestContent(),
                     new RequestTargetHost(),
                     new RequestClientConnControl(),
                     new RequestUserAgent(userAgent),
                     new RequestExpectContinue());
             if (!cookieManagementDisabled) {
                 b.add(new RequestAddCookies());
             }
             if (!contentCompressionDisabled) {
                 b.add(new RequestAcceptEncoding());
             }
             if (!authCachingDisabled) {
                 b.add(new RequestAuthCache());
             }
             if (!cookieManagementDisabled) {
                 b.add(new ResponseProcessCookies());
             }
             if (!contentCompressionDisabled) {
                 b.add(new ResponseContentEncoding());
             }
             if (requestLast != null) {
                 for (final HttpRequestInterceptor i: requestLast) {
                     b.addLast(i);
                 }
             }
             if (responseLast != null) {
                 for (final HttpResponseInterceptor i: responseLast) {
                     b.addLast(i);
                 }
             }
             httpprocessor = b.build();
         }
         execChain = new ProtocolExec(execChain, httpprocessor);
 
         execChain = decorateProtocolExec(execChain);
 
         // Add request retry executor, if not disabled
         if (!automaticRetriesDisabled) {
             HttpRequestRetryHandler retryHandler = this.retryHandler;
             if (retryHandler == null) {
                 retryHandler = DefaultHttpRequestRetryHandler.INSTANCE;
             }
             execChain = new RetryExec(execChain, retryHandler);
         }
 
         // Add redirect executor, if not disabled
         HttpRoutePlanner routePlanner = this.routePlanner;
         if (routePlanner == null) {
             if (proxy != null) {
                 routePlanner = new DefaultProxyRoutePlanner(proxy, schemePortResolver);
             } else if (systemProperties) {
                 routePlanner = new SystemDefaultRoutePlanner(
                         schemePortResolver, ProxySelector.getDefault());
             } else {
                 routePlanner = new DefaultRoutePlanner(schemePortResolver);
             }
         }
         if (!redirectHandlingDisabled) {
             RedirectStrategy redirectStrategy = this.redirectStrategy;
             if (redirectStrategy == null) {
                 redirectStrategy = DefaultRedirectStrategy.INSTANCE;
             }
             execChain = new RedirectExec(execChain, routePlanner, redirectStrategy);
         }
 
         // Optionally, add service unavailable retry executor
         final ServiceUnavailableRetryStrategy serviceUnavailStrategy = this.serviceUnavailStrategy;
         if (serviceUnavailStrategy != null) {
             execChain = new ServiceUnavailableRetryExec(execChain, serviceUnavailStrategy);
         }
         // Optionally, add connection back-off executor
         final BackoffManager backoffManager = this.backoffManager;
         final ConnectionBackoffStrategy connectionBackoffStrategy = this.connectionBackoffStrategy;
         if (backoffManager != null && connectionBackoffStrategy != null) {
             execChain = new BackoffStrategyExec(execChain, connectionBackoffStrategy, backoffManager);
         }
 
         Lookup<AuthSchemeProvider> authSchemeRegistry = this.authSchemeRegistry;
         if (authSchemeRegistry == null) {
             authSchemeRegistry = RegistryBuilder.<AuthSchemeProvider>create()
                 .register(AuthSchemes.BASIC, new BasicSchemeFactory())
                 .register(AuthSchemes.DIGEST, new DigestSchemeFactory())
                 .register(AuthSchemes.NTLM, new NTLMSchemeFactory())
                 .register(AuthSchemes.SPNEGO, new SPNegoSchemeFactory())
                 .register(AuthSchemes.KERBEROS, new KerberosSchemeFactory())
                 .build();
         }
         Lookup<CookieSpecProvider> cookieSpecRegistry = this.cookieSpecRegistry;
         if (cookieSpecRegistry == null) {
             cookieSpecRegistry = RegistryBuilder.<CookieSpecProvider>create()
                 .register(CookieSpecs.BEST_MATCH, new BestMatchSpecFactory())
                 .register(CookieSpecs.BROWSER_COMPATIBILITY, new BrowserCompatSpecFactory())
                 .register(CookieSpecs.NETSCAPE, new NetscapeDraftSpecFactory())
                 .register(CookieSpecs.RFC_2109, new RFC2109SpecFactory())
                 .register(CookieSpecs.RFC_2965, new RFC2965SpecFactory())
                 .register(CookieSpecs.IGNORE_COOKIES, new IgnoreSpecFactory())
                 .build();
         }
 
         CookieStore defaultCookieStore = this.cookieStore;
         if (defaultCookieStore == null) {
             defaultCookieStore = new BasicCookieStore();
         }
 
         CredentialsProvider defaultCredentialsProvider = this.credentialsProvider;
         if (defaultCredentialsProvider == null) {
             defaultCredentialsProvider = new BasicCredentialsProvider();
         }
 
         return new InternalHttpClient(
                 execChain,
                 connManager,
                 routePlanner,
                 cookieSpecRegistry,
                 authSchemeRegistry,
                 defaultCookieStore,
                 defaultCredentialsProvider,
                 defaultRequestConfig != null ? defaultRequestConfig : RequestConfig.DEFAULT,
                 closeables != null ? new ArrayList<Closeable>(closeables) : null);
     }
 
 }