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 final 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> serviceClass) {
             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;
+            mChildClass = serviceClass;
             mInSandbox = inSandbox;
         }
 
         public ChildProcessConnection allocate(
                 Context context, ChildProcessConnection.DeathCallback deathCallback,
                 ChromiumLinkerParams chromiumLinkerParams,
                 boolean alwaysInForeground,
                 ChildProcessCreationParams creationParams) {
             synchronized (mConnectionLock) {
                 if (mFreeConnectionIndices.isEmpty()) {
@@ skipping 136 matching lines @@
     // 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";
+    private static final String SANDBOXED_SERVICES_NAME_KEY =
+            "org.chromium.content.browser.SANDBOXED_SERVICES_NAME";
     // Overrides the number of available sandboxed services.
     @VisibleForTesting
     public static final String SWITCH_NUM_SANDBOXED_SERVICES_FOR_TESTING = "num-sandboxed-services";
+    public static final String SWITCH_SANDBOXED_SERVICES_NAME_FOR_TESTING =
+            "sandboxed-services-name";
 
     private static int getNumberOfServices(Context context, boolean inSandbox, String packageName) {
-        try {
-            PackageManager packageManager = context.getPackageManager();
-            ApplicationInfo appInfo = packageManager.getApplicationInfo(packageName,
-                    PackageManager.GET_META_DATA);
-            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);
-                    }
+        int numServices = -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");
+        } else {
+            try {
+                PackageManager packageManager = context.getPackageManager();
+                ApplicationInfo appInfo = packageManager.getApplicationInfo(packageName,
+                        PackageManager.GET_META_DATA);
+                if (appInfo.metaData != null) {
+                    numServices = appInfo.metaData.getInt(inSandbox
+                            ? NUM_SANDBOXED_SERVICES_KEY : NUM_PRIVILEGED_SERVICES_KEY, -1);
+                }
+            } catch (PackageManager.NameNotFoundException e) {
+                throw new RuntimeException("Could not get application info");
             }
-            return numServices;
-        } catch (PackageManager.NameNotFoundException e) {
-            throw new RuntimeException("Could not get application info");
         }
+        if (numServices < 0) {
+            throw new RuntimeException("Illegal meta data value for number of child services");
+        }
+        return numServices;
+    }
+
+    private static Class<? extends Service> getClassOfService(Context context, boolean inSandbox,
+            String packageName) {
+        if (!inSandbox) {
+            return PrivilegedProcessService.class;
+        }
+        String serviceName = null;
+        if (CommandLine.getInstance().hasSwitch(SWITCH_SANDBOXED_SERVICES_NAME_FOR_TESTING)) {
+            serviceName = CommandLine.getInstance().getSwitchValue(
+                    SWITCH_SANDBOXED_SERVICES_NAME_FOR_TESTING);
+        } else {
+            try {
+                PackageManager packageManager = context.getPackageManager();
+                ApplicationInfo appInfo = packageManager.getApplicationInfo(packageName,
+                        PackageManager.GET_META_DATA);
+                if (appInfo.metaData != null) {
+                    serviceName = appInfo.metaData.getString(SANDBOXED_SERVICES_NAME_KEY);
+                }
+            } catch (PackageManager.NameNotFoundException e) {
+                throw new RuntimeException("Could not get application info.");
+            }
+        }
+        if (serviceName != null) {
+            try {
+                Class<? extends Service> service =
+                        (Class<? extends Service>) Class.forName(serviceName);
+                return service;
+            } catch (ClassNotFoundException e) {
+                throw new RuntimeException(
+                        "Illegal meta data value: the child service class doesn't exist");
+            }
+        }
+        return SandboxedProcessService.class;

[no sievers, 2016/06/24 21:33:40]

This should probably return PrivilegedProcessService.class if |!inSandbox|.
(Launching the GPU process as sandboxed will cause subtle problems on SELinux
enabled devices where video playback will break.)

And I would maybe also throw an exception if |appInfo.metaData| is valid but
serviceName somehow still ends up being null. (I guess if you put something
that's not a string in the manifest?)

[Xi Han, 2016/06/24 21:57:06]

The first check is |!inSandbox|, and already returns
PrivilegedProcessService.class for that case. Do I miss your point?

 
The manifest could have other kinds of metadata, so even the |appInfo.metaData|
is valid, it could still miss the serviceName. So we can't tell whether missing
the service name or the service name isn't a string, when calling
|appInfo.metaData.getString(SANDBOXED_SERVICES_
NAME_KEY)|. So I split the error cases as followings:
1) null service name in metadata: use the default SandboxedProcessService.
2) have service name, but not valid: throw "Illegal meta data value: the child
service class doesn't exist" error.

     }
 
     private static void initConnectionAllocatorsIfNecessary(
             Context context, boolean inSandbox, String packageName) {
         // 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),
+                                    getClassOfService(context, true, packageName)));
                 }
             } else if (sPrivilegedChildConnectionAllocator == null) {
                 sPrivilegedChildConnectionAllocator = new ChildConnectionAllocator(
-                        false, getNumberOfServices(context, false, packageName));
+                        false, getNumberOfServices(context, false, packageName),
+                        getClassOfService(context, false, packageName));
             }
             // 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.
      */
@@ skipping 632 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();
         PendingSpawnQueue pendingSpawnQueue = getPendingSpawnQueue(context,
-                creationParams.getPackageName(), inSandbox);
+                packageName, inSandbox);
         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.
@@ skipping 41 matching lines @@
         }
 
         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();
 }