Moving some CPL logic to CPLH.

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;
-import android.os.Bundle;
 
 import org.chromium.base.Log;
 import org.chromium.base.VisibleForTesting;
 
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.LinkedList;
 import java.util.Queue;
 
 /**
  * This class is responsible for allocating and managing connections to child
  * process services. These connections are in a pool (the services are defined
  * in the AndroidManifest.xml).
  */
 public class ChildConnectionAllocator {
     private static final String TAG = "ChildConnAllocator";
 
     /** Factory interface. Used by tests to specialize created connections. */
     @VisibleForTesting
     protected interface ConnectionFactory {
         ChildProcessConnection createConnection(ChildSpawnData spawnData,
-                ChildProcessConnection.DeathCallback deathCallback,
-                Bundle childProcessCommonParameters, String serviceClassName);
+                ChildProcessConnection.DeathCallback deathCallback, String serviceClassName);
     }
 
     /** Default implementation of the ConnectionFactory that creates actual connections. */
     private static class ConnectionFactoryImpl implements ConnectionFactory {
         public ChildProcessConnection createConnection(ChildSpawnData spawnData,
-                ChildProcessConnection.DeathCallback deathCallback,
-                Bundle childProcessCommonParameters, String serviceClassName) {
+                ChildProcessConnection.DeathCallback deathCallback, String serviceClassName) {
             return new ChildProcessConnection(spawnData.getContext(), deathCallback,
-                    serviceClassName, childProcessCommonParameters, spawnData.getCreationParams());
+                    serviceClassName, spawnData.getServiceBundle(), spawnData.getCreationParams());
         }
     }
 
     // Connections to services. Indices of the array correspond to the service numbers.
     private final ChildProcessConnection[] mChildProcessConnections;
 
     private final String mServiceClassName;
 
     // The list of free (not bound) service indices.
     private final ArrayList<Integer> mFreeConnectionIndices;
@@ skipping 76 matching lines @@
         mServiceClassName = serviceClassName;
         mChildProcessConnections = new ChildProcessConnection[numChildServices];
         mFreeConnectionIndices = new ArrayList<Integer>(numChildServices);
         for (int i = 0; i < numChildServices; i++) {
             mFreeConnectionIndices.add(i);
         }
     }
 
     // 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) {
+            ChildProcessConnection.DeathCallback deathCallback, boolean queueIfNoSlotAvailable) {
         assert LauncherThread.runningOnLauncherThread();
         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;
         String serviceClassName = mServiceClassName + slot;
-        mChildProcessConnections[slot] = mConnectionFactory.createConnection(
-                spawnData, deathCallback, childProcessCommonParameters, serviceClassName);
+        mChildProcessConnections[slot] =
+                mConnectionFactory.createConnection(spawnData, deathCallback, serviceClassName);
         Log.d(TAG, "Allocator allocated a connection, name: %s, slot: %d", mServiceClassName, slot);
         return mChildProcessConnections[slot];
     }
 
     // Also return the first ChildSpawnData in the pending queue, if any.
     public ChildSpawnData free(ChildProcessConnection connection) {
         assert LauncherThread.runningOnLauncherThread();
         // mChildProcessConnections is relatively short (20 items at max at this point).
         // We are better of iterating than caching in a map.
         int slot = Arrays.asList(mChildProcessConnections).indexOf(connection);
@@ skipping 40 matching lines @@
         assert LauncherThread.runningOnLauncherThread();
         mPendingSpawnQueue.add(spawnData);
     }
 
     @VisibleForTesting
     int pendingSpawnsCountForTesting() {
         assert LauncherThread.runningOnLauncherThread();
         return mPendingSpawnQueue.size();
     }
 }