379 lines
14 KiB
Java
Executable File
379 lines
14 KiB
Java
Executable File
// 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.base;
|
|
|
|
import android.text.TextUtils;
|
|
import android.util.Log;
|
|
|
|
import java.io.File;
|
|
import java.io.FileInputStream;
|
|
import java.io.FileNotFoundException;
|
|
import java.io.IOException;
|
|
import java.io.InputStreamReader;
|
|
import java.io.Reader;
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.HashMap;
|
|
import java.util.concurrent.atomic.AtomicReference;
|
|
|
|
/**
|
|
* Java mirror of base/command_line.h.
|
|
* Android applications don't have command line arguments. Instead, they're "simulated" by reading a
|
|
* file at a specific location early during startup. Applications each define their own files, e.g.,
|
|
* ContentShellActivity.COMMAND_LINE_FILE or ChromiumTestShellApplication.COMMAND_LINE_FILE.
|
|
**/
|
|
public abstract class CommandLine {
|
|
// Public abstract interface, implemented in derived classes.
|
|
// All these methods reflect their native-side counterparts.
|
|
/**
|
|
* Returns true if this command line contains the given switch.
|
|
* (Switch names ARE case-sensitive).
|
|
*/
|
|
public abstract boolean hasSwitch(String switchString);
|
|
|
|
/**
|
|
* Return the value associated with the given switch, or null.
|
|
* @param switchString The switch key to lookup. It should NOT start with '--' !
|
|
* @return switch value, or null if the switch is not set or set to empty.
|
|
*/
|
|
public abstract String getSwitchValue(String switchString);
|
|
|
|
/**
|
|
* Return the value associated with the given switch, or {@code defaultValue} if the switch
|
|
* was not specified.
|
|
* @param switchString The switch key to lookup. It should NOT start with '--' !
|
|
* @param defaultValue The default value to return if the switch isn't set.
|
|
* @return Switch value, or {@code defaultValue} if the switch is not set or set to empty.
|
|
*/
|
|
public String getSwitchValue(String switchString, String defaultValue) {
|
|
String value = getSwitchValue(switchString);
|
|
return TextUtils.isEmpty(value) ? defaultValue : value;
|
|
}
|
|
|
|
/**
|
|
* Append a switch to the command line. There is no guarantee
|
|
* this action happens before the switch is needed.
|
|
* @param switchString the switch to add. It should NOT start with '--' !
|
|
*/
|
|
public abstract void appendSwitch(String switchString);
|
|
|
|
/**
|
|
* Append a switch and value to the command line. There is no
|
|
* guarantee this action happens before the switch is needed.
|
|
* @param switchString the switch to add. It should NOT start with '--' !
|
|
* @param value the value for this switch.
|
|
* For example, --foo=bar becomes 'foo', 'bar'.
|
|
*/
|
|
public abstract void appendSwitchWithValue(String switchString, String value);
|
|
|
|
/**
|
|
* Append switch/value items in "command line" format (excluding argv[0] program name).
|
|
* E.g. { '--gofast', '--username=fred' }
|
|
* @param array an array of switch or switch/value items in command line format.
|
|
* Unlike the other append routines, these switches SHOULD start with '--' .
|
|
* Unlike init(), this does not include the program name in array[0].
|
|
*/
|
|
public abstract void appendSwitchesAndArguments(String[] array);
|
|
|
|
/**
|
|
* Determine if the command line is bound to the native (JNI) implementation.
|
|
* @return true if the underlying implementation is delegating to the native command line.
|
|
*/
|
|
public boolean isNativeImplementation() {
|
|
return false;
|
|
}
|
|
|
|
private static final AtomicReference<CommandLine> sCommandLine =
|
|
new AtomicReference<CommandLine>();
|
|
|
|
/**
|
|
* @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() {
|
|
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) {
|
|
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) {
|
|
// Arbitrary clamp of 8k on the amount of file we read in.
|
|
char[] buffer = readUtf8FileFully(file, 8 * 1024);
|
|
init(buffer == null ? null : 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() {
|
|
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().
|
|
*/
|
|
public static String[] tokenizeQuotedAruments(char[] buffer) {
|
|
ArrayList<String> args = new ArrayList<String>();
|
|
StringBuilder arg = null;
|
|
final char noQuote = '\0';
|
|
final char singleQuote = '\'';
|
|
final char doubleQuote = '"';
|
|
char currentQuote = noQuote;
|
|
for (char c : buffer) {
|
|
// Detect start or end of quote block.
|
|
if ((currentQuote == noQuote && (c == singleQuote || c == doubleQuote)) ||
|
|
c == currentQuote) {
|
|
if (arg != null && arg.length() > 0 && arg.charAt(arg.length() - 1) == '\\') {
|
|
// Last char was a backslash; pop it, and treat c as a literal.
|
|
arg.setCharAt(arg.length() - 1, c);
|
|
} else {
|
|
currentQuote = currentQuote == noQuote ? c : noQuote;
|
|
}
|
|
} else if (currentQuote == noQuote && Character.isWhitespace(c)) {
|
|
if (arg != null) {
|
|
args.add(arg.toString());
|
|
arg = null;
|
|
}
|
|
} else {
|
|
if (arg == null) arg = new StringBuilder();
|
|
arg.append(c);
|
|
}
|
|
}
|
|
if (arg != null) {
|
|
if (currentQuote != noQuote) {
|
|
Log.w(TAG, "Unterminated quoted string: " + arg);
|
|
}
|
|
args.add(arg.toString());
|
|
}
|
|
return args.toArray(new String[args.size()]);
|
|
}
|
|
|
|
private static final String TAG = "CommandLine";
|
|
private static final String SWITCH_PREFIX = "--";
|
|
private static final String SWITCH_TERMINATOR = SWITCH_PREFIX;
|
|
private static final String SWITCH_VALUE_SEPARATOR = "=";
|
|
|
|
public static void enableNativeProxy() {
|
|
// Make a best-effort to ensure we make a clean (atomic) switch over from the old to
|
|
// the new command line implementation. If another thread is modifying the command line
|
|
// when this happens, all bets are off. (As per the native CommandLine).
|
|
sCommandLine.set(new NativeCommandLine());
|
|
}
|
|
|
|
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.
|
|
* @return Array of chars read from the file, or null if the file cannot be read
|
|
* or if its length exceeds |sizeLimit|.
|
|
*/
|
|
private static char[] readUtf8FileFully(String fileName, int sizeLimit) {
|
|
Reader reader = null;
|
|
File f = new File(fileName);
|
|
long fileLength = f.length();
|
|
|
|
if (fileLength == 0) {
|
|
return null;
|
|
}
|
|
|
|
if (fileLength > sizeLimit) {
|
|
Log.w(TAG, "File " + fileName + " length " + fileLength + " exceeds limit "
|
|
+ sizeLimit);
|
|
return null;
|
|
}
|
|
|
|
try {
|
|
char[] buffer = new char[(int) fileLength];
|
|
reader = new InputStreamReader(new FileInputStream(f), "UTF-8");
|
|
int charsRead = reader.read(buffer);
|
|
// Debug check that we've exhausted the input stream (will fail e.g. if the
|
|
// file grew after we inspected its length).
|
|
assert !reader.ready();
|
|
return charsRead < buffer.length ? Arrays.copyOfRange(buffer, 0, charsRead) : buffer;
|
|
} catch (FileNotFoundException e) {
|
|
return null;
|
|
} catch (IOException e) {
|
|
return null;
|
|
} finally {
|
|
try {
|
|
if (reader != null) reader.close();
|
|
} catch (IOException e) {
|
|
Log.e(TAG, "Unable to close file reader.", e);
|
|
}
|
|
}
|
|
}
|
|
|
|
private CommandLine() {}
|
|
|
|
private static class JavaCommandLine extends CommandLine {
|
|
private HashMap<String, String> mSwitches = new HashMap<String, String>();
|
|
private ArrayList<String> mArgs = new ArrayList<String>();
|
|
|
|
// The arguments begin at index 1, since index 0 contains the executable name.
|
|
private int mArgsBegin = 1;
|
|
|
|
JavaCommandLine(String[] args) {
|
|
if (args == null || args.length == 0 || args[0] == null) {
|
|
mArgs.add("");
|
|
} else {
|
|
mArgs.add(args[0]);
|
|
appendSwitchesInternal(args, 1);
|
|
}
|
|
// Invariant: we always have the argv[0] program name element.
|
|
assert mArgs.size() > 0;
|
|
}
|
|
|
|
/**
|
|
* Returns the switches and arguments passed into the program, with switches and their
|
|
* values coming before all of the arguments.
|
|
*/
|
|
private String[] getCommandLineArguments() {
|
|
return mArgs.toArray(new String[mArgs.size()]);
|
|
}
|
|
|
|
@Override
|
|
public boolean hasSwitch(String switchString) {
|
|
return mSwitches.containsKey(switchString);
|
|
}
|
|
|
|
@Override
|
|
public String getSwitchValue(String switchString) {
|
|
// This is slightly round about, but needed for consistency with the NativeCommandLine
|
|
// version which does not distinguish empty values from key not present.
|
|
String value = mSwitches.get(switchString);
|
|
return value == null || value.isEmpty() ? null : value;
|
|
}
|
|
|
|
@Override
|
|
public void appendSwitch(String switchString) {
|
|
appendSwitchWithValue(switchString, null);
|
|
}
|
|
|
|
/**
|
|
* Appends a switch to the current list.
|
|
* @param switchString the switch to add. It should NOT start with '--' !
|
|
* @param value the value for this switch.
|
|
*/
|
|
@Override
|
|
public void appendSwitchWithValue(String switchString, String value) {
|
|
mSwitches.put(switchString, value == null ? "" : value);
|
|
|
|
// Append the switch and update the switches/arguments divider mArgsBegin.
|
|
String combinedSwitchString = SWITCH_PREFIX + switchString;
|
|
if (value != null && !value.isEmpty())
|
|
combinedSwitchString += SWITCH_VALUE_SEPARATOR + value;
|
|
|
|
mArgs.add(mArgsBegin++, combinedSwitchString);
|
|
}
|
|
|
|
@Override
|
|
public void appendSwitchesAndArguments(String[] array) {
|
|
appendSwitchesInternal(array, 0);
|
|
}
|
|
|
|
// Add the specified arguments, but skipping the first |skipCount| elements.
|
|
private void appendSwitchesInternal(String[] array, int skipCount) {
|
|
boolean parseSwitches = true;
|
|
for (String arg : array) {
|
|
if (skipCount > 0) {
|
|
--skipCount;
|
|
continue;
|
|
}
|
|
|
|
if (arg.equals(SWITCH_TERMINATOR)) {
|
|
parseSwitches = false;
|
|
}
|
|
|
|
if (parseSwitches && arg.startsWith(SWITCH_PREFIX)) {
|
|
String[] parts = arg.split(SWITCH_VALUE_SEPARATOR, 2);
|
|
String value = parts.length > 1 ? parts[1] : null;
|
|
appendSwitchWithValue(parts[0].substring(SWITCH_PREFIX.length()), value);
|
|
} else {
|
|
mArgs.add(arg);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static class NativeCommandLine extends CommandLine {
|
|
@Override
|
|
public boolean hasSwitch(String switchString) {
|
|
return nativeHasSwitch(switchString);
|
|
}
|
|
|
|
@Override
|
|
public String getSwitchValue(String switchString) {
|
|
return nativeGetSwitchValue(switchString);
|
|
}
|
|
|
|
@Override
|
|
public void appendSwitch(String switchString) {
|
|
nativeAppendSwitch(switchString);
|
|
}
|
|
|
|
@Override
|
|
public void appendSwitchWithValue(String switchString, String value) {
|
|
nativeAppendSwitchWithValue(switchString, value);
|
|
}
|
|
|
|
@Override
|
|
public void appendSwitchesAndArguments(String[] array) {
|
|
nativeAppendSwitchesAndArguments(array);
|
|
}
|
|
|
|
@Override
|
|
public boolean isNativeImplementation() {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
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);
|
|
}
|