Upstream: Renderers are running in WebAPKs.

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.annotation.SuppressLint;
+import android.app.Service;
 import android.content.Context;
 import android.content.Intent;
 import android.content.pm.ApplicationInfo;
 import android.content.pm.PackageManager;
 import android.graphics.SurfaceTexture;
 import android.os.Build;
 import android.os.Bundle;
 import android.os.ParcelFileDescriptor;
 import android.os.RemoteException;
 import android.text.TextUtils;
 import android.util.Pair;
 import android.view.Surface;
 
 import org.chromium.base.CommandLine;
 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.annotations.CalledByNative;
 import org.chromium.base.annotations.JNINamespace;
 import org.chromium.base.library_loader.Linker;
-import org.chromium.content.app.ChildProcessService;
 import org.chromium.content.app.ChromiumLinkerParams;
 import org.chromium.content.app.DownloadProcessService;
 import org.chromium.content.app.PrivilegedProcessService;
 import org.chromium.content.app.SandboxedProcessService;
 import org.chromium.content.common.ContentSwitches;
 import org.chromium.content.common.IChildProcessCallback;
 import org.chromium.content.common.SurfaceWrapper;
 
 import java.io.IOException;
 import java.util.ArrayList;
@@ skipping 17 matching lines @@
 
     private static class ChildConnectionAllocator {
         // Connections to services. Indices of the array correspond to the service numbers.
         private final ChildProcessConnection[] mChildProcessConnections;
 
         // The list of free (not bound) service indices.
         // SHOULD BE ACCESSED WITH mConnectionLock.
         private final ArrayList<Integer> mFreeConnectionIndices;
         private final Object mConnectionLock = new Object();
 
-        private Class<? extends ChildProcessService> mChildClass;
+        private Class<? extends Service> mChildClass;
         private final boolean mInSandbox;
         // 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 PendingSpawnQueue mPendingSpawnQueue = new PendingSpawnQueue();
 
-        public ChildConnectionAllocator(boolean inSandbox, int numChildServices) {
+        public ChildConnectionAllocator(boolean inSandbox, int numChildServices,
+                Class<? extends Service> serviceName) {

[pkotwicz, 2016/06/15 14:13:51]

Does {@link serviceName} need to be passed into the ChildConnectionAllocator
constructor given that ChildProcessCreationParams are passed into
ChildConnectionAllocator#allocate()?

The child class can be determined based on ChildConnectionAllocator#mInSandbox
and ChildProcessCreationParams in ChildConnectionAllocator#allocate()

[Xi Han, 2016/06/15 17:10:40]

I understand why you suggest this, but I am feeling bad to keep a wrong Service
class in the Allocator. How about remove the |mServiceClass| in the
|ChildProcessAllocator| and always use a new added getServiceClass() function?

[pkotwicz, 2016/06/15 17:51:00]

I agree, it is good to remove ChildConnectionAllocator#mChildClass

I was thinking of determining which service class to use inline in
ChildConnectionAllocator#allocate() but adding the
ChildConnectionAllocator#getServiceClass() function is OK too.

             mChildProcessConnections = new ChildProcessConnectionImpl[numChildServices];
             mFreeConnectionIndices = new ArrayList<Integer>(numChildServices);
             for (int i = 0; i < numChildServices; i++) {
                 mFreeConnectionIndices.add(i);
             }
-            mChildClass =
-                    inSandbox ? SandboxedProcessService.class : PrivilegedProcessService.class;
+            if (serviceName == null) {
+                mChildClass = inSandbox ? SandboxedProcessService.class
+                        : PrivilegedProcessService.class;
+            } else {
+                mChildClass = serviceName;
+            }
             mInSandbox = inSandbox;
         }
 
         public ChildProcessConnection allocate(
                 Context context, ChildProcessConnection.DeathCallback deathCallback,
                 ChromiumLinkerParams chromiumLinkerParams,
                 boolean alwaysInForeground,
                 ChildProcessCreationParams creationParams) {
             synchronized (mConnectionLock) {
                 if (mFreeConnectionIndices.isEmpty()) {
@@ skipping 174 matching lines @@
             if (numServices < 0) {
                 throw new RuntimeException("Illegal meta data value for number of child services");
             }
             return numServices;
         } catch (PackageManager.NameNotFoundException e) {
             throw new RuntimeException("Could not get application info");
         }
     }
 
     private static void initConnectionAllocatorsIfNecessary(
-            Context context, boolean inSandbox, String packageName) {
+            Context context, boolean inSandbox, String packageName,
+            Class<? extends Service> serviceName) {
         // TODO(mariakhomenko): Uses an Object to lock the access.
         synchronized (ChildProcessLauncher.class) {
             if (inSandbox) {
                 if (sSandboxedChildConnectionAllocatorMap == null) {
                     sSandboxedChildConnectionAllocatorMap =
                             new ConcurrentHashMap<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)));
+                                    getNumberOfServices(context, true, packageName), serviceName));
                 }
             } else if (sPrivilegedChildConnectionAllocator == null) {
                 sPrivilegedChildConnectionAllocator = new ChildConnectionAllocator(
-                        false, getNumberOfServices(context, false, packageName));
+                        false, getNumberOfServices(context, false, packageName), null);
             }
             // TODO(pkotwicz|hanxi): Figure out when old allocators should be removed from
             // {@code sSandboxedChildConnectionAllocatorMap}.
         }
     }
 
     /**
      * Note: please make sure that the Allocator has been initialized before calling this function.
      * Otherwise, always calls {@link initConnectionAllocatorsIfNecessary} first.
      */
     private static ChildConnectionAllocator getConnectionAllocator(
             String packageName, boolean inSandbox) {
         if (!inSandbox) {
             return sPrivilegedChildConnectionAllocator;
         }
         return sSandboxedChildConnectionAllocatorMap.get(packageName);
     }
 
     /**
      * Get the PendingSpawnQueue of the Allocator. Initialize the Allocator if needed.
      */
     private static PendingSpawnQueue getPendingSpawnQueue(Context context, String packageName,
-            boolean inSandbox) {
-        initConnectionAllocatorsIfNecessary(context, inSandbox, packageName);
+            boolean inSandbox, Class<? extends Service> serviceName) {
+        initConnectionAllocatorsIfNecessary(context, inSandbox, packageName, serviceName);
         return getConnectionAllocator(packageName, inSandbox).getPendingSpawnQueue();
     }
 
     private static ChildProcessConnection allocateConnection(Context context, boolean inSandbox,
             ChromiumLinkerParams chromiumLinkerParams, boolean alwaysInForeground,
             ChildProcessCreationParams creationParams) {
         ChildProcessConnection.DeathCallback deathCallback =
                 new ChildProcessConnection.DeathCallback() {
                     @Override
                     public void onChildProcessDied(ChildProcessConnection connection) {
                         if (connection.getPid() != 0) {
                             stop(connection.getPid());
                         } else {
                             freeConnection(connection);
                         }
                     }
                 };
         String packageName = creationParams != null ? creationParams.getPackageName()
                 : context.getPackageName();
-        initConnectionAllocatorsIfNecessary(context, inSandbox, packageName);
-        return getConnectionAllocator(packageName, inSandbox)
-                .allocate(context, deathCallback, chromiumLinkerParams, alwaysInForeground,
-                        creationParams);
+        Class<? extends Service> serviceName = creationParams != null
+                ? creationParams.getServiceName() : null;
+        initConnectionAllocatorsIfNecessary(context, inSandbox, packageName, serviceName);
+        return getConnectionAllocator(packageName, inSandbox).allocate(
+                context, deathCallback, chromiumLinkerParams, alwaysInForeground,
+                creationParams);
     }
 
     private static boolean sLinkerInitialized = false;
     private static long sLinkerLoadAddress = 0;
 
     private static ChromiumLinkerParams getLinkerParamsForNewConnection() {
         if (!sLinkerInitialized) {
             if (Linker.isUsed()) {
                 sLinkerLoadAddress = Linker.getInstance().getBaseLoadAddress();
                 if (sLinkerLoadAddress == 0) {
@@ skipping 371 matching lines @@
             synchronized (ChildProcessLauncher.class) {
                 if (inSandbox && sSpareSandboxedConnection != null
                         && sSpareSandboxedConnection.getPackageName().equals(packageName)) {
                     allocatedConnection = sSpareSandboxedConnection;
                     sSpareSandboxedConnection = null;
                 }
             }
             if (allocatedConnection == null) {
                 boolean alwaysInForeground = false;
                 if (callbackType == CALLBACK_FOR_GPU_PROCESS) alwaysInForeground = true;
+                Class<? extends Service> serviceName = creationParams != null
+                        ? creationParams.getServiceName() : null;
                 PendingSpawnQueue pendingSpawnQueue = getPendingSpawnQueue(
-                        context, packageName, inSandbox);
+                        context, packageName, inSandbox, serviceName);
                 synchronized (pendingSpawnQueue.mPendingSpawnsLock) {
                     allocatedConnection = allocateBoundConnection(
                             context, commandLine, inSandbox, alwaysInForeground, creationParams);
                     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;
                     }
@@ skipping 175 matching lines @@
             ChildProcessCreationParams creationParams) {
         return allocateBoundConnection(context, null, true, false, creationParams);
     }
 
     /**
      * Queue up a spawn requests for testing.
      */
     @VisibleForTesting
     static void enqueuePendingSpawnForTesting(Context context, String[] commandLine,
             ChildProcessCreationParams creationParams, boolean inSandbox) {
+        String packageName = creationParams != null ? creationParams.getPackageName()
+                : context.getPackageName();
+        Class<? extends Service> serviceName = creationParams != null
+                ? creationParams.getServiceName() : null;
         PendingSpawnQueue pendingSpawnQueue = getPendingSpawnQueue(context,
-                creationParams.getPackageName(), inSandbox);
+                packageName, inSandbox, serviceName);
         synchronized (pendingSpawnQueue.mPendingSpawnsLock) {
             pendingSpawnQueue.enqueueLocked(new PendingSpawnData(context, commandLine, 1,
                     new FileDescriptorInfo[0], 0, CALLBACK_FOR_RENDERER_PROCESS, true,
                     creationParams));
         }
     }
 
     /**
      * @return the number of sandboxed connections of given {@link packageName} managed by the
      * allocator.
      */
     @VisibleForTesting
     static int allocatedSandboxedConnectionsCountForTesting(Context context, String packageName) {
-        initConnectionAllocatorsIfNecessary(context, true, packageName);
+        initConnectionAllocatorsIfNecessary(context, true, packageName, null);
         return sSandboxedChildConnectionAllocatorMap.get(packageName)
                 .allocatedConnectionsCountForTesting();
     }
 
     /** @return the count of services set up and working */
     @VisibleForTesting
     static int connectedServicesCountForTesting() {
         return sServiceMap.size();
     }
 
     /**
      * @param context The context.
      * @param packageName The package name of the {@link ChildProcessAlocator}.
      * @param inSandbox Whether the connection is sandboxed.
      * @return the count of pending spawns in the queue.
      */
     @VisibleForTesting
     static int pendingSpawnsCountForTesting(Context context, String packageName,
             boolean inSandbox) {
-        PendingSpawnQueue pendingSpawnQueue = getPendingSpawnQueue(context, packageName, inSandbox);
+        PendingSpawnQueue pendingSpawnQueue = getPendingSpawnQueue(context, packageName, inSandbox,
+                null);
         synchronized (pendingSpawnQueue.mPendingSpawnsLock) {
             return pendingSpawnQueue.sizeLocked();
         }
     }
 
     /**
      * 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();
         } catch (RemoteException ex) {
             return false;
         }
 
         return true;
     }
 
     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 boolean nativeIsSingleProcess();
 }