Prefetch the native library from native code by parsing /proc/pid/maps.

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

Index: base/android/java/src/org/chromium/base/library_loader/LibraryLoader.java
diff --git a/base/android/java/src/org/chromium/base/library_loader/LibraryLoader.java b/base/android/java/src/org/chromium/base/library_loader/LibraryLoader.java
index 484c6bc56d55596cdf77610e3cbf8e541c4d3d67..96b9c23508b2c8b1da6d7578557cc0e68d1264f7 100644
--- a/base/android/java/src/org/chromium/base/library_loader/LibraryLoader.java
+++ b/base/android/java/src/org/chromium/base/library_loader/LibraryLoader.java
@@ -250,15 +250,23 @@ public class LibraryLoader {
         new AsyncTask<Void, Void, Void>() {
             @Override
             protected Void doInBackground(Void... params) {
-                // Note: AsyncTasks are executed in a low priority background
-                // thread, which is the desired behavior here since we don't
-                // want to interfere with the rest of the initialization.
-                for (String library : NativeLibraries.LIBRARIES) {
-                    if (Linker.isChromiumLinkerLibrary(library)) {
-                        continue;
+                TraceEvent.begin("LibraryLoader.asyncPrefetchLibrariesToMemory");
+                // First, try to fork a new process to do the prefetch. If it
+                // fails, fall back to doing it by mapping the library.
+                boolean ok = nativeForkAndPrefetchNativeLibrary();
+                if (!ok) {

[rmcilroy, 2015/04/07 12:17:27]

Do you expect the fork to ever fail for any valid reason other than bugs? I
would really prefer not to do a fallback - it just hides issues when the actual
implementation fails and makes things more difficult to spot problems and debug
them. Even if the fork fails it isn't the end of the world, startup will just be
slightly slower. Let's just remove this and add some UMA metrics to track
whether the fork actually fails in the wild.

[Benoit L, 2015/04/16 13:28:47]

fork() can fail for a variety of reasons (weird SELinux policy for instance). I
do agree that the fallback should not stay, but I suggest to first put a UMA
metric, and then to remove the current prefetching code.
Would that work for you?

[rmcilroy, 2015/04/23 15:09:42]

I would prefer you removed the fallback now and added UMA either in this CL or
in a followup soon after. As I say, the fallback would hide a multitude of sins
and since we aren't breaking anything if the prefetching fails I would really
prefer not to have any fallback code in here.

[Benoit L, 2015/04/24 14:24:36]

Done.

+                    Log.w(TAG, "Forking a process to prefetch the native library failed.");
+                    // AsyncTasks are executed in a low priority background
+                    // thread, which is the desired behavior to avoid
+                    // interfering with the rest of the initialization.
+                    for (String library : NativeLibraries.LIBRARIES) {
+                        if (Linker.isChromiumLinkerLibrary(library)) {
+                            continue;
+                        }
+                        prefetchLibraryToMemory(context, library);
                     }
-                    prefetchLibraryToMemory(context, library);
                 }
+                TraceEvent.end("LibraryLoader.asyncPrefetchLibrariesToMemory");
                 return null;
             }
         }.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
@@ -573,4 +581,9 @@ public class LibraryLoader {
     // 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 native String nativeGetVersionNumber();
+
+    // 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();
 }