Refactoring ChildProcessConnection.

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;
@@ skipping 84 matching lines @@
      * Tests cleanup for a connection that terminates before setup.
      */
     @Test
     @MediumTest
     @Feature({"ProcessManagement"})
     public void testServiceCrashedBeforeSetup() throws RemoteException {
         Assert.assertEquals(0, allocatedChromeSandboxedConnectionsCount());
         Assert.assertEquals(0, ChildProcessLauncher.connectedServicesCountForTesting());
 
         // Start and connect to a new service.
-        final ChildProcessConnectionImpl connection = startConnection();
+        final BaseChildProcessConnection connection = startConnection();
         Assert.assertEquals(1, allocatedChromeSandboxedConnectionsCount());
 
         // Verify that the service is not yet set up.
         Assert.assertEquals(0, connection.getPid());
         Assert.assertEquals(0, ChildProcessLauncher.connectedServicesCountForTesting());
 
         // Crash the service.
         connection.crashServiceForTesting();
 
         // Verify that the connection gets cleaned-up.
@@ skipping 15 matching lines @@
     /**
      * Tests cleanup for a connection that terminates after setup.
      */
     @Test
     @MediumTest
     @Feature({"ProcessManagement"})
     public void testServiceCrashedAfterSetup() throws RemoteException {
         Assert.assertEquals(0, allocatedChromeSandboxedConnectionsCount());
 
         // Start and connect to a new service.
-        final ChildProcessConnectionImpl connection = startConnection();
+        final BaseChildProcessConnection connection = startConnection();
         Assert.assertEquals(1, allocatedChromeSandboxedConnectionsCount());
 
         // Initiate the connection setup.
         triggerConnectionSetup(connection);
 
         // Verify that the connection completes the setup.
         CriteriaHelper.pollInstrumentationThread(Criteria.equals(1, new Callable<Integer>() {
             @Override
             public Integer call() {
                 return ChildProcessLauncher.connectedServicesCountForTesting();
@@ skipping 34 matching lines @@
      * Tests spawning a pending process from queue.
      */
     @Test
     @MediumTest
     @Feature({"ProcessManagement"})
     public void testPendingSpawnQueue() throws RemoteException {
         final Context appContext = InstrumentationRegistry.getInstrumentation().getTargetContext();
         Assert.assertEquals(0, allocatedChromeSandboxedConnectionsCount());
 
         // Start and connect to a new service.
-        final ChildProcessConnectionImpl connection = startConnection();
+        final BaseChildProcessConnection connection = startConnection();
         Assert.assertEquals(1, allocatedChromeSandboxedConnectionsCount());
 
         // Queue up a new spawn request. There is no way to kill the pending connection, leak it
         // until the browser restart.
         final String packageName = appContext.getPackageName();
         final boolean inSandbox = true;
         enqueuePendingSpawnForTesting(appContext, sProcessWaitArguments,
                 getDefaultChildProcessCreationParams(packageName), inSandbox);
         Assert.assertEquals(1, pendingSpawnsCountForTesting(appContext, packageName, inSandbox));
 
@@ skipping 55 matching lines @@
     @ChildProcessAllocatorSettings(
             sandboxedServiceCount = 4, sandboxedServiceName = DEFAULT_SANDBOXED_PROCESS_SERVICE)
     public void testServiceNumberAllocation() {
         Context appContext = InstrumentationRegistry.getInstrumentation().getTargetContext();
         Assert.assertEquals(0,
                 allocatedSandboxedConnectionsCountForTesting(
                         appContext, EXTERNAL_APK_PACKAGE_NAME));
         Assert.assertEquals(0, allocatedChromeSandboxedConnectionsCount());
 
         // Start and connect to a new service of an external APK.
-        ChildProcessConnectionImpl externalApkConnection =
+        BaseChildProcessConnection externalApkConnection =
                 allocateConnection(EXTERNAL_APK_PACKAGE_NAME);
         // Start and connect to a new service for a regular tab.
-        ChildProcessConnectionImpl tabConnection = allocateConnection(appContext.getPackageName());
+        BaseChildProcessConnection tabConnection = allocateConnection(appContext.getPackageName());
 
         // Verify that one connection is allocated for an external APK and a regular tab
         // respectively.
         Assert.assertEquals(1,
                 allocatedSandboxedConnectionsCountForTesting(
                         appContext, EXTERNAL_APK_PACKAGE_NAME));
         Assert.assertEquals(1, allocatedChromeSandboxedConnectionsCount());
 
         // Verify that connections allocated for an external APK and the regular tab are from
         // different ChildConnectionAllocators, since both ChildConnectionAllocators start
@@ skipping 12 matching lines @@
     @Feature({"ProcessManagement"})
     @ChildProcessAllocatorSettings(
             sandboxedServiceCount = 1, sandboxedServiceName = DEFAULT_SANDBOXED_PROCESS_SERVICE)
     public void testExceedMaximumConnectionNumber() {
         Context appContext = InstrumentationRegistry.getInstrumentation().getTargetContext();
         Assert.assertEquals(0,
                 allocatedSandboxedConnectionsCountForTesting(
                         appContext, EXTERNAL_APK_PACKAGE_NAME));
 
         // Setup a connection for an external APK to reach the maximum allowed connection number.
-        ChildProcessConnectionImpl externalApkConnection =
+        BaseChildProcessConnection externalApkConnection =
                 allocateConnection(EXTERNAL_APK_PACKAGE_NAME);
         Assert.assertNotNull(externalApkConnection);
 
         // Verify that there isn't any connection available for the external APK.
-        ChildProcessConnectionImpl exceedNumberExternalApkConnection =
+        BaseChildProcessConnection exceedNumberExternalApkConnection =
                 allocateConnection(EXTERNAL_APK_PACKAGE_NAME);
         Assert.assertNull(exceedNumberExternalApkConnection);
 
         // Verify that we can still allocate connection for a regular tab.
-        ChildProcessConnectionImpl tabConnection = allocateConnection(appContext.getPackageName());
+        BaseChildProcessConnection tabConnection = allocateConnection(appContext.getPackageName());
         Assert.assertNotNull(tabConnection);
     }
 
     /**
      * Tests binding to the same sandboxed service process from multiple processes in the
      * same package. This uses the ChildProcessLauncherTestHelperService declared in
      * ContentShell.apk as a separate android:process to bind the first (slot 0) service. The
      * instrumentation test then tries to bind the same slot, which fails, so the
      * ChildProcessLauncher retries on a new connection.
      */
@@ skipping 69 matching lines @@
                 "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.
         final ChildProcessCreationParams creationParams = new ChildProcessCreationParams(
                 context.getPackageName(), false /* isExternalService */,
                 LibraryProcessType.PROCESS_CHILD, true /* bindToCallerCheck */);
-        final ChildProcessConnection conn =
+        final BaseChildProcessConnection conn =
                 ChildProcessLauncherTestHelperService.startInternalForTesting(
                         context, sProcessWaitArguments, new FileDescriptorInfo[0], creationParams);
 
         CriteriaHelper.pollInstrumentationThread(
                 new Criteria("Failed waiting for instrumentation-bound service") {
                     @Override
                     public boolean isSatisfied() {
                         return conn.getService() != null;
                     }
                 });
 
         Assert.assertEquals(0, conn.getServiceNumber());
 
-        final ChildProcessConnection[] sandboxedConnections =
+        final BaseChildProcessConnection[] 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];
+                            BaseChildProcessConnection conn = sandboxedConnections[i];
                             allChildrenConnected &= conn != null && conn.getService() != null;
                         }
                         return allChildrenConnected;
                     }
                 });
 
         // Check that only two connections are created.
         for (int i = 0; i < sandboxedConnections.length; ++i) {
-            ChildProcessConnection sandboxedConn = sandboxedConnections[i];
+            BaseChildProcessConnection sandboxedConn = sandboxedConnections[i];
             if (i <= 1) {
                 Assert.assertNotNull(sandboxedConn);
                 Assert.assertNotNull(sandboxedConn.getService());
             } else {
                 Assert.assertNull(sandboxedConn);
             }
         }
 
         Assert.assertTrue(conn == sandboxedConnections[0]);
-        final ChildProcessConnection retryConn = sandboxedConnections[1];
+        final BaseChildProcessConnection retryConn = sandboxedConnections[1];
 
         Assert.assertFalse(conn == retryConn);
 
         Assert.assertEquals(0, conn.getServiceNumber());
         Assert.assertEquals(0, conn.getPid());
         Assert.assertFalse(conn.getService().bindToCaller());
 
         Assert.assertEquals(1, retryConn.getServiceNumber());
         CriteriaHelper.pollInstrumentationThread(
                 new Criteria("Failed waiting retry connection to get pid") {
@@ skipping 19 matching lines @@
     @MediumTest
     @Feature({"ProcessManagement"})
     public void testWarmUp() {
         final Context context = InstrumentationRegistry.getInstrumentation().getTargetContext();
         warmUpOnUiThreadBlocking(context);
         ChildProcessLauncherTestHelperService.runOnLauncherThreadBlocking(new Runnable() {
             @Override
             public void run() {
                 Assert.assertEquals(1, allocatedChromeSandboxedConnectionsCount());
 
-                final ChildProcessConnection conn =
+                final BaseChildProcessConnection conn =
                         ChildProcessLauncherTestHelperService.startInternalForTesting(
                                 context, new String[0], new FileDescriptorInfo[0], null);
                 Assert.assertEquals(
                         1, allocatedChromeSandboxedConnectionsCount()); // Used warmup connection.
 
                 ChildProcessLauncher.stop(conn.getPid());
             }
         });
     }
 
@@ skipping 21 matching lines @@
 
                 startRendererProcess(
                         context, ChildProcessCreationParams.DEFAULT_ID, new FileDescriptorInfo[0]);
                 Assert.assertEquals(2, allocatedChromeSandboxedConnectionsCount()); // Warmup used.
 
                 ChildProcessCreationParams.unregister(paramId);
             }
         });
     }
 
-    private ChildProcessConnectionImpl startConnection() {
+    private BaseChildProcessConnection startConnection() {
         // Allocate a new connection.
         Context context = InstrumentationRegistry.getInstrumentation().getTargetContext();
-        final ChildProcessConnectionImpl connection =
-                (ChildProcessConnectionImpl) allocateBoundConnectionForTesting(
-                        context, getDefaultChildProcessCreationParams(context.getPackageName()));
+        final BaseChildProcessConnection connection = allocateBoundConnectionForTesting(
+                context, getDefaultChildProcessCreationParams(context.getPackageName()));
 
         // Wait for the service to connect.
         CriteriaHelper.pollInstrumentationThread(
                 new Criteria("The connection wasn't established.") {
                     @Override
                     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,
                 new String[] {"--" + ContentSwitches.SWITCH_PROCESS_TYPE + "="
                         + ContentSwitches.SWITCH_RENDERER_PROCESS},
                 0 /* childProcessId */, filesToMap, null /* launchCallback */);
     }
 
-    private static ChildProcessConnection allocateBoundConnectionForTesting(
+    private static BaseChildProcessConnection allocateBoundConnectionForTesting(
             final Context context, final ChildProcessCreationParams creationParams) {
         return ChildProcessLauncherTestHelperService.runOnLauncherAndGetResult(
-                new Callable<ChildProcessConnection>() {
+                new Callable<BaseChildProcessConnection>() {
                     @Override
-                    public ChildProcessConnection call() {
+                    public BaseChildProcessConnection call() {
                         return ChildProcessLauncher.allocateBoundConnection(
                                 new ChildSpawnData(context, null /* commandLine */,
                                         0 /* childProcessId */, null /* filesToBeMapped */,
                                         null /* LaunchCallback */, null /* childProcessCallback */,
                                         true /* inSandbox */, false /* alwaysInForeground */,
                                         creationParams),
                                 null /* startCallback */, false /* forWarmUp */);
                     }
                 });
     }
 
     /**
      * Returns a new connection if it is allocated. Note this function only allocates a connection
      * but doesn't really start the connection to bind a service. It is for testing whether the
      * connection is allocated properly for different application packages.
      */
-    private ChildProcessConnectionImpl allocateConnection(final String packageName) {
+    private BaseChildProcessConnection allocateConnection(final String packageName) {
         return ChildProcessLauncherTestHelperService.runOnLauncherAndGetResult(
-                new Callable<ChildProcessConnectionImpl>() {
+                new Callable<BaseChildProcessConnection>() {
                     @Override
-                    public ChildProcessConnectionImpl call() {
+                    public BaseChildProcessConnection call() {
                         // Allocate a new connection.
                         Context context = InstrumentationRegistry.getTargetContext();
                         ChildProcessCreationParams creationParams =
                                 getDefaultChildProcessCreationParams(packageName);
-                        return (ChildProcessConnectionImpl) ChildProcessLauncher.allocateConnection(
+                        return ChildProcessLauncher.allocateConnection(
                                 new ChildSpawnData(context, null /* commandLine */,
                                         0 /* childProcessId */, null /* filesToBeMapped */,
                                         null /* launchCallback */, null /* childProcessCallback */,
                                         true /* inSandbox */, false /* alwaysInForeground */,
                                         creationParams),
                                 ChildProcessLauncher.createCommonParamsBundle(creationParams),
                                 false /* forWarmUp */);
                     }
                 });
     }
@@ skipping 22 matching lines @@
                 new Callable<Integer>() {
                     @Override
                     public Integer call() {
                         return ChildConnectionAllocator
                                 .getAllocator(context, packageName, true /*isSandboxed */)
                                 .allocatedConnectionsCountForTesting();
                     }
                 });
     }
 
-    private static ChildProcessConnection[] getSandboxedConnectionArrayForTesting(
+    private static BaseChildProcessConnection[] getSandboxedConnectionArrayForTesting(
             final Context context, final String packageName) {
         return ChildProcessLauncherTestHelperService.runOnLauncherAndGetResult(
-                new Callable<ChildProcessConnection[]>() {
+                new Callable<BaseChildProcessConnection[]>() {
                     @Override
-                    public ChildProcessConnection[] call() {
+                    public BaseChildProcessConnection[] call() {
                         return ChildConnectionAllocator
                                 .getAllocator(context, packageName, true /*isSandboxed */)
                                 .connectionArrayForTesting();
                     }
                 });
     }
 
     private static int pendingSpawnsCountForTesting(
             final Context context, final String packageName, final boolean inSandbox) {
         return ChildProcessLauncherTestHelperService.runOnLauncherAndGetResult(
@@ skipping 13 matching lines @@
     private int allocatedChromeSandboxedConnectionsCount() {
         Context context = InstrumentationRegistry.getInstrumentation().getTargetContext();
         return allocatedSandboxedConnectionsCountForTesting(context, context.getPackageName());
     }
 
     private ChildProcessCreationParams getDefaultChildProcessCreationParams(String packageName) {
         return new ChildProcessCreationParams(packageName, false /* isExternalService */,
                 LibraryProcessType.PROCESS_CHILD, false /* bindToCallerCheck */);
     }
 
-    private void triggerConnectionSetup(final ChildProcessConnectionImpl connection) {
+    private void triggerConnectionSetup(final BaseChildProcessConnection connection) {
         ChildProcessLauncherTestHelperService.runOnLauncherThreadBlocking(new Runnable() {
             @Override
             public void run() {
                 ChildProcessLauncher.triggerConnectionSetup(connection, sProcessWaitArguments,
                         1 /* childProcessId */, new FileDescriptorInfo[0],
                         null /* launchCallback */, null /* childProcessCallback */);
             }
         });
     }
 }