Snap for 8426163 from 7b0961dc0d3f2c3f811ba9c1c725eb3a22537f59 to mainline-tzdata2-releaseandroid-mainline-12.0.0_r112aml_tz2_305400500aml_tz2_305400300aml_tz2_305400100aml_tz2_304500300aml_tz2_303900110aml_tz2_303900102aml_tz2_303800002aml_tz2_303800001aml_tz2_303200001android12-mainline-tzdata2-releaseaml_tz2_305400100

Change-Id: I92c336f92e68fef88c2e82ea554471566052a3a8

6 files changed, 172 insertions, 145 deletions

diff --git a/Android.bp b/Android.bp
index c3393bc..6ca5f42 100644
--- a/Android.bp
+++ b/Android.bp
@@ -15,10 +15,6 @@
 // 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 28b24f1..793b284 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,6 +33,7 @@ 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;
@@ -49,8 +50,8 @@ import android.util.SparseArray;
 import com.android.internal.util.IndentingPrintWriter;
 
 import java.io.FileDescriptor;
-import java.util.Objects;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.Objects;
 
 /**
  * {@link NetworkFactory} that represents Ethernet networks.
@@ -86,16 +87,20 @@ public class EthernetNetworkFactory extends NetworkFactory {
     }
 
     @Override
-    public boolean acceptRequest(NetworkRequest request) {
+    public boolean acceptRequest(NetworkRequest request, int score) {
+        if (request.type == NetworkRequest.Type.TRACK_DEFAULT) {
+            return false;
+        }
+
         if (DBG) {
-            Log.d(TAG, "acceptRequest, request: " + request);
+            Log.d(TAG, "acceptRequest, request: " + request + ", score: " + score);
         }
 
         return networkForRequest(request) != null;
     }
 
     @Override
-    protected void needNetworkFor(NetworkRequest networkRequest) {
+    protected void needNetworkFor(NetworkRequest networkRequest, int score) {
         NetworkInterfaceState network = networkForRequest(networkRequest);
 
         if (network == null) {
@@ -156,22 +161,12 @@ 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 =
-                NetworkCapabilities.Builder.withoutDefaultCapabilities()
-                .addTransportType(NetworkCapabilities.TRANSPORT_ETHERNET)
-                .build();
+        NetworkCapabilities capabilitiesFilter = new NetworkCapabilities();
+        capabilitiesFilter.clearAll();
 
         for (NetworkInterfaceState iface:  mTrackingInterfaces.values()) {
-            capabilitiesFilter = mixInCapabilities(capabilitiesFilter, iface.mCapabilities);
+            capabilitiesFilter.combineCapabilities(iface.mCapabilities);
         }
 
         if (DBG) Log.d(TAG, "updateCapabilityFilter: " + capabilitiesFilter);
@@ -215,21 +210,20 @@ public class EthernetNetworkFactory extends NetworkFactory {
     private NetworkInterfaceState networkForRequest(NetworkRequest request) {
         String requestedIface = null;
 
-        NetworkSpecifier specifier = request.getNetworkSpecifier();
-        if (specifier instanceof EthernetNetworkSpecifier) {
-            requestedIface = ((EthernetNetworkSpecifier) specifier)
-                .getInterfaceName();
+        NetworkSpecifier specifier = request.networkCapabilities.getNetworkSpecifier();
+        if (specifier instanceof StringNetworkSpecifier) {
+            requestedIface = ((StringNetworkSpecifier) specifier).specifier;
         }
 
         NetworkInterfaceState network = null;
         if (!TextUtils.isEmpty(requestedIface)) {
             NetworkInterfaceState n = mTrackingInterfaces.get(requestedIface);
-            if (n != null && request.canBeSatisfiedBy(n.mCapabilities)) {
+            if (n != null && n.satisfied(request.networkCapabilities)) {
                 network = n;
             }
         } else {
             for (NetworkInterfaceState n : mTrackingInterfaces.values()) {
-                if (request.canBeSatisfiedBy(n.mCapabilities) && n.mLinkUp) {
+                if (n.satisfied(request.networkCapabilities) && n.mLinkUp) {
                     network = n;
                     break;
                 }
@@ -472,7 +466,6 @@ 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,
@@ -487,6 +480,7 @@ public class EthernetNetworkFactory extends NetworkFactory {
                 }
             };
             mNetworkAgent.register();
+            mNetworkAgent.setLegacyExtraInfo(mHwAddress);
             mNetworkAgent.markConnected();
         }
 
@@ -558,7 +552,7 @@ public class EthernetNetworkFactory extends NetworkFactory {
             if (config.getProxySettings() == ProxySettings.STATIC ||
                     config.getProxySettings() == ProxySettings.PAC) {
                 try {
-                    ipClient.setHttpProxy(config.getHttpProxy());
+                    ipClient.setHttpProxy(toStableParcelable(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 c06f61e..3fc6aab 100644
--- a/java/com/android/server/ethernet/EthernetServiceImpl.java
+++ b/java/com/android/server/ethernet/EthernetServiceImpl.java
@@ -87,8 +87,6 @@ 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 b2b60fc..d7fd408 100644
--- a/java/com/android/server/ethernet/EthernetTracker.java
+++ b/java/com/android/server/ethernet/EthernetTracker.java
@@ -21,7 +21,6 @@ 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;
@@ -29,7 +28,6 @@ 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;
@@ -40,17 +38,14 @@ 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;
 
 /**
@@ -92,7 +87,6 @@ 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;
@@ -123,7 +117,6 @@ 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();
@@ -287,8 +280,7 @@ final class EthernetTracker {
         InterfaceConfiguration config = null;
         // Bring up the interface so we get link status indications.
         try {
-            NetworkStack.checkNetworkStackPermission(mContext);
-            NetdUtils.setInterfaceUp(mNetd, iface);
+            mNMService.setInterfaceUp(iface);
             config = mNMService.getInterfaceConfig(iface);
         } catch (RemoteException | IllegalStateException e) {
             // Either the system is crashing or the interface has disappeared. Just ignore the
@@ -459,7 +451,7 @@ final class EthernetTracker {
         String transport = tokens.length > 3 ? tokens[3] : null;
         NetworkCapabilities nc = createNetworkCapabilities(
                 !TextUtils.isEmpty(capabilities)  /* clear default capabilities */, capabilities,
