Upstream: ChildProcessLauncher connects renderer processes of 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.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.LibraryProcessType;
 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;
+import java.util.HashMap;
 import java.util.LinkedList;
 import java.util.Map;
 import java.util.Queue;
 import java.util.concurrent.ConcurrentHashMap;
 
 /**
  * This class provides the method to start/stop ChildProcess called by native.
  */
 @JNINamespace("content")
 public class ChildProcessLauncher {
@@ skipping 67 matching lines @@
                 }
             }
         }
 
         public boolean isFreeConnectionAvailable() {
             synchronized (mConnectionLock) {
                 return !mFreeConnectionIndices.isEmpty();
             }
         }
 
-        /** @return the count of connections managed by the allocator */
+        /** Returns the count of connections managed by the allocator */
         @VisibleForTesting
         int allocatedConnectionsCountForTesting() {
             return mChildProcessConnections.length - mFreeConnectionIndices.size();
         }
     }
 
     private static class PendingSpawnData {
         private final Context mContext;
         private final String[] mCommandLine;
         private final int mChildProcessId;
@@ skipping 60 matching lines @@
 
         /**
          * Pop the next request from the queue. Called when a free service is available.
          * @return the next spawn request waiting in the queue.
          */
         public PendingSpawnData dequeueLocked() {
             assert Thread.holdsLock(sPendingSpawnsLock);
             return sPendingSpawns.poll();
         }
 
-        /** @return the count of pending spawns in the queue */
+        /** Returns the count of pending spawns in the queue */
         public int sizeLocked() {
             assert Thread.holdsLock(sPendingSpawnsLock);
             return sPendingSpawns.size();
         }
     }
 
     private static final PendingSpawnQueue sPendingSpawnQueue = new PendingSpawnQueue();
 
-    // Service class for child process. As the default value it uses SandboxedProcessService0 and
-    // PrivilegedProcessService0.
-    private static ChildConnectionAllocator sSandboxedChildConnectionAllocator;
+    // Service class for child process.
+    // Map from package name to ChildConnectionAllocator;
+    private static Map<String, ChildConnectionAllocator> sSandboxedChildConnectionAllocatorMap;
+    // As the default value it uses PrivilegedProcessService0.
     private static ChildConnectionAllocator sPrivilegedChildConnectionAllocator;
 
     private static final String NUM_SANDBOXED_SERVICES_KEY =
             "org.chromium.content.browser.NUM_SANDBOXED_SERVICES";
     private static final String NUM_PRIVILEGED_SERVICES_KEY =
             "org.chromium.content.browser.NUM_PRIVILEGED_SERVICES";
     // Overrides the number of available sandboxed services.
     @VisibleForTesting
     public static final String SWITCH_NUM_SANDBOXED_SERVICES_FOR_TESTING = "num-sandboxed-services";
 
