android: Move PendingSpawnQueue into ChildConnectionAllocator

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.ComponentName;
 import android.content.Context;
 import android.content.pm.ApplicationInfo;
 import android.content.pm.PackageManager;
@@ skipping 24 matching lines @@
 
 import java.io.IOException;
 import java.util.ArrayList;
 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.
+ *
+ * Note about threading. The threading here is complicated and not well documented.
+ * Code can run on these threads: UI, Launcher, async thread pool, binder, and one-off
+ * background threads.
  */
 @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;
 
     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 final String mChildClassName;
         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();
+        private final Queue<SpawnData> mPendingSpawnQueue = new LinkedList<>();

[Maria, 2017/02/14 00:59:41]

Should this comment also mention that this uses mConnectionLock to synchronize?

[boliu, 2017/02/14 01:34:20]

Done.

 
         public ChildConnectionAllocator(boolean inSandbox, int numChildServices,
                 String serviceClassName) {
             mChildProcessConnections = new ChildProcessConnectionImpl[numChildServices];
             mFreeConnectionIndices = new ArrayList<Integer>(numChildServices);
             for (int i = 0; i < numChildServices; i++) {
                 mFreeConnectionIndices.add(i);
             }
             mChildClassName = serviceClassName;
             mInSandbox = inSandbox;
         }
 
-        public ChildProcessConnection allocate(
-                Context context, ChildProcessConnection.DeathCallback deathCallback,
-                ChromiumLinkerParams chromiumLinkerParams,
-                boolean alwaysInForeground,
-                ChildProcessCreationParams creationParams) {
+        // Allocate or enqueue. If there are no free slots, return null and enqueue the spawn data.
+        public ChildProcessConnection allocate(SpawnData spawnData,
+                ChildProcessConnection.DeathCallback deathCallback,
+                ChromiumLinkerParams chromiumLinkerParams, boolean alwaysInForeground) {
+            assert spawnData.inSandbox() == mInSandbox;
             synchronized (mConnectionLock) {
                 if (mFreeConnectionIndices.isEmpty()) {
                     Log.d(TAG, "Ran out of services to allocate.");
+                    if (!spawnData.forWarmUp()) {
+                        mPendingSpawnQueue.add(spawnData);
+                    }
                     return null;
                 }
                 int slot = mFreeConnectionIndices.remove(0);
                 assert mChildProcessConnections[slot] == null;
-                mChildProcessConnections[slot] = new ChildProcessConnectionImpl(context, slot,
-                        mInSandbox, deathCallback, mChildClassName, chromiumLinkerParams,
-                        alwaysInForeground, creationParams);
+                mChildProcessConnections[slot] = new ChildProcessConnectionImpl(spawnData.context(),
+                        slot, mInSandbox, deathCallback, mChildClassName, chromiumLinkerParams,
+                        alwaysInForeground, spawnData.getCreationParams());
                 Log.d(TAG, "Allocator allocated a connection, sandbox: %b, slot: %d", mInSandbox,
                         slot);
                 return mChildProcessConnections[slot];
             }
         }
 
-        public void free(ChildProcessConnection connection) {
+        // Also return the first SpawnData in the pending queue, if any.
+        public SpawnData free(ChildProcessConnection connection) {
             synchronized (mConnectionLock) {
                 int slot = connection.getServiceNumber();
                 if (mChildProcessConnections[slot] != connection) {
                     int occupier = mChildProcessConnections[slot] == null
                             ? -1 : mChildProcessConnections[slot].getServiceNumber();
                     Log.e(TAG, "Unable to find connection to free in slot: %d "
                             + "already occupied by service: %d", slot, occupier);
                     assert false;
                 } else {
                     mChildProcessConnections[slot] = null;
                     assert !mFreeConnectionIndices.contains(slot);
                     mFreeConnectionIndices.add(slot);
                     Log.d(TAG, "Allocator freed a connection, sandbox: %b, slot: %d", mInSandbox,
                             slot);
                 }
+                return mPendingSpawnQueue.poll();
             }
         }
 
         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();
         }
 
         @VisibleForTesting
         ChildProcessConnection[] connectionArrayForTesting() {
             return mChildProcessConnections;
         }
+
+        @VisibleForTesting
+        void enqueuePendingQueueForTesting(SpawnData spawnData) {
+            synchronized (mConnectionLock) {
+                mPendingSpawnQueue.add(spawnData);
+            }
+        }
+
+        @VisibleForTesting
+        int pendingSpawnsCountForTesting() {
+            synchronized (mConnectionLock) {
+                return mPendingSpawnQueue.size();
+            }
+        }
     }
 
