Introduce Visible Networks Tracker.

chrome/android/java/src/org/chromium/chrome/browser/omnibox/geo/VisibleNetworksTracker.java

+// Copyright 2017 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.chrome.browser.omnibox.geo;
+
+import android.content.Context;
+import android.os.AsyncTask;
+import android.os.SystemClock;
+
+import org.chromium.base.Log;
+import org.chromium.base.ThreadUtils;
+import org.chromium.base.VisibleForTesting;
+
+import javax.annotation.Nullable;
+
+/**
+ * VisibleNetworksTracker keeps track of the visible networks.
+ */
+public class VisibleNetworksTracker {
+    private static final String TAG = "VNTracker";
+
+    @VisibleForTesting
+    static final int AGE_THRESHOLD = 5 * 60 * 1000; // 5 min
+
+    @Nullable
+    private static VisibleNetworks sVisibleNetworks;
+    private static long sVisibleNetworksTime = Long.MAX_VALUE;
+
+    @Nullable
+    private static AsyncTask<Void, Void, VisibleNetworks> sOngoingRefresh = null;
+
+    private static VisibleNetworks sVisibleNetworksForTesting;
+    private static boolean sUseVisibleNetworksForTesting;
+
+    /**
+     * Returns last known visible networks. It returns the cached value if the cache is valid or it
+     * computes the simplest possible visibleNetworks fast, and triggers a background asynchronous
+     * refresh. Might return null if visible networks cannot be computed.
+     */
+    @Nullable
+    public static VisibleNetworks getLastKnownVisibleNetworks(final Context context) {
+        if (sUseVisibleNetworksForTesting) return sVisibleNetworksForTesting;
+
+        if (isValidCachedVisibleNetworks()) return getCachedVisibleNetworks();
+
+        VisibleNetworks visibleNetworks = null;
+        try {
+            // Include only the connected cell/wifi to minimize latency and compute the simplest
+            // visible networks possible.
+            visibleNetworks = PlatformNetworksManager.computeVisibleNetworks(
+                    context, false /* includeAllVisibleNotConnectedNetworks */);
+        } catch (Exception e) {
+            Log.e(TAG, "Failed to get the visible networks. Error: ", e.toString());
+        }
+        // Update cache on the UI thread.
+        ThreadUtils.runOnUiThread(new Runnable() {

[Ted C, 2017/05/18 14:56:30]

When is getLastKnownVisibleNetworks not run on the UI thread? 
GeolocationHeader#getGeoHeader looks to only be called on the UI thread from
prod code?  Is this for tests?  If so, I think we should fix the test instead of
introduce this hop.

[lbargu, 2017/05/18 15:40:41]

Updated to post on UI Thread instead of run.
I wanted to return visible networks as soon as possible, since this is in the
critical path.

Also I don't know enough about where getGeoHeader is called. But if you can
confirm it will always called from UI thread and think we are fine doing this in
the critical path, then I'm happy to remove it.

[Ted C, 2017/05/18 15:45:40]

The two callers are LocationBarLayout#loadUrl and
ChromeActionModeCallback#search, which are both definitely on the UI thread. 
Even the existing GeolocationHeaderTest always calls getGeoHeader on the UI
thread.

So, I would just remove this block entirely.  refreshVisibleNetworks kicks off
an AsyncTask so that is fine in terms of not doing a lot of work on the main
thread.

[lbargu, 2017/05/18 16:02:34]

Done.

+            @Override
+            public void run() {
+                refreshVisibleNetworks(context);
+            }
+        });
+
+        return visibleNetworks;
+    }
+
+    /**
+     * Determines if the visible networks need to be refreshed and asynchronously updates them if
+     * needed.
+     */
+    public static void refreshVisibleNetworks(final Context context) {
+        ThreadUtils.assertOnUiThread();
+        if (isValidCachedVisibleNetworks() || sOngoingRefresh != null) {
+            return;
+        }
+        sOngoingRefresh = new AsyncTask<Void, Void, VisibleNetworks>() {
+            @Override
+            protected VisibleNetworks doInBackground(Void... params) {
+                VisibleNetworks visibleNetworks = null;
+                try {
+                    // Include all visible wifis and cells.
+                    visibleNetworks = PlatformNetworksManager.computeVisibleNetworks(
+                            context, true /* includeAllVisibleNotConnectedNetworks */);
+                } catch (Exception e) {
+                    Log.e(TAG, "Failed to get the visible networks. Error: ", e.toString());
+                }
+                return visibleNetworks;
+            }
+
+            @Override
+            protected void onPostExecute(VisibleNetworks visibleNetworks) {
+                sOngoingRefresh = null;
+                setCachedVisibleNetworks(visibleNetworks);
+            }
+        };
+        sOngoingRefresh.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
+    }
+
+    @Nullable
+    @VisibleForTesting
+    static VisibleNetworks getCachedVisibleNetworks() {
+        return sVisibleNetworks;
+    }
+
+    @VisibleForTesting
+    static long getCachedVisibleNetworksTime() {
+        return sVisibleNetworksTime;
+    }
+
+    @VisibleForTesting
+    static void clearCache() {
+        ThreadUtils.runOnUiThread(new Runnable() {

[Ted C, 2017/05/18 14:56:30]

same thing, if the thread restriction is a test thing, then let's do the thread
wrapping in the test code (and in tests, you might want to do
runOnUiThreadBlocking to make sure the ordering is predictable)

[lbargu, 2017/05/18 15:40:41]

Done.

+            @Override
+            public void run() {
+                setCachedVisibleNetworks(null);
+                sVisibleNetworksTime = Long.MAX_VALUE;
+            }
+        });
+    }
+
+    @VisibleForTesting
+    static void setVisibleNetworksForTesting(VisibleNetworks visibleNetworksForTesting) {
+        sVisibleNetworksForTesting = visibleNetworksForTesting;
+        sUseVisibleNetworksForTesting = true;
+    }
+
+    private static void setCachedVisibleNetworks(VisibleNetworks visibleNetworks) {
+        ThreadUtils.assertOnUiThread();
+        sVisibleNetworks = visibleNetworks;
+        sVisibleNetworksTime = SystemClock.elapsedRealtime();
+    }
+
+    private static boolean isValidCachedVisibleNetworks() {
+        return sVisibleNetworks != null && sVisibleNetworksTime != Long.MAX_VALUE
+                && !sVisibleNetworks.isEmpty()
+                && SystemClock.elapsedRealtime() - sVisibleNetworksTime < AGE_THRESHOLD;
+    }
+}