Add a way to reset cached command line arguments

base/android/java/src/org/chromium/base/CommandLine.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.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.List;
 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.,
  * ContentShellApplication.COMMAND_LINE_FILE or ChromeShellApplication.COMMAND_LINE_FILE.
 **/
 public abstract class CommandLine {
+    /**
+     * Allows classes who cache command line flags to be notified when those arguments are updated
+     * at runtime. This happens in tests.
+     */
+    public interface ResetListener {
+        /** Called when the command line arguments are reset. */
+        void onCommandLineReset();
+    }
+
     // 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).
      */
     @VisibleForTesting
     public abstract boolean hasSwitch(String switchString);
 
     /**
@@ skipping 42 matching lines @@
     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 List<ResetListener> sResetListeners = new ArrayList<>();
     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;
     }
 
@@ skipping 25 matching lines @@
         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.
      */
     @VisibleForTesting
     public static void reset() {
         setInstance(null);
+        ThreadUtils.postOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                for (ResetListener listener : sResetListeners) listener.onCommandLineReset();
+            }
+        });
+    }
+
+    public static void addResetListener(ResetListener listener) {

[jdduke (slow), 2015/07/27 15:05:23]

Hmm, I'd really like to understand use-cases that legitimately need dynamic
CommandLine-change observation outside of tests. I don't think we should be
complicating this interface with listeners only to supporting testing. Rather,
we should modify tests to be consistent in how they rely on command-line flags.

[dgn, 2015/07/27 15:12:29]

It should not be used out of tests, yes. An annotation is missing. And the
correct solution would be to fix the tests indeed. There I just wanted to send a
fix that would make the tests pass without reverting cls or disabling them on
all L+ bots.

+        sResetListeners.add(listener);
+    }
+
+    public static void removeResetListener(ResetListener listener) {
+        sResetListeners.remove(listener);
     }
 
     /**
      * 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 229 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);
 }