Upstream: ChildProcessLauncher connects renderer processes of WebAPKs.

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.annotation.SuppressLint;
 import android.content.Context;
 import android.content.Intent;
 import android.content.pm.ApplicationInfo;
@@ skipping 20 matching lines @@
 import org.chromium.content.app.ChromiumLinkerParams;
 import org.chromium.content.app.DownloadProcessService;
 import org.chromium.content.app.PrivilegedProcessService;
 import org.chromium.content.app.SandboxedProcessService;
 import org.chromium.content.common.ContentSwitches;
 import org.chromium.content.common.IChildProcessCallback;
 import org.chromium.content.common.SurfaceWrapper;
 
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.LinkedList;
 import java.util.Map;
 import java.util.Queue;
 import java.util.concurrent.ConcurrentHashMap;
 
 /**
  * This class provides the method to start/stop ChildProcess called by native.
  */
 @JNINamespace("content")
 public class ChildProcessLauncher {
     private static final String TAG = "ChildProcLauncher";
 
     static final int CALLBACK_FOR_UNKNOWN_PROCESS = 0;
     static final int CALLBACK_FOR_GPU_PROCESS = 1;
     static final int CALLBACK_FOR_RENDERER_PROCESS = 2;
     static final int CALLBACK_FOR_UTILITY_PROCESS = 3;
     static final int CALLBACK_FOR_DOWNLOAD_PROCESS = 4;
 
     private static class ChildConnectionAllocator {
         // Connections to services. Indices of the array correspond to the service numbers.
         private final ChildProcessConnection[] mChildProcessConnections;
 
         // The list of free (not bound) service indices.
         // SHOULD BE ACCESSED WITH mConnectionLock.
         private final ArrayList<Integer> mFreeConnectionIndices;
         private final Object mConnectionLock = new Object();
 
         private Class<? extends ChildProcessService> mChildClass;
         private final boolean mInSandbox;
+        // Each Allocator keeps an queue for the pending spawn data. Once a connection is free, we
+        // dequeue the pending spawn data from the same allocator as the connection.
+        private PendingSpawnQueue mPendingSpawnQueue = new PendingSpawnQueue();

[Maria, 2016/06/07 17:20:17]

final?

an queue -> a queue.

[Xi Han, 2016/06/07 18:50:00]

Done.

 
         public ChildConnectionAllocator(boolean inSandbox, int numChildServices) {
             mChildProcessConnections = new ChildProcessConnectionImpl[numChildServices];
             mFreeConnectionIndices = new ArrayList<Integer>(numChildServices);
             for (int i = 0; i < numChildServices; i++) {
                 mFreeConnectionIndices.add(i);
             }
             mChildClass =
                     inSandbox ? SandboxedProcessService.class : PrivilegedProcessService.class;
             mInSandbox = inSandbox;
@@ skipping 38 matching lines @@
                 }
             }
         }
 
         public boolean isFreeConnectionAvailable() {
             synchronized (mConnectionLock) {
                 return !mFreeConnectionIndices.isEmpty();
             }
         }
 
