Moving some CPL logic to CPLH.

content/public/android/javatests/src/org/chromium/content/browser/ChildProcessLauncherTest.java

 // Copyright 2014 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.Intent;
 import android.content.ServiceConnection;
+import android.os.Bundle;
 import android.os.Handler;
 import android.os.IBinder;
 import android.os.Looper;
 import android.os.Message;
 import android.os.Messenger;
 import android.os.RemoteException;
 import android.support.test.InstrumentationRegistry;
 import android.support.test.filters.MediumTest;
 
 import org.junit.Assert;
@@ skipping 376 matching lines @@
         Assert.assertNotNull(replyHandler.mMessage);
         Assert.assertEquals(ChildProcessLauncherTestHelperService.MSG_BIND_SERVICE_REPLY,
                 replyHandler.mMessage.what);
         Assert.assertEquals(
                 "Connection slot from helper service is not 0", 0, replyHandler.mMessage.arg2);
 
         final int helperConnPid = replyHandler.mMessage.arg1;
         Assert.assertTrue(helperConnPid > 0);
 
         // Launch a service from this process. Since slot 0 is already bound by the Helper, it
-        // will fail to start and the ChildProcessLauncher will retry.
+        // will fail to start and the ChildProcessLauncher will retry and use the slot 1.
         final ChildProcessCreationParams creationParams = new ChildProcessCreationParams(
                 context.getPackageName(), false /* isExternalService */,
                 LibraryProcessType.PROCESS_CHILD, true /* bindToCallerCheck */);
-        final ChildProcessConnection conn = ChildProcessLauncherTestUtils.startInternalForTesting(
-                context, sProcessWaitArguments, new FileDescriptorInfo[0], creationParams);
+        final ChildProcessLauncherHelper launcherHelper =
+                ChildProcessLauncherTestUtils.startForTesting(
+                        context, sProcessWaitArguments, new FileDescriptorInfo[0], creationParams);
 
-        CriteriaHelper.pollInstrumentationThread(
-                new Criteria("Failed waiting for instrumentation-bound service") {
-                    @Override
-                    public boolean isSatisfied() {
-                        return ChildProcessLauncherTestUtils.getConnectionService(conn) != null;
-                    }
-                });
-
-        Assert.assertEquals(0, ChildProcessLauncherTestUtils.getConnectionServiceNumber(conn));
+        // Retrieve the connection (this waits for the service to connect).
+        final ChildProcessConnection retryConn = retrieveConnection(launcherHelper);
+        Assert.assertEquals(1, ChildProcessLauncherTestUtils.getConnectionServiceNumber(retryConn));
 
         final ChildProcessConnection[] sandboxedConnections =
                 getSandboxedConnectionArrayForTesting(context, context.getPackageName());
 
-        // Wait for the retry to succeed.
-        CriteriaHelper.pollInstrumentationThread(
-                new Criteria("Failed waiting for both child process services") {
-                    @Override
-                    public boolean isSatisfied() {
-                        boolean allChildrenConnected = true;
-                        for (int i = 0; i <= 1; ++i) {
-                            ChildProcessConnection conn = sandboxedConnections[i];
-                            allChildrenConnected &= conn != null
-                                    && ChildProcessLauncherTestUtils.getConnectionService(conn)
-                                            != null;
-                        }
-                        return allChildrenConnected;
-                    }
-                });
-
         // Check that only two connections are created.
         for (int i = 0; i < sandboxedConnections.length; ++i) {
             ChildProcessConnection sandboxedConn = sandboxedConnections[i];
             if (i <= 1) {
                 Assert.assertNotNull(sandboxedConn);
                 Assert.assertNotNull(
                         ChildProcessLauncherTestUtils.getConnectionService(sandboxedConn));
             } else {
                 Assert.assertNull(sandboxedConn);
             }
         }
 
-        Assert.assertTrue(conn == sandboxedConnections[0]);
-        final ChildProcessConnection retryConn = sandboxedConnections[1];
+        Assert.assertTrue(retryConn == sandboxedConnections[1]);
 
