Library loading fallback.

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.content.Context;
 import android.os.SystemClock;
 import android.util.Log;
 
 import org.chromium.base.CommandLine;
 import org.chromium.base.JNINamespace;
 import org.chromium.base.TraceEvent;
 
+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.
  *
  * The libraries may be loaded and initialized from any thread. Synchronization
  * primitives are used to ensure that overlapping requests from different
  * threads are handled sequentially.
@@ skipping 21 matching lines @@
     // One-way switch becomes true when the libraries are initialized (
     // by calling nativeLibraryLoaded, which forwards to LibraryLoaded(...) in
     // library_loader_hooks.cc).
     private static boolean sInitialized = false;
 
     // One-way switches recording attempts to use Relro sharing in the browser.
     // The flags are used to report UMA stats later.
     private static boolean sIsUsingBrowserSharedRelros = false;
     private static boolean sLoadAtFixedAddressFailed = false;
 
-    // One-way switch becomes true if the library was loaded from the APK file
-    // directly.
+    // One-way switch becomes true if the device supports loading the Chromium
+    // library directly from the APK.
+    private static boolean sLibraryLoadFromApkSupported = false;
+
+    // One-way switch becomes true if the Chromium library was loaded from the
+    // APK file directly.
     private static boolean sLibraryWasLoadedFromApk = false;
 
     // One-way switch becomes false if the Chromium library should be loaded
     // directly from the APK file but it was not aligned.
     private static boolean sLibraryWasAlignedInApk = true;
 
     // One-way switch becomes true if the system library loading failed,
     // and the right native library was found and loaded by the hack.
     // The flag is used to report UMA stats later.
     private static boolean sNativeLibraryHackWasUsed = false;
@@ skipping 93 matching lines @@
             Context context, boolean shouldDeleteOldWorkaroundLibraries)
             throws ProcessInitException {
         try {
             if (!sLoaded) {
                 assert !sInitialized;
 
                 long startTime = SystemClock.uptimeMillis();
                 boolean useChromiumLinker = Linker.isUsed();
 
                 if (useChromiumLinker) {
+                    String apkFilename = null;
+
+                    // Check if the device supports loading a library directly from the APK file.
+                    if (context != null) {
+                        apkFilename = context.getApplicationInfo().sourceDir;
+                        sLibraryLoadFromApkSupported = Linker.checkLibraryLoadFromApkSupport(
+                                apkFilename);
+                    } else {
+                        Log.w(TAG, "loadAlreadyLocked(): null context");
+                    }
+
                     // Load libraries using the Chromium linker.
                     Linker.prepareLibraryLoad();
 
                     for (String library : NativeLibraries.LIBRARIES) {
                         // Don't self-load the linker. This is because the build system is
                         // not clever enough to understand that all the libraries packaged
                         // 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;
                         }
 
-                        String zipfile = null;
-                        if (Linker.isInZipFile()) {
-                            zipfile = context.getApplicationInfo().sourceDir;
-                            sLibraryWasAlignedInApk = Linker.checkLibraryAlignedInApk(
-                                    zipfile, System.mapLibraryName(library));
-                            Log.i(TAG, "Loading " + library + " from within " + zipfile);
+                        // Determine where the library should be loaded from.
+                        String zipFilename = null;
+                        String libFilename = System.mapLibraryName(library);
+                        if (apkFilename != null && Linker.isInZipFile()) {
+                            // The library is in the APK file.
+                            if (!Linker.checkLibraryAlignedInApk(
+                                    apkFilename, System.mapLibraryName(library))) {

[Anton, 2014/10/29 13:35:35]

Replace System.mapLibraryName(library) with libFilename

[petrcermak, 2014/10/29 14:01:01]

Done.

+                                sLibraryWasAlignedInApk = false;
+                            }
+                            if (sLibraryLoadFromApkSupported && sLibraryWasAlignedInApk) {
+                                // Load directly from the APK.
+                                Log.i(TAG, "Loading " + library + " directly from within " +
+                                        apkFilename);
+                                zipFilename = apkFilename;
+                            } else {
+                                // Fallback.
+                                Log.i(TAG, "Loading " + library + " using fallback from within " +
+                                        apkFilename);
+                                libFilename = LibraryLoaderHelper.buildFallbackLibrary(
+                                        context, apkFilename, libFilename);
+                                Log.i(TAG, "Built fallback library " + libFilename);
+                            }
                         } else {
-                            Log.i(TAG, "Loading: " + library);
+                            // The library is in its own file.
+                            Log.i(TAG, "Loading " + library);
                         }
 
+                        // Load the library.
                         boolean isLoaded = false;
                         if (Linker.isUsingBrowserSharedRelros()) {
                             sIsUsingBrowserSharedRelros = true;
                             try {
-                                if (zipfile != null) {
-                                    Linker.loadLibraryInZipFile(zipfile, library);
-                                    sLibraryWasLoadedFromApk = true;
-                                } else {
-                                    Linker.loadLibrary(library);
-                                }
+                                loadLibrary(zipFilename, libFilename);
                                 isLoaded = true;
                             } catch (UnsatisfiedLinkError e) {
                                 Log.w(TAG, "Failed to load native library with shared RELRO, " +
                                       "retrying without");
                                 Linker.disableSharedRelros();
                                 sLoadAtFixedAddressFailed = true;
                             }
                         }
                         if (!isLoaded) {
-                            if (zipfile != null) {
-                                Linker.loadLibraryInZipFile(zipfile, library);
-                                sLibraryWasLoadedFromApk = true;
-                            } else {
-                                Linker.loadLibrary(library);
-                            }
+                            loadLibrary(zipFilename, libFilename);
                         }
                     }
 
                     Linker.finishLibraryLoad();
                 } else {
                     // Load libraries using the system linker.
                     for (String library : NativeLibraries.LIBRARIES) {
                         try {
                             System.loadLibrary(library);
                         } catch (UnsatisfiedLinkError e) {
@@ skipping 30 matching lines @@
         Log.i(TAG, String.format(
                 "Expected native library version number \"%s\"," +
                         "actual native library version number \"%s\"",
                 NativeLibraries.sVersionNumber,
                 nativeGetVersionNumber()));
         if (!NativeLibraries.sVersionNumber.equals(nativeGetVersionNumber())) {
             throw new ProcessInitException(LoaderErrors.LOADER_ERROR_NATIVE_LIBRARY_WRONG_VERSION);
         }
     }
 
+    // Load a native shared library with the Chromium linker. If the zip file
+    // filename is not null, the library is loaded directly from the zip file.
+    private static void loadLibrary(@Nullable String zipFilename, String libFilename) {
+        if (zipFilename != null) {
+            sLibraryWasLoadedFromApk = true;
+        }
+        Linker.loadLibrary(zipFilename, libFilename);
+    }
+
     // The WebView requires the Command Line to be switched over before
     // initialization is done. This is okay in the WebView's case since the
     // JNI is already loaded by this point.
     public static void switchCommandLineForWebView() {
         synchronized (sLock) {
             ensureCommandLineSwitchedAlreadyLocked();
         }
     }
 
     // Switch the CommandLine over from Java to native if it hasn't already been done.
@@ skipping 116 matching lines @@
     private static native void nativeRegisterChromiumAndroidLinkerRendererHistogram(
             boolean requestedSharedRelro,
             boolean loadAtFixedAddressFailed);
 
     // Get the version of the native library. This is needed so that we can check we
     // have the right version before initializing the (rest of the) JNI.
     private static native String nativeGetVersionNumber();
 
     private static native void nativeRecordNativeLibraryHack(boolean usedHack);
 }