Add a flag to not start GPU process on browser startup

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 org.chromium.base.Log;
@@ skipping 43 matching lines @@
 
     // Helper constants for {@link #executeEnqueuedCallbacks(int, boolean)}.
     @VisibleForTesting
     static final int STARTUP_SUCCESS = -1;
     @VisibleForTesting
     static final int STARTUP_FAILURE = 1;
 
     private static BrowserStartupController sInstance;
 
     private static boolean sBrowserMayStartAsynchronously = false;
+    private static boolean sShouldStartGpuProcessOnBrowserStartup = true;
 
     private static void setAsynchronousStartup(boolean enable) {
         sBrowserMayStartAsynchronously = enable;
     }
 
+    private static void setShouldStartGpuProcessOnBrowserStartup(boolean enable) {
+        sShouldStartGpuProcessOnBrowserStartup = enable;
+    }
+
     @VisibleForTesting
     @CalledByNative
     static boolean browserMayStartAsynchonously() {
         return sBrowserMayStartAsynchronously;
     }
 
     @VisibleForTesting
     @CalledByNative
     static void browserStartupComplete(int result) {
         if (sInstance != null) {
             sInstance.executeEnqueuedCallbacks(result, NOT_ALREADY_STARTED);
         }
     }
 
+    @CalledByNative
+    static boolean shouldStartGpuProcessOnBrowserStartup() {
+        return sShouldStartGpuProcessOnBrowserStartup;
+    }
+
     // A list of callbacks that should be called when the async startup of the browser process is
     // complete.
     private final List<StartupCallback> mAsyncStartupCallbacks;
 
     // The context is set on creation, but the reference is cleared after the browser process
     // 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.
@@ skipping 46 matching lines @@
         }
         return sInstance;
     }
 
     /**
      * Start the browser process asynchronously. This will set up a queue of UI thread tasks to
      * initialize the browser process.
      * <p/>
      * Note that this can only be called on the UI thread.
      *
+     * @param startGpuProcess Whether to start the GPU process if it is not started.
      * @param callback the callback to be called when browser startup is complete.
      */
-    public void startBrowserProcessesAsync(final StartupCallback callback)
+    public void startBrowserProcessesAsync(boolean startGpuProcess, final StartupCallback callback)
             throws ProcessInitException {
         assert ThreadUtils.runningOnUiThread() : "Tried to start the browser on the wrong thread.";
         if (mStartupDone) {
             // Browser process initialization has already been completed, so we can immediately post
             // the callback.
             postStartupCompleted(callback);
             return;
         }
 
         // 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;
 
             setAsynchronousStartup(true);
+            setShouldStartGpuProcessOnBrowserStartup(startGpuProcess);
             prepareToStartBrowserProcess(false, new Runnable() {
                 @Override
                 public void run() {
                     ThreadUtils.assertOnUiThread();
                     if (contentStart() > 0) {
                         // Failed. The callbacks may not have run, so run them.
                         enqueueCallbackExecution(STARTUP_FAILURE, NOT_ALREADY_STARTED);
                     }
                 }
             });
@@ skipping 103 matching lines @@
         // 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.get(mLibraryProcessType).ensureInitialized(mContext);
 
         Runnable postResourceExtraction = new Runnable() {
             @Override
             public void run() {
                 if (!mPostResourceExtractionTasksCompleted) {
                     // TODO(yfriedman): Remove dependency on a command line flag for this.
                     DeviceUtils.addDeviceSpecificUserAgentSwitch(mContext);
-
                     nativeSetCommandLineFlags(
                             singleProcess, nativeIsPluginEnabled() ? getPlugins() : null);
                     mPostResourceExtractionTasksCompleted = true;
                 }
 
                 if (completionCallback != null) completionCallback.run();
             }
         };
 
         if (completionCallback == null) {
@@ skipping 22 matching lines @@
 
     private static native void nativeSetCommandLineFlags(
             boolean singleProcess, 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();
 }