Allow native command line arguments to be initialized early.

base/android/java/src/org/chromium/base/library_loader/LibraryLoader.java

 // Copyright 2014 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.base.library_loader;
 
 import android.content.Context;
 import android.os.SystemClock;
 import android.util.Log;
 
@@ skipping 19 matching lines @@
 @JNINamespace("base::android")
 public class LibraryLoader {
     private static final String TAG = "LibraryLoader";
 
     // Guards all access to the libraries
     private static final Object sLock = new Object();
 
     // One-way switch becomes true when the libraries are loaded.
     private static boolean sLoaded = false;
 
+    // One-way switch becomes true when the native command line is initialized (
+    // by calling nativeInitCommandLine, which forwards to
+    // InitCommandLine(...) in library_loader_hooks.cc).
+    private static boolean sCommandLineInitialized = false;
+
     // One-way switch becomes true when the libraries are initialized (
     // by calling nativeLibraryLoaded, which forwards to LibraryLoaded(...) in
     // library_loader_hooks.cc).
     private static boolean sInitialized = false;
 
     // One-way switch becomes true if the system library loading failed,
     // and the right native library was found and loaded by the hack.
     // The flag is used to report UMA stats later.
     private static boolean sNativeLibraryHackWasUsed = false;
 
@@ skipping 26 matching lines @@
      */
     public static void ensureInitialized(
             Context context, boolean shouldDeleteOldWorkaroundLibraries)
             throws ProcessInitException {
         synchronized (sLock) {
             if (sInitialized) {
                 // Already initialized, nothing to do.
                 return;
             }
             loadAlreadyLocked(context, shouldDeleteOldWorkaroundLibraries);
-            initializeAlreadyLocked(CommandLine.getJavaSwitchesOrNull());
+
+            // We can only call getJavaSwitchesOrNull if we have not yet
+            // switched CommandLine to native.
+            String[] switches = null;
+            if (!sCommandLineInitialized) {
+                switches = CommandLine.getJavaSwitchesOrNull();
+            }
+            initializeAlreadyLocked(switches);
         }
     }
 
     /**
      * Checks if library is fully loaded and initialized.
      */
     public static boolean isInitialized() {
         synchronized (sLock) {
             return sInitialized;
         }
@@ skipping 96 matching lines @@
         Log.i(TAG, String.format(
                 "Expected native library version number \"%s\"," +
                         "actual native library version number \"%s\"",
                 NativeLibraries.VERSION_NUMBER,
                 nativeGetVersionNumber()));
         if (!NativeLibraries.VERSION_NUMBER.equals(nativeGetVersionNumber())) {
             throw new ProcessInitException(LoaderErrors.LOADER_ERROR_NATIVE_LIBRARY_WRONG_VERSION);
         }
     }
 
+    /**
+     * Set the native command line if it is has not been set yet.
+     * If the command line is set already the arguments are ignored.
+     * The library must have previously been loaded with loadNow.
+     */
+    public static void ensureCommandLineInit(String[] initCommandLine) {

[bulach, 2014/05/21 11:33:49]

hmm... this method seems dangerous, it "ensures" but still can "fail", i.e., if
the command line has already been initialized, callers of this method would
never know that the new switches haven't been applied at all..
there are several entry points for loading the library, and it feels this is
bound to be racy...

[hjd, 2014/05/22 11:09:10]

Yeah I felt bad writing that name... I've changed it so there are two paths
one where you initialize everything at once and another where you do it in 
two parts. Attempting to initialize the command line early twice is now 
throws and exception.

+        synchronized (sLock) {
+            ensureCommandLineInitAlreadyLocked(initCommandLine);
+        }
+    }
+
+    private static void ensureCommandLineInitAlreadyLocked(String[] initCommandLine) {
+        if (sCommandLineInitialized) {
+            return;
+        }
+        nativeInitCommandLine(initCommandLine);

[bulach, 2014/05/21 11:33:49]

calling an unbound method throws some fairly cryptic exceptions :)
maybe check sInitialized and throw a nicer looking exception?
even better, do this at the method above, since the documentation mandates it
there..

[hjd, 2014/05/22 11:09:10]

I added a lot of extra LoaderErrors and checked that sLoaded was true :)

+        CommandLine.enableNativeProxy();
+        sCommandLineInitialized = true;
+    }
+
     // Invoke base::android::LibraryLoaded in library_loader_hooks.cc
     private static void initializeAlreadyLocked(String[] initCommandLine)
             throws ProcessInitException {
         if (sInitialized) {
             return;
         }
-        if (!nativeLibraryLoaded(initCommandLine)) {
+
+        ensureCommandLineInitAlreadyLocked(initCommandLine);
+
+        if (!nativeLibraryLoaded()) {
             Log.e(TAG, "error calling nativeLibraryLoaded");
             throw new ProcessInitException(LoaderErrors.LOADER_ERROR_FAILED_TO_REGISTER_JNI);
         }
         // From this point on, native code is ready to use and checkIsReady()
         // shouldn't complain from now on (and in fact, it's used by the
         // following calls).
         sInitialized = true;
-        CommandLine.enableNativeProxy();
 
         // From now on, keep tracing in sync with native.
         TraceEvent.registerNativeEnabledObserver();
 
         // Record histogram for the Chromium linker.
         if (Linker.isUsed()) {
             nativeRecordChromiumAndroidLinkerHistogram(Linker.loadAtFixedAddressFailed(),
                     SysUtils.isLowEndDevice());
         }
 
         nativeRecordNativeLibraryHack(sNativeLibraryHackWasUsed);
     }
 
+    // Invokes InitCommandLine in library_loader_hooks.cc to set the native command line.
+    private static native void nativeInitCommandLine(String[] commandLine);
+
     // Only methods needed before or during normal JNI registration are during System.OnLoad.
     // nativeLibraryLoaded is then called to register everything else.  This process is called
     // "initialization".  This method will be mapped (by generated code) to the LibraryLoaded
     // definition in base/android/library_loader/library_loader_hooks.cc.
     //
     // Return true on success and false on failure.
-    private static native boolean nativeLibraryLoaded(String[] initCommandLine);
+    private static native boolean nativeLibraryLoaded();
 
     // Method called to record statistics about the Chromium linker operation,
     // i.e. whether the library failed to be loaded at a fixed address, and
     // whether the device is 'low-memory'.
     private static native void nativeRecordChromiumAndroidLinkerHistogram(
             boolean loadedAtFixedAddressFailed,
             boolean isLowMemoryDevice);
 
     // Get the version of the native library. This is needed so that we can check we
     // have the right version before initializing the (rest of the) JNI.
     private static native String nativeGetVersionNumber();
 
     private static native void nativeRecordNativeLibraryHack(boolean usedHack);
 }