[Android] Upstreaming CommandLine.java diff

content/public/android/java/src/org/chromium/content/common/CommandLine.java

 // Copyright (c) 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.common;
 
 import android.text.TextUtils;
 import android.util.Log;
 
 import java.io.File;
@@ skipping 107 matching lines @@
 
     /**
      * @returns true if the command line has already been initialized.
      */
     public static boolean isInitialized() {
         return sCommandLine.get() != null;
     }
 
     // Equivalent to CommandLine::ForCurrentProcess in C++.
     public static CommandLine getInstance() {
-        assert sCommandLine.get() != null;
-        return sCommandLine.get();
+        CommandLine commandLine = sCommandLine.get();
+        assert commandLine != null;
+        return commandLine;
     }
 
     /**
      * Initialize the singleton instance, must be called exactly once (either directly or
      * via one of the convenience wrappers below) before using the static singleton instance.
      * @param args command line flags in 'argv' format: args[0] is the program name.
      */
     public static void init(String[] args) {
-        assert sCommandLine.get() == null;
-        sCommandLine.compareAndSet(null, new JavaCommandLine(args));
+        setInstance(new JavaCommandLine(args));
     }
 
     /**
      * Initialize the command line from the command-line file.
      *
      * @param file The fully qualified command line file.
      */
     public static void initFromFile(String file) {
         char[] buffer = new char[0];
         try {
             // Arbitrary clamp of 8k on the amount of file we read in.
             buffer = readUtf8FileFully(file, 8 * 1024);
         } catch (FileNotFoundException e) {
             // Ignore: having a command line file is optional.
         } catch (IOException e) {
             Log.w(TAG, "error reading command line file " + file + e);
         }
         init(tokenizeQuotedAruments(buffer));
     }
 
     /**
      * Resets both the java proxy and the native command lines. This allows the entire
      * command line initialization to be re-run including the call to onJniLoaded.
      */
     public static void reset() {
-        if (sCommandLine.get() != null && sCommandLine.get().isNativeImplementation()) {
-            nativeReset();
-        }
-        sCommandLine.set(null);
+        setInstance(null);
     }
 
     /**
      * Public for testing (TODO: why are the tests in a different package?)
      * Parse command line flags from a flat buffer, supporting double-quote enclosed strings
      * containing whitespace. argv elements are derived by splitting the buffer on whitepace;
      * double quote characters may enclose tokens containing whitespace; a double-quote literal
      * may be escaped with back-slash. (Otherwise backslash is taken as a literal).
      * @param buffer A command line in command line file format as described above.
      * @return the tokenized arguments, suitable for passing to init().
@@ skipping 43 matching lines @@
 
     public static String[] getJavaSwitchesOrNull() {
         CommandLine commandLine = sCommandLine.get();
         if (commandLine != null) {
             assert !commandLine.isNativeImplementation();
             return ((JavaCommandLine) commandLine).getCommandLineArguments();
         }
         return null;
     }
 
+    private static void setInstance(CommandLine commandLine) {
+        CommandLine oldCommandLine = sCommandLine.getAndSet(commandLine);
+        if (oldCommandLine != null && oldCommandLine.isNativeImplementation()) {
+            nativeReset();
+        }
+    }
+
     /**
      * @param fileName the file to read in.
      * @param sizeLimit cap on the file size: will throw an exception if exceeded
      * @return Array of chars read from the file
      * @throws FileNotFoundException file does not exceed
      * @throws IOException error encountered accessing the file
      */
     private static char[] readUtf8FileFully(String fileName, int sizeLimit) throws
             FileNotFoundException, IOException {
         Reader reader = null;
@@ skipping 139 matching lines @@
         }
     }
 
     private static native void nativeReset();
     private static native boolean nativeHasSwitch(String switchString);
     private static native String nativeGetSwitchValue(String switchString);
     private static native void nativeAppendSwitch(String switchString);
     private static native void nativeAppendSwitchWithValue(String switchString, String value);
     private static native void nativeAppendSwitchesAndArguments(String[] array);
 };