Use supported Android network handles in Android M and newer.

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

 // Copyright 2012 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.net;
 
 import static android.net.NetworkCapabilities.NET_CAPABILITY_INTERNET;
 import static android.net.NetworkCapabilities.TRANSPORT_CELLULAR;
 import static android.net.NetworkCapabilities.TRANSPORT_VPN;
 import static android.net.NetworkCapabilities.TRANSPORT_WIFI;
@@ skipping 131 matching lines @@
         private int mNetworkSubtype;
         private NetworkCallback mLastRegisteredNetworkCallback;
 
         @Override
         public NetworkState getNetworkState() {
             return new NetworkState(mActiveNetworkExists, mNetworkType, mNetworkSubtype);
         }
 
         @Override
         protected NetworkCapabilities getNetworkCapabilities(Network network) {
-            int netId = NetworkChangeNotifierAutoDetect.networkToNetId(network);
+            long netId = NetworkChangeNotifierAutoDetect.networkToNetId(network);
             for (MockNetwork mockNetwork : mMockNetworks) {
                 if (netId == mockNetwork.mNetId) {
                     return mockNetwork.getCapabilities();
                 }
             }
             return null;
         }
 
         @Override
         protected boolean vpnAccessible(Network network) {
-            int netId = NetworkChangeNotifierAutoDetect.networkToNetId(network);
+            long netId = NetworkChangeNotifierAutoDetect.networkToNetId(network);
             for (MockNetwork mockNetwork : mMockNetworks) {
                 if (netId == mockNetwork.mNetId) {
                     return mockNetwork.mVpnAccessible;
                 }
             }
             return false;
         }
 
         @Override
         protected Network[] getAllNetworksUnfiltered() {
             Network[] networks = new Network[mMockNetworks.size()];
             for (int i = 0; i < networks.length; i++) {
                 networks[i] = netIdToNetwork(mMockNetworks.get(i).mNetId);
             }
             return networks;
         }
 
         // Dummy implementations to avoid NullPointerExceptions in default implementations:
 
         @Override
-        public int getDefaultNetId() {
+        public long getDefaultNetId() {
             return NetId.INVALID;
         }
 
         @Override
         public NetworkState getNetworkState(Network network) {
             return new NetworkState(false, -1, -1);
         }
 
         @Override
         public void unregisterNetworkCallback(NetworkCallback networkCallback) {}
@@ skipping 76 matching lines @@
 
     // Types of network changes. Each is associated with a NetworkChangeNotifierAutoDetect.Observer
     // callback, and NONE is provided to indicate no callback observed.
     private static enum ChangeType { NONE, CONNECT, SOON_TO_DISCONNECT, DISCONNECT, PURGE_LIST }
 
     // Recorded information about a network change that took place.
     private static class ChangeInfo {
         // The type of change.
         final ChangeType mChangeType;
         // The network identifier of the network changing.
-        final int mNetId;
+        final long mNetId;
 
         /**
          * @param changeType the type of change.
          * @param netId the network identifier of the network changing.
          */
-        ChangeInfo(ChangeType changeType, int netId) {
+        ChangeInfo(ChangeType changeType, long netId) {
             mChangeType = changeType;
             mNetId = netId;
         }
     }
 
     // NetworkChangeNotifierAutoDetect.Observer used to verify proper notifications are sent out.
     // Notifications come back on UI thread. assertLastChange() called on test thread.
     private static class TestNetworkChangeNotifierAutoDetectObserver
             implements NetworkChangeNotifierAutoDetect.Observer {
         // The list of network changes that have been witnessed.
         final ArrayList<ChangeInfo> mChanges = new ArrayList<ChangeInfo>();
 
         @Override
         public void onConnectionTypeChanged(int newConnectionType) {}
         @Override
         public void onMaxBandwidthChanged(double maxBandwidthMbps) {}
 
         @Override
-        public void onNetworkConnect(int netId, int connectionType) {
+        public void onNetworkConnect(long netId, int connectionType) {
             ThreadUtils.assertOnUiThread();
             mChanges.add(new ChangeInfo(ChangeType.CONNECT, netId));
         }
 
         @Override
-        public void onNetworkSoonToDisconnect(int netId) {
+        public void onNetworkSoonToDisconnect(long netId) {
             ThreadUtils.assertOnUiThread();
             mChanges.add(new ChangeInfo(ChangeType.SOON_TO_DISCONNECT, netId));
         }
 
         @Override
-        public void onNetworkDisconnect(int netId) {
+        public void onNetworkDisconnect(long netId) {
             ThreadUtils.assertOnUiThread();
             mChanges.add(new ChangeInfo(ChangeType.DISCONNECT, netId));
         }
 
         @Override
-        public void purgeActiveNetworkList(int[] activeNetIds) {
+        public void purgeActiveNetworkList(long[] activeNetIds) {
             ThreadUtils.assertOnUiThread();
             if (activeNetIds.length == 1) {
                 mChanges.add(new ChangeInfo(ChangeType.PURGE_LIST, activeNetIds[0]));
             } else {
                 mChanges.add(new ChangeInfo(ChangeType.PURGE_LIST, NetId.INVALID));
             }
         }
 
         // Verify last notification was the expected one.
         public void assertLastChange(ChangeType type, int netId) throws Exception {
@@ skipping 424 matching lines @@
         ncn.setConnectivityManagerDelegateForTests(new ConnectivityManagerDelegate() {
             public final Network[] mNetworks =
                     new Network[] {netIdToNetwork(111), netIdToNetwork(333)};
 
             @Override
             protected Network[] getAllNetworksUnfiltered() {
                 return mNetworks;
             }
 
             @Override
-            int getDefaultNetId() {
+            long getDefaultNetId() {
                 return Integer.parseInt(mNetworks[1].toString());
             }
 
             @Override
             protected NetworkCapabilities getNetworkCapabilities(Network network) {
                 return getCapabilities(TRANSPORT_WIFI);
             }
 
             @Override
             public NetworkState getNetworkState(Network network) {
@@ skipping 147 matching lines @@
             mConnectivityDelegate.setActiveNetworkExists(true);
             mConnectivityDelegate.setNetworkType(i);
             mReceiver.onReceive(getInstrumentation().getTargetContext(), intent);
             assertTrue(NetworkChangeNotifier.isOnline());
         }
         mConnectivityDelegate.setActiveNetworkExists(false);
         mReceiver.onReceive(getInstrumentation().getTargetContext(), intent);
         assertFalse(NetworkChangeNotifier.isOnline());
     }
 }