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 49 matching lines @@
         // 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 a 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 final PendingSpawnQueue mPendingSpawnQueue = new PendingSpawnQueue();
 
         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 =
-                new LinkedList<PendingSpawnData>();
-        static final Object sPendingSpawnsLock = new Object();
+        private Queue<PendingSpawnData> mPendingSpawns = new LinkedList<PendingSpawnData>();
+        final Object mPendingSpawnsLock = new Object();
 
         /**
          * 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.
+    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) {
         synchronized (ChildProcessLauncher.class) {

[Maria, 2016/06/08 18:25:08]

Please add a TODO with my name here to move to using an object to lock the
access. It came up yesterday in our discussion and I know it's already this way,
but it should probably be changed in the future.

[Xi Han, 2016/06/08 18:42:10]

Done.

-            if (sSandboxedChildConnectionAllocator == null) {
-                sSandboxedChildConnectionAllocator =
-                        new ChildConnectionAllocator(true, getNumberOfServices(context, true));
+            if (inSandbox) {
+                if (sSandboxedChildConnectionAllocatorMap == null) {
+                    sSandboxedChildConnectionAllocatorMap =
+                            new ConcurrentHashMap<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;
         }
 
         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();
 }