Android: Add chrome-specific dynamic linker.

content/public/android/java/src/org/chromium/content/app/LibraryLoader.java

 // Copyright (c) 2012 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.content.app;
 
 import android.text.TextUtils;
 import android.util.Log;
 
+import org.chromium.base.Linker;
 import org.chromium.base.JNINamespace;
+import org.chromium.content.browser.ChildProcessLauncher;
 import org.chromium.content.common.CommandLine;
 import org.chromium.content.common.ProcessInitException;
 import org.chromium.content.common.ResultCodes;
 import org.chromium.content.common.TraceEvent;
 
 /**
  * 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
@@ skipping 14 matching lines @@
     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 libraries are initialized (
     // by calling nativeLibraryLoaded, which forwards to LibraryLoaded(...) in
     // library_loader_hooks.cc).
     private static boolean sInitialized = false;
 
+    public static boolean useCrazyLinker() {
+        return NativeLibraries.USE_CRAZY_LINKER;
+    }
+
     // TODO(cjhopman): Remove this once it's unused.
     /**
      * Doesn't do anything.
      */
     @Deprecated
     public static void setLibraryToLoad(String library) {
     }
 
     /**
      *  This method blocks until the library is fully loaded and initialized.
      */
     public static void ensureInitialized() throws ProcessInitException {
         synchronized (sLock) {
             if (sInitialized) {
                 // Already initialized, nothing to do.
                 return;
             }
             loadAlreadyLocked();
             initializeAlreadyLocked(CommandLine.getJavaSwitchesOrNull());
+            if (useCrazyLinker())
+                ChildProcessLauncher.setRelroBundle(Linker.getRelroBundle());
         }
     }
 
     /**
      * Checks if library is fully loaded and initialized.
      */
     public static boolean isInitialized() {
         synchronized (sLock) {
             return sInitialized;
         }
@@ skipping 28 matching lines @@
         }
     }
 
 
     // Invoke System.loadLibrary(...), triggering JNI_OnLoad in native code
     private static void loadAlreadyLocked() throws ProcessInitException {
         try {
             if (!sLoaded) {
                 assert !sInitialized;
                 for (String sLibrary : NativeLibraries.libraries) {
-                    Log.i(TAG, "loading: " + sLibrary);
-                    System.loadLibrary(sLibrary);
-                    Log.i(TAG, "loaded: " + sLibrary);
+                    if (useCrazyLinker()) {
+                        Linker.loadLibrary(sLibrary);
+                    } else if (!sLibrary.equals("crazy_linker")) {
+                        System.loadLibrary(sLibrary);
+                    }
                 }
                 sLoaded = true;
             }
         } catch (UnsatisfiedLinkError e) {
             throw new ProcessInitException(ResultCodes.RESULT_CODE_NATIVE_LIBRARY_LOAD_FAILED, e);
         }
     }
 
 
     // Invoke content::LibraryLoaded in library_loader_hooks.cc
     private static void initializeAlreadyLocked(String[] initCommandLine)
             throws ProcessInitException {
         if (sInitialized) {
             return;
         }
         int resultCode = nativeLibraryLoaded(initCommandLine);
         if (resultCode != 0) {
             Log.e(TAG, "error calling nativeLibraryLoaded");
             throw new ProcessInitException(resultCode);
         }
         // From this point on, native code is ready to use and checkIsReady()
         // shouldn't complain from now on (and in fact, it's used by the
         // following calls).
         sInitialized = true;
         CommandLine.enableNativeProxy();
         TraceEvent.setEnabledToMatchNative();
+        // Record histogram for crazy linker.
+        if (useCrazyLinker())
+          nativeRecordCrazyLinkerHistogram(Linker.loadAtFixedAddressFailed());
     }
 
     // This is the only method that is registered during System.loadLibrary. We then call it
     // to register everything else. This process is called "initialization".
     // This method will be mapped (by generated code) to the LibraryLoaded
     // definition in content/app/android/library_loader_hooks.cc.
     //
     // Return 0 on success, otherwise return the error code from
     // content/public/common/result_codes.h.
     private static native int nativeLibraryLoaded(String[] initCommandLine);
+
+    // Method called to register if the crazy linker was able to load library at a fixed address.
+     // This is called once the library loading is done and successful.
+    private static native void nativeRecordCrazyLinkerHistogram(
+         boolean loadedAtFixedAddressFailed);
 }