Android: Add chrome-specific dynamic linker.

content/public/android/java/src/org/chromium/content/app/ChildProcessService.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.app.Service;
 import android.content.Context;
 import android.content.Intent;
 import android.graphics.SurfaceTexture;
 import android.os.Bundle;
 import android.os.IBinder;
 import android.os.ParcelFileDescriptor;
 import android.os.Process;
 import android.os.RemoteException;
 import android.util.Log;
 import android.view.Surface;
 
 import org.chromium.base.CalledByNative;
 import org.chromium.base.JNINamespace;
 import org.chromium.content.browser.ChildProcessConnection;
 import org.chromium.content.common.IChildProcessCallback;
 import org.chromium.content.common.IChildProcessService;
-import org.chromium.content.browser.ChildProcessLauncher;
 import org.chromium.content.common.ProcessInitException;
 
 import java.util.ArrayList;
 import java.util.concurrent.atomic.AtomicReference;
 
 /**
  * This is the base class for child services; the [Non]SandboxedProcessService0, 1.. etc
  * subclasses provide the concrete service entry points, to enable the browser to connect
  * to more than one distinct process (i.e. one process per service number, up to limit of N).
  * The embedding application must declare these service instances in the application section
@@ skipping 10 matching lines @@
 
     // This is the native "Main" thread for the renderer / utility process.
     private Thread mMainThread;
     // Parameters received via IPC, only accessed while holding the mMainThread monitor.
     private String[] mCommandLineParams;
     private int mCpuCount;
     private long mCpuFeatures;
     // Pairs IDs and file descriptors that should be registered natively.
     private ArrayList<Integer> mFileIds;
     private ArrayList<ParcelFileDescriptor> mFileFds;
+    // Linker-specific parameters for this child process service.
+    private LinkerParams mLinkerParams;
 
     private static AtomicReference<Context> sContext = new AtomicReference<Context>(null);
     private boolean mLibraryInitialized = false;
+    // Becomes true once the service is bound.
+    private boolean mIsBound = false;
 
     // Binder object used by clients for this service.
     private final IChildProcessService.Stub mBinder = new IChildProcessService.Stub() {
         // NOTE: Implement any IChildProcessService methods here.
         @Override
         public int setupConnection(Bundle args, IChildProcessCallback callback) {
             mCallback = callback;
             synchronized (mMainThread) {
                 // Allow the command line to be set via bind() intent or setupConnection, but
                 // the FD can only be transferred here.
@@ skipping 14 matching lines @@
                     ParcelFileDescriptor parcel = args.getParcelable(fdName);
                     if (parcel == null) {
                         // End of the file list.
                         break;
                     }
                     mFileFds.add(parcel);
                     String idName = ChildProcessConnection.EXTRA_FILES_PREFIX + i
                             + ChildProcessConnection.EXTRA_FILES_ID_SUFFIX;
                     mFileIds.add(args.getInt(idName));
                 }
+                Bundle sharedRelros = args.getBundle(Linker.EXTRA_LINKER_SHARED_RELROS);
+                if (sharedRelros != null) {
+                    Linker.useSharedRelros(sharedRelros);

[palmer, 2013/10/01 00:11:22]

How sure are we that only the browser could invoke this? I think this guarantees
it (from AndroidManifest.xml):

 12     <permission
android:name="com.google.android.apps.chrome.permission.CHILD_SERVICE"
 13         android:protectionLevel="signature" />

And then each SandboxedProcessService* requires callers to have this Permission.

That works for me, but I wanted to make sure it matches your intent.

[digit1, 2013/10/01 15:40:20]

Yes, this is part of the existing code for starting child processes, and if
anything could invoke it, there would be much more serious problems here.

+                    sharedRelros = null;
+                }
                 mMainThread.notifyAll();
             }
             return Process.myPid();
         }
     };
 
     /* package */ static Context getContext() {
         return sContext.get();
     }
 
     @Override
     public void onCreate() {
         Log.i(TAG, "Creating new ChildProcessService pid=" + Process.myPid());
         if (sContext.get() != null) {
             Log.e(TAG, "ChildProcessService created again in process!");
         }
         sContext.set(this);
         super.onCreate();
 
         mMainThread = new Thread(new Runnable() {
             @Override
             public void run()  {
                 try {
+                    boolean useLinker = Linker.isUsed();
+
+                    if (useLinker) {
+                        synchronized (mMainThread) {
+                            while (!mIsBound)
+                                mMainThread.wait();
+                        }
+                        if (mLinkerParams != null && mLinkerParams.mWaitForSharedRelro)
+                            Linker.initServiceProcess(mLinkerParams.mBaseLoadAddress);
+                        else
+                            Linker.disableSharedRelros();
+                    }
                     try {
                         LibraryLoader.loadNow();
                     } catch (ProcessInitException e) {
                         Log.e(TAG, "Failed to load native library, exiting child process", e);
                         return;
                     }
                     synchronized (mMainThread) {
                         while (mCommandLineParams == null) {
                             mMainThread.wait();
                         }
@@ skipping 56 matching lines @@
     public IBinder onBind(Intent intent) {
         // We call stopSelf() to request that this service be stopped as soon as the client
         // unbinds. Otherwise the system may keep it around and available for a reconnect. The
         // child processes do not currently support reconnect; they must be initialized from
         // scratch every time.
         stopSelf();
 
         synchronized (mMainThread) {
             mCommandLineParams = intent.getStringArrayExtra(
                     ChildProcessConnection.EXTRA_COMMAND_LINE);
+            mLinkerParams = null;
+            if (Linker.isUsed())
+                mLinkerParams = new LinkerParams(intent);
+            mIsBound = true;
             mMainThread.notifyAll();
         }
 
         return mBinder;
     }
 
     /**
      * Called from native code to share a surface texture with another child process.
      * Through using the callback object the browser is used as a proxy to route the
      * call to the correct process.
@@ skipping 65 matching lines @@
             ChildProcessService service, int[] extraFileIds, int[] extraFileFds,
             int cpuCount, long cpuFeatures);
 
     /**
      * Force the child process to exit.
      */
     private static native void nativeExitChildProcess();
 
     private native void nativeShutdownMainThread();
 }