Don't share renderers between unrelated tabs on Android.

content/public/android/java/src/org/chromium/content/browser/BrowserStartupController.java

 // Copyright 2013 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.Context;
 import android.os.Handler;
 import android.util.Log;
 
@@ skipping 76 matching lines @@
     // initialization has been started, since it is not needed anymore. This is to ensure the
     // context is not leaked.
     private final Context mContext;
 
     // Whether the async startup of the browser process has started.
     private boolean mHasStartedInitializingBrowserProcess;
 
     // Whether the async startup of the browser process is complete.
     private boolean mStartupDone;
 
-    // Use single-process mode that runs the renderer on a separate thread in
-    // the main application.
-    public static final int MAX_RENDERERS_SINGLE_PROCESS = 0;
-
-    // Cap on the maximum number of renderer processes that can be requested.
-    // This is currently set to account for:
-    //  13: The maximum number of sandboxed processes we have available
-    // - 1: The regular New Tab Page
-    // - 1: The incognito New Tab Page
-    // - 1: A regular incognito tab
-    // - 1: Safety buffer (http://crbug.com/251279)
-    public static final int MAX_RENDERERS_LIMIT =
-            ChildProcessLauncher.MAX_REGISTERED_SANDBOXED_SERVICES - 4;
-
     // This field is set after startup has been completed based on whether the startup was a success
     // or not. It is used when later requests to startup come in that happen after the initial set
     // of enqueued callbacks have been executed.
     private boolean mStartupSuccess;
 
     BrowserStartupController(Context context) {
         mContext = context;
         mAsyncStartupCallbacks = new ArrayList<StartupCallback>();
     }
 
@@ skipping 33 matching lines @@
         }
 
         // Browser process has not been fully started yet, so we defer executing the callback.
         mAsyncStartupCallbacks.add(callback);
 
         if (!mHasStartedInitializingBrowserProcess) {
             // This is the first time we have been asked to start the browser process. We set the
             // flag that indicates that we have kicked off starting the browser process.
             mHasStartedInitializingBrowserProcess = true;
 
-            prepareToStartBrowserProcess(MAX_RENDERERS_LIMIT);
+            prepareToStartBrowserProcess(false);
 
             setAsynchronousStartup(true);
             if (contentStart() > 0) {
                 // Failed. The callbacks may not have run, so run them.
                 enqueueCallbackExecution(STARTUP_FAILURE, NOT_ALREADY_STARTED);
             }
         }
     }
 
     /**
      * Start the browser process synchronously. If the browser is already being started
      * asynchronously then complete startup synchronously
      *
      * <p/>
      * Note that this can only be called on the UI thread.
      *
-     * @param maxRenderers The maximum number of renderer processes the browser may
-     *                      create. Zero for single process mode.
+     * @param inProcess true iff the browser should run single-process, ie. keep renderers in the
+     *                  browser process
      * @throws ProcessInitException
      */
-    public void startBrowserProcessesSync(int maxRenderers) throws ProcessInitException {
+    public void startBrowserProcessesSync(boolean inProcess) throws ProcessInitException {
         // If already started skip to checking the result
         if (!mStartupDone) {
             if (!mHasStartedInitializingBrowserProcess) {
-                prepareToStartBrowserProcess(maxRenderers);
+                prepareToStartBrowserProcess(inProcess);
             }
 
             setAsynchronousStartup(false);
             if (contentStart() > 0) {
                 // Failed. The callbacks may not have run, so run them.
                 enqueueCallbackExecution(STARTUP_FAILURE, NOT_ALREADY_STARTED);
             }
         }
 
         // Startup should now be complete
@@ skipping 53 matching lines @@
                 if (mStartupSuccess) {
                     callback.onSuccess(ALREADY_STARTED);
                 } else {
                     callback.onFailure();
                 }
             }
         });
     }
 
     @VisibleForTesting
-    void prepareToStartBrowserProcess(int maxRendererProcesses) throws ProcessInitException {
-        Log.i(TAG, "Initializing chromium process, renderers=" + maxRendererProcesses);
+    void prepareToStartBrowserProcess(boolean inProcess) throws ProcessInitException {
+        Log.i(TAG, "Initializing chromium process, inProcess=" + inProcess);
 
         // Normally Main.java will have kicked this off asynchronously for Chrome. But other
         // ContentView apps like tests also need them so we make sure we've extracted resources
         // here. We can still make it a little async (wait until the library is loaded).
         ResourceExtractor resourceExtractor = ResourceExtractor.get(mContext);
         resourceExtractor.startExtractingResources();
 
         // Normally Main.java will have already loaded the library asynchronously, we only need
         // to load it here if we arrived via another flow, e.g. bookmark access & sync setup.
         LibraryLoader.ensureInitialized(mContext, true);
 
         // TODO(yfriedman): Remove dependency on a command line flag for this.
         DeviceUtils.addDeviceSpecificUserAgentSwitch(mContext);
 
         Context appContext = mContext.getApplicationContext();
         // Now we really need to have the resources ready.
         resourceExtractor.waitForCompletion();
 
-        nativeSetCommandLineFlags(maxRendererProcesses,
-                nativeIsPluginEnabled() ? getPlugins() : null);
+        nativeSetCommandLineFlags(inProcess, nativeIsPluginEnabled() ? getPlugins() : null);
         ContentMain.initApplicationContext(appContext);
     }
 
     /**
      * Initialization needed for tests. Mainly used by content browsertests.
      */
     public void initChromiumBrowserProcessForTests() {
         ResourceExtractor resourceExtractor = ResourceExtractor.get(mContext);
         resourceExtractor.startExtractingResources();
         resourceExtractor.waitForCompletion();
-
-        // Having a single renderer should be sufficient for tests. We can't have more than
-        // MAX_RENDERERS_LIMIT.
-        nativeSetCommandLineFlags(1 /* maxRenderers */, null);
+        nativeSetCommandLineFlags(false, null);
     }
 
     private String getPlugins() {
         return PepperPluginManager.getPlugins(mContext);
     }
 
-    private static native void nativeSetCommandLineFlags(int maxRenderProcesses,
-            String pluginDescriptor);
+    private static native void nativeSetCommandLineFlags(
+            boolean inProcess, String pluginDescriptor);
 
     // Is this an official build of Chrome? Only native code knows for sure. Official build
     // knowledge is needed very early in process startup.
     private static native boolean nativeIsOfficialBuild();
 
     private static native boolean nativeIsPluginEnabled();
 }