-                transport).build();
+                transport);
         mNetworkCapabilities.put(name, nc);
 
         if (tokens.length > 2 && !TextUtils.isEmpty(tokens[2])) {
@@ -469,26 +461,24 @@ final class EthernetTracker {
     }
 
     private static NetworkCapabilities createDefaultNetworkCapabilities(boolean isTestIface) {
-        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);
+        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);
 
         if (isTestIface) {
-                builder.addTransportType(NetworkCapabilities.TRANSPORT_TEST);
+            nc.addTransportType(NetworkCapabilities.TRANSPORT_TEST);
         } else {
-                builder.addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET);
+            nc.addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET);
         }
 
-        return builder.build();
+        return nc;
     }
 
     private static NetworkCapabilities createNetworkCapabilities(boolean clearDefaultCapabilities) {
-        return createNetworkCapabilities(clearDefaultCapabilities, null, null).build();
+        return createNetworkCapabilities(clearDefaultCapabilities, null, null);
     }
 
     /**
@@ -503,13 +493,14 @@ final class EthernetTracker {
      *                          will cause the override to be ignored.
      */
     @VisibleForTesting
-    static NetworkCapabilities.Builder createNetworkCapabilities(
+    static NetworkCapabilities createNetworkCapabilities(
             boolean clearDefaultCapabilities, @Nullable String commaSeparatedCapabilities,
             @Nullable String overrideTransport) {
 
-        final NetworkCapabilities.Builder builder = clearDefaultCapabilities
-                ? NetworkCapabilities.Builder.withoutDefaultCapabilities()
-                : new NetworkCapabilities.Builder();
+        NetworkCapabilities nc = new NetworkCapabilities();
+        if (clearDefaultCapabilities) {
+            nc.clearAll();  // Remove default capabilities and transports
+        }
 
         // 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
@@ -536,21 +527,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 {
-            builder.addTransportType(transport);
+            nc.addTransportType(transport);
         } catch (IllegalArgumentException iae) {
             Log.e(TAG, transport + " is not a valid NetworkCapability.TRANSPORT_* value. "
                     + "Defaulting to TRANSPORT_ETHERNET");
-            builder.addTransportType(NetworkCapabilities.TRANSPORT_ETHERNET);
+            nc.addTransportType(NetworkCapabilities.TRANSPORT_ETHERNET);
         }
 
-        builder.setLinkUpstreamBandwidthKbps(100 * 1000);
-        builder.setLinkDownstreamBandwidthKbps(100 * 1000);
+        nc.setLinkUpstreamBandwidthKbps(100 * 1000);
+        nc.setLinkDownstreamBandwidthKbps(100 * 1000);
 
         if (!TextUtils.isEmpty(commaSeparatedCapabilities)) {
             for (String strNetworkCapability : commaSeparatedCapabilities.split(",")) {
                 if (!TextUtils.isEmpty(strNetworkCapability)) {
                     try {
-                        builder.addCapability(Integer.valueOf(strNetworkCapability));
+                        nc.addCapability(Integer.valueOf(strNetworkCapability));
                     } catch (NumberFormatException nfe) {
                         Log.e(TAG, "Capability '" + strNetworkCapability + "' could not be parsed");
                     } catch (IllegalArgumentException iae) {
@@ -562,11 +553,11 @@ final class EthernetTracker {
         }
         // Ethernet networks have no way to update the following capabilities, so they always
         // have them.
-        builder.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_ROAMING);
-        builder.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_CONGESTED);
-        builder.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_SUSPENDED);
+        nc.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_ROAMING);
+        nc.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_CONGESTED);
+        nc.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_SUSPENDED);
 
