Moving BindingManager and ChildProcessConnection to base/.

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;
 
 import org.chromium.base.CpuFeatures;
 import org.chromium.base.Log;
 import org.chromium.base.ThreadUtils;
 import org.chromium.base.TraceEvent;
 import org.chromium.base.VisibleForTesting;
 import org.chromium.base.library_loader.Linker;
+import org.chromium.base.process_launcher.BaseChildProcessConnection;
+import org.chromium.base.process_launcher.BindingManager;
+import org.chromium.base.process_launcher.BindingManagerImpl;
 import org.chromium.base.process_launcher.ChildProcessCreationParams;
 import org.chromium.base.process_launcher.FileDescriptorInfo;
+import org.chromium.base.process_launcher.ManagedChildProcessConnection;
 import org.chromium.content.app.ChromiumLinkerParams;
 import org.chromium.content.common.ContentSwitches;
 
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 
 /**
  * This class provides the method to start/stop ChildProcess called by native.
  *
  * Note about threading. The threading here is complicated and not well documented.
@@ skipping 63 matching lines @@
                                             linker.getImplementationForTesting());
         } else {
             return new ChromiumLinkerParams(sLinkerLoadAddress,
                                             waitForSharedRelros);
         }
     }
 
     @VisibleForTesting
     static Bundle createCommonParamsBundle(ChildProcessCreationParams params) {
         Bundle commonParams = new Bundle();
-        commonParams.putParcelable(
-                ChildProcessConstants.EXTRA_LINKER_PARAMS, getLinkerParamsForNewConnection());
+        commonParams.putParcelable(ContentChildProcessConstants.EXTRA_LINKER_PARAMS,
+                getLinkerParamsForNewConnection());
         final boolean bindToCallerCheck = params == null ? false : params.getBindToCallerCheck();
-        commonParams.putBoolean(ChildProcessConstants.EXTRA_BIND_TO_CALLER, bindToCallerCheck);
+        commonParams.putBoolean(
+                ContentChildProcessConstants.EXTRA_BIND_TO_CALLER, bindToCallerCheck);
         return commonParams;
     }
 
     @VisibleForTesting
     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();
@@ skipping 83 matching lines @@
     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() {
         synchronized (sBindingManagerLock) {
             if (sBindingManager == null) {
-                sBindingManager = BindingManagerImpl.createBindingManager();
+                sBindingManager =
+                        BindingManagerImpl.createBindingManager(LauncherThread.getHandler());
             }
             return sBindingManager;
         }
     }
 
     @VisibleForTesting
     public static void setBindingManagerForTesting(BindingManager manager) {
         sBindingManager = manager;
     }
 
@@ skipping 241 matching lines @@
             }
 
             triggerConnectionSetup(allocatedConnection, commandLine, childProcessId,
                     filesToBeMapped, childProcessCallback, launchCallback);
             return allocatedConnection;
         } finally {
             TraceEvent.end("ChildProcessLauncher.startInternal");
         }
     }
 
-    /**
-     * Create the common bundle to be passed to child processes.
-     * @param context Application context.
-     * @param commandLine Command line params to be passed to the service.
-     * @param linkerParams Linker params to start the service.
-     */
-    protected static Bundle createsServiceBundle(
-            String[] commandLine, FileDescriptorInfo[] filesToBeMapped) {
-        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 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());
         BaseChildProcessConnection.ConnectionCallback connectionCallback =
                 new BaseChildProcessConnection.ConnectionCallback() {
                     @Override
+                    public void onConnectionSetup(Bundle params) {
+                        params.putInt(ContentChildProcessConstants.EXTRA_CPU_COUNT,
+                                CpuFeatures.getCount());
+                        params.putLong(ContentChildProcessConstants.EXTRA_CPU_FEATURES,
+                                CpuFeatures.getMask());
+                        params.putBundle(Linker.EXTRA_LINKER_SHARED_RELROS,
+                                Linker.getInstance().getSharedRelros());
+                    }
+
+                    @Override
                     public void onConnected(BaseChildProcessConnection connection) {
                         assert LauncherThread.runningOnLauncherThread();
                         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);
@@ skipping 45 matching lines @@
 
         try {
             ((ManagedChildProcessConnection) sServiceMap.get(pid)).crashServiceForTesting();
         } catch (RemoteException ex) {
             return false;
         }
 
         return true;
     }
 }