+        public PendingSpawnQueue getPendingSpawnQueue() {
+            return mPendingSpawnQueue;
+        }
+
         /** @return the count of connections managed by the allocator */
         @VisibleForTesting
         int allocatedConnectionsCountForTesting() {
             return mChildProcessConnections.length - mFreeConnectionIndices.size();
         }
     }
 
     private static class PendingSpawnData {
         private final Context mContext;
         private final String[] mCommandLine;
         private final int mChildProcessId;
         private final FileDescriptorInfo[] mFilesToBeMapped;
         private final long mClientContext;
         private final int mCallbackType;
         private final boolean mInSandbox;
+        private final ChildProcessCreationParams mCreationParams;
 
         private PendingSpawnData(
                 Context context,
                 String[] commandLine,
                 int childProcessId,
                 FileDescriptorInfo[] filesToBeMapped,
                 long clientContext,
                 int callbackType,
-                boolean inSandbox) {
+                boolean inSandbox,
+                ChildProcessCreationParams creationParams) {
             mContext = context;
             mCommandLine = commandLine;
             mChildProcessId = childProcessId;
             mFilesToBeMapped = filesToBeMapped;
             mClientContext = clientContext;
             mCallbackType = callbackType;
             mInSandbox = inSandbox;
+            mCreationParams = creationParams;
         }
 
         private Context context() {
             return mContext;
         }
         private String[] commandLine() {
             return mCommandLine;
         }
         private int childProcessId() {
             return mChildProcessId;
         }
         private FileDescriptorInfo[] filesToBeMapped() {
             return mFilesToBeMapped;
         }
         private long clientContext() {
             return mClientContext;
         }
         private int callbackType() {
             return mCallbackType;
         }
         private boolean inSandbox() {
             return mInSandbox;
         }
+        private ChildProcessCreationParams getCreationParams() {
+            return mCreationParams;
+        }
     }
 
     private static class PendingSpawnQueue {
         // The list of pending process spawn requests and its lock.
         // Operations on this queue must be atomical w.r.t. free connections updates.
-        private static Queue<PendingSpawnData> sPendingSpawns =
+        private Queue<PendingSpawnData> mPendingSpawns =
                 new LinkedList<PendingSpawnData>();

[Maria, 2016/06/07 17:20:17]

fits on one line

[Xi Han, 2016/06/07 18:49:59]

Done.

-        static final Object sPendingSpawnsLock = new Object();
+        final Object mPendingSpawnsLock = new Object();

[Maria, 2016/06/07 17:20:17]

Now that the queue of spawns isn't static, do we still need to lock it?

[Xi Han, 2016/06/07 18:50:00]

Good catch. Remove the lock.

 
         /**
          * Queue up a spawn requests to be processed once a free service is available.
          * Called when a spawn is requested while we are at the capacity.
          */
         public void enqueueLocked(final PendingSpawnData pendingSpawn) {
-            assert Thread.holdsLock(sPendingSpawnsLock);
-            sPendingSpawns.add(pendingSpawn);
+            assert Thread.holdsLock(mPendingSpawnsLock);
+            mPendingSpawns.add(pendingSpawn);
         }
 
         /**
          * Pop the next request from the queue. Called when a free service is available.
          * @return the next spawn request waiting in the queue.
          */
         public PendingSpawnData dequeueLocked() {
-            assert Thread.holdsLock(sPendingSpawnsLock);
-            return sPendingSpawns.poll();
+            assert Thread.holdsLock(mPendingSpawnsLock);
+            return mPendingSpawns.poll();
         }
 
         /** @return the count of pending spawns in the queue */
         public int sizeLocked() {
-            assert Thread.holdsLock(sPendingSpawnsLock);
-            return sPendingSpawns.size();
+            assert Thread.holdsLock(mPendingSpawnsLock);
+            return mPendingSpawns.size();
         }
     }
 
-    private static final PendingSpawnQueue sPendingSpawnQueue = new PendingSpawnQueue();
-
-    // Service class for child process. As the default value it uses SandboxedProcessService0 and
-    // PrivilegedProcessService0.
-    private static ChildConnectionAllocator sSandboxedChildConnectionAllocator;
+    // Service class for child process.
+    // Map from package name to ChildConnectionAllocator;

[Maria, 2016/06/07 17:20:17]

; -> .

[Xi Han, 2016/06/07 18:50:00]

Done.

+    private static Map<String, ChildConnectionAllocator> sSandboxedChildConnectionAllocatorMap;
+    // As the default value it uses PrivilegedProcessService0.
     private static ChildConnectionAllocator sPrivilegedChildConnectionAllocator;
 
     private static final String NUM_SANDBOXED_SERVICES_KEY =
             "org.chromium.content.browser.NUM_SANDBOXED_SERVICES";
     private static final String NUM_PRIVILEGED_SERVICES_KEY =
             "org.chromium.content.browser.NUM_PRIVILEGED_SERVICES";
     // Overrides the number of available sandboxed services.
     @VisibleForTesting
     public static final String SWITCH_NUM_SANDBOXED_SERVICES_FOR_TESTING = "num-sandboxed-services";
 
