Clean-up in ChildProcessLauncher.

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 25 matching lines @@
 /**
  * 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.
  */
 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;
@@ skipping 10 matching lines @@
             for (int i = 0; i < numChildServices; i++) {
                 mFreeConnectionIndices.add(i);
             }
             mChildClassName = serviceClassName;
             mInSandbox = inSandbox;
         }
 
         // Allocate or enqueue. If there are no free slots, return null and enqueue the spawn data.
         public ChildProcessConnection allocate(SpawnData spawnData,
                 ChildProcessConnection.DeathCallback deathCallback,
-                Bundle childProcessCommonParameters, boolean alwaysInForeground) {
-            assert spawnData.inSandbox() == mInSandbox;
+                Bundle childProcessCommonParameters) {
+            assert spawnData.isInSandbox() == mInSandbox;
             synchronized (mConnectionLock) {
                 if (mFreeConnectionIndices.isEmpty()) {
                     Log.d(TAG, "Ran out of services to allocate.");
-                    if (!spawnData.forWarmUp()) {
+                    if (!spawnData.isForWarmUp()) {
                         mPendingSpawnQueue.add(spawnData);
                     }
                     return null;
                 }
                 int slot = mFreeConnectionIndices.remove(0);
                 assert mChildProcessConnections[slot] == null;
                 mChildProcessConnections[slot] =
-                        new ChildProcessConnectionImpl(spawnData.context(), slot, mInSandbox,
+                        new ChildProcessConnectionImpl(spawnData.getContext(), slot, mInSandbox,
                                 deathCallback, mChildClassName, childProcessCommonParameters,
-                                alwaysInForeground, spawnData.getCreationParams());
+                                spawnData.isAlwaysInForeground(), spawnData.getCreationParams());
                 Log.d(TAG, "Allocator allocated a connection, sandbox: %b, slot: %d", mInSandbox,
                         slot);
                 return mChildProcessConnections[slot];
             }
         }
 
         // Also return the first SpawnData in the pending queue, if any.
         public SpawnData free(ChildProcessConnection connection) {
             synchronized (mConnectionLock) {
                 int slot = connection.getServiceNumber();
@@ skipping 46 matching lines @@
         }
     }
 
     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 LaunchCallback mLaunchCallback;
-        private final int mCallbackType;
+        private final IBinder mChildProcessCallback;
         private final boolean mInSandbox;
+        private final boolean mAlwaysInForeground;
         private final ChildProcessCreationParams mCreationParams;
 
         private SpawnData(boolean forWarmUp, Context context, String[] commandLine,
                 int childProcessId, FileDescriptorInfo[] filesToBeMapped,
-                LaunchCallback launchCallback, int callbackType, boolean inSandbox,
-                ChildProcessCreationParams creationParams) {
+                LaunchCallback launchCallback, IBinder childProcessCallback, boolean inSandbox,
+                boolean alwaysInForeground, ChildProcessCreationParams creationParams) {
             mForWarmup = forWarmUp;
             mContext = context;
             mCommandLine = commandLine;
             mChildProcessId = childProcessId;
             mFilesToBeMapped = filesToBeMapped;
             mLaunchCallback = launchCallback;
-            mCallbackType = callbackType;
+            mChildProcessCallback = childProcessCallback;
             mInSandbox = inSandbox;
+            mAlwaysInForeground = alwaysInForeground;
             mCreationParams = creationParams;
         }
 
-        private boolean forWarmUp() {
+        private boolean isForWarmUp() {
             return mForWarmup;
         }
-
-        private Context context() {
+        private Context getContext() {
             return mContext;
         }
-        private String[] commandLine() {
+        private String[] getCommandLine() {
             return mCommandLine;
         }
-        private int childProcessId() {
+        private int getChildProcessId() {
             return mChildProcessId;
         }
-        private FileDescriptorInfo[] filesToBeMapped() {
+        private FileDescriptorInfo[] getFilesToBeMapped() {
             return mFilesToBeMapped;
         }
-        private LaunchCallback launchCallback() {
+        private LaunchCallback getLaunchCallback() {
             return mLaunchCallback;
         }
-        private int callbackType() {
-            return mCallbackType;
+        private IBinder getChildProcessCallback() {
+            return mChildProcessCallback;
         }
-        private boolean inSandbox() {
+        private boolean isInSandbox() {
             return mInSandbox;
         }
+        private boolean isAlwaysInForeground() {
+            return mAlwaysInForeground;
+        }
         private ChildProcessCreationParams getCreationParams() {
             return mCreationParams;
         }
     }
 
     /**
      * Implemented by ChildProcessLauncherHelper.
      */
     public interface LaunchCallback { void onChildProcessStarted(int pid); }
 
     // 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 boolean SPARE_CONNECTION_ALWAYS_IN_FOREGROUND = false;
+
     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";
     private static final String SANDBOXED_SERVICES_NAME_KEY =
             "org.chromium.content.browser.SANDBOXED_SERVICES_NAME";
     // Overrides the number of available sandboxed services.
     @VisibleForTesting
     public static final String SWITCH_NUM_SANDBOXED_SERVICES_FOR_TESTING = "num-sandboxed-services";
     public static final String SWITCH_SANDBOXED_SERVICES_NAME_FOR_TESTING =
@@ skipping 111 matching lines @@
         return sSandboxedChildConnectionAllocatorMap.get(packageName);
     }
 
     private static ChildConnectionAllocator getAllocatorForTesting(
             Context context, String packageName, boolean inSandbox) {
         initConnectionAllocatorsIfNecessary(context, inSandbox, packageName);
         return getConnectionAllocator(packageName, inSandbox);
     }
 
     private static ChildProcessConnection allocateConnection(
-            SpawnData spawnData, Bundle childProcessCommonParams, boolean alwaysInForeground) {
+            SpawnData spawnData, Bundle childProcessCommonParams) {
         ChildProcessConnection.DeathCallback deathCallback =
                 new ChildProcessConnection.DeathCallback() {
                     @Override
                     public void onChildProcessDied(ChildProcessConnection connection) {
                         if (connection.getPid() != 0) {
                             stop(connection.getPid());
                         } else {
                             freeConnection(connection);
                         }
                     }
                 };
         final ChildProcessCreationParams creationParams = spawnData.getCreationParams();
-        final Context context = spawnData.context();
-        final boolean inSandbox = spawnData.inSandbox();
+        final Context context = spawnData.getContext();
+        final boolean inSandbox = spawnData.isInSandbox();
         String packageName =
                 creationParams != null ? creationParams.getPackageName() : context.getPackageName();
         initConnectionAllocatorsIfNecessary(context, inSandbox, packageName);
         return getConnectionAllocator(packageName, inSandbox)
-                .allocate(spawnData, deathCallback, childProcessCommonParams, alwaysInForeground);
+                .allocate(spawnData, deathCallback, childProcessCommonParams);
     }
 
     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(SpawnData spawnData,
-            boolean alwaysInForeground, ChildProcessConnection.StartCallback startCallback) {
-        final Context context = spawnData.context();
-        final boolean inSandbox = spawnData.inSandbox();
+    private static ChildProcessConnection allocateBoundConnection(
+            SpawnData spawnData, ChildProcessConnection.StartCallback startCallback) {
+        final Context context = spawnData.getContext();
+        final boolean inSandbox = spawnData.isInSandbox();
         final ChildProcessCreationParams creationParams = spawnData.getCreationParams();
         Bundle commonParams = new Bundle();
         commonParams.putParcelable(
                 ChildProcessConstants.EXTRA_LINKER_PARAMS, getLinkerParamsForNewConnection());
-        ChildProcessConnection connection =
-                allocateConnection(spawnData, commonParams, alwaysInForeground);
+        ChildProcessConnection connection = allocateConnection(spawnData, commonParams);
         if (connection != null) {
             connection.start(startCallback);
 
             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
@@ skipping 18 matching lines @@
         // variables are set when we don't expect them to).
         final ChildProcessConnection conn = connection;
         ThreadUtils.postOnUiThreadDelayed(new Runnable() {
             @Override
             public void run() {
                 final SpawnData pendingSpawn = freeConnectionAndDequeuePending(conn);
                 if (pendingSpawn != null) {
                     LauncherThread.post(new Runnable() {
                         @Override
                         public void run() {
-                            startInternal(pendingSpawn.context(), pendingSpawn.commandLine(),
-                                    pendingSpawn.childProcessId(), pendingSpawn.filesToBeMapped(),
-                                    pendingSpawn.launchCallback(), pendingSpawn.callbackType(),
-                                    pendingSpawn.inSandbox(), pendingSpawn.getCreationParams());
+                            startInternal(pendingSpawn.getContext(), pendingSpawn.getCommandLine(),
+                                    pendingSpawn.getChildProcessId(),
+                                    pendingSpawn.getFilesToBeMapped(),
+                                    pendingSpawn.getLaunchCallback(),
+                                    pendingSpawn.getChildProcessCallback(),
+                                    pendingSpawn.isInSandbox(), pendingSpawn.isAlwaysInForeground(),
+                                    pendingSpawn.getCreationParams());
                         }
                     });
                 }
             }
         }, FREE_CONNECTION_DELAY_MILLIS);
     }
 
     private static SpawnData freeConnectionAndDequeuePending(ChildProcessConnection conn) {
         ChildConnectionAllocator allocator = getConnectionAllocator(
                 conn.getPackageName(), conn.isInSandbox());
@@ skipping 110 matching lines @@
                                 synchronized (sSpareConnectionLock) {
                                     sSpareSandboxedConnection = null;
                                     sSpareConnectionStarting = false;
                                     sSpareConnectionLock.notify();
                                 }
                             }
                         };
                 SpawnData spawnData = new SpawnData(true /* forWarmUp*/, context,
                         null /* commandLine */, -1 /* child process id */,
                         null /* filesToBeMapped */, null /* launchCallback */,
-                        CALLBACK_FOR_RENDERER_PROCESS, true /* inSandbox */, params);
-                sSpareSandboxedConnection = allocateBoundConnection(
-                        spawnData, false /* alwaysInForeground */, startCallback);
+                        null /* child process callback */, true /* inSandbox */,
+                        SPARE_CONNECTION_ALWAYS_IN_FOREGROUND, params);
+                sSpareSandboxedConnection = allocateBoundConnection(spawnData, startCallback);
             }
         }
     }
 
     /**
      * Spawns and connects to a child process. May be called on any thread. It will not block, but
      * will instead callback to {@link #nativeOnChildProcessStarted} when the connection is
      * established. Note this callback will not necessarily be from the same thread (currently it
      * always comes from the main thread).
      *
      * @param context Context used to obtain the application context.
      * @param paramId Key used to retrieve ChildProcessCreationParams.
      * @param commandLine The child process command line argv.
      * @param filesToBeMapped File IDs, FDs, offsets, and lengths to pass through.
      */
     // TODO(boliu): All tests should use this over startForTesting.
     static void start(Context context, int paramId, final String[] commandLine, int childProcessId,
             FileDescriptorInfo[] filesToBeMapped, LaunchCallback launchCallback) {
-        int callbackType = CALLBACK_FOR_UNKNOWN_PROCESS;
+        IBinder childProcessCallback = null;
         boolean inSandbox = true;
+        boolean alwaysInForeground = false;
         String processType =
                 ContentSwitches.getSwitchValue(commandLine, ContentSwitches.SWITCH_PROCESS_TYPE);
         ChildProcessCreationParams params = ChildProcessCreationParams.get(paramId);
         if (paramId != ChildProcessCreationParams.DEFAULT_ID && params == null) {
             throw new RuntimeException("CreationParams id " + paramId + " not found");
         }
-        if (ContentSwitches.SWITCH_RENDERER_PROCESS.equals(processType)) {
-            callbackType = CALLBACK_FOR_RENDERER_PROCESS;
-        } else {
+        if (!ContentSwitches.SWITCH_RENDERER_PROCESS.equals(processType)) {
             if (params != null && !params.getPackageName().equals(context.getPackageName())) {
                 // WebViews and WebAPKs have renderer processes running in their applications.
                 // When launching these renderer processes, {@link ChildProcessConnectionImpl}
                 // requires the package name of the application which holds the renderer process.
                 // Therefore, the package name in ChildProcessCreationParams could be the package
                 // name of WebViews, WebAPKs, or Chrome, depending on the host application.
                 // Except renderer process, all other child processes should use Chrome's package
                 // name. In WebAPK, ChildProcessCreationParams are initialized with WebAPK's
                 // package name. Make a copy of the WebAPK's params, but replace the package with
                 // Chrome's package to use when initializing a non-renderer processes.
                 // TODO(boliu): Should fold into |paramId|. Investigate why this is needed.
                 params = new ChildProcessCreationParams(context.getPackageName(),
                         params.getIsExternalService(), params.getLibraryProcessType());
             }
             if (ContentSwitches.SWITCH_GPU_PROCESS.equals(processType)) {
-                callbackType = CALLBACK_FOR_GPU_PROCESS;
+                childProcessCallback = new GpuProcessCallback();
                 inSandbox = false;
-            } else if (ContentSwitches.SWITCH_UTILITY_PROCESS.equals(processType)) {
-                // We only support sandboxed right now.
-                callbackType = CALLBACK_FOR_UTILITY_PROCESS;
+                alwaysInForeground = true;
             } else {
-                assert false;
+                // We only support sandboxed utility processes now.
+                assert ContentSwitches.SWITCH_UTILITY_PROCESS.equals(processType);
             }
         }
 
         startInternal(context, commandLine, childProcessId, filesToBeMapped, launchCallback,
-                callbackType, inSandbox, params);
+                childProcessCallback, inSandbox, alwaysInForeground, params);
     }
 
     private static ChildProcessConnection startInternal(final Context context,
             final String[] commandLine, final int childProcessId,
             final FileDescriptorInfo[] filesToBeMapped, final LaunchCallback launchCallback,
-            final int callbackType, final boolean inSandbox,
-            final ChildProcessCreationParams creationParams) {
+            final IBinder childProcessCallback, final boolean inSandbox,
+            final boolean alwaysInForeground, final ChildProcessCreationParams creationParams) {
         try {
             TraceEvent.begin("ChildProcessLauncher.startInternal");
 
             ChildProcessConnection allocatedConnection = null;
             String packageName = creationParams != null ? creationParams.getPackageName()
                     : context.getPackageName();
             synchronized (sSpareConnectionLock) {
                 if (inSandbox && sSpareSandboxedConnection != null
+                        && SPARE_CONNECTION_ALWAYS_IN_FOREGROUND == alwaysInForeground
                         && sSpareSandboxedConnection.getPackageName().equals(packageName)
                         // Object identity check for getDefault should be enough. The default is
                         // not supposed to change once set.
                         && creationParams == ChildProcessCreationParams.getDefault()) {
                     while (sSpareConnectionStarting) {
                         try {
                             sSpareConnectionLock.wait();
                         } catch (InterruptedException ex) {
                         }
                     }
                     allocatedConnection = sSpareSandboxedConnection;
                     sSpareSandboxedConnection = null;
                 }
             }
             if (allocatedConnection == null) {
-                boolean alwaysInForeground = false;
-                if (callbackType == CALLBACK_FOR_GPU_PROCESS) alwaysInForeground = true;
                 ChildProcessConnection.StartCallback startCallback =
                         new ChildProcessConnection.StartCallback() {
                             @Override
                             public void onChildStarted() {}
 
                             @Override
                             public void onChildStartFailed() {
                                 Log.e(TAG, "ChildProcessConnection.start failed, trying again");
                                 LauncherThread.post(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, launchCallback, callbackType,
-                                                inSandbox, creationParams);
+                                                filesToBeMapped, launchCallback,
+                                                childProcessCallback, inSandbox, alwaysInForeground,
+                                                creationParams);
                                     }
                                 });
                             }
                         };
 
                 SpawnData spawnData = new SpawnData(false /* forWarmUp */, context, commandLine,
-                        childProcessId, filesToBeMapped, launchCallback, callbackType, inSandbox,
-                        creationParams);
-                allocatedConnection =
-                        allocateBoundConnection(spawnData, alwaysInForeground, startCallback);
+                        childProcessId, filesToBeMapped, launchCallback, childProcessCallback,
+                        inSandbox, alwaysInForeground, creationParams);
+                allocatedConnection = allocateBoundConnection(spawnData, startCallback);
                 if (allocatedConnection == null) {
                     return null;
                 }
             }
 
             Log.d(TAG, "Setting up connection to process: slot=%d",
                     allocatedConnection.getServiceNumber());
             triggerConnectionSetup(allocatedConnection, commandLine, childProcessId,
-                    filesToBeMapped, callbackType, launchCallback);
+                    filesToBeMapped, childProcessCallback, launchCallback);
             return allocatedConnection;
         } finally {
             TraceEvent.end("ChildProcessLauncher.startInternal");
         }
     }
 
     /**
      * Create the common bundle to be passed to child processes.
      * @param context Application context.
      * @param commandLine Command line params to be passed to the service.
      * @param linkerParams Linker params to start the service.
      */
     protected static Bundle createsServiceBundle(
             String[] commandLine, FileDescriptorInfo[] filesToBeMapped) {
         Bundle bundle = new Bundle();
         bundle.putStringArray(ChildProcessConstants.EXTRA_COMMAND_LINE, commandLine);
         bundle.putParcelableArray(ChildProcessConstants.EXTRA_FILES, filesToBeMapped);
         bundle.putInt(ChildProcessConstants.EXTRA_CPU_COUNT, CpuFeatures.getCount());
         bundle.putLong(ChildProcessConstants.EXTRA_CPU_FEATURES, CpuFeatures.getMask());
         bundle.putBundle(Linker.EXTRA_LINKER_SHARED_RELROS, Linker.getInstance().getSharedRelros());
         return bundle;
     }
 
     @VisibleForTesting
     static void triggerConnectionSetup(final ChildProcessConnection connection,
             String[] commandLine, int childProcessId, FileDescriptorInfo[] filesToBeMapped,
-            final int callbackType, final LaunchCallback launchCallback) {
+            final IBinder childProcessCallback, final LaunchCallback launchCallback) {
         ChildProcessConnection.ConnectionCallback connectionCallback =
                 new ChildProcessConnection.ConnectionCallback() {
                     @Override
                     public void onConnected(int pid) {
-                        Log.d(TAG, "on connect callback, pid=%d callbackType=%d", pid,
-                                callbackType);
+                        Log.d(TAG, "on connect callback, pid=%d", pid);
                         if (pid != NULL_PROCESS_HANDLE) {
                             sBindingManager.addNewConnection(pid, connection);
                             sServiceMap.put(pid, connection);
                         }
                         // If the connection fails and pid == 0, the Java-side cleanup was already
                         // handled by DeathCallback. We still have to call back to native for
                         // cleanup there.
                         if (launchCallback != null) { // Will be null in Java instrumentation tests.
                             launchCallback.onChildProcessStarted(pid);
                         }
                     }
                 };
 
-        assert callbackType != CALLBACK_FOR_UNKNOWN_PROCESS;
-        connection.setupConnection(commandLine, filesToBeMapped,
-                createCallback(childProcessId, callbackType), connectionCallback);
+        connection.setupConnection(
+                commandLine, filesToBeMapped, childProcessCallback, connectionCallback);
     }
 
     /**
      * Terminates a child process. This may be called from any thread.
      *
      * @param pid The pid (process handle) of the service connection obtained from {@link #start}.
      */
     static void stop(int pid) {
         Log.d(TAG, "stopping child connection: pid=%d", pid);
         ChildProcessConnection connection = sServiceMap.remove(pid);
         if (connection == null) {
             // Can happen for single process.
             return;
         }
         sBindingManager.clearConnection(pid);
         connection.stop();
         freeConnection(connection);
     }
 
