Bind Android ChildProcessServices to a specific client PID.

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.ComponentName;
 import android.content.Context;
 import android.content.pm.ApplicationInfo;
 import android.content.pm.PackageManager;
+import android.os.AsyncTask;
 import android.os.Bundle;
 import android.os.ParcelFileDescriptor;
 import android.os.RemoteException;
 import android.text.TextUtils;
 import android.view.Surface;
 
 import org.chromium.base.CommandLine;
 import org.chromium.base.CpuFeatures;
 import org.chromium.base.Log;
 import org.chromium.base.ThreadUtils;
@@ skipping 385 matching lines @@
                                             linker.getTestRunnerClassNameForTesting(),
                                             linker.getImplementationForTesting());
         } else {
             return new ChromiumLinkerParams(sLinkerLoadAddress,
                                             waitForSharedRelros);
         }
     }
 
     private static ChildProcessConnection allocateBoundConnection(Context context,
             String[] commandLine, boolean inSandbox, boolean alwaysInForeground,
-            ChildProcessCreationParams creationParams) {
+            ChildProcessCreationParams creationParams,
+            ChildProcessConnection.StartCallback startCallback) {
         ChromiumLinkerParams chromiumLinkerParams = getLinkerParamsForNewConnection();
         ChildProcessConnection connection = allocateConnection(
                 context, inSandbox, chromiumLinkerParams, alwaysInForeground, creationParams);
         if (connection != null) {
-            connection.start(commandLine);
+            connection.start(commandLine, startCallback);
 
             String packageName = creationParams != null ? creationParams.getPackageName()
                     : context.getPackageName();
             if (inSandbox && !getConnectionAllocator(packageName, inSandbox)
                     .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.
                 sBindingManager.releaseAllModerateBindings();
             }
         }
         return connection;
     }
 
     private static final long FREE_CONNECTION_DELAY_MILLIS = 1;
 
     private static void freeConnection(ChildProcessConnection connection) {
-        synchronized (ChildProcessLauncher.class) {
+        synchronized (sSpareConnectionLock) {
             if (connection.equals(sSpareSandboxedConnection)) sSpareSandboxedConnection = null;
         }
 
         // 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;
         ThreadUtils.postOnUiThreadDelayed(new Runnable() {
@@ skipping 26 matching lines @@
         }
     }
 
     // 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>();
 
+    // Lock and monitor for these members {{{
+    private static final Object sSpareConnectionLock = new Object();
     // A pre-allocated and pre-bound connection ready for connection setup, or null.
     private static ChildProcessConnection sSpareSandboxedConnection;
+    // If sSpareSandboxedConnection is not null, this indicates whether the service is
+    // ready for connection setup. Wait on the monitor lock to be notified when this
+    // state changes. sSpareSandboxedConnection may be null after waiting, if starting
+    // the service failed.
+    private static boolean sSpareConnectionStarting;
+    // }}}
 
     // Manages oom bindings used to bind chind services.
     private static BindingManager sBindingManager = BindingManagerImpl.createBindingManager();
 
     // Whether the main application is currently brought to the foreground.
     private static boolean sApplicationInForeground = true;
 
     @VisibleForTesting
     public static void setBindingManagerForTesting(BindingManager manager) {
         sBindingManager = manager;
@@ skipping 62 matching lines @@
         return sApplicationInForeground;
     }
 
     /**
      * Should be called early in startup so the work needed to spawn the child process can be done
      * in parallel to other startup work. Must not be called on the UI thread. Spare connection is
      * created in sandboxed child process.
      * @param context the application context used for the connection.
      */
     public static void warmUp(Context context) {
-        synchronized (ChildProcessLauncher.class) {
+        synchronized (sSpareConnectionLock) {
             assert !ThreadUtils.runningOnUiThread();
             if (sSpareSandboxedConnection == null) {
                 ChildProcessCreationParams params = ChildProcessCreationParams.get();
                 if (params != null) {
                     params = params.copy();
                 }
+

[Tobias Sargeant, 2017/01/14 23:24:58]

Presumably the fact that warmUp doesn't retry means that in second and
subsequent browser processes, warmUp will be non-functional?

[Robert Sesek, 2017/01/17 19:51:22]

Since warmUp is only used for the first connection, there's no point in
re-trying it if it fails.

+                sSpareConnectionStarting = true;
+
+                ChildProcessConnection.StartCallback startCallback =
+                        new ChildProcessConnection.StartCallback() {
+                            @Override
+                            public void onChildStarted() {
+                                synchronized (sSpareConnectionLock) {
+                                    sSpareConnectionStarting = false;
+                                    sSpareConnectionLock.notify();
+                                }
+                            }
+
+                            @Override
+                            public void onChildStartFailed() {
+                                Log.e(TAG, "Failed to warm up the spare sandbox service");
+                                synchronized (sSpareConnectionLock) {
+                                    sSpareSandboxedConnection = null;
+                                    sSpareConnectionStarting = false;
+                                    sSpareConnectionLock.notify();
+                                }
+                            }
+                        };
                 sSpareSandboxedConnection = allocateBoundConnection(context, null, true, false,
-                        params);
+                        params, startCallback);
             }
         }
     }
 
     @CalledByNative
     private static FileDescriptorInfo makeFdInfo(
             int id, int fd, boolean autoClose, long offset, long size) {
         ParcelFileDescriptor pFd;
         if (autoClose) {
             // Adopt the FD, it will be closed when we close the ParcelFileDescriptor.
@@ skipping 58 matching lines @@
             } else {
                 assert false;
             }
         }
 
         startInternal(context, commandLine, childProcessId, filesToBeMapped, clientContext,
                 callbackType, inSandbox, params);
     }
 
     private static void startInternal(
-            Context context,
+            final Context context,
             final String[] commandLine,
-            int childProcessId,
-            FileDescriptorInfo[] filesToBeMapped,
-            long clientContext,
-            int callbackType,
-            boolean inSandbox,
-            ChildProcessCreationParams creationParams) {
+            final int childProcessId,
+            final FileDescriptorInfo[] filesToBeMapped,
+            final long clientContext,
+            final int callbackType,
+            final boolean inSandbox,
+            final ChildProcessCreationParams creationParams) {
         try {
             TraceEvent.begin("ChildProcessLauncher.startInternal");
 
             ChildProcessConnection allocatedConnection = null;
             String packageName = creationParams != null ? creationParams.getPackageName()
                     : context.getPackageName();
-            synchronized (ChildProcessLauncher.class) {
+            synchronized (sSpareConnectionLock) {
                 if (inSandbox && sSpareSandboxedConnection != null
                         && sSpareSandboxedConnection.getPackageName().equals(packageName)) {
+                    while (sSpareConnectionStarting) {
+                        try {
+                            sSpareConnectionLock.wait();
+                        } catch (InterruptedException ex) {
+                        }
+                    }
                     allocatedConnection = sSpareSandboxedConnection;
                     sSpareSandboxedConnection = null;
                 }
             }
             if (allocatedConnection == null) {
                 boolean alwaysInForeground = false;
                 if (callbackType == CALLBACK_FOR_GPU_PROCESS) alwaysInForeground = true;
                 PendingSpawnQueue pendingSpawnQueue = getPendingSpawnQueue(
                         context, packageName, inSandbox);
+                ChildProcessConnection.StartCallback startCallback =
+                        new ChildProcessConnection.StartCallback() {
+                            @Override
+                            public void onChildStarted() {}
+
+                            @Override
+                            public void onChildStartFailed() {
+                                Log.e(TAG, "ChildProcessConnection.start failed, trying again");
+                                new AsyncTask<Void, Void, Void>() {

[Torne, 2017/01/16 12:44:43]

If the asynctask only has a doInBackground and is void, you can just pass a
Runnable to the execute() method of the executor, which looks a bit neater. The
AsyncTask machinery is only useful for the case where you pass a result back to
the UI thread.

[Robert Sesek, 2017/01/17 19:51:22]

Done.

+                                    @Override
+                                    protected Void doInBackground(Void... params) {
+                                        startInternal(context, commandLine, childProcessId,
+                                                filesToBeMapped, clientContext, callbackType,
+                                                inSandbox, creationParams);
+                                        return null;
+                                    }
+                                }.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
+                            }
+                        };
                 synchronized (pendingSpawnQueue.mPendingSpawnsLock) {
                     allocatedConnection = allocateBoundConnection(
-                            context, commandLine, inSandbox, alwaysInForeground, creationParams);
+                            context, commandLine, inSandbox, alwaysInForeground, creationParams,
+                            startCallback);
                     if (allocatedConnection == null) {
                         Log.d(TAG, "Allocation of new service failed. Queuing up pending spawn.");
                         pendingSpawnQueue.enqueueLocked(new PendingSpawnData(context, commandLine,
                                 childProcessId, filesToBeMapped, clientContext,
                                 callbackType, inSandbox, creationParams));
                         return;
                     }
                 }
             }
 
             Log.d(TAG, "Setting up connection to process: slot=%d",
                     allocatedConnection.getServiceNumber());
             triggerConnectionSetup(allocatedConnection, commandLine, childProcessId,

[Tobias Sargeant, 2017/01/14 23:24:57]

I'm not sure that I understand this code, but in the case where we have to
retry, won't each call to startInternal reach here and call
triggerConnectionSetup with whatever allocatedConnection is (whether or not it
was claimed)?

[Torne, 2017/01/16 12:44:43]

I think it will have early returned on line 750 above because
allocatedConnection is still null? Not sure..

[Robert Sesek, 2017/01/17 19:51:22]

Right. allocatedConnection will be null so it will allocateBoundConnection() a
new one.

                     filesToBeMapped, callbackType, clientContext);
         } 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.
@@ skipping 120 matching lines @@
     static void logPidWarning(int pid, String message) {
         // This class is effectively a no-op in single process mode, so don't log warnings there.
         if (pid > 0 && !nativeIsSingleProcess()) {
             Log.w(TAG, "%s, pid=%d", message, pid);
         }
     }
 
     @VisibleForTesting
     static ChildProcessConnection allocateBoundConnectionForTesting(Context context,
             ChildProcessCreationParams creationParams) {
-        return allocateBoundConnection(context, null, true, false, creationParams);
+        return allocateBoundConnection(context, null, true, false, creationParams, null);
     }
 
     @VisibleForTesting
     static ChildProcessConnection allocateConnectionForTesting(Context context,
             ChildProcessCreationParams creationParams) {
         return allocateConnection(
                 context, true, getLinkerParamsForNewConnection(), false, creationParams);
     }
 
     /**
@@ skipping 63 matching lines @@
     }
 
     private static native void nativeOnChildProcessStarted(long clientContext, int pid);
     private static native void nativeEstablishSurfacePeer(
             int pid, Surface surface, int primaryID, int secondaryID);
     private static native void nativeCompleteScopedSurfaceRequest(
             UnguessableToken requestToken, Surface surface);
     private static native boolean nativeIsSingleProcess();
     private static native Surface nativeGetViewSurface(int surfaceId);
 }