-        Assert.assertFalse(conn == retryConn);
-
+        ChildProcessConnection conn = sandboxedConnections[0];
         Assert.assertEquals(0, ChildProcessLauncherTestUtils.getConnectionServiceNumber(conn));
         Assert.assertEquals(0, ChildProcessLauncherTestUtils.getConnectionPid(conn));
         Assert.assertFalse(ChildProcessLauncherTestUtils.getConnectionService(conn).bindToCaller());
 
         Assert.assertEquals(1, ChildProcessLauncherTestUtils.getConnectionServiceNumber(retryConn));
         CriteriaHelper.pollInstrumentationThread(
                 new Criteria("Failed waiting retry connection to get pid") {
                     @Override
                     public boolean isSatisfied() {
                         return ChildProcessLauncherTestUtils.getConnectionPid(retryConn) > 0;
@@ skipping 11 matching lines @@
             public void run() {
                 ChildProcessLauncher.warmUp(context);
             }
         });
     }
 
     @Test
     @MediumTest
     @Feature({"ProcessManagement"})
     public void testWarmUp() {
-        final Context context = InstrumentationRegistry.getInstrumentation().getTargetContext();
+        Context context = InstrumentationRegistry.getInstrumentation().getTargetContext();
         warmUpOnUiThreadBlocking(context);
+
+        Assert.assertEquals(1, allocatedChromeSandboxedConnectionsCount());
+
+        ChildProcessLauncherHelper launcherHelper = ChildProcessLauncherTestUtils.startForTesting(
+                context, new String[0], new FileDescriptorInfo[0], null);
+
+        final ChildProcessConnection conn = retrieveConnection(launcherHelper);
+
+        Assert.assertEquals(
+                1, allocatedChromeSandboxedConnectionsCount()); // Used warmup connection.
+
         ChildProcessLauncherTestUtils.runOnLauncherThreadBlocking(new Runnable() {
             @Override
             public void run() {
-                Assert.assertEquals(1, allocatedChromeSandboxedConnectionsCount());
-
-                final ChildProcessConnection conn =
-                        ChildProcessLauncherTestUtils.startInternalForTesting(
-                                context, new String[0], new FileDescriptorInfo[0], null);
-                Assert.assertEquals(
-                        1, allocatedChromeSandboxedConnectionsCount()); // Used warmup connection.
-
                 ChildProcessLauncher.stop(ChildProcessLauncherTestUtils.getConnectionPid(conn));
             }
         });
     }
 
     @Test
     @MediumTest
     @Feature({"ProcessManagement"})
     public void testCustomCreationParamDoesNotReuseWarmupConnection() {
         // Since warmUp only uses default params.
@@ skipping 36 matching lines @@
                     public boolean isSatisfied() {
                         return connection.isConnected();
                     }
                 });
         return connection;
     }
 
     private static void startRendererProcess(
             Context context, int paramId, FileDescriptorInfo[] filesToMap) {
         assert LauncherThread.runningOnLauncherThread();
-        ChildProcessLauncher.start(context, paramId,
+        ChildProcessLauncherHelper.createAndStart(0L /* nativePointer */, paramId,
                 new String[] {"--" + ContentSwitches.SWITCH_PROCESS_TYPE + "="
                         + ContentSwitches.SWITCH_RENDERER_PROCESS},
-                filesToMap, null /* launchCallback */);
+                filesToMap);
     }
 
     private static ChildProcessConnection allocateBoundConnectionForTesting(
             final Context context, final ChildProcessCreationParams creationParams) {
         return ChildProcessLauncherTestUtils.runOnLauncherAndGetResult(
                 new Callable<ChildProcessConnection>() {
                     @Override
                     public ChildProcessConnection call() {
                         return ChildProcessLauncher.allocateBoundConnection(
                                 new ChildSpawnData(context, null /* commandLine */,
@@ skipping 13 matching lines @@
     private ChildProcessConnection allocateConnection(final String packageName) {
         return ChildProcessLauncherTestUtils.runOnLauncherAndGetResult(
                 new Callable<ChildProcessConnection>() {
                     @Override
                     public ChildProcessConnection call() {
                         // Allocate a new connection.
                         Context context = InstrumentationRegistry.getTargetContext();
                         ChildProcessCreationParams creationParams =
                                 getDefaultChildProcessCreationParams(packageName);
                         return ChildProcessLauncher.allocateConnection(
-                                new ChildSpawnData(context, null /* commandLine */,
-                                        null /* filesToBeMapped */, null /* launchCallback */,
+                                new ChildSpawnData(context, null /* serviceBundle */,
+                                        null /* connectionBundle */, null /* launchCallback */,
                                         null /* childProcessCallback */, true /* inSandbox */,
                                         false /* alwaysInForeground */, creationParams),
-                                ChildProcessLauncher.createCommonParamsBundle(creationParams),
                                 false /* forWarmUp */);
                     }
                 });
     }
 
     private static void enqueuePendingSpawnForTesting(final Context context,
             final String[] commandLine, final ChildProcessCreationParams creationParams,
             final boolean inSandbox) {
         ChildProcessLauncherTestUtils.runOnLauncherThreadBlocking(new Runnable() {
             @Override
             public void run() {
                 String packageName = creationParams != null ? creationParams.getPackageName()
                                                             : context.getPackageName();
                 ChildConnectionAllocator allocator = ChildProcessLauncher.getConnectionAllocator(
                         context, packageName, inSandbox);
-                allocator.enqueuePendingQueueForTesting(new ChildSpawnData(context, commandLine,
-                        new FileDescriptorInfo[0], null /* launchCallback */,
-                        null /* childProcessCallback */, true /* inSandbox */,
-                        false /* alwaysInForeground */, creationParams));
+
+                allocator.enqueuePendingQueueForTesting(new ChildSpawnData(context,
+                        null /* serviceBundle */, null /* connectionBundle */,
+                        null /* launchCallback */, null /* childProcessCallback */,
+                        true /* inSandbox */, false /* alwaysInForeground */, creationParams));
             }
         });
     }
 
     private static int allocatedSandboxedConnectionsCountForTesting(
             final Context context, final String packageName) {
         return ChildProcessLauncherTestUtils.runOnLauncherAndGetResult(
                 new Callable<Integer>() {
                     @Override
                     public Integer call() {
@@ skipping 40 matching lines @@
 
     private ChildProcessCreationParams getDefaultChildProcessCreationParams(String packageName) {
         return new ChildProcessCreationParams(packageName, false /* isExternalService */,
                 LibraryProcessType.PROCESS_CHILD, false /* bindToCallerCheck */);
     }
 
     private void triggerConnectionSetup(final ChildProcessConnection connection) {
         ChildProcessLauncherTestUtils.runOnLauncherThreadBlocking(new Runnable() {
             @Override
             public void run() {
-                ChildProcessLauncher.triggerConnectionSetup(connection, sProcessWaitArguments,
-                        new FileDescriptorInfo[0], null /* launchCallback */,
-                        null /* childProcessCallback */, true /* addToBindingManager */);
+                Bundle connectionBundle = ChildProcessLauncherHelper.createConnectionBundle(
+                        sProcessWaitArguments, new FileDescriptorInfo[0]);
+                ChildProcessLauncher.triggerConnectionSetup(connection, connectionBundle,
+                        null /* launchCallback */, null /* childProcessCallback */,
+                        true /* addToBindingmanager */);
             }
         });
     }
+
+    private static ChildProcessConnection retrieveConnection(
+            final ChildProcessLauncherHelper launcherHelper) {
+        CriteriaHelper.pollInstrumentationThread(
+                new Criteria("Failed waiting for child process to connect") {
+                    @Override
+                    public boolean isSatisfied() {
+                        return ChildProcessLauncherTestUtils.getConnection(launcherHelper) != null;
+                    }
+                });
+
+        return ChildProcessLauncherTestUtils.getConnection(launcherHelper);
+    }
 }