Android: Add chrome-specific dynamic linker.

content/public/android/java/src/org/chromium/content/browser/ChildProcessConnection.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.ComponentName;
 import android.content.Context;
 import android.content.Intent;
 import android.content.ServiceConnection;
 import android.os.AsyncTask;
 import android.os.Bundle;
 import android.os.Handler;
 import android.os.IBinder;
 import android.os.Looper;
 import android.os.ParcelFileDescriptor;
 import android.util.Log;
 
 import java.io.IOException;
 import java.util.concurrent.atomic.AtomicBoolean;
 
 import org.chromium.base.CalledByNative;
 import org.chromium.base.CpuFeatures;
 import org.chromium.base.SysUtils;
 import org.chromium.base.ThreadUtils;
 import org.chromium.content.app.ChildProcessService;
+import org.chromium.content.app.Linker;
+import org.chromium.content.app.LinkerParams;
 import org.chromium.content.common.CommandLine;
 import org.chromium.content.common.IChildProcessCallback;
 import org.chromium.content.common.IChildProcessService;
 import org.chromium.content.common.TraceEvent;
 
 /**
  * Manages a connection between the browser activity and a child service. The class is responsible
  * for estabilishing the connection (start()), closing it (stop()) and increasing the priority of
  * the service when it is in active use (between calls to attachAsActive() and detachAsActive()).
  */
@@ skipping 59 matching lines @@
     // the OS to be able to kill background renderers as it kills other background apps, so strong
     // bindings are maintained only for services that are active at the moment (between
     // attachAsActive() and detachAsActive()).
     private ChildServiceConnection mStrongBinding = null;
     // Low priority binding maintained in the entire lifetime of the connection, i.e. between calls
     // to start() and stop().
     private ChildServiceConnection mWaivedBinding = null;
     // Incremented on attachAsActive(), decremented on detachAsActive().
     private int mAttachAsActiveCount = 0;
 
+    // Linker-related parameters.
+    private LinkerParams mLinkerParams = null;
+
     private static final String TAG = "ChildProcessConnection";
 
     private static class ConnectionParams {
         final String[] mCommandLine;
         final FileDescriptorInfo[] mFilesToBeMapped;
         final IChildProcessCallback mCallback;
+        final Bundle mSharedRelros;
 
         ConnectionParams(String[] commandLine, FileDescriptorInfo[] filesToBeMapped,
-                IChildProcessCallback callback) {
+                IChildProcessCallback callback, Bundle sharedRelros) {
             mCommandLine = commandLine;
             mFilesToBeMapped = filesToBeMapped;
             mCallback = callback;
+            mSharedRelros = sharedRelros;
         }
     }
 
     // This is set by the consumer of the class in setupConnection() and is later used in
     // doSetupConnection(), after which the variable is cleared. Therefore this is only valid while
     // the connection is being set up.
     private ConnectionParams mConnectionParams;
 
     // Callbacks used to notify the consumer about connection events. This is also provided in
     // setupConnection(), but remains valid after setup.
     private ChildProcessConnection.ConnectionCallback mConnectionCallback;
 
     private class ChildServiceConnection implements ServiceConnection {
         private boolean mBound = false;
 
         private final int mBindFlags;
 
         public ChildServiceConnection(int bindFlags) {
             mBindFlags = bindFlags;
         }
 
         boolean bind(String[] commandLine) {
             if (!mBound) {
                 final Intent intent = createServiceBindIntent();
                 if (commandLine != null) {
                     intent.putExtra(EXTRA_COMMAND_LINE, commandLine);
                 }
+                if (mLinkerParams != null)
+                    mLinkerParams.addIntentExtras(intent);
                 mBound = mContext.bindService(intent, this, mBindFlags);
             }
             return mBound;
         }
 
         void unbind() {
             if (mBound) {
                 mContext.unbindService(this);
                 mBound = false;
             }
@@ skipping 42 matching lines @@
             }
             // TODO(ppi): does anyone know why we need to do that?
             if (disconnectedWhileBeingSetUp && mConnectionCallback != null) {
                 mConnectionCallback.onConnected(0);
             }
         }
     }
 
     ChildProcessConnection(Context context, int number, boolean inSandbox,
             ChildProcessConnection.DeathCallback deathCallback,
-            Class<? extends ChildProcessService> serviceClass) {
+            Class<? extends ChildProcessService> serviceClass,
+            LinkerParams linkerParams) {
         mContext = context;
         mServiceNumber = number;
         mInSandbox = inSandbox;
         mDeathCallback = deathCallback;
         mServiceClass = serviceClass;
+        mLinkerParams = linkerParams;
         mInitialBinding = new ChildServiceConnection(Context.BIND_AUTO_CREATE);
         mStrongBinding = new ChildServiceConnection(
                 Context.BIND_AUTO_CREATE | Context.BIND_IMPORTANT);
         mWaivedBinding = new ChildServiceConnection(
                 Context.BIND_AUTO_CREATE | Context.BIND_WAIVE_PRIORITY);
     }
 
     int getServiceNumber() {
         return mServiceNumber;
     }
@@ skipping 43 matching lines @@
      * @param commandLine (Optional) will be ignored if the command line was already sent in bind()
      * @param fileToBeMapped a list of file descriptors that should be registered
      * @param callback Used for status updates regarding this process connection.
      * @param connectionCallbacks will notify the consumer about the connection being established
      * and the status of the out-of-memory bindings being bound for the connection.
      */
     void setupConnection(
             String[] commandLine,
             FileDescriptorInfo[] filesToBeMapped,
             IChildProcessCallback processCallback,
-            ConnectionCallback connectionCallbacks) {
+            ConnectionCallback connectionCallbacks,
+            Bundle sharedRelros) {
         synchronized(mLock) {
             TraceEvent.begin();
             assert mConnectionParams == null;
             mConnectionCallback = connectionCallbacks;
-            mConnectionParams = new ConnectionParams(commandLine, filesToBeMapped, processCallback);
+            mConnectionParams = new ConnectionParams(
+                    commandLine, filesToBeMapped, processCallback, sharedRelros);
             // Make sure that the service is already connected. If not, doConnectionSetup() will be
             // called from onServiceConnected().
             if (mServiceConnectComplete) {
                 doConnectionSetup();
             }
             TraceEvent.end();
         }
     }
 
     /**
@@ skipping 62 matching lines @@
                     }
 
                 }
                 bundle.putParcelable(fdName, parcelFiles[i]);
                 bundle.putInt(idName, fileInfos[i].mId);
             }
             // Add the CPU properties now.
             bundle.putInt(EXTRA_CPU_COUNT, CpuFeatures.getCount());
             bundle.putLong(EXTRA_CPU_FEATURES, CpuFeatures.getMask());
 
+            bundle.putBundle(Linker.EXTRA_LINKER_SHARED_RELROS,
+                             mConnectionParams.mSharedRelros);
+
             try {
                 mPID = mService.setupConnection(bundle, mConnectionParams.mCallback);
             } catch (android.os.RemoteException re) {
                 Log.e(TAG, "Failed to setup connection.", re);
             }
             // We proactively close the FDs rather than wait for GC & finalizer.
             try {
                 for (ParcelFileDescriptor parcelFile : parcelFiles) {
                     if (parcelFile != null) parcelFile.close();
                 }
@@ skipping 84 matching lines @@
 
     /**
      * @return The connection PID, or 0 if not yet connected.
      */
     int getPid() {
         synchronized(mLock) {
             return mPID;
         }
     }
 }