-    private static class PendingSpawnData {
+    private static class SpawnData {
+        private final boolean mForWarmup; // Do not queue up if failed.
         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,
-                ChildProcessCreationParams creationParams) {
+        private SpawnData(boolean forWarmUp, Context context, String[] commandLine,
+                int childProcessId, FileDescriptorInfo[] filesToBeMapped, long clientContext,
+                int callbackType, boolean inSandbox, ChildProcessCreationParams creationParams) {
+            mForWarmup = forWarmUp;
             mContext = context;
             mCommandLine = commandLine;
             mChildProcessId = childProcessId;
             mFilesToBeMapped = filesToBeMapped;
             mClientContext = clientContext;
             mCallbackType = callbackType;
             mInSandbox = inSandbox;
             mCreationParams = creationParams;
         }
 
+        private boolean forWarmUp() {
+            return mForWarmup;
+        }
+
         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 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(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(mPendingSpawnsLock);
-            return mPendingSpawns.poll();
-        }
-
-        /** @return the count of pending spawns in the queue */
-        public int sizeLocked() {
-            assert Thread.holdsLock(mPendingSpawnsLock);
-            return mPendingSpawns.size();
-        }
-    }
-
     // 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";
@@ skipping 110 matching lines @@
      * 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) {
+    private static ChildConnectionAllocator getAllocatorForTesting(
+            Context context, String packageName, boolean inSandbox) {
         initConnectionAllocatorsIfNecessary(context, inSandbox, packageName);
-        return getConnectionAllocator(packageName, inSandbox).getPendingSpawnQueue();
+        return getConnectionAllocator(packageName, inSandbox);
     }
 
-    private static ChildProcessConnection allocateConnection(Context context, boolean inSandbox,
-            ChromiumLinkerParams chromiumLinkerParams, boolean alwaysInForeground,
-            ChildProcessCreationParams creationParams) {
+    private static ChildProcessConnection allocateConnection(SpawnData spawnData,
+            ChromiumLinkerParams chromiumLinkerParams, boolean alwaysInForeground) {
         ChildProcessConnection.DeathCallback deathCallback =
                 new ChildProcessConnection.DeathCallback() {
                     @Override
                     public void onChildProcessDied(ChildProcessConnection connection) {
                         if (connection.getPid() != 0) {
                             stop(connection.getPid());
                         } else {
                             freeConnection(connection);
                         }
                     }
                 };
-        String packageName = creationParams != null ? creationParams.getPackageName()
-                : context.getPackageName();
+        final ChildProcessCreationParams creationParams = spawnData.getCreationParams();
+        final Context context = spawnData.context();
+        final boolean inSandbox = spawnData.inSandbox();
+        String packageName =
+                creationParams != null ? creationParams.getPackageName() : context.getPackageName();
         initConnectionAllocatorsIfNecessary(context, inSandbox, packageName);
         return getConnectionAllocator(packageName, inSandbox)
-                .allocate(context, deathCallback, chromiumLinkerParams, alwaysInForeground,
-                        creationParams);
+                .allocate(spawnData, deathCallback, chromiumLinkerParams, alwaysInForeground);
     }
 
     private static boolean sLinkerInitialized;
     private static long sLinkerLoadAddress;
 
     private static ChromiumLinkerParams getLinkerParamsForNewConnection() {
         if (!sLinkerInitialized) {
             if (Linker.isUsed()) {
                 sLinkerLoadAddress = Linker.getInstance().getBaseLoadAddress();
                 if (sLinkerLoadAddress == 0) {
@@ skipping 12 matching lines @@
             return new ChromiumLinkerParams(sLinkerLoadAddress,
                                             waitForSharedRelros,
                                             linker.getTestRunnerClassNameForTesting(),
                                             linker.getImplementationForTesting());
         } else {
             return new ChromiumLinkerParams(sLinkerLoadAddress,
                                             waitForSharedRelros);
         }
     }
 
-    private static ChildProcessConnection allocateBoundConnection(Context context,
-            String[] commandLine, boolean inSandbox, boolean alwaysInForeground,
-            ChildProcessCreationParams creationParams,
-            ChildProcessConnection.StartCallback startCallback) {
+    private static ChildProcessConnection allocateBoundConnection(SpawnData spawnData,
+            boolean alwaysInForeground, ChildProcessConnection.StartCallback startCallback) {
+        final Context context = spawnData.context();
+        final String[] commandLine = spawnData.commandLine();
+        final boolean inSandbox = spawnData.inSandbox();
+        final ChildProcessCreationParams creationParams = spawnData.getCreationParams();
         ChromiumLinkerParams chromiumLinkerParams = getLinkerParamsForNewConnection();
-        ChildProcessConnection connection = allocateConnection(
-                context, inSandbox, chromiumLinkerParams, alwaysInForeground, creationParams);
+        ChildProcessConnection connection =
+                allocateConnection(spawnData, chromiumLinkerParams, alwaysInForeground);
         if (connection != null) {
             connection.start(commandLine, startCallback);
 
             String packageName = creationParams != null ? creationParams.getPackageName()
-                    : context.getPackageName();
-            if (inSandbox && !getConnectionAllocator(packageName, inSandbox)
-                    .isFreeConnectionAvailable()) {
+                                                        : 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;
 
     private static void freeConnection(ChildProcessConnection connection) {
         synchronized (sSpareConnectionLock) {
             if (connection.equals(sSpareSandboxedConnection)) sSpareSandboxedConnection = null;
         }
 
         // Freeing a service should be delayed. This is so that we avoid immediately reusing the
         // freed service (see http://crbug.com/164069): the framework might keep a service process
         // alive when it's been unbound for a short time. If a new connection to the same service
         // is bound at that point, the process is reused and bad things happen (mostly static
         // variables are set when we don't expect them to).
         final ChildProcessConnection conn = connection;
         ThreadUtils.postOnUiThreadDelayed(new Runnable() {
             @Override
             public void run() {
-                final PendingSpawnData pendingSpawn = freeConnectionAndDequeuePending(conn);
+                final SpawnData 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.getCreationParams());
                         }
                     }).start();
                 }
             }
         }, FREE_CONNECTION_DELAY_MILLIS);
     }
 
-    private static PendingSpawnData freeConnectionAndDequeuePending(ChildProcessConnection conn) {
+    private static SpawnData freeConnectionAndDequeuePending(ChildProcessConnection conn) {
         ChildConnectionAllocator allocator = getConnectionAllocator(
                 conn.getPackageName(), conn.isInSandbox());
         assert allocator != null;
-        PendingSpawnQueue pendingSpawnQueue = allocator.getPendingSpawnQueue();
-        synchronized (pendingSpawnQueue.mPendingSpawnsLock) {
-            allocator.free(conn);
-            return pendingSpawnQueue.dequeueLocked();
-        }
+        return allocator.free(conn);
     }
 
     // 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>();
 
     // Lock and monitor for these members {{{
@@ skipping 111 matching lines @@
                             @Override
                             public void onChildStartFailed() {
                                 Log.e(TAG, "Failed to warm up the spare sandbox service");
                                 synchronized (sSpareConnectionLock) {
                                     sSpareSandboxedConnection = null;
                                     sSpareConnectionStarting = false;
                                     sSpareConnectionLock.notify();
                                 }
                             }
                         };
-                sSpareSandboxedConnection = allocateBoundConnection(context, null, true, false,
-                        params, startCallback);
+                SpawnData spawnData = new SpawnData(true /* forWarmUp*/, context,
+                        null /* commandLine */, -1 /* child process id */,
+                        null /* filesToBeMapped */, 0 /* clientContext */,
+                        CALLBACK_FOR_RENDERER_PROCESS, true /* inSandbox */, params);

[Maria, 2017/02/14 00:59:41]

these new calls with a bunch of comments make me think we should consider
builder pattern. Not for this CL, but maybe later?

[boliu, 2017/02/14 01:34:20]

Hmm.. If we want to force caller to make a decision instead of taking default,
then builder doesn't help. Don't really know if that's important or not though.

Anyway, aesthetics is pretty low on my list of things to fix :p

+                sSpareSandboxedConnection = allocateBoundConnection(
+                        spawnData, false /* alwaysInForeground */, startCallback);
             }
         }
     }
 
     @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 88 matching lines @@
                         } catch (InterruptedException ex) {
                         }
                     }
                     allocatedConnection = sSpareSandboxedConnection;
                     sSpareSandboxedConnection = null;
                 }
             }
             if (allocatedConnection == null) {
                 boolean alwaysInForeground = false;
                 if (callbackType == CALLBACK_FOR_GPU_PROCESS) alwaysInForeground = true;
-                PendingSpawnQueue pendingSpawnQueue = getPendingSpawnQueue(
-                        context, packageName, inSandbox);
                 ChildProcessConnection.StartCallback startCallback =
                         new ChildProcessConnection.StartCallback() {
                             @Override
                             public void onChildStarted() {}
 
                             @Override
                             public void onChildStartFailed() {
                                 Log.e(TAG, "ChildProcessConnection.start failed, trying again");
                                 AsyncTask.THREAD_POOL_EXECUTOR.execute(new Runnable() {
                                     @Override
                                     public void run() {
                                         // The child process may already be bound to another client
                                         // (this can happen if multi-process WebView is used in more
                                         // than one process), so try starting the process again.
                                         // This connection that failed to start has not been freed,
                                         // so a new bound connection will be allocated.
                                         startInternal(context, commandLine, childProcessId,
                                                 filesToBeMapped, clientContext, callbackType,
                                                 inSandbox, creationParams);
                                     }
                                 });
                             }
                         };
-                synchronized (pendingSpawnQueue.mPendingSpawnsLock) {
-                    allocatedConnection = allocateBoundConnection(
-                            context, commandLine, inSandbox, alwaysInForeground, creationParams,
-                            startCallback);
-                    if (allocatedConnection == null) {
-                        Log.d(TAG, "Allocation of new service failed. Queuing up pending spawn.");
-                        pendingSpawnQueue.enqueueLocked(new PendingSpawnData(context, commandLine,
-                                childProcessId, filesToBeMapped, clientContext,
-                                callbackType, inSandbox, creationParams));
-                        return null;
-                    }
+
+                SpawnData spawnData = new SpawnData(false /* forWarmUp */, context, commandLine,
+                        childProcessId, filesToBeMapped, clientContext, callbackType, inSandbox,
+                        creationParams);
+                allocatedConnection =
+                        allocateBoundConnection(spawnData, alwaysInForeground, startCallback);
+                if (allocatedConnection == null) {
+                    return null;
                 }
             }
 
             Log.d(TAG, "Setting up connection to process: slot=%d",
                     allocatedConnection.getServiceNumber());
             triggerConnectionSetup(allocatedConnection, commandLine, childProcessId,
                     filesToBeMapped, callbackType, clientContext);
             return allocatedConnection;
         } finally {
             TraceEvent.end("ChildProcessLauncher.startInternal");
@@ skipping 115 matching lines @@
     @VisibleForTesting
     public static ChildProcessConnection startForTesting(Context context, String[] commandLine,
             FileDescriptorInfo[] filesToMap, ChildProcessCreationParams params) {
         return startInternal(context, commandLine, 0, filesToMap, 0,
                 CALLBACK_FOR_RENDERER_PROCESS, true, params);
     }
 
     @VisibleForTesting
     static ChildProcessConnection allocateBoundConnectionForTesting(Context context,
             ChildProcessCreationParams creationParams) {
-        return allocateBoundConnection(context, null, true, false, creationParams, null);
+        return allocateBoundConnection(
+                new SpawnData(false /* forWarmUp */, context, null /* commandLine */,
+                        0 /* childProcessId */, null /* filesToBeMapped */, 0 /* clientContext */,
+                        CALLBACK_FOR_RENDERER_PROCESS, true /* inSandbox */, creationParams),
+                false /* alwaysInForeground */, null);
     }
 
     @VisibleForTesting
     static ChildProcessConnection allocateConnectionForTesting(Context context,
             ChildProcessCreationParams creationParams) {
         return allocateConnection(
-                context, true, getLinkerParamsForNewConnection(), false, creationParams);
+                new SpawnData(false /* forWarmUp */, context, null /* commandLine */,
+                        0 /* childProcessId */, null /* filesToBeMapped */, 0 /* clientContext */,
+                        CALLBACK_FOR_RENDERER_PROCESS, true /* inSandbox */, creationParams),
+                getLinkerParamsForNewConnection(), false);
     }
 
     /**
      * Queue up a spawn requests for testing.
      */
     @VisibleForTesting
     static void enqueuePendingSpawnForTesting(Context context, String[] commandLine,
             ChildProcessCreationParams creationParams, boolean inSandbox) {
         String packageName = creationParams != null ? creationParams.getPackageName()
                 : context.getPackageName();
-        PendingSpawnQueue pendingSpawnQueue = getPendingSpawnQueue(context,
-                packageName, inSandbox);
-        synchronized (pendingSpawnQueue.mPendingSpawnsLock) {
-            pendingSpawnQueue.enqueueLocked(new PendingSpawnData(context, commandLine, 1,
-                    new FileDescriptorInfo[0], 0, CALLBACK_FOR_RENDERER_PROCESS, true,
-                    creationParams));
-        }
+        ChildConnectionAllocator allocator =
+                getAllocatorForTesting(context, packageName, inSandbox);
+        allocator.enqueuePendingQueueForTesting(new SpawnData(false /* forWarmUp*/, context,
+                commandLine, 1, new FileDescriptorInfo[0], 0, CALLBACK_FOR_RENDERER_PROCESS, true,
+                creationParams));
     }
 
     /**
      * @return the number of sandboxed connections of given {@link packageName} managed by the
      * allocator.
      */
     @VisibleForTesting
     static int allocatedSandboxedConnectionsCountForTesting(Context context, String packageName) {
         initConnectionAllocatorsIfNecessary(context, true, packageName);
         return sSandboxedChildConnectionAllocatorMap.get(packageName)
                 .allocatedConnectionsCountForTesting();
     }
 
     /**
      * @return gets the service connection array for a specific package name.
      */
     @VisibleForTesting
