Snap for 7550930 from 72d1a3eabe78bff3506560f7a4ab17ad51322f0e to mainline-resolv-releaseandroid-mainline-12.0.0_r94android-mainline-12.0.0_r80android-mainline-12.0.0_r65android-mainline-12.0.0_r52android-mainline-12.0.0_r35android-mainline-12.0.0_r16android-mainline-12.0.0_r124android-mainline-12.0.0_r108android12-mainline-resolv-release

Change-Id: I7524f92cce583f3a082c30936fe86ead2e30f321

6 files changed, 145 insertions, 172 deletions

diff --git a/Android.bp b/Android.bp
index 6ca5f42..c3393bc 100644
--- a/Android.bp
+++ b/Android.bp
@@ -15,6 +15,10 @@
 // Build the java code
 // ============================================================
 
+package {
+    default_applicable_licenses: ["Android-Apache-2.0"],
+}
+
 java_library {
     name: "ethernet-service",
     installable: true,
diff --git a/java/com/android/server/ethernet/EthernetNetworkFactory.java b/java/com/android/server/ethernet/EthernetNetworkFactory.java
index 793b284..28b24f1 100644
--- a/java/com/android/server/ethernet/EthernetNetworkFactory.java
+++ b/java/com/android/server/ethernet/EthernetNetworkFactory.java
@@ -16,13 +16,13 @@
 
 package com.android.server.ethernet;
 
-import static android.net.shared.LinkPropertiesParcelableUtil.toStableParcelable;
 import static com.android.internal.util.Preconditions.checkNotNull;
 
 import android.annotation.NonNull;
 import android.annotation.Nullable;
 import android.content.Context;
 import android.net.ConnectivityManager;
+import android.net.EthernetNetworkSpecifier;
 import android.net.IpConfiguration;
 import android.net.IpConfiguration.IpAssignment;
 import android.net.IpConfiguration.ProxySettings;
@@ -33,7 +33,6 @@ import android.net.NetworkCapabilities;
 import android.net.NetworkFactory;
 import android.net.NetworkRequest;
 import android.net.NetworkSpecifier;
-import android.net.StringNetworkSpecifier;
 import android.net.ip.IIpClient;
 import android.net.ip.IpClientCallbacks;
 import android.net.ip.IpClientUtil;
@@ -50,8 +49,8 @@ import android.util.SparseArray;
 import com.android.internal.util.IndentingPrintWriter;
 
 import java.io.FileDescriptor;
-import java.util.concurrent.ConcurrentHashMap;
 import java.util.Objects;
+import java.util.concurrent.ConcurrentHashMap;
 
 /**
  * {@link NetworkFactory} that represents Ethernet networks.
@@ -87,20 +86,16 @@ public class EthernetNetworkFactory extends NetworkFactory {
     }
 
     @Override
-    public boolean acceptRequest(NetworkRequest request, int score) {
-        if (request.type == NetworkRequest.Type.TRACK_DEFAULT) {
-            return false;
-        }
-
+    public boolean acceptRequest(NetworkRequest request) {
         if (DBG) {
-            Log.d(TAG, "acceptRequest, request: " + request + ", score: " + score);
+            Log.d(TAG, "acceptRequest, request: " + request);
         }
 
         return networkForRequest(request) != null;
     }
 
     @Override
-    protected void needNetworkFor(NetworkRequest networkRequest, int score) {
+    protected void needNetworkFor(NetworkRequest networkRequest) {
         NetworkInterfaceState network = networkForRequest(networkRequest);
 
         if (network == null) {
@@ -161,12 +156,22 @@ public class EthernetNetworkFactory extends NetworkFactory {
         updateCapabilityFilter();
     }
 
+    private static NetworkCapabilities mixInCapabilities(NetworkCapabilities nc,
+            NetworkCapabilities addedNc) {
+       final NetworkCapabilities.Builder builder = new NetworkCapabilities.Builder(nc);
+       for (int transport : addedNc.getTransportTypes()) builder.addTransportType(transport);
+       for (int capability : addedNc.getCapabilities()) builder.addCapability(capability);
+       return builder.build();
+    }
+
     private void updateCapabilityFilter() {
-        NetworkCapabilities capabilitiesFilter = new NetworkCapabilities();
-        capabilitiesFilter.clearAll();
+        NetworkCapabilities capabilitiesFilter =
+                NetworkCapabilities.Builder.withoutDefaultCapabilities()
+                .addTransportType(NetworkCapabilities.TRANSPORT_ETHERNET)
+                .build();
 
         for (NetworkInterfaceState iface:  mTrackingInterfaces.values()) {
-            capabilitiesFilter.combineCapabilities(iface.mCapabilities);
+            capabilitiesFilter = mixInCapabilities(capabilitiesFilter, iface.mCapabilities);
         }
 
         if (DBG) Log.d(TAG, "updateCapabilityFilter: " + capabilitiesFilter);
@@ -210,20 +215,21 @@ public class EthernetNetworkFactory extends NetworkFactory {
     private NetworkInterfaceState networkForRequest(NetworkRequest request) {
         String requestedIface = null;
 
-        NetworkSpecifier specifier = request.networkCapabilities.getNetworkSpecifier();
-        if (specifier instanceof StringNetworkSpecifier) {
-            requestedIface = ((StringNetworkSpecifier) specifier).specifier;
+        NetworkSpecifier specifier = request.getNetworkSpecifier();
+        if (specifier instanceof EthernetNetworkSpecifier) {
+            requestedIface = ((EthernetNetworkSpecifier) specifier)
+                .getInterfaceName();
         }
 
         NetworkInterfaceState network = null;
         if (!TextUtils.isEmpty(requestedIface)) {
             NetworkInterfaceState n = mTrackingInterfaces.get(requestedIface);
-            if (n != null && n.satisfied(request.networkCapabilities)) {
+            if (n != null && request.canBeSatisfiedBy(n.mCapabilities)) {
                 network = n;
             }
         } else {
             for (NetworkInterfaceState n : mTrackingInterfaces.values()) {
-                if (n.satisfied(request.networkCapabilities) && n.mLinkUp) {
+                if (request.canBeSatisfiedBy(n.mCapabilities) && n.mLinkUp) {
                     network = n;
                     break;
                 }
@@ -466,6 +472,7 @@ public class EthernetNetworkFactory extends NetworkFactory {
             final NetworkAgentConfig config = new NetworkAgentConfig.Builder()
                     .setLegacyType(mLegacyType)
                     .setLegacyTypeName(NETWORK_TYPE)
+                    .setLegacyExtraInfo(mHwAddress)
                     .build();
             mNetworkAgent = new NetworkAgent(mContext, mHandler.getLooper(),
                     NETWORK_TYPE, mCapabilities, mLinkProperties,
@@ -480,7 +487,6 @@ public class EthernetNetworkFactory extends NetworkFactory {
                 }
             };
             mNetworkAgent.register();
-            mNetworkAgent.setLegacyExtraInfo(mHwAddress);
             mNetworkAgent.markConnected();
         }
 
@@ -552,7 +558,7 @@ public class EthernetNetworkFactory extends NetworkFactory {
             if (config.getProxySettings() == ProxySettings.STATIC ||
                     config.getProxySettings() == ProxySettings.PAC) {
                 try {
-                    ipClient.setHttpProxy(toStableParcelable(config.getHttpProxy()));
+                    ipClient.setHttpProxy(config.getHttpProxy());
                 } catch (RemoteException e) {
                     e.rethrowFromSystemServer();
                 }
diff --git a/java/com/android/server/ethernet/EthernetServiceImpl.java b/java/com/android/server/ethernet/EthernetServiceImpl.java
index 3fc6aab..c06f61e 100644
--- a/java/com/android/server/ethernet/EthernetServiceImpl.java
+++ b/java/com/android/server/ethernet/EthernetServiceImpl.java
@@ -87,6 +87,8 @@ public class EthernetServiceImpl extends IEthernetManager.Stub {
 
     @Override
     public String[] getAvailableInterfaces() throws RemoteException {
+        enforceAccessPermission();
+
         return mTracker.getInterfaces(checkUseRestrictedNetworksPermission());
     }
 
diff --git a/java/com/android/server/ethernet/EthernetTracker.java b/java/com/android/server/ethernet/EthernetTracker.java
index d7fd408..b2b60fc 100644
--- a/java/com/android/server/ethernet/EthernetTracker.java
+++ b/java/com/android/server/ethernet/EthernetTracker.java
@@ -21,6 +21,7 @@ import static android.net.TestNetworkManager.TEST_TAP_PREFIX;
 import android.annotation.Nullable;
 import android.content.Context;
 import android.net.IEthernetServiceListener;
+import android.net.INetd;
 import android.net.ITetheredInterfaceCallback;
 import android.net.InterfaceConfiguration;
 import android.net.IpConfiguration;
@@ -28,6 +29,7 @@ import android.net.IpConfiguration.IpAssignment;
 import android.net.IpConfiguration.ProxySettings;
 import android.net.LinkAddress;
 import android.net.NetworkCapabilities;
+import android.net.NetworkStack;
 import android.net.StaticIpConfiguration;
 import android.os.Handler;
 import android.os.IBinder;
@@ -38,14 +40,17 @@ import android.os.ServiceManager;
 import android.text.TextUtils;
 import android.util.ArrayMap;
 import android.util.Log;
+import android.net.util.NetdService;
 
 import com.android.internal.annotations.VisibleForTesting;
 import com.android.internal.util.IndentingPrintWriter;
+import com.android.net.module.util.NetdUtils;
 import com.android.server.net.BaseNetworkObserver;
 
 import java.io.FileDescriptor;
 import java.net.InetAddress;
 import java.util.ArrayList;
+import java.util.Objects;
 import java.util.concurrent.ConcurrentHashMap;
 
 /**
@@ -87,6 +92,7 @@ final class EthernetTracker {
 
     private final Context mContext;
     private final INetworkManagementService mNMService;
+    private final INetd mNetd;
     private final Handler mHandler;
     private final EthernetNetworkFactory mFactory;
     private final EthernetConfigStore mConfigStore;
@@ -117,6 +123,7 @@ final class EthernetTracker {
         // The services we use.
         IBinder b = ServiceManager.getService(Context.NETWORKMANAGEMENT_SERVICE);
         mNMService = INetworkManagementService.Stub.asInterface(b);
+        mNetd = Objects.requireNonNull(NetdService.getInstance(), "could not get netd instance");
 
         // Interface match regex.
         updateIfaceMatchRegexp();
@@ -280,7 +287,8 @@ final class EthernetTracker {
         InterfaceConfiguration config = null;
         // Bring up the interface so we get link status indications.
         try {
-            mNMService.setInterfaceUp(iface);
+            NetworkStack.checkNetworkStackPermission(mContext);
+            NetdUtils.setInterfaceUp(mNetd, iface);
             config = mNMService.getInterfaceConfig(iface);
         } catch (RemoteException | IllegalStateException e) {
             // Either the system is crashing or the interface has disappeared. Just ignore the
@@ -451,7 +459,7 @@ final class EthernetTracker {
         String transport = tokens.length > 3 ? tokens[3] : null;
         NetworkCapabilities nc = createNetworkCapabilities(
                 !TextUtils.isEmpty(capabilities)  /* clear default capabilities */, capabilities,
-                transport);
+                transport).build();
         mNetworkCapabilities.put(name, nc);
 
         if (tokens.length > 2 && !TextUtils.isEmpty(tokens[2])) {
@@ -461,24 +469,26 @@ final class EthernetTracker {
     }
 
     private static NetworkCapabilities createDefaultNetworkCapabilities(boolean isTestIface) {
-        NetworkCapabilities nc = createNetworkCapabilities(false /* clear default capabilities */);
-        nc.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED);
-        nc.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_METERED);
-        nc.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_ROAMING);
-        nc.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_CONGESTED);
-        nc.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_SUSPENDED);
+        NetworkCapabilities.Builder builder = createNetworkCapabilities(
+                false /* clear default capabilities */, null, null)
+                .addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED)
+                .addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_METERED)
+                .addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_ROAMING)
+                .addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_CONGESTED)
+                .addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_SUSPENDED)
+                .addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_VCN_MANAGED);
 
         if (isTestIface) {
-            nc.addTransportType(NetworkCapabilities.TRANSPORT_TEST);
+                builder.addTransportType(NetworkCapabilities.TRANSPORT_TEST);
         } else {
-            nc.addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET);
+                builder.addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET);
         }
 
