Refactoring ChildProcessConnection.

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.Context;
 import android.os.Bundle;
 import android.os.IBinder;
 import android.os.RemoteException;
@@ skipping 18 matching lines @@
  * 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";
 
     /**
      * Implemented by ChildProcessLauncherHelper.
      */
-    public interface LaunchCallback { void onChildProcessStarted(int pid); }
+    public interface LaunchCallback {
+        void onChildProcessStarted(BaseChildProcessConnection connection);
+    }
 
     private static final boolean SPARE_CONNECTION_ALWAYS_IN_FOREGROUND = false;
 
     @VisibleForTesting
-    static ChildProcessConnection allocateConnection(
+    static BaseChildProcessConnection allocateConnection(
             ChildSpawnData spawnData, Bundle childProcessCommonParams, boolean forWarmUp) {
         assert LauncherThread.runningOnLauncherThread();
-        ChildProcessConnection.DeathCallback deathCallback =
-                new ChildProcessConnection.DeathCallback() {
+        BaseChildProcessConnection.DeathCallback deathCallback =
+                new BaseChildProcessConnection.DeathCallback() {
                     @Override
-                    public void onChildProcessDied(ChildProcessConnection connection) {
+                    public void onChildProcessDied(BaseChildProcessConnection connection) {
                         assert LauncherThread.runningOnLauncherThread();
                         if (connection.getPid() != 0) {
                             stop(connection.getPid());
                         } else {
                             freeConnection(connection);
                         }
                     }
                 };
         final ChildProcessCreationParams creationParams = spawnData.getCreationParams();
         final Context context = spawnData.getContext();
@@ skipping 38 matching lines @@
     static Bundle createCommonParamsBundle(ChildProcessCreationParams params) {
         Bundle commonParams = new Bundle();
         commonParams.putParcelable(
                 ChildProcessConstants.EXTRA_LINKER_PARAMS, getLinkerParamsForNewConnection());
         final boolean bindToCallerCheck = params == null ? false : params.getBindToCallerCheck();
         commonParams.putBoolean(ChildProcessConstants.EXTRA_BIND_TO_CALLER, bindToCallerCheck);
         return commonParams;
     }
 
     @VisibleForTesting
-    static ChildProcessConnection allocateBoundConnection(ChildSpawnData spawnData,
-            ChildProcessConnection.StartCallback startCallback, boolean forWarmUp) {
+    static BaseChildProcessConnection allocateBoundConnection(ChildSpawnData spawnData,
+            BaseChildProcessConnection.StartCallback startCallback, boolean forWarmUp) {
         assert LauncherThread.runningOnLauncherThread();
         final Context context = spawnData.getContext();
         final boolean inSandbox = spawnData.isInSandbox();
         final ChildProcessCreationParams creationParams = spawnData.getCreationParams();
 
-        ChildProcessConnection connection = allocateConnection(
+        BaseChildProcessConnection connection = allocateConnection(
                 spawnData, createCommonParamsBundle(spawnData.getCreationParams()), forWarmUp);
         if (connection != null) {
             connection.start(startCallback);
 
             String packageName = creationParams != null ? creationParams.getPackageName()
                                                         : context.getPackageName();
             if (inSandbox
-                    && !ChildConnectionAllocator.getAllocator(context, packageName, inSandbox)
+                    && !ChildConnectionAllocator
+                                .getAllocator(context, packageName, true /* sandboxed */)
                                 .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
                 // killer.
                 getBindingManager().releaseAllModerateBindings();
             }
         }
         return connection;
     }
 
     private static final long FREE_CONNECTION_DELAY_MILLIS = 1;
 
-    private static void freeConnection(ChildProcessConnection connection) {
+    private static void freeConnection(BaseChildProcessConnection connection) {
         assert LauncherThread.runningOnLauncherThread();
         if (connection == sSpareSandboxedConnection) clearSpareConnection();
 
         // Freeing a service should be delayed. This is so that we avoid immediately reusing the
         // freed service (see http://crbug.com/164069): the framework might keep a service process
         // alive when it's been unbound for a short time. If a new connection to the same service
         // is bound at that point, the process is reused and bad things happen (mostly static
         // variables are set when we don't expect them to).
-        final ChildProcessConnection conn = connection;
+        final BaseChildProcessConnection conn = connection;
         LauncherThread.postDelayed(new Runnable() {
             @Override
             public void run() {
                 // TODO(jcivelli): it should be safe to pass a null Context here as it is used to
                 // initialize the ChildConnectionAllocator object and if we are freeing a
                 // connection, we must have allocated one previously guaranteeing it is already
                 // initialized. When we consolidate ChildProcessLauncher and
                 // ChildProcessLauncherHelper, we'll have a context around that we can pass in
                 // there.
                 ChildConnectionAllocator allocator = ChildConnectionAllocator.getAllocator(
-                        null /* context */, conn.getPackageName(), conn.isInSandbox());
+                        null /* context */, conn.getPackageName(), conn.isSandboxed());
                 assert allocator != null;
                 final ChildSpawnData pendingSpawn = allocator.free(conn);
                 if (pendingSpawn != null) {
                     LauncherThread.post(new Runnable() {
                         @Override
                         public void run() {
                             startInternal(pendingSpawn.getContext(), pendingSpawn.getCommandLine(),
                                     pendingSpawn.getChildProcessId(),
                                     pendingSpawn.getFilesToBeMapped(),
                                     pendingSpawn.getLaunchCallback(),
                                     pendingSpawn.getChildProcessCallback(),
                                     pendingSpawn.isInSandbox(), pendingSpawn.isAlwaysInForeground(),
                                     pendingSpawn.getCreationParams());
                         }
                     });
                 }
             }
         }, FREE_CONNECTION_DELAY_MILLIS);
     }
 
-    // Represents an invalid process handle; same as base/process/process.h kNullProcessHandle.
-    private static final int NULL_PROCESS_HANDLE = 0;
-
     // Map from pid to ChildService connection.
-    private static Map<Integer, ChildProcessConnection> sServiceMap =
-            new ConcurrentHashMap<Integer, ChildProcessConnection>();
+    private static Map<Integer, BaseChildProcessConnection> sServiceMap =
+            new ConcurrentHashMap<Integer, BaseChildProcessConnection>();
 
     // Lock for getBindingManager()
     private static final Object sBindingManagerLock = new Object();
 
     // These variables are used for the warm up sandboxed connection.
     // |sSpareSandboxedConnection| is non-null when there is a pending connection. Note it's cleared
     // to null again after the connection is used for a real child process.
     // |sSpareConnectionStarting| is true if ChildProcessConnection.StartCallback has not fired.
     // This is used for a child process allocation to determine if StartCallback should be chained.
     // |sSpareConnectionStartCallback| is the chained StartCallback. This is also used to determine
     // if there is already a child process launch that's used this this connection.
-    private static ChildProcessConnection sSpareSandboxedConnection;
+    private static BaseChildProcessConnection sSpareSandboxedConnection;
     private static boolean sSpareConnectionStarting;
-    private static ChildProcessConnection.StartCallback sSpareConnectionStartCallback;
+    private static BaseChildProcessConnection.StartCallback sSpareConnectionStartCallback;
 
     // Manages oom bindings used to bind chind services. Lazily initialized by getBindingManager()
     private static BindingManager sBindingManager;
 
     // Whether the main application is currently brought to the foreground.
     private static boolean sApplicationInForeground = true;
 
     // Lazy initialize sBindingManager
     // TODO(boliu): This should be internal to content.
     public static BindingManager getBindingManager() {
@@ skipping 63 matching lines @@
      * @param context the application context used for the connection.
      */
     public static void warmUp(final Context context) {
         assert ThreadUtils.runningOnUiThread();
         LauncherThread.post(new Runnable() {
             @Override
             public void run() {
                 if (sSpareSandboxedConnection != null) return;
                 ChildProcessCreationParams params = ChildProcessCreationParams.getDefault();
 
-                ChildProcessConnection.StartCallback startCallback =
-                        new ChildProcessConnection.StartCallback() {
+                BaseChildProcessConnection.StartCallback startCallback =
+                        new BaseChildProcessConnection.StartCallback() {
                             @Override
                             public void onChildStarted() {
                                 assert LauncherThread.runningOnLauncherThread();
                                 sSpareConnectionStarting = false;
                                 if (sSpareConnectionStartCallback != null) {
                                     sSpareConnectionStartCallback.onChildStarted();
                                     clearSpareConnection();
                                 }
                                 // If there is no chained callback, that means nothing has tried to
                                 // use the spare connection yet. It will be cleared when it is used
@@ skipping 47 matching lines @@
         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)) {
             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}
+                // When launching these renderer processes, {@link ManagedChildProcessConnection}
                 // 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(),
                         params.getBindToCallerCheck());
             }
             if (ContentSwitches.SWITCH_GPU_PROCESS.equals(processType)) {
                 childProcessCallback = new GpuProcessCallback();
                 inSandbox = false;
                 alwaysInForeground = true;
             } else {
                 // We only support sandboxed utility processes now.
                 assert ContentSwitches.SWITCH_UTILITY_PROCESS.equals(processType);
             }
         }
 
         startInternal(context, commandLine, childProcessId, filesToBeMapped, launchCallback,
                 childProcessCallback, inSandbox, alwaysInForeground, params);
     }
 
     @VisibleForTesting
-    public static ChildProcessConnection startInternal(final Context context,
+    public static BaseChildProcessConnection startInternal(final Context context,
             final String[] commandLine, final int childProcessId,
             final FileDescriptorInfo[] filesToBeMapped, final LaunchCallback launchCallback,
             final IBinder childProcessCallback, final boolean inSandbox,
             final boolean alwaysInForeground, final ChildProcessCreationParams creationParams) {
         assert LauncherThread.runningOnLauncherThread();
         try {
             TraceEvent.begin("ChildProcessLauncher.startInternal");
 
-            ChildProcessConnection allocatedConnection = null;
+            BaseChildProcessConnection allocatedConnection = null;
             String packageName = creationParams != null ? creationParams.getPackageName()
                     : context.getPackageName();
-            ChildProcessConnection.StartCallback startCallback =
-                    new ChildProcessConnection.StartCallback() {
+            BaseChildProcessConnection.StartCallback startCallback =
+                    new BaseChildProcessConnection.StartCallback() {
                         @Override
                         public void onChildStarted() {}
 
                         @Override
                         public void onChildStartFailed() {
                             assert LauncherThread.runningOnLauncherThread();
-                            Log.e(TAG, "ChildProcessConnection.start failed, trying again");
+                            Log.e(TAG, "BaseChildProcessConnection.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, childProcessCallback,
@@ skipping 48 matching lines @@
         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,
+    static void triggerConnectionSetup(final BaseChildProcessConnection connection,
             String[] commandLine, int childProcessId, FileDescriptorInfo[] filesToBeMapped,
             final IBinder childProcessCallback, final LaunchCallback launchCallback) {
         assert LauncherThread.runningOnLauncherThread();
         Log.d(TAG, "Setting up connection to process: slot=%d", connection.getServiceNumber());
-        ChildProcessConnection.ConnectionCallback connectionCallback =
-                new ChildProcessConnection.ConnectionCallback() {
+        BaseChildProcessConnection.ConnectionCallback connectionCallback =
+                new BaseChildProcessConnection.ConnectionCallback() {
                     @Override
-                    public void onConnected(int pid) {
-                        Log.d(TAG, "on connect callback, pid=%d", pid);
-                        if (pid != NULL_PROCESS_HANDLE) {
-                            getBindingManager().addNewConnection(pid, connection);
+                    public void onConnected(BaseChildProcessConnection connection) {
+                        if (connection != null) {
+                            int pid = connection.getPid();
+                            Log.d(TAG, "on connect callback, pid=%d", pid);
+                            if (connection instanceof ManagedChildProcessConnection) {
+                                getBindingManager().addNewConnection(
+                                        pid, (ManagedChildProcessConnection) 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);
+                            launchCallback.onChildProcessStarted(connection);
                         }
                     }
                 };
 
         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) {
         assert LauncherThread.runningOnLauncherThread();
         Log.d(TAG, "stopping child connection: pid=%d", pid);
-        ChildProcessConnection connection = sServiceMap.remove(pid);
+        BaseChildProcessConnection connection = sServiceMap.remove(pid);
         if (connection == null) {
             // Can happen for single process.
             return;
         }
-        getBindingManager().clearConnection(pid);
+        getBindingManager().removeConnection(pid);
         connection.stop();
         freeConnection(connection);
     }
 
     /** @return the count of services set up and working */
     @VisibleForTesting
     static int connectedServicesCountForTesting() {
         return sServiceMap.size();
     }
 
     /**
      * Kills the child process for testing.
      * @return true iff the process was killed as expected
      */
     @VisibleForTesting
     public static boolean crashProcessForTesting(int pid) {
         if (sServiceMap.get(pid) == null) return false;
 
         try {
-            ((ChildProcessConnectionImpl) sServiceMap.get(pid)).crashServiceForTesting();
+            ((ManagedChildProcessConnection) sServiceMap.get(pid)).crashServiceForTesting();
         } catch (RemoteException ex) {
             return false;
         }
 
         return true;
     }
 }