Listen to default network callbacks for Android Pie.

Listening for LinkProperties changes is required so we can detect if
private DNS is enabled. Register a default-network callback so
NetworkChangeNotifierAutoDetect on Android can listen for these
LinkProperties changes.  Use this default-network callback in place
of CONNECTIVITY_ACTION which is deprecated.

Bug: 885291, 774497
Change-Id: I0e6457f9cb970f1e010171af6c030638b1a667e6
Reviewed-on: https://chromium-review.googlesource.com/1243343
Commit-Queue: Paul Jensen <pauljensen@chromium.org>
Reviewed-by: Cathy Li <chili@chromium.org>
Reviewed-by: Misha Efimov <mef@chromium.org>
Cr-Commit-Position: refs/heads/master@{#594739}

chrome/android/javatests/src/org/chromium/chrome/browser/offlinepages/prefetch/PrefetchFlowTest.java

@@ -71,7 +71,7 @@ public class PrefetchFlowTest implements WebServer.RequestHandler {
         }
         @Override
         public NetworkState getCurrentNetworkState() {
-            return new NetworkState(true, ConnectivityManager.TYPE_WIFI, 0, null);
+            return new NetworkState(true, ConnectivityManager.TYPE_WIFI, 0, null, false);
         }
     }
 

net/android/java/src/org/chromium/net/AndroidNetworkLibrary.java

