Enable variations restrict param for Java-side fetches.

chrome/android/java/src/org/chromium/chrome/browser/metrics/VariationsSession.java

Index: chrome/android/java/src/org/chromium/chrome/browser/metrics/VariationsSession.java
diff --git a/chrome/android/java/src/org/chromium/chrome/browser/metrics/VariationsSession.java b/chrome/android/java/src/org/chromium/chrome/browser/metrics/VariationsSession.java
index 526353144a8e24d42c64c51498640895180f10a2..a171ca0041e19032c1b86ae03f5716b2cd3cfa3d 100644
--- a/chrome/android/java/src/org/chromium/chrome/browser/metrics/VariationsSession.java
+++ b/chrome/android/java/src/org/chromium/chrome/browser/metrics/VariationsSession.java
@@ -13,39 +13,61 @@ import org.chromium.base.Callback;
  * triggering seed fetches on application startup.
  */
 public class VariationsSession {
-    private boolean mInitialized;
+    private boolean mRestrictModeFetchStarted;
     private String mRestrictMode;
 
     /**
      * Triggers to the native VariationsService that the application has entered the foreground.
      */
     public void start(Context context) {
-        if (!mInitialized) {
-            mInitialized = true;
-            // Check the restrict mode only once initially to avoid doing extra work each time the
-            // app enters foreground.
-            getRestrictMode(context, new Callback<String>() {
-                @Override
-                public void onResult(String restrictMode) {
-                    assert restrictMode != null;
-                    mRestrictMode = restrictMode;
-                    nativeStartVariationsSession(mRestrictMode);
-                }
-            });
-        // If |mRestrictMode| is null, async initialization is in progress and
-        // nativeStartVariationsSession will be called when it completes.
-        } else if (mRestrictMode != null) {
-            nativeStartVariationsSession(mRestrictMode);
+        // If |mRestrictModeFetchStarted| is true and |mRestrictMode| is null, then async
+        // initializationn is in progress and nativeStartVariationsSession() will be called
+        // when it completes.
+        if (mRestrictModeFetchStarted && mRestrictMode == null) {
+            return;
         }
+
+        mRestrictModeFetchStarted = true;
+        getRestrictModeValue(context, new Callback<String>() {
+            @Override
+            public void onResult(String restrictMode) {
+                nativeStartVariationsSession(mRestrictMode);
+            }
+        });
+    }
+
+    /**
+     * Asynchronously returns the value of the "restrict" URL param that the variations service
+     * should use for variation seed requests. Public version that can be called externally.
+     * Uses the protected version (that could be overridden by subclasses) to actually get the
+     * value and also sets that value internally when retrieved.
+     * @param callback Callback that will be called with the param value when available.
+     */
+    public final void getRestrictModeValue(Context context, final Callback<String> callback) {
+        // If |mRestrictMode| is not null, the value has already been fetched and so it can
+        // simply be provided to the callback.
+        if (mRestrictMode != null) {
+            callback.onResult(mRestrictMode);
+            return;
+        }
+        getRestrictMode(context, new Callback<String>() {

[Ted C, 2017/04/07 19:13:43]

Ok...overthinking this even more (something that very likely could be done in a
follow up...or never if it doesn't matter).

If we want to restrict this to only call getRestrictMode once.  I think we would
need to support a queue of callbacks waiting on the initial response from
getRestrictMode.

private List<Callback<String>> mPendingRestrictModeCallbacks = new
ArrayList<>();

...

ThreadUtils.assertOnUiThread();
if (mRestrictMode != null) {
   ...
   return;
}

mPendingRestrictModeCallbacks.add(callback);
if (mPendingRestrictModeCallbacks.size() > 1) return;

getRestrictMode(context, new Callback<String>() {
    @Override
    public void onResult(String restrictMode) {
        ThreadUtils.assertOnUiThread();
        assert restrictMode != null;
        mRestrictMode = restrictMode;
        for (int i = 0; i < mPendingRestrictModeCallbacks.size(); i++) {
            mPendingRestrictModeCallbacks.get(i).onResult(restrictMode);
        }
        mPendingRestrictModeCallbacks.clear();
    }
});


Again...probably way more than needed and potentially more complicated to all.

[Alexei Svitkine (slow), 2017/04/07 19:18:53]

Right. I don't think the above is necessary at this point - since this will be
called: a) on FRE and b) on session start (i.e. app foregrounded & native
initialized).

The two are unlikely to overlap much in practice, so I don't think we need the
more complicated solution currently.

+            @Override
+            public void onResult(String restrictMode) {
+                assert restrictMode != null;
+                mRestrictMode = restrictMode;
+                callback.onResult(restrictMode);
+            }
+        });
     }
 
     /**
      * Asynchronously returns the value of the "restrict" URL param that the variations service
-     * should use for variation seed requests.
+     * should use for variation seed requests. This can be overriden by subclass to provide actual
+     * restrict values, which must not be null.
      */
     protected void getRestrictMode(Context context, Callback<String> callback) {
         callback.onResult("");
     }
 
-    private native void nativeStartVariationsSession(String restrictMode);
+    protected native void nativeStartVariationsSession(String restrictMode);
 }