Add API for custom library loading

components/cronet/android/api/src/org/chromium/net/CronetEngine.java

 // Copyright 2015 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;
 
 import android.content.Context;
 import android.support.annotation.IntDef;
 import android.support.annotation.Nullable;
 import android.util.Log;
@@ skipping 23 matching lines @@
  * An engine to process {@link UrlRequest}s, which uses the best HTTP stack
  * available on the current platform.
  */
 public abstract class CronetEngine {
     /**
      * A builder for {@link CronetEngine}s, which allows runtime configuration of
      * {@code CronetEngine}. Configuration options are set on the builder and
      * then {@link #build} is called to create the {@code CronetEngine}.
      */
     public static class Builder {
+        /**
+         * A callback for loading the "cronet" library.

[xunjieli, 2016/01/21 19:50:53]

Suggest making this into an abstract class, and mLibraryLoader as an optional
param.
Maybe also rename LibraryLoader to CustomLibraryLoader.

That way we can avoid creating an instance of LibraryLoader if it isn't needed.
It is slightly clearer that this step is optional.

Also document in what scenarios the embedder might want to have a custom
LibraryLoader. A few sentences will do.

[mgersh, 2016/01/22 17:41:16]

I made it into an interface instead, since it looks like it meets all the
criteria for that. Let me know if there's a reason for it to be specifically an
abstract class.

+         */
+        public static class LibraryLoader {
+            /**
+             * Load the native library.
+             */
+            public void loadLibrary(Context context, String name) {

[xunjieli, 2016/01/21 19:50:53]

I don't think we need the context as an argument. If the embedder needs it, they
can have it through other means e.g. supplied through the constructor.

Also document what "name" is. Maybe rename it to libName to be clearer.

[mgersh, 2016/01/22 17:41:16]

Done.

+                // The context isn't used here, but other implementations might need it
+                System.loadLibrary(name);
+            }
+        }
+
         // A hint that a host supports QUIC.
         static class QuicHint {
             // The host.
             final String mHost;
             // Port of the server that supports QUIC.
             final int mPort;
             // Alternate protocol port.
             final int mAlternatePort;
 
             QuicHint(String host, int port, int alternatePort) {
@@ skipping 25 matching lines @@
         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 mContext;
         private final List<QuicHint> mQuicHints = new LinkedList<QuicHint>();
         private final List<Pkp> mPkps = new LinkedList<Pkp>();
         private String mUserAgent;
         private String mStoragePath;
         private boolean mLegacyModeEnabled;
+        private LibraryLoader mLibraryLoader;
         private String mLibraryName;
         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;
 
         /**
          * Default config enables SPDY, disables QUIC, SDCH and HTTP cache.
          * @param context Android {@link Context} for engine to use.
          */
         public Builder(Context context) {
             mContext = context;
             setLibraryName("cronet");
+            setLibraryLoader(new LibraryLoader());
             enableLegacyMode(false);
             enableQUIC(false);
             enableHTTP2(true);
             enableSDCH(false);
             enableHttpCache(HTTP_CACHE_DISABLED, 0);
         }
 
         /**
          * Constructs a User-Agent string including Cronet version, and
          * application name and version.
@@ skipping 60 matching lines @@
 
         /**
          * Overrides the name of the native library backing Cronet.
          * @return the builder to facilitate chaining.
          */
         Builder setLibraryName(String libName) {
             mLibraryName = libName;
             return this;
         }
 
-        String libraryName() {
-            return mLibraryName;
+        /**
+         * Overrides the callback to load the native library.
+         * @return the builder to facilitate chaining.
+         */
+        public Builder setLibraryLoader(LibraryLoader loader) {
+            mLibraryLoader = loader;
+            return this;
+        }
+
+        void loadLibrary(Context context) {
+            mLibraryLoader.loadLibrary(context, mLibraryName);

[xunjieli, 2016/01/21 19:50:53]

Suggest do the following:
If mLibraryLoader is null, do System.loadLibrary( mLibraryName);
Otherwise invoke the loadLibrary on mLibraryLoader.

[mgersh, 2016/01/22 17:41:16]

Done.

         }
 
         /**
          * Sets whether <a href="https://www.chromium.org/quic">QUIC</a> protocol
          * is enabled. Defaults to disabled.
          * @return the builder to facilitate chaining.
          */
         public Builder enableQUIC(boolean value) {
             mQuicEnabled = value;
             return this;
@@ skipping 824 matching lines @@
      * Interface to listen for finished requests that were created via this CronetEngine instance.
      *
      * @deprecated not really deprecated but hidden for now as it's a prototype.
      */
     @Deprecated
     public interface RequestFinishedListener { // TODO(klm): Add a convenience abstract class.
         /** Invoked with request info. */
         void onRequestFinished(UrlRequestInfo requestInfo);
     }
 }