Cronet: a framework to provide alternative Cronet implementations

components/cronet/android/java/src/org/chromium/net/impl/CronetEngineBuilderImpl.java

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 package org.chromium.net.impl;
 
 import android.content.Context;
 import android.support.annotation.IntDef;
 import android.support.annotation.VisibleForTesting;
-import android.util.Log;
 
 import static org.chromium.net.CronetEngine.Builder.HTTP_CACHE_DISABLED;
 import static org.chromium.net.CronetEngine.Builder.HTTP_CACHE_DISK;
 import static org.chromium.net.CronetEngine.Builder.HTTP_CACHE_DISK_NO_HTTP;
 import static org.chromium.net.CronetEngine.Builder.HTTP_CACHE_IN_MEMORY;
 
 import org.chromium.net.CronetEngine;
-import org.chromium.net.ExperimentalCronetEngine;
 import org.chromium.net.ICronetEngineBuilder;
 
 import java.io.File;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
-import java.lang.reflect.Constructor;
 import java.net.IDN;
 import java.util.Date;
 import java.util.HashSet;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Set;
 import java.util.regex.Pattern;
 
 /**
  * Implementation of {@link ICronetEngineBuilder}.
  */
-public class CronetEngineBuilderImpl extends ICronetEngineBuilder {
+public abstract class CronetEngineBuilderImpl extends ICronetEngineBuilder {
     /**
      * A hint that a host supports QUIC.
      */
     public static class QuicHint {
         // The host.
         final String mHost;
         // Port of the server that supports QUIC.
         final int mPort;
         // Alternate protocol port.
         final int mAlternatePort;
@@ skipping 19 matching lines @@
         final Date mExpirationDate;
 
         Pkp(String host, byte[][] hashes, boolean includeSubdomains, Date expirationDate) {
             mHost = host;
             mHashes = hashes;
             mIncludeSubdomains = includeSubdomains;
             mExpirationDate = expirationDate;
         }
     }
 
-    private static final String TAG = CronetEngineBuilderImpl.class.getSimpleName();
-    private static final String NATIVE_CRONET_IMPL_CLASS =
-            "org.chromium.net.impl.CronetUrlRequestContext";
-    private static final String JAVA_CRONET_IMPL_CLASS = "org.chromium.net.impl.JavaCronetEngine";
     private static final Pattern INVALID_PKP_HOST_NAME = Pattern.compile("^[0-9\\.]*$");
 
     // Private fields are simply storage of configuration for the resulting CronetEngine.
     // See setters below for verbose descriptions.
     private final Context mApplicationContext;
     private final List<QuicHint> mQuicHints = new LinkedList<>();
     private final List<Pkp> mPkps = new LinkedList<>();
     private boolean mPublicKeyPinningBypassForLocalTrustAnchorsEnabled;
     private String mUserAgent;
     private String mStoragePath;
-    private boolean mLegacyModeEnabled;
     private VersionSafeCallbacks.LibraryLoader mLibraryLoader;
     private boolean mQuicEnabled;
     private boolean mHttp2Enabled;
     private boolean mSdchEnabled;
     private String mDataReductionProxyKey;
     private String mDataReductionProxyPrimaryProxy;
     private String mDataReductionProxyFallbackProxy;
     private String mDataReductionProxySecureProxyCheckUrl;
     private boolean mDisableCache;
     private int mHttpCacheMode;
     private long mHttpCacheMaxSize;
     private String mExperimentalOptions;
-    private long mMockCertVerifier;
+    protected long mMockCertVerifier;
     private boolean mNetworkQualityEstimatorEnabled;
     private String mCertVerifierData;
 
     /**
      * Default config enables SPDY, disables QUIC, SDCH and HTTP cache.
      * @param context Android {@link Context} for engine to use.
      */
     public CronetEngineBuilderImpl(Context context) {
         mApplicationContext = context.getApplicationContext();
-        enableLegacyMode(false);
         enableQuic(false);
         enableHttp2(true);
         enableSdch(false);
         enableHttpCache(HTTP_CACHE_DISABLED, 0);
         enableNetworkQualityEstimator(false);
         enablePublicKeyPinningBypassForLocalTrustAnchors(true);
     }
 
     @Override
     public String getDefaultUserAgent() {
@@ skipping 17 matching lines @@
         }
         mStoragePath = value;
         return this;
     }
 
     String storagePath() {
         return mStoragePath;
     }
 
     @Override
-    public CronetEngineBuilderImpl enableLegacyMode(boolean value) {
-        mLegacyModeEnabled = value;
-        return this;
-    }
-
-    private boolean legacyMode() {
-        return mLegacyModeEnabled;
-    }
-
-    @Override
     public CronetEngineBuilderImpl setLibraryLoader(CronetEngine.Builder.LibraryLoader loader) {
         mLibraryLoader = new VersionSafeCallbacks.LibraryLoader(loader);
         return this;
     }
 
     VersionSafeCallbacks.LibraryLoader libraryLoader() {
         return mLibraryLoader;
     }
 
     @Override
@@ skipping 264 matching lines @@
     }
 
     /**
      * Returns {@link Context} for builder.
      *
      * @return {@link Context} for builder.
      */
     Context getContext() {
         return mApplicationContext;
     }
-
-    @Override
-    public ExperimentalCronetEngine build() {
-        final ClassLoader loader = getClass().getClassLoader();
-        if (getUserAgent() == null) {
-            setUserAgent(getDefaultUserAgent());
-        }
-
-        ExperimentalCronetEngine cronetEngine = null;
-        if (!legacyMode()) {
-            cronetEngine = createNativeCronetEngine(loader);
-        }
-        if (cronetEngine == null) {
-            cronetEngine = createJavaCronetEngine(loader);
-        }
-
-        if (cronetEngine == null) {
-            Log.i(TAG,
-                    "Class loader " + loader + " couldn't find any Cronet engine implementation.");
-        } else {
-            Log.i(TAG, loader.toString() + " found Cronet engine implementation "
-                            + cronetEngine.getClass() + ". Network stack version "
-                            + cronetEngine.getVersionString());
-            // Clear MOCK_CERT_VERIFIER reference if there is any, since
-            // the ownership has been transferred to the engine.
-            mMockCertVerifier = 0;
-        }
-        return cronetEngine;
-    }
-
-    private ExperimentalCronetEngine createNativeCronetEngine(ClassLoader loader) {
-        return createCronetEngine(loader, NATIVE_CRONET_IMPL_CLASS, this);
-    }
-
-    private ExperimentalCronetEngine createJavaCronetEngine(ClassLoader loader) {
-        return createCronetEngine(loader, JAVA_CRONET_IMPL_CLASS, getUserAgent());
-    }
-
-    private ExperimentalCronetEngine createCronetEngine(
-            ClassLoader loader, String name, Object argument) {
-        ExperimentalCronetEngine cronetEngine = null;
-        try {
-            Class<? extends ExperimentalCronetEngine> engineClass =
-                    loader.loadClass(name).asSubclass(ExperimentalCronetEngine.class);
-            Constructor<? extends ExperimentalCronetEngine> constructor =
-                    engineClass.getConstructor(argument.getClass());
-            cronetEngine = constructor.newInstance(argument);
-        } catch (ClassNotFoundException e) {
-            // Leave as null.
-            Log.i(TAG, "Class loader " + loader + " cannot find Cronet engine implementation: "
-                            + name + ". Will try to find an alternative implementation.");
-        } catch (Exception e) {
-            throw new IllegalStateException("Cannot instantiate: " + name, e);
-        }
-        return cronetEngine;
-    }
 }