Refactoring ChildProcessConnection.

content/public/android/java/src/org/chromium/content/browser/ChildConnectionAllocator.java

 // Copyright 2017 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 30 matching lines @@
     // Map from package name to ChildConnectionAllocator.
     private static Map<String, ChildConnectionAllocator> sSandboxedChildConnectionAllocatorMap;
 
     // Allocator used for non-sandboxed services.
     private static ChildConnectionAllocator sPrivilegedChildConnectionAllocator;
 
     // Used by test to override the default sandboxed service settings.
     private static int sSandboxedServicesCountForTesting = -1;
     private static String sSandboxedServicesNameForTesting;
 
+    // The factory used to create BaseChildProcessConnection instances.
+    private final BaseChildProcessConnection.Factory mConnectionFactory;
+
     // Connections to services. Indices of the array correspond to the service numbers.
-    private final ChildProcessConnection[] mChildProcessConnections;
+    private final BaseChildProcessConnection[] mChildProcessConnections;
 
     private final String mChildClassName;
     private final boolean mInSandbox;
 
     // The list of free (not bound) service indices.
     private final ArrayList<Integer> mFreeConnectionIndices;
 
     // 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 Queue<ChildSpawnData> mPendingSpawnQueue = new LinkedList<>();
 
     @SuppressFBWarnings("LI_LAZY_INIT_STATIC") // Method is single thread.
     public static ChildConnectionAllocator getAllocator(
-            Context context, String packageName, boolean inSandbox) {
+            Context context, String packageName, boolean sandboxed) {
         assert LauncherThread.runningOnLauncherThread();
-        if (!inSandbox) {
+        if (!sandboxed) {
             if (sPrivilegedChildConnectionAllocator == null) {
-                sPrivilegedChildConnectionAllocator = new ChildConnectionAllocator(false,
+                sPrivilegedChildConnectionAllocator = new ChildConnectionAllocator(
+                        ImportantChildProcessConnection.FACTORY, false /* sandboxed */,
                         getNumberOfServices(context, false, packageName),
                         getClassNameOfService(context, false, packageName));
             }
             return sPrivilegedChildConnectionAllocator;
         }
 
         if (sSandboxedChildConnectionAllocatorMap == null) {
             sSandboxedChildConnectionAllocatorMap = new HashMap<String, ChildConnectionAllocator>();
         }
         if (!sSandboxedChildConnectionAllocatorMap.containsKey(packageName)) {
             Log.w(TAG,
                     "Create a new ChildConnectionAllocator with package name = %s,"
                             + " inSandbox = true",
                     packageName);
             sSandboxedChildConnectionAllocatorMap.put(packageName,
-                    new ChildConnectionAllocator(true,
-                            getNumberOfServices(context, true, packageName),
+                    new ChildConnectionAllocator(ManagedChildProcessConnection.FACTORY,
+                            true /* sandboxed */, getNumberOfServices(context, true, packageName),
                             getClassNameOfService(context, true, packageName)));
         }
         return sSandboxedChildConnectionAllocatorMap.get(packageName);
         // TODO(pkotwicz|hanxi): Figure out when old allocators should be removed from
         // {@code sSandboxedChildConnectionAllocatorMap}.
     }
 
     private static String getClassNameOfService(
             Context context, boolean inSandbox, String packageName) {
         if (!inSandbox) {
@@ skipping 55 matching lines @@
         }
         return numServices;
     }
 
     @VisibleForTesting
     public static void setSandboxServicesSettingsForTesting(int serviceCount, String serviceName) {
         sSandboxedServicesCountForTesting = serviceCount;
         sSandboxedServicesNameForTesting = serviceName;
     }
 
-    private ChildConnectionAllocator(
+    private ChildConnectionAllocator(BaseChildProcessConnection.Factory connectionFactory,
             boolean inSandbox, int numChildServices, String serviceClassName) {
-        mChildProcessConnections = new ChildProcessConnectionImpl[numChildServices];
+        mConnectionFactory = connectionFactory;
+        mChildProcessConnections = new BaseChildProcessConnection[numChildServices];
         mFreeConnectionIndices = new ArrayList<Integer>(numChildServices);
         for (int i = 0; i < numChildServices; i++) {
             mFreeConnectionIndices.add(i);
         }
         mChildClassName = serviceClassName;
         mInSandbox = inSandbox;
     }
 
     // Allocates or enqueues. If there are no free slots, returns null and enqueues the spawn data.
-    public ChildProcessConnection allocate(ChildSpawnData spawnData,
-            ChildProcessConnection.DeathCallback deathCallback, Bundle childProcessCommonParameters,
-            boolean queueIfNoSlotAvailable) {
+    public BaseChildProcessConnection allocate(ChildSpawnData spawnData,
+            BaseChildProcessConnection.DeathCallback deathCallback,
+            Bundle childProcessCommonParameters, boolean queueIfNoSlotAvailable) {
         assert LauncherThread.runningOnLauncherThread();
         assert spawnData.isInSandbox() == mInSandbox;
         if (mFreeConnectionIndices.isEmpty()) {
             Log.d(TAG, "Ran out of services to allocate.");
             if (queueIfNoSlotAvailable) {
                 mPendingSpawnQueue.add(spawnData);
             }
             return null;
         }
         int slot = mFreeConnectionIndices.remove(0);
         assert mChildProcessConnections[slot] == null;
-        mChildProcessConnections[slot] = new ChildProcessConnectionImpl(spawnData.getContext(),
-                slot, mInSandbox, deathCallback, mChildClassName, childProcessCommonParameters,
-                spawnData.isAlwaysInForeground(), spawnData.getCreationParams());
+        mChildProcessConnections[slot] = mConnectionFactory.create(spawnData.getContext(), slot,
+                mInSandbox, deathCallback, mChildClassName, childProcessCommonParameters,
+                spawnData.getCreationParams());
         Log.d(TAG, "Allocator allocated a connection, sandbox: %b, slot: %d", mInSandbox, slot);
         return mChildProcessConnections[slot];
     }
 
     // Also return the first ChildSpawnData in the pending queue, if any.
-    public ChildSpawnData free(ChildProcessConnection connection) {
+    public ChildSpawnData free(BaseChildProcessConnection connection) {
         assert LauncherThread.runningOnLauncherThread();
         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);
@@ skipping 13 matching lines @@
     }
 
     /** @return the count of connections managed by the allocator */
     @VisibleForTesting
     int allocatedConnectionsCountForTesting() {
         assert LauncherThread.runningOnLauncherThread();
         return mChildProcessConnections.length - mFreeConnectionIndices.size();
     }
 
     @VisibleForTesting
-    ChildProcessConnection[] connectionArrayForTesting() {
+    BaseChildProcessConnection[] connectionArrayForTesting() {
         return mChildProcessConnections;
     }
 
     @VisibleForTesting
     void enqueuePendingQueueForTesting(ChildSpawnData spawnData) {
         assert LauncherThread.runningOnLauncherThread();
         mPendingSpawnQueue.add(spawnData);
     }
 
     @VisibleForTesting
     int pendingSpawnsCountForTesting() {
         assert LauncherThread.runningOnLauncherThread();
         return mPendingSpawnQueue.size();
     }
 }