-        return nc;
+        return builder.build();
     }
 
     private static NetworkCapabilities createNetworkCapabilities(boolean clearDefaultCapabilities) {
-        return createNetworkCapabilities(clearDefaultCapabilities, null, null);
+        return createNetworkCapabilities(clearDefaultCapabilities, null, null).build();
     }
 
     /**
@@ -493,14 +503,13 @@ final class EthernetTracker {
      *                          will cause the override to be ignored.
      */
     @VisibleForTesting
-    static NetworkCapabilities createNetworkCapabilities(
+    static NetworkCapabilities.Builder createNetworkCapabilities(
             boolean clearDefaultCapabilities, @Nullable String commaSeparatedCapabilities,
             @Nullable String overrideTransport) {
 
-        NetworkCapabilities nc = new NetworkCapabilities();
-        if (clearDefaultCapabilities) {
-            nc.clearAll();  // Remove default capabilities and transports
-        }
+        final NetworkCapabilities.Builder builder = clearDefaultCapabilities
+                ? NetworkCapabilities.Builder.withoutDefaultCapabilities()
+                : new NetworkCapabilities.Builder();
 
         // Determine the transport type. If someone has tried to define an override transport then
         // attempt to add it. Since we can only have one override, all errors with it will
@@ -527,21 +536,21 @@ final class EthernetTracker {
         // Apply the transport. If the user supplied a valid number that is not a valid transport
         // then adding will throw an exception. Default back to TRANSPORT_ETHERNET if that happens
         try {
-            nc.addTransportType(transport);
+            builder.addTransportType(transport);
         } catch (IllegalArgumentException iae) {
             Log.e(TAG, transport + " is not a valid NetworkCapability.TRANSPORT_* value. "
                     + "Defaulting to TRANSPORT_ETHERNET");
-            nc.addTransportType(NetworkCapabilities.TRANSPORT_ETHERNET);
+            builder.addTransportType(NetworkCapabilities.TRANSPORT_ETHERNET);
         }
 
-        nc.setLinkUpstreamBandwidthKbps(100 * 1000);
-        nc.setLinkDownstreamBandwidthKbps(100 * 1000);
+        builder.setLinkUpstreamBandwidthKbps(100 * 1000);
+        builder.setLinkDownstreamBandwidthKbps(100 * 1000);
 
         if (!TextUtils.isEmpty(commaSeparatedCapabilities)) {
             for (String strNetworkCapability : commaSeparatedCapabilities.split(",")) {
                 if (!TextUtils.isEmpty(strNetworkCapability)) {
                     try {
-                        nc.addCapability(Integer.valueOf(strNetworkCapability));
+                        builder.addCapability(Integer.valueOf(strNetworkCapability));
                     } catch (NumberFormatException nfe) {
                         Log.e(TAG, "Capability '" + strNetworkCapability + "' could not be parsed");
                     } catch (IllegalArgumentException iae) {
@@ -553,11 +562,11 @@ final class EthernetTracker {
         }
         // Ethernet networks have no way to update the following capabilities, so they always
         // have them.
-        nc.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_ROAMING);
-        nc.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_CONGESTED);
-        nc.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_SUSPENDED);
+        builder.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_ROAMING);
+        builder.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_CONGESTED);
+        builder.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_SUSPENDED);
 
-        return nc;
+        return builder;
     }
 
     /**
@@ -569,7 +578,8 @@ final class EthernetTracker {
      */
     @VisibleForTesting
     static IpConfiguration parseStaticIpConfiguration(String staticIpConfig) {
-        StaticIpConfiguration ipConfig = new StaticIpConfiguration();
+        final StaticIpConfiguration.Builder staticIpConfigBuilder =
+                new StaticIpConfiguration.Builder();
 
         for (String keyValueAsString : staticIpConfig.trim().split(" ")) {
             if (TextUtils.isEmpty(keyValueAsString)) continue;
@@ -585,20 +595,20 @@ final class EthernetTracker {
 
             switch (key) {
                 case "ip":
-                    ipConfig.ipAddress = new LinkAddress(value);
+                    staticIpConfigBuilder.setIpAddress(new LinkAddress(value));
                     break;
                 case "domains":
-                    ipConfig.domains = value;
+                    staticIpConfigBuilder.setDomains(value);
                     break;
                 case "gateway":
-                    ipConfig.gateway = InetAddress.parseNumericAddress(value);
+                    staticIpConfigBuilder.setGateway(InetAddress.parseNumericAddress(value));
                     break;
                 case "dns": {
                     ArrayList<InetAddress> dnsAddresses = new ArrayList<>();
                     for (String address: value.split(",")) {
                         dnsAddresses.add(InetAddress.parseNumericAddress(address));
                     }
-                    ipConfig.dnsServers.addAll(dnsAddresses);
+                    staticIpConfigBuilder.setDnsServers(dnsAddresses);
                     break;
                 }
                 default : {
@@ -607,11 +617,18 @@ final class EthernetTracker {
                 }
             }
         }
-        return new IpConfiguration(IpAssignment.STATIC, ProxySettings.NONE, ipConfig, null);
+        final IpConfiguration ret = new IpConfiguration();
+        ret.setIpAssignment(IpAssignment.STATIC);
+        ret.setProxySettings(ProxySettings.NONE);
+        ret.setStaticIpConfiguration(staticIpConfigBuilder.build());
+        return ret;
     }
 
     private static IpConfiguration createDefaultIpConfiguration() {
-        return new IpConfiguration(IpAssignment.DHCP, ProxySettings.NONE, null, null);
+        final IpConfiguration ret = new IpConfiguration();
+        ret.setIpAssignment(IpAssignment.DHCP);
+        ret.setProxySettings(ProxySettings.NONE);
+        return ret;
     }
 
     private void updateIfaceMatchRegexp() {
diff --git a/tests/Android.bp b/tests/Android.bp
index 9c776e6..4b2d270 100644
--- a/tests/Android.bp
+++ b/tests/Android.bp
@@ -13,6 +13,10 @@
 // limitations under the License.
 //
 
+package {
+    default_applicable_licenses: ["Android-Apache-2.0"],
+}
+
 android_test {
     name: "EthernetServiceTests",
 
diff --git a/tests/java/com/android/server/ethernet/EthernetTrackerTest.java b/tests/java/com/android/server/ethernet/EthernetTrackerTest.java
index 67740b6..ee9f349 100644
--- a/tests/java/com/android/server/ethernet/EthernetTrackerTest.java
+++ b/tests/java/com/android/server/ethernet/EthernetTrackerTest.java
@@ -19,6 +19,7 @@ package com.android.server.ethernet;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.fail;
 
+import android.net.InetAddresses;
 import android.net.IpConfiguration;
 import android.net.IpConfiguration.IpAssignment;
 import android.net.IpConfiguration.ProxySettings;
@@ -33,6 +34,7 @@ import org.junit.Test;
 import org.junit.runner.RunWith;
 
 import java.net.InetAddress;
+import java.util.ArrayList;
 
 @SmallTest
 @RunWith(AndroidJUnit4.class)
@@ -46,28 +48,26 @@ public class EthernetTrackerTest {
         assertStaticConfiguration(new StaticIpConfiguration(), "");
 
         // Setting only the IP address properly cascades and assumes defaults
-        assertStaticConfiguration(
-                new StaticIpConfigBuilder().setIp("192.0.2.10/24").build(),
-                "ip=192.0.2.10/24");
+        assertStaticConfiguration(new StaticIpConfiguration.Builder()
+                .setIpAddress(new LinkAddress("192.0.2.10/24")).build(), "ip=192.0.2.10/24");
 
+        final ArrayList<InetAddress> dnsAddresses = new ArrayList<>();
+        dnsAddresses.add(InetAddresses.parseNumericAddress("4.4.4.4"));
+        dnsAddresses.add(InetAddresses.parseNumericAddress("8.8.8.8"));
         // Setting other fields properly cascades them
-        assertStaticConfiguration(
-                new StaticIpConfigBuilder()
-                        .setIp("192.0.2.10/24")
-                        .setDns(new String[] {"4.4.4.4", "8.8.8.8"})
-                        .setGateway("192.0.2.1")
-                        .setDomains("android")
-                        .build(),
+        assertStaticConfiguration(new StaticIpConfiguration.Builder()
+                .setIpAddress(new LinkAddress("192.0.2.10/24"))
+                .setDnsServers(dnsAddresses)
+                .setGateway(InetAddresses.parseNumericAddress("192.0.2.1"))
+                .setDomains("android").build(),
                 "ip=192.0.2.10/24 dns=4.4.4.4,8.8.8.8 gateway=192.0.2.1 domains=android");
 
         // Verify order doesn't matter
-        assertStaticConfiguration(
-                new StaticIpConfigBuilder()
-                        .setIp("192.0.2.10/24")
-                        .setDns(new String[] {"4.4.4.4", "8.8.8.8"})
-                        .setGateway("192.0.2.1")
-                        .setDomains("android")
-                        .build(),
+        assertStaticConfiguration(new StaticIpConfiguration.Builder()
+                .setIpAddress(new LinkAddress("192.0.2.10/24"))
+                .setDnsServers(dnsAddresses)
+                .setGateway(InetAddresses.parseNumericAddress("192.0.2.1"))
+                .setDomains("android").build(),
                 "domains=android ip=192.0.2.10/24 gateway=192.0.2.1 dns=4.4.4.4,8.8.8.8 ");
     }
 
@@ -96,41 +96,22 @@ public class EthernetTrackerTest {
 
     private void assertStaticConfiguration(StaticIpConfiguration expectedStaticIpConfig,
                 String configAsString) {
-        IpConfiguration expectedIpConfiguration = new IpConfiguration(IpAssignment.STATIC,
-                ProxySettings.NONE, expectedStaticIpConfig, null);
+        final IpConfiguration expectedIpConfiguration = new IpConfiguration();
+        expectedIpConfiguration.setIpAssignment(IpAssignment.STATIC);
+        expectedIpConfiguration.setProxySettings(ProxySettings.NONE);
+        expectedIpConfiguration.setStaticIpConfiguration(expectedStaticIpConfig);
 
         assertEquals(expectedIpConfiguration,
                 EthernetTracker.parseStaticIpConfiguration(configAsString));
     }
 
-    private static class StaticIpConfigBuilder {
-        private final StaticIpConfiguration config = new StaticIpConfiguration();
-
-        StaticIpConfigBuilder setIp(String address) {
-            config.ipAddress = new LinkAddress(address);
-            return this;
-        }
-
-        StaticIpConfigBuilder setDns(String[] dnsArray) {
-            for (String dns : dnsArray) {
-                config.dnsServers.add(InetAddress.parseNumericAddress(dns));
-            }
-            return this;
-        }
-
-        StaticIpConfigBuilder setGateway(String gateway) {
-            config.gateway = InetAddress.parseNumericAddress(gateway);
-            return this;
-        }
-
-        StaticIpConfigBuilder setDomains(String domains) {
-            config.domains = domains;
-            return this;
-        }
-
-        StaticIpConfiguration build() {
-            return new StaticIpConfiguration(config);
-        }
+    private NetworkCapabilities.Builder makeEthernetCapabilitiesBuilder(boolean clearAll) {
+        final NetworkCapabilities.Builder builder =
+                clearAll ? NetworkCapabilities.Builder.withoutDefaultCapabilities()
+                        : new NetworkCapabilities.Builder();
+        return builder.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_ROAMING)
+                .addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_CONGESTED)
+                .addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_SUSPENDED);
     }
 
     /**
@@ -140,23 +121,23 @@ public class EthernetTrackerTest {
     public void createNetworkCapabilities() {
 
         // Particularly common expected results
-        NetworkCapabilities defaultEthernetCleared = new NetworkCapabilitiesBuilder()
-                .clearAll()
-                .setLinkUpstreamBandwidthKbps(100000)
-                .setLinkDownstreamBandwidthKbps(100000)
-                .addTransport(NetworkCapabilities.TRANSPORT_ETHERNET)
-                .build();
+        NetworkCapabilities defaultEthernetCleared =
+                makeEthernetCapabilitiesBuilder(true /* clearAll */)
+                        .setLinkUpstreamBandwidthKbps(100000)
+                        .setLinkDownstreamBandwidthKbps(100000)
+                        .addTransportType(NetworkCapabilities.TRANSPORT_ETHERNET)
+                        .build();
 
-        NetworkCapabilities ethernetClearedWithCommonCaps = new NetworkCapabilitiesBuilder()
-                .clearAll()
-                .setLinkUpstreamBandwidthKbps(100000)
-                .setLinkDownstreamBandwidthKbps(100000)
-                .addTransport(NetworkCapabilities.TRANSPORT_ETHERNET)
-                .addCapability(12)
-                .addCapability(13)
-                .addCapability(14)
-                .addCapability(15)
-                .build();
+        NetworkCapabilities ethernetClearedWithCommonCaps =
+                makeEthernetCapabilitiesBuilder(true /* clearAll */)
+                        .setLinkUpstreamBandwidthKbps(100000)
+                        .setLinkDownstreamBandwidthKbps(100000)
+                        .addTransportType(NetworkCapabilities.TRANSPORT_ETHERNET)
+                        .addCapability(12)
+                        .addCapability(13)
+                        .addCapability(14)
+                        .addCapability(15)
+                        .build();
 
         // Empty capabilities and transports lists with a "please clear defaults" should
         // yield an empty capabilities set with TRANPORT_ETHERNET
@@ -165,20 +146,20 @@ public class EthernetTrackerTest {
         // Empty capabilities and transports without the clear defaults flag should return the
         // default capabilities set with TRANSPORT_ETHERNET
         assertParsedNetworkCapabilities(
-                new NetworkCapabilitiesBuilder()
+                makeEthernetCapabilitiesBuilder(false /* clearAll */)
                         .setLinkUpstreamBandwidthKbps(100000)
                         .setLinkDownstreamBandwidthKbps(100000)
-                        .addTransport(NetworkCapabilities.TRANSPORT_ETHERNET)
+                        .addTransportType(NetworkCapabilities.TRANSPORT_ETHERNET)
                         .build(),
                 false, "", "");
 
         // A list of capabilities without the clear defaults flag should return the default
         // capabilities, mixed with the desired capabilities, and TRANSPORT_ETHERNET
         assertParsedNetworkCapabilities(
-                new NetworkCapabilitiesBuilder()
+                makeEthernetCapabilitiesBuilder(false /* clearAll */)
                         .setLinkUpstreamBandwidthKbps(100000)
                         .setLinkDownstreamBandwidthKbps(100000)
-                        .addTransport(NetworkCapabilities.TRANSPORT_ETHERNET)
+                        .addTransportType(NetworkCapabilities.TRANSPORT_ETHERNET)
                         .addCapability(11)
                         .addCapability(12)
                         .build(),
@@ -195,35 +176,31 @@ public class EthernetTrackerTest {
         // Adding a valid override transport will remove the default TRANSPORT_ETHERNET transport
         // and apply only the override to the capabiltities object
         assertParsedNetworkCapabilities(
-                new NetworkCapabilitiesBuilder()
-                        .clearAll()
+                makeEthernetCapabilitiesBuilder(true /* clearAll */)
                         .setLinkUpstreamBandwidthKbps(100000)
                         .setLinkDownstreamBandwidthKbps(100000)
-                        .addTransport(0)
+                        .addTransportType(0)
                         .build(),
                 true, "", "0");
         assertParsedNetworkCapabilities(
-                new NetworkCapabilitiesBuilder()
-                        .clearAll()
+                makeEthernetCapabilitiesBuilder(true /* clearAll */)
                         .setLinkUpstreamBandwidthKbps(100000)
                         .setLinkDownstreamBandwidthKbps(100000)
-                        .addTransport(1)
+                        .addTransportType(1)
                         .build(),
                 true, "", "1");
         assertParsedNetworkCapabilities(
-                new NetworkCapabilitiesBuilder()
-                        .clearAll()
+                makeEthernetCapabilitiesBuilder(true /* clearAll */)
                         .setLinkUpstreamBandwidthKbps(100000)
                         .setLinkDownstreamBandwidthKbps(100000)
-                        .addTransport(2)
+                        .addTransportType(2)
                         .build(),
                 true, "", "2");
         assertParsedNetworkCapabilities(
-                new NetworkCapabilitiesBuilder()
-                        .clearAll()
+                makeEthernetCapabilitiesBuilder(true /* clearAll */)
                         .setLinkUpstreamBandwidthKbps(100000)
                         .setLinkDownstreamBandwidthKbps(100000)
-                        .addTransport(3)
+                        .addTransportType(3)
                         .build(),
                 true, "", "3");
 
@@ -244,15 +221,14 @@ public class EthernetTrackerTest {
 
         // Ensure the adding of both capabilities and transports work
         assertParsedNetworkCapabilities(
-                new NetworkCapabilitiesBuilder()
-                        .clearAll()
+                makeEthernetCapabilitiesBuilder(true /* clearAll */)
                         .setLinkUpstreamBandwidthKbps(100000)
                         .setLinkDownstreamBandwidthKbps(100000)
                         .addCapability(12)
                         .addCapability(13)
                         .addCapability(14)
                         .addCapability(15)
-                        .addTransport(3)
+                        .addTransportType(3)
                         .build(),
                 true, "12,13,14,15", "3");
 
@@ -264,42 +240,6 @@ public class EthernetTrackerTest {
             boolean clearCapabilties, String configCapabiltiies,String configTransports) {
         assertEquals(expectedNetworkCapabilities,
                 EthernetTracker.createNetworkCapabilities(clearCapabilties, configCapabiltiies,
-                        configTransports));
-    }
-
-    private static class NetworkCapabilitiesBuilder {
-        private final NetworkCapabilities nc = new NetworkCapabilities();
-
-        NetworkCapabilitiesBuilder clearAll(){
-            // This is THE ONLY one that doesn't return a reference to the object so I wrapped
-            // everything in a builder to keep things consistent and clean above. Fix if this
-            // ever changes
-            nc.clearAll();
-            return this;
-        }
-
-        NetworkCapabilitiesBuilder addCapability(int capability) {
-            nc.addCapability(capability);
-            return this;
-        }
-
-        NetworkCapabilitiesBuilder addTransport(int transport) {
-            nc.addTransportType(transport);
-            return this;
-        }
-
-        NetworkCapabilitiesBuilder setLinkUpstreamBandwidthKbps(int upKbps) {
-            nc.setLinkUpstreamBandwidthKbps(upKbps);
-            return this;
-        }
-
-        NetworkCapabilitiesBuilder setLinkDownstreamBandwidthKbps(int downKbps) {
-            nc.setLinkDownstreamBandwidthKbps(downKbps);
-            return this;
-        }
-
-        NetworkCapabilities build() {
-            return new NetworkCapabilities(nc);
-        }
+                        configTransports).build());
     }
 }