-        return builder;
+        return nc;
     }
 
     /**
@@ -578,8 +569,7 @@ final class EthernetTracker {
      */
     @VisibleForTesting
     static IpConfiguration parseStaticIpConfiguration(String staticIpConfig) {
-        final StaticIpConfiguration.Builder staticIpConfigBuilder =
-                new StaticIpConfiguration.Builder();
+        StaticIpConfiguration ipConfig = new StaticIpConfiguration();
 
         for (String keyValueAsString : staticIpConfig.trim().split(" ")) {
             if (TextUtils.isEmpty(keyValueAsString)) continue;
@@ -595,20 +585,20 @@ final class EthernetTracker {
 
             switch (key) {
                 case "ip":
-                    staticIpConfigBuilder.setIpAddress(new LinkAddress(value));
+                    ipConfig.ipAddress = new LinkAddress(value);
                     break;
                 case "domains":
-                    staticIpConfigBuilder.setDomains(value);
+                    ipConfig.domains = value;
                     break;
                 case "gateway":
-                    staticIpConfigBuilder.setGateway(InetAddress.parseNumericAddress(value));
+                    ipConfig.gateway = InetAddress.parseNumericAddress(value);
                     break;
                 case "dns": {
                     ArrayList<InetAddress> dnsAddresses = new ArrayList<>();
                     for (String address: value.split(",")) {
                         dnsAddresses.add(InetAddress.parseNumericAddress(address));
                     }
-                    staticIpConfigBuilder.setDnsServers(dnsAddresses);
+                    ipConfig.dnsServers.addAll(dnsAddresses);
                     break;
                 }
                 default : {
@@ -617,18 +607,11 @@ final class EthernetTracker {
                 }
             }
         }
-        final IpConfiguration ret = new IpConfiguration();
-        ret.setIpAssignment(IpAssignment.STATIC);
-        ret.setProxySettings(ProxySettings.NONE);
-        ret.setStaticIpConfiguration(staticIpConfigBuilder.build());
-        return ret;
+        return new IpConfiguration(IpAssignment.STATIC, ProxySettings.NONE, ipConfig, null);
     }
 
     private static IpConfiguration createDefaultIpConfiguration() {
-        final IpConfiguration ret = new IpConfiguration();
-        ret.setIpAssignment(IpAssignment.DHCP);
-        ret.setProxySettings(ProxySettings.NONE);
-        return ret;
+        return new IpConfiguration(IpAssignment.DHCP, ProxySettings.NONE, null, null);
     }
 
     private void updateIfaceMatchRegexp() {
diff --git a/tests/Android.bp b/tests/Android.bp
index 4b2d270..9c776e6 100644
--- a/tests/Android.bp
+++ b/tests/Android.bp
@@ -13,10 +13,6 @@
 // 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 ee9f349..67740b6 100644
--- a/tests/java/com/android/server/ethernet/EthernetTrackerTest.java
+++ b/tests/java/com/android/server/ethernet/EthernetTrackerTest.java
@@ -19,7 +19,6 @@ 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;
@@ -34,7 +33,6 @@ import org.junit.Test;
 import org.junit.runner.RunWith;
 
 import java.net.InetAddress;
-import java.util.ArrayList;
 
 @SmallTest
 @RunWith(AndroidJUnit4.class)
@@ -48,26 +46,28 @@ public class EthernetTrackerTest {
         assertStaticConfiguration(new StaticIpConfiguration(), "");
 
         // Setting only the IP address properly cascades and assumes defaults
-        assertStaticConfiguration(new StaticIpConfiguration.Builder()
-                .setIpAddress(new LinkAddress("192.0.2.10/24")).build(), "ip=192.0.2.10/24");
+        assertStaticConfiguration(
+                new StaticIpConfigBuilder().setIp("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 StaticIpConfiguration.Builder()
-                .setIpAddress(new LinkAddress("192.0.2.10/24"))
-                .setDnsServers(dnsAddresses)
-                .setGateway(InetAddresses.parseNumericAddress("192.0.2.1"))
-                .setDomains("android").build(),
+        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(),
                 "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 StaticIpConfiguration.Builder()
-                .setIpAddress(new LinkAddress("192.0.2.10/24"))
-                .setDnsServers(dnsAddresses)
-                .setGateway(InetAddresses.parseNumericAddress("192.0.2.1"))
-                .setDomains("android").build(),
+        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(),
                 "domains=android ip=192.0.2.10/24 gateway=192.0.2.1 dns=4.4.4.4,8.8.8.8 ");
     }
 
@@ -96,22 +96,41 @@ public class EthernetTrackerTest {
 
     private void assertStaticConfiguration(StaticIpConfiguration expectedStaticIpConfig,
                 String configAsString) {
-        final IpConfiguration expectedIpConfiguration = new IpConfiguration();
-        expectedIpConfiguration.setIpAssignment(IpAssignment.STATIC);
-        expectedIpConfiguration.setProxySettings(ProxySettings.NONE);
-        expectedIpConfiguration.setStaticIpConfiguration(expectedStaticIpConfig);
+        IpConfiguration expectedIpConfiguration = new IpConfiguration(IpAssignment.STATIC,
+                ProxySettings.NONE, expectedStaticIpConfig, null);
 
         assertEquals(expectedIpConfiguration,
                 EthernetTracker.parseStaticIpConfiguration(configAsString));
     }
 
-    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);
+    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);
+        }
     }
 
     /**
@@ -121,23 +140,23 @@ public class EthernetTrackerTest {
     public void createNetworkCapabilities() {
 
         // Particularly common expected results
-        NetworkCapabilities defaultEthernetCleared =
-                makeEthernetCapabilitiesBuilder(true /* clearAll */)
-                        .setLinkUpstreamBandwidthKbps(100000)
-                        .setLinkDownstreamBandwidthKbps(100000)
-                        .addTransportType(NetworkCapabilities.TRANSPORT_ETHERNET)
-                        .build();
+        NetworkCapabilities defaultEthernetCleared = new NetworkCapabilitiesBuilder()
+                .clearAll()
+                .setLinkUpstreamBandwidthKbps(100000)
+                .setLinkDownstreamBandwidthKbps(100000)
+                .addTransport(NetworkCapabilities.TRANSPORT_ETHERNET)
+                .build();
 