-    private static int getNumberOfServices(Context context, boolean inSandbox) {
+    private static int getNumberOfServices(Context context, boolean inSandbox, String packageName) {
         try {
             PackageManager packageManager = context.getPackageManager();
-            ChildProcessCreationParams childProcessCreationParams =
-                    ChildProcessCreationParams.get();
-            final String packageName = childProcessCreationParams != null
-                    ? childProcessCreationParams.getPackageName() : context.getPackageName();
             ApplicationInfo appInfo = packageManager.getApplicationInfo(packageName,
                     PackageManager.GET_META_DATA);
-            int numServices = appInfo.metaData.getInt(inSandbox ? NUM_SANDBOXED_SERVICES_KEY
-                    : NUM_PRIVILEGED_SERVICES_KEY, -1);
+            int numServices = -1;
+            if (appInfo.metaData != null) {
+                numServices = appInfo.metaData.getInt(
+                        inSandbox ? NUM_SANDBOXED_SERVICES_KEY : NUM_PRIVILEGED_SERVICES_KEY, -1);
+            }
             if (inSandbox
                     && CommandLine.getInstance().hasSwitch(
                                SWITCH_NUM_SANDBOXED_SERVICES_FOR_TESTING)) {
                 String value = CommandLine.getInstance().getSwitchValue(
                         SWITCH_NUM_SANDBOXED_SERVICES_FOR_TESTING);
                 if (!TextUtils.isEmpty(value)) {
                     try {
                         numServices = Integer.parseInt(value);
                     } catch (NumberFormatException e) {
                         Log.w(TAG, "The value of --num-sandboxed-services is formatted wrongly: "
                                         + value);
                     }
                 }
             }
             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) {
+    private static void initConnectionAllocatorsIfNecessary(
+            Context context, boolean inSandbox, String packageName) {
         synchronized (ChildProcessLauncher.class) {
-            if (sSandboxedChildConnectionAllocator == null) {
-                sSandboxedChildConnectionAllocator =
-                        new ChildConnectionAllocator(true, getNumberOfServices(context, true));
+            if (inSandbox) {
+                if (sSandboxedChildConnectionAllocatorMap == null) {
+                    sSandboxedChildConnectionAllocatorMap =
+                            new HashMap<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,
+                                                                       inSandbox, packageName)));
+                }
+            } else if (sPrivilegedChildConnectionAllocator == null) {
+                sPrivilegedChildConnectionAllocator = new ChildConnectionAllocator(
+                        false, getNumberOfServices(context, false, packageName));
             }
-            if (sPrivilegedChildConnectionAllocator == null) {
-                sPrivilegedChildConnectionAllocator =
-                        new ChildConnectionAllocator(false, getNumberOfServices(context, false));
-            }
+            // TODO(pkotwicz|hanxi): Figure out when old allocators should be removed from
+            // {@code sSandboxedChildConnectionAllocatorMap}.
         }
     }
 
-    private static ChildConnectionAllocator getConnectionAllocator(boolean inSandbox) {
-        return inSandbox
-                ? sSandboxedChildConnectionAllocator : sPrivilegedChildConnectionAllocator;
+    private static ChildConnectionAllocator getConnectionAllocator(
+            String packageName, boolean inSandbox) {
+        if (!inSandbox) {
+            return sPrivilegedChildConnectionAllocator;
+        }
+        return sSandboxedChildConnectionAllocatorMap.get(packageName);
     }
 
     private static ChildProcessConnection allocateConnection(Context context, boolean inSandbox,
-            ChromiumLinkerParams chromiumLinkerParams, boolean alwaysInForeground) {
+            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);
                         }
                     }
                 };
-        initConnectionAllocatorsIfNecessary(context);
-        return getConnectionAllocator(inSandbox).allocate(context, deathCallback,
-                chromiumLinkerParams, alwaysInForeground, ChildProcessCreationParams.get());
+        String packageName = creationParams.getPackageName();
+        initConnectionAllocatorsIfNecessary(context, inSandbox, packageName);
+        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 13 matching lines @@
                                             waitForSharedRelros,
                                             linker.getTestRunnerClassNameForTesting(),
                                             linker.getImplementationForTesting());
         } else {
             return new ChromiumLinkerParams(sLinkerLoadAddress,
                                             waitForSharedRelros);
         }
     }
 
     private static ChildProcessConnection allocateBoundConnection(Context context,
-            String[] commandLine, boolean inSandbox, boolean alwaysInForeground) {
+            String[] commandLine, boolean inSandbox, boolean alwaysInForeground,
+            ChildProcessCreationParams creationParams) {
         ChromiumLinkerParams chromiumLinkerParams = getLinkerParamsForNewConnection();
-        ChildProcessConnection connection = allocateConnection(context, inSandbox,
-                chromiumLinkerParams, alwaysInForeground);
+        ChildProcessConnection connection = allocateConnection(
+                context, inSandbox, chromiumLinkerParams, alwaysInForeground, creationParams);
         if (connection != null) {
             connection.start(commandLine);
 
-            if (inSandbox && !sSandboxedChildConnectionAllocator.isFreeConnectionAvailable()) {
+            if (inSandbox
+                    && !sSandboxedChildConnectionAllocatorMap.get(creationParams.getPackageName())
+                                .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;
@@ skipping 13 matching lines @@
             @Override
             public void run() {
                 final PendingSpawnData pendingSpawn = freeConnectionAndDequeuePending(conn);
                 if (pendingSpawn != null) {
                     new Thread(new Runnable() {
                         @Override
                         public void run() {
                             startInternal(pendingSpawn.context(), pendingSpawn.commandLine(),
                                     pendingSpawn.childProcessId(), pendingSpawn.filesToBeMapped(),
                                     pendingSpawn.clientContext(), pendingSpawn.callbackType(),
-                                    pendingSpawn.inSandbox());
+                                    pendingSpawn.inSandbox(), conn.getCreationParams());
                         }
                     }).start();
                 }
             }
         }, FREE_CONNECTION_DELAY_MILLIS);
     }
 
     private static PendingSpawnData freeConnectionAndDequeuePending(ChildProcessConnection conn) {
         synchronized (PendingSpawnQueue.sPendingSpawnsLock) {
-            getConnectionAllocator(conn.isInSandbox()).free(conn);
+            getConnectionAllocator(conn.getCreationParams().getPackageName(), conn.isInSandbox())
+                    .free(conn);
             return sPendingSpawnQueue.dequeueLocked();
         }
     }
 
     // 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>();