-    /**
-     * This implementation is used to receive callbacks from the remote service.
-     */
-    private static IBinder createCallback(int childProcessId, int callbackType) {
-        return callbackType == CALLBACK_FOR_GPU_PROCESS ? new GpuProcessCallback() : null;
-    }
-
     @VisibleForTesting
     public static ChildProcessConnection startForTesting(Context context, String[] commandLine,
             FileDescriptorInfo[] filesToMap, ChildProcessCreationParams params) {
-        return startInternal(context, commandLine, 0, filesToMap, null,
-                CALLBACK_FOR_RENDERER_PROCESS, true, params);
+        return startInternal(context, commandLine, 0 /* childProcessId */, filesToMap,
+                null /* launchCallback */, null /* childProcessCallback */, true /* inSandbox */,
+                false /* alwaysInForeground */, params);
     }
 
     @VisibleForTesting
     static ChildProcessConnection allocateBoundConnectionForTesting(Context context,
             ChildProcessCreationParams creationParams) {
         return allocateBoundConnection(
                 new SpawnData(false /* forWarmUp */, context, null /* commandLine */,
                         0 /* childProcessId */, null /* filesToBeMapped */,
-                        null /* LaunchCallback */, CALLBACK_FOR_RENDERER_PROCESS,
-                        true /* inSandbox */, creationParams),
-                false /* alwaysInForeground */, null);
+                        null /* LaunchCallback */, null /* childProcessCallback */,
+                        true /* inSandbox */, false /* alwaysInForeground */, creationParams),
+                null /* startCallback */);
     }
 
     @VisibleForTesting
     static ChildProcessConnection allocateConnectionForTesting(Context context,
             ChildProcessCreationParams creationParams) {
         Bundle commonParams = new Bundle();
         commonParams.putParcelable(
                 ChildProcessConstants.EXTRA_LINKER_PARAMS, getLinkerParamsForNewConnection());
         return allocateConnection(
                 new SpawnData(false /* forWarmUp */, context, null /* commandLine */,
                         0 /* childProcessId */, null /* filesToBeMapped */,
-                        null /* LaunchCallback */, CALLBACK_FOR_RENDERER_PROCESS,
-                        true /* inSandbox */, creationParams),
-                commonParams, false);
+                        null /* launchCallback */, null /* childProcessCallback */,
+                        true /* inSandbox */, false /* alwaysInForeground */, creationParams),
+                commonParams);
     }
 
     /**
      * 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();
         ChildConnectionAllocator allocator =
                 getAllocatorForTesting(context, packageName, inSandbox);
         allocator.enqueuePendingQueueForTesting(new SpawnData(false /* forWarmUp*/, context,
-                commandLine, 1, new FileDescriptorInfo[0], null, CALLBACK_FOR_RENDERER_PROCESS,
-                true, creationParams));
+                commandLine, 1 /* childProcessId */, new FileDescriptorInfo[0],
+                null /* launchCallback */, null /* childProcessCallback */, true /* inSandbox */,
+                false /* alwaysInForeground */, 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)
@@ skipping 38 matching lines @@
 
         try {
             ((ChildProcessConnectionImpl) sServiceMap.get(pid)).crashServiceForTesting();
         } catch (RemoteException ex) {
             return false;
         }
 
         return true;
     }
 }