-        NetworkCapabilities ethernetClearedWithCommonCaps =
-                makeEthernetCapabilitiesBuilder(true /* clearAll */)
-                        .setLinkUpstreamBandwidthKbps(100000)
-                        .setLinkDownstreamBandwidthKbps(100000)
-                        .addTransportType(NetworkCapabilities.TRANSPORT_ETHERNET)
-                        .addCapability(12)
-                        .addCapability(13)
-                        .addCapability(14)
-                        .addCapability(15)
-                        .build();
+        NetworkCapabilities ethernetClearedWithCommonCaps = new NetworkCapabilitiesBuilder()
+                .clearAll()
+                .setLinkUpstreamBandwidthKbps(100000)
+                .setLinkDownstreamBandwidthKbps(100000)
+                .addTransport(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
@@ -146,20 +165,20 @@ public class EthernetTrackerTest {
         // Empty capabilities and transports without the clear defaults flag should return the
         // default capabilities set with TRANSPORT_ETHERNET
         assertParsedNetworkCapabilities(
-                makeEthernetCapabilitiesBuilder(false /* clearAll */)
+                new NetworkCapabilitiesBuilder()
                         .setLinkUpstreamBandwidthKbps(100000)
                         .setLinkDownstreamBandwidthKbps(100000)
-                        .addTransportType(NetworkCapabilities.TRANSPORT_ETHERNET)
+                        .addTransport(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(
-                makeEthernetCapabilitiesBuilder(false /* clearAll */)
+                new NetworkCapabilitiesBuilder()
                         .setLinkUpstreamBandwidthKbps(100000)
                         .setLinkDownstreamBandwidthKbps(100000)
-                        .addTransportType(NetworkCapabilities.TRANSPORT_ETHERNET)
+                        .addTransport(NetworkCapabilities.TRANSPORT_ETHERNET)
                         .addCapability(11)
                         .addCapability(12)
                         .build(),
@@ -176,31 +195,35 @@ 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(
-                makeEthernetCapabilitiesBuilder(true /* clearAll */)
+                new NetworkCapabilitiesBuilder()
+                        .clearAll()
                         .setLinkUpstreamBandwidthKbps(100000)
                         .setLinkDownstreamBandwidthKbps(100000)
-                        .addTransportType(0)
+                        .addTransport(0)
                         .build(),
                 true, "", "0");
         assertParsedNetworkCapabilities(
-                makeEthernetCapabilitiesBuilder(true /* clearAll */)
+                new NetworkCapabilitiesBuilder()
+                        .clearAll()
                         .setLinkUpstreamBandwidthKbps(100000)
                         .setLinkDownstreamBandwidthKbps(100000)
-                        .addTransportType(1)
+                        .addTransport(1)
                         .build(),
                 true, "", "1");
         assertParsedNetworkCapabilities(
-                makeEthernetCapabilitiesBuilder(true /* clearAll */)
+                new NetworkCapabilitiesBuilder()
+                        .clearAll()
                         .setLinkUpstreamBandwidthKbps(100000)
                         .setLinkDownstreamBandwidthKbps(100000)
-                        .addTransportType(2)
+                        .addTransport(2)
                         .build(),
                 true, "", "2");
         assertParsedNetworkCapabilities(
-                makeEthernetCapabilitiesBuilder(true /* clearAll */)
+                new NetworkCapabilitiesBuilder()
+                        .clearAll()
                         .setLinkUpstreamBandwidthKbps(100000)
                         .setLinkDownstreamBandwidthKbps(100000)
-                        .addTransportType(3)
+                        .addTransport(3)
                         .build(),
                 true, "", "3");
 
@@ -221,14 +244,15 @@ public class EthernetTrackerTest {
 
         // Ensure the adding of both capabilities and transports work
         assertParsedNetworkCapabilities(
-                makeEthernetCapabilitiesBuilder(true /* clearAll */)
+                new NetworkCapabilitiesBuilder()
+                        .clearAll()
                         .setLinkUpstreamBandwidthKbps(100000)
                         .setLinkDownstreamBandwidthKbps(100000)
                         .addCapability(12)
                         .addCapability(13)
                         .addCapability(14)
                         .addCapability(15)
-                        .addTransportType(3)
+                        .addTransport(3)
                         .build(),
                 true, "12,13,14,15", "3");
 
@@ -240,6 +264,42 @@ public class EthernetTrackerTest {
             boolean clearCapabilties, String configCapabiltiies,String configTransports) {
         assertEquals(expectedNetworkCapabilities,
                 EthernetTracker.createNetworkCapabilities(clearCapabilties, configCapabiltiies,
-                        configTransports).build());
+                        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);
+        }
     }
 }