Support Crazy Linker in WebAPK to load Chrome's uncompressed native libraries.

base/android/java/src/org/chromium/base/library_loader/LibraryLoader.java

 // Copyright 2014 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.base.library_loader;
 
 import android.annotation.TargetApi;
 import android.content.Context;
+import android.content.SharedPreferences;
 import android.content.pm.ApplicationInfo;
 import android.content.pm.PackageInfo;
 import android.content.pm.PackageManager.NameNotFoundException;
 import android.os.AsyncTask;
 import android.os.Build;
 import android.os.SystemClock;
 
 import org.chromium.base.CommandLine;
 import org.chromium.base.Log;
 import org.chromium.base.PackageUtils;
 import org.chromium.base.TraceEvent;
 import org.chromium.base.annotations.CalledByNative;
 import org.chromium.base.annotations.JNINamespace;
 import org.chromium.base.metrics.RecordHistogram;
 
-import java.io.File;
 import java.util.concurrent.atomic.AtomicBoolean;
 
 import javax.annotation.Nullable;
 
 /**
  * This class provides functionality to load and register the native libraries.
  * Callers are allowed to separate loading the libraries from initializing them.
  * This may be an advantage for Android Webview, where the libraries can be loaded
  * by the zygote process, but then needs per process initialization after the
  * application processes are forked from the zygote process.
@@ skipping 217 matching lines @@
                         // in the final .apk don't need to be explicitly loaded.
                         if (linker.isChromiumLinkerLibrary(library)) {
                             if (DEBUG) Log.i(TAG, "ignoring self-linker load");
                             continue;
                         }
 
                         // Determine where the library should be loaded from.
                         String zipFilePath = null;
                         String libFilePath = System.mapLibraryName(library);
                         if (Linker.isInZipFile()) {
+                            SharedPreferences prefs = context.getSharedPreferences(
+                                    "MINT_PREFS", Context.MODE_PRIVATE);
+                            String packageString =  prefs.getString("CHROME_PACKAGE_PREF",
+                                    DEFAULT_CHROME_PACKAGE_NAME);
+                            Context remoteContext = context;
+                            if (mLibraryProcessType == LibraryProcessType.PROCESS_CHILD
+                                    && !context.getPackageName().equals(packageString)) {
+                                try {
+                                    // Construct the context of the WebAPK host, which has native
+                                    // libraries that the WebAPK.
+                                    Log.w(TAG, "package name from context: %s",
+                                            context.getPackageName());
+                                    remoteContext =
+                                            context.getApplicationContext().createPackageContext(
+                                                    packageString,
+                                                    Context.CONTEXT_IGNORE_SECURITY
+                                                    | Context.CONTEXT_INCLUDE_CODE);
+                                } catch (NameNotFoundException e) {
+                                    e.printStackTrace();
+                                }
+                            }
                             // Load directly from the APK.
-                            zipFilePath = getLibraryApkPath(context);
+                            zipFilePath = getLibraryApkPath(remoteContext);
                             Log.i(TAG, "Loading " + library + " from within " + zipFilePath);
                         } else {
                             // The library is in its own file.
                             Log.i(TAG, "Loading " + library);
                         }
 
                         // Load the library using this Linker. May throw UnsatisfiedLinkError.
                         loadLibrary(linker, zipFilePath, libFilePath);
                     }
 
                     linker.finishLibraryLoad();
                 } else {
-                    // TODO(yfriedman): Extract library for Chrome to depend on when using Minted
-                    // APKs. This should come from that library instead of reading the same shared
-                    // prefs.
-                    String packageString =
-                            context.getSharedPreferences(MINT_PREFS, Context.MODE_PRIVATE)
-                            .getString(CHROME_PACKAGE_PREF, DEFAULT_CHROME_PACKAGE_NAME);
-
-                    if (mLibraryProcessType == LibraryProcessType.PROCESS_CHILD
-                            && !context.getPackageName().equals(packageString)) {
-                        Context remoteContext = null;
-                        try {
-                            Log.w(TAG, "package name from context: %s", context.getPackageName());
-                            remoteContext = context.getApplicationContext().createPackageContext(
-                                  packageString,
-                                  Context.CONTEXT_IGNORE_SECURITY | Context.CONTEXT_INCLUDE_CODE);
-                        } catch (NameNotFoundException e1) {
-                            e1.printStackTrace();
-                        }
-                        File input = new File(remoteContext.getApplicationInfo().nativeLibraryDir);
-                        Log.w(TAG, "load native libraries from remote context: "
-                                + input.getAbsolutePath());
-                        for (String library : NativeLibraries.LIBRARIES) {
-                            System.load(input.getAbsolutePath() + "/lib" + library + ".so");
-                        }
-                    } else {
-                        // Load libraries using the system linker.
-                        for (String library : NativeLibraries.LIBRARIES) {
-                            System.loadLibrary(library);
-                        }
+                    // Load libraries using the system linker.
+                    for (String library : NativeLibraries.LIBRARIES) {
+                        System.loadLibrary(library);
                     }
                 }
 
                 long stopTime = SystemClock.uptimeMillis();
                 mLibraryLoadTimeMs = stopTime - startTime;
                 Log.i(TAG, String.format("Time to load native libraries: %d ms (timestamps %d-%d)",
                         mLibraryLoadTimeMs,
                         startTime % 10000,
                         stopTime % 10000));
 
@@ skipping 20 matching lines @@
     }
 
     // Returns the path to the .apk that holds the native libraries.
     // This is either the main .apk, or the abi split apk.
     @TargetApi(Build.VERSION_CODES.LOLLIPOP)
     private static String getLibraryApkPath(Context context) {
         ApplicationInfo appInfo = context.getApplicationInfo();
         if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
             return appInfo.sourceDir;
         }
+        // In minted runtime, getApplicationContext() of its host context returns null, since

[Yaron, 2016/02/19 22:10:19]

I wonder if this might bite us elsewhere but seems ok

[Xi Han, 2016/02/24 19:09:38]

Do you know when the splitSourceDirs are used?

[Yaron, 2016/02/25 05:32:50]

It's not used. We thought we'd be using split apks but we aren't. I was
referring to the fact that getApplicationContext is null which may be a problem
in the future

[Xi Han, 2016/02/25 14:55:37]

Got it. We need to be more careful with dealing with remote context.

+        // we use reflection to construct the host's context. In this case, simply
+        // return its host's sourceDir.
+        if (context.getApplicationContext() == null) {
+            return appInfo.sourceDir;
+        }
         PackageInfo packageInfo = PackageUtils.getOwnPackageInfo(context);
         if (packageInfo.splitNames != null) {
             for (int i = 0; i < packageInfo.splitNames.length; ++i) {
                 if (isAbiSplit(packageInfo.splitNames[i])) {
                     return appInfo.splitSourceDirs[i];
                 }
             }
         }
         return appInfo.sourceDir;
     }
@@ skipping 142 matching lines @@
 
     // Finds the ranges corresponding to the native library pages, forks a new
     // process to prefetch these pages and waits for it. The new process then
     // terminates. This is blocking.
     private static native boolean nativeForkAndPrefetchNativeLibrary();
 
     // Returns the percentage of the native library code page that are currently reseident in
     // memory.
     private static native int nativePercentageOfResidentNativeLibraryCode();
 }