-    static ChildProcessConnection[] getSandboxedConnectionArrayForTesting(
-            String packageName) {
+    static ChildProcessConnection[] getSandboxedConnectionArrayForTesting(String packageName) {
         return sSandboxedChildConnectionAllocatorMap.get(packageName).connectionArrayForTesting();
     }
 
     /** @return the count of services set up and working */
     @VisibleForTesting
     static int connectedServicesCountForTesting() {
         return sServiceMap.size();
     }
 
     /**
      * @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(Context context, String packageName,
-            boolean inSandbox) {
-        PendingSpawnQueue pendingSpawnQueue = getPendingSpawnQueue(context, packageName, inSandbox);
-        synchronized (pendingSpawnQueue.mPendingSpawnsLock) {
-            return pendingSpawnQueue.sizeLocked();
-        }
+    static int pendingSpawnsCountForTesting(
+            Context context, String packageName, boolean inSandbox) {
+        ChildConnectionAllocator allocator =
+                getAllocatorForTesting(context, packageName, inSandbox);
+        return allocator.pendingSpawnsCountForTesting();
     }
 
     /**
      * 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 nativeCompleteScopedSurfaceRequest(
             UnguessableToken requestToken, Surface surface);
     private static native boolean nativeIsSingleProcess();
     private static native Surface nativeGetViewSurface(int surfaceId);
 }