@@ skipping 13 matching lines @@
             new ConcurrentHashMap<Pair<Integer, Integer>, Surface>();
 
     // Whether the main application is currently brought to the foreground.
     private static boolean sApplicationInForeground = true;
 
     @VisibleForTesting
     public static void setBindingManagerForTesting(BindingManager manager) {
         sBindingManager = manager;
     }
 
-    /** @return true iff the child process is protected from out-of-memory killing */
+    /** Returns true iff the child process is protected from out-of-memory killing */
     @CalledByNative
     private static boolean isOomProtected(int pid) {
         return sBindingManager.isOomProtected(pid);
     }
 
     @CalledByNative
     private static void registerViewSurface(int surfaceId, Surface surface) {
         if (!surface.isValid())
             throw new RuntimeException("Attempting to register invalid Surface.");
         sViewSurfaceMap.put(surfaceId, surface);
@@ skipping 85 matching lines @@
 
     /**
      * Starts moderate binding management.
      * @param context Android's context.
      * @param moderateBindingTillBackgrounded true if the BindingManager should add a moderate
      * binding to a render process when it is created and remove the moderate binding when Chrome is
      * sent to the background.
      */
     public static void startModerateBindingManagement(
             Context context, boolean moderateBindingTillBackgrounded) {
-        sBindingManager.startModerateBindingManagement(
-                context, getNumberOfServices(context, true), moderateBindingTillBackgrounded);
+        sBindingManager.startModerateBindingManagement(context,
+                getNumberOfServices(context, true, context.getPackageName()),
+                moderateBindingTillBackgrounded);
     }
 
     /**
      * Called when the embedding application is brought to foreground.
      */
     public static void onBroughtToForeground() {
         sApplicationInForeground = true;
         sBindingManager.onBroughtToForeground();
     }
 
     /**
      * Returns whether the application is currently in the foreground.
      */
     static boolean isApplicationInForeground() {
         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.
-     * @param params child process creation params.
      */
-    public static void warmUp(Context context, ChildProcessCreationParams params) {
-        ChildProcessCreationParams.set(params);
+    public static void warmUp(Context context) {
         synchronized (ChildProcessLauncher.class) {
             assert !ThreadUtils.runningOnUiThread();
             if (sSpareSandboxedConnection == null) {
-                sSpareSandboxedConnection = allocateBoundConnection(context, null, true, false);
+                sSpareSandboxedConnection = allocateBoundConnection(context, null, true, false,
+                      ChildProcessCreationParams.get().clone());
             }
         }
     }
 
     @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 22 matching lines @@
      */
     @CalledByNative
     private static void start(Context context, final String[] commandLine, int childProcessId,
             FileDescriptorInfo[] filesToBeMapped, long clientContext) {
         assert clientContext != 0;
 
         int callbackType = CALLBACK_FOR_UNKNOWN_PROCESS;
         boolean inSandbox = true;
         String processType =
                 ContentSwitches.getSwitchValue(commandLine, ContentSwitches.SWITCH_PROCESS_TYPE);
+        ChildProcessCreationParams params = ChildProcessCreationParams.get().clone();
         if (ContentSwitches.SWITCH_RENDERER_PROCESS.equals(processType)) {
             callbackType = CALLBACK_FOR_RENDERER_PROCESS;
         } else if (ContentSwitches.SWITCH_GPU_PROCESS.equals(processType)) {
             callbackType = CALLBACK_FOR_GPU_PROCESS;
             inSandbox = false;
+            // For GPU process, always set the Chrome's package name.
+            params = new ChildProcessCreationParams(
+                    context.getPackageName(), 0, LibraryProcessType.PROCESS_CHILD);
         } else if (ContentSwitches.SWITCH_UTILITY_PROCESS.equals(processType)) {
             // We only support sandboxed right now.
             callbackType = CALLBACK_FOR_UTILITY_PROCESS;
         } else {
             assert false;
         }
 
         startInternal(context, commandLine, childProcessId, filesToBeMapped, clientContext,
-                callbackType, inSandbox);
+                callbackType, inSandbox, params);
     }
 
     /**
      * Spawns a background download process if it hasn't been started. The download process will
      * manage its own lifecyle and can outlive chrome.
      *
      * @param context Context used to obtain the application context.
      * @param commandLine The child process command line argv.
      */
     @SuppressLint("NewApi")
@@ skipping 22 matching lines @@
         context.startService(intent);
     }
 
     private static void startInternal(
             Context context,
             final String[] commandLine,
             int childProcessId,
             FileDescriptorInfo[] filesToBeMapped,
             long clientContext,
             int callbackType,
-            boolean inSandbox) {
+            boolean inSandbox,
+            ChildProcessCreationParams creationParams) {
         try {
             TraceEvent.begin("ChildProcessLauncher.startInternal");
 
             ChildProcessConnection allocatedConnection = null;
             synchronized (ChildProcessLauncher.class) {
                 if (inSandbox) {
                     allocatedConnection = sSpareSandboxedConnection;
                     sSpareSandboxedConnection = null;
                 }
             }
             if (allocatedConnection == null) {
                 boolean alwaysInForeground = false;
                 if (callbackType == CALLBACK_FOR_GPU_PROCESS) alwaysInForeground = true;
                 synchronized (PendingSpawnQueue.sPendingSpawnsLock) {
                     allocatedConnection = allocateBoundConnection(
-                            context, commandLine, inSandbox, alwaysInForeground);
+                            context, commandLine, inSandbox, alwaysInForeground, creationParams);
                     if (allocatedConnection == null) {
                         Log.d(TAG, "Allocation of new service failed. Queuing up pending spawn.");
                         sPendingSpawnQueue.enqueueLocked(new PendingSpawnData(context, commandLine,
                                 childProcessId, filesToBeMapped, clientContext,
                                 callbackType, inSandbox));
                         return;
                     }
                 }
             }
 
@@ skipping 161 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) {
-        return allocateBoundConnection(context, null, true, false);
+    static ChildProcessConnection allocateBoundConnectionForTesting(Context context,
+            ChildProcessCreationParams creationParams) {
+        return allocateBoundConnection(context, null, true, false, creationParams);
     }
 
     /**
      * Queue up a spawn requests for testing.
      */
     @VisibleForTesting
     static void enqueuePendingSpawnForTesting(Context context, String[] commandLine) {
         synchronized (PendingSpawnQueue.sPendingSpawnsLock) {
             sPendingSpawnQueue.enqueueLocked(new PendingSpawnData(context, commandLine, 1,
                     new FileDescriptorInfo[0], 0, CALLBACK_FOR_RENDERER_PROCESS, true));
         }
     }
 
-    /** @return the count of sandboxed connections managed by the allocator */
+    /**
+     * Returns the number of sandboxed connections of given {@link packageName} managed by the
+     * allocator.
+     */
     @VisibleForTesting
-    static int allocatedConnectionsCountForTesting(Context context) {
-        initConnectionAllocatorsIfNecessary(context);
-        return sSandboxedChildConnectionAllocator.allocatedConnectionsCountForTesting();
+    static int allocatedSandboxedConnectionsCountForTesting(Context context, String packageName) {
+        initConnectionAllocatorsIfNecessary(context, true, packageName);
+        return sSandboxedChildConnectionAllocatorMap.get(packageName)
+                .allocatedConnectionsCountForTesting();
     }
 
-    /** @return the count of services set up and working */
+    /** Returns the count of services set up and working */
     @VisibleForTesting
     static int connectedServicesCountForTesting() {
         return sServiceMap.size();
     }
 
-    /** @return the count of pending spawns in the queue */
+    /** Returns the count of pending spawns in the queue */
     @VisibleForTesting
     static int pendingSpawnsCountForTesting() {
         synchronized (PendingSpawnQueue.sPendingSpawnsLock) {
             return sPendingSpawnQueue.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();
 }