Fix low-memory devices crashing on Chrome start up during UMA recodring

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 32 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 recording whether the device supports memory mapping
-    // APK files with executable permissions. Only used in the browser.
-    private static boolean sLibraryLoadFromApkSupported = false;
+    // The name of the APK file.
+    private static String sApkFileName = null;
+
+    // One-way switch becomes true when the library is successfully loaded from

[rmcilroy, 2014/10/20 10:42:39]

nit - One-way switch becomes true if the library was loaded from the APK
directly.

[petrcermak, 2014/10/20 15:33:22]

Done.

+    // the APK file.
+    private static boolean sLibraryLoadedFromApk = false;

[rmcilroy, 2014/10/20 10:42:39]

nit - sLibraryWasLoadedFromApk

[petrcermak, 2014/10/20 15:33:22]

Done.

 
     // 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.
      *
@@ skipping 87 matching lines @@
     private static void loadAlreadyLocked(
             Context context, boolean shouldDeleteOldWorkaroundLibraries)
             throws ProcessInitException {
         try {
             if (!sLoaded) {
                 assert !sInitialized;
 
                 long startTime = SystemClock.uptimeMillis();
                 boolean useChromiumLinker = Linker.isUsed();
 
+                if (context != null) {
+                    sApkFileName = context.getApplicationInfo().sourceDir;
+                }
+
                 if (useChromiumLinker) {
                     // Load libraries using the Chromium linker.
                     Linker.prepareLibraryLoad();
 
-                    // Check if the device supports loading a library directly from the APK file.
-                    String apkfile = context.getApplicationInfo().sourceDir;
-                    if (Linker.isInBrowserProcess()) {
-                        sLibraryLoadFromApkSupported = Linker.checkLibraryLoadFromApkSupport(
-                                apkfile);
-                    }
-
                     for (String library : NativeLibraries.LIBRARIES) {
                         String zipfile = null;
                         if (Linker.isInZipFile()) {
-                            zipfile = apkfile;
+                            zipfile = sApkFileName;
                             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);
+                                    sLibraryLoadedFromApk = true;
                                 } else {
                                     Linker.loadLibrary(library);
                                 }
                                 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);
+                                sLibraryLoadedFromApk = true;
                             } else {
                                 Linker.loadLibrary(library);
                             }
                         }
                     }
 
                     Linker.finishLibraryLoad();
                 } else {
                     // Load libraries using the system linker.
                     for (String library : NativeLibraries.LIBRARIES) {
@@ skipping 94 matching lines @@
     }
 
     // Called after all native initializations are complete.
     public static void onNativeInitializationComplete() {
         recordBrowserProcessHistogram();
         nativeRecordNativeLibraryHack(sNativeLibraryHackWasUsed);
     }
 
     // Record Chromium linker histogram state for the main browser process. Called from
     // onNativeInitializationComplete().
     private static void recordBrowserProcessHistogram() {

[rmcilroy, 2014/10/20 10:42:39]

It looks like this is only called from onNativeInitializationComplete(), which
itself is only called from NativeInitializationController, which has a mContext
field.  Could we pass the context to this function in order to avoid storing
sApkFileName as a static field?

[petrcermak, 2014/10/20 15:33:22]

Done.

         if (Linker.isUsed()) {
-            assert Linker.isInBrowserProcess();
+            int libraryLoadFromApkSupport;

[rmcilroy, 2014/10/20 10:42:39]

nit - libraryLoadFromApkStatus

[petrcermak, 2014/10/20 15:33:22]

The variable is not needed now that the code is in a separate function.

+            if (sLibraryLoadedFromApk) {
+                libraryLoadFromApkSupport = LibraryLoadFromApkSupportCode.SUCCESSFUL;
+            } else if (sApkFileName != null) {
+                libraryLoadFromApkSupport = Linker.checkLibraryLoadFromApkSupport(sApkFileName) ?
+                        LibraryLoadFromApkSupportCode.SUPPORTED :
+                        LibraryLoadFromApkSupportCode.NOT_SUPPORTED;
+            } else {
+                libraryLoadFromApkSupport = LibraryLoadFromApkSupportCode.UNKNOWN;
+                Log.w(TAG, "Unknown APK filename due to null context");
+            }

[rmcilroy, 2014/10/20 10:42:39]

Please pull this out into a separate function which returns the
libraryLoadFromApkStatus and just call it on the line below.

[petrcermak, 2014/10/20 15:33:22]

Done.

             nativeRecordChromiumAndroidLinkerBrowserHistogram(sIsUsingBrowserSharedRelros,
                                                               sLoadAtFixedAddressFailed,
-                                                              sLibraryLoadFromApkSupported);
+                                                              libraryLoadFromApkSupport);
         }
     }
 
     // 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,
                                                                  loadAtFixedAddressFailed);
         }
     }
 
     private static native void nativeInitCommandLine(String[] initCommandLine);
 
     // Only methods needed before or during normal JNI registration are during System.OnLoad.
     // nativeLibraryLoaded is then called to register everything else.  This process is called
     // "initialization".  This method will be mapped (by generated code) to the LibraryLoaded
     // definition in base/android/library_loader/library_loader_hooks.cc.
     //
     // Return true on success and false on failure.
     private static native boolean nativeLibraryLoaded();
 
     // Method called to record statistics about the Chromium linker operation for the main
     // browser process. Indicates whether the linker attempted relro sharing for the browser,
     // and if it did, whether the library failed to load at a fixed address. Also records
-    // support for memory mapping APK files with executable permissions.
+    // support for loading a library directly from the APK file.
     private static native void nativeRecordChromiumAndroidLinkerBrowserHistogram(
             boolean isUsingBrowserSharedRelros,
             boolean loadAtFixedAddressFailed,
-            boolean apkMemoryMappingSupported);
+            int libraryLoadFromApkSupport);
 
     // Method called to register (for later recording) statistics about the Chromium linker
     // operation for a renderer process. Indicates whether the linker attempted relro sharing,
     // and if it did, whether the library failed to load at a fixed address.
     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);
 }