Android: Add chrome-specific dynamic linker.

content/public/android/java/src/org/chromium/content/browser/ChildProcessLauncher.java

 // Copyright 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.browser;
 
 import android.content.Context;
+import android.os.Bundle;
 import android.util.Log;
 import android.util.SparseIntArray;
 import android.view.Surface;
 
 import java.util.ArrayList;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 
 import org.chromium.base.CalledByNative;
 import org.chromium.base.JNINamespace;
+import org.chromium.base.Linker;
 import org.chromium.base.ThreadUtils;
 import org.chromium.content.app.ChildProcessService;
+import org.chromium.content.app.LibraryLoader;
 import org.chromium.content.app.PrivilegedProcessService;
 import org.chromium.content.app.SandboxedProcessService;
 import org.chromium.content.common.IChildProcessCallback;
 import org.chromium.content.common.IChildProcessService;
 
 /**
  * This class provides the method to start/stop ChildProcess called by native.
  */
 @JNINamespace("content")
 public class ChildProcessLauncher {
@@ skipping 138 matching lines @@
         return;
     }
 
     // Represents an invalid process handle; same as base/process/process.h kNullProcessHandle.
     private static final int NULL_PROCESS_HANDLE = 0;
 
     // Map from pid to ChildService connection.
     private static Map<Integer, ChildProcessConnection> sServiceMap =
             new ConcurrentHashMap<Integer, ChildProcessConnection>();
 
+    // Bundle from Linker.getRelroBundle(), to be sent to each service once
+    // setRelroBundle() is called.
+    private static Bundle sRelroBundle = null;
+
     // Map from pid to the count of oom bindings. "Oom binding" is a binding that raises the process
     // oom priority so that it shouldn't be killed by the OS out-of-memory killer under normal
     // conditions (it can still be killed under drastic memory pressure).
     private static SparseIntArray sOomBindingCount = new SparseIntArray();
 
     // A pre-allocated and pre-bound connection ready for connection setup, or null.
     private static ChildProcessConnection sSpareSandboxedConnection = null;
 
     /**
      * Returns the child process service interface for the given pid. This may be called on
@@ skipping 13 matching lines @@
 
     /**
      * Should be called early in startup so the work needed to spawn the child process can be done
      * in parallel to other startup work. Must not be called on the UI thread. Spare connection is
      * created in sandboxed child process.
      * @param context the application context used for the connection.
      */
     public static void warmUp(Context context) {
         synchronized (ChildProcessLauncher.class) {
             assert !ThreadUtils.runningOnUiThread();
+            if (LibraryLoader.useCrazyLinker()) {
+                // Initialization of the relro sharing must happen before any process is started.
+                Linker.initRelroSharing();
+            }
             if (sSpareSandboxedConnection == null) {
                 sSpareSandboxedConnection = allocateBoundConnection(context, null, true);
             }
         }
     }
 
+    public static void setRelroBundle(Bundle bundle) {
+        synchronized (ChildProcessLauncher.class) {
+            sRelroBundle = bundle;
+            if (bundle != null) {
+                for (Map.Entry<Integer, ChildProcessConnection> entry : sServiceMap.entrySet()) {
+                    ChildProcessConnection connection = entry.getValue();
+                    connection.applyRelro(bundle);
+                }
+            }
+        }
+    }
+
     private static String getSwitchValue(final String[] commandLine, String switchKey) {
         if (commandLine == null || switchKey == null) {
             return null;
         }
         // This format should be matched with the one defined in command_line.h.
         final String switchKeyPrefix = "--" + switchKey + "=";
         for (String command : commandLine) {
             if (command != null && command.startsWith(switchKeyPrefix)) {
                 return command.substring(switchKeyPrefix.length());
             }
@@ skipping 60 matching lines @@
         final ChildProcessConnection connection = allocatedConnection;
         Log.d(TAG, "Setting up connection to process: slot=" + connection.getServiceNumber());
 
         ChildProcessConnection.ConnectionCallbacks connectionCallbacks =
                 new ChildProcessConnection.ConnectionCallbacks() {
             public void onConnected(int pid, int oomBindingCount) {
                 Log.d(TAG, "on connect callback, pid=" + pid + " context=" + clientContext);
                 if (pid != NULL_PROCESS_HANDLE) {
                     sOomBindingCount.put(pid, oomBindingCount);
                     sServiceMap.put(pid, connection);
+
+                    if (sRelroBundle != null)
+                        connection.applyRelro(sRelroBundle);
                 } else {
                     freeConnection(connection);
                 }
                 nativeOnChildProcessStarted(clientContext, pid);
             }
 
             public void onOomBindingAdded(int pid) {
                 if (pid != NULL_PROCESS_HANDLE) {
                     sOomBindingCount.put(pid, sOomBindingCount.get(pid) + 1);
                 }
@@ skipping 132 matching lines @@
             Log.w(TAG, message + ", pid=" + pid);
         }
     }
 
     private static native void nativeOnChildProcessStarted(int clientContext, int pid);
     private static native Surface nativeGetViewSurface(int surfaceId);
     private static native void nativeEstablishSurfacePeer(
             int pid, Surface surface, int primaryID, int secondaryID);
     private static native boolean nativeIsSingleProcess();
 }