@@ -56,6 +56,9 @@ class AndroidNetworkLibrary {
 
     private static final String TAG = "AndroidNetworkLibrary";
 
+    // Cached Method for LinkProperties.isPrivateDnsActive().
+    private static Method sIsPrivateDnsActiveMethod;
+
     /**
      * @return the mime type (if any) that is associated with the file
      *         extension. Returns null if no corresponding mime type exists.
@@ -283,6 +286,27 @@ class AndroidNetworkLibrary {
         }
     }
 
+    /**
+     * @returns result of linkProperties.isPrivateDnsActive().
+     */
+    static boolean isPrivateDnsActive(LinkProperties linkProperties) {
+        if (BuildInfo.isAtLeastP() && linkProperties != null) {
+            // TODO(pauljensen): When Android P SDK is available, remove reflection.
+            try {
+                // This could be racy if called on multiple threads, but races will
+                // end in the same result so it's not a problem.
+                if (sIsPrivateDnsActiveMethod == null) {
+                    sIsPrivateDnsActiveMethod =
+                            linkProperties.getClass().getMethod("isPrivateDnsActive");
+                }
+                return ((Boolean) sIsPrivateDnsActiveMethod.invoke(linkProperties)).booleanValue();
+            } catch (Exception e) {
+                Log.e(TAG, "Can not call LinkProperties.isPrivateDnsActive():", e);
+            }
+        }
+        return false;
+    }
+
     /**
      * Returns list of IP addresses of DNS servers.
      * If private DNS is active, then returns a 1x1 array.
@@ -304,19 +328,9 @@ class AndroidNetworkLibrary {
         if (linkProperties == null) {
             return new byte[0][0];
         }
-        if (BuildInfo.isAtLeastP()) {
-            // TODO(pauljensen): When Android P SDK is available, remove reflection.
-            try {
-                if (((Boolean) linkProperties.getClass()
-                                    .getMethod("isPrivateDnsActive")
-                                    .invoke(linkProperties))
-                                .booleanValue()) {
+        if (isPrivateDnsActive(linkProperties)) {
             return new byte[1][1];
         }
-            } catch (Exception e) {
-                Log.e(TAG, "Can not call LinkProperties.isPrivateDnsActive():", e);
-            }
-        }
         List<InetAddress> dnsServersList = linkProperties.getDnsServers();
         byte[][] dnsServers = new byte[dnsServersList.size()][];
         for (int i = 0; i < dnsServersList.size(); i++) {

net/android/javatests/src/org/chromium/net/NetworkChangeNotifierTest.java

@@ -21,6 +21,8 @@ import android.net.Network;
 import android.net.NetworkCapabilities;
 import android.net.NetworkRequest;
 import android.os.Build;
+import android.os.Handler;
+import android.os.Looper;
 import android.os.StrictMode;
 import android.support.test.InstrumentationRegistry;
 import android.support.test.annotation.UiThreadTest;
@@ -35,6 +37,7 @@ import org.junit.Test;
 import org.junit.runner.RunWith;
 
 import org.chromium.base.ApplicationState;
+import org.chromium.base.BuildInfo;
 import org.chromium.base.ContextUtils;
 import org.chromium.base.ThreadUtils;
 import org.chromium.base.library_loader.LibraryLoader;
@@ -187,14 +190,17 @@ public class NetworkChangeNotifierTest {
         private boolean mActiveNetworkExists;
         private int mNetworkType;
         private int mNetworkSubtype;
+        private boolean mIsPrivateDnsActive;
         private NetworkCallback mLastRegisteredNetworkCallback;
+        private NetworkCallback mLastRegisteredDefaultNetworkCallback;
 
         @Override
         public NetworkState getNetworkState(WifiManagerDelegate wifiManagerDelegate) {
             return new NetworkState(mActiveNetworkExists, mNetworkType, mNetworkSubtype,
                     mNetworkType == ConnectivityManager.TYPE_WIFI
                             ? wifiManagerDelegate.getWifiSsid()
-                            : null);
+                            : null,
+                    mIsPrivateDnsActive);
         }
 
         @Override
@@ -246,10 +252,17 @@ public class NetworkChangeNotifierTest {
         // Dummy implementation that also records the last registered callback.
         @Override
         public void registerNetworkCallback(
-                NetworkRequest networkRequest, NetworkCallback networkCallback) {
+                NetworkRequest networkRequest, NetworkCallback networkCallback, Handler handler) {
             mLastRegisteredNetworkCallback = networkCallback;
         }
 
+        // Dummy implementation that also records the last registered callback.
+        @Override
+        public void registerDefaultNetworkCallback(
+                NetworkCallback networkCallback, Handler handler) {
+            mLastRegisteredDefaultNetworkCallback = networkCallback;
+        }
+
         public void setActiveNetworkExists(boolean networkExists) {
             mActiveNetworkExists = networkExists;
         }
@@ -262,10 +275,18 @@ public class NetworkChangeNotifierTest {
             mNetworkSubtype = networkSubtype;
         }
 
+        public void setIsPrivateDnsActive(boolean isPrivateDnsActive) {
+            mIsPrivateDnsActive = isPrivateDnsActive;
+        }
+
         public NetworkCallback getLastRegisteredNetworkCallback() {
             return mLastRegisteredNetworkCallback;
         }
 
+        public NetworkCallback getDefaultNetworkCallback() {
+            return mLastRegisteredDefaultNetworkCallback;
+        }
+
         /**
          * Pretends a network connects.
          * @param netId Network identifier
@@ -413,6 +434,8 @@ public class NetworkChangeNotifierTest {
             // Mock out to avoid unintended system interaction.
             @Override
             public Intent registerReceiver(BroadcastReceiver receiver, IntentFilter filter) {
+                // Should not be used starting with Pie.
+                Assert.assertFalse(BuildInfo.isAtLeastP());
                 return null;
             }
 
@@ -581,6 +604,19 @@ public class NetworkChangeNotifierTest {
         Assert.assertEquals(ConnectionSubtype.SUBTYPE_LTE, getCurrentConnectionSubtype());
     }
 
+    /**
+     * Indicate to NetworkChangeNotifierAutoDetect that a connectivity change has occurred.
+     * Uses same signals that system would use.
+     */
+    private void notifyConnectivityChange() {
+        if (BuildInfo.isAtLeastP()) {
+            mConnectivityDelegate.getDefaultNetworkCallback().onAvailable(null);
+        } else {
+            Intent connectivityIntent = new Intent(ConnectivityManager.CONNECTIVITY_ACTION);
+            mReceiver.onReceive(InstrumentationRegistry.getTargetContext(), connectivityIntent);
+        }
+    }
+
     /**
      * Tests that when Chrome gets an intent indicating a change in network connectivity, it sends a
      * notification to Java observers.
@@ -598,31 +634,51 @@ public class NetworkChangeNotifierTest {
         // We shouldn't be re-notified if the connection hasn't actually changed.
         NetworkChangeNotifierTestObserver observer = new NetworkChangeNotifierTestObserver();
         NetworkChangeNotifier.addConnectionTypeObserver(observer);
-        mReceiver.onReceive(InstrumentationRegistry.getTargetContext(), connectivityIntent);
+        notifyConnectivityChange();
         Assert.assertFalse(observer.hasReceivedNotification());
 
         // We shouldn't be notified if we're connected to non-Wifi and the Wifi SSID changes.
         mWifiDelegate.setWifiSSID("bar");
-        mReceiver.onReceive(InstrumentationRegistry.getTargetContext(), connectivityIntent);
+        notifyConnectivityChange();
         Assert.assertFalse(observer.hasReceivedNotification());
         // We should be notified when we change to Wifi.
         mConnectivityDelegate.setNetworkType(ConnectivityManager.TYPE_WIFI);
-        mReceiver.onReceive(InstrumentationRegistry.getTargetContext(), connectivityIntent);
+        notifyConnectivityChange();
         Assert.assertTrue(observer.hasReceivedNotification());
         observer.resetHasReceivedNotification();
         // We should be notified when the Wifi SSID changes.
         mWifiDelegate.setWifiSSID("foo");
-        mReceiver.onReceive(InstrumentationRegistry.getTargetContext(), connectivityIntent);
+        notifyConnectivityChange();
         Assert.assertTrue(observer.hasReceivedNotification());
         observer.resetHasReceivedNotification();
         // We shouldn't be re-notified if the Wifi SSID hasn't actually changed.
-        mReceiver.onReceive(InstrumentationRegistry.getTargetContext(), connectivityIntent);
+        notifyConnectivityChange();
         Assert.assertFalse(observer.hasReceivedNotification());
 
+        // We should be notified if use of DNS-over-TLS changes.
+        if (BuildInfo.isAtLeastP()) {
+            // Verify notification for enabling.
+            mConnectivityDelegate.setIsPrivateDnsActive(true);
+            mConnectivityDelegate.getDefaultNetworkCallback().onLinkPropertiesChanged(null, null);
+            Assert.assertTrue(observer.hasReceivedNotification());
+            observer.resetHasReceivedNotification();
+            // Verify no notification for no change.
+            mConnectivityDelegate.getDefaultNetworkCallback().onLinkPropertiesChanged(null, null);
+            Assert.assertFalse(observer.hasReceivedNotification());
+            // Verify notification for disbling.
+            mConnectivityDelegate.setIsPrivateDnsActive(false);
+            mConnectivityDelegate.getDefaultNetworkCallback().onLinkPropertiesChanged(null, null);
+            Assert.assertTrue(observer.hasReceivedNotification());
+            observer.resetHasReceivedNotification();
+        }
+
         // Mimic that connectivity has been lost and ensure that Chrome notifies our observer.
         mConnectivityDelegate.setActiveNetworkExists(false);
-        Intent noConnectivityIntent = new Intent(ConnectivityManager.CONNECTIVITY_ACTION);
-        mReceiver.onReceive(InstrumentationRegistry.getTargetContext(), noConnectivityIntent);
+        if (BuildInfo.isAtLeastP()) {
+            mConnectivityDelegate.getDefaultNetworkCallback().onLost(null);
+        } else {
+            mReceiver.onReceive(InstrumentationRegistry.getTargetContext(), connectivityIntent);
+        }
         Assert.assertTrue(observer.hasReceivedNotification());
 
         observer.resetHasReceivedNotification();
@@ -730,7 +786,8 @@ public class NetworkChangeNotifierTest {
             delegate.getDefaultNetwork();
             NetworkCallback networkCallback = new NetworkCallback();
             NetworkRequest networkRequest = new NetworkRequest.Builder().build();
-            delegate.registerNetworkCallback(networkRequest, networkCallback);
+            delegate.registerNetworkCallback(
+                    networkRequest, networkCallback, new Handler(Looper.myLooper()));
             delegate.unregisterNetworkCallback(networkCallback);
         }
     }