Remove instanceof check vs non-JDK SSL providers

Author: franz1981

src/main/java/io/vertx/core/net/impl/SSLHelper.java

@@ -76,7 +76,7 @@ ByteBufAllocator serverByteBufAllocator(SslContextProvider ctxProvider) {
 
   private boolean usesJDKSSLWithPooledHeapBuffers(SslContextProvider ctxProvider) {
     return ssl && sslEngineOptions instanceof JdkSSLEngineOptions &&
-      ctxProvider.sslProvider() == SslProvider.JDK &&
+      ctxProvider.jdkSSLProvider() &&
       ((JdkSSLEngineOptions) sslEngineOptions).isPooledHeapBuffers();
   }
 
@@ -173,22 +173,22 @@ private static class CachedProvider {
 
   private class EngineConfig {
 
-    private final SslProvider sslProvider;
+    private final boolean jdkSSLProvider;
     private final SSLOptions sslOptions;
     private final Supplier<SslContextFactory> supplier;
     private final boolean useWorkerPool;
 
-    public EngineConfig(SslProvider sslProvider, SSLOptions sslOptions, Supplier<SslContextFactory> supplier,
+    public EngineConfig(boolean jdkSSLProvider, SSLOptions sslOptions, Supplier<SslContextFactory> supplier,
                         boolean useWorkerPool) {
-      this.sslProvider = sslProvider;
+      this.jdkSSLProvider = jdkSSLProvider;
       this.sslOptions = sslOptions;
       this.supplier = supplier;
       this.useWorkerPool = useWorkerPool;
     }
 
     SslContextProvider sslContextProvider() {
       return new SslContextProvider(
-        sslProvider,
+        jdkSSLProvider,
         clientAuth,
         endpointIdentificationAlgorithm,
         applicationProtocols,
@@ -319,26 +319,20 @@ private Future<EngineConfig> build(SSLOptions sslOptions, ContextInternal ctx) {
       }).compose(v2 -> ctx.<EngineConfig>executeBlockingInternal(p -> {
         Supplier<SslContextFactory> supplier;
         boolean useWorkerPool;
-        SslProvider sslProvider;
+        final boolean jdkSSLProvider;
         try {
           SSLEngineOptions resolvedEngineOptions = resolveEngineOptions(sslEngineOptions, useAlpn);
           supplier = resolvedEngineOptions::sslContextFactory;
           useWorkerPool = resolvedEngineOptions.getUseWorkerThread();
-          if (resolvedEngineOptions instanceof JdkSSLEngineOptions) {
-            sslProvider = SslProvider.JDK;
-          } else if (resolvedEngineOptions instanceof OpenSSLEngineOptions) {
-            sslProvider = SslProvider.OPENSSL;
-          } else {
-            sslProvider = SslProvider.JDK;
-          }
+          jdkSSLProvider = resolvedEngineOptions instanceof JdkSSLEngineOptions;
         } catch (Exception e) {
           p.fail(e);
           return;
         }
-        p.complete(new EngineConfig(sslProvider, sslOptions, supplier, useWorkerPool));
+        p.complete(new EngineConfig(jdkSSLProvider, sslOptions, supplier, useWorkerPool));
       })).onComplete(promise);
     } else {
-      sslContextFactorySupplier = Future.succeededFuture(new EngineConfig(SslProvider.JDK, sslOptions, () -> new DefaultSslContextFactory(SslProvider.JDK, false), SSLEngineOptions.DEFAULT_USE_WORKER_POOL));
+      sslContextFactorySupplier = Future.succeededFuture(new EngineConfig(true, sslOptions, () -> new DefaultSslContextFactory(SslProvider.JDK, false), SSLEngineOptions.DEFAULT_USE_WORKER_POOL));
     }
     return sslContextFactorySupplier;
   }

src/main/java/io/vertx/core/net/impl/SslContextProvider.java

@@ -11,7 +11,6 @@
 package io.vertx.core.net.impl;
 
 import io.netty.handler.ssl.SslContext;
-import io.netty.handler.ssl.SslProvider;
 import io.vertx.core.VertxException;
 import io.vertx.core.http.ClientAuth;
 import io.vertx.core.spi.tls.SslContextFactory;
@@ -31,7 +30,7 @@
  */
 public class SslContextProvider {
 
-  private final SslProvider providerType;
+  private final boolean jdkSSLProvider;
   private final Supplier<SslContextFactory> provider;
   private final Set<String> enabledProtocols;
   private final List<CRL> crls;
@@ -44,7 +43,7 @@ public class SslContextProvider {
   private final Function<String, KeyManagerFactory> keyManagerFactoryMapper;
   private final Function<String, TrustManager[]> trustManagerMapper;
 
-  public SslContextProvider(SslProvider providerType,
+  public SslContextProvider(boolean jdkSSLProvider,
                             ClientAuth clientAuth,
                             String endpointIdentificationAlgorithm,
                             List<String> applicationProtocols,
@@ -56,7 +55,7 @@ public SslContextProvider(SslProvider providerType,
                             Function<String, TrustManager[]> trustManagerMapper,
                             List<CRL> crls,
                             Supplier<SslContextFactory> provider) {
-    this.providerType = providerType;
+    this.jdkSSLProvider = jdkSSLProvider;
     this.provider = provider;
     this.clientAuth = clientAuth;
     this.endpointIdentificationAlgorithm = endpointIdentificationAlgorithm;
@@ -70,8 +69,8 @@ public SslContextProvider(SslProvider providerType,
     this.crls = crls;
   }
 
-  SslProvider sslProvider() {
-    return providerType;
+  boolean jdkSSLProvider() {
+    return jdkSSLProvider;
   }
 
   public VertxSslContext createContext(boolean server,

src/test/java/io/vertx/core/net/impl/SSLAllocatorTest.java

@@ -16,7 +16,6 @@
 import org.junit.Test;
 
 import io.netty.buffer.PooledByteBufAllocator;
-import io.netty.handler.ssl.SslProvider;
 import io.vertx.core.buffer.impl.PartialPooledByteBufAllocator;
 import io.vertx.core.http.HttpClientOptions;
 import io.vertx.core.http.HttpServerOptions;
@@ -41,7 +40,7 @@ public void testUsePartialPooledByteBufAllocatorInstanceWhenNotSpecified() throw
     helper
       .buildContextProvider(new SSLOptions().setKeyCertOptions(Cert.CLIENT_JKS.get()).setTrustOptions(Trust.SERVER_JKS.get()), (ContextInternal) vertx.getOrCreateContext())
       .onComplete(onSuccess(provider -> {
-        assertSame(SslProvider.JDK, provider.sslProvider());
+        assertTrue(provider.jdkSSLProvider());
         assertSame(PartialPooledByteBufAllocator.INSTANCE, helper.clientByteBufAllocator(provider));
         assertSame(PartialPooledByteBufAllocator.INSTANCE, helper.serverByteBufAllocator(provider));
         testComplete();
@@ -61,7 +60,7 @@ public void testUsePartialPooledByteBufAllocatorInstanceIfDefaultJDKSSLIsConfigu
     helper
       .buildContextProvider(new SSLOptions().setKeyCertOptions(Cert.CLIENT_JKS.get()).setTrustOptions(Trust.SERVER_JKS.get()), (ContextInternal) vertx.getOrCreateContext())
       .onComplete(onSuccess(provider -> {
-        assertSame(SslProvider.JDK, provider.sslProvider());
+        assertTrue(provider.jdkSSLProvider());
         assertSame(PartialPooledByteBufAllocator.INSTANCE, helper.clientByteBufAllocator(provider));
         assertSame(PartialPooledByteBufAllocator.INSTANCE, helper.serverByteBufAllocator(provider));
         testComplete();
@@ -81,7 +80,7 @@ public void testUsePooledByteBufAllocatorDefaultIfJDKSSLPooledHeapBufferConfigur
     helper
       .buildContextProvider(new SSLOptions().setKeyCertOptions(Cert.CLIENT_JKS.get()).setTrustOptions(Trust.SERVER_JKS.get()), (ContextInternal) vertx.getOrCreateContext())
       .onComplete(onSuccess(provider -> {
-        assertSame(SslProvider.JDK, provider.sslProvider());
+        assertTrue(provider.jdkSSLProvider());
         assertSame(PooledByteBufAllocator.DEFAULT, helper.clientByteBufAllocator(provider));
         assertSame(PooledByteBufAllocator.DEFAULT, helper.serverByteBufAllocator(provider));
         testComplete();
@@ -133,7 +132,7 @@ public void testUsePooledByteBufAllocatorDefaultIfOpenSSLIsConfigured() {
         .setPemKeyCertOptions(Cert.CLIENT_PEM.get()).setTrustOptions(Trust.SERVER_PEM.get()),
       null);
     helper.buildContextProvider(new SSLOptions().setKeyCertOptions(Cert.CLIENT_PEM.get()).setTrustOptions(Trust.SERVER_PEM.get()), (ContextInternal) vertx.getOrCreateContext()).onComplete(onSuccess(provider -> {
-      assertSame(SslProvider.OPENSSL, provider.sslProvider());
+      assertFalse(provider.jdkSSLProvider());
       assertSame(PartialPooledByteBufAllocator.INSTANCE, helper.clientByteBufAllocator(provider));
       assertSame(PartialPooledByteBufAllocator.INSTANCE, helper.serverByteBufAllocator(provider));
       testComplete();