Update from chromium https://crrev.com/302282

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;
 
@@ skipping 12 matching lines @@
  * primitives are used to ensure that overlapping requests from different
  * threads are handled sequentially.
  *
  * See also base/android/library_loader/library_loader_hooks.cc, which contains
  * the native counterpart to this class.
  */
 @JNINamespace("base::android")
 public class LibraryLoader {
     private static final String TAG = "LibraryLoader";
 
+    // Set to true to enable debug logs.
+    private static final boolean DEBUG = false;
+
     // Guards all access to the libraries
     private static final Object sLock = new Object();
 
     // One-way switch becomes true when the libraries are loaded.
     private static boolean sLoaded = false;
 
     // One-way switch becomes true when the Java command line is switched to
     // native.
     private static boolean sCommandLineSwitched = false;
 
     // 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.
     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;
 
     /**
      * The same as ensureInitialized(null, false), should only be called
      * by non-browser processes.
      *
      * @throws ProcessInitException
@@ skipping 91 matching lines @@
                 assert !sInitialized;
 
                 long startTime = SystemClock.uptimeMillis();
                 boolean useChromiumLinker = Linker.isUsed();
 
                 if (useChromiumLinker) {
                     // 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);
                         } else {
                             Log.i(TAG, "Loading: " + library);
                         }
 
                         boolean isLoaded = false;
                         if (Linker.isUsingBrowserSharedRelros()) {
                             sIsUsingBrowserSharedRelros = true;
                             try {
                                 if (zipfile != null) {
                                     Linker.loadLibraryInZipFile(zipfile, library);
                                     sLibraryWasLoadedFromApk = true;
                                 } else {
                                     Linker.loadLibrary(library);
                                 }
                                 isLoaded = true;
                             } catch (UnsatisfiedLinkError e) {
-                                Log.w(TAG, "Failed to load native library with shared RELRO, " +
-                                      "retrying without");
+                                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);
                             }
                         }
                     }
 
                     Linker.finishLibraryLoad();
                 } else {
                     // Load libraries using the system linker.
                     for (String library : NativeLibraries.LIBRARIES) {
                         try {
                             System.loadLibrary(library);
                         } catch (UnsatisfiedLinkError e) {
                             if (context != null
-                                && LibraryLoaderHelper.tryLoadLibraryUsingWorkaround(context,
+                                    && LibraryLoaderHelper.tryLoadLibraryUsingWorkaround(context,
                                                                                      library)) {
                                 sNativeLibraryHackWasUsed = true;
                             } else {
                                 throw e;
                             }
                         }
                     }
                 }
 
                 if (context != null
-                    && shouldDeleteOldWorkaroundLibraries
-                    && !sNativeLibraryHackWasUsed) {
+                        && shouldDeleteOldWorkaroundLibraries
+                        && !sNativeLibraryHackWasUsed) {
                     LibraryLoaderHelper.deleteWorkaroundLibrariesAsynchronously(
-                        context);
+                            context);
                 }
 
                 long stopTime = SystemClock.uptimeMillis();
                 Log.i(TAG, String.format("Time to load native libraries: %d ms (timestamps %d-%d)",
                         stopTime - startTime,
                         startTime % 10000,
                         stopTime % 10000));
 
                 sLoaded = true;
             }
         } catch (UnsatisfiedLinkError e) {
             throw new ProcessInitException(LoaderErrors.LOADER_ERROR_NATIVE_LIBRARY_LOAD_FAILED, e);
         }
         // Check that the version of the library we have loaded matches the version we expect
         Log.i(TAG, String.format(
-                "Expected native library version number \"%s\"," +
-                        "actual native library version number \"%s\"",
+                "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);
         }
     }
 
     // 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.
@@ skipping 65 matching lines @@
 
     // Returns the device's status for loading a library directly from the APK file.
     // This method can only be called when the Chromium linker is used.
     private static int getLibraryLoadFromApkStatus(Context context) {
         assert Linker.isUsed();
 
         if (sLibraryWasLoadedFromApk) {
             return LibraryLoadFromApkStatusCodes.SUCCESSFUL;
         }
 
+        if (!sLibraryWasAlignedInApk) {
+            return LibraryLoadFromApkStatusCodes.NOT_ALIGNED;
+        }
+
         if (context == null) {
             Log.w(TAG, "Unknown APK filename due to null context");
             return LibraryLoadFromApkStatusCodes.UNKNOWN;
         }
 
-        return Linker.checkLibraryLoadFromApkSupport(context.getApplicationInfo().sourceDir) ?
-                LibraryLoadFromApkStatusCodes.SUPPORTED :
-                LibraryLoadFromApkStatusCodes.NOT_SUPPORTED;
+        return Linker.checkLibraryLoadFromApkSupport(context.getApplicationInfo().sourceDir)
+                ? LibraryLoadFromApkStatusCodes.SUPPORTED
+                : LibraryLoadFromApkStatusCodes.NOT_SUPPORTED;
     }
 
     // Register pending Chromium linker histogram state for renderer processes. This cannot be
     // recorded as a histogram immediately because histograms and IPC are not ready at the
     // time it are captured. This function stores a pending value, so that a later call to
     // RecordChromiumAndroidLinkerRendererHistogram() will record it correctly.
     public static void registerRendererProcessHistogram(boolean requestedSharedRelro,
                                                         boolean loadAtFixedAddressFailed) {
         if (Linker.isUsed()) {
             nativeRegisterChromiumAndroidLinkerRendererHistogram(requestedSharedRelro,
@@ skipping 26 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);
 }