-    private static int getNumberOfServices(Context context, boolean inSandbox) {
+    private static int getNumberOfServices(Context context, boolean inSandbox, String packageName) {
         try {
             PackageManager packageManager = context.getPackageManager();
-            ChildProcessCreationParams childProcessCreationParams =
-                    ChildProcessCreationParams.get();
-            final String packageName = childProcessCreationParams != null
-                    ? childProcessCreationParams.getPackageName() : context.getPackageName();
             ApplicationInfo appInfo = packageManager.getApplicationInfo(packageName,
                     PackageManager.GET_META_DATA);
-            int numServices = appInfo.metaData.getInt(inSandbox ? NUM_SANDBOXED_SERVICES_KEY
-                    : NUM_PRIVILEGED_SERVICES_KEY, -1);
+            int numServices = -1;
+            if (appInfo.metaData != null) {
+                numServices = appInfo.metaData.getInt(
+                        inSandbox ? NUM_SANDBOXED_SERVICES_KEY : NUM_PRIVILEGED_SERVICES_KEY, -1);
+            }
             if (inSandbox
                     && CommandLine.getInstance().hasSwitch(
                                SWITCH_NUM_SANDBOXED_SERVICES_FOR_TESTING)) {
                 String value = CommandLine.getInstance().getSwitchValue(
                         SWITCH_NUM_SANDBOXED_SERVICES_FOR_TESTING);
                 if (!TextUtils.isEmpty(value)) {
                     try {
                         numServices = Integer.parseInt(value);
                     } catch (NumberFormatException e) {
                         Log.w(TAG, "The value of --num-sandboxed-services is formatted wrongly: "
                                         + value);
                     }
                 }
             }
             if (numServices < 0) {
                 throw new RuntimeException("Illegal meta data value for number of child services");
             }
             return numServices;
         } catch (PackageManager.NameNotFoundException e) {
             throw new RuntimeException("Could not get application info");
         }
     }
 
-    private static void initConnectionAllocatorsIfNecessary(Context context) {
+    private static void initConnectionAllocatorsIfNecessary(
+            Context context, boolean inSandbox, String packageName) {

[Maria, 2016/06/07 17:20:17]

it seems like previously this method allocated both a sandboxed allocator and a
privileged allocator, but now it will only do either one or the other depending
on the value of inSandbox?

[Xi Han, 2016/06/07 18:49:59]

Yes, we can prevent the privileged process (GPU) is initialized by using the
WebAPK's package name when it is in the WebAPK's run time. The GPU process
should always use the default Chrome's parameter if exists. It is possible to
use a wrong one, think of the case that WebAPK is launched when Chrome isn't. If
the renderer process is created before the GPU process, this function will use
the wrong package name to initialize the sPrivilegedChildConnectionAllocator.

         synchronized (ChildProcessLauncher.class) {
-            if (sSandboxedChildConnectionAllocator == null) {
-                sSandboxedChildConnectionAllocator =
-                        new ChildConnectionAllocator(true, getNumberOfServices(context, true));
+            if (inSandbox) {
+                if (sSandboxedChildConnectionAllocatorMap == null) {
+                    sSandboxedChildConnectionAllocatorMap =
+                            new HashMap<String, ChildConnectionAllocator>();
+                }
+                if (!sSandboxedChildConnectionAllocatorMap.containsKey(packageName)) {
+                    Log.w(TAG, "Create a new ChildConnectionAllocator with package name = %s,"
+                                    + " inSandbox = true",
+                            packageName);
+                    sSandboxedChildConnectionAllocatorMap.put(packageName,
+                            new ChildConnectionAllocator(true,
+                                    getNumberOfServices(context, true, packageName)));
+                }
+            } else if (sPrivilegedChildConnectionAllocator == null) {
+                sPrivilegedChildConnectionAllocator = new ChildConnectionAllocator(
+                        false, getNumberOfServices(context, false, packageName));
             }
-            if (sPrivilegedChildConnectionAllocator == null) {
-                sPrivilegedChildConnectionAllocator =
-                        new ChildConnectionAllocator(false, getNumberOfServices(context, false));
-            }
+            // TODO(pkotwicz|hanxi): Figure out when old allocators should be removed from
+            // {@code sSandboxedChildConnectionAllocatorMap}.
         }
     }
 
-    private static ChildConnectionAllocator getConnectionAllocator(boolean inSandbox) {
-        return inSandbox
-                ? sSandboxedChildConnectionAllocator : sPrivilegedChildConnectionAllocator;
+    /**
+     * Note: please make sure that the Allocator has been initialized before calling this function.
+     * Otherwise, always calls {@link initConnectionAllocatorsIfNecessary} first.
+     */
+    private static ChildConnectionAllocator getConnectionAllocator(
+            String packageName, boolean inSandbox) {
+        if (!inSandbox) {
+            return sPrivilegedChildConnectionAllocator;
+        }
+        return sSandboxedChildConnectionAllocatorMap.get(packageName);
+    }
+
+    /**
+     * Get the PendingSpawnQueue of the Allocator. Initialize the Allocator if needed.
+     */
+    private static PendingSpawnQueue getPendingSpawnQueue(Context context, String packageName,
+            boolean inSandbox) {
+        initConnectionAllocatorsIfNecessary(context, inSandbox, packageName);
+        return getConnectionAllocator(packageName, inSandbox).getPendingSpawnQueue();
     }
 
     private static ChildProcessConnection allocateConnection(Context context, boolean inSandbox,
-            ChromiumLinkerParams chromiumLinkerParams, boolean alwaysInForeground) {
+            ChromiumLinkerParams chromiumLinkerParams, boolean alwaysInForeground,
+            ChildProcessCreationParams creationParams) {
         ChildProcessConnection.DeathCallback deathCallback =
                 new ChildProcessConnection.DeathCallback() {
                     @Override
                     public void onChildProcessDied(ChildProcessConnection connection) {
                         if (connection.getPid() != 0) {
                             stop(connection.getPid());
                         } else {
                             freeConnection(connection);
                         }
                     }
                 };
-        initConnectionAllocatorsIfNecessary(context);
-        return getConnectionAllocator(inSandbox).allocate(context, deathCallback,
-                chromiumLinkerParams, alwaysInForeground, ChildProcessCreationParams.get());
+        String packageName = creationParams != null ? creationParams.getPackageName()
+                : context.getPackageName();
+        initConnectionAllocatorsIfNecessary(context, inSandbox, packageName);
+        return getConnectionAllocator(packageName, inSandbox)
+                .allocate(context, deathCallback, chromiumLinkerParams, alwaysInForeground,
+                        creationParams);
     }
 
     private static boolean sLinkerInitialized = false;
     private static long sLinkerLoadAddress = 0;
 
     private static ChromiumLinkerParams getLinkerParamsForNewConnection() {
         if (!sLinkerInitialized) {
             if (Linker.isUsed()) {
                 sLinkerLoadAddress = Linker.getInstance().getBaseLoadAddress();
                 if (sLinkerLoadAddress == 0) {
@@ skipping 13 matching lines @@
                                             waitForSharedRelros,
                                             linker.getTestRunnerClassNameForTesting(),
                                             linker.getImplementationForTesting());
         } else {
             return new ChromiumLinkerParams(sLinkerLoadAddress,
                                             waitForSharedRelros);
         }
     }
 
     private static ChildProcessConnection allocateBoundConnection(Context context,
-            String[] commandLine, boolean inSandbox, boolean alwaysInForeground) {
+            String[] commandLine, boolean inSandbox, boolean alwaysInForeground,
+            ChildProcessCreationParams creationParams) {
         ChromiumLinkerParams chromiumLinkerParams = getLinkerParamsForNewConnection();
-        ChildProcessConnection connection = allocateConnection(context, inSandbox,
-                chromiumLinkerParams, alwaysInForeground);
+        ChildProcessConnection connection = allocateConnection(
+                context, inSandbox, chromiumLinkerParams, alwaysInForeground, creationParams);
         if (connection != null) {
             connection.start(commandLine);
 
-            if (inSandbox && !sSandboxedChildConnectionAllocator.isFreeConnectionAvailable()) {
+            String packageName = creationParams != null ? creationParams.getPackageName()
+                    : context.getPackageName();
+            if (inSandbox && !getConnectionAllocator(packageName, inSandbox)
+                    .isFreeConnectionAvailable()) {
                 // Proactively releases all the moderate bindings once all the sandboxed services
                 // are allocated, which will be very likely to have some of them killed by OOM
                 // killer.
                 sBindingManager.releaseAllModerateBindings();
             }
         }
         return connection;
     }
 
     private static final long FREE_CONNECTION_DELAY_MILLIS = 1;
@@ skipping 13 matching lines @@
             @Override
             public void run() {
                 final PendingSpawnData pendingSpawn = freeConnectionAndDequeuePending(conn);
                 if (pendingSpawn != null) {
                     new Thread(new Runnable() {
                         @Override
                         public void run() {
                             startInternal(pendingSpawn.context(), pendingSpawn.commandLine(),
                                     pendingSpawn.childProcessId(), pendingSpawn.filesToBeMapped(),
                                     pendingSpawn.clientContext(), pendingSpawn.callbackType(),
-                                    pendingSpawn.inSandbox());
+                                    pendingSpawn.inSandbox(), pendingSpawn.getCreationParams());
                         }
                     }).start();
                 }
             }
         }, FREE_CONNECTION_DELAY_MILLIS);
     }
 
     private static PendingSpawnData freeConnectionAndDequeuePending(ChildProcessConnection conn) {
-        synchronized (PendingSpawnQueue.sPendingSpawnsLock) {
-            getConnectionAllocator(conn.isInSandbox()).free(conn);
-            return sPendingSpawnQueue.dequeueLocked();
+        ChildConnectionAllocator allocator = getConnectionAllocator(
+                conn.getPackageName(), conn.isInSandbox());
+        assert allocator != null;
+        PendingSpawnQueue pendingSpawnQueue = allocator.getPendingSpawnQueue();
+        synchronized (pendingSpawnQueue.mPendingSpawnsLock) {
+            allocator.free(conn);
+            return pendingSpawnQueue.dequeueLocked();
         }
     }
 
     // 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>();
 
@@ skipping 111 matching lines @@
     /**
      * Called when the embedding application is sent to background.
      */
     public static void onSentToBackground() {
         sApplicationInForeground = false;
         sBindingManager.onSentToBackground();
     }
 
     /**
      * Starts moderate binding management.
+     * Note: WebAPKs and non WebAPKs share the same moderate binding pool, so the size of the
+     * shared moderate binding pool is always set based on the number of sandboxes processes
+     * used by Chrome.
      * @param context Android's context.
      * @param moderateBindingTillBackgrounded true if the BindingManager should add a moderate
      * binding to a render process when it is created and remove the moderate binding when Chrome is
      * sent to the background.
      */
     public static void startModerateBindingManagement(
             Context context, boolean moderateBindingTillBackgrounded) {
-        sBindingManager.startModerateBindingManagement(
-                context, getNumberOfServices(context, true), moderateBindingTillBackgrounded);
+        sBindingManager.startModerateBindingManagement(context,
+                getNumberOfServices(context, true, context.getPackageName()),
+                moderateBindingTillBackgrounded);
     }
 
     /**
      * Called when the embedding application is brought to foreground.
      */
     public static void onBroughtToForeground() {
         sApplicationInForeground = true;
         sBindingManager.onBroughtToForeground();
     }
 
     /**
      * Returns whether the application is currently in the foreground.
      */
     static boolean isApplicationInForeground() {
         return sApplicationInForeground;
     }
 
     /**
      * 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.
-     * @param params child process creation params.
      */
-    public static void warmUp(Context context, ChildProcessCreationParams params) {
-        ChildProcessCreationParams.set(params);
+    public static void warmUp(Context context) {
         synchronized (ChildProcessLauncher.class) {
             assert !ThreadUtils.runningOnUiThread();
             if (sSpareSandboxedConnection == null) {
-                sSpareSandboxedConnection = allocateBoundConnection(context, null, true, false);
+                ChildProcessCreationParams params = ChildProcessCreationParams.get();
+                if (params != null) {
+                    params = params.copy();
+                }
+                sSpareSandboxedConnection = allocateBoundConnection(context, null, true, false,
+                        params);
             }
         }
     }
 
     @CalledByNative
     private static FileDescriptorInfo makeFdInfo(
             int id, int fd, boolean autoClose, long offset, long size) {
         ParcelFileDescriptor pFd;
         if (autoClose) {
             // Adopt the FD, it will be closed when we close the ParcelFileDescriptor.
@@ skipping 22 matching lines @@
      */
     @CalledByNative
     private static void start(Context context, final String[] commandLine, int childProcessId,
             FileDescriptorInfo[] filesToBeMapped, long clientContext) {
         assert clientContext != 0;
 
         int callbackType = CALLBACK_FOR_UNKNOWN_PROCESS;
         boolean inSandbox = true;
         String processType =
                 ContentSwitches.getSwitchValue(commandLine, ContentSwitches.SWITCH_PROCESS_TYPE);
+        ChildProcessCreationParams params = null;
         if (ContentSwitches.SWITCH_RENDERER_PROCESS.equals(processType)) {
             callbackType = CALLBACK_FOR_RENDERER_PROCESS;
+            if (ChildProcessCreationParams.get() != null) {
+                params = ChildProcessCreationParams.get().copy();
+            }
         } else if (ContentSwitches.SWITCH_GPU_PROCESS.equals(processType)) {
             callbackType = CALLBACK_FOR_GPU_PROCESS;
             inSandbox = false;
         } else if (ContentSwitches.SWITCH_UTILITY_PROCESS.equals(processType)) {
             // We only support sandboxed right now.
             callbackType = CALLBACK_FOR_UTILITY_PROCESS;
         } else {
             assert false;
         }

[pkotwicz, 2016/06/02 02:16:30]

michaelbai@ would it be acceptable to set {@link params} to the default value if
{@link params} == null.
This would save a lot of null checking elsewhere

If am thinking:

if (params == null) {
    params = new ChildProcessCreationParams(new
ChildProcessCreationParams(context.getPackageName(), 0,
LibraryProcessType.PROCESS_CHILD);
}

[michaelbai, 2016/06/03 17:38:46]

It is fine.

[Xi Han, 2016/06/03 18:03:36]

Since I already added these checks, will leave them as now unless they bother
other reviewers.

 
         startInternal(context, commandLine, childProcessId, filesToBeMapped, clientContext,
-                callbackType, inSandbox);
+                callbackType, inSandbox, params);
     }
 
     /**
      * Spawns a background download process if it hasn't been started. The download process will
      * manage its own lifecyle and can outlive chrome.
      *
      * @param context Context used to obtain the application context.
      * @param commandLine The child process command line argv.
      */
     @SuppressLint("NewApi")
@@ skipping 22 matching lines @@
         context.startService(intent);
     }
 
     private static void startInternal(
             Context context,
             final String[] commandLine,
             int childProcessId,
             FileDescriptorInfo[] filesToBeMapped,
             long clientContext,
             int callbackType,
-            boolean inSandbox) {
+            boolean inSandbox,
+            ChildProcessCreationParams creationParams) {
         try {
             TraceEvent.begin("ChildProcessLauncher.startInternal");
 
             ChildProcessConnection allocatedConnection = null;
+            String packageName = creationParams != null ? creationParams.getPackageName()
+                    : context.getPackageName();
             synchronized (ChildProcessLauncher.class) {
-                if (inSandbox) {
+                if (inSandbox && sSpareSandboxedConnection != null
+                        && sSpareSandboxedConnection.getPackageName().equals(packageName)) {
                     allocatedConnection = sSpareSandboxedConnection;
                     sSpareSandboxedConnection = null;
                 }
             }
             if (allocatedConnection == null) {
                 boolean alwaysInForeground = false;
                 if (callbackType == CALLBACK_FOR_GPU_PROCESS) alwaysInForeground = true;
-                synchronized (PendingSpawnQueue.sPendingSpawnsLock) {
+                PendingSpawnQueue pendingSpawnQueue = getPendingSpawnQueue(
+                        context, packageName, inSandbox);
+                synchronized (pendingSpawnQueue.mPendingSpawnsLock) {
                     allocatedConnection = allocateBoundConnection(
-                            context, commandLine, inSandbox, alwaysInForeground);
+                            context, commandLine, inSandbox, alwaysInForeground, creationParams);
                     if (allocatedConnection == null) {
                         Log.d(TAG, "Allocation of new service failed. Queuing up pending spawn.");
-                        sPendingSpawnQueue.enqueueLocked(new PendingSpawnData(context, commandLine,
+                        pendingSpawnQueue.enqueueLocked(new PendingSpawnData(context, commandLine,
                                 childProcessId, filesToBeMapped, clientContext,
-                                callbackType, inSandbox));
+                                callbackType, inSandbox, creationParams));
                         return;
                     }
                 }
             }
 
             Log.d(TAG, "Setting up connection to process: slot=%d",
                     allocatedConnection.getServiceNumber());
             triggerConnectionSetup(allocatedConnection, commandLine, childProcessId,
                     filesToBeMapped, callbackType, clientContext);
         } finally {
@@ skipping 156 matching lines @@
     }
 
     static void logPidWarning(int pid, String message) {
         // This class is effectively a no-op in single process mode, so don't log warnings there.
         if (pid > 0 && !nativeIsSingleProcess()) {
             Log.w(TAG, "%s, pid=%d", message, pid);
         }
     }
 
     @VisibleForTesting
-    static ChildProcessConnection allocateBoundConnectionForTesting(Context context) {
-        return allocateBoundConnection(context, null, true, false);
+    static ChildProcessConnection allocateBoundConnectionForTesting(Context context,
+            ChildProcessCreationParams creationParams) {
+        return allocateBoundConnection(context, null, true, false, creationParams);
     }
 
     /**
      * Queue up a spawn requests for testing.
      */
     @VisibleForTesting
-    static void enqueuePendingSpawnForTesting(Context context, String[] commandLine) {
-        synchronized (PendingSpawnQueue.sPendingSpawnsLock) {
-            sPendingSpawnQueue.enqueueLocked(new PendingSpawnData(context, commandLine, 1,
-                    new FileDescriptorInfo[0], 0, CALLBACK_FOR_RENDERER_PROCESS, true));
+    static void enqueuePendingSpawnForTesting(Context context, String[] commandLine,
+            ChildProcessCreationParams creationParams, boolean inSandbox) {
+        PendingSpawnQueue pendingSpawnQueue = getPendingSpawnQueue(context,
+                creationParams.getPackageName(), inSandbox);
+        synchronized (pendingSpawnQueue.mPendingSpawnsLock) {
+            pendingSpawnQueue.enqueueLocked(new PendingSpawnData(context, commandLine, 1,
+                    new FileDescriptorInfo[0], 0, CALLBACK_FOR_RENDERER_PROCESS, true,
+                    creationParams));
         }
     }
 
-    /** @return the count of sandboxed connections managed by the allocator */
+    /**
+     * @return the number of sandboxed connections of given {@link packageName} managed by the
+     * allocator.
+     */
     @VisibleForTesting
-    static int allocatedConnectionsCountForTesting(Context context) {
-        initConnectionAllocatorsIfNecessary(context);
-        return sSandboxedChildConnectionAllocator.allocatedConnectionsCountForTesting();
+    static int allocatedSandboxedConnectionsCountForTesting(Context context, String packageName) {
+        initConnectionAllocatorsIfNecessary(context, true, packageName);
+        return sSandboxedChildConnectionAllocatorMap.get(packageName)
+                .allocatedConnectionsCountForTesting();
     }
 
     /** @return the count of services set up and working */
     @VisibleForTesting
     static int connectedServicesCountForTesting() {
         return sServiceMap.size();
     }
 
-    /** @return the count of pending spawns in the queue */
+    /**
+     * @param context The context.
+     * @param packageName The package name of the {@link ChildProcessAlocator}.
+     * @param inSandbox Whether the connection is sandboxed.
+     * @return the count of pending spawns in the queue.
+     */
     @VisibleForTesting
-    static int pendingSpawnsCountForTesting() {
-        synchronized (PendingSpawnQueue.sPendingSpawnsLock) {
-            return sPendingSpawnQueue.sizeLocked();
+    static int pendingSpawnsCountForTesting(Context context, String packageName,
+            boolean inSandbox) {
+        PendingSpawnQueue pendingSpawnQueue = getPendingSpawnQueue(context, packageName, inSandbox);
+        synchronized (pendingSpawnQueue.mPendingSpawnsLock) {
+            return pendingSpawnQueue.sizeLocked();
         }
     }
 
     /**
      * Kills the child process for testing.
      * @return true iff the process was killed as expected
      */
     @VisibleForTesting
     public static boolean crashProcessForTesting(int pid) {
         if (sServiceMap.get(pid) == null) return false;
 
         try {
             ((ChildProcessConnectionImpl) sServiceMap.get(pid)).crashServiceForTesting();
         } catch (RemoteException ex) {
             return false;
         }
 
         return true;
     }
 
     private static native void nativeOnChildProcessStarted(long clientContext, int pid);
     private static native void nativeEstablishSurfacePeer(
             int pid, Surface surface, int primaryID, int secondaryID);
     private static native boolean nativeIsSingleProcess();
 }