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 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) {
             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;
             mInSandbox = inSandbox;
         }
 
+        private Class<? extends Service> getServiceClass(Class<? extends Service> serviceClass) {
+            if (serviceClass != null) {
+                return serviceClass;
+            }
+            return mInSandbox ? SandboxedProcessService.class
+                    : PrivilegedProcessService.class;
+        }
+
         public ChildProcessConnection allocate(
                 Context context, ChildProcessConnection.DeathCallback deathCallback,
                 ChromiumLinkerParams chromiumLinkerParams,
                 boolean alwaysInForeground,
                 ChildProcessCreationParams creationParams) {
             synchronized (mConnectionLock) {
                 if (mFreeConnectionIndices.isEmpty()) {
                     Log.d(TAG, "Ran out of services to allocate.");
                     return null;
                 }
                 int slot = mFreeConnectionIndices.remove(0);
                 assert mChildProcessConnections[slot] == null;
+                Class<? extends Service> serviceClass = getServiceClass(creationParams != null
+                        ? creationParams.getServiceClass() : null);

[Maria, 2016/06/17 17:09:24]

I think that's an odd division of logic. Why not just pass creation params into
getServiceClass() call?

[Xi Han, 2016/06/17 18:35:20]

It sounds good to me, since we can just pass null if we want to have a default
service class, and only construct a CreationParams when a WebAPK's service class
is needed. Updated.

                 mChildProcessConnections[slot] = new ChildProcessConnectionImpl(context, slot,
-                        mInSandbox, deathCallback, mChildClass, chromiumLinkerParams,
+                        mInSandbox, deathCallback, serviceClass, chromiumLinkerParams,
                         alwaysInForeground, creationParams);
                 Log.d(TAG, "Allocator allocated a connection, sandbox: %b, slot: %d", mInSandbox,
                         slot);
                 return mChildProcessConnections[slot];
             }
         }
 
         public void free(ChildProcessConnection connection) {
             synchronized (mConnectionLock) {
                 int slot = connection.getServiceNumber();
@@ skipping 828 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();
 }