diff --git a/Cronet/tests/common/Android.bp b/Cronet/tests/common/Android.bp
index f8bdb08..939a81c 100644
--- a/Cronet/tests/common/Android.bp
+++ b/Cronet/tests/common/Android.bp
@@ -27,7 +27,9 @@
 android_test {
     name: "NetHttpCoverageTests",
     defaults: ["CronetTestJavaDefaults"],
+    enforce_default_target_sdk_version: true,
     sdk_version: "test_current",
+    min_sdk_version: "30",
     test_suites: ["general-tests", "mts-tethering"],
     static_libs: [
         "modules-utils-native-coverage-listener",
diff --git a/Cronet/tests/common/AndroidManifest.xml b/Cronet/tests/common/AndroidManifest.xml
index efe880c..b00fc90 100644
--- a/Cronet/tests/common/AndroidManifest.xml
+++ b/Cronet/tests/common/AndroidManifest.xml
@@ -18,6 +18,7 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
           xmlns:tools="http://schemas.android.com/tools"
           package="com.android.net.http.tests.coverage">
+
     <!-- NetHttpCoverageTests combines CtsNetHttpTestCases and NetHttpTests targets,
      so permissions and others are declared in their respective manifests -->
     <application tools:replace="android:label"
diff --git a/Cronet/tests/common/AndroidTest.xml b/Cronet/tests/common/AndroidTest.xml
index ca298dd..2ac418f 100644
--- a/Cronet/tests/common/AndroidTest.xml
+++ b/Cronet/tests/common/AndroidTest.xml
@@ -20,8 +20,11 @@
     </target_preparer>
     <option name="test-tag" value="NetHttpCoverageTests" />
     <!-- Tethering/Connectivity is a SDK 30+ module -->
+    <!-- TODO Switch back to Sdk30 when b/270049141 is fixed -->
     <object type="module_controller"
-            class="com.android.tradefed.testtype.suite.module.Sdk30ModuleController" />
+            class="com.android.tradefed.testtype.suite.module.Sdk31ModuleController" />
+    <option name="config-descriptor:metadata" key="mainline-param"
+            value="CaptivePortalLoginGoogle.apk+NetworkStackGoogle.apk+com.google.android.resolv.apex+com.google.android.tethering.apex" />
     <test class="com.android.tradefed.testtype.AndroidJUnitTest" >
         <option name="package" value="com.android.net.http.tests.coverage" />
         <option name="runner" value="androidx.test.runner.AndroidJUnitRunner" />
diff --git a/Cronet/tests/cts/Android.bp b/Cronet/tests/cts/Android.bp
index 945b220..d969b54 100644
--- a/Cronet/tests/cts/Android.bp
+++ b/Cronet/tests/cts/Android.bp
@@ -29,6 +29,10 @@
 java_defaults {
     name: "CronetTestJavaDefaultsEnabled",
     enabled: true,
+    // TODO(danstahr): move to unconditional static_libs once the T branch is abandoned
+    static_libs: [
+        "truth",
+    ],
 }
 
 java_defaults {
@@ -43,7 +47,12 @@
 
 android_library {
     name: "CtsNetHttpTestsLib",
+    defaults: [
+        "cts_defaults",
+        "CronetTestJavaDefaults",
+    ],
     sdk_version: "test_current",
+    min_sdk_version: "30",
     srcs: [
         "src/**/*.java",
         "src/**/*.kt",
@@ -62,6 +71,7 @@
         "framework-tethering",
         "org.apache.http.legacy",
     ],
+    lint: { test: true }
 }
 
 android_test {
diff --git a/Cronet/tests/cts/src/android/net/http/cts/QuicOptionsTest.kt b/Cronet/tests/cts/src/android/net/http/cts/QuicOptionsTest.kt
new file mode 100644
index 0000000..1888962
--- /dev/null
+++ b/Cronet/tests/cts/src/android/net/http/cts/QuicOptionsTest.kt
@@ -0,0 +1,70 @@
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package android.net.http.cts
+
+import android.net.http.QuicOptions
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.google.common.truth.Truth.assertThat
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class QuicOptionsTest {
+    @Test
+    fun testQuicOptions_defaultValues() {
+        val quicOptions = QuicOptions.Builder().build()
+        assertThat(quicOptions.quicHostAllowlist).isEmpty()
+        assertThat(quicOptions.handshakeUserAgent).isNull()
+        // TODO(danstahr): idleConnectionTimeout getter should be public
+        // assertThat(quicOptions.idleConnectionTimeout).isNull()
+        assertThat(quicOptions.inMemoryServerConfigsCacheSize).isNull()
+    }
+
+    @Test
+    fun testQuicOptions_quicHostAllowlist_returnsAddedValues() {
+        val quicOptions = QuicOptions.Builder()
+                .addAllowedQuicHost("foo")
+                .addAllowedQuicHost("bar")
+                .addAllowedQuicHost("foo")
+                .addAllowedQuicHost("baz")
+                .build()
+        assertThat(quicOptions.quicHostAllowlist)
+                .containsExactly("foo", "bar", "baz")
+                .inOrder()
+    }
+
+    // TODO(danstahr): idleConnectionTimeout getter should be public
+    /*
+    @Test
+    fun testQuicOptions_idleConnectionTimeout_returnsSetValue() {
+        val timeout = Duration.ofMinutes(10)
+        val quicOptions = QuicOptions.Builder()
+                .setIdleConnectionTimeout(timeout)
+                .build()
+        assertThat(quicOptions.idleConnectionTimeout)
+                .isEqualTo(timeout)
+    }
+    */
+
+    @Test
+    fun testQuicOptions_inMemoryServerConfigsCacheSize_returnsSetValue() {
+        val quicOptions = QuicOptions.Builder()
+                .setInMemoryServerConfigsCacheSize(42)
+                .build()
+        assertThat(quicOptions.inMemoryServerConfigsCacheSize)
+                .isEqualTo(42)
+    }
+}
diff --git a/Cronet/tests/mts/Android.bp b/Cronet/tests/mts/Android.bp
index 1cabd63..03d163c 100644
--- a/Cronet/tests/mts/Android.bp
+++ b/Cronet/tests/mts/Android.bp
@@ -20,6 +20,8 @@
 android_library {
     name: "NetHttpTestsLibPreJarJar",
     srcs: [":cronet_aml_javatests_sources"],
+    sdk_version: "test_current",
+    min_sdk_version: "30",
     static_libs: [
         "androidx.test.ext.junit",
         "androidx.test.rules",
@@ -28,7 +30,8 @@
     libs: [
         "android.test.base",
         "framework-tethering-pre-jarjar",
-    ]
+    ],
+    lint: { test: true }
 }
 
 android_test {
diff --git a/Cronet/tests/mts/AndroidTest.xml b/Cronet/tests/mts/AndroidTest.xml
index 8cb549e..0d780a1 100644
--- a/Cronet/tests/mts/AndroidTest.xml
+++ b/Cronet/tests/mts/AndroidTest.xml
@@ -16,8 +16,9 @@
   -->
 <configuration description="Runs NetHttp Mainline Tests.">
     <!-- Only run tests if the device under test is SDK version 30 or above. -->
+    <!-- TODO Switch back to Sdk30 when b/270049141 is fixed -->
     <object type="module_controller"
-            class="com.android.tradefed.testtype.suite.module.Sdk30ModuleController" />
+            class="com.android.tradefed.testtype.suite.module.Sdk31ModuleController" />
 
     <target_preparer class="com.android.tradefed.targetprep.suite.SuiteApkInstaller">
         <option name="test-file-name" value="NetHttpTests.apk" />
diff --git a/TEST_MAPPING b/TEST_MAPPING
index 4d3ecdf..70c5f85 100644
--- a/TEST_MAPPING
+++ b/TEST_MAPPING
@@ -213,6 +213,9 @@
     },
     {
       "name": "libnetworkstats_test[CaptivePortalLoginGoogle.apk+NetworkStackGoogle.apk+com.google.android.resolv.apex+com.google.android.tethering.apex]"
+    },
+    {
+      "name": "NetHttpCoverageTests[CaptivePortalLoginGoogle.apk+NetworkStackGoogle.apk+com.google.android.resolv.apex+com.google.android.tethering.apex]"
     }
   ],
   "mainline-postsubmit": [
diff --git a/bpf_progs/netd.c b/bpf_progs/netd.c
index 84da79d..e068d8a 100644
--- a/bpf_progs/netd.c
+++ b/bpf_progs/netd.c
@@ -350,10 +350,10 @@
 
 static __always_inline inline int bpf_owner_match(struct __sk_buff* skb, uint32_t uid,
                                                   bool egress, const unsigned kver) {
-    if (skip_owner_match(skb, kver)) return PASS;
-
     if (is_system_uid(uid)) return PASS;
 
+    if (skip_owner_match(skb, kver)) return PASS;
+
     BpfConfig enabledRules = getConfig(UID_RULES_CONFIGURATION_KEY);
 
     UidOwnerValue* uidEntry = bpf_uid_owner_map_lookup_elem(&uid);
@@ -415,11 +415,6 @@
     }
 
     int match = bpf_owner_match(skb, sock_uid, egress, kver);
-    if (egress && (match == DROP)) {
-        // If an outbound packet is going to be dropped, we do not count that
-        // traffic.
-        return match;
-    }
 
 // Workaround for secureVPN with VpnIsolation enabled, refer to b/159994981 for details.
 // Keep TAG_SYSTEM_DNS in sync with DnsResolver/include/netd_resolv/resolv.h
@@ -432,6 +427,9 @@
         if (match == DROP_UNLESS_DNS) match = DROP;
     }
 
+    // If an outbound packet is going to be dropped, we do not count that traffic.
+    if (egress && (match == DROP)) return DROP;
+
     StatsKey key = {.uid = uid, .tag = tag, .counterSet = 0, .ifaceIndex = skb->ifindex};
 
     uint8_t* counterSet = bpf_uid_counterset_map_lookup_elem(&uid);
diff --git a/framework-t/src/android/net/NetworkTemplate.java b/framework-t/src/android/net/NetworkTemplate.java
index 4a1632b..55fcc4a 100644
--- a/framework-t/src/android/net/NetworkTemplate.java
+++ b/framework-t/src/android/net/NetworkTemplate.java
@@ -51,6 +51,7 @@
 import android.util.Log;
 
 import com.android.internal.annotations.VisibleForTesting;
+import com.android.modules.utils.build.SdkLevel;
 import com.android.net.module.util.CollectionUtils;
 import com.android.net.module.util.NetworkIdentityUtils;
 
@@ -246,6 +247,38 @@
         return new NetworkTemplate.Builder(MATCH_ETHERNET).build();
     }
 
+    /**
+     * Template to combine all {@link ConnectivityManager#TYPE_BLUETOOTH} style
+     * networks together.
+     *
+     * @hide
+     */
+    // TODO(b/270089918): Remove this method. This can only be done after there are no more callers,
+    //  including in OEM code which can access this by linking against the framework.
+    public static NetworkTemplate buildTemplateBluetooth() {
+        if (SdkLevel.isAtLeastU()) {
+            throw new UnsupportedOperationException(
+                    "buildTemplateBluetooth is not supported on Android U devices or above");
+        }
+        return new NetworkTemplate.Builder(MATCH_BLUETOOTH).build();
+    }
+
+    /**
+     * Template to combine all {@link ConnectivityManager#TYPE_PROXY} style
+     * networks together.
+     *
+     * @hide
+     */
+    // TODO(b/270089918): Remove this method. This can only be done after there are no more callers,
+    //  including in OEM code which can access this by linking against the framework.
+    public static NetworkTemplate buildTemplateProxy() {
+        if (SdkLevel.isAtLeastU()) {
+            throw new UnsupportedOperationException(
+                    "buildTemplateProxy is not supported on Android U devices or above");
+        }
+        return new NetworkTemplate(MATCH_PROXY, null, null);
+    }
+
     private final int mMatchRule;
 
     /**
@@ -316,6 +349,10 @@
         if (matchRule == 6 || matchRule == 7) {
             Log.e(TAG, "Use MATCH_MOBILE with empty subscriberIds or MATCH_WIFI with empty "
                     + "wifiNetworkKeys instead of template with matchRule=" + matchRule);
+            if (SdkLevel.isAtLeastU()) {
+                throw new UnsupportedOperationException(
+                        "Wildcard templates are not supported on Android U devices or above");
+            }
         }
     }
 
@@ -337,6 +374,43 @@
     }
 
     /** @hide */
+    // TODO(b/270089918): Remove this method after no callers.
+    public NetworkTemplate(int matchRule, String subscriberId, String[] matchSubscriberIds,
+            String wifiNetworkKey) {
+        // Older versions used to only match MATCH_MOBILE and MATCH_MOBILE_WILDCARD templates
+        // to metered networks. It is now possible to match mobile with any meteredness, but
+        // in order to preserve backward compatibility of @UnsupportedAppUsage methods, this
+        // constructor passes METERED_YES for these types.
+        this(getBackwardsCompatibleMatchRule(matchRule), matchSubscriberIds,
+                wifiNetworkKey != null ? new String[] { wifiNetworkKey } : new String[0],
+                getMeterednessForBackwardsCompatibility(matchRule),
+                ROAMING_ALL, DEFAULT_NETWORK_ALL, NETWORK_TYPE_ALL,
+                OEM_MANAGED_ALL);
+        if (SdkLevel.isAtLeastU()) {
+            throw new UnsupportedOperationException(
+                    "This constructor is not supported on Android U devices or above");
+        }
+    }
+
+    /** @hide */
+    // TODO(b/269974916): Remove this method after Android U is released.
+    //  This is only used by CTS of Android T.
+    public NetworkTemplate(int matchRule, String subscriberId, String[] matchSubscriberIds,
+            String[] matchWifiNetworkKeys, int metered, int roaming,
+            int defaultNetwork, int ratType, int oemManaged, int subscriberIdMatchRule) {
+        // subscriberId and subscriberIdMatchRule aren't used since they are replaced by
+        // matchSubscriberIds, which could be null to indicate the intention of matching any
+        // subscriberIds.
+        this(getBackwardsCompatibleMatchRule(matchRule),
+                matchSubscriberIds == null ? new String[]{} : matchSubscriberIds,
+                matchWifiNetworkKeys, metered, roaming, defaultNetwork, ratType, oemManaged);
+        if (SdkLevel.isAtLeastU()) {
+            throw new UnsupportedOperationException(
+                    "This constructor is not supported on Android U devices or above");
+        }
+    }
+
+    /** @hide */
     public NetworkTemplate(int matchRule, String[] matchSubscriberIds,
             String[] matchWifiNetworkKeys, int metered, int roaming, int defaultNetwork,
             int ratType, int oemManaged) {
@@ -436,9 +510,14 @@
         return false;
     }
 
-    // TODO(b/270089918): Remove this method after no callers.
+    // TODO(b/270089918): Remove this method. This can only be done after there are no more callers,
+    //  including in OEM code which can access this by linking against the framework.
     /** @hide */
     public boolean isMatchRuleMobile() {
+        if (SdkLevel.isAtLeastU()) {
+            throw new UnsupportedOperationException(
+                    "isMatchRuleMobile is not supported on Android U devices or above");
+        }
         switch (mMatchRule) {
             case MATCH_MOBILE:
             // Old MATCH_MOBILE_WILDCARD
diff --git a/framework/src/android/net/NetworkCapabilities.java b/framework/src/android/net/NetworkCapabilities.java
index 427eac1..324f565 100644
--- a/framework/src/android/net/NetworkCapabilities.java
+++ b/framework/src/android/net/NetworkCapabilities.java
@@ -53,18 +53,70 @@
 import java.util.StringJoiner;
 
 /**
- * Representation of the capabilities of an active network. Instances are
- * typically obtained through
- * {@link NetworkCallback#onCapabilitiesChanged(Network, NetworkCapabilities)}
- * or {@link ConnectivityManager#getNetworkCapabilities(Network)}.
- * <p>
- * This replaces the old {@link ConnectivityManager#TYPE_MOBILE} method of
- * network selection. Rather than indicate a need for Wi-Fi because an
- * application needs high bandwidth and risk obsolescence when a new, fast
- * network appears (like LTE), the application should specify it needs high
- * bandwidth. Similarly if an application needs an unmetered network for a bulk
- * transfer it can specify that rather than assuming all cellular based
- * connections are metered and all Wi-Fi based connections are not.
+ * Representation of the capabilities of an active network.
+ *
+ * <p>@see <a href="https://developer.android.com/training/basics/network-ops/reading-network-state>
+ * this general guide</a> on how to use NetworkCapabilities and related classes.
+ *
+ * <p>NetworkCapabilities represent what a network can do and what its
+ * characteristics are like. The principal attribute of NetworkCapabilities
+ * is in the capabilities bits, which are checked with
+ * {@link #hasCapability(int)}. See the list of capabilities and each
+ * capability for a description of what it means.
+ *
+ * <p>Some prime examples include {@code NET_CAPABILITY_MMS}, which means that the
+ * network is capable of sending MMS. A network without this capability
+ * is not capable of sending MMS.
+ * <p>The {@code NET_CAPABILITY_INTERNET} capability means that the network is
+ * configured to reach the general Internet. It may or may not actually
+ * provide connectivity ; the {@code NET_CAPABILITY_VALIDATED} bit indicates that
+ * the system found actual connectivity to the general Internet the last
+ * time it checked. Apps interested in actual connectivity should usually
+ * look at both these capabilities.
+ * <p>The {@code NET_CAPABILITY_NOT_METERED} capability is set for networks that
+ * do not bill the user for consumption of bytes. Applications are
+ * encouraged to consult this to determine appropriate usage, and to
+ * limit usage of metered network where possible, including deferring
+ * big downloads until such a time that an unmetered network is connected.
+ * Also see {@link android.app.job.JobScheduler} to help with scheduling such
+ * downloads, in particular
+ * {@link android.app.job.JobInfo.Builder#setRequiredNetwork(NetworkRequest)}.
+ * <p>NetworkCapabilities contain a number of other capabilities that
+ * represent what modern networks can and can't do. Look up the individual
+ * capabilities in this class to learn about each of them.
+ *
+ * <p>NetworkCapabilities typically represent attributes that can apply to
+ * any network. The attributes that apply only to specific transports like
+ * cellular or Wi-Fi can be found in the specifier (for requestable attributes)
+ * or in the transport info (for non-requestable ones). See
+ * {@link #getNetworkSpecifier} and {@link #getTransportInfo}. An app would
+ * downcast these to the specific class for the transport they need if they
+ * are interested in transport-specific attributes. Also see
+ * {@link android.net.wifi.WifiNetworkSpecifier} or
+ * {@link android.net.wifi.WifiInfo} for some examples of each of these.
+ *
+ * <p>NetworkCapabilities also contains other attributes like the estimated
+ * upstream and downstream bandwidth and the specific transport of that
+ * network (e.g. {@link #TRANSPORT_CELLULAR}). Generally, apps should normally
+ * have little reason to check for the type of transport ; for example, to
+ * query whether a network costs money to the user, do not look at the
+ * transport, but instead look at the absence or presence of
+ * {@link #NET_CAPABILITY_NOT_METERED} which will correctly account for
+ * metered Wi-Fis and free of charge cell connections.
+ *
+ * <p>The system communicates with apps about connected networks and uses
+ * NetworkCapabilities to express these capabilities about these networks.
+ * Apps should register callbacks with the {@link ConnectivityManager#requestNetwork}
+ * or {@link ConnectivityManager#registerNetworkCallback} family of methods
+ * to learn about the capabilities of a network on a continuous basis
+ * and be able to react to changes to capabilities. For quick debugging Android also
+ * provides {@link ConnectivityManager#getNetworkCapabilities(Network)},
+ * but the dynamic nature of networking makes this ill-suited to production
+ * code since capabilities obtained in this way can go stale immediately.
+ *
+ * <p>Also see {@link NetworkRequest} which uses the same capabilities
+ * together with {@link ConnectivityManager#requestNetwork} for how to
+ * request the system brings up the kind of network your application needs.
  */
 public final class NetworkCapabilities implements Parcelable {
     private static final String TAG = "NetworkCapabilities";
@@ -622,11 +674,19 @@
 
     /**
      * Indicates that this network should be able to prioritize latency for the internet.
+     *
+     * Starting with {@link Build.VERSION_CODES#UPSIDE_DOWN_CAKE}, requesting this capability with
+     * {@link ConnectivityManager#requestNetwork} requires declaration in the self-certified
+     * network capabilities. See {@link NetworkRequest} for the self-certification documentation.
      */
     public static final int NET_CAPABILITY_PRIORITIZE_LATENCY = 34;
 
     /**
      * Indicates that this network should be able to prioritize bandwidth for the internet.
+     *
+     * Starting with {@link Build.VERSION_CODES#UPSIDE_DOWN_CAKE}, requesting this capability with
+     * {@link ConnectivityManager#requestNetwork} requires declaration in the self-certified
+     * network capabilities. See {@link NetworkRequest} for the self-certification documentation.
      */
     public static final int NET_CAPABILITY_PRIORITIZE_BANDWIDTH = 35;
 
diff --git a/framework/src/android/net/NetworkRequest.java b/framework/src/android/net/NetworkRequest.java
index b7a6076..6c351d0 100644
--- a/framework/src/android/net/NetworkRequest.java
+++ b/framework/src/android/net/NetworkRequest.java
@@ -54,9 +54,92 @@
 import java.util.Set;
 
 /**
- * Defines a request for a network, made through {@link NetworkRequest.Builder} and used
- * to request a network via {@link ConnectivityManager#requestNetwork} or listen for changes
- * via {@link ConnectivityManager#registerNetworkCallback}.
+ * An object describing a network that the application is interested in.
+ *
+ * <p>@see <a href="https://developer.android.com/training/basics/network-ops/reading-network-state>
+ * this general guide</a> on how to use NetworkCapabilities and related classes.
+ *
+ * NetworkRequest defines a request for a network, made through
+ * {@link NetworkRequest.Builder} and used to request a network via
+ * {@link ConnectivityManager#requestNetwork} or to listen for changes
+ * via the {@link ConnectivityManager#registerNetworkCallback} family of
+ * functions.
+ *
+ * <p>{@link ConnectivityManager#requestNetwork} will try to find a connected
+ * network matching the NetworkRequest, and return it if there is one.
+ * As long as the request is outstanding, the system will try to find the best
+ * possible network that matches the request. The request will keep up the
+ * currently best connected network, and if a better one is found (e.g. cheaper
+ * or faster) the system will bring up that better network to better serve the
+ * request. A request filed with {@link ConnectivityManager#requestNetwork} will
+ * only match one network at a time (the one the system thinks is best), even if
+ * other networks can match the request that are being kept up by other requests.
+ *
+ * For example, an application needing a network with
+ * {@link NetworkCapabilities#NET_CAPABILITY_INTERNET} should use
+ * {@link ConnectivityManager#requestNetwork} to request the system keeps one up.
+ * A general cellular network can satisfy this request, but if the system finds
+ * a free Wi-Fi network which is expected to be faster, it will try and connect
+ * to that Wi-Fi network and switch the request over to it once it is connected.
+ * The cell network may stay connected if there are outstanding requests (from
+ * the same app or from other apps on the system) that match the cell network
+ * but not the Wi-Fi network, such as a request with {@link NetworkCapabilities#NET_CAPABILITY_MMS}.
+ *
+ * When a network is no longer needed to serve any request, the system can
+ * tear it down at any time and usually does so immediately, so make sure to
+ * keep up requests for the networks your app needs.
+ *
+ * <p>By contrast, requests filed with {@link ConnectivityManager#registerNetworkCallback}
+ * will receive callbacks for all matching networks, and will not cause the system to
+ * keep up the networks they match. Use this to listen to networks that the device is
+ * connected to, but that you don't want the system to keep up for your use case.
+ *
+ * <p>Applications build a NetworkRequest and pass it to one of the
+ * {@link ConnectivityManager} methods above together with a
+ * {@link ConnectivityManager.NetworkCallback} object. The callback
+ * will then start receiving method calls about networks that match
+ * the request.
+ *
+ * <p>Networks are brought up and/or matched according to the capabilities
+ * set in the builder. For example, a request with
+ * {@link NetworkCapabilities#NET_CAPABILITY_MMS} lets the system match
+ * and/or bring up a network that is capable to send MMS. A request with
+ * {@link NetworkCapabilities#NET_CAPABILITY_NOT_METERED} matches a network
+ * that doesn't charge the user for usage. See
+ * {@link NetworkCapabilities} for a list of capabilities and their
+ * description.
+ *
+ * <p>While all capabilities can be matched with the
+ * {@link ConnectivityManager#registerNetworkCallback} family of methods,
+ * not all capabilities can be used to request that the system brings
+ * up a network with {@link ConnectivityManager#requestNetwork}. For example,
+ * an application cannot use {@link ConnectivityManager#requestNetwork} to
+ * ask the system to bring up a network with
+ * {@link NetworkCapabilities#NET_CAPABILITY_CAPTIVE_PORTAL}, because the
+ * system won't know if a network has a captive portal before it connects
+ * to that network. Similarly, some capabilities may require a specific
+ * permission or privilege to be requested.
+ *
+ * Look up the specific capability and the {@link ConnectivityManager#requestNetwork}
+ * method for limitations applicable to each capability.
+ *
+ * <p>Also, starting with {@link Build.VERSION_CODES#UPSIDE_DOWN_CAKE}, some capabilities
+ * require the application to self-certify by explicitly adding the
+ * {@link android.content.pm.PackageManager#PROPERTY_SELF_CERTIFIED_NETWORK_CAPABILITIES}
+ * property in the AndroidManifest.xml, which points to an XML resource file. In the
+ * XML resource file, the application declares what kind of network capabilities the application
+ * wants to have.
+ *
+ * Here is an example self-certification XML resource file :
+ * <pre>
+ *  {@code
+ *  <network-capabilities-declaration xmlns:android="http://schemas.android.com/apk/res/android">
+ *     <uses-network-capability android:name="NET_CAPABILITY_PRIORITIZE_LATENCY"/>
+ *     <uses-network-capability android:name="NET_CAPABILITY_PRIORITIZE_BANDWIDTH"/>
+ * </network-capabilities-declaration>
+ *  }
+ *  </pre>
+ * Look up the specific capability to learn whether its usage requires this self-certification.
  */
 public class NetworkRequest implements Parcelable {
     /**
diff --git a/service-t/src/com/android/server/NsdService.java b/service-t/src/com/android/server/NsdService.java
index 8e06fde..619b64d 100644
--- a/service-t/src/com/android/server/NsdService.java
+++ b/service-t/src/com/android/server/NsdService.java
@@ -20,6 +20,7 @@
 import static android.net.nsd.NsdManager.MDNS_DISCOVERY_MANAGER_EVENT;
 import static android.net.nsd.NsdManager.MDNS_SERVICE_EVENT;
 import static android.provider.DeviceConfig.NAMESPACE_CONNECTIVITY;
+import static android.provider.DeviceConfig.NAMESPACE_TETHERING;
 
 import android.annotation.NonNull;
 import android.annotation.Nullable;
@@ -79,6 +80,7 @@
 import java.nio.charset.Charset;
 import java.nio.charset.CharsetEncoder;
 import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -110,6 +112,34 @@
      */
     private static final String MDNS_ADVERTISER_VERSION = "mdns_advertiser_version";
 
+    /**
+     * Comma-separated list of type:flag mappings indicating the flags to use to allowlist
+     * discovery/advertising using MdnsDiscoveryManager / MdnsAdvertiser for a given type.
+     *
+     * For example _mytype._tcp.local and _othertype._tcp.local would be configured with:
+     * _mytype._tcp:mytype,_othertype._tcp.local:othertype
+     *
+     * In which case the flags:
+     * "mdns_discovery_manager_allowlist_mytype_version",
+     * "mdns_advertiser_allowlist_mytype_version",
+     * "mdns_discovery_manager_allowlist_othertype_version",
+     * "mdns_advertiser_allowlist_othertype_version"
+     * would be used to toggle MdnsDiscoveryManager / MdnsAdvertiser for each type. The flags will
+     * be read with
+     * {@link DeviceConfigUtils#isFeatureEnabled(Context, String, String, String, boolean)}.
+     *
+     * @see #MDNS_DISCOVERY_MANAGER_ALLOWLIST_FLAG_PREFIX
+     * @see #MDNS_ADVERTISER_ALLOWLIST_FLAG_PREFIX
+     * @see #MDNS_ALLOWLIST_FLAG_SUFFIX
+     */
+    private static final String MDNS_TYPE_ALLOWLIST_FLAGS = "mdns_type_allowlist_flags";
+
+    private static final String MDNS_DISCOVERY_MANAGER_ALLOWLIST_FLAG_PREFIX =
+            "mdns_discovery_manager_allowlist_";
+    private static final String MDNS_ADVERTISER_ALLOWLIST_FLAG_PREFIX =
+            "mdns_advertiser_allowlist_";
+    private static final String MDNS_ALLOWLIST_FLAG_SUFFIX = "_version";
+
     public static final boolean DBG = Log.isLoggable(TAG, Log.DEBUG);
     private static final long CLEANUP_DELAY_MS = 10000;
     private static final int IFACE_IDX_ANY = 0;
@@ -496,31 +526,6 @@
                 clientInfo.mClientIdForServiceUpdates = 0;
             }
 
-            /**
-             * Check the given service type is valid and construct it to a service type
-             * which can use for discovery / resolution service.
-             *
-             * <p> The valid service type should be 2 labels, or 3 labels if the query is for a
-             * subtype (see RFC6763 7.1). Each label is up to 63 characters and must start with an
-             * underscore; they are alphanumerical characters or dashes or underscore, except the
-             * last one that is just alphanumerical. The last label must be _tcp or _udp.
-             *
-             * @param serviceType the request service type for discovery / resolution service
-             * @return constructed service type or null if the given service type is invalid.
-             */
-            @Nullable
-            private String constructServiceType(String serviceType) {
-                if (TextUtils.isEmpty(serviceType)) return null;
-
-                final Pattern serviceTypePattern = Pattern.compile(
-                        "^(_[a-zA-Z0-9-_]{1,61}[a-zA-Z0-9]\\.)?"
-                                + "(_[a-zA-Z0-9-_]{1,61}[a-zA-Z0-9]\\._(?:tcp|udp))$");
-                final Matcher matcher = serviceTypePattern.matcher(serviceType);
-                if (!matcher.matches()) return null;
-                return matcher.group(1) == null
-                        ? serviceType
-                        : matcher.group(1) + "_sub." + matcher.group(2);
-            }
 
             /**
              * Truncate a service name to up to 63 UTF-8 bytes.
@@ -545,6 +550,12 @@
                 return new String(out.array(), 0, out.position(), utf8);
             }
 
+            private void stopDiscoveryManagerRequest(ClientRequest request, int clientId, int id,
+                    ClientInfo clientInfo) {
+                clientInfo.unregisterMdnsListenerFromRequest(request);
+                removeRequestMap(clientId, id, clientInfo);
+            }
+
             @Override
             public boolean processMessage(Message msg) {
                 final ClientInfo clientInfo;
@@ -572,8 +583,9 @@
 
                         final NsdServiceInfo info = args.serviceInfo;
                         id = getUniqueId();
-                        if (mDeps.isMdnsDiscoveryManagerEnabled(mContext)) {
-                            final String serviceType = constructServiceType(info.getServiceType());
+                        final String serviceType = constructServiceType(info.getServiceType());
+                        if (mDeps.isMdnsDiscoveryManagerEnabled(mContext)
+                                || useDiscoveryManagerForType(serviceType)) {
                             if (serviceType == null) {
                                 clientInfo.onDiscoverServicesFailed(clientId,
                                         NsdManager.FAILURE_INTERNAL_ERROR);
@@ -631,11 +643,7 @@
                         // point, so this needs to check the type of the original request to
                         // unregister instead of looking at the flag value.
                         if (request instanceof DiscoveryManagerRequest) {
-                            final MdnsListener listener =
-                                    ((DiscoveryManagerRequest) request).mListener;
-                            mMdnsDiscoveryManager.unregisterListener(
-                                    listener.getListenedServiceType(), listener);
-                            removeRequestMap(clientId, id, clientInfo);
+                            stopDiscoveryManagerRequest(request, clientId, id, clientInfo);
                             clientInfo.onStopDiscoverySucceeded(clientId);
                         } else {
                             removeRequestMap(clientId, id, clientInfo);
@@ -667,10 +675,11 @@
                         }
 
                         id = getUniqueId();
-                        if (mDeps.isMdnsAdvertiserEnabled(mContext)) {
-                            final NsdServiceInfo serviceInfo = args.serviceInfo;
-                            final String serviceType = serviceInfo.getServiceType();
-                            final String registerServiceType = constructServiceType(serviceType);
+                        final NsdServiceInfo serviceInfo = args.serviceInfo;
+                        final String serviceType = serviceInfo.getServiceType();
+                        final String registerServiceType = constructServiceType(serviceType);
+                        if (mDeps.isMdnsAdvertiserEnabled(mContext)
+                                || useAdvertiserForType(registerServiceType)) {
                             if (registerServiceType == null) {
                                 Log.e(TAG, "Invalid service type: " + serviceType);
                                 clientInfo.onRegisterServiceFailed(clientId,
@@ -686,7 +695,7 @@
                             storeAdvertiserRequestMap(clientId, id, clientInfo);
                         } else {
                             maybeStartDaemon();
-                            if (registerService(id, args.serviceInfo)) {
+                            if (registerService(id, serviceInfo)) {
                                 if (DBG) Log.d(TAG, "Register " + clientId + " " + id);
                                 storeLegacyRequestMap(clientId, id, clientInfo, msg.what);
                                 // Return success after mDns reports success
@@ -748,8 +757,9 @@
 
                         final NsdServiceInfo info = args.serviceInfo;
                         id = getUniqueId();
-                        if (mDeps.isMdnsDiscoveryManagerEnabled(mContext)) {
-                            final String serviceType = constructServiceType(info.getServiceType());
+                        final String serviceType = constructServiceType(info.getServiceType());
+                        if (mDeps.isMdnsDiscoveryManagerEnabled(mContext)
+                                || useDiscoveryManagerForType(serviceType)) {
                             if (serviceType == null) {
                                 clientInfo.onResolveServiceFailed(clientId,
                                         NsdManager.FAILURE_INTERNAL_ERROR);
@@ -763,6 +773,7 @@
                             final MdnsSearchOptions options = MdnsSearchOptions.newBuilder()
                                     .setNetwork(info.getNetwork())
                                     .setIsPassiveMode(true)
+                                    .setResolveInstanceName(info.getServiceName())
                                     .build();
                             mMdnsDiscoveryManager.registerListener(
                                     resolveServiceType, listener, options);
@@ -775,7 +786,7 @@
                             }
 
                             maybeStartDaemon();
-                            if (resolveService(id, args.serviceInfo)) {
+                            if (resolveService(id, info)) {
                                 clientInfo.mResolvedService = new NsdServiceInfo();
                                 storeLegacyRequestMap(clientId, id, clientInfo, msg.what);
                             } else {
@@ -803,15 +814,22 @@
                             break;
                         }
                         id = request.mGlobalId;
-                        removeRequestMap(clientId, id, clientInfo);
-                        if (stopResolveService(id)) {
+                        // Note isMdnsDiscoveryManagerEnabled may have changed to false at this
+                        // point, so this needs to check the type of the original request to
+                        // unregister instead of looking at the flag value.
+                        if (request instanceof DiscoveryManagerRequest) {
+                            stopDiscoveryManagerRequest(request, clientId, id, clientInfo);
                             clientInfo.onStopResolutionSucceeded(clientId);
                         } else {
-                            clientInfo.onStopResolutionFailed(
-                                    clientId, NsdManager.FAILURE_OPERATION_NOT_RUNNING);
+                            removeRequestMap(clientId, id, clientInfo);
+                            if (stopResolveService(id)) {
+                                clientInfo.onStopResolutionSucceeded(clientId);
+                            } else {
+                                clientInfo.onStopResolutionFailed(
+                                        clientId, NsdManager.FAILURE_OPERATION_NOT_RUNNING);
+                            }
+                            clientInfo.mResolvedService = null;
                         }
-                        clientInfo.mResolvedService = null;
-                        // TODO: Implement the stop resolution with MdnsDiscoveryManager.
                         break;
                     }
                     case NsdManager.REGISTER_SERVICE_CALLBACK:
@@ -1144,17 +1162,27 @@
                                 Log.e(TAG, "Invalid attribute", e);
                             }
                         }
-                        try {
-                            if (serviceInfo.getIpv4Address() != null) {
-                                info.setHost(InetAddresses.parseNumericAddress(
-                                        serviceInfo.getIpv4Address()));
-                            } else {
-                                info.setHost(InetAddresses.parseNumericAddress(
-                                        serviceInfo.getIpv6Address()));
+                        final List<InetAddress> addresses = new ArrayList<>();
+                        for (String ipv4Address : serviceInfo.getIpv4Addresses()) {
+                            try {
+                                addresses.add(InetAddresses.parseNumericAddress(ipv4Address));
+                            } catch (IllegalArgumentException e) {
+                                Log.wtf(TAG, "Invalid ipv4 address", e);
                             }
+                        }
+                        for (String ipv6Address : serviceInfo.getIpv6Addresses()) {
+                            try {
+                                addresses.add(InetAddresses.parseNumericAddress(ipv6Address));
+                            } catch (IllegalArgumentException e) {
+                                Log.wtf(TAG, "Invalid ipv6 address", e);
+                            }
+                        }
+
+                        if (addresses.size() != 0) {
+                            info.setHostAddresses(addresses);
                             clientInfo.onResolveServiceSucceeded(clientId, info);
-                        } catch (IllegalArgumentException e) {
-                            Log.wtf(TAG, "Invalid address in RESOLVE_SERVICE_SUCCEEDED", e);
+                        } else {
+                            // No address. Notify resolution failure.
                             clientInfo.onResolveServiceFailed(
                                     clientId, NsdManager.FAILURE_INTERNAL_ERROR);
                         }
@@ -1164,10 +1192,7 @@
                             Log.wtf(TAG, "non-DiscoveryManager request in DiscoveryManager event");
                             break;
                         }
-                        final MdnsListener listener = ((DiscoveryManagerRequest) request).mListener;
-                        mMdnsDiscoveryManager.unregisterListener(
-                                listener.getListenedServiceType(), listener);
-                        removeRequestMap(clientId, transactionId, clientInfo);
+                        stopDiscoveryManagerRequest(request, clientId, transactionId, clientInfo);
                         break;
                     }
                     default:
@@ -1227,6 +1252,34 @@
         return sb.toString();
     }
 
+    /**
+     * Check the given service type is valid and construct it to a service type
+     * which can use for discovery / resolution service.
+     *
+     * <p> The valid service type should be 2 labels, or 3 labels if the query is for a
+     * subtype (see RFC6763 7.1). Each label is up to 63 characters and must start with an
+     * underscore; they are alphanumerical characters or dashes or underscore, except the
+     * last one that is just alphanumerical. The last label must be _tcp or _udp.
+     *
+     * @param serviceType the request service type for discovery / resolution service
+     * @return constructed service type or null if the given service type is invalid.
+     */
+    @Nullable
+    public static String constructServiceType(String serviceType) {
+        if (TextUtils.isEmpty(serviceType)) return null;
+
+        final Pattern serviceTypePattern = Pattern.compile(
+                "^(_[a-zA-Z0-9-_]{1,61}[a-zA-Z0-9]\\.)?"
+                        + "(_[a-zA-Z0-9-_]{1,61}[a-zA-Z0-9]\\._(?:tcp|udp))"
+                        // Drop '.' at the end of service type that is compatible with old backend.
+                        + "\\.?$");
+        final Matcher matcher = serviceTypePattern.matcher(serviceType);
+        if (!matcher.matches()) return null;
+        return matcher.group(1) == null
+                ? matcher.group(2)
+                : matcher.group(1) + "_sub." + matcher.group(2);
+    }
+
     @VisibleForTesting
     NsdService(Context ctx, Handler handler, long cleanupDelayMs) {
         this(ctx, handler, cleanupDelayMs, new Dependencies());
@@ -1280,6 +1333,24 @@
         }
 
         /**
+         * Get the type allowlist flag value.
+         * @see #MDNS_TYPE_ALLOWLIST_FLAGS
+         */
+        @Nullable
+        public String getTypeAllowlistFlags() {
+            return DeviceConfigUtils.getDeviceConfigProperty(NAMESPACE_TETHERING,
+                    MDNS_TYPE_ALLOWLIST_FLAGS, null);
+        }
+
+        /**
+         * @see DeviceConfigUtils#isFeatureEnabled(Context, String, String, String, boolean)
+         */
+        public boolean isFeatureEnabled(Context context, String feature) {
+            return DeviceConfigUtils.isFeatureEnabled(context, NAMESPACE_TETHERING,
+                    feature, DeviceConfigUtils.TETHERING_MODULE_NAME, false /* defaultEnabled */);
+        }
+
+        /**
          * @see MdnsDiscoveryManager
          */
         public MdnsDiscoveryManager makeMdnsDiscoveryManager(
@@ -1304,6 +1375,41 @@
         }
     }
 
+    /**
+     * Return whether a type is allowlisted to use the Java backend.
+     * @param type The service type
+     * @param flagPrefix One of {@link #MDNS_ADVERTISER_ALLOWLIST_FLAG_PREFIX} or
+     *                   {@link #MDNS_DISCOVERY_MANAGER_ALLOWLIST_FLAG_PREFIX}.
+     */
+    private boolean isTypeAllowlistedForJavaBackend(@Nullable String type,
+            @NonNull String flagPrefix) {
+        if (type == null) return false;
+        final String typesConfig = mDeps.getTypeAllowlistFlags();
+        if (TextUtils.isEmpty(typesConfig)) return false;
+
+        final String mappingPrefix = type + ":";
+        String mappedFlag = null;
+        for (String mapping : TextUtils.split(typesConfig, ",")) {
+            if (mapping.startsWith(mappingPrefix)) {
+                mappedFlag = mapping.substring(mappingPrefix.length());
+                break;
+            }
+        }
+
+        if (mappedFlag == null) return false;
+
+        return mDeps.isFeatureEnabled(mContext,
+                flagPrefix + mappedFlag + MDNS_ALLOWLIST_FLAG_SUFFIX);
+    }
+
+    private boolean useDiscoveryManagerForType(@Nullable String type) {
+        return isTypeAllowlistedForJavaBackend(type, MDNS_DISCOVERY_MANAGER_ALLOWLIST_FLAG_PREFIX);
+    }
+
+    private boolean useAdvertiserForType(@Nullable String type) {
+        return isTypeAllowlistedForJavaBackend(type, MDNS_ADVERTISER_ALLOWLIST_FLAG_PREFIX);
+    }
+
     public static NsdService create(Context context) {
         HandlerThread thread = new HandlerThread(TAG);
         thread.start();
@@ -1694,6 +1800,13 @@
             mIsPreSClient = true;
         }
 
+        private void unregisterMdnsListenerFromRequest(ClientRequest request) {
+            final MdnsListener listener =
+                    ((DiscoveryManagerRequest) request).mListener;
+            mMdnsDiscoveryManager.unregisterListener(
+                    listener.getListenedServiceType(), listener);
+        }
+
         // Remove any pending requests from the global map when we get rid of a client,
         // and send cancellations to the daemon.
         private void expungeAllRequests() {
@@ -1709,10 +1822,7 @@
                 }
 
                 if (request instanceof DiscoveryManagerRequest) {
-                    final MdnsListener listener =
-                            ((DiscoveryManagerRequest) request).mListener;
-                    mMdnsDiscoveryManager.unregisterListener(
-                            listener.getListenedServiceType(), listener);
+                    unregisterMdnsListenerFromRequest(request);
                     continue;
                 }
 
diff --git a/service-t/src/com/android/server/connectivity/mdns/EnqueueMdnsQueryCallable.java b/service-t/src/com/android/server/connectivity/mdns/EnqueueMdnsQueryCallable.java
index c472a8f..9a67007 100644
--- a/service-t/src/com/android/server/connectivity/mdns/EnqueueMdnsQueryCallable.java
+++ b/service-t/src/com/android/server/connectivity/mdns/EnqueueMdnsQueryCallable.java
@@ -120,21 +120,17 @@
             // List of (name, type) to query
             final ArrayList<Pair<String[], Integer>> missingKnownAnswerRecords = new ArrayList<>();
             for (MdnsResponse response : servicesToResolve) {
-                // In practice responses should always have at least one pointer record, since the
-                // record is added after creation in MdnsResponseDecoder. All PTR records point to
-                // the same instance name, since addPointerRecord is only called on instances
-                // obtained through MdnsResponseDecoder.findResponseWithPointer.
                 // TODO: also send queries to renew record TTL (as per RFC6762 7.1 no need to query
                 // if remaining TTL is more than half the original one, so send the queries if half
                 // the TTL has passed).
-                if (!response.hasPointerRecords() || response.isComplete()) continue;
-                final String[] instanceName = response.getPointerRecords().get(0).getPointer();
-                if (instanceName == null) continue;
+                if (response.isComplete()) continue;
+                final String[] serviceName = response.getServiceName();
+                if (serviceName == null) continue;
                 if (!response.hasTextRecord()) {
-                    missingKnownAnswerRecords.add(new Pair<>(instanceName, MdnsRecord.TYPE_TXT));
+                    missingKnownAnswerRecords.add(new Pair<>(serviceName, MdnsRecord.TYPE_TXT));
                 }
                 if (!response.hasServiceRecord()) {
-                    missingKnownAnswerRecords.add(new Pair<>(instanceName, MdnsRecord.TYPE_SRV));
+                    missingKnownAnswerRecords.add(new Pair<>(serviceName, MdnsRecord.TYPE_SRV));
                     // The hostname is not yet known, so queries for address records will be sent
                     // the next time the EnqueueMdnsQueryCallable is enqueued if the reply does not
                     // contain them. In practice, advertisers should include the address records
diff --git a/service-t/src/com/android/server/connectivity/mdns/MdnsAdvertiser.java b/service-t/src/com/android/server/connectivity/mdns/MdnsAdvertiser.java
index 977478a..ec3e997 100644
--- a/service-t/src/com/android/server/connectivity/mdns/MdnsAdvertiser.java
+++ b/service-t/src/com/android/server/connectivity/mdns/MdnsAdvertiser.java
@@ -31,6 +31,7 @@
 
 import java.util.List;
 import java.util.Map;
+import java.util.UUID;
 import java.util.function.BiPredicate;
 import java.util.function.Consumer;
 
@@ -43,6 +44,9 @@
     private static final String TAG = MdnsAdvertiser.class.getSimpleName();
     static final boolean DBG = Log.isLoggable(TAG, Log.DEBUG);
 
+    // Top-level domain for link-local queries, as per RFC6762 3.
+    private static final String LOCAL_TLD = "local";
+
     private final Looper mLooper;
     private final AdvertiserCallback mCb;
 
@@ -60,6 +64,8 @@
     private final SparseArray<Registration> mRegistrations = new SparseArray<>();
     private final Dependencies mDeps;
 
+    private String[] mDeviceHostName;
+
     /**
      * Dependencies for {@link MdnsAdvertiser}, useful for testing.
      */
@@ -71,11 +77,32 @@
         public MdnsInterfaceAdvertiser makeAdvertiser(@NonNull MdnsInterfaceSocket socket,
                 @NonNull List<LinkAddress> initialAddresses,
                 @NonNull Looper looper, @NonNull byte[] packetCreationBuffer,
-                @NonNull MdnsInterfaceAdvertiser.Callback cb) {
+                @NonNull MdnsInterfaceAdvertiser.Callback cb,
+                @NonNull String[] deviceHostName) {
             // Note NetworkInterface is final and not mockable
             final String logTag = socket.getInterface().getName();
             return new MdnsInterfaceAdvertiser(logTag, socket, initialAddresses, looper,
-                    packetCreationBuffer, cb);
+                    packetCreationBuffer, cb, deviceHostName);
+        }
+
+        /**
+         * Generates a unique hostname to be used by the device.
+         */
+        @NonNull
+        public String[] generateHostname() {
+            // Generate a very-probably-unique hostname. This allows minimizing possible conflicts
+            // to the point that probing for it is no longer necessary (as per RFC6762 8.1 last
+            // paragraph), and does not leak more information than what could already be obtained by
+            // looking at the mDNS packets source address.
+            // This differs from historical behavior that just used "Android.local" for many
+            // devices, creating a lot of conflicts.
+            // Having a different hostname per interface is an acceptable option as per RFC6762 14.
+            // This hostname will change every time the interface is reconnected, so this does not
+            // allow tracking the device.
+            // TODO: consider deriving a hostname from other sources, such as the IPv6 addresses
+            // (reusing the same privacy-protecting mechanics).
+            return new String[] {
+                    "Android_" + UUID.randomUUID().toString().replace("-", ""), LOCAL_TLD };
         }
     }
 
@@ -260,7 +287,7 @@
             MdnsInterfaceAdvertiser advertiser = mAllAdvertisers.get(socket);
             if (advertiser == null) {
                 advertiser = mDeps.makeAdvertiser(socket, addresses, mLooper, mPacketCreationBuffer,
-                        mInterfaceAdvertiserCb);
+                        mInterfaceAdvertiserCb, mDeviceHostName);
                 mAllAdvertisers.put(socket, advertiser);
                 advertiser.start();
             }
@@ -389,6 +416,7 @@
         mCb = cb;
         mSocketProvider = socketProvider;
         mDeps = deps;
+        mDeviceHostName = deps.generateHostname();
     }
 
     private void checkThread() {
@@ -453,6 +481,10 @@
             advertiser.removeService(id);
         }
         mRegistrations.remove(id);
+        // Regenerates host name when registrations removed.
+        if (mRegistrations.size() == 0) {
+            mDeviceHostName = mDeps.generateHostname();
+        }
     }
 
     private static <K, V> boolean any(@NonNull ArrayMap<K, V> map,
diff --git a/service-t/src/com/android/server/connectivity/mdns/MdnsInterfaceAdvertiser.java b/service-t/src/com/android/server/connectivity/mdns/MdnsInterfaceAdvertiser.java
index c616e01..79cddce 100644
--- a/service-t/src/com/android/server/connectivity/mdns/MdnsInterfaceAdvertiser.java
+++ b/service-t/src/com/android/server/connectivity/mdns/MdnsInterfaceAdvertiser.java
@@ -141,8 +141,9 @@
     public static class Dependencies {
         /** @see MdnsRecordRepository */
         @NonNull
-        public MdnsRecordRepository makeRecordRepository(@NonNull Looper looper) {
-            return new MdnsRecordRepository(looper);
+        public MdnsRecordRepository makeRecordRepository(@NonNull Looper looper,
+                @NonNull String[] deviceHostName) {
+            return new MdnsRecordRepository(looper, deviceHostName);
         }
 
         /** @see MdnsReplySender */
@@ -169,17 +170,18 @@
 
     public MdnsInterfaceAdvertiser(@NonNull String logTag,
             @NonNull MdnsInterfaceSocket socket, @NonNull List<LinkAddress> initialAddresses,
-            @NonNull Looper looper, @NonNull byte[] packetCreationBuffer, @NonNull Callback cb) {
+            @NonNull Looper looper, @NonNull byte[] packetCreationBuffer, @NonNull Callback cb,
+            @NonNull String[] deviceHostName) {
         this(logTag, socket, initialAddresses, looper, packetCreationBuffer, cb,
-                new Dependencies());
+                new Dependencies(), deviceHostName);
     }
 
     public MdnsInterfaceAdvertiser(@NonNull String logTag,
             @NonNull MdnsInterfaceSocket socket, @NonNull List<LinkAddress> initialAddresses,
             @NonNull Looper looper, @NonNull byte[] packetCreationBuffer, @NonNull Callback cb,
-            @NonNull Dependencies deps) {
+            @NonNull Dependencies deps, @NonNull String[] deviceHostName) {
         mTag = MdnsInterfaceAdvertiser.class.getSimpleName() + "/" + logTag;
-        mRecordRepository = deps.makeRecordRepository(looper);
+        mRecordRepository = deps.makeRecordRepository(looper, deviceHostName);
         mRecordRepository.updateAddresses(initialAddresses);
         mSocket = socket;
         mCb = cb;
diff --git a/service-t/src/com/android/server/connectivity/mdns/MdnsRecordRepository.java b/service-t/src/com/android/server/connectivity/mdns/MdnsRecordRepository.java
index e975ab4..1329172 100644
--- a/service-t/src/com/android/server/connectivity/mdns/MdnsRecordRepository.java
+++ b/service-t/src/com/android/server/connectivity/mdns/MdnsRecordRepository.java
@@ -47,7 +47,6 @@
 import java.util.Random;
 import java.util.Set;
 import java.util.TreeMap;
-import java.util.UUID;
 import java.util.concurrent.TimeUnit;
 
 /**
@@ -90,15 +89,16 @@
     @NonNull
     private final Looper mLooper;
     @NonNull
-    private String[] mDeviceHostname;
+    private final String[] mDeviceHostname;
 
-    public MdnsRecordRepository(@NonNull Looper looper) {
-        this(looper, new Dependencies());
+    public MdnsRecordRepository(@NonNull Looper looper, @NonNull String[] deviceHostname) {
+        this(looper, new Dependencies(), deviceHostname);
     }
 
     @VisibleForTesting
-    public MdnsRecordRepository(@NonNull Looper looper, @NonNull Dependencies deps) {
-        mDeviceHostname = deps.getHostname();
+    public MdnsRecordRepository(@NonNull Looper looper, @NonNull Dependencies deps,
+            @NonNull String[] deviceHostname) {
+        mDeviceHostname = deviceHostname;
         mLooper = looper;
     }
 
@@ -107,25 +107,6 @@
      */
     @VisibleForTesting
     public static class Dependencies {
-        /**
-         * Get a unique hostname to be used by the device.
-         */
-        @NonNull
-        public String[] getHostname() {
-            // Generate a very-probably-unique hostname. This allows minimizing possible conflicts
-            // to the point that probing for it is no longer necessary (as per RFC6762 8.1 last
-            // paragraph), and does not leak more information than what could already be obtained by
-            // looking at the mDNS packets source address.
-            // This differs from historical behavior that just used "Android.local" for many
-            // devices, creating a lot of conflicts.
-            // Having a different hostname per interface is an acceptable option as per RFC6762 14.
-            // This hostname will change every time the interface is reconnected, so this does not
-            // allow tracking the device.
-            // TODO: consider deriving a hostname from other sources, such as the IPv6 addresses
-            // (reusing the same privacy-protecting mechanics).
-            return new String[] {
-                    "Android_" + UUID.randomUUID().toString().replace("-", ""), LOCAL_TLD };
-        }
 
         /**
          * @see NetworkInterface#getInetAddresses().
diff --git a/service-t/src/com/android/server/connectivity/mdns/MdnsResponse.java b/service-t/src/com/android/server/connectivity/mdns/MdnsResponse.java
index 3a41978..be2555b 100644
--- a/service-t/src/com/android/server/connectivity/mdns/MdnsResponse.java
+++ b/service-t/src/com/android/server/connectivity/mdns/MdnsResponse.java
@@ -16,16 +16,20 @@
 
 package com.android.server.connectivity.mdns;
 
+import android.annotation.NonNull;
 import android.annotation.Nullable;
 import android.net.Network;
 
 import com.android.internal.annotations.VisibleForTesting;
 
 import java.io.IOException;
+import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.Objects;
 
 /** An mDNS response. */
 public class MdnsResponse {
@@ -33,42 +37,72 @@
     private final List<MdnsPointerRecord> pointerRecords;
     private MdnsServiceRecord serviceRecord;
     private MdnsTextRecord textRecord;
-    private MdnsInetAddressRecord inet4AddressRecord;
-    private MdnsInetAddressRecord inet6AddressRecord;
+    @NonNull private List<MdnsInetAddressRecord> inet4AddressRecords;
+    @NonNull private List<MdnsInetAddressRecord> inet6AddressRecords;
     private long lastUpdateTime;
     private final int interfaceIndex;
     @Nullable private final Network network;
+    @NonNull private final String[] serviceName;
 
     /** Constructs a new, empty response. */
-    public MdnsResponse(long now, int interfaceIndex, @Nullable Network network) {
+    public MdnsResponse(long now, @NonNull String[] serviceName, int interfaceIndex,
+            @Nullable Network network) {
         lastUpdateTime = now;
         records = new LinkedList<>();
         pointerRecords = new LinkedList<>();
+        inet4AddressRecords = new ArrayList<>();
+        inet6AddressRecords = new ArrayList<>();
         this.interfaceIndex = interfaceIndex;
         this.network = network;
+        this.serviceName = serviceName;
     }
 
-    // This generic typed helper compares records for equality.
-    // Returns True if records are the same.
-    private <T> boolean recordsAreSame(T a, T b) {
-        return ((a == null) && (b == null)) || ((a != null) && (b != null) && a.equals(b));
+    public MdnsResponse(@NonNull MdnsResponse base) {
+        records = new ArrayList<>(base.records);
+        pointerRecords = new ArrayList<>(base.pointerRecords);
+        serviceRecord = base.serviceRecord;
+        textRecord = base.textRecord;
+        inet4AddressRecords = new ArrayList<>(base.inet4AddressRecords);
+        inet6AddressRecords = new ArrayList<>(base.inet6AddressRecords);
+        lastUpdateTime = base.lastUpdateTime;
+        serviceName = base.serviceName;
+        interfaceIndex = base.interfaceIndex;
+        network = base.network;
+    }
+
+    /**
+     * Compare records for equality, including their TTL.
+     *
+     * MdnsRecord#equals ignores TTL and receiptTimeMillis, but methods in this class need to update
+     * records when the TTL changes (especially for goodbye announcements).
+     */
+    private boolean recordsAreSame(MdnsRecord a, MdnsRecord b) {
+        if (!Objects.equals(a, b)) return false;
+        return a == null || a.getTtl() == b.getTtl();
     }
 
     /**
      * Adds a pointer record.
      *
      * @return <code>true</code> if the record was added, or <code>false</code> if a matching
-     * pointer
-     * record is already present in the response.
+     * pointer record is already present in the response with the same TTL.
      */
     public synchronized boolean addPointerRecord(MdnsPointerRecord pointerRecord) {
-        if (!pointerRecords.contains(pointerRecord)) {
-            pointerRecords.add(pointerRecord);
-            records.add(pointerRecord);
-            return true;
+        if (!Arrays.equals(serviceName, pointerRecord.getPointer())) {
+            throw new IllegalArgumentException(
+                    "Pointer records for different service names cannot be added");
         }
-
-        return false;
+        final int existing = pointerRecords.indexOf(pointerRecord);
+        if (existing >= 0) {
+            if (recordsAreSame(pointerRecord, pointerRecords.get(existing))) {
+                return false;
+            }
+            final MdnsRecord record = pointerRecords.remove(existing);
+            records.remove(record);
+        }
+        pointerRecords.add(pointerRecord);
+        records.add(pointerRecord);
+        return true;
     }
 
     /** Gets the pointer records. */
@@ -170,44 +204,60 @@
         return textRecord != null;
     }
 
-    /** Sets the IPv4 address record. */
-    public synchronized boolean setInet4AddressRecord(
-            @Nullable MdnsInetAddressRecord newInet4AddressRecord) {
-        if (recordsAreSame(this.inet4AddressRecord, newInet4AddressRecord)) {
-            return false;
+    /** Add the IPv4 address record. */
+    public synchronized boolean addInet4AddressRecord(
+            @NonNull MdnsInetAddressRecord newInet4AddressRecord) {
+        final int existing = inet4AddressRecords.indexOf(newInet4AddressRecord);
+        if (existing >= 0) {
+            if (recordsAreSame(newInet4AddressRecord, inet4AddressRecords.get(existing))) {
+                return false;
+            }
+            final MdnsRecord record = inet4AddressRecords.remove(existing);
+            records.remove(record);
         }
-        if (this.inet4AddressRecord != null) {
-            records.remove(this.inet4AddressRecord);
-        }
-        if (newInet4AddressRecord != null && newInet4AddressRecord.getInet4Address() != null) {
-            this.inet4AddressRecord = newInet4AddressRecord;
-            records.add(this.inet4AddressRecord);
-        }
+        inet4AddressRecords.add(newInet4AddressRecord);
+        records.add(newInet4AddressRecord);
         return true;
     }
 
-    /** Gets the IPv4 address record. */
+    /** Gets the IPv4 address records. */
+    @NonNull
+    public synchronized List<MdnsInetAddressRecord> getInet4AddressRecords() {
+        return Collections.unmodifiableList(inet4AddressRecords);
+    }
+
+    /** Return the first IPv4 address record or null if no record. */
+    @Nullable
     public synchronized MdnsInetAddressRecord getInet4AddressRecord() {
-        return inet4AddressRecord;
+        return inet4AddressRecords.isEmpty() ? null : inet4AddressRecords.get(0);
     }
 
+    /** Check whether response has IPv4 address record */
     public synchronized boolean hasInet4AddressRecord() {
-        return inet4AddressRecord != null;
+        return !inet4AddressRecords.isEmpty();
     }
 
-    /** Sets the IPv6 address record. */
-    public synchronized boolean setInet6AddressRecord(
-            @Nullable MdnsInetAddressRecord newInet6AddressRecord) {
-        if (recordsAreSame(this.inet6AddressRecord, newInet6AddressRecord)) {
-            return false;
+    /** Clear all IPv4 address records */
+    synchronized void clearInet4AddressRecords() {
+        for (MdnsInetAddressRecord record : inet4AddressRecords) {
+            records.remove(record);
         }
-        if (this.inet6AddressRecord != null) {
-            records.remove(this.inet6AddressRecord);
+        inet4AddressRecords.clear();
+    }
+
+    /** Sets the IPv6 address records. */
+    public synchronized boolean addInet6AddressRecord(
+            @NonNull MdnsInetAddressRecord newInet6AddressRecord) {
+        final int existing = inet6AddressRecords.indexOf(newInet6AddressRecord);
+        if (existing >= 0) {
+            if (recordsAreSame(newInet6AddressRecord, inet6AddressRecords.get(existing))) {
+                return false;
+            }
+            final MdnsRecord record = inet6AddressRecords.remove(existing);
+            records.remove(record);
         }
-        if (newInet6AddressRecord != null && newInet6AddressRecord.getInet6Address() != null) {
-            this.inet6AddressRecord = newInet6AddressRecord;
-            records.add(this.inet6AddressRecord);
-        }
+        inet6AddressRecords.add(newInet6AddressRecord);
+        records.add(newInet6AddressRecord);
         return true;
     }
 
@@ -227,13 +277,28 @@
         return network;
     }
 
-    /** Gets the IPv6 address record. */
-    public synchronized MdnsInetAddressRecord getInet6AddressRecord() {
-        return inet6AddressRecord;
+    /** Gets all IPv6 address records. */
+    public synchronized List<MdnsInetAddressRecord> getInet6AddressRecords() {
+        return Collections.unmodifiableList(inet6AddressRecords);
     }
 
+    /** Return the first IPv6 address record or null if no record. */
+    @Nullable
+    public synchronized MdnsInetAddressRecord getInet6AddressRecord() {
+        return inet6AddressRecords.isEmpty() ? null : inet6AddressRecords.get(0);
+    }
+
+    /** Check whether response has IPv6 address record */
     public synchronized boolean hasInet6AddressRecord() {
-        return inet6AddressRecord != null;
+        return !inet6AddressRecords.isEmpty();
+    }
+
+    /** Clear all IPv6 address records */
+    synchronized void clearInet6AddressRecords() {
+        for (MdnsInetAddressRecord record : inet6AddressRecords) {
+            records.remove(record);
+        }
+        inet6AddressRecords.clear();
     }
 
     /** Gets all of the records. */
@@ -242,101 +307,58 @@
     }
 
     /**
-     * Merges any records that are present in another response into this one.
+     * Drop address records if they are for a hostname that does not match the service record.
      *
-     * @return <code>true</code> if any records were added or updated.
+     * @return True if the records were dropped.
      */
-    public synchronized boolean mergeRecordsFrom(MdnsResponse other) {
-        lastUpdateTime = other.lastUpdateTime;
+    public synchronized boolean dropUnmatchedAddressRecords() {
+        if (this.serviceRecord == null) return false;
+        boolean dropAddressRecords = false;
 
-        boolean updated = false;
-
-        List<MdnsPointerRecord> pointerRecords = other.getPointerRecords();
-        if (pointerRecords != null) {
-            for (MdnsPointerRecord pointerRecord : pointerRecords) {
-                if (addPointerRecord(pointerRecord)) {
-                    updated = true;
-                }
+        for (MdnsInetAddressRecord inetAddressRecord : getInet4AddressRecords()) {
+            if (!Arrays.equals(
+                    this.serviceRecord.getServiceHost(), inetAddressRecord.getName())) {
+                dropAddressRecords = true;
+            }
+        }
+        for (MdnsInetAddressRecord inetAddressRecord : getInet6AddressRecords()) {
+            if (!Arrays.equals(
+                    this.serviceRecord.getServiceHost(), inetAddressRecord.getName())) {
+                dropAddressRecords = true;
             }
         }
 
-        MdnsServiceRecord serviceRecord = other.getServiceRecord();
-        if (serviceRecord != null) {
-            if (setServiceRecord(serviceRecord)) {
-                updated = true;
-            }
+        if (dropAddressRecords) {
+            clearInet4AddressRecords();
+            clearInet6AddressRecords();
+            return true;
         }
-
-        MdnsTextRecord textRecord = other.getTextRecord();
-        if (textRecord != null) {
-            if (setTextRecord(textRecord)) {
-                updated = true;
-            }
-        }
-
-        MdnsInetAddressRecord otherInet4AddressRecord = other.getInet4AddressRecord();
-        if (otherInet4AddressRecord != null && otherInet4AddressRecord.getInet4Address() != null) {
-            if (setInet4AddressRecord(otherInet4AddressRecord)) {
-                updated = true;
-            }
-        }
-
-        MdnsInetAddressRecord otherInet6AddressRecord = other.getInet6AddressRecord();
-        if (otherInet6AddressRecord != null && otherInet6AddressRecord.getInet6Address() != null) {
-            if (setInet6AddressRecord(otherInet6AddressRecord)) {
-                updated = true;
-            }
-        }
-
-        // If the hostname in the service record no longer matches the hostname in either of the
-        // address records, then drop the address records.
-        if (this.serviceRecord != null) {
-            boolean dropAddressRecords = false;
-
-            if (this.inet4AddressRecord != null) {
-                if (!Arrays.equals(
-                        this.serviceRecord.getServiceHost(), this.inet4AddressRecord.getName())) {
-                    dropAddressRecords = true;
-                }
-            }
-            if (this.inet6AddressRecord != null) {
-                if (!Arrays.equals(
-                        this.serviceRecord.getServiceHost(), this.inet6AddressRecord.getName())) {
-                    dropAddressRecords = true;
-                }
-            }
-
-            if (dropAddressRecords) {
-                setInet4AddressRecord(null);
-                setInet6AddressRecord(null);
-                updated = true;
-            }
-        }
-
-        return updated;
+        return false;
     }
 
     /**
-     * Tests if the response is complete. A response is considered complete if it contains PTR, SRV,
-     * TXT, and A (for IPv4) or AAAA (for IPv6) records.
+     * Tests if the response is complete. A response is considered complete if it contains SRV,
+     * TXT, and A (for IPv4) or AAAA (for IPv6) records. The service type->name mapping is always
+     * known when constructing a MdnsResponse, so this may return true when there is no PTR record.
      */
     public synchronized boolean isComplete() {
-        return !pointerRecords.isEmpty()
-                && (serviceRecord != null)
+        return (serviceRecord != null)
                 && (textRecord != null)
-                && (inet4AddressRecord != null || inet6AddressRecord != null);
+                && (!inet4AddressRecords.isEmpty() || !inet6AddressRecords.isEmpty());
     }
 
     /**
      * Returns the key for this response. The key uniquely identifies the response by its service
      * name.
      */
-    public synchronized String getServiceInstanceName() {
-        if (pointerRecords.isEmpty()) {
-            return null;
-        }
-        String[] pointers = pointerRecords.get(0).getPointer();
-        return ((pointers != null) && (pointers.length > 0)) ? pointers[0] : null;
+    @Nullable
+    public String getServiceInstanceName() {
+        return serviceName.length > 0 ? serviceName[0] : null;
+    }
+
+    @NonNull
+    public String[] getServiceName() {
+        return serviceName;
     }
 
     /**
@@ -388,13 +410,13 @@
             ++count;
         }
 
-        if (inet4AddressRecord != null) {
-            inet4AddressRecord.write(writer, now);
+        for (MdnsInetAddressRecord inetAddressRecord : inet4AddressRecords) {
+            inetAddressRecord.write(writer, now);
             ++count;
         }
 
-        if (inet6AddressRecord != null) {
-            inet6AddressRecord.write(writer, now);
+        for (MdnsInetAddressRecord inetAddressRecord : inet6AddressRecords) {
+            inetAddressRecord.write(writer, now);
             ++count;
         }
 
diff --git a/service-t/src/com/android/server/connectivity/mdns/MdnsResponseDecoder.java b/service-t/src/com/android/server/connectivity/mdns/MdnsResponseDecoder.java
index 31527c0..0151202 100644
--- a/service-t/src/com/android/server/connectivity/mdns/MdnsResponseDecoder.java
+++ b/service-t/src/com/android/server/connectivity/mdns/MdnsResponseDecoder.java
@@ -20,17 +20,18 @@
 import android.annotation.Nullable;
 import android.net.Network;
 import android.os.SystemClock;
+import android.util.ArraySet;
 
 import com.android.server.connectivity.mdns.util.MdnsLogger;
 
 import java.io.EOFException;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.List;
 
 /** A class that decodes mDNS responses from UDP packets. */
 public class MdnsResponseDecoder {
-
     public static final int SUCCESS = 0;
     private static final String TAG = "MdnsResponseDecoder";
     private static final MdnsLogger LOGGER = new MdnsLogger(TAG);
@@ -49,14 +50,8 @@
             List<MdnsResponse> responses, String[] pointer) {
         if (responses != null) {
             for (MdnsResponse response : responses) {
-                List<MdnsPointerRecord> pointerRecords = response.getPointerRecords();
-                if (pointerRecords == null) {
-                    continue;
-                }
-                for (MdnsPointerRecord pointerRecord : pointerRecords) {
-                    if (Arrays.equals(pointerRecord.getPointer(), pointer)) {
-                        return response;
-                    }
+                if (Arrays.equals(response.getServiceName(), pointer)) {
+                    return response;
                 }
             }
         }
@@ -105,7 +100,7 @@
             mdnsPacket = MdnsPacket.parseRecordsSection(reader, flags);
             if (mdnsPacket.answers.size() < 1) {
                 throw new MdnsPacket.ParseException(
-                        MdnsResponseErrorCode.ERROR_NOT_RESPONSE_MESSAGE, "Response has no answers",
+                        MdnsResponseErrorCode.ERROR_NO_ANSWERS, "Response has no answers",
                         null);
             }
             return mdnsPacket;
@@ -116,16 +111,18 @@
     }
 
     /**
-     * Builds mDNS responses for the desired service type from a packet.
+     * Augments a list of {@link MdnsResponse} with records from a packet. The class does not check
+     * the resulting responses for completeness; the caller should do that.
      *
-     * The class does not check the responses for completeness; the caller should do that.
-     *
-     * @param mdnsPacket The packet to read from.
-     * @param interfaceIndex the network interface index (or {@link
-     *     MdnsSocket#INTERFACE_INDEX_UNSPECIFIED} if not known) at which the packet was received.
+     * @param mdnsPacket the response packet with the new records
+     * @param existingResponses list of existing responses. Will not be modified.
+     * @param interfaceIndex the network interface index (or
+     * {@link MdnsSocket#INTERFACE_INDEX_UNSPECIFIED} if not known) at which the packet was received
      * @param network the network at which the packet was received, or null if it is unknown.
+     * @return The set of response instances that were modified or newly added.
      */
-    public List<MdnsResponse> buildResponses(@NonNull MdnsPacket mdnsPacket, int interfaceIndex,
+    public ArraySet<MdnsResponse> augmentResponses(@NonNull MdnsPacket mdnsPacket,
+            @NonNull Collection<MdnsResponse> existingResponses, int interfaceIndex,
             @Nullable Network network) {
         final ArrayList<MdnsRecord> records = new ArrayList<>(
                 mdnsPacket.questions.size() + mdnsPacket.answers.size()
@@ -134,8 +131,11 @@
         records.addAll(mdnsPacket.authorityRecords);
         records.addAll(mdnsPacket.additionalRecords);
 
-        final ArrayList<MdnsResponse> responses = new ArrayList<>();
-
+        final ArraySet<MdnsResponse> modified = new ArraySet<>();
+        final ArrayList<MdnsResponse> responses = new ArrayList<>(existingResponses.size());
+        for (MdnsResponse existing : existingResponses) {
+            responses.add(new MdnsResponse(existing));
+        }
         // The response records are structured in a hierarchy, where some records reference
         // others, as follows:
         //
@@ -175,12 +175,14 @@
                     MdnsResponse response = findResponseWithPointer(responses,
                             pointerRecord.getPointer());
                     if (response == null) {
-                        response = new MdnsResponse(now, interfaceIndex, network);
+                        response = new MdnsResponse(now, pointerRecord.getPointer(), interfaceIndex,
+                                network);
                         responses.add(response);
                     }
-                    // Set interface index earlier because some responses have PTR record only.
-                    // Need to know every response is getting from which interface.
-                    response.addPointerRecord((MdnsPointerRecord) record);
+
+                    if (response.addPointerRecord((MdnsPointerRecord) record)) {
+                        modified.add(response);
+                    }
                 }
             }
         }
@@ -190,46 +192,94 @@
             if (record instanceof MdnsServiceRecord) {
                 MdnsServiceRecord serviceRecord = (MdnsServiceRecord) record;
                 MdnsResponse response = findResponseWithPointer(responses, serviceRecord.getName());
-                if (response != null) {
-                    response.setServiceRecord(serviceRecord);
+                if (response != null && response.setServiceRecord(serviceRecord)) {
+                    response.dropUnmatchedAddressRecords();
+                    modified.add(response);
                 }
             } else if (record instanceof MdnsTextRecord) {
                 MdnsTextRecord textRecord = (MdnsTextRecord) record;
                 MdnsResponse response = findResponseWithPointer(responses, textRecord.getName());
-                if (response != null) {
-                    response.setTextRecord(textRecord);
+                if (response != null && response.setTextRecord(textRecord)) {
+                    modified.add(response);
                 }
             }
         }
 
-        // Loop 3: find A and AAAA records, which reference the host name in the SRV record.
+        // Loop 3-1: find A and AAAA records and clear addresses if the cache-flush bit set, which
+        //           reference the host name in the SRV record.
+        final List<MdnsInetAddressRecord> inetRecords = new ArrayList<>();
         for (MdnsRecord record : records) {
             if (record instanceof MdnsInetAddressRecord) {
                 MdnsInetAddressRecord inetRecord = (MdnsInetAddressRecord) record;
+                inetRecords.add(inetRecord);
                 if (allowMultipleSrvRecordsPerHost) {
                     List<MdnsResponse> matchingResponses =
                             findResponsesWithHostName(responses, inetRecord.getName());
                     for (MdnsResponse response : matchingResponses) {
-                        assignInetRecord(response, inetRecord);
+                        // Per RFC6762 10.2, clear all address records if the cache-flush bit set.
+                        // This bit, the cache-flush bit, tells neighboring hosts
+                        // that this is not a shared record type.  Instead of merging this new
+                        // record additively into the cache in addition to any previous records with
+                        // the same name, rrtype, and rrclass, all old records with that name,
+                        // rrtype, and rrclass that were received more than one second ago are
+                        // declared invalid, and marked to expire from the cache in one second.
+                        if (inetRecord.getCacheFlush()) {
+                            response.clearInet4AddressRecords();
+                            response.clearInet6AddressRecords();
+                        }
                     }
                 } else {
                     MdnsResponse response =
                             findResponseWithHostName(responses, inetRecord.getName());
                     if (response != null) {
-                        assignInetRecord(response, inetRecord);
+                        // Per RFC6762 10.2, clear all address records if the cache-flush bit set.
+                        // This bit, the cache-flush bit, tells neighboring hosts
+                        // that this is not a shared record type.  Instead of merging this new
+                        // record additively into the cache in addition to any previous records with
+                        // the same name, rrtype, and rrclass, all old records with that name,
+                        // rrtype, and rrclass that were received more than one second ago are
+                        // declared invalid, and marked to expire from the cache in one second.
+                        if (inetRecord.getCacheFlush()) {
+                            response.clearInet4AddressRecords();
+                            response.clearInet6AddressRecords();
+                        }
                     }
                 }
             }
         }
-        return responses;
+
+        // Loop 3-2: Assign addresses, which reference the host name in the SRV record.
+        for (MdnsInetAddressRecord inetRecord : inetRecords) {
+            if (allowMultipleSrvRecordsPerHost) {
+                List<MdnsResponse> matchingResponses =
+                        findResponsesWithHostName(responses, inetRecord.getName());
+                for (MdnsResponse response : matchingResponses) {
+                    if (assignInetRecord(response, inetRecord)) {
+                        modified.add(response);
+                    }
+                }
+            } else {
+                MdnsResponse response =
+                        findResponseWithHostName(responses, inetRecord.getName());
+                if (response != null) {
+                    if (assignInetRecord(response, inetRecord)) {
+                        modified.add(response);
+                    }
+                }
+            }
+        }
+
+        return modified;
     }
 
-    private static void assignInetRecord(MdnsResponse response, MdnsInetAddressRecord inetRecord) {
+    private static boolean assignInetRecord(
+            MdnsResponse response, MdnsInetAddressRecord inetRecord) {
         if (inetRecord.getInet4Address() != null) {
-            response.setInet4AddressRecord(inetRecord);
+            return response.addInet4AddressRecord(inetRecord);
         } else if (inetRecord.getInet6Address() != null) {
-            response.setInet6AddressRecord(inetRecord);
+            return response.addInet6AddressRecord(inetRecord);
         }
+        return false;
     }
 
     private static List<MdnsResponse> findResponsesWithHostName(
diff --git a/service-t/src/com/android/server/connectivity/mdns/MdnsServiceInfo.java b/service-t/src/com/android/server/connectivity/mdns/MdnsServiceInfo.java
index 938fc3f..78df6df 100644
--- a/service-t/src/com/android/server/connectivity/mdns/MdnsServiceInfo.java
+++ b/service-t/src/com/android/server/connectivity/mdns/MdnsServiceInfo.java
@@ -31,10 +31,10 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
-import java.util.HashMap;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
+import java.util.TreeMap;
 
 /**
  * A class representing a discovered mDNS service instance.
@@ -57,8 +57,8 @@
                             source.createStringArrayList(),
                             source.createStringArray(),
                             source.readInt(),
-                            source.readString(),
-                            source.readString(),
+                            source.createStringArrayList(),
+                            source.createStringArrayList(),
                             source.createStringArrayList(),
                             source.createTypedArrayList(TextEntry.CREATOR),
                             source.readInt(),
@@ -76,10 +76,10 @@
     private final List<String> subtypes;
     private final String[] hostName;
     private final int port;
-    @Nullable
-    private final String ipv4Address;
-    @Nullable
-    private final String ipv6Address;
+    @NonNull
+    private final List<String> ipv4Addresses;
+    @NonNull
+    private final List<String> ipv6Addresses;
     final List<String> textStrings;
     @Nullable
     final List<TextEntry> textEntries;
@@ -105,8 +105,8 @@
                 subtypes,
                 hostName,
                 port,
-                ipv4Address,
-                ipv6Address,
+                List.of(ipv4Address),
+                List.of(ipv6Address),
                 textStrings,
                 /* textEntries= */ null,
                 /* interfaceIndex= */ INTERFACE_INDEX_UNSPECIFIED,
@@ -130,8 +130,8 @@
                 subtypes,
                 hostName,
                 port,
-                ipv4Address,
-                ipv6Address,
+                List.of(ipv4Address),
+                List.of(ipv6Address),
                 textStrings,
                 textEntries,
                 /* interfaceIndex= */ INTERFACE_INDEX_UNSPECIFIED,
@@ -160,8 +160,8 @@
                 subtypes,
                 hostName,
                 port,
-                ipv4Address,
-                ipv6Address,
+                List.of(ipv4Address),
+                List.of(ipv6Address),
                 textStrings,
                 textEntries,
                 interfaceIndex,
@@ -179,8 +179,8 @@
             @Nullable List<String> subtypes,
             String[] hostName,
             int port,
-            @Nullable String ipv4Address,
-            @Nullable String ipv6Address,
+            @NonNull List<String> ipv4Addresses,
+            @NonNull List<String> ipv6Addresses,
             @Nullable List<String> textStrings,
             @Nullable List<TextEntry> textEntries,
             int interfaceIndex,
@@ -193,8 +193,8 @@
         }
         this.hostName = hostName;
         this.port = port;
-        this.ipv4Address = ipv4Address;
-        this.ipv6Address = ipv6Address;
+        this.ipv4Addresses = new ArrayList<>(ipv4Addresses);
+        this.ipv6Addresses = new ArrayList<>(ipv6Addresses);
         this.textStrings = new ArrayList<>();
         if (textStrings != null) {
             this.textStrings.addAll(textStrings);
@@ -205,17 +205,14 @@
         // compatibility. We should prefer only {@code textEntries} if it's not null.
         List<TextEntry> entries =
                 (this.textEntries != null) ? this.textEntries : parseTextStrings(this.textStrings);
-        Map<String, byte[]> attributes = new HashMap<>(entries.size());
+        // The map of attributes is case-insensitive.
+        final Map<String, byte[]> attributes = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
         for (TextEntry entry : entries) {
-            String key = entry.getKey().toLowerCase(Locale.ENGLISH);
-
             // Per https://datatracker.ietf.org/doc/html/rfc6763#section-6.4, only the first entry
             // of the same key should be accepted:
             // If a client receives a TXT record containing the same key more than once, then the
             // client MUST silently ignore all but the first occurrence of that attribute.
-            if (!attributes.containsKey(key)) {
-                attributes.put(key, entry.getValue());
-            }
+            attributes.putIfAbsent(entry.getKey(), entry.getValue());
         }
         this.attributes = Collections.unmodifiableMap(attributes);
         this.interfaceIndex = interfaceIndex;
@@ -263,16 +260,41 @@
         return port;
     }
 
-    /** Returns the IPV4 address of this service instance. */
+    /** Returns the IPV4 addresses of this service instance. */
+    @NonNull
+    public List<String> getIpv4Addresses() {
+        return Collections.unmodifiableList(ipv4Addresses);
+    }
+
+    /**
+     * Returns the first IPV4 address of this service instance.
+     *
+     * @deprecated Use {@link #getIpv4Addresses()} to get the entire list of IPV4
+     * addresses for
+     * the host.
+     */
     @Nullable
+    @Deprecated
     public String getIpv4Address() {
-        return ipv4Address;
+        return ipv4Addresses.isEmpty() ? null : ipv4Addresses.get(0);
     }
 
     /** Returns the IPV6 address of this service instance. */
+    @NonNull
+    public List<String> getIpv6Addresses() {
+        return Collections.unmodifiableList(ipv6Addresses);
+    }
+
+    /**
+     * Returns the first IPV6 address of this service instance.
+     *
+     * @deprecated Use {@link #getIpv6Addresses()} to get the entire list of IPV6 addresses for
+     * the host.
+     */
     @Nullable
+    @Deprecated
     public String getIpv6Address() {
-        return ipv6Address;
+        return ipv6Addresses.isEmpty() ? null : ipv6Addresses.get(0);
     }
 
     /**
@@ -311,12 +333,12 @@
      */
     @Nullable
     public byte[] getAttributeAsBytes(@NonNull String key) {
-        return attributes.get(key.toLowerCase(Locale.ENGLISH));
+        return attributes.get(key);
     }
 
     /** Returns an immutable map of all attributes. */
     public Map<String, String> getAttributes() {
-        Map<String, String> map = new HashMap<>(attributes.size());
+        Map<String, String> map = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
         for (Map.Entry<String, byte[]> kv : attributes.entrySet()) {
             final byte[] value = kv.getValue();
             map.put(kv.getKey(), value == null ? null : new String(value, UTF_8));
@@ -336,8 +358,8 @@
         out.writeStringList(subtypes);
         out.writeStringArray(hostName);
         out.writeInt(port);
-        out.writeString(ipv4Address);
-        out.writeString(ipv6Address);
+        out.writeStringList(ipv4Addresses);
+        out.writeStringList(ipv6Addresses);
         out.writeStringList(textStrings);
         out.writeTypedList(textEntries);
         out.writeInt(interfaceIndex);
@@ -346,13 +368,16 @@
 
     @Override
     public String toString() {
-        return String.format(
-                Locale.ROOT,
-                "Name: %s, subtypes: %s, ip: %s, port: %d",
-                serviceInstanceName,
-                TextUtils.join(",", subtypes),
-                ipv4Address,
-                port);
+        return "Name: " + serviceInstanceName
+                + ", type: " + TextUtils.join(".", serviceType)
+                + ", subtypes: " + TextUtils.join(",", subtypes)
+                + ", ip: " + ipv4Addresses
+                + ", ipv6: " + ipv6Addresses
+                + ", port: " + port
+                + ", interfaceIndex: " + interfaceIndex
+                + ", network: " + network
+                + ", textStrings: " + textStrings
+                + ", textEntries: " + textEntries;
     }
 
 
diff --git a/service-t/src/com/android/server/connectivity/mdns/MdnsServiceTypeClient.java b/service-t/src/com/android/server/connectivity/mdns/MdnsServiceTypeClient.java
index 707a57e..df270bb 100644
--- a/service-t/src/com/android/server/connectivity/mdns/MdnsServiceTypeClient.java
+++ b/service-t/src/com/android/server/connectivity/mdns/MdnsServiceTypeClient.java
@@ -23,6 +23,7 @@
 import android.net.Network;
 import android.text.TextUtils;
 import android.util.ArrayMap;
+import android.util.ArraySet;
 import android.util.Pair;
 
 import com.android.internal.annotations.GuardedBy;
@@ -50,6 +51,7 @@
     private static final int DEFAULT_MTU = 1500;
     private static final MdnsLogger LOGGER = new MdnsLogger("MdnsServiceTypeClient");
 
+
     private final String serviceType;
     private final String[] serviceTypeLabels;
     private final MdnsSocketClientBase socketClient;
@@ -113,15 +115,19 @@
             port = response.getServiceRecord().getServicePort();
         }
 
-        String ipv4Address = null;
-        String ipv6Address = null;
+        final List<String> ipv4Addresses = new ArrayList<>();
+        final List<String> ipv6Addresses = new ArrayList<>();
         if (response.hasInet4AddressRecord()) {
-            Inet4Address inet4Address = response.getInet4AddressRecord().getInet4Address();
-            ipv4Address = (inet4Address == null) ? null : inet4Address.getHostAddress();
+            for (MdnsInetAddressRecord inetAddressRecord : response.getInet4AddressRecords()) {
+                final Inet4Address inet4Address = inetAddressRecord.getInet4Address();
+                ipv4Addresses.add((inet4Address == null) ? null : inet4Address.getHostAddress());
+            }
         }
         if (response.hasInet6AddressRecord()) {
-            Inet6Address inet6Address = response.getInet6AddressRecord().getInet6Address();
-            ipv6Address = (inet6Address == null) ? null : inet6Address.getHostAddress();
+            for (MdnsInetAddressRecord inetAddressRecord : response.getInet6AddressRecords()) {
+                final Inet6Address inet6Address = inetAddressRecord.getInet6Address();
+                ipv6Addresses.add((inet6Address == null) ? null : inet6Address.getHostAddress());
+            }
         }
         String serviceInstanceName = response.getServiceInstanceName();
         if (serviceInstanceName == null) {
@@ -141,8 +147,8 @@
                 response.getSubtypes(),
                 hostName,
                 port,
-                ipv4Address,
-                ipv6Address,
+                ipv4Addresses,
+                ipv6Addresses,
                 textStrings,
                 textEntries,
                 response.getInterfaceIndex(),
@@ -216,25 +222,19 @@
      */
     public synchronized void processResponse(@NonNull MdnsPacket packet, int interfaceIndex,
             Network network) {
-        final List<MdnsResponse> responses = responseDecoder.buildResponses(packet, interfaceIndex,
-                network);
-        for (MdnsResponse response : responses) {
-            if (shouldRemoveServiceAfterTtlExpires()) {
-                // Because {@link QueryTask} and {@link processResponse} are running in different
-                // threads. We need to synchronize {@link lock} to protect
-                // {@link instanceNameToResponse} won’t be modified at the same time.
-                synchronized (lock) {
-                    if (response.isGoodbye()) {
-                        onGoodbyeReceived(response.getServiceInstanceName());
-                    } else {
-                        onResponseReceived(response);
-                    }
-                }
-            } else {
-                if (response.isGoodbye()) {
-                    onGoodbyeReceived(response.getServiceInstanceName());
+        synchronized (lock) {
+            // Augment the list of current known responses, and generated responses for resolve
+            // requests if there is no known response
+            final List<MdnsResponse> currentList = new ArrayList<>(instanceNameToResponse.values());
+            currentList.addAll(makeResponsesForResolveIfUnknown(interfaceIndex, network));
+            final ArraySet<MdnsResponse> modifiedResponses = responseDecoder.augmentResponses(
+                    packet, currentList, interfaceIndex, network);
+
+            for (MdnsResponse modified : modifiedResponses) {
+                if (modified.isGoodbye()) {
+                    onGoodbyeReceived(modified.getServiceInstanceName());
                 } else {
-                    onResponseReceived(response);
+                    onResponseModified(modified);
                 }
             }
         }
@@ -246,31 +246,26 @@
         }
     }
 
-    private void onResponseReceived(@NonNull MdnsResponse response) {
-        MdnsResponse currentResponse;
-        currentResponse = instanceNameToResponse.get(response.getServiceInstanceName());
+    private void onResponseModified(@NonNull MdnsResponse response) {
+        final MdnsResponse currentResponse =
+                instanceNameToResponse.get(response.getServiceInstanceName());
 
         boolean newServiceFound = false;
-        boolean existingServiceChanged = false;
         boolean serviceBecomesComplete = false;
         if (currentResponse == null) {
             newServiceFound = true;
-            currentResponse = response;
             String serviceInstanceName = response.getServiceInstanceName();
             if (serviceInstanceName != null) {
-                instanceNameToResponse.put(serviceInstanceName, currentResponse);
+                instanceNameToResponse.put(serviceInstanceName, response);
             }
         } else {
             boolean before = currentResponse.isComplete();
-            existingServiceChanged = currentResponse.mergeRecordsFrom(response);
-            boolean after = currentResponse.isComplete();
+            instanceNameToResponse.put(response.getServiceInstanceName(), response);
+            boolean after = response.isComplete();
             serviceBecomesComplete = !before && after;
         }
-        if (!newServiceFound && !existingServiceChanged) {
-            return;
-        }
         MdnsServiceInfo serviceInfo =
-                buildMdnsServiceInfoFromResponse(currentResponse, serviceTypeLabels);
+                buildMdnsServiceInfoFromResponse(response, serviceTypeLabels);
 
         for (int i = 0; i < listeners.size(); i++) {
             final MdnsServiceBrowserListener listener = listeners.keyAt(i);
@@ -278,7 +273,7 @@
                 listener.onServiceNameDiscovered(serviceInfo);
             }
 
-            if (currentResponse.isComplete()) {
+            if (response.isComplete()) {
                 if (newServiceFound || serviceBecomesComplete) {
                     listener.onServiceFound(serviceInfo);
                 } else {
@@ -413,6 +408,29 @@
         }
     }
 
+    private List<MdnsResponse> makeResponsesForResolveIfUnknown(int interfaceIndex,
+            @NonNull Network network) {
+        final List<MdnsResponse> resolveResponses = new ArrayList<>();
+        for (int i = 0; i < listeners.size(); i++) {
+            final String resolveName = listeners.valueAt(i).getResolveInstanceName();
+            if (resolveName == null) {
+                continue;
+            }
+            MdnsResponse knownResponse = instanceNameToResponse.get(resolveName);
+            if (knownResponse == null) {
+                final ArrayList<String> instanceFullName = new ArrayList<>(
+                        serviceTypeLabels.length + 1);
+                instanceFullName.add(resolveName);
+                instanceFullName.addAll(Arrays.asList(serviceTypeLabels));
+                knownResponse = new MdnsResponse(
+                        0L /* lastUpdateTime */, instanceFullName.toArray(new String[0]),
+                        interfaceIndex, network);
+            }
+            resolveResponses.add(knownResponse);
+        }
+        return resolveResponses;
+    }
+
     // A FutureTask that enqueues a single query, and schedule a new FutureTask for the next task.
     private class QueryTask implements Runnable {
 
@@ -424,35 +442,17 @@
 
         @Override
         public void run() {
-            final List<MdnsResponse> servicesToResolve = new ArrayList<>();
-            boolean sendDiscoveryQueries = false;
+            final List<MdnsResponse> servicesToResolve;
+            final boolean sendDiscoveryQueries;
             synchronized (lock) {
-                for (int i = 0; i < listeners.size(); i++) {
-                    final String resolveName = listeners.valueAt(i).getResolveInstanceName();
-                    if (resolveName == null) {
-                        sendDiscoveryQueries = true;
-                        continue;
-                    }
-                    MdnsResponse knownResponse = instanceNameToResponse.get(resolveName);
-                    if (knownResponse == null) {
-                        // The listener is requesting to resolve a service that has no info in
-                        // cache. Use the provided name to generate a minimal response with just a
-                        // PTR record, so other records are queried to complete it.
-                        // Only the names are used to know which queries to send, other
-                        // parameters do not matter.
-                        knownResponse = new MdnsResponse(
-                                0L /* now */, 0 /* interfaceIndex */, config.network);
-                        final ArrayList<String> instanceFullName = new ArrayList<>(
-                                serviceTypeLabels.length + 1);
-                        instanceFullName.add(resolveName);
-                        instanceFullName.addAll(Arrays.asList(serviceTypeLabels));
-                        knownResponse.addPointerRecord(new MdnsPointerRecord(
-                                serviceTypeLabels, 0L /* receiptTimeMillis */,
-                                false /* cacheFlush */, 0L /* ttlMillis */,
-                                instanceFullName.toArray(new String[0])));
-                    }
-                    servicesToResolve.add(knownResponse);
-                }
+                // The listener is requesting to resolve a service that has no info in
+                // cache. Use the provided name to generate a minimal response, so other records are
+                // queried to complete it.
+                // Only the names are used to know which queries to send, other parameters like
+                // interfaceIndex do not matter.
+                servicesToResolve = makeResponsesForResolveIfUnknown(
+                        0 /* interfaceIndex */, config.network);
+                sendDiscoveryQueries = servicesToResolve.size() < listeners.size();
             }
             Pair<Integer, List<String>> result;
             try {
diff --git a/service/src/com/android/server/ConnectivityService.java b/service/src/com/android/server/ConnectivityService.java
index 58310bb..4c55afe 100755
--- a/service/src/com/android/server/ConnectivityService.java
+++ b/service/src/com/android/server/ConnectivityService.java
@@ -6685,8 +6685,6 @@
 
         @Override
         public void binderDied() {
-            log("ConnectivityService NetworkRequestInfo binderDied(" +
-                    "uid/pid:" + mUid + "/" + mPid + ", " + mRequests + ", " + mBinder + ")");
             // As an immutable collection, mRequests cannot change by the time the
             // lambda is evaluated on the handler thread so calling .get() from a binder thread
             // is acceptable. Use handleReleaseNetworkRequest and not directly
diff --git a/tests/common/java/android/net/netstats/NetworkTemplateTest.kt b/tests/common/java/android/net/netstats/NetworkTemplateTest.kt
index c2eacbc..fb6759e 100644
--- a/tests/common/java/android/net/netstats/NetworkTemplateTest.kt
+++ b/tests/common/java/android/net/netstats/NetworkTemplateTest.kt
@@ -165,23 +165,6 @@
     }
 
     @Test
-    fun testUnsupportedAppUsageConstructor() {
-        val templateMobile = NetworkTemplate(MATCH_MOBILE, null /* subscriberId */,
-                null /* wifiNetworkKey */)
-        val templateMobileWildcard = NetworkTemplate(6 /* MATCH_MOBILE_WILDCARD */,
-                null /* subscriberId */, null /* wifiNetworkKey */)
-        val templateWifiWildcard = NetworkTemplate(7 /* MATCH_WIFI_WILDCARD */,
-                null /* subscriberId */,
-                null /* wifiNetworkKey */)
-
-        assertEquals(NetworkTemplate.Builder(MATCH_MOBILE).setMeteredness(METERED_YES).build(),
-                templateMobile)
-        assertEquals(NetworkTemplate.Builder(MATCH_MOBILE).setMeteredness(METERED_YES).build(),
-                templateMobileWildcard)
-        assertEquals(NetworkTemplate.Builder(MATCH_WIFI).build(), templateWifiWildcard)
-    }
-
-    @Test
     fun testBuilderWifiNetworkKeys() {
         // Verify template builder which generates same template with the given different
         // sequence keys.
diff --git a/tests/unit/java/com/android/server/NsdServiceTest.java b/tests/unit/java/com/android/server/NsdServiceTest.java
index 8fc9252..3dc5647 100644
--- a/tests/unit/java/com/android/server/NsdServiceTest.java
+++ b/tests/unit/java/com/android/server/NsdServiceTest.java
@@ -21,6 +21,7 @@
 import static android.net.nsd.NsdManager.FAILURE_INTERNAL_ERROR;
 import static android.net.nsd.NsdManager.FAILURE_OPERATION_NOT_RUNNING;
 
+import static com.android.server.NsdService.constructServiceType;
 import static com.android.testutils.ContextUtils.mockService;
 
 import static libcore.junit.util.compat.CoreCompatChangeRule.DisableCompatChanges;
@@ -895,8 +896,8 @@
                 List.of(), /* subtypes */
                 new String[] {"android", "local"}, /* hostName */
                 12345, /* port */
-                IPV4_ADDRESS,
-                IPV6_ADDRESS,
+                List.of(IPV4_ADDRESS),
+                List.of(IPV6_ADDRESS),
                 List.of(), /* textStrings */
                 List.of(), /* textEntries */
                 1234, /* interfaceIndex */
@@ -915,8 +916,8 @@
                 null, /* subtypes */
                 null, /* hostName */
                 0, /* port */
-                null, /* ipv4Address */
-                null, /* ipv6Address */
+                List.of(), /* ipv4Address */
+                List.of(), /* ipv6Address */
                 null, /* textStrings */
                 null, /* textEntries */
                 1234, /* interfaceIndex */
@@ -981,7 +982,9 @@
         waitForIdle();
         verify(mSocketProvider).startMonitoringSockets();
         verify(mDiscoveryManager).registerListener(eq(constructedServiceType),
-                listenerCaptor.capture(), argThat(options -> network.equals(options.getNetwork())));
+                listenerCaptor.capture(), argThat(options ->
+                        network.equals(options.getNetwork())
+                                && SERVICE_NAME.equals(options.getResolveInstanceName())));
 
         final MdnsServiceBrowserListener listener = listenerCaptor.getValue();
         final MdnsServiceInfo mdnsServiceInfo = new MdnsServiceInfo(
@@ -990,8 +993,8 @@
                 List.of(), /* subtypes */
                 new String[]{"android", "local"}, /* hostName */
                 PORT,
-                IPV4_ADDRESS,
-                IPV6_ADDRESS,
+                List.of(IPV4_ADDRESS),
+                List.of("2001:db8::1", "2001:db8::2"),
                 List.of() /* textStrings */,
                 List.of(MdnsServiceInfo.TextEntry.fromBytes(new byte[]{
                         'k', 'e', 'y', '=', (byte) 0xFF, (byte) 0xFE})) /* textEntries */,
@@ -1011,6 +1014,11 @@
         assertEquals(1, info.getAttributes().size());
         assertArrayEquals(new byte[]{(byte) 0xFF, (byte) 0xFE}, info.getAttributes().get("key"));
         assertEquals(parseNumericAddress(IPV4_ADDRESS), info.getHost());
+        assertEquals(3, info.getHostAddresses().size());
+        assertTrue(info.getHostAddresses().stream().anyMatch(
+                address -> address.equals(parseNumericAddress("2001:db8::1"))));
+        assertTrue(info.getHostAddresses().stream().anyMatch(
+                address -> address.equals(parseNumericAddress("2001:db8::2"))));
         assertEquals(network, info.getNetwork());
 
         // Verify the listener has been unregistered.
@@ -1055,6 +1063,54 @@
     }
 
     @Test
+    public void testTypeSpecificFeatureFlagging() {
+        doReturn("_type1._tcp:flag1,_type2._tcp:flag2").when(mDeps).getTypeAllowlistFlags();
+        doReturn(true).when(mDeps).isFeatureEnabled(any(),
+                eq("mdns_discovery_manager_allowlist_flag1_version"));
+        doReturn(true).when(mDeps).isFeatureEnabled(any(),
+                eq("mdns_advertiser_allowlist_flag2_version"));
+
+        final NsdManager client = connectClient(mService);
+        final NsdServiceInfo service1 = new NsdServiceInfo(SERVICE_NAME, "_type1._tcp");
+        service1.setHostAddresses(List.of(parseNumericAddress("2001:db8::123")));
+        service1.setPort(1234);
+        final NsdServiceInfo service2 = new NsdServiceInfo(SERVICE_NAME, "_type2._tcp");
+        service2.setHostAddresses(List.of(parseNumericAddress("2001:db8::123")));
+        service2.setPort(1234);
+
+        client.discoverServices(service1.getServiceType(),
+                NsdManager.PROTOCOL_DNS_SD, mock(DiscoveryListener.class));
+        client.discoverServices(service2.getServiceType(),
+                NsdManager.PROTOCOL_DNS_SD, mock(DiscoveryListener.class));
+        waitForIdle();
+
+        // The DiscoveryManager is enabled for _type1 but not _type2
+        verify(mDiscoveryManager).registerListener(eq("_type1._tcp.local"), any(), any());
+        verify(mDiscoveryManager, never()).registerListener(
+                eq("_type2._tcp.local"), any(), any());
+
+        client.resolveService(service1, mock(ResolveListener.class));
+        client.resolveService(service2, mock(ResolveListener.class));
+        waitForIdle();
+
+        // Same behavior for resolve
+        verify(mDiscoveryManager, times(2)).registerListener(
+                eq("_type1._tcp.local"), any(), any());
+        verify(mDiscoveryManager, never()).registerListener(
+                eq("_type2._tcp.local"), any(), any());
+
+        client.registerService(service1, NsdManager.PROTOCOL_DNS_SD,
+                mock(RegistrationListener.class));
+        client.registerService(service2, NsdManager.PROTOCOL_DNS_SD,
+                mock(RegistrationListener.class));
+        waitForIdle();
+
+        // The advertiser is enabled for _type2 but not _type1
+        verify(mAdvertiser, never()).addService(anyInt(), argThat(info -> matches(info, service1)));
+        verify(mAdvertiser).addService(anyInt(), argThat(info -> matches(info, service2)));
+    }
+
+    @Test
     public void testAdvertiseWithMdnsAdvertiser() {
         setMdnsAdvertiserEnabled();
 
@@ -1150,6 +1206,50 @@
                 argThat(info -> matches(info, new NsdServiceInfo(regInfo.getServiceName(), null))));
     }
 
+    @Test
+    public void testStopServiceResolutionWithMdnsDiscoveryManager() {
+        setMdnsDiscoveryManagerEnabled();
+
+        final NsdManager client = connectClient(mService);
+        final ResolveListener resolveListener = mock(ResolveListener.class);
+        final Network network = new Network(999);
+        final String serviceType = "_nsd._service._tcp";
+        final String constructedServiceType = "_nsd._sub._service._tcp.local";
+        final ArgumentCaptor<MdnsServiceBrowserListener> listenerCaptor =
+                ArgumentCaptor.forClass(MdnsServiceBrowserListener.class);
+        final NsdServiceInfo request = new NsdServiceInfo(SERVICE_NAME, serviceType);
+        request.setNetwork(network);
+        client.resolveService(request, resolveListener);
+        waitForIdle();
+        verify(mSocketProvider).startMonitoringSockets();
+        verify(mDiscoveryManager).registerListener(eq(constructedServiceType),
+                listenerCaptor.capture(), argThat(options -> network.equals(options.getNetwork())));
+
+        client.stopServiceResolution(resolveListener);
+        waitForIdle();
+
+        // Verify the listener has been unregistered.
+        verify(mDiscoveryManager, timeout(TIMEOUT_MS))
+                .unregisterListener(eq(constructedServiceType), eq(listenerCaptor.getValue()));
+        verify(resolveListener, timeout(TIMEOUT_MS)).onResolutionStopped(argThat(ns ->
+                request.getServiceName().equals(ns.getServiceName())
+                        && request.getServiceType().equals(ns.getServiceType())));
+        verify(mSocketProvider, timeout(CLEANUP_DELAY_MS + TIMEOUT_MS)).requestStopWhenInactive();
+    }
+
+    @Test
+    public void testConstructServiceType() {
+        final String serviceType1 = "test._tcp";
+        final String serviceType2 = "_test._quic";
+        final String serviceType3 = "_123._udp.";
+        final String serviceType4 = "_TEST._999._tcp.";
+
+        assertEquals(null, constructServiceType(serviceType1));
+        assertEquals(null, constructServiceType(serviceType2));
+        assertEquals("_123._udp", constructServiceType(serviceType3));
+        assertEquals("_TEST._sub._999._tcp", constructServiceType(serviceType4));
+    }
+
     private void waitForIdle() {
         HandlerUtils.waitForIdle(mHandler, TIMEOUT_MS);
     }
diff --git a/tests/unit/java/com/android/server/connectivity/mdns/MdnsAdvertiserTest.kt b/tests/unit/java/com/android/server/connectivity/mdns/MdnsAdvertiserTest.kt
index 1febe6d..375c150 100644
--- a/tests/unit/java/com/android/server/connectivity/mdns/MdnsAdvertiserTest.kt
+++ b/tests/unit/java/com/android/server/connectivity/mdns/MdnsAdvertiserTest.kt
@@ -42,6 +42,7 @@
 import org.mockito.Mockito.doReturn
 import org.mockito.Mockito.mock
 import org.mockito.Mockito.never
+import org.mockito.Mockito.times
 import org.mockito.Mockito.verify
 
 private const val SERVICE_ID_1 = 1
@@ -51,6 +52,7 @@
 private val TEST_LINKADDR = LinkAddress(TEST_ADDR, 64 /* prefixLength */)
 private val TEST_NETWORK_1 = mock(Network::class.java)
 private val TEST_NETWORK_2 = mock(Network::class.java)
+private val TEST_HOSTNAME = arrayOf("Android_test", "local")
 
 private val SERVICE_1 = NsdServiceInfo("TestServiceName", "_advertisertest._tcp").apply {
     port = 12345
@@ -81,10 +83,13 @@
     @Before
     fun setUp() {
         thread.start()
+        doReturn(TEST_HOSTNAME).`when`(mockDeps).generateHostname()
         doReturn(mockInterfaceAdvertiser1).`when`(mockDeps).makeAdvertiser(eq(mockSocket1),
-                any(), any(), any(), any())
+                any(), any(), any(), any(), eq(TEST_HOSTNAME)
+        )
         doReturn(mockInterfaceAdvertiser2).`when`(mockDeps).makeAdvertiser(eq(mockSocket2),
-                any(), any(), any(), any())
+                any(), any(), any(), any(), eq(TEST_HOSTNAME)
+        )
         doReturn(true).`when`(mockInterfaceAdvertiser1).isProbing(anyInt())
         doReturn(true).`when`(mockInterfaceAdvertiser2).isProbing(anyInt())
     }
@@ -106,8 +111,14 @@
         postSync { socketCb.onSocketCreated(TEST_NETWORK_1, mockSocket1, listOf(TEST_LINKADDR)) }
 
         val intAdvCbCaptor = ArgumentCaptor.forClass(MdnsInterfaceAdvertiser.Callback::class.java)
-        verify(mockDeps).makeAdvertiser(eq(mockSocket1),
-                eq(listOf(TEST_LINKADDR)), eq(thread.looper), any(), intAdvCbCaptor.capture())
+        verify(mockDeps).makeAdvertiser(
+            eq(mockSocket1),
+            eq(listOf(TEST_LINKADDR)),
+            eq(thread.looper),
+            any(),
+            intAdvCbCaptor.capture(),
+            eq(TEST_HOSTNAME)
+        )
 
         doReturn(false).`when`(mockInterfaceAdvertiser1).isProbing(SERVICE_ID_1)
         postSync { intAdvCbCaptor.value.onRegisterServiceSucceeded(
@@ -134,9 +145,11 @@
         val intAdvCbCaptor1 = ArgumentCaptor.forClass(MdnsInterfaceAdvertiser.Callback::class.java)
         val intAdvCbCaptor2 = ArgumentCaptor.forClass(MdnsInterfaceAdvertiser.Callback::class.java)
         verify(mockDeps).makeAdvertiser(eq(mockSocket1), eq(listOf(TEST_LINKADDR)),
-                eq(thread.looper), any(), intAdvCbCaptor1.capture())
+                eq(thread.looper), any(), intAdvCbCaptor1.capture(), eq(TEST_HOSTNAME)
+        )
         verify(mockDeps).makeAdvertiser(eq(mockSocket2), eq(listOf(TEST_LINKADDR)),
-                eq(thread.looper), any(), intAdvCbCaptor2.capture())
+                eq(thread.looper), any(), intAdvCbCaptor2.capture(), eq(TEST_HOSTNAME)
+        )
 
         doReturn(false).`when`(mockInterfaceAdvertiser1).isProbing(SERVICE_ID_1)
         postSync { intAdvCbCaptor1.value.onRegisterServiceSucceeded(
@@ -192,7 +205,8 @@
 
         val intAdvCbCaptor = ArgumentCaptor.forClass(MdnsInterfaceAdvertiser.Callback::class.java)
         verify(mockDeps).makeAdvertiser(eq(mockSocket1), eq(listOf(TEST_LINKADDR)),
-                eq(thread.looper), any(), intAdvCbCaptor.capture())
+                eq(thread.looper), any(), intAdvCbCaptor.capture(), eq(TEST_HOSTNAME)
+        )
         verify(mockInterfaceAdvertiser1).addService(eq(SERVICE_ID_1),
                 argThat { it.matches(SERVICE_1) })
         verify(mockInterfaceAdvertiser1).addService(eq(SERVICE_ID_2),
@@ -216,6 +230,15 @@
         verify(mockInterfaceAdvertiser1, atLeastOnce()).destroyNow()
     }
 
+    @Test
+    fun testRemoveService_whenAllServiceRemoved_thenUpdateHostName() {
+        val advertiser = MdnsAdvertiser(thread.looper, socketProvider, cb, mockDeps)
+        verify(mockDeps, times(1)).generateHostname()
+        postSync { advertiser.addService(SERVICE_ID_1, SERVICE_1) }
+        postSync { advertiser.removeService(SERVICE_ID_1) }
+        verify(mockDeps, times(2)).generateHostname()
+    }
+
     private fun postSync(r: () -> Unit) {
         handler.post(r)
         handler.waitForIdle(TIMEOUT_MS)
diff --git a/tests/unit/java/com/android/server/connectivity/mdns/MdnsInterfaceAdvertiserTest.kt b/tests/unit/java/com/android/server/connectivity/mdns/MdnsInterfaceAdvertiserTest.kt
index 4a806b1..2d8d8f3 100644
--- a/tests/unit/java/com/android/server/connectivity/mdns/MdnsInterfaceAdvertiserTest.kt
+++ b/tests/unit/java/com/android/server/connectivity/mdns/MdnsInterfaceAdvertiserTest.kt
@@ -55,6 +55,7 @@
 
 private val TEST_ADDRS = listOf(LinkAddress(parseNumericAddress("2001:db8::123"), 64))
 private val TEST_BUFFER = ByteArray(1300)
+private val TEST_HOSTNAME = arrayOf("Android_test", "local")
 
 private const val TEST_SERVICE_ID_1 = 42
 private val TEST_SERVICE_1 = NsdServiceInfo().apply {
@@ -88,12 +89,23 @@
     private val packetHandler get() = packetHandlerCaptor.value
 
     private val advertiser by lazy {
-        MdnsInterfaceAdvertiser(LOG_TAG, socket, TEST_ADDRS, thread.looper, TEST_BUFFER, cb, deps)
+        MdnsInterfaceAdvertiser(
+            LOG_TAG,
+            socket,
+            TEST_ADDRS,
+            thread.looper,
+            TEST_BUFFER,
+            cb,
+            deps,
+            TEST_HOSTNAME
+        )
     }
 
     @Before
     fun setUp() {
-        doReturn(repository).`when`(deps).makeRecordRepository(any())
+        doReturn(repository).`when`(deps).makeRecordRepository(any(),
+            eq(TEST_HOSTNAME)
+        )
         doReturn(replySender).`when`(deps).makeReplySender(anyString(), any(), any(), any())
         doReturn(announcer).`when`(deps).makeMdnsAnnouncer(anyString(), any(), any(), any())
         doReturn(prober).`when`(deps).makeMdnsProber(anyString(), any(), any(), any())
diff --git a/tests/unit/java/com/android/server/connectivity/mdns/MdnsRecordRepositoryTest.kt b/tests/unit/java/com/android/server/connectivity/mdns/MdnsRecordRepositoryTest.kt
index ecc11ec..5665091 100644
--- a/tests/unit/java/com/android/server/connectivity/mdns/MdnsRecordRepositoryTest.kt
+++ b/tests/unit/java/com/android/server/connectivity/mdns/MdnsRecordRepositoryTest.kt
@@ -67,7 +67,6 @@
 class MdnsRecordRepositoryTest {
     private val thread = HandlerThread(MdnsRecordRepositoryTest::class.simpleName)
     private val deps = object : Dependencies() {
-        override fun getHostname() = TEST_HOSTNAME
         override fun getInterfaceInetAddresses(iface: NetworkInterface) =
                 Collections.enumeration(TEST_ADDRESSES.map { it.address })
     }
@@ -84,7 +83,7 @@
 
     @Test
     fun testAddServiceAndProbe() {
-        val repository = MdnsRecordRepository(thread.looper, deps)
+        val repository = MdnsRecordRepository(thread.looper, deps, TEST_HOSTNAME)
         assertEquals(0, repository.servicesCount)
         assertEquals(-1, repository.addService(TEST_SERVICE_ID_1, TEST_SERVICE_1))
         assertEquals(1, repository.servicesCount)
@@ -117,7 +116,7 @@
 
     @Test
     fun testAddAndConflicts() {
-        val repository = MdnsRecordRepository(thread.looper, deps)
+        val repository = MdnsRecordRepository(thread.looper, deps, TEST_HOSTNAME)
         repository.addService(TEST_SERVICE_ID_1, TEST_SERVICE_1)
         assertFailsWith(NameConflictException::class) {
             repository.addService(TEST_SERVICE_ID_2, TEST_SERVICE_1)
@@ -126,7 +125,7 @@
 
     @Test
     fun testInvalidReuseOfServiceId() {
-        val repository = MdnsRecordRepository(thread.looper, deps)
+        val repository = MdnsRecordRepository(thread.looper, deps, TEST_HOSTNAME)
         repository.addService(TEST_SERVICE_ID_1, TEST_SERVICE_1)
         assertFailsWith(IllegalArgumentException::class) {
             repository.addService(TEST_SERVICE_ID_1, TEST_SERVICE_2)
@@ -135,7 +134,7 @@
 
     @Test
     fun testHasActiveService() {
-        val repository = MdnsRecordRepository(thread.looper, deps)
+        val repository = MdnsRecordRepository(thread.looper, deps, TEST_HOSTNAME)
         assertFalse(repository.hasActiveService(TEST_SERVICE_ID_1))
 
         repository.addService(TEST_SERVICE_ID_1, TEST_SERVICE_1)
@@ -152,7 +151,7 @@
 
     @Test
     fun testExitAnnouncements() {
-        val repository = MdnsRecordRepository(thread.looper, deps)
+        val repository = MdnsRecordRepository(thread.looper, deps, TEST_HOSTNAME)
         repository.initWithService(TEST_SERVICE_ID_1, TEST_SERVICE_1)
         repository.onAdvertisementSent(TEST_SERVICE_ID_1)
 
@@ -181,7 +180,7 @@
 
     @Test
     fun testExitingServiceReAdded() {
-        val repository = MdnsRecordRepository(thread.looper, deps)
+        val repository = MdnsRecordRepository(thread.looper, deps, TEST_HOSTNAME)
         repository.initWithService(TEST_SERVICE_ID_1, TEST_SERVICE_1)
         repository.onAdvertisementSent(TEST_SERVICE_ID_1)
         repository.exitService(TEST_SERVICE_ID_1)
@@ -195,7 +194,7 @@
 
     @Test
     fun testOnProbingSucceeded() {
-        val repository = MdnsRecordRepository(thread.looper, deps)
+        val repository = MdnsRecordRepository(thread.looper, deps, TEST_HOSTNAME)
         val announcementInfo = repository.initWithService(TEST_SERVICE_ID_1, TEST_SERVICE_1)
         repository.onAdvertisementSent(TEST_SERVICE_ID_1)
         val packet = announcementInfo.getPacket(0)
@@ -319,7 +318,7 @@
 
     @Test
     fun testGetReply() {
-        val repository = MdnsRecordRepository(thread.looper, deps)
+        val repository = MdnsRecordRepository(thread.looper, deps, TEST_HOSTNAME)
         repository.initWithService(TEST_SERVICE_ID_1, TEST_SERVICE_1)
         val questions = listOf(MdnsPointerRecord(arrayOf("_testservice", "_tcp", "local"),
                 0L /* receiptTimeMillis */,
@@ -404,7 +403,7 @@
 
     @Test
     fun testGetConflictingServices() {
-        val repository = MdnsRecordRepository(thread.looper, deps)
+        val repository = MdnsRecordRepository(thread.looper, deps, TEST_HOSTNAME)
         repository.addService(TEST_SERVICE_ID_1, TEST_SERVICE_1)
         repository.addService(TEST_SERVICE_ID_2, TEST_SERVICE_2)
 
@@ -432,7 +431,7 @@
 
     @Test
     fun testGetConflictingServices_IdenticalService() {
-        val repository = MdnsRecordRepository(thread.looper, deps)
+        val repository = MdnsRecordRepository(thread.looper, deps, TEST_HOSTNAME)
         repository.addService(TEST_SERVICE_ID_1, TEST_SERVICE_1)
         repository.addService(TEST_SERVICE_ID_2, TEST_SERVICE_2)
 
diff --git a/tests/unit/java/com/android/server/connectivity/mdns/MdnsResponseDecoderTests.java b/tests/unit/java/com/android/server/connectivity/mdns/MdnsResponseDecoderTests.java
index aaef048..a80c078 100644
--- a/tests/unit/java/com/android/server/connectivity/mdns/MdnsResponseDecoderTests.java
+++ b/tests/unit/java/com/android/server/connectivity/mdns/MdnsResponseDecoderTests.java
@@ -16,20 +16,26 @@
 
 package com.android.server.connectivity.mdns;
 
+import static android.net.InetAddresses.parseNumericAddress;
+
 import static com.android.server.connectivity.mdns.MdnsResponseDecoder.Clock;
 import static com.android.testutils.DevSdkIgnoreRuleKt.SC_V2;
 
+import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
 import static org.mockito.Mockito.mock;
 
-import android.net.InetAddresses;
 import android.net.Network;
+import android.util.ArraySet;
 
 import com.android.net.module.util.HexDump;
+import com.android.server.connectivity.mdns.MdnsResponseTests.MdnsInet4AddressRecord;
+import com.android.server.connectivity.mdns.MdnsResponseTests.MdnsInet6AddressRecord;
 import com.android.testutils.DevSdkIgnoreRule;
 import com.android.testutils.DevSdkIgnoreRunner;
 
@@ -43,7 +49,11 @@
 import java.net.Inet4Address;
 import java.net.Inet6Address;
 import java.net.InetSocketAddress;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
 import java.util.List;
+import java.util.stream.Collectors;
 
 @RunWith(DevSdkIgnoreRunner.class)
 @DevSdkIgnoreRule.IgnoreUpTo(SC_V2)
@@ -146,6 +156,44 @@
             + "010001000000780004C0A8018A0000000000000000000000000000"
             + "000000");
 
+    // MDNS record for name "testhost1" with an IPv4 address of 10.1.2.3
+    private static final byte[] DATAIN_IPV4_1 = HexDump.hexStringToByteArray(
+            "0974657374686f73743100000180010000007800040a010203");
+    // MDNS record for name "testhost1" with an IPv4 address of 10.1.2.4
+    private static final byte[] DATAIN_IPV4_2 = HexDump.hexStringToByteArray(
+            "0974657374686f73743100000180010000007800040a010204");
+    // MDNS record w/name "testhost1" & IPv6 address of aabb:ccdd:1122:3344:a0b0:c0d0:1020:3040
+    private static final byte[] DATAIN_IPV6_1 = HexDump.hexStringToByteArray(
+            "0974657374686f73743100001c8001000000780010aabbccdd11223344a0b0c0d010203040");
+    // MDNS record w/name "testhost1" & IPv6 address of aabb:ccdd:1122:3344:a0b0:c0d0:1020:3030
+    private static final byte[] DATAIN_IPV6_2 = HexDump.hexStringToByteArray(
+            "0974657374686f73743100001c8001000000780010aabbccdd11223344a0b0c0d010203030");
+    // MDNS record w/name "test" & PTR to foo.bar.quxx
+    private static final byte[] DATAIN_PTR_1 = HexDump.hexStringToByteArray(
+            "047465737400000C000100001194000E03666F6F03626172047175787800");
+    // MDNS record w/name "test" & PTR to foo.bar.quxy
+    private static final byte[] DATAIN_PTR_2 = HexDump.hexStringToByteArray(
+            "047465737400000C000100001194000E03666F6F03626172047175787900");
+    // SRV record for: scapy.DNSRRSRV(rrname='foo.bar.quxx', ttl=120, port=1234, target='testhost1')
+    private static final byte[] DATAIN_SERVICE_1 = HexDump.hexStringToByteArray(
+            "03666f6f03626172047175787800002100010000007800110000000004d20974657374686f73743100");
+    // SRV record for: scapy.DNSRRSRV(rrname='foo.bar.quxx', ttl=120, port=1234, target='testhost2')
+    private static final byte[] DATAIN_SERVICE_2 = HexDump.hexStringToByteArray(
+            "03666f6f03626172047175787800002100010000007800110000000004d20974657374686f73743200");
+    // TXT record for: scapy.DNSRR(rrname='foo.bar.quxx', type='TXT', ttl=120,
+    //     rdata=[b'a=hello there', b'b=1234567890', b'xyz=!$$$'])
+    private static final byte[] DATAIN_TEXT_1 = HexDump.hexStringToByteArray(
+            "03666f6f03626172047175787800001000010000007800240d613d68656c6c6f2074686572650c623d3132"
+                    + "33343536373839300878797a3d21242424");
+
+    // TXT record for: scapy.DNSRR(rrname='foo.bar.quxx', type='TXT', ttl=120,
+    //     rdata=[b'a=hello there', b'b=1234567890', b'xyz=!$$$'])
+    private static final byte[] DATAIN_TEXT_2 = HexDump.hexStringToByteArray(
+            "03666f6f03626172047175787800001000010000007800240d613d68656c6c6f2074686572650c623d3132"
+                    + "33343536373839300878797a3d21402324");
+
+    private static final String[] DATAIN_SERVICE_NAME_1 = new String[] { "foo", "bar", "quxx" };
+
     private static final String CAST_SERVICE_NAME = "_googlecast";
     private static final String[] CAST_SERVICE_TYPE =
             new String[] {CAST_SERVICE_NAME, "_tcp", "local"};
@@ -153,7 +201,7 @@
     private static final String[] MATTER_SERVICE_TYPE =
             new String[] {MATTER_SERVICE_NAME, "_tcp", "local"};
 
-    private List<MdnsResponse> responses;
+    private ArraySet<MdnsResponse> responses;
 
     private final Clock mClock = mock(Clock.class);
 
@@ -174,7 +222,7 @@
 
     @Test
     public void testDecodeMultipleAnswerPacket() throws IOException {
-        MdnsResponse response = responses.get(0);
+        MdnsResponse response = responses.valueAt(0);
         assertTrue(response.isComplete());
 
         MdnsInetAddressRecord inet4AddressRecord = response.getInet4AddressRecord();
@@ -224,7 +272,7 @@
 
         responses = decode(decoder, data6);
         assertEquals(1, responses.size());
-        MdnsResponse response = responses.get(0);
+        MdnsResponse response = responses.valueAt(0);
         assertTrue(response.isComplete());
 
         MdnsInetAddressRecord inet6AddressRecord = response.getInet6AddressRecord();
@@ -239,25 +287,30 @@
 
     @Test
     public void testIsComplete() {
-        MdnsResponse response = responses.get(0);
+        MdnsResponse response = new MdnsResponse(responses.valueAt(0));
         assertTrue(response.isComplete());
 
         response.clearPointerRecords();
+        // The service name is still known in MdnsResponse#getServiceName
+        assertTrue(response.isComplete());
+
+        response = new MdnsResponse(responses.valueAt(0));
+        response.clearInet4AddressRecords();
         assertFalse(response.isComplete());
 
-        response = responses.get(0);
-        response.setInet4AddressRecord(null);
+        response.addInet6AddressRecord(new MdnsInetAddressRecord(new String[] { "testhostname" },
+                0L /* receiptTimeMillis */, false /* cacheFlush */, 1234L /* ttlMillis */,
+                parseNumericAddress("2008:db1::123")));
+        assertTrue(response.isComplete());
+
+        response.clearInet6AddressRecords();
         assertFalse(response.isComplete());
 
-        response = responses.get(0);
-        response.setInet6AddressRecord(null);
-        assertFalse(response.isComplete());
-
-        response = responses.get(0);
+        response = new MdnsResponse(responses.valueAt(0));
         response.setServiceRecord(null);
         assertFalse(response.isComplete());
 
-        response = responses.get(0);
+        response = new MdnsResponse(responses.valueAt(0));
         response.setTextRecord(null);
         assertFalse(response.isComplete());
     }
@@ -274,12 +327,13 @@
         assertNotNull(parsedPacket);
 
         final Network network = mock(Network.class);
-        responses = decoder.buildResponses(parsedPacket,
+        responses = decoder.augmentResponses(parsedPacket,
+                /* existingResponses= */ Collections.emptyList(),
                 /* interfaceIndex= */ 10, network /* expireOnExit= */);
 
         assertEquals(responses.size(), 1);
-        assertEquals(responses.get(0).getInterfaceIndex(), 10);
-        assertEquals(network, responses.get(0).getNetwork());
+        assertEquals(responses.valueAt(0).getInterfaceIndex(), 10);
+        assertEquals(network, responses.valueAt(0).getNetwork());
     }
 
     @Test
@@ -294,18 +348,20 @@
         // This should emit two records:
         assertEquals(2, responses.size());
 
-        MdnsResponse response1 = responses.get(0);
-        MdnsResponse response2 = responses.get(0);
+        MdnsResponse response1 = responses.valueAt(0);
+        MdnsResponse response2 = responses.valueAt(0);
 
         // Both of which are complete:
         assertTrue(response1.isComplete());
         assertTrue(response2.isComplete());
 
         // And should both have the same IPv6 address:
-        assertEquals(InetAddresses.parseNumericAddress("2605:a601:a846:5700:3e61:5ff:fe0c:89f8"),
-                response1.getInet6AddressRecord().getInet6Address());
-        assertEquals(InetAddresses.parseNumericAddress("2605:a601:a846:5700:3e61:5ff:fe0c:89f8"),
-                response2.getInet6AddressRecord().getInet6Address());
+        assertTrue(response1.getInet6AddressRecords().stream().anyMatch(
+                record -> record.getInet6Address().equals(
+                        parseNumericAddress("2605:a601:a846:5700:3e61:5ff:fe0c:89f8"))));
+        assertTrue(response2.getInet6AddressRecords().stream().anyMatch(
+                record -> record.getInet6Address().equals(
+                        parseNumericAddress("2605:a601:a846:5700:3e61:5ff:fe0c:89f8"))));
     }
 
     @Test
@@ -322,17 +378,206 @@
         assertEquals(2, responses.size());
 
         // But only the first is complete:
-        assertTrue(responses.get(0).isComplete());
-        assertFalse(responses.get(1).isComplete());
+        assertTrue(responses.valueAt(0).isComplete());
+        assertFalse(responses.valueAt(1).isComplete());
+    }
+
+    @Test
+    public void testDecodeWithIpv4AddressChange() throws IOException {
+        MdnsResponse response = makeMdnsResponse(0, DATAIN_SERVICE_NAME_1, List.of(
+                new PacketAndRecordClass(DATAIN_PTR_1,
+                        MdnsPointerRecord.class),
+                new PacketAndRecordClass(DATAIN_SERVICE_1,
+                        MdnsServiceRecord.class),
+                new PacketAndRecordClass(DATAIN_IPV4_1,
+                        MdnsInet4AddressRecord.class)));
+        // Now update the response with another address
+        final MdnsResponseDecoder decoder = new MdnsResponseDecoder(mClock, null);
+        final ArraySet<MdnsResponse> updatedResponses = decode(
+                decoder, makeResponsePacket(DATAIN_IPV4_2), List.of(response));
+        assertEquals(1, updatedResponses.size());
+        assertEquals(parseNumericAddress("10.1.2.4"),
+                updatedResponses.valueAt(0).getInet4AddressRecord().getInet4Address());
+        assertEquals(parseNumericAddress("10.1.2.3"),
+                response.getInet4AddressRecord().getInet4Address());
+    }
+
+    @Test
+    public void testDecodeWithIpv6AddressChange() throws IOException {
+        MdnsResponse response = makeMdnsResponse(0, DATAIN_SERVICE_NAME_1, List.of(
+                new PacketAndRecordClass(DATAIN_PTR_1,
+                        MdnsPointerRecord.class),
+                new PacketAndRecordClass(DATAIN_SERVICE_1,
+                        MdnsServiceRecord.class),
+                new PacketAndRecordClass(DATAIN_IPV6_1,
+                        MdnsInet6AddressRecord.class)));
+        // Now update the response with another address
+        final MdnsResponseDecoder decoder = new MdnsResponseDecoder(mClock, null);
+        final ArraySet<MdnsResponse> updatedResponses = decode(
+                decoder, makeResponsePacket(DATAIN_IPV6_2), List.of(response));
+        assertEquals(1, updatedResponses.size());
+        assertEquals(parseNumericAddress("aabb:ccdd:1122:3344:a0b0:c0d0:1020:3030"),
+                updatedResponses.valueAt(0).getInet6AddressRecord().getInet6Address());
+        assertEquals(parseNumericAddress("aabb:ccdd:1122:3344:a0b0:c0d0:1020:3040"),
+                response.getInet6AddressRecord().getInet6Address());
+    }
+
+    @Test
+    public void testDecodeWithChangeOnText() throws IOException {
+        MdnsResponse response = makeMdnsResponse(0, DATAIN_SERVICE_NAME_1, List.of(
+                new PacketAndRecordClass(DATAIN_PTR_1,
+                        MdnsPointerRecord.class),
+                new PacketAndRecordClass(DATAIN_SERVICE_1,
+                        MdnsServiceRecord.class),
+                new PacketAndRecordClass(DATAIN_TEXT_1,
+                        MdnsTextRecord.class)));
+        // Now update the response with another address
+        final MdnsResponseDecoder decoder = new MdnsResponseDecoder(mClock, null);
+        final ArraySet<MdnsResponse> updatedResponses = decode(
+                decoder, makeResponsePacket(DATAIN_TEXT_2), List.of(response));
+        assertEquals(1, updatedResponses.size());
+        assertEquals(List.of(
+                new MdnsServiceInfo.TextEntry("a", "hello there"),
+                new MdnsServiceInfo.TextEntry("b", "1234567890"),
+                new MdnsServiceInfo.TextEntry("xyz", "!@#$")),
+                updatedResponses.valueAt(0).getTextRecord().getEntries());
+    }
+
+    @Test
+    public void testDecodeWithChangeOnService() throws IOException {
+        MdnsResponse response = makeMdnsResponse(0, DATAIN_SERVICE_NAME_1, List.of(
+                new PacketAndRecordClass(DATAIN_PTR_1,
+                        MdnsPointerRecord.class),
+                new PacketAndRecordClass(DATAIN_SERVICE_1,
+                        MdnsServiceRecord.class),
+                new PacketAndRecordClass(DATAIN_IPV4_1,
+                        MdnsInet4AddressRecord.class)));
+        assertArrayEquals(new String[] { "testhost1" },
+                response.getServiceRecord().getServiceHost());
+        assertNotNull(response.getInet4AddressRecord());
+        // Now update the response with another hostname
+        final MdnsResponseDecoder decoder = new MdnsResponseDecoder(mClock, null);
+        final ArraySet<MdnsResponse> updatedResponses = decode(
+                decoder, makeResponsePacket(DATAIN_SERVICE_2), List.of(response));
+        assertEquals(1, updatedResponses.size());
+        assertArrayEquals(new String[] { "testhost2" },
+                updatedResponses.valueAt(0).getServiceRecord().getServiceHost());
+        // Hostname changed, so address records are dropped
+        assertNull(updatedResponses.valueAt(0).getInet4AddressRecord());
+    }
+
+    @Test
+    public void testDecodeWithChangeOnPtr() throws IOException {
+        MdnsResponse response = makeMdnsResponse(0, DATAIN_SERVICE_NAME_1, List.of(
+                new PacketAndRecordClass(DATAIN_PTR_1,
+                        MdnsPointerRecord.class),
+                new PacketAndRecordClass(DATAIN_SERVICE_1,
+                        MdnsServiceRecord.class)));
+        // Now update the response with another address
+        final MdnsResponseDecoder decoder = new MdnsResponseDecoder(mClock, null);
+        final ArraySet<MdnsResponse> updatedResponses = decode(
+                decoder, makeResponsePacket(DATAIN_PTR_2), List.of(response));
+        assertEquals(1, updatedResponses.size());
+        assertArrayEquals(new String[] { "foo", "bar", "quxy" },
+                updatedResponses.valueAt(0).getPointerRecords().get(0).getPointer());
+    }
+
+    @Test
+    public void testDecodeWithNoChange() throws IOException {
+        List<PacketAndRecordClass> recordList =
+                Arrays.asList(
+                        new PacketAndRecordClass(DATAIN_IPV4_1, MdnsInet4AddressRecord.class),
+                        new PacketAndRecordClass(DATAIN_IPV6_1, MdnsInet6AddressRecord.class),
+                        new PacketAndRecordClass(DATAIN_PTR_1, MdnsPointerRecord.class),
+                        new PacketAndRecordClass(DATAIN_SERVICE_2, MdnsServiceRecord.class),
+                        new PacketAndRecordClass(DATAIN_TEXT_1, MdnsTextRecord.class));
+        // Create a two identical responses.
+        MdnsResponse response = makeMdnsResponse(0, DATAIN_SERVICE_NAME_1, recordList);
+
+        final MdnsResponseDecoder decoder = new MdnsResponseDecoder(mClock, null);
+        final byte[] identicalResponse = makeResponsePacket(
+                recordList.stream().map(p -> p.packetData).collect(Collectors.toList()));
+        final ArraySet<MdnsResponse> changes = decode(
+                decoder, identicalResponse, List.of(response));
+
+        // Decoding should not indicate any change.
+        assertEquals(0, changes.size());
+    }
+
+    private static MdnsResponse makeMdnsResponse(long time, String[] serviceName,
+            List<PacketAndRecordClass> responseList) throws IOException {
+        final MdnsResponse response = new MdnsResponse(
+                time, serviceName, 999 /* interfaceIndex */, mock(Network.class));
+        for (PacketAndRecordClass responseData : responseList) {
+            DatagramPacket packet =
+                    new DatagramPacket(responseData.packetData, responseData.packetData.length);
+            MdnsPacketReader reader = new MdnsPacketReader(packet);
+            String[] name = reader.readLabels();
+            reader.skip(2); // skip record type indication.
+            // Apply the right kind of record to the response.
+            if (responseData.recordClass == MdnsInet4AddressRecord.class) {
+                response.addInet4AddressRecord(new MdnsInet4AddressRecord(name, reader));
+            } else if (responseData.recordClass == MdnsInet6AddressRecord.class) {
+                response.addInet6AddressRecord(new MdnsInet6AddressRecord(name, reader));
+            } else if (responseData.recordClass == MdnsPointerRecord.class) {
+                response.addPointerRecord(new MdnsPointerRecord(name, reader));
+            } else if (responseData.recordClass == MdnsServiceRecord.class) {
+                response.setServiceRecord(new MdnsServiceRecord(name, reader));
+            } else if (responseData.recordClass == MdnsTextRecord.class) {
+                response.setTextRecord(new MdnsTextRecord(name, reader));
+            } else {
+                fail("Unsupported/unexpected MdnsRecord subtype used in test - invalid test!");
+            }
+        }
+        return response;
+    }
+
+    private static byte[] makeResponsePacket(byte[] responseRecord) throws IOException {
+        return makeResponsePacket(List.of(responseRecord));
+    }
+
+    private static byte[] makeResponsePacket(List<byte[]> responseRecords) throws IOException {
+        final MdnsPacketWriter writer = new MdnsPacketWriter(1500);
+        writer.writeUInt16(0); // Transaction ID (advertisement: 0)
+        writer.writeUInt16(0x8400); // Flags: response, authoritative
+        writer.writeUInt16(0); // questions count
+        writer.writeUInt16(responseRecords.size()); // answers count
+        writer.writeUInt16(0); // authority entries count
+        writer.writeUInt16(0); // additional records count
+
+        for (byte[] record : responseRecords) {
+            writer.writeBytes(record);
+        }
+        final DatagramPacket packet = writer.getPacket(new InetSocketAddress(0 /* port */));
+        return Arrays.copyOf(packet.getData(), packet.getLength());
     }
 
 
-    private List<MdnsResponse> decode(MdnsResponseDecoder decoder, byte[] data)
+    // This helper class just wraps the data bytes of a response packet with the contained record
+    // type.
+    // Its only purpose is to make the test code a bit more readable.
+    private static class PacketAndRecordClass {
+        public final byte[] packetData;
+        public final Class<?> recordClass;
+
+        PacketAndRecordClass(byte[] data, Class<?> c) {
+            packetData = data;
+            recordClass = c;
+        }
+    }
+
+    private ArraySet<MdnsResponse> decode(MdnsResponseDecoder decoder, byte[] data)
             throws MdnsPacket.ParseException {
+        return decode(decoder, data, Collections.emptyList());
+    }
+
+    private ArraySet<MdnsResponse> decode(MdnsResponseDecoder decoder, byte[] data,
+            Collection<MdnsResponse> existingResponses) throws MdnsPacket.ParseException {
         final MdnsPacket parsedPacket = MdnsResponseDecoder.parseResponse(data, data.length);
         assertNotNull(parsedPacket);
 
-        return decoder.buildResponses(parsedPacket,
+        return decoder.augmentResponses(parsedPacket,
+                existingResponses,
                 MdnsSocket.INTERFACE_INDEX_UNSPECIFIED, mock(Network.class));
     }
 }
\ No newline at end of file
diff --git a/tests/unit/java/com/android/server/connectivity/mdns/MdnsResponseTests.java b/tests/unit/java/com/android/server/connectivity/mdns/MdnsResponseTests.java
index ec57dc8..3f5e7a1 100644
--- a/tests/unit/java/com/android/server/connectivity/mdns/MdnsResponseTests.java
+++ b/tests/unit/java/com/android/server/connectivity/mdns/MdnsResponseTests.java
@@ -16,6 +16,8 @@
 
 package com.android.server.connectivity.mdns;
 
+import static android.net.InetAddresses.parseNumericAddress;
+
 import static com.android.testutils.DevSdkIgnoreRuleKt.SC_V2;
 
 import static org.junit.Assert.assertEquals;
@@ -23,22 +25,21 @@
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
 import static org.mockito.Mockito.mock;
 
+import static java.util.Collections.emptyList;
+
 import android.net.Network;
 
 import com.android.net.module.util.HexDump;
 import com.android.testutils.DevSdkIgnoreRule;
 import com.android.testutils.DevSdkIgnoreRunner;
 
-import org.junit.Ignore;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 
 import java.io.IOException;
 import java.net.DatagramPacket;
-import java.util.Arrays;
 import java.util.List;
 
 // The record test data does not use compressed names (label pointers), since that would require
@@ -48,36 +49,24 @@
 public class MdnsResponseTests {
     private static final String TAG = "MdnsResponseTests";
     // MDNS response packet for name "test" with an IPv4 address of 10.1.2.3
-    private static final byte[] dataIn_ipv4_1 = HexDump.hexStringToByteArray(
+    private static final byte[] DATAIN_IPV4 = HexDump.hexStringToByteArray(
             "0474657374000001" + "0001000011940004" + "0A010203");
-    // MDNS response packet for name "tess" with an IPv4 address of 10.1.2.4
-    private static final byte[] dataIn_ipv4_2 = HexDump.hexStringToByteArray(
-            "0474657373000001" + "0001000011940004" + "0A010204");
     // MDNS response w/name "test" & IPv6 address of aabb:ccdd:1122:3344:a0b0:c0d0:1020:3040
-    private static final byte[] dataIn_ipv6_1 = HexDump.hexStringToByteArray(
+    private static final byte[] DATAIN_IPV6 = HexDump.hexStringToByteArray(
             "047465737400001C" + "0001000011940010" + "AABBCCDD11223344" + "A0B0C0D010203040");
-    // MDNS response w/name "test" & IPv6 address of aabb:ccdd:1122:3344:a0b0:c0d0:1020:3030
-    private static final byte[] dataIn_ipv6_2 = HexDump.hexStringToByteArray(
-            "047465737400001C" + "0001000011940010" + "AABBCCDD11223344" + "A0B0C0D010203030");
     // MDNS response w/name "test" & PTR to foo.bar.quxx
-    private static final byte[] dataIn_ptr_1 = HexDump.hexStringToByteArray(
+    private static final byte[] DATAIN_PTR = HexDump.hexStringToByteArray(
             "047465737400000C" + "000100001194000E" + "03666F6F03626172" + "047175787800");
-    // MDNS response w/name "test" & PTR to foo.bar.quxy
-    private static final byte[] dataIn_ptr_2 = HexDump.hexStringToByteArray(
-            "047465737400000C" + "000100001194000E" + "03666F6F03626172" + "047175787900");
     // MDNS response w/name "test" & Service for host foo.bar.quxx
-    private static final byte[] dataIn_service_1 = HexDump.hexStringToByteArray(
+    private static final byte[] DATAIN_SERVICE = HexDump.hexStringToByteArray(
             "0474657374000021"
             + "0001000011940014"
             + "000100FF1F480366"
             + "6F6F036261720471"
             + "75787800");
-    // MDNS response w/name "test" & Service for host test
-    private static final byte[] dataIn_service_2 = HexDump.hexStringToByteArray(
-            "0474657374000021" + "000100001194000B" + "000100FF1F480474" + "657374");
     // MDNS response w/name "test" & the following text strings:
     // "a=hello there", "b=1234567890", and "xyz=!$$$"
-    private static final byte[] dataIn_text_1 = HexDump.hexStringToByteArray(
+    private static final byte[] DATAIN_TEXT = HexDump.hexStringToByteArray(
             "0474657374000010"
             + "0001000011940024"
             + "0D613D68656C6C6F"
@@ -85,18 +74,11 @@
             + "3D31323334353637"
             + "3839300878797A3D"
             + "21242424");
-    // MDNS response w/name "test" & the following text strings:
-    // "a=hello there", "b=1234567890", and "xyz=!@#$"
-    private static final byte[] dataIn_text_2 = HexDump.hexStringToByteArray(
-            "0474657374000010"
-            + "0001000011940024"
-            + "0D613D68656C6C6F"
-            + "2074686572650C62"
-            + "3D31323334353637"
-            + "3839300878797A3D"
-            + "21402324");
+    private static final String[] TEST_SERVICE_NAME =
+            new String[] { "test", "_type", "_tcp", "local" };
 
     private static final int INTERFACE_INDEX = 999;
+    private static final int TEST_TTL_MS = 120_000;
     private final Network mNetwork = mock(Network.class);
 
     // The following helper classes act as wrappers so that IPv4 and IPv6 address records can
@@ -113,87 +95,63 @@
         }
     }
 
-    // This helper class just wraps the data bytes of a response packet with the contained record
-    // type.
-    // Its only purpose is to make the test code a bit more readable.
-    static class PacketAndRecordClass {
-        public final byte[] packetData;
-        public final Class<?> recordClass;
-
-        public PacketAndRecordClass() {
-            packetData = null;
-            recordClass = null;
-        }
-
-        public PacketAndRecordClass(byte[] data, Class<?> c) {
-            packetData = data;
-            recordClass = c;
-        }
-    }
-
-    // Construct an MdnsResponse with the specified data packets applied.
-    private MdnsResponse makeMdnsResponse(long time, List<PacketAndRecordClass> responseList)
-            throws IOException {
-        MdnsResponse response = new MdnsResponse(time, INTERFACE_INDEX, mNetwork);
-        for (PacketAndRecordClass responseData : responseList) {
-            DatagramPacket packet =
-                    new DatagramPacket(responseData.packetData, responseData.packetData.length);
-            MdnsPacketReader reader = new MdnsPacketReader(packet);
-            String[] name = reader.readLabels();
-            reader.skip(2); // skip record type indication.
-            // Apply the right kind of record to the response.
-            if (responseData.recordClass == MdnsInet4AddressRecord.class) {
-                response.setInet4AddressRecord(new MdnsInet4AddressRecord(name, reader));
-            } else if (responseData.recordClass == MdnsInet6AddressRecord.class) {
-                response.setInet6AddressRecord(new MdnsInet6AddressRecord(name, reader));
-            } else if (responseData.recordClass == MdnsPointerRecord.class) {
-                response.addPointerRecord(new MdnsPointerRecord(name, reader));
-            } else if (responseData.recordClass == MdnsServiceRecord.class) {
-                response.setServiceRecord(new MdnsServiceRecord(name, reader));
-            } else if (responseData.recordClass == MdnsTextRecord.class) {
-                response.setTextRecord(new MdnsTextRecord(name, reader));
-            } else {
-                fail("Unsupported/unexpected MdnsRecord subtype used in test - invalid test!");
-            }
-        }
+    private MdnsResponse makeCompleteResponse(int recordsTtlMillis) {
+        final String[] hostname = new String[] { "MyHostname" };
+        final String[] serviceName = new String[] { "MyService", "_type", "_tcp", "local" };
+        final String[] serviceType = new String[] { "_type", "_tcp", "local" };
+        final MdnsResponse response = new MdnsResponse(/* now= */ 0, serviceName, INTERFACE_INDEX,
+                mNetwork);
+        response.addPointerRecord(new MdnsPointerRecord(serviceType, 0L /* receiptTimeMillis */,
+                false /* cacheFlush */, recordsTtlMillis, serviceName));
+        response.setServiceRecord(new MdnsServiceRecord(serviceName, 0L /* receiptTimeMillis */,
+                true /* cacheFlush */, recordsTtlMillis, 0 /* servicePriority */,
+                0 /* serviceWeight */, 0 /* servicePort */, hostname));
+        response.setTextRecord(new MdnsTextRecord(serviceName, 0L /* receiptTimeMillis */,
+                true /* cacheFlush */, recordsTtlMillis, emptyList() /* entries */));
+        response.addInet4AddressRecord(new MdnsInetAddressRecord(
+                hostname, 0L /* receiptTimeMillis */, true /* cacheFlush */,
+                recordsTtlMillis, parseNumericAddress("192.0.2.123")));
+        response.addInet6AddressRecord(new MdnsInetAddressRecord(
+                hostname, 0L /* receiptTimeMillis */, true /* cacheFlush */,
+                recordsTtlMillis, parseNumericAddress("2001:db8::123")));
         return response;
     }
 
     @Test
     public void getInet4AddressRecord_returnsAddedRecord() throws IOException {
-        DatagramPacket packet = new DatagramPacket(dataIn_ipv4_1, dataIn_ipv4_1.length);
+        DatagramPacket packet = new DatagramPacket(DATAIN_IPV4, DATAIN_IPV4.length);
         MdnsPacketReader reader = new MdnsPacketReader(packet);
         String[] name = reader.readLabels();
         reader.skip(2); // skip record type indication.
         MdnsInetAddressRecord record = new MdnsInetAddressRecord(name, MdnsRecord.TYPE_A, reader);
-        MdnsResponse response = new MdnsResponse(0, INTERFACE_INDEX, mNetwork);
+        MdnsResponse response = new MdnsResponse(0, TEST_SERVICE_NAME, INTERFACE_INDEX, mNetwork);
         assertFalse(response.hasInet4AddressRecord());
-        assertTrue(response.setInet4AddressRecord(record));
+        assertTrue(response.addInet4AddressRecord(record));
         assertEquals(response.getInet4AddressRecord(), record);
     }
 
     @Test
     public void getInet6AddressRecord_returnsAddedRecord() throws IOException {
-        DatagramPacket packet = new DatagramPacket(dataIn_ipv6_1, dataIn_ipv6_1.length);
+        DatagramPacket packet = new DatagramPacket(DATAIN_IPV6, DATAIN_IPV6.length);
         MdnsPacketReader reader = new MdnsPacketReader(packet);
         String[] name = reader.readLabels();
         reader.skip(2); // skip record type indication.
         MdnsInetAddressRecord record =
                 new MdnsInetAddressRecord(name, MdnsRecord.TYPE_AAAA, reader);
-        MdnsResponse response = new MdnsResponse(0, INTERFACE_INDEX, mNetwork);
+        MdnsResponse response = new MdnsResponse(0, TEST_SERVICE_NAME, INTERFACE_INDEX, mNetwork);
         assertFalse(response.hasInet6AddressRecord());
-        assertTrue(response.setInet6AddressRecord(record));
+        assertTrue(response.addInet6AddressRecord(record));
         assertEquals(response.getInet6AddressRecord(), record);
     }
 
     @Test
     public void getPointerRecords_returnsAddedRecord() throws IOException {
-        DatagramPacket packet = new DatagramPacket(dataIn_ptr_1, dataIn_ptr_1.length);
+        DatagramPacket packet = new DatagramPacket(DATAIN_PTR, DATAIN_PTR.length);
         MdnsPacketReader reader = new MdnsPacketReader(packet);
         String[] name = reader.readLabels();
         reader.skip(2); // skip record type indication.
         MdnsPointerRecord record = new MdnsPointerRecord(name, reader);
-        MdnsResponse response = new MdnsResponse(0, INTERFACE_INDEX, mNetwork);
+        MdnsResponse response = new MdnsResponse(0, record.getPointer(), INTERFACE_INDEX, mNetwork);
         assertFalse(response.hasPointerRecords());
         assertTrue(response.addPointerRecord(record));
         List<MdnsPointerRecord> recordList = response.getPointerRecords();
@@ -204,12 +162,12 @@
 
     @Test
     public void getServiceRecord_returnsAddedRecord() throws IOException {
-        DatagramPacket packet = new DatagramPacket(dataIn_service_1, dataIn_service_1.length);
+        DatagramPacket packet = new DatagramPacket(DATAIN_SERVICE, DATAIN_SERVICE.length);
         MdnsPacketReader reader = new MdnsPacketReader(packet);
         String[] name = reader.readLabels();
         reader.skip(2); // skip record type indication.
         MdnsServiceRecord record = new MdnsServiceRecord(name, reader);
-        MdnsResponse response = new MdnsResponse(0, INTERFACE_INDEX, mNetwork);
+        MdnsResponse response = new MdnsResponse(0, name, INTERFACE_INDEX, mNetwork);
         assertFalse(response.hasServiceRecord());
         assertTrue(response.setServiceRecord(record));
         assertEquals(response.getServiceRecord(), record);
@@ -217,12 +175,12 @@
 
     @Test
     public void getTextRecord_returnsAddedRecord() throws IOException {
-        DatagramPacket packet = new DatagramPacket(dataIn_text_1, dataIn_text_1.length);
+        DatagramPacket packet = new DatagramPacket(DATAIN_TEXT, DATAIN_TEXT.length);
         MdnsPacketReader reader = new MdnsPacketReader(packet);
         String[] name = reader.readLabels();
         reader.skip(2); // skip record type indication.
         MdnsTextRecord record = new MdnsTextRecord(name, reader);
-        MdnsResponse response = new MdnsResponse(0, INTERFACE_INDEX, mNetwork);
+        MdnsResponse response = new MdnsResponse(0, name, INTERFACE_INDEX, mNetwork);
         assertFalse(response.hasTextRecord());
         assertTrue(response.setTextRecord(record));
         assertEquals(response.getTextRecord(), record);
@@ -230,104 +188,86 @@
 
     @Test
     public void getInterfaceIndex() {
-        final MdnsResponse response1 = new MdnsResponse(/* now= */ 0, INTERFACE_INDEX, mNetwork);
+        final MdnsResponse response1 = new MdnsResponse(/* now= */ 0, TEST_SERVICE_NAME,
+                INTERFACE_INDEX, mNetwork);
         assertEquals(INTERFACE_INDEX, response1.getInterfaceIndex());
 
-        final MdnsResponse response2 =
-                new MdnsResponse(/* now= */ 0, 1234 /* interfaceIndex */, mNetwork);
+        final MdnsResponse response2 = new MdnsResponse(/* now= */ 0, TEST_SERVICE_NAME,
+                1234 /* interfaceIndex */, mNetwork);
         assertEquals(1234, response2.getInterfaceIndex());
     }
 
     @Test
     public void testGetNetwork() {
-        final MdnsResponse response1 =
-                new MdnsResponse(/* now= */ 0, INTERFACE_INDEX, null /* network */);
+        final MdnsResponse response1 = new MdnsResponse(/* now= */ 0, TEST_SERVICE_NAME,
+                INTERFACE_INDEX, null /* network */);
         assertNull(response1.getNetwork());
 
-        final MdnsResponse response2 =
-                new MdnsResponse(/* now= */ 0, 1234 /* interfaceIndex */, mNetwork);
+        final MdnsResponse response2 = new MdnsResponse(/* now= */ 0, TEST_SERVICE_NAME,
+                1234 /* interfaceIndex */, mNetwork);
         assertEquals(mNetwork, response2.getNetwork());
     }
 
     @Test
-    public void mergeRecordsFrom_indicates_change_on_ipv4_address() throws IOException {
-        MdnsResponse response = makeMdnsResponse(
-                0,
-                Arrays.asList(
-                        new PacketAndRecordClass(dataIn_ipv4_1, MdnsInet4AddressRecord.class)));
-        // Now create a new response that updates the address.
-        MdnsResponse response2 = makeMdnsResponse(
-                100,
-                Arrays.asList(
-                        new PacketAndRecordClass(dataIn_ipv4_2, MdnsInet4AddressRecord.class)));
-        assertTrue(response.mergeRecordsFrom(response2));
+    public void copyConstructor() {
+        final MdnsResponse response = makeCompleteResponse(TEST_TTL_MS);
+        final MdnsResponse copy = new MdnsResponse(response);
+
+        assertEquals(response.getInet6AddressRecord(), copy.getInet6AddressRecord());
+        assertEquals(response.getInet4AddressRecord(), copy.getInet4AddressRecord());
+        assertEquals(response.getPointerRecords(), copy.getPointerRecords());
+        assertEquals(response.getServiceRecord(), copy.getServiceRecord());
+        assertEquals(response.getTextRecord(), copy.getTextRecord());
+        assertEquals(response.getRecords(), copy.getRecords());
+        assertEquals(response.getNetwork(), copy.getNetwork());
+        assertEquals(response.getInterfaceIndex(), copy.getInterfaceIndex());
     }
 
     @Test
-    public void mergeRecordsFrom_indicates_change_on_ipv6_address() throws IOException {
-        MdnsResponse response = makeMdnsResponse(
-                0,
-                Arrays.asList(
-                        new PacketAndRecordClass(dataIn_ipv6_1, MdnsInet6AddressRecord.class)));
-        // Now create a new response that updates the address.
-        MdnsResponse response2 = makeMdnsResponse(
-                100,
-                Arrays.asList(
-                        new PacketAndRecordClass(dataIn_ipv6_2, MdnsInet6AddressRecord.class)));
-        assertTrue(response.mergeRecordsFrom(response2));
+    public void addRecords_noChange() {
+        final MdnsResponse response = makeCompleteResponse(TEST_TTL_MS);
+
+        assertFalse(response.addPointerRecord(response.getPointerRecords().get(0)));
+        assertFalse(response.addInet6AddressRecord(response.getInet6AddressRecord()));
+        assertFalse(response.addInet4AddressRecord(response.getInet4AddressRecord()));
+        assertFalse(response.setServiceRecord(response.getServiceRecord()));
+        assertFalse(response.setTextRecord(response.getTextRecord()));
     }
 
     @Test
-    public void mergeRecordsFrom_indicates_change_on_text() throws IOException {
-        MdnsResponse response = makeMdnsResponse(
-                0,
-                Arrays.asList(new PacketAndRecordClass(dataIn_text_1, MdnsTextRecord.class)));
-        // Now create a new response that updates the address.
-        MdnsResponse response2 = makeMdnsResponse(
-                100,
-                Arrays.asList(new PacketAndRecordClass(dataIn_text_2, MdnsTextRecord.class)));
-        assertTrue(response.mergeRecordsFrom(response2));
-    }
+    public void addRecords_ttlChange() {
+        final MdnsResponse response = makeCompleteResponse(TEST_TTL_MS);
+        final MdnsResponse ttlZeroResponse = makeCompleteResponse(0);
 
-    @Test
-    public void mergeRecordsFrom_indicates_change_on_service() throws IOException {
-        MdnsResponse response = makeMdnsResponse(
-                0,
-                Arrays.asList(new PacketAndRecordClass(dataIn_service_1, MdnsServiceRecord.class)));
-        // Now create a new response that updates the address.
-        MdnsResponse response2 = makeMdnsResponse(
-                100,
-                Arrays.asList(new PacketAndRecordClass(dataIn_service_2, MdnsServiceRecord.class)));
-        assertTrue(response.mergeRecordsFrom(response2));
-    }
+        assertTrue(response.addPointerRecord(ttlZeroResponse.getPointerRecords().get(0)));
+        assertEquals(1, response.getPointerRecords().size());
+        assertEquals(0, response.getPointerRecords().get(0).getTtl());
+        assertTrue(response.getRecords().stream().anyMatch(r ->
+                r == response.getPointerRecords().get(0)));
 
-    @Test
-    public void mergeRecordsFrom_indicates_change_on_pointer() throws IOException {
-        MdnsResponse response = makeMdnsResponse(
-                0,
-                Arrays.asList(new PacketAndRecordClass(dataIn_ptr_1, MdnsPointerRecord.class)));
-        // Now create a new response that updates the address.
-        MdnsResponse response2 = makeMdnsResponse(
-                100,
-                Arrays.asList(new PacketAndRecordClass(dataIn_ptr_2, MdnsPointerRecord.class)));
-        assertTrue(response.mergeRecordsFrom(response2));
-    }
+        assertTrue(response.addInet6AddressRecord(ttlZeroResponse.getInet6AddressRecord()));
+        assertEquals(1, response.getInet6AddressRecords().size());
+        assertEquals(0, response.getInet6AddressRecord().getTtl());
+        assertTrue(response.getRecords().stream().anyMatch(r ->
+                r == response.getInet6AddressRecord()));
 
-    @Test
-    @Ignore("MdnsConfigs is not configurable currently.")
-    public void mergeRecordsFrom_indicates_noChange() throws IOException {
-        //MdnsConfigsFlagsImpl.useReducedMergeRecordUpdateEvents.override(true);
-        List<PacketAndRecordClass> recordList =
-                Arrays.asList(
-                        new PacketAndRecordClass(dataIn_ipv4_1, MdnsInet4AddressRecord.class),
-                        new PacketAndRecordClass(dataIn_ipv6_1, MdnsInet6AddressRecord.class),
-                        new PacketAndRecordClass(dataIn_ptr_1, MdnsPointerRecord.class),
-                        new PacketAndRecordClass(dataIn_service_2, MdnsServiceRecord.class),
-                        new PacketAndRecordClass(dataIn_text_1, MdnsTextRecord.class));
-        // Create a two identical responses.
-        MdnsResponse response = makeMdnsResponse(0, recordList);
-        MdnsResponse response2 = makeMdnsResponse(100, recordList);
-        // Merging should not indicate any change.
-        assertFalse(response.mergeRecordsFrom(response2));
+        assertTrue(response.addInet4AddressRecord(ttlZeroResponse.getInet4AddressRecord()));
+        assertEquals(1, response.getInet4AddressRecords().size());
+        assertEquals(0, response.getInet4AddressRecord().getTtl());
+        assertTrue(response.getRecords().stream().anyMatch(r ->
+                r == response.getInet4AddressRecord()));
+
+        assertTrue(response.setServiceRecord(ttlZeroResponse.getServiceRecord()));
+        assertEquals(0, response.getServiceRecord().getTtl());
+        assertTrue(response.getRecords().stream().anyMatch(r ->
+                r == response.getServiceRecord()));
+
+        assertTrue(response.setTextRecord(ttlZeroResponse.getTextRecord()));
+        assertEquals(0, response.getTextRecord().getTtl());
+        assertTrue(response.getRecords().stream().anyMatch(r ->
+                r == response.getTextRecord()));
+
+        // All records were replaced, not added
+        assertEquals(ttlZeroResponse.getRecords().size(), response.getRecords().size());
     }
 }
\ No newline at end of file
diff --git a/tests/unit/java/com/android/server/connectivity/mdns/MdnsServiceInfoTest.java b/tests/unit/java/com/android/server/connectivity/mdns/MdnsServiceInfoTest.java
index 76728cf..e7d7a98 100644
--- a/tests/unit/java/com/android/server/connectivity/mdns/MdnsServiceInfoTest.java
+++ b/tests/unit/java/com/android/server/connectivity/mdns/MdnsServiceInfoTest.java
@@ -119,6 +119,26 @@
     }
 
     @Test
+    public void constructor_createWithUppercaseKeys_correctAttributes() {
+        MdnsServiceInfo info =
+                new MdnsServiceInfo(
+                        "my-mdns-service",
+                        new String[] {"_testtype", "_tcp"},
+                        List.of(),
+                        new String[] {"my-host", "local"},
+                        12345,
+                        "192.168.1.1",
+                        "2001::1",
+                        List.of("KEY=Value"),
+                        /* textEntries= */ null);
+
+        assertEquals("Value", info.getAttributeByKey("key"));
+        assertEquals("Value", info.getAttributeByKey("KEY"));
+        assertEquals(1, info.getAttributes().size());
+        assertEquals("KEY", info.getAttributes().keySet().iterator().next());
+    }
+
+    @Test
     public void getInterfaceIndex_constructorWithDefaultValues_returnsMinusOne() {
         MdnsServiceInfo info =
                 new MdnsServiceInfo(
@@ -177,8 +197,8 @@
                         List.of(),
                         new String[] {"my-host", "local"},
                         12345,
-                        "192.168.1.1",
-                        "2001::1",
+                        List.of("192.168.1.1"),
+                        List.of("2001::1"),
                         List.of(),
                         /* textEntries= */ null,
                         /* interfaceIndex= */ 20,
@@ -197,8 +217,8 @@
                         List.of(),
                         new String[] {"my-host", "local"},
                         12345,
-                        "192.168.1.1",
-                        "2001::1",
+                        List.of("192.168.1.1", "192.168.1.2"),
+                        List.of("2001::1", "2001::2"),
                         List.of("vn=Alphabet Inc.", "mn=Google Nest Hub Max", "id=12345"),
                         List.of(
                                 MdnsServiceInfo.TextEntry.fromString("vn=Google Inc."),
@@ -217,7 +237,9 @@
         assertArrayEquals(beforeParcel.getHostName(), afterParcel.getHostName());
         assertEquals(beforeParcel.getPort(), afterParcel.getPort());
         assertEquals(beforeParcel.getIpv4Address(), afterParcel.getIpv4Address());
+        assertEquals(beforeParcel.getIpv4Addresses(), afterParcel.getIpv4Addresses());
         assertEquals(beforeParcel.getIpv6Address(), afterParcel.getIpv6Address());
+        assertEquals(beforeParcel.getIpv6Addresses(), afterParcel.getIpv6Addresses());
         assertEquals(beforeParcel.getAttributes(), afterParcel.getAttributes());
         assertEquals(beforeParcel.getInterfaceIndex(), afterParcel.getInterfaceIndex());
         assertEquals(beforeParcel.getNetwork(), afterParcel.getNetwork());
diff --git a/tests/unit/java/com/android/server/connectivity/mdns/MdnsServiceTypeClientTests.java b/tests/unit/java/com/android/server/connectivity/mdns/MdnsServiceTypeClientTests.java
index d266b3d..d9fa10f 100644
--- a/tests/unit/java/com/android/server/connectivity/mdns/MdnsServiceTypeClientTests.java
+++ b/tests/unit/java/com/android/server/connectivity/mdns/MdnsServiceTypeClientTests.java
@@ -25,9 +25,11 @@
 import static org.junit.Assert.assertTrue;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.argThat;
+import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.inOrder;
 import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
@@ -68,6 +70,7 @@
 import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.ScheduledThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
+import java.util.stream.Stream;
 
 /** Tests for {@link MdnsServiceTypeClient}. */
 @RunWith(DevSdkIgnoreRunner.class)
@@ -417,13 +420,13 @@
     }
 
     private static void verifyServiceInfo(MdnsServiceInfo serviceInfo, String serviceName,
-            String[] serviceType, String ipv4Address, String ipv6Address, int port,
+            String[] serviceType, List<String> ipv4Addresses, List<String> ipv6Addresses, int port,
             List<String> subTypes, Map<String, String> attributes, int interfaceIndex,
             Network network) {
         assertEquals(serviceName, serviceInfo.getServiceInstanceName());
         assertArrayEquals(serviceType, serviceInfo.getServiceType());
-        assertEquals(ipv4Address, serviceInfo.getIpv4Address());
-        assertEquals(ipv6Address, serviceInfo.getIpv6Address());
+        assertEquals(ipv4Addresses, serviceInfo.getIpv4Addresses());
+        assertEquals(ipv6Addresses, serviceInfo.getIpv6Addresses());
         assertEquals(port, serviceInfo.getPort());
         assertEquals(subTypes, serviceInfo.getSubtypes());
         for (String key : attributes.keySet()) {
@@ -446,8 +449,8 @@
         verifyServiceInfo(serviceInfoCaptor.getAllValues().get(0),
                 "service-instance-1",
                 SERVICE_TYPE_LABELS,
-                /* ipv4Address= */ null,
-                /* ipv6Address= */ null,
+                /* ipv4Address= */ List.of(),
+                /* ipv6Address= */ List.of(),
                 /* port= */ 0,
                 /* subTypes= */ List.of(),
                 Collections.emptyMap(),
@@ -481,8 +484,8 @@
         verifyServiceInfo(serviceInfoCaptor.getAllValues().get(0),
                 "service-instance-1",
                 SERVICE_TYPE_LABELS,
-                ipV4Address /* ipv4Address */,
-                null /* ipv6Address */,
+                List.of(ipV4Address) /* ipv4Address */,
+                List.of() /* ipv6Address */,
                 5353 /* port */,
                 Collections.singletonList("ABCDE") /* subTypes */,
                 Collections.singletonMap("key", null) /* attributes */,
@@ -536,8 +539,8 @@
         verifyServiceInfo(serviceInfoCaptor.getAllValues().get(0),
                 "service-instance-1",
                 SERVICE_TYPE_LABELS,
-                null /* ipv4Address */,
-                ipV6Address /* ipv6Address */,
+                List.of() /* ipv4Address */,
+                List.of(ipV6Address) /* ipv6Address */,
                 5353 /* port */,
                 Collections.singletonList("ABCDE") /* subTypes */,
                 Collections.singletonMap("key", null) /* attributes */,
@@ -635,8 +638,8 @@
         verifyServiceInfo(serviceInfoCaptor.getAllValues().get(0),
                 "service-instance-1",
                 SERVICE_TYPE_LABELS,
-                "192.168.1.1" /* ipv4Address */,
-                null /* ipv6Address */,
+                List.of("192.168.1.1") /* ipv4Address */,
+                List.of() /* ipv6Address */,
                 5353 /* port */,
                 Collections.singletonList("ABCDE") /* subTypes */,
                 Collections.singletonMap("key", null) /* attributes */,
@@ -831,8 +834,8 @@
         verifyServiceInfo(serviceInfoCaptor.getAllValues().get(0),
                 serviceName,
                 SERVICE_TYPE_LABELS,
-                null /* ipv4Address */,
-                null /* ipv6Address */,
+                List.of() /* ipv4Address */,
+                List.of() /* ipv6Address */,
                 5353 /* port */,
                 Collections.singletonList(subtype) /* subTypes */,
                 Collections.singletonMap("key", null) /* attributes */,
@@ -844,8 +847,8 @@
         verifyServiceInfo(serviceInfoCaptor.getAllValues().get(1),
                 serviceName,
                 SERVICE_TYPE_LABELS,
-                ipV4Address /* ipv4Address */,
-                null /* ipv6Address */,
+                List.of(ipV4Address) /* ipv4Address */,
+                List.of() /* ipv6Address */,
                 5353 /* port */,
                 Collections.singletonList(subtype) /* subTypes */,
                 Collections.singletonMap("key", null) /* attributes */,
@@ -857,8 +860,8 @@
         verifyServiceInfo(serviceInfoCaptor.getAllValues().get(2),
                 serviceName,
                 SERVICE_TYPE_LABELS,
-                ipV4Address /* ipv4Address */,
-                ipV6Address /* ipv6Address */,
+                List.of(ipV4Address) /* ipv4Address */,
+                List.of(ipV6Address) /* ipv6Address */,
                 5354 /* port */,
                 Collections.singletonList(subtype) /* subTypes */,
                 Collections.singletonMap("key", "value") /* attributes */,
@@ -870,8 +873,8 @@
         verifyServiceInfo(serviceInfoCaptor.getAllValues().get(3),
                 serviceName,
                 SERVICE_TYPE_LABELS,
-                ipV4Address /* ipv4Address */,
-                ipV6Address /* ipv6Address */,
+                List.of(ipV4Address) /* ipv4Address */,
+                List.of(ipV6Address) /* ipv6Address */,
                 5354 /* port */,
                 Collections.singletonList("ABCDE") /* subTypes */,
                 Collections.singletonMap("key", "value") /* attributes */,
@@ -883,8 +886,8 @@
         verifyServiceInfo(serviceInfoCaptor.getAllValues().get(4),
                 serviceName,
                 SERVICE_TYPE_LABELS,
-                ipV4Address /* ipv4Address */,
-                ipV6Address /* ipv6Address */,
+                List.of(ipV4Address) /* ipv4Address */,
+                List.of(ipV6Address) /* ipv6Address */,
                 5354 /* port */,
                 Collections.singletonList("ABCDE") /* subTypes */,
                 Collections.singletonMap("key", "value") /* attributes */,
@@ -892,6 +895,102 @@
                 mockNetwork);
     }
 
+    @Test
+    public void testProcessResponse_Resolve() throws Exception {
+        client = new MdnsServiceTypeClient(SERVICE_TYPE, mockSocketClient, currentThreadExecutor);
+
+        final String instanceName = "service-instance";
+        final String[] hostname = new String[] { "testhost "};
+        final String ipV4Address = "192.0.2.0";
+        final String ipV6Address = "2001:db8::";
+
+        final MdnsSearchOptions resolveOptions = MdnsSearchOptions.newBuilder()
+                .setResolveInstanceName(instanceName).build();
+
+        client.startSendAndReceive(mockListenerOne, resolveOptions);
+        InOrder inOrder = inOrder(mockListenerOne, mockSocketClient);
+
+        // Verify a query for SRV/TXT was sent, but no PTR query
+        final ArgumentCaptor<DatagramPacket> srvTxtQueryCaptor =
+                ArgumentCaptor.forClass(DatagramPacket.class);
+        currentThreadExecutor.getAndClearLastScheduledRunnable().run();
+        // Send twice for IPv4 and IPv6
+        inOrder.verify(mockSocketClient, times(2)).sendUnicastPacket(srvTxtQueryCaptor.capture(),
+                eq(null) /* network */);
+
+        final MdnsPacket srvTxtQueryPacket = MdnsPacket.parse(
+                new MdnsPacketReader(srvTxtQueryCaptor.getValue()));
+        final List<MdnsRecord> srvTxtQuestions = srvTxtQueryPacket.questions;
+
+        final String[] serviceName = Stream.concat(Stream.of(instanceName),
+                Arrays.stream(SERVICE_TYPE_LABELS)).toArray(String[]::new);
+        assertFalse(srvTxtQuestions.stream().anyMatch(q -> q.getType() == MdnsRecord.TYPE_PTR));
+        assertTrue(srvTxtQuestions.stream().anyMatch(q ->
+                q.getType() == MdnsRecord.TYPE_SRV && Arrays.equals(q.name, serviceName)));
+        assertTrue(srvTxtQuestions.stream().anyMatch(q ->
+                q.getType() == MdnsRecord.TYPE_TXT && Arrays.equals(q.name, serviceName)));
+
+        // Process a response with SRV+TXT
+        final MdnsPacket srvTxtResponse = new MdnsPacket(
+                0 /* flags */,
+                Collections.emptyList() /* questions */,
+                List.of(
+                        new MdnsServiceRecord(serviceName, 0L /* receiptTimeMillis */,
+                                true /* cacheFlush */, TEST_TTL, 0 /* servicePriority */,
+                                0 /* serviceWeight */, 1234 /* servicePort */, hostname),
+                        new MdnsTextRecord(serviceName, 0L /* receiptTimeMillis */,
+                                true /* cacheFlush */, TEST_TTL,
+                                Collections.emptyList() /* entries */)),
+                Collections.emptyList() /* authorityRecords */,
+                Collections.emptyList() /* additionalRecords */);
+
+        client.processResponse(srvTxtResponse, INTERFACE_INDEX, mockNetwork);
+
+        // Expect a query for A/AAAA
+        final ArgumentCaptor<DatagramPacket> addressQueryCaptor =
+                ArgumentCaptor.forClass(DatagramPacket.class);
+        currentThreadExecutor.getAndClearLastScheduledRunnable().run();
+        inOrder.verify(mockSocketClient, times(2)).sendMulticastPacket(addressQueryCaptor.capture(),
+                eq(null) /* network */);
+
+        final MdnsPacket addressQueryPacket = MdnsPacket.parse(
+                new MdnsPacketReader(addressQueryCaptor.getValue()));
+        final List<MdnsRecord> addressQueryQuestions = addressQueryPacket.questions;
+        assertTrue(addressQueryQuestions.stream().anyMatch(q ->
+                q.getType() == MdnsRecord.TYPE_A && Arrays.equals(q.name, hostname)));
+        assertTrue(addressQueryQuestions.stream().anyMatch(q ->
+                q.getType() == MdnsRecord.TYPE_AAAA && Arrays.equals(q.name, hostname)));
+
+        // Process a response with address records
+        final MdnsPacket addressResponse = new MdnsPacket(
+                0 /* flags */,
+                Collections.emptyList() /* questions */,
+                List.of(
+                        new MdnsInetAddressRecord(hostname, 0L /* receiptTimeMillis */,
+                                true /* cacheFlush */, TEST_TTL,
+                                InetAddresses.parseNumericAddress(ipV4Address)),
+                        new MdnsInetAddressRecord(hostname, 0L /* receiptTimeMillis */,
+                                true /* cacheFlush */, TEST_TTL,
+                                InetAddresses.parseNumericAddress(ipV6Address))),
+                Collections.emptyList() /* authorityRecords */,
+                Collections.emptyList() /* additionalRecords */);
+
+        inOrder.verify(mockListenerOne, never()).onServiceNameDiscovered(any());
+        client.processResponse(addressResponse, INTERFACE_INDEX, mockNetwork);
+
+        inOrder.verify(mockListenerOne).onServiceFound(serviceInfoCaptor.capture());
+        verifyServiceInfo(serviceInfoCaptor.getValue(),
+                instanceName,
+                SERVICE_TYPE_LABELS,
+                List.of(ipV4Address),
+                List.of(ipV6Address),
+                1234 /* port */,
+                Collections.emptyList() /* subTypes */,
+                Collections.emptyMap() /* attributes */,
+                INTERFACE_INDEX,
+                mockNetwork);
+    }
+
     // verifies that the right query was enqueued with the right delay, and send query by executing
     // the runnable.
     private void verifyAndSendQuery(int index, long timeInMs, boolean expectsUnicastResponse) {
diff --git a/tools/gn2bp/Android.bp.swp b/tools/gn2bp/Android.bp.swp
index 0ff8284..d22a576 100644
--- a/tools/gn2bp/Android.bp.swp
+++ b/tools/gn2bp/Android.bp.swp
@@ -292,7 +292,6 @@
 cc_library_static {
     name: "cronet_aml_base_allocator_partition_allocator_partition_alloc",
     srcs: [
-        ":cronet_aml_third_party_android_ndk_cpu_features",
         "base/allocator/partition_allocator/address_pool_manager.cc",
         "base/allocator/partition_allocator/address_pool_manager_bitmap.cc",
         "base/allocator/partition_allocator/address_space_randomization.cc",
@@ -346,6 +345,9 @@
         "base/allocator/partition_allocator/tagging.cc",
         "base/allocator/partition_allocator/thread_cache.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_android_ndk_cpu_features",
+    ],
     generated_headers: [
         "cronet_aml_base_allocator_partition_allocator_chromecast_buildflags",
         "cronet_aml_base_allocator_partition_allocator_chromeos_buildflags",
@@ -557,13 +559,15 @@
     target: {
         android_arm: {
             srcs: [
-                ":cronet_aml_third_party_android_ndk_cpu_features__testing",
                 "base/allocator/partition_allocator/partition_alloc_base/files/file_path.cc",
                 "base/allocator/partition_allocator/partition_alloc_base/native_library.cc",
                 "base/allocator/partition_allocator/partition_alloc_base/native_library_posix.cc",
                 "base/allocator/partition_allocator/partition_alloc_base/time/time_android.cc",
                 "base/allocator/partition_allocator/starscan/stack/asm/arm/push_registers_asm.cc",
             ],
+            static_libs: [
+                "cronet_aml_third_party_android_ndk_cpu_features__testing",
+            ],
             cflags: [
                 "-DANDROID",
                 "-DANDROID_NDK_VERSION_ROLL=r23_1",
@@ -576,13 +580,15 @@
         },
         android_arm64: {
             srcs: [
-                ":cronet_aml_third_party_android_ndk_cpu_features__testing",
                 "base/allocator/partition_allocator/partition_alloc_base/files/file_path.cc",
                 "base/allocator/partition_allocator/partition_alloc_base/native_library.cc",
                 "base/allocator/partition_allocator/partition_alloc_base/native_library_posix.cc",
                 "base/allocator/partition_allocator/partition_alloc_base/time/time_android.cc",
                 "base/allocator/partition_allocator/starscan/stack/asm/arm64/push_registers_asm.cc",
             ],
+            static_libs: [
+                "cronet_aml_third_party_android_ndk_cpu_features__testing",
+            ],
             cflags: [
                 "-DANDROID",
                 "-DANDROID_NDK_VERSION_ROLL=r23_1",
@@ -598,13 +604,15 @@
         },
         android_x86: {
             srcs: [
-                ":cronet_aml_third_party_android_ndk_cpu_features__testing",
                 "base/allocator/partition_allocator/partition_alloc_base/files/file_path.cc",
                 "base/allocator/partition_allocator/partition_alloc_base/native_library.cc",
                 "base/allocator/partition_allocator/partition_alloc_base/native_library_posix.cc",
                 "base/allocator/partition_allocator/partition_alloc_base/time/time_android.cc",
                 "base/allocator/partition_allocator/starscan/stack/asm/x86/push_registers_asm.cc",
             ],
+            static_libs: [
+                "cronet_aml_third_party_android_ndk_cpu_features__testing",
+            ],
             cflags: [
                 "-DANDROID",
                 "-DANDROID_NDK_VERSION_ROLL=r23_1",
@@ -617,13 +625,15 @@
         },
         android_x86_64: {
             srcs: [
-                ":cronet_aml_third_party_android_ndk_cpu_features__testing",
                 "base/allocator/partition_allocator/partition_alloc_base/files/file_path.cc",
                 "base/allocator/partition_allocator/partition_alloc_base/native_library.cc",
                 "base/allocator/partition_allocator/partition_alloc_base/native_library_posix.cc",
                 "base/allocator/partition_allocator/partition_alloc_base/time/time_android.cc",
                 "base/allocator/partition_allocator/starscan/stack/asm/x64/push_registers_asm.cc",
             ],
+            static_libs: [
+                "cronet_aml_third_party_android_ndk_cpu_features__testing",
+            ],
             cflags: [
                 "-DANDROID",
                 "-DANDROID_NDK_VERSION_ROLL=r23_1",
@@ -933,56 +943,6 @@
 cc_library_static {
     name: "cronet_aml_base_base",
     srcs: [
-        ":cronet_aml_base_nodebug_assertion",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_base",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_strerror",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
-        ":cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler",
-        ":cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set",
-        ":cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
-        ":cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
-        ":cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack",
-        ":cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler",
-        ":cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
-        ":cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
-        ":cronet_aml_third_party_abseil_cpp_absl_hash_city",
-        ":cronet_aml_third_party_abseil_cpp_absl_hash_hash",
-        ":cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash",
-        ":cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
-        ":cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_distributions",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_randen",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences",
-        ":cronet_aml_third_party_abseil_cpp_absl_status_status",
-        ":cronet_aml_third_party_abseil_cpp_absl_status_statusor",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_cord",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_internal",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_strings",
-        ":cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
-        ":cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
-        ":cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
-        ":cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
-        ":cronet_aml_third_party_abseil_cpp_absl_time_time",
-        ":cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
-        ":cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access",
-        ":cronet_aml_third_party_android_ndk_cpu_features",
-        ":cronet_aml_third_party_ashmem_ashmem",
         "base/allocator/allocator_check.cc",
         "base/allocator/allocator_extension.cc",
         "base/allocator/dispatcher/dispatcher.cc",
@@ -1424,9 +1384,60 @@
     static_libs: [
         "cronet_aml_base_allocator_partition_allocator_partition_alloc",
         "cronet_aml_base_base_static",
+        "cronet_aml_base_nodebug_assertion",
         "cronet_aml_base_third_party_double_conversion_double_conversion",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access",
+        "cronet_aml_third_party_android_ndk_cpu_features",
+        "cronet_aml_third_party_ashmem_ashmem",
         "cronet_aml_third_party_boringssl_boringssl",
+        "cronet_aml_third_party_boringssl_boringssl_asm",
         "cronet_aml_third_party_icu_icui18n",
         "cronet_aml_third_party_icu_icuuc_private",
         "cronet_aml_third_party_libevent_libevent",
@@ -1605,54 +1616,6 @@
 cc_library_static {
     name: "cronet_aml_base_base__testing",
     srcs: [
-        ":cronet_aml_base_nodebug_assertion__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_strerror__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_hash_city__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_hash_hash__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_distributions__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_randen__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_status_status__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_status_statusor__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_cord__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access__testing",
         "base/allocator/allocator_check.cc",
         "base/allocator/allocator_extension.cc",
         "base/allocator/dispatcher/dispatcher.cc",
@@ -2020,9 +1983,58 @@
     static_libs: [
         "cronet_aml_base_allocator_partition_allocator_partition_alloc__testing",
         "cronet_aml_base_base_static__testing",
+        "cronet_aml_base_nodebug_assertion__testing",
         "cronet_aml_base_third_party_double_conversion_double_conversion__testing",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access__testing",
         "cronet_aml_third_party_boringssl_boringssl__testing",
+        "cronet_aml_third_party_boringssl_boringssl_asm__testing",
         "cronet_aml_third_party_icu_icui18n__testing",
         "cronet_aml_third_party_icu_icuuc_private__testing",
         "cronet_aml_third_party_libevent_libevent__testing",
@@ -2134,8 +2146,6 @@
         },
         android_arm: {
             srcs: [
-                ":cronet_aml_third_party_android_ndk_cpu_features__testing",
-                ":cronet_aml_third_party_ashmem_ashmem__testing",
                 "base/allocator/partition_allocator/shim/allocator_shim_default_dispatch_to_linker_wrapped_symbols.cc",
                 "base/android/android_hardware_buffer_compat.cc",
                 "base/android/android_image_reader_compat.cc",
@@ -2212,6 +2222,10 @@
                 "base/time/time_android.cc",
                 "base/trace_event/cfi_backtrace_android.cc",
             ],
+            static_libs: [
+                "cronet_aml_third_party_android_ndk_cpu_features__testing",
+                "cronet_aml_third_party_ashmem_ashmem__testing",
+            ],
             cflags: [
                 "-DANDROID",
                 "-DANDROID_NDK_VERSION_ROLL=r23_1",
@@ -2228,13 +2242,6 @@
                 "cronet_aml_base_logging_buildflags__testing",
                 "cronet_aml_build_chromeos_buildflags__testing",
             ],
-            export_generated_headers: [
-                "cronet_aml_base_android_runtime_jni_headers__testing",
-                "cronet_aml_base_base_jni_headers__testing",
-                "cronet_aml_base_debugging_buildflags__testing",
-                "cronet_aml_base_logging_buildflags__testing",
-                "cronet_aml_build_chromeos_buildflags__testing",
-            ],
             ldflags: [
                 "-Wl,-wrap,asprintf",
                 "-Wl,-wrap,calloc",
@@ -2255,8 +2262,6 @@
         },
         android_arm64: {
             srcs: [
-                ":cronet_aml_third_party_android_ndk_cpu_features__testing",
-                ":cronet_aml_third_party_ashmem_ashmem__testing",
                 "base/allocator/partition_allocator/shim/allocator_shim_default_dispatch_to_linker_wrapped_symbols.cc",
                 "base/android/android_hardware_buffer_compat.cc",
                 "base/android/android_image_reader_compat.cc",
@@ -2329,6 +2334,10 @@
                 "base/threading/platform_thread_android.cc",
                 "base/time/time_android.cc",
             ],
+            static_libs: [
+                "cronet_aml_third_party_android_ndk_cpu_features__testing",
+                "cronet_aml_third_party_ashmem_ashmem__testing",
+            ],
             cflags: [
                 "-DANDROID",
                 "-DANDROID_NDK_VERSION_ROLL=r23_1",
@@ -2347,13 +2356,6 @@
                 "cronet_aml_base_logging_buildflags__testing",
                 "cronet_aml_build_chromeos_buildflags__testing",
             ],
-            export_generated_headers: [
-                "cronet_aml_base_android_runtime_jni_headers__testing",
-                "cronet_aml_base_base_jni_headers__testing",
-                "cronet_aml_base_debugging_buildflags__testing",
-                "cronet_aml_base_logging_buildflags__testing",
-                "cronet_aml_build_chromeos_buildflags__testing",
-            ],
             ldflags: [
                 "-Wl,-wrap,asprintf",
                 "-Wl,-wrap,calloc",
@@ -2374,8 +2376,6 @@
         },
         android_x86: {
             srcs: [
-                ":cronet_aml_third_party_android_ndk_cpu_features__testing",
-                ":cronet_aml_third_party_ashmem_ashmem__testing",
                 "base/allocator/partition_allocator/shim/allocator_shim_default_dispatch_to_linker_wrapped_symbols.cc",
                 "base/android/android_hardware_buffer_compat.cc",
                 "base/android/android_image_reader_compat.cc",
@@ -2448,6 +2448,10 @@
                 "base/threading/platform_thread_android.cc",
                 "base/time/time_android.cc",
             ],
+            static_libs: [
+                "cronet_aml_third_party_android_ndk_cpu_features__testing",
+                "cronet_aml_third_party_ashmem_ashmem__testing",
+            ],
             cflags: [
                 "-DANDROID",
                 "-DANDROID_NDK_VERSION_ROLL=r23_1",
@@ -2464,13 +2468,6 @@
                 "cronet_aml_base_logging_buildflags__testing",
                 "cronet_aml_build_chromeos_buildflags__testing",
             ],
-            export_generated_headers: [
-                "cronet_aml_base_android_runtime_jni_headers__testing",
-                "cronet_aml_base_base_jni_headers__testing",
-                "cronet_aml_base_debugging_buildflags__testing",
-                "cronet_aml_base_logging_buildflags__testing",
-                "cronet_aml_build_chromeos_buildflags__testing",
-            ],
             ldflags: [
                 "-Wl,-wrap,asprintf",
                 "-Wl,-wrap,calloc",
@@ -2491,8 +2488,6 @@
         },
         android_x86_64: {
             srcs: [
-                ":cronet_aml_third_party_android_ndk_cpu_features__testing",
-                ":cronet_aml_third_party_ashmem_ashmem__testing",
                 "base/allocator/partition_allocator/shim/allocator_shim_default_dispatch_to_linker_wrapped_symbols.cc",
                 "base/android/android_hardware_buffer_compat.cc",
                 "base/android/android_image_reader_compat.cc",
@@ -2565,6 +2560,10 @@
                 "base/threading/platform_thread_android.cc",
                 "base/time/time_android.cc",
             ],
+            static_libs: [
+                "cronet_aml_third_party_android_ndk_cpu_features__testing",
+                "cronet_aml_third_party_ashmem_ashmem__testing",
+            ],
             cflags: [
                 "-DANDROID",
                 "-DANDROID_NDK_VERSION_ROLL=r23_1",
@@ -2582,13 +2581,6 @@
                 "cronet_aml_base_logging_buildflags__testing",
                 "cronet_aml_build_chromeos_buildflags__testing",
             ],
-            export_generated_headers: [
-                "cronet_aml_base_android_runtime_jni_headers__testing",
-                "cronet_aml_base_base_jni_headers__testing",
-                "cronet_aml_base_debugging_buildflags__testing",
-                "cronet_aml_base_logging_buildflags__testing",
-                "cronet_aml_build_chromeos_buildflags__testing",
-            ],
             ldflags: [
                 "-Wl,-wrap,asprintf",
                 "-Wl,-wrap,calloc",
@@ -3743,9 +3735,60 @@
         "cronet_aml_base_allocator_partition_allocator_partition_alloc__testing",
         "cronet_aml_base_base__testing",
         "cronet_aml_base_base_static__testing",
+        "cronet_aml_base_nodebug_assertion__testing",
         "cronet_aml_base_third_party_double_conversion_double_conversion__testing",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access__testing",
+        "cronet_aml_third_party_android_ndk_cpu_features__testing",
+        "cronet_aml_third_party_ashmem_ashmem__testing",
         "cronet_aml_third_party_boringssl_boringssl__testing",
+        "cronet_aml_third_party_boringssl_boringssl_asm__testing",
         "cronet_aml_third_party_ced_ced__testing",
         "cronet_aml_third_party_icu_icui18n__testing",
         "cronet_aml_third_party_icu_icuuc_private__testing",
@@ -4051,7 +4094,7 @@
 }
 
 // GN: //base:nodebug_assertion
-cc_object {
+cc_library_static {
     name: "cronet_aml_base_nodebug_assertion",
     srcs: [
         "base/nodebug_assertion.cc",
@@ -4096,6 +4139,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -4124,7 +4172,7 @@
 }
 
 // GN: //base:nodebug_assertion__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_base_nodebug_assertion__testing",
     srcs: [
         "base/nodebug_assertion.cc",
@@ -4165,6 +4213,11 @@
         "buildtools/third_party/libc++/trunk/include",
         "buildtools/third_party/libc++abi/trunk/include",
     ],
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -4648,9 +4701,60 @@
         "cronet_aml_base_allocator_partition_allocator_partition_alloc__testing",
         "cronet_aml_base_base__testing",
         "cronet_aml_base_base_static__testing",
+        "cronet_aml_base_nodebug_assertion__testing",
         "cronet_aml_base_third_party_double_conversion_double_conversion__testing",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access__testing",
+        "cronet_aml_third_party_android_ndk_cpu_features__testing",
+        "cronet_aml_third_party_ashmem_ashmem__testing",
         "cronet_aml_third_party_boringssl_boringssl__testing",
+        "cronet_aml_third_party_boringssl_boringssl_asm__testing",
         "cronet_aml_third_party_icu_icui18n__testing",
         "cronet_aml_third_party_icu_icuuc_private__testing",
         "cronet_aml_third_party_libevent_libevent__testing",
@@ -4754,55 +4858,6 @@
 cc_library_static {
     name: "cronet_aml_base_test_test_support__testing",
     srcs: [
-        ":cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_strerror__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_hash_city__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_hash_hash__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_distributions__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_randen__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_status_status__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_status_statusor__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_cord__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access__testing",
-        ":cronet_aml_third_party_googletest_gmock__testing",
-        ":cronet_aml_third_party_googletest_gtest__testing",
         "base/task/sequence_manager/test/fake_task.cc",
         "base/task/sequence_manager/test/mock_time_domain.cc",
         "base/task/sequence_manager/test/mock_time_message_pump.cc",
@@ -4880,12 +4935,65 @@
         "cronet_aml_base_base__testing",
         "cronet_aml_base_base_static__testing",
         "cronet_aml_base_i18n__testing",
+        "cronet_aml_base_nodebug_assertion__testing",
         "cronet_aml_base_test_test_config__testing",
         "cronet_aml_base_third_party_double_conversion_double_conversion__testing",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations__testing",
         "cronet_aml_testing_gtest_gtest__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access__testing",
+        "cronet_aml_third_party_android_ndk_cpu_features__testing",
+        "cronet_aml_third_party_ashmem_ashmem__testing",
         "cronet_aml_third_party_boringssl_boringssl__testing",
+        "cronet_aml_third_party_boringssl_boringssl_asm__testing",
         "cronet_aml_third_party_ced_ced__testing",
+        "cronet_aml_third_party_googletest_gmock__testing",
+        "cronet_aml_third_party_googletest_gtest__testing",
         "cronet_aml_third_party_icu_icui18n__testing",
         "cronet_aml_third_party_icu_icuuc_private__testing",
         "cronet_aml_third_party_libevent_libevent__testing",
@@ -5823,7 +5931,7 @@
 }
 
 // GN: //buildtools/third_party/libc++:libc++
-cc_object {
+cc_library_static {
     name: "cronet_aml_buildtools_third_party_libc___libc__",
     srcs: [
         "buildtools/third_party/libc++/trunk/src/algorithm.cpp",
@@ -5869,6 +5977,9 @@
         "buildtools/third_party/libc++/trunk/src/vector.cpp",
         "buildtools/third_party/libc++/trunk/src/verbose_abort.cpp",
     ],
+    static_libs: [
+        "cronet_aml_buildtools_third_party_libc__abi_libc__abi",
+    ],
     host_supported: true,
     defaults: [
         "cronet_aml_defaults",
@@ -5904,6 +6015,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
     ],
     cpp_std: "c++20",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     cppflags: [
         "-fexceptions",
     ],
@@ -5967,7 +6083,7 @@
 }
 
 // GN: //buildtools/third_party/libc++:libc++__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_buildtools_third_party_libc___libc____testing",
     srcs: [
         "buildtools/third_party/libc++/trunk/src/algorithm.cpp",
@@ -6013,6 +6129,9 @@
         "buildtools/third_party/libc++/trunk/src/vector.cpp",
         "buildtools/third_party/libc++/trunk/src/verbose_abort.cpp",
     ],
+    static_libs: [
+        "cronet_aml_buildtools_third_party_libc__abi_libc__abi__testing",
+    ],
     host_supported: true,
     defaults: [
         "cronet_aml_defaults",
@@ -6048,6 +6167,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
     ],
     cpp_std: "c++20",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     cppflags: [
         "-fexceptions",
     ],
@@ -6111,7 +6235,7 @@
 }
 
 // GN: //buildtools/third_party/libc++abi:libc++abi
-cc_object {
+cc_library_static {
     name: "cronet_aml_buildtools_third_party_libc__abi_libc__abi",
     srcs: [
         "buildtools/third_party/libc++abi/trunk/src/abort_message.cpp",
@@ -6165,6 +6289,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
     ],
     cpp_std: "c++20",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     cppflags: [
         "-fexceptions",
     ],
@@ -6243,7 +6372,7 @@
 }
 
 // GN: //buildtools/third_party/libc++abi:libc++abi__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_buildtools_third_party_libc__abi_libc__abi__testing",
     srcs: [
         "buildtools/third_party/libc++abi/trunk/src/abort_message.cpp",
@@ -6297,6 +6426,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
     ],
     cpp_std: "c++20",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     cppflags: [
         "-fexceptions",
     ],
@@ -6424,12 +6558,6 @@
 cc_library_shared {
     name: "cronet_aml_components_cronet_android_cronet",
     srcs: [
-        ":cronet_aml_buildtools_third_party_libc___libc__",
-        ":cronet_aml_buildtools_third_party_libc__abi_libc__abi",
-        ":cronet_aml_components_cronet_android_cronet_static",
-        ":cronet_aml_components_cronet_cronet_common",
-        ":cronet_aml_components_cronet_metrics_util",
-        ":cronet_aml_components_metrics_library_support",
         "components/cronet/android/cronet_jni.cc",
     ],
     shared_libs: [
@@ -6441,15 +6569,79 @@
         "cronet_aml_base_allocator_partition_allocator_partition_alloc",
         "cronet_aml_base_base",
         "cronet_aml_base_base_static",
+        "cronet_aml_base_nodebug_assertion",
         "cronet_aml_base_third_party_double_conversion_double_conversion",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations",
+        "cronet_aml_buildtools_third_party_libc___libc__",
+        "cronet_aml_buildtools_third_party_libc__abi_libc__abi",
+        "cronet_aml_components_cronet_android_cronet_static",
+        "cronet_aml_components_cronet_cronet_common",
+        "cronet_aml_components_cronet_cronet_version_header",
+        "cronet_aml_components_cronet_metrics_util",
+        "cronet_aml_components_metrics_library_support",
         "cronet_aml_components_prefs_prefs",
         "cronet_aml_crypto_crypto",
+        "cronet_aml_net_dns_dns",
+        "cronet_aml_net_dns_public_public",
+        "cronet_aml_net_http_transport_security_state_generated_files",
         "cronet_aml_net_net",
+        "cronet_aml_net_net_deps",
+        "cronet_aml_net_net_public_deps",
         "cronet_aml_net_preload_decoder",
         "cronet_aml_net_third_party_quiche_quiche",
+        "cronet_aml_net_traffic_annotation_traffic_annotation",
         "cronet_aml_net_uri_template",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access",
+        "cronet_aml_third_party_android_ndk_cpu_features",
+        "cronet_aml_third_party_ashmem_ashmem",
         "cronet_aml_third_party_boringssl_boringssl",
+        "cronet_aml_third_party_boringssl_boringssl_asm",
         "cronet_aml_third_party_brotli_common",
         "cronet_aml_third_party_brotli_dec",
         "cronet_aml_third_party_icu_icui18n",
@@ -6459,30 +6651,6 @@
         "cronet_aml_third_party_protobuf_protobuf_lite",
         "cronet_aml_url_url",
     ],
-    generated_headers: [
-        "cronet_aml_base_debugging_buildflags",
-        "cronet_aml_base_logging_buildflags",
-        "cronet_aml_build_chromeos_buildflags",
-        "cronet_aml_components_cronet_android_buildflags",
-        "cronet_aml_components_cronet_android_cronet_jni_headers",
-        "cronet_aml_components_cronet_android_cronet_jni_registration",
-        "cronet_aml_components_cronet_cronet_buildflags",
-        "cronet_aml_components_cronet_cronet_version_header_action",
-        "cronet_aml_third_party_metrics_proto_metrics_proto_gen_headers",
-        "cronet_aml_url_buildflags",
-    ],
-    export_generated_headers: [
-        "cronet_aml_base_debugging_buildflags",
-        "cronet_aml_base_logging_buildflags",
-        "cronet_aml_build_chromeos_buildflags",
-        "cronet_aml_components_cronet_android_buildflags",
-        "cronet_aml_components_cronet_android_cronet_jni_headers",
-        "cronet_aml_components_cronet_android_cronet_jni_registration",
-        "cronet_aml_components_cronet_cronet_buildflags",
-        "cronet_aml_components_cronet_cronet_version_header_action",
-        "cronet_aml_third_party_metrics_proto_metrics_proto_gen_headers",
-        "cronet_aml_url_buildflags",
-    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -7693,7 +7861,7 @@
 }
 
 // GN: //components/cronet/android:cronet_static
-cc_object {
+cc_library_static {
     name: "cronet_aml_components_cronet_android_cronet_static",
     srcs: [
         "components/cronet/android/cronet_bidirectional_stream_adapter.cc",
@@ -7713,15 +7881,76 @@
         "cronet_aml_base_allocator_partition_allocator_partition_alloc",
         "cronet_aml_base_base",
         "cronet_aml_base_base_static",
+        "cronet_aml_base_nodebug_assertion",
         "cronet_aml_base_third_party_double_conversion_double_conversion",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations",
+        "cronet_aml_components_cronet_cronet_common",
+        "cronet_aml_components_cronet_cronet_version_header",
+        "cronet_aml_components_cronet_metrics_util",
+        "cronet_aml_components_metrics_library_support",
         "cronet_aml_components_prefs_prefs",
         "cronet_aml_crypto_crypto",
+        "cronet_aml_net_dns_dns",
+        "cronet_aml_net_dns_public_public",
+        "cronet_aml_net_http_transport_security_state_generated_files",
         "cronet_aml_net_net",
+        "cronet_aml_net_net_deps",
+        "cronet_aml_net_net_public_deps",
         "cronet_aml_net_preload_decoder",
         "cronet_aml_net_third_party_quiche_quiche",
+        "cronet_aml_net_traffic_annotation_traffic_annotation",
         "cronet_aml_net_uri_template",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access",
+        "cronet_aml_third_party_android_ndk_cpu_features",
+        "cronet_aml_third_party_ashmem_ashmem",
         "cronet_aml_third_party_boringssl_boringssl",
+        "cronet_aml_third_party_boringssl_boringssl_asm",
         "cronet_aml_third_party_brotli_common",
         "cronet_aml_third_party_brotli_dec",
         "cronet_aml_third_party_icu_icui18n",
@@ -7738,9 +7967,15 @@
         "cronet_aml_components_cronet_android_buildflags",
         "cronet_aml_components_cronet_android_cronet_jni_headers",
         "cronet_aml_components_cronet_android_cronet_jni_registration",
-        "cronet_aml_components_cronet_cronet_buildflags",
-        "cronet_aml_components_cronet_cronet_version_header_action",
-        "cronet_aml_third_party_metrics_proto_metrics_proto_gen_headers",
+        "cronet_aml_url_buildflags",
+    ],
+    export_generated_headers: [
+        "cronet_aml_base_debugging_buildflags",
+        "cronet_aml_base_logging_buildflags",
+        "cronet_aml_build_chromeos_buildflags",
+        "cronet_aml_components_cronet_android_buildflags",
+        "cronet_aml_components_cronet_android_cronet_jni_headers",
+        "cronet_aml_components_cronet_android_cronet_jni_registration",
         "cronet_aml_url_buildflags",
     ],
     defaults: [
@@ -7789,6 +8024,27 @@
         "third_party/protobuf/src/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+        "-Wl,--script,external/cronet/base/android/library_loader/anchor_functions.lds",
+        "-Wl,-wrap,asprintf",
+        "-Wl,-wrap,calloc",
+        "-Wl,-wrap,free",
+        "-Wl,-wrap,getcwd",
+        "-Wl,-wrap,malloc",
+        "-Wl,-wrap,malloc_usable_size",
+        "-Wl,-wrap,memalign",
+        "-Wl,-wrap,posix_memalign",
+        "-Wl,-wrap,pvalloc",
+        "-Wl,-wrap,realloc",
+        "-Wl,-wrap,realpath",
+        "-Wl,-wrap,strdup",
+        "-Wl,-wrap,strndup",
+        "-Wl,-wrap,valloc",
+        "-Wl,-wrap,vasprintf",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -7817,7 +8073,7 @@
 }
 
 // GN: //components/cronet/android:cronet_static__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_components_cronet_android_cronet_static__testing",
     srcs: [
         "components/cronet/android/cronet_bidirectional_stream_adapter.cc",
@@ -7837,15 +8093,76 @@
         "cronet_aml_base_allocator_partition_allocator_partition_alloc__testing",
         "cronet_aml_base_base__testing",
         "cronet_aml_base_base_static__testing",
+        "cronet_aml_base_nodebug_assertion__testing",
         "cronet_aml_base_third_party_double_conversion_double_conversion__testing",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations__testing",
+        "cronet_aml_components_cronet_cronet_common__testing",
+        "cronet_aml_components_cronet_cronet_version_header__testing",
+        "cronet_aml_components_cronet_metrics_util__testing",
+        "cronet_aml_components_metrics_library_support__testing",
         "cronet_aml_components_prefs_prefs__testing",
         "cronet_aml_crypto_crypto__testing",
+        "cronet_aml_net_dns_dns__testing",
+        "cronet_aml_net_dns_public_public__testing",
+        "cronet_aml_net_http_transport_security_state_generated_files__testing",
         "cronet_aml_net_net__testing",
+        "cronet_aml_net_net_deps__testing",
+        "cronet_aml_net_net_public_deps__testing",
         "cronet_aml_net_preload_decoder__testing",
         "cronet_aml_net_third_party_quiche_quiche__testing",
+        "cronet_aml_net_traffic_annotation_traffic_annotation__testing",
         "cronet_aml_net_uri_template__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access__testing",
+        "cronet_aml_third_party_android_ndk_cpu_features__testing",
+        "cronet_aml_third_party_ashmem_ashmem__testing",
         "cronet_aml_third_party_boringssl_boringssl__testing",
+        "cronet_aml_third_party_boringssl_boringssl_asm__testing",
         "cronet_aml_third_party_brotli_common__testing",
         "cronet_aml_third_party_brotli_dec__testing",
         "cronet_aml_third_party_icu_icui18n__testing",
@@ -7862,9 +8179,15 @@
         "cronet_aml_components_cronet_android_buildflags__testing",
         "cronet_aml_components_cronet_android_cronet_jni_headers__testing",
         "cronet_aml_components_cronet_android_cronet_jni_registration__testing",
-        "cronet_aml_components_cronet_cronet_buildflags__testing",
-        "cronet_aml_components_cronet_cronet_version_header_action__testing",
-        "cronet_aml_third_party_metrics_proto_metrics_proto__testing_gen_headers",
+        "cronet_aml_url_buildflags__testing",
+    ],
+    export_generated_headers: [
+        "cronet_aml_base_debugging_buildflags__testing",
+        "cronet_aml_base_logging_buildflags__testing",
+        "cronet_aml_build_chromeos_buildflags__testing",
+        "cronet_aml_components_cronet_android_buildflags__testing",
+        "cronet_aml_components_cronet_android_cronet_jni_headers__testing",
+        "cronet_aml_components_cronet_android_cronet_jni_registration__testing",
         "cronet_aml_url_buildflags__testing",
     ],
     defaults: [
@@ -7913,6 +8236,27 @@
         "third_party/protobuf/src/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+        "-Wl,--script,external/cronet/base/android/library_loader/anchor_functions.lds",
+        "-Wl,-wrap,asprintf",
+        "-Wl,-wrap,calloc",
+        "-Wl,-wrap,free",
+        "-Wl,-wrap,getcwd",
+        "-Wl,-wrap,malloc",
+        "-Wl,-wrap,malloc_usable_size",
+        "-Wl,-wrap,memalign",
+        "-Wl,-wrap,posix_memalign",
+        "-Wl,-wrap,pvalloc",
+        "-Wl,-wrap,realloc",
+        "-Wl,-wrap,realpath",
+        "-Wl,-wrap,strdup",
+        "-Wl,-wrap,strndup",
+        "-Wl,-wrap,valloc",
+        "-Wl,-wrap,vasprintf",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -7944,15 +8288,6 @@
 cc_library_shared {
     name: "cronet_aml_components_cronet_android_cronet_unittests_android__library__testing",
     srcs: [
-        ":cronet_aml_buildtools_third_party_libc___libc____testing",
-        ":cronet_aml_buildtools_third_party_libc__abi_libc__abi__testing",
-        ":cronet_aml_components_cronet_android_cronet_static__testing",
-        ":cronet_aml_components_cronet_cronet_common__testing",
-        ":cronet_aml_components_cronet_cronet_common_unittests__testing",
-        ":cronet_aml_components_cronet_metrics_util__testing",
-        ":cronet_aml_components_metrics_library_support__testing",
-        ":cronet_aml_testing_android_native_test_native_test_native_code__testing",
-        ":cronet_aml_testing_android_native_test_native_test_support__testing",
         "components/cronet/run_all_unittests.cc",
     ],
     shared_libs: [
@@ -7965,25 +8300,98 @@
         "cronet_aml_base_base__testing",
         "cronet_aml_base_base_static__testing",
         "cronet_aml_base_i18n__testing",
+        "cronet_aml_base_nodebug_assertion__testing",
         "cronet_aml_base_test_test_config__testing",
         "cronet_aml_base_test_test_support__testing",
         "cronet_aml_base_third_party_double_conversion_double_conversion__testing",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations__testing",
+        "cronet_aml_buildtools_third_party_libc___libc____testing",
+        "cronet_aml_buildtools_third_party_libc__abi_libc__abi__testing",
+        "cronet_aml_components_cronet_android_cronet_static__testing",
+        "cronet_aml_components_cronet_cronet_common__testing",
+        "cronet_aml_components_cronet_cronet_common_unittests__testing",
+        "cronet_aml_components_cronet_cronet_version_header__testing",
+        "cronet_aml_components_cronet_metrics_util__testing",
+        "cronet_aml_components_metrics_library_support__testing",
         "cronet_aml_components_prefs_prefs__testing",
         "cronet_aml_components_prefs_test_support__testing",
         "cronet_aml_crypto_crypto__testing",
+        "cronet_aml_net_dns_dns__testing",
+        "cronet_aml_net_dns_public_public__testing",
+        "cronet_aml_net_dns_test_support__testing",
         "cronet_aml_net_gtest_util__testing",
+        "cronet_aml_net_http_transport_security_state_generated_files__testing",
         "cronet_aml_net_net__testing",
+        "cronet_aml_net_net_deps__testing",
+        "cronet_aml_net_net_public_deps__testing",
         "cronet_aml_net_preload_decoder__testing",
+        "cronet_aml_net_quic_test_flags_utils__testing",
+        "cronet_aml_net_simple_quic_tools__testing",
         "cronet_aml_net_test_support__testing",
         "cronet_aml_net_third_party_quiche_quiche__testing",
         "cronet_aml_net_third_party_quiche_quiche_tool_support__testing",
+        "cronet_aml_net_tools_tld_cleanup_tld_cleanup__testing",
+        "cronet_aml_net_traffic_annotation_traffic_annotation__testing",
         "cronet_aml_net_uri_template__testing",
+        "cronet_aml_testing_android_native_test_native_test_native_code__testing",
+        "cronet_aml_testing_android_native_test_native_test_support__testing",
         "cronet_aml_testing_gtest_gtest__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access__testing",
+        "cronet_aml_third_party_android_ndk_cpu_features__testing",
+        "cronet_aml_third_party_ashmem_ashmem__testing",
         "cronet_aml_third_party_boringssl_boringssl__testing",
+        "cronet_aml_third_party_boringssl_boringssl_asm__testing",
         "cronet_aml_third_party_brotli_common__testing",
         "cronet_aml_third_party_brotli_dec__testing",
         "cronet_aml_third_party_ced_ced__testing",
+        "cronet_aml_third_party_googletest_gmock__testing",
+        "cronet_aml_third_party_googletest_gtest__testing",
         "cronet_aml_third_party_icu_icui18n__testing",
         "cronet_aml_third_party_icu_icuuc_private__testing",
         "cronet_aml_third_party_libevent_libevent__testing",
@@ -7994,32 +8402,6 @@
         "cronet_aml_third_party_protobuf_protobuf_lite__testing",
         "cronet_aml_url_url__testing",
     ],
-    generated_headers: [
-        "cronet_aml_base_debugging_buildflags__testing",
-        "cronet_aml_base_logging_buildflags__testing",
-        "cronet_aml_build_chromeos_buildflags__testing",
-        "cronet_aml_components_cronet_android_buildflags__testing",
-        "cronet_aml_components_cronet_android_cronet_jni_headers__testing",
-        "cronet_aml_components_cronet_android_cronet_jni_registration__testing",
-        "cronet_aml_components_cronet_cronet_buildflags__testing",
-        "cronet_aml_components_cronet_cronet_version_header_action__testing",
-        "cronet_aml_testing_android_native_test_native_test_jni_headers__testing",
-        "cronet_aml_third_party_metrics_proto_metrics_proto__testing_gen_headers",
-        "cronet_aml_url_buildflags__testing",
-    ],
-    export_generated_headers: [
-        "cronet_aml_base_debugging_buildflags__testing",
-        "cronet_aml_base_logging_buildflags__testing",
-        "cronet_aml_build_chromeos_buildflags__testing",
-        "cronet_aml_components_cronet_android_buildflags__testing",
-        "cronet_aml_components_cronet_android_cronet_jni_headers__testing",
-        "cronet_aml_components_cronet_android_cronet_jni_registration__testing",
-        "cronet_aml_components_cronet_cronet_buildflags__testing",
-        "cronet_aml_components_cronet_cronet_version_header_action__testing",
-        "cronet_aml_testing_android_native_test_native_test_jni_headers__testing",
-        "cronet_aml_third_party_metrics_proto_metrics_proto__testing_gen_headers",
-        "cronet_aml_url_buildflags__testing",
-    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -8430,7 +8812,7 @@
 }
 
 // GN: //components/cronet:cronet_common
-cc_object {
+cc_library_static {
     name: "cronet_aml_components_cronet_cronet_common",
     srcs: [
         "components/cronet/cronet_context.cc",
@@ -8450,15 +8832,74 @@
         "cronet_aml_base_allocator_partition_allocator_partition_alloc",
         "cronet_aml_base_base",
         "cronet_aml_base_base_static",
+        "cronet_aml_base_nodebug_assertion",
         "cronet_aml_base_third_party_double_conversion_double_conversion",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations",
+        "cronet_aml_components_cronet_cronet_version_header",
+        "cronet_aml_components_metrics_library_support",
         "cronet_aml_components_prefs_prefs",
         "cronet_aml_crypto_crypto",
+        "cronet_aml_net_dns_dns",
+        "cronet_aml_net_dns_public_public",
+        "cronet_aml_net_http_transport_security_state_generated_files",
         "cronet_aml_net_net",
+        "cronet_aml_net_net_deps",
+        "cronet_aml_net_net_public_deps",
         "cronet_aml_net_preload_decoder",
         "cronet_aml_net_third_party_quiche_quiche",
+        "cronet_aml_net_traffic_annotation_traffic_annotation",
         "cronet_aml_net_uri_template",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access",
+        "cronet_aml_third_party_android_ndk_cpu_features",
+        "cronet_aml_third_party_ashmem_ashmem",
         "cronet_aml_third_party_boringssl_boringssl",
+        "cronet_aml_third_party_boringssl_boringssl_asm",
         "cronet_aml_third_party_brotli_common",
         "cronet_aml_third_party_brotli_dec",
         "cronet_aml_third_party_icu_icui18n",
@@ -8470,8 +8911,9 @@
     ],
     generated_headers: [
         "cronet_aml_components_cronet_cronet_buildflags",
-        "cronet_aml_components_cronet_cronet_version_header_action",
-        "cronet_aml_third_party_metrics_proto_metrics_proto_gen_headers",
+    ],
+    export_generated_headers: [
+        "cronet_aml_components_cronet_cronet_buildflags",
     ],
     defaults: [
         "cronet_aml_defaults",
@@ -8519,6 +8961,27 @@
         "third_party/protobuf/src/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+        "-Wl,--script,external/cronet/base/android/library_loader/anchor_functions.lds",
+        "-Wl,-wrap,asprintf",
+        "-Wl,-wrap,calloc",
+        "-Wl,-wrap,free",
+        "-Wl,-wrap,getcwd",
+        "-Wl,-wrap,malloc",
+        "-Wl,-wrap,malloc_usable_size",
+        "-Wl,-wrap,memalign",
+        "-Wl,-wrap,posix_memalign",
+        "-Wl,-wrap,pvalloc",
+        "-Wl,-wrap,realloc",
+        "-Wl,-wrap,realpath",
+        "-Wl,-wrap,strdup",
+        "-Wl,-wrap,strndup",
+        "-Wl,-wrap,valloc",
+        "-Wl,-wrap,vasprintf",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -8547,7 +9010,7 @@
 }
 
 // GN: //components/cronet:cronet_common__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_components_cronet_cronet_common__testing",
     srcs: [
         "components/cronet/cronet_context.cc",
@@ -8567,15 +9030,74 @@
         "cronet_aml_base_allocator_partition_allocator_partition_alloc__testing",
         "cronet_aml_base_base__testing",
         "cronet_aml_base_base_static__testing",
+        "cronet_aml_base_nodebug_assertion__testing",
         "cronet_aml_base_third_party_double_conversion_double_conversion__testing",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations__testing",
+        "cronet_aml_components_cronet_cronet_version_header__testing",
+        "cronet_aml_components_metrics_library_support__testing",
         "cronet_aml_components_prefs_prefs__testing",
         "cronet_aml_crypto_crypto__testing",
+        "cronet_aml_net_dns_dns__testing",
+        "cronet_aml_net_dns_public_public__testing",
+        "cronet_aml_net_http_transport_security_state_generated_files__testing",
         "cronet_aml_net_net__testing",
+        "cronet_aml_net_net_deps__testing",
+        "cronet_aml_net_net_public_deps__testing",
         "cronet_aml_net_preload_decoder__testing",
         "cronet_aml_net_third_party_quiche_quiche__testing",
+        "cronet_aml_net_traffic_annotation_traffic_annotation__testing",
         "cronet_aml_net_uri_template__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access__testing",
+        "cronet_aml_third_party_android_ndk_cpu_features__testing",
+        "cronet_aml_third_party_ashmem_ashmem__testing",
         "cronet_aml_third_party_boringssl_boringssl__testing",
+        "cronet_aml_third_party_boringssl_boringssl_asm__testing",
         "cronet_aml_third_party_brotli_common__testing",
         "cronet_aml_third_party_brotli_dec__testing",
         "cronet_aml_third_party_icu_icui18n__testing",
@@ -8587,8 +9109,9 @@
     ],
     generated_headers: [
         "cronet_aml_components_cronet_cronet_buildflags__testing",
-        "cronet_aml_components_cronet_cronet_version_header_action__testing",
-        "cronet_aml_third_party_metrics_proto_metrics_proto__testing_gen_headers",
+    ],
+    export_generated_headers: [
+        "cronet_aml_components_cronet_cronet_buildflags__testing",
     ],
     defaults: [
         "cronet_aml_defaults",
@@ -8636,6 +9159,27 @@
         "third_party/protobuf/src/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+        "-Wl,--script,external/cronet/base/android/library_loader/anchor_functions.lds",
+        "-Wl,-wrap,asprintf",
+        "-Wl,-wrap,calloc",
+        "-Wl,-wrap,free",
+        "-Wl,-wrap,getcwd",
+        "-Wl,-wrap,malloc",
+        "-Wl,-wrap,malloc_usable_size",
+        "-Wl,-wrap,memalign",
+        "-Wl,-wrap,posix_memalign",
+        "-Wl,-wrap,pvalloc",
+        "-Wl,-wrap,realloc",
+        "-Wl,-wrap,realpath",
+        "-Wl,-wrap,strdup",
+        "-Wl,-wrap,strndup",
+        "-Wl,-wrap,valloc",
+        "-Wl,-wrap,vasprintf",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -8664,7 +9208,7 @@
 }
 
 // GN: //components/cronet:cronet_common_unittests__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_components_cronet_cronet_common_unittests__testing",
     srcs: [
         "components/cronet/host_cache_persistence_manager_unittest.cc",
@@ -8682,25 +9226,91 @@
         "cronet_aml_base_base__testing",
         "cronet_aml_base_base_static__testing",
         "cronet_aml_base_i18n__testing",
+        "cronet_aml_base_nodebug_assertion__testing",
         "cronet_aml_base_test_test_config__testing",
         "cronet_aml_base_test_test_support__testing",
         "cronet_aml_base_third_party_double_conversion_double_conversion__testing",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations__testing",
+        "cronet_aml_components_cronet_cronet_common__testing",
+        "cronet_aml_components_cronet_cronet_version_header__testing",
+        "cronet_aml_components_metrics_library_support__testing",
         "cronet_aml_components_prefs_prefs__testing",
         "cronet_aml_components_prefs_test_support__testing",
         "cronet_aml_crypto_crypto__testing",
+        "cronet_aml_net_dns_dns__testing",
+        "cronet_aml_net_dns_public_public__testing",
+        "cronet_aml_net_dns_test_support__testing",
         "cronet_aml_net_gtest_util__testing",
+        "cronet_aml_net_http_transport_security_state_generated_files__testing",
         "cronet_aml_net_net__testing",
+        "cronet_aml_net_net_deps__testing",
+        "cronet_aml_net_net_public_deps__testing",
         "cronet_aml_net_preload_decoder__testing",
+        "cronet_aml_net_quic_test_flags_utils__testing",
+        "cronet_aml_net_simple_quic_tools__testing",
         "cronet_aml_net_test_support__testing",
         "cronet_aml_net_third_party_quiche_quiche__testing",
         "cronet_aml_net_third_party_quiche_quiche_tool_support__testing",
+        "cronet_aml_net_tools_tld_cleanup_tld_cleanup__testing",
+        "cronet_aml_net_traffic_annotation_traffic_annotation__testing",
         "cronet_aml_net_uri_template__testing",
         "cronet_aml_testing_gtest_gtest__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access__testing",
+        "cronet_aml_third_party_android_ndk_cpu_features__testing",
+        "cronet_aml_third_party_ashmem_ashmem__testing",
         "cronet_aml_third_party_boringssl_boringssl__testing",
+        "cronet_aml_third_party_boringssl_boringssl_asm__testing",
         "cronet_aml_third_party_brotli_common__testing",
         "cronet_aml_third_party_brotli_dec__testing",
         "cronet_aml_third_party_ced_ced__testing",
+        "cronet_aml_third_party_googletest_gmock__testing",
+        "cronet_aml_third_party_googletest_gtest__testing",
         "cronet_aml_third_party_icu_icui18n__testing",
         "cronet_aml_third_party_icu_icuuc_private__testing",
         "cronet_aml_third_party_libevent_libevent__testing",
@@ -8711,11 +9321,6 @@
         "cronet_aml_third_party_protobuf_protobuf_lite__testing",
         "cronet_aml_url_url__testing",
     ],
-    generated_headers: [
-        "cronet_aml_components_cronet_cronet_buildflags__testing",
-        "cronet_aml_components_cronet_cronet_version_header_action__testing",
-        "cronet_aml_third_party_metrics_proto_metrics_proto__testing_gen_headers",
-    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -8782,6 +9387,181 @@
         "third_party/protobuf/src/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+        "-Wl,--script,external/cronet/base/android/library_loader/anchor_functions.lds",
+        "-Wl,-wrap,asprintf",
+        "-Wl,-wrap,calloc",
+        "-Wl,-wrap,free",
+        "-Wl,-wrap,getcwd",
+        "-Wl,-wrap,malloc",
+        "-Wl,-wrap,malloc_usable_size",
+        "-Wl,-wrap,memalign",
+        "-Wl,-wrap,posix_memalign",
+        "-Wl,-wrap,pvalloc",
+        "-Wl,-wrap,realloc",
+        "-Wl,-wrap,realpath",
+        "-Wl,-wrap,strdup",
+        "-Wl,-wrap,strndup",
+        "-Wl,-wrap,valloc",
+        "-Wl,-wrap,vasprintf",
+    ],
+    target: {
+        android_arm: {
+            cflags: [
+                "-fstack-protector",
+            ],
+        },
+        android_arm64: {
+            cflags: [
+                "-fstack-protector",
+                "-mno-outline",
+                "-mno-outline-atomics",
+            ],
+        },
+        android_x86: {
+            cflags: [
+                "-msse3",
+            ],
+        },
+        android_x86_64: {
+            cflags: [
+                "-fstack-protector",
+                "-msse3",
+            ],
+        },
+    },
+}
+
+// GN: //components/cronet:cronet_version_header
+cc_library_static {
+    name: "cronet_aml_components_cronet_cronet_version_header",
+    generated_headers: [
+        "cronet_aml_components_cronet_cronet_version_header_action",
+    ],
+    export_generated_headers: [
+        "cronet_aml_components_cronet_cronet_version_header_action",
+    ],
+    defaults: [
+        "cronet_aml_defaults",
+    ],
+    cflags: [
+        "-DANDROID",
+        "-DANDROID_NDK_VERSION_ROLL=r23_1",
+        "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+        "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+        "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+        "-DHAVE_SYS_UIO_H",
+        "-DNDEBUG",
+        "-DNO_UNWIND_TABLES",
+        "-DNVALGRIND",
+        "-DOFFICIAL_BUILD",
+        "-D_FORTIFY_SOURCE=2",
+        "-D_GNU_SOURCE",
+        "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+        "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+        "-D__STDC_CONSTANT_MACROS",
+        "-D__STDC_FORMAT_MACROS",
+        "-Oz",
+        "-fdata-sections",
+        "-ffunction-sections",
+        "-fno-asynchronous-unwind-tables",
+        "-fno-unwind-tables",
+        "-fvisibility-inlines-hidden",
+        "-fvisibility=hidden",
+        "-g1",
+    ],
+    local_include_dirs: [
+        "./",
+        "buildtools/third_party/libc++/",
+        "buildtools/third_party/libc++/trunk/include",
+        "buildtools/third_party/libc++abi/trunk/include",
+    ],
+    cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
+    target: {
+        android_arm: {
+            cflags: [
+                "-fstack-protector",
+            ],
+        },
+        android_arm64: {
+            cflags: [
+                "-fstack-protector",
+                "-mno-outline",
+                "-mno-outline-atomics",
+            ],
+        },
+        android_x86: {
+            cflags: [
+                "-msse3",
+            ],
+        },
+        android_x86_64: {
+            cflags: [
+                "-fstack-protector",
+                "-msse3",
+            ],
+        },
+    },
+}
+
+// GN: //components/cronet:cronet_version_header__testing
+cc_library_static {
+    name: "cronet_aml_components_cronet_cronet_version_header__testing",
+    generated_headers: [
+        "cronet_aml_components_cronet_cronet_version_header_action__testing",
+    ],
+    export_generated_headers: [
+        "cronet_aml_components_cronet_cronet_version_header_action__testing",
+    ],
+    defaults: [
+        "cronet_aml_defaults",
+    ],
+    cflags: [
+        "-DANDROID",
+        "-DANDROID_NDK_VERSION_ROLL=r23_1",
+        "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+        "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+        "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+        "-DHAVE_SYS_UIO_H",
+        "-DNDEBUG",
+        "-DNO_UNWIND_TABLES",
+        "-DNVALGRIND",
+        "-DOFFICIAL_BUILD",
+        "-D_FORTIFY_SOURCE=2",
+        "-D_GNU_SOURCE",
+        "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+        "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+        "-D__STDC_CONSTANT_MACROS",
+        "-D__STDC_FORMAT_MACROS",
+        "-Oz",
+        "-fdata-sections",
+        "-ffunction-sections",
+        "-fno-asynchronous-unwind-tables",
+        "-fno-unwind-tables",
+        "-fvisibility-inlines-hidden",
+        "-fvisibility=hidden",
+        "-g1",
+    ],
+    local_include_dirs: [
+        "./",
+        "buildtools/third_party/libc++/",
+        "buildtools/third_party/libc++/trunk/include",
+        "buildtools/third_party/libc++abi/trunk/include",
+    ],
+    cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -8862,7 +9642,7 @@
 }
 
 // GN: //components/cronet:metrics_util
-cc_object {
+cc_library_static {
     name: "cronet_aml_components_cronet_metrics_util",
     srcs: [
         "components/cronet/metrics_util.cc",
@@ -8875,9 +9655,60 @@
         "cronet_aml_base_allocator_partition_allocator_partition_alloc",
         "cronet_aml_base_base",
         "cronet_aml_base_base_static",
+        "cronet_aml_base_nodebug_assertion",
         "cronet_aml_base_third_party_double_conversion_double_conversion",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access",
+        "cronet_aml_third_party_android_ndk_cpu_features",
+        "cronet_aml_third_party_ashmem_ashmem",
         "cronet_aml_third_party_boringssl_boringssl",
+        "cronet_aml_third_party_boringssl_boringssl_asm",
         "cronet_aml_third_party_icu_icui18n",
         "cronet_aml_third_party_icu_icuuc_private",
         "cronet_aml_third_party_libevent_libevent",
@@ -8921,6 +9752,27 @@
         "third_party/boringssl/src/include/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+        "-Wl,--script,external/cronet/base/android/library_loader/anchor_functions.lds",
+        "-Wl,-wrap,asprintf",
+        "-Wl,-wrap,calloc",
+        "-Wl,-wrap,free",
+        "-Wl,-wrap,getcwd",
+        "-Wl,-wrap,malloc",
+        "-Wl,-wrap,malloc_usable_size",
+        "-Wl,-wrap,memalign",
+        "-Wl,-wrap,posix_memalign",
+        "-Wl,-wrap,pvalloc",
+        "-Wl,-wrap,realloc",
+        "-Wl,-wrap,realpath",
+        "-Wl,-wrap,strdup",
+        "-Wl,-wrap,strndup",
+        "-Wl,-wrap,valloc",
+        "-Wl,-wrap,vasprintf",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -8949,7 +9801,7 @@
 }
 
 // GN: //components/cronet:metrics_util__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_components_cronet_metrics_util__testing",
     srcs: [
         "components/cronet/metrics_util.cc",
@@ -8962,9 +9814,60 @@
         "cronet_aml_base_allocator_partition_allocator_partition_alloc__testing",
         "cronet_aml_base_base__testing",
         "cronet_aml_base_base_static__testing",
+        "cronet_aml_base_nodebug_assertion__testing",
         "cronet_aml_base_third_party_double_conversion_double_conversion__testing",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access__testing",
+        "cronet_aml_third_party_android_ndk_cpu_features__testing",
+        "cronet_aml_third_party_ashmem_ashmem__testing",
         "cronet_aml_third_party_boringssl_boringssl__testing",
+        "cronet_aml_third_party_boringssl_boringssl_asm__testing",
         "cronet_aml_third_party_icu_icui18n__testing",
         "cronet_aml_third_party_icu_icuuc_private__testing",
         "cronet_aml_third_party_libevent_libevent__testing",
@@ -9008,6 +9911,27 @@
         "third_party/boringssl/src/include/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+        "-Wl,--script,external/cronet/base/android/library_loader/anchor_functions.lds",
+        "-Wl,-wrap,asprintf",
+        "-Wl,-wrap,calloc",
+        "-Wl,-wrap,free",
+        "-Wl,-wrap,getcwd",
+        "-Wl,-wrap,malloc",
+        "-Wl,-wrap,malloc_usable_size",
+        "-Wl,-wrap,memalign",
+        "-Wl,-wrap,posix_memalign",
+        "-Wl,-wrap,pvalloc",
+        "-Wl,-wrap,realloc",
+        "-Wl,-wrap,realpath",
+        "-Wl,-wrap,strdup",
+        "-Wl,-wrap,strndup",
+        "-Wl,-wrap,valloc",
+        "-Wl,-wrap,vasprintf",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -9036,7 +9960,7 @@
 }
 
 // GN: //components/metrics:library_support
-cc_object {
+cc_library_static {
     name: "cronet_aml_components_metrics_library_support",
     srcs: [
         ":cronet_aml_third_party_metrics_proto_metrics_proto_gen",
@@ -9052,9 +9976,60 @@
         "cronet_aml_base_allocator_partition_allocator_partition_alloc",
         "cronet_aml_base_base",
         "cronet_aml_base_base_static",
+        "cronet_aml_base_nodebug_assertion",
         "cronet_aml_base_third_party_double_conversion_double_conversion",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access",
+        "cronet_aml_third_party_android_ndk_cpu_features",
+        "cronet_aml_third_party_ashmem_ashmem",
         "cronet_aml_third_party_boringssl_boringssl",
+        "cronet_aml_third_party_boringssl_boringssl_asm",
         "cronet_aml_third_party_icu_icui18n",
         "cronet_aml_third_party_icu_icuuc_private",
         "cronet_aml_third_party_libevent_libevent",
@@ -9064,6 +10039,9 @@
     generated_headers: [
         "cronet_aml_third_party_metrics_proto_metrics_proto_gen_headers",
     ],
+    export_generated_headers: [
+        "cronet_aml_third_party_metrics_proto_metrics_proto_gen_headers",
+    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -9107,6 +10085,27 @@
         "third_party/protobuf/src/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+        "-Wl,--script,external/cronet/base/android/library_loader/anchor_functions.lds",
+        "-Wl,-wrap,asprintf",
+        "-Wl,-wrap,calloc",
+        "-Wl,-wrap,free",
+        "-Wl,-wrap,getcwd",
+        "-Wl,-wrap,malloc",
+        "-Wl,-wrap,malloc_usable_size",
+        "-Wl,-wrap,memalign",
+        "-Wl,-wrap,posix_memalign",
+        "-Wl,-wrap,pvalloc",
+        "-Wl,-wrap,realloc",
+        "-Wl,-wrap,realpath",
+        "-Wl,-wrap,strdup",
+        "-Wl,-wrap,strndup",
+        "-Wl,-wrap,valloc",
+        "-Wl,-wrap,vasprintf",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -9135,7 +10134,7 @@
 }
 
 // GN: //components/metrics:library_support__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_components_metrics_library_support__testing",
     srcs: [
         ":cronet_aml_third_party_metrics_proto_metrics_proto__testing_gen",
@@ -9151,9 +10150,60 @@
         "cronet_aml_base_allocator_partition_allocator_partition_alloc__testing",
         "cronet_aml_base_base__testing",
         "cronet_aml_base_base_static__testing",
+        "cronet_aml_base_nodebug_assertion__testing",
         "cronet_aml_base_third_party_double_conversion_double_conversion__testing",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access__testing",
+        "cronet_aml_third_party_android_ndk_cpu_features__testing",
+        "cronet_aml_third_party_ashmem_ashmem__testing",
         "cronet_aml_third_party_boringssl_boringssl__testing",
+        "cronet_aml_third_party_boringssl_boringssl_asm__testing",
         "cronet_aml_third_party_icu_icui18n__testing",
         "cronet_aml_third_party_icu_icuuc_private__testing",
         "cronet_aml_third_party_libevent_libevent__testing",
@@ -9163,6 +10213,9 @@
     generated_headers: [
         "cronet_aml_third_party_metrics_proto_metrics_proto__testing_gen_headers",
     ],
+    export_generated_headers: [
+        "cronet_aml_third_party_metrics_proto_metrics_proto__testing_gen_headers",
+    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -9206,6 +10259,27 @@
         "third_party/protobuf/src/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+        "-Wl,--script,external/cronet/base/android/library_loader/anchor_functions.lds",
+        "-Wl,-wrap,asprintf",
+        "-Wl,-wrap,calloc",
+        "-Wl,-wrap,free",
+        "-Wl,-wrap,getcwd",
+        "-Wl,-wrap,malloc",
+        "-Wl,-wrap,malloc_usable_size",
+        "-Wl,-wrap,memalign",
+        "-Wl,-wrap,posix_memalign",
+        "-Wl,-wrap,pvalloc",
+        "-Wl,-wrap,realloc",
+        "-Wl,-wrap,realpath",
+        "-Wl,-wrap,strdup",
+        "-Wl,-wrap,strndup",
+        "-Wl,-wrap,valloc",
+        "-Wl,-wrap,vasprintf",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -9333,9 +10407,60 @@
         "cronet_aml_base_allocator_partition_allocator_partition_alloc",
         "cronet_aml_base_base",
         "cronet_aml_base_base_static",
+        "cronet_aml_base_nodebug_assertion",
         "cronet_aml_base_third_party_double_conversion_double_conversion",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access",
+        "cronet_aml_third_party_android_ndk_cpu_features",
+        "cronet_aml_third_party_ashmem_ashmem",
         "cronet_aml_third_party_boringssl_boringssl",
+        "cronet_aml_third_party_boringssl_boringssl_asm",
         "cronet_aml_third_party_icu_icui18n",
         "cronet_aml_third_party_icu_icuuc_private",
         "cronet_aml_third_party_libevent_libevent",
@@ -9474,9 +10599,60 @@
         "cronet_aml_base_allocator_partition_allocator_partition_alloc__testing",
         "cronet_aml_base_base__testing",
         "cronet_aml_base_base_static__testing",
+        "cronet_aml_base_nodebug_assertion__testing",
         "cronet_aml_base_third_party_double_conversion_double_conversion__testing",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access__testing",
+        "cronet_aml_third_party_android_ndk_cpu_features__testing",
+        "cronet_aml_third_party_ashmem_ashmem__testing",
         "cronet_aml_third_party_boringssl_boringssl__testing",
+        "cronet_aml_third_party_boringssl_boringssl_asm__testing",
         "cronet_aml_third_party_icu_icui18n__testing",
         "cronet_aml_third_party_icu_icuuc_private__testing",
         "cronet_aml_third_party_libevent_libevent__testing",
@@ -9585,55 +10761,6 @@
 cc_library_static {
     name: "cronet_aml_components_prefs_test_support__testing",
     srcs: [
-        ":cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_strerror__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_hash_city__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_hash_hash__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_distributions__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_randen__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_status_status__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_status_statusor__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_cord__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access__testing",
-        ":cronet_aml_third_party_googletest_gmock__testing",
-        ":cronet_aml_third_party_googletest_gtest__testing",
         "components/prefs/mock_pref_change_callback.cc",
         "components/prefs/pref_store_observer_mock.cc",
         "components/prefs/pref_test_utils.cc",
@@ -9650,14 +10777,67 @@
         "cronet_aml_base_base__testing",
         "cronet_aml_base_base_static__testing",
         "cronet_aml_base_i18n__testing",
+        "cronet_aml_base_nodebug_assertion__testing",
         "cronet_aml_base_test_test_config__testing",
         "cronet_aml_base_test_test_support__testing",
         "cronet_aml_base_third_party_double_conversion_double_conversion__testing",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations__testing",
         "cronet_aml_components_prefs_prefs__testing",
         "cronet_aml_testing_gtest_gtest__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access__testing",
+        "cronet_aml_third_party_android_ndk_cpu_features__testing",
+        "cronet_aml_third_party_ashmem_ashmem__testing",
         "cronet_aml_third_party_boringssl_boringssl__testing",
+        "cronet_aml_third_party_boringssl_boringssl_asm__testing",
         "cronet_aml_third_party_ced_ced__testing",
+        "cronet_aml_third_party_googletest_gmock__testing",
+        "cronet_aml_third_party_googletest_gtest__testing",
         "cronet_aml_third_party_icu_icui18n__testing",
         "cronet_aml_third_party_icu_icuuc_private__testing",
         "cronet_aml_third_party_libevent_libevent__testing",
@@ -9666,12 +10846,6 @@
         "cronet_aml_third_party_libxml_xml_reader__testing",
         "cronet_aml_third_party_modp_b64_modp_b64__testing",
     ],
-    generated_headers: [
-        "cronet_aml_build_chromeos_buildflags__testing",
-    ],
-    export_generated_headers: [
-        "cronet_aml_build_chromeos_buildflags__testing",
-    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -9856,9 +11030,60 @@
         "cronet_aml_base_allocator_partition_allocator_partition_alloc",
         "cronet_aml_base_base",
         "cronet_aml_base_base_static",
+        "cronet_aml_base_nodebug_assertion",
         "cronet_aml_base_third_party_double_conversion_double_conversion",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access",
+        "cronet_aml_third_party_android_ndk_cpu_features",
+        "cronet_aml_third_party_ashmem_ashmem",
         "cronet_aml_third_party_boringssl_boringssl",
+        "cronet_aml_third_party_boringssl_boringssl_asm",
         "cronet_aml_third_party_icu_icui18n",
         "cronet_aml_third_party_icu_icuuc_private",
         "cronet_aml_third_party_libevent_libevent",
@@ -9985,9 +11210,58 @@
         "cronet_aml_base_allocator_partition_allocator_partition_alloc__testing",
         "cronet_aml_base_base__testing",
         "cronet_aml_base_base_static__testing",
+        "cronet_aml_base_nodebug_assertion__testing",
         "cronet_aml_base_third_party_double_conversion_double_conversion__testing",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access__testing",
         "cronet_aml_third_party_boringssl_boringssl__testing",
+        "cronet_aml_third_party_boringssl_boringssl_asm__testing",
         "cronet_aml_third_party_icu_icui18n__testing",
         "cronet_aml_third_party_icu_icuuc_private__testing",
         "cronet_aml_third_party_libevent_libevent__testing",
@@ -10048,6 +11322,10 @@
             ],
         },
         android_arm: {
+            static_libs: [
+                "cronet_aml_third_party_android_ndk_cpu_features__testing",
+                "cronet_aml_third_party_ashmem_ashmem__testing",
+            ],
             cflags: [
                 "-DANDROID",
                 "-DANDROID_NDK_VERSION_ROLL=r23_1",
@@ -10074,6 +11352,10 @@
             ],
         },
         android_arm64: {
+            static_libs: [
+                "cronet_aml_third_party_android_ndk_cpu_features__testing",
+                "cronet_aml_third_party_ashmem_ashmem__testing",
+            ],
             cflags: [
                 "-DANDROID",
                 "-DANDROID_NDK_VERSION_ROLL=r23_1",
@@ -10102,6 +11384,10 @@
             ],
         },
         android_x86: {
+            static_libs: [
+                "cronet_aml_third_party_android_ndk_cpu_features__testing",
+                "cronet_aml_third_party_ashmem_ashmem__testing",
+            ],
             cflags: [
                 "-DANDROID",
                 "-DANDROID_NDK_VERSION_ROLL=r23_1",
@@ -10128,6 +11414,10 @@
             ],
         },
         android_x86_64: {
+            static_libs: [
+                "cronet_aml_third_party_android_ndk_cpu_features__testing",
+                "cronet_aml_third_party_ashmem_ashmem__testing",
+            ],
             cflags: [
                 "-DANDROID",
                 "-DANDROID_NDK_VERSION_ROLL=r23_1",
@@ -11094,7 +12384,7 @@
 }
 
 // GN: //net/dns:dns
-cc_object {
+cc_library_static {
     name: "cronet_aml_net_dns_dns",
     srcs: [
         "net/dns/address_info.cc",
@@ -11144,13 +12434,68 @@
         "cronet_aml_base_allocator_partition_allocator_partition_alloc",
         "cronet_aml_base_base",
         "cronet_aml_base_base_static",
+        "cronet_aml_base_nodebug_assertion",
         "cronet_aml_base_third_party_double_conversion_double_conversion",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations",
         "cronet_aml_crypto_crypto",
+        "cronet_aml_net_dns_public_public",
+        "cronet_aml_net_net_deps",
+        "cronet_aml_net_net_public_deps",
         "cronet_aml_net_preload_decoder",
         "cronet_aml_net_third_party_quiche_quiche",
+        "cronet_aml_net_traffic_annotation_traffic_annotation",
         "cronet_aml_net_uri_template",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access",
+        "cronet_aml_third_party_android_ndk_cpu_features",
+        "cronet_aml_third_party_ashmem_ashmem",
         "cronet_aml_third_party_boringssl_boringssl",
+        "cronet_aml_third_party_boringssl_boringssl_asm",
         "cronet_aml_third_party_brotli_common",
         "cronet_aml_third_party_brotli_dec",
         "cronet_aml_third_party_icu_icui18n",
@@ -11160,18 +12505,6 @@
         "cronet_aml_third_party_protobuf_protobuf_lite",
         "cronet_aml_url_url",
     ],
-    generated_headers: [
-        "cronet_aml_base_debugging_buildflags",
-        "cronet_aml_base_logging_buildflags",
-        "cronet_aml_build_chromeos_buildflags",
-        "cronet_aml_net_base_registry_controlled_domains_registry_controlled_domains",
-        "cronet_aml_net_buildflags",
-        "cronet_aml_net_isolation_info_proto_gen_headers",
-        "cronet_aml_net_net_jni_headers",
-        "cronet_aml_net_net_nqe_proto_gen_headers",
-        "cronet_aml_net_third_party_quiche_net_quic_test_tools_proto_gen_headers",
-        "cronet_aml_url_buildflags",
-    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -11221,6 +12554,27 @@
         "third_party/protobuf/src/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+        "-Wl,--script,external/cronet/base/android/library_loader/anchor_functions.lds",
+        "-Wl,-wrap,asprintf",
+        "-Wl,-wrap,calloc",
+        "-Wl,-wrap,free",
+        "-Wl,-wrap,getcwd",
+        "-Wl,-wrap,malloc",
+        "-Wl,-wrap,malloc_usable_size",
+        "-Wl,-wrap,memalign",
+        "-Wl,-wrap,posix_memalign",
+        "-Wl,-wrap,pvalloc",
+        "-Wl,-wrap,realloc",
+        "-Wl,-wrap,realpath",
+        "-Wl,-wrap,strdup",
+        "-Wl,-wrap,strndup",
+        "-Wl,-wrap,valloc",
+        "-Wl,-wrap,vasprintf",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -11249,7 +12603,7 @@
 }
 
 // GN: //net/dns:dns__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_net_dns_dns__testing",
     srcs: [
         "net/dns/address_info.cc",
@@ -11299,13 +12653,68 @@
         "cronet_aml_base_allocator_partition_allocator_partition_alloc__testing",
         "cronet_aml_base_base__testing",
         "cronet_aml_base_base_static__testing",
+        "cronet_aml_base_nodebug_assertion__testing",
         "cronet_aml_base_third_party_double_conversion_double_conversion__testing",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations__testing",
         "cronet_aml_crypto_crypto__testing",
+        "cronet_aml_net_dns_public_public__testing",
+        "cronet_aml_net_net_deps__testing",
+        "cronet_aml_net_net_public_deps__testing",
         "cronet_aml_net_preload_decoder__testing",
         "cronet_aml_net_third_party_quiche_quiche__testing",
+        "cronet_aml_net_traffic_annotation_traffic_annotation__testing",
         "cronet_aml_net_uri_template__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access__testing",
+        "cronet_aml_third_party_android_ndk_cpu_features__testing",
+        "cronet_aml_third_party_ashmem_ashmem__testing",
         "cronet_aml_third_party_boringssl_boringssl__testing",
+        "cronet_aml_third_party_boringssl_boringssl_asm__testing",
         "cronet_aml_third_party_brotli_common__testing",
         "cronet_aml_third_party_brotli_dec__testing",
         "cronet_aml_third_party_icu_icui18n__testing",
@@ -11315,18 +12724,6 @@
         "cronet_aml_third_party_protobuf_protobuf_lite__testing",
         "cronet_aml_url_url__testing",
     ],
-    generated_headers: [
-        "cronet_aml_base_debugging_buildflags__testing",
-        "cronet_aml_base_logging_buildflags__testing",
-        "cronet_aml_build_chromeos_buildflags__testing",
-        "cronet_aml_net_base_registry_controlled_domains_registry_controlled_domains__testing",
-        "cronet_aml_net_buildflags__testing",
-        "cronet_aml_net_isolation_info_proto__testing_gen_headers",
-        "cronet_aml_net_net_jni_headers__testing",
-        "cronet_aml_net_net_nqe_proto__testing_gen_headers",
-        "cronet_aml_net_third_party_quiche_net_quic_test_tools_proto__testing_gen_headers",
-        "cronet_aml_url_buildflags__testing",
-    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -11376,6 +12773,27 @@
         "third_party/protobuf/src/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+        "-Wl,--script,external/cronet/base/android/library_loader/anchor_functions.lds",
+        "-Wl,-wrap,asprintf",
+        "-Wl,-wrap,calloc",
+        "-Wl,-wrap,free",
+        "-Wl,-wrap,getcwd",
+        "-Wl,-wrap,malloc",
+        "-Wl,-wrap,malloc_usable_size",
+        "-Wl,-wrap,memalign",
+        "-Wl,-wrap,posix_memalign",
+        "-Wl,-wrap,pvalloc",
+        "-Wl,-wrap,realloc",
+        "-Wl,-wrap,realpath",
+        "-Wl,-wrap,strdup",
+        "-Wl,-wrap,strndup",
+        "-Wl,-wrap,valloc",
+        "-Wl,-wrap,vasprintf",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -11404,7 +12822,7 @@
 }
 
 // GN: //net/dns/public:public
-cc_object {
+cc_library_static {
     name: "cronet_aml_net_dns_public_public",
     srcs: [
         "net/dns/public/dns_config_overrides.cc",
@@ -11425,13 +12843,67 @@
         "cronet_aml_base_allocator_partition_allocator_partition_alloc",
         "cronet_aml_base_base",
         "cronet_aml_base_base_static",
+        "cronet_aml_base_nodebug_assertion",
         "cronet_aml_base_third_party_double_conversion_double_conversion",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations",
         "cronet_aml_crypto_crypto",
+        "cronet_aml_net_net_deps",
+        "cronet_aml_net_net_public_deps",
         "cronet_aml_net_preload_decoder",
         "cronet_aml_net_third_party_quiche_quiche",
+        "cronet_aml_net_traffic_annotation_traffic_annotation",
         "cronet_aml_net_uri_template",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access",
+        "cronet_aml_third_party_android_ndk_cpu_features",
+        "cronet_aml_third_party_ashmem_ashmem",
         "cronet_aml_third_party_boringssl_boringssl",
+        "cronet_aml_third_party_boringssl_boringssl_asm",
         "cronet_aml_third_party_brotli_common",
         "cronet_aml_third_party_brotli_dec",
         "cronet_aml_third_party_icu_icui18n",
@@ -11441,18 +12913,6 @@
         "cronet_aml_third_party_protobuf_protobuf_lite",
         "cronet_aml_url_url",
     ],
-    generated_headers: [
-        "cronet_aml_base_debugging_buildflags",
-        "cronet_aml_base_logging_buildflags",
-        "cronet_aml_build_chromeos_buildflags",
-        "cronet_aml_net_base_registry_controlled_domains_registry_controlled_domains",
-        "cronet_aml_net_buildflags",
-        "cronet_aml_net_isolation_info_proto_gen_headers",
-        "cronet_aml_net_net_jni_headers",
-        "cronet_aml_net_net_nqe_proto_gen_headers",
-        "cronet_aml_net_third_party_quiche_net_quic_test_tools_proto_gen_headers",
-        "cronet_aml_url_buildflags",
-    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -11502,6 +12962,27 @@
         "third_party/protobuf/src/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+        "-Wl,--script,external/cronet/base/android/library_loader/anchor_functions.lds",
+        "-Wl,-wrap,asprintf",
+        "-Wl,-wrap,calloc",
+        "-Wl,-wrap,free",
+        "-Wl,-wrap,getcwd",
+        "-Wl,-wrap,malloc",
+        "-Wl,-wrap,malloc_usable_size",
+        "-Wl,-wrap,memalign",
+        "-Wl,-wrap,posix_memalign",
+        "-Wl,-wrap,pvalloc",
+        "-Wl,-wrap,realloc",
+        "-Wl,-wrap,realpath",
+        "-Wl,-wrap,strdup",
+        "-Wl,-wrap,strndup",
+        "-Wl,-wrap,valloc",
+        "-Wl,-wrap,vasprintf",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -11530,7 +13011,7 @@
 }
 
 // GN: //net/dns/public:public__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_net_dns_public_public__testing",
     srcs: [
         "net/dns/public/dns_config_overrides.cc",
@@ -11551,13 +13032,67 @@
         "cronet_aml_base_allocator_partition_allocator_partition_alloc__testing",
         "cronet_aml_base_base__testing",
         "cronet_aml_base_base_static__testing",
+        "cronet_aml_base_nodebug_assertion__testing",
         "cronet_aml_base_third_party_double_conversion_double_conversion__testing",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations__testing",
         "cronet_aml_crypto_crypto__testing",
+        "cronet_aml_net_net_deps__testing",
+        "cronet_aml_net_net_public_deps__testing",
         "cronet_aml_net_preload_decoder__testing",
         "cronet_aml_net_third_party_quiche_quiche__testing",
+        "cronet_aml_net_traffic_annotation_traffic_annotation__testing",
         "cronet_aml_net_uri_template__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access__testing",
+        "cronet_aml_third_party_android_ndk_cpu_features__testing",
+        "cronet_aml_third_party_ashmem_ashmem__testing",
         "cronet_aml_third_party_boringssl_boringssl__testing",
+        "cronet_aml_third_party_boringssl_boringssl_asm__testing",
         "cronet_aml_third_party_brotli_common__testing",
         "cronet_aml_third_party_brotli_dec__testing",
         "cronet_aml_third_party_icu_icui18n__testing",
@@ -11567,18 +13102,6 @@
         "cronet_aml_third_party_protobuf_protobuf_lite__testing",
         "cronet_aml_url_url__testing",
     ],
-    generated_headers: [
-        "cronet_aml_base_debugging_buildflags__testing",
-        "cronet_aml_base_logging_buildflags__testing",
-        "cronet_aml_build_chromeos_buildflags__testing",
-        "cronet_aml_net_base_registry_controlled_domains_registry_controlled_domains__testing",
-        "cronet_aml_net_buildflags__testing",
-        "cronet_aml_net_isolation_info_proto__testing_gen_headers",
-        "cronet_aml_net_net_jni_headers__testing",
-        "cronet_aml_net_net_nqe_proto__testing_gen_headers",
-        "cronet_aml_net_third_party_quiche_net_quic_test_tools_proto__testing_gen_headers",
-        "cronet_aml_url_buildflags__testing",
-    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -11628,6 +13151,27 @@
         "third_party/protobuf/src/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+        "-Wl,--script,external/cronet/base/android/library_loader/anchor_functions.lds",
+        "-Wl,-wrap,asprintf",
+        "-Wl,-wrap,calloc",
+        "-Wl,-wrap,free",
+        "-Wl,-wrap,getcwd",
+        "-Wl,-wrap,malloc",
+        "-Wl,-wrap,malloc_usable_size",
+        "-Wl,-wrap,memalign",
+        "-Wl,-wrap,posix_memalign",
+        "-Wl,-wrap,pvalloc",
+        "-Wl,-wrap,realloc",
+        "-Wl,-wrap,realpath",
+        "-Wl,-wrap,strdup",
+        "-Wl,-wrap,strndup",
+        "-Wl,-wrap,valloc",
+        "-Wl,-wrap,vasprintf",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -11656,7 +13200,7 @@
 }
 
 // GN: //net/dns:test_support__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_net_dns_test_support__testing",
     srcs: [
         "net/dns/dns_test_util.cc",
@@ -11672,17 +13216,76 @@
         "cronet_aml_base_allocator_partition_allocator_partition_alloc__testing",
         "cronet_aml_base_base__testing",
         "cronet_aml_base_base_static__testing",
+        "cronet_aml_base_nodebug_assertion__testing",
         "cronet_aml_base_third_party_double_conversion_double_conversion__testing",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations__testing",
         "cronet_aml_crypto_crypto__testing",
+        "cronet_aml_net_dns_dns__testing",
+        "cronet_aml_net_dns_public_public__testing",
+        "cronet_aml_net_http_transport_security_state_generated_files__testing",
         "cronet_aml_net_net__testing",
+        "cronet_aml_net_net_deps__testing",
+        "cronet_aml_net_net_public_deps__testing",
         "cronet_aml_net_preload_decoder__testing",
         "cronet_aml_net_third_party_quiche_quiche__testing",
+        "cronet_aml_net_traffic_annotation_traffic_annotation__testing",
         "cronet_aml_net_uri_template__testing",
         "cronet_aml_testing_gtest_gtest__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access__testing",
+        "cronet_aml_third_party_android_ndk_cpu_features__testing",
+        "cronet_aml_third_party_ashmem_ashmem__testing",
         "cronet_aml_third_party_boringssl_boringssl__testing",
+        "cronet_aml_third_party_boringssl_boringssl_asm__testing",
         "cronet_aml_third_party_brotli_common__testing",
         "cronet_aml_third_party_brotli_dec__testing",
+        "cronet_aml_third_party_googletest_gmock__testing",
+        "cronet_aml_third_party_googletest_gtest__testing",
         "cronet_aml_third_party_icu_icui18n__testing",
         "cronet_aml_third_party_icu_icuuc_private__testing",
         "cronet_aml_third_party_libevent_libevent__testing",
@@ -11690,9 +13293,6 @@
         "cronet_aml_third_party_protobuf_protobuf_lite__testing",
         "cronet_aml_url_url__testing",
     ],
-    generated_headers: [
-        "cronet_aml_build_chromeos_buildflags__testing",
-    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -11748,6 +13348,27 @@
         "third_party/protobuf/src/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+        "-Wl,--script,external/cronet/base/android/library_loader/anchor_functions.lds",
+        "-Wl,-wrap,asprintf",
+        "-Wl,-wrap,calloc",
+        "-Wl,-wrap,free",
+        "-Wl,-wrap,getcwd",
+        "-Wl,-wrap,malloc",
+        "-Wl,-wrap,malloc_usable_size",
+        "-Wl,-wrap,memalign",
+        "-Wl,-wrap,posix_memalign",
+        "-Wl,-wrap,pvalloc",
+        "-Wl,-wrap,realloc",
+        "-Wl,-wrap,realpath",
+        "-Wl,-wrap,strdup",
+        "-Wl,-wrap,strndup",
+        "-Wl,-wrap,valloc",
+        "-Wl,-wrap,vasprintf",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -11798,55 +13419,6 @@
 cc_library_static {
     name: "cronet_aml_net_gtest_util__testing",
     srcs: [
-        ":cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_strerror__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_hash_city__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_hash_hash__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_distributions__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_randen__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_status_status__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_status_statusor__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_cord__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access__testing",
-        ":cronet_aml_third_party_googletest_gmock__testing",
-        ":cronet_aml_third_party_googletest_gtest__testing",
         "net/test/scoped_disable_exit_on_dfatal.cc",
     ],
     shared_libs: [
@@ -11859,20 +13431,79 @@
         "cronet_aml_base_base__testing",
         "cronet_aml_base_base_static__testing",
         "cronet_aml_base_i18n__testing",
+        "cronet_aml_base_nodebug_assertion__testing",
         "cronet_aml_base_test_test_config__testing",
         "cronet_aml_base_test_test_support__testing",
         "cronet_aml_base_third_party_double_conversion_double_conversion__testing",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations__testing",
         "cronet_aml_crypto_crypto__testing",
+        "cronet_aml_net_dns_dns__testing",
+        "cronet_aml_net_dns_public_public__testing",
+        "cronet_aml_net_http_transport_security_state_generated_files__testing",
         "cronet_aml_net_net__testing",
+        "cronet_aml_net_net_deps__testing",
+        "cronet_aml_net_net_public_deps__testing",
         "cronet_aml_net_preload_decoder__testing",
         "cronet_aml_net_third_party_quiche_quiche__testing",
+        "cronet_aml_net_traffic_annotation_traffic_annotation__testing",
         "cronet_aml_net_uri_template__testing",
         "cronet_aml_testing_gtest_gtest__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access__testing",
+        "cronet_aml_third_party_android_ndk_cpu_features__testing",
+        "cronet_aml_third_party_ashmem_ashmem__testing",
         "cronet_aml_third_party_boringssl_boringssl__testing",
+        "cronet_aml_third_party_boringssl_boringssl_asm__testing",
         "cronet_aml_third_party_brotli_common__testing",
         "cronet_aml_third_party_brotli_dec__testing",
         "cronet_aml_third_party_ced_ced__testing",
+        "cronet_aml_third_party_googletest_gmock__testing",
+        "cronet_aml_third_party_googletest_gtest__testing",
         "cronet_aml_third_party_icu_icui18n__testing",
         "cronet_aml_third_party_icu_icuuc_private__testing",
         "cronet_aml_third_party_libevent_libevent__testing",
@@ -11883,12 +13514,6 @@
         "cronet_aml_third_party_protobuf_protobuf_lite__testing",
         "cronet_aml_url_url__testing",
     ],
-    generated_headers: [
-        "cronet_aml_build_chromeos_buildflags__testing",
-    ],
-    export_generated_headers: [
-        "cronet_aml_build_chromeos_buildflags__testing",
-    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -12003,7 +13628,7 @@
 }
 
 // GN: //net/http:transport_security_state_generated_files
-cc_object {
+cc_library_static {
     name: "cronet_aml_net_http_transport_security_state_generated_files",
     srcs: [
         "net/http/transport_security_state.cc",
@@ -12017,13 +13642,69 @@
         "cronet_aml_base_allocator_partition_allocator_partition_alloc",
         "cronet_aml_base_base",
         "cronet_aml_base_base_static",
+        "cronet_aml_base_nodebug_assertion",
         "cronet_aml_base_third_party_double_conversion_double_conversion",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations",
         "cronet_aml_crypto_crypto",
+        "cronet_aml_net_dns_dns",
+        "cronet_aml_net_dns_public_public",
+        "cronet_aml_net_net_deps",
+        "cronet_aml_net_net_public_deps",
         "cronet_aml_net_preload_decoder",
         "cronet_aml_net_third_party_quiche_quiche",
+        "cronet_aml_net_traffic_annotation_traffic_annotation",
         "cronet_aml_net_uri_template",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access",
+        "cronet_aml_third_party_android_ndk_cpu_features",
+        "cronet_aml_third_party_ashmem_ashmem",
         "cronet_aml_third_party_boringssl_boringssl",
+        "cronet_aml_third_party_boringssl_boringssl_asm",
         "cronet_aml_third_party_brotli_common",
         "cronet_aml_third_party_brotli_dec",
         "cronet_aml_third_party_icu_icui18n",
@@ -12034,17 +13715,10 @@
         "cronet_aml_url_url",
     ],
     generated_headers: [
-        "cronet_aml_base_debugging_buildflags",
-        "cronet_aml_base_logging_buildflags",
         "cronet_aml_build_branding_buildflags",
-        "cronet_aml_build_chromeos_buildflags",
-        "cronet_aml_net_base_registry_controlled_domains_registry_controlled_domains",
-        "cronet_aml_net_buildflags",
-        "cronet_aml_net_isolation_info_proto_gen_headers",
-        "cronet_aml_net_net_jni_headers",
-        "cronet_aml_net_net_nqe_proto_gen_headers",
-        "cronet_aml_net_third_party_quiche_net_quic_test_tools_proto_gen_headers",
-        "cronet_aml_url_buildflags",
+    ],
+    export_generated_headers: [
+        "cronet_aml_build_branding_buildflags",
     ],
     defaults: [
         "cronet_aml_defaults",
@@ -12095,6 +13769,27 @@
         "third_party/protobuf/src/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+        "-Wl,--script,external/cronet/base/android/library_loader/anchor_functions.lds",
+        "-Wl,-wrap,asprintf",
+        "-Wl,-wrap,calloc",
+        "-Wl,-wrap,free",
+        "-Wl,-wrap,getcwd",
+        "-Wl,-wrap,malloc",
+        "-Wl,-wrap,malloc_usable_size",
+        "-Wl,-wrap,memalign",
+        "-Wl,-wrap,posix_memalign",
+        "-Wl,-wrap,pvalloc",
+        "-Wl,-wrap,realloc",
+        "-Wl,-wrap,realpath",
+        "-Wl,-wrap,strdup",
+        "-Wl,-wrap,strndup",
+        "-Wl,-wrap,valloc",
+        "-Wl,-wrap,vasprintf",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -12123,7 +13818,7 @@
 }
 
 // GN: //net/http:transport_security_state_generated_files__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_net_http_transport_security_state_generated_files__testing",
     srcs: [
         "net/http/transport_security_state.cc",
@@ -12137,13 +13832,69 @@
         "cronet_aml_base_allocator_partition_allocator_partition_alloc__testing",
         "cronet_aml_base_base__testing",
         "cronet_aml_base_base_static__testing",
+        "cronet_aml_base_nodebug_assertion__testing",
         "cronet_aml_base_third_party_double_conversion_double_conversion__testing",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations__testing",
         "cronet_aml_crypto_crypto__testing",
+        "cronet_aml_net_dns_dns__testing",
+        "cronet_aml_net_dns_public_public__testing",
+        "cronet_aml_net_net_deps__testing",
+        "cronet_aml_net_net_public_deps__testing",
         "cronet_aml_net_preload_decoder__testing",
         "cronet_aml_net_third_party_quiche_quiche__testing",
+        "cronet_aml_net_traffic_annotation_traffic_annotation__testing",
         "cronet_aml_net_uri_template__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access__testing",
+        "cronet_aml_third_party_android_ndk_cpu_features__testing",
+        "cronet_aml_third_party_ashmem_ashmem__testing",
         "cronet_aml_third_party_boringssl_boringssl__testing",
+        "cronet_aml_third_party_boringssl_boringssl_asm__testing",
         "cronet_aml_third_party_brotli_common__testing",
         "cronet_aml_third_party_brotli_dec__testing",
         "cronet_aml_third_party_icu_icui18n__testing",
@@ -12154,17 +13905,10 @@
         "cronet_aml_url_url__testing",
     ],
     generated_headers: [
-        "cronet_aml_base_debugging_buildflags__testing",
-        "cronet_aml_base_logging_buildflags__testing",
         "cronet_aml_build_branding_buildflags__testing",
-        "cronet_aml_build_chromeos_buildflags__testing",
-        "cronet_aml_net_base_registry_controlled_domains_registry_controlled_domains__testing",
-        "cronet_aml_net_buildflags__testing",
-        "cronet_aml_net_isolation_info_proto__testing_gen_headers",
-        "cronet_aml_net_net_jni_headers__testing",
-        "cronet_aml_net_net_nqe_proto__testing_gen_headers",
-        "cronet_aml_net_third_party_quiche_net_quic_test_tools_proto__testing_gen_headers",
-        "cronet_aml_url_buildflags__testing",
+    ],
+    export_generated_headers: [
+        "cronet_aml_build_branding_buildflags__testing",
     ],
     defaults: [
         "cronet_aml_defaults",
@@ -12215,6 +13959,27 @@
         "third_party/protobuf/src/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+        "-Wl,--script,external/cronet/base/android/library_loader/anchor_functions.lds",
+        "-Wl,-wrap,asprintf",
+        "-Wl,-wrap,calloc",
+        "-Wl,-wrap,free",
+        "-Wl,-wrap,getcwd",
+        "-Wl,-wrap,malloc",
+        "-Wl,-wrap,malloc_usable_size",
+        "-Wl,-wrap,memalign",
+        "-Wl,-wrap,posix_memalign",
+        "-Wl,-wrap,pvalloc",
+        "-Wl,-wrap,realloc",
+        "-Wl,-wrap,realpath",
+        "-Wl,-wrap,strdup",
+        "-Wl,-wrap,strndup",
+        "-Wl,-wrap,valloc",
+        "-Wl,-wrap,vasprintf",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -12399,12 +14164,6 @@
 cc_library_static {
     name: "cronet_aml_net_net",
     srcs: [
-        ":cronet_aml_net_dns_dns",
-        ":cronet_aml_net_dns_public_public",
-        ":cronet_aml_net_http_transport_security_state_generated_files",
-        ":cronet_aml_net_net_deps",
-        ":cronet_aml_net_net_public_deps",
-        ":cronet_aml_net_traffic_annotation_traffic_annotation",
         "net/android/android_http_util.cc",
         "net/android/cert_verify_result_android.cc",
         "net/android/gurl_utils.cc",
@@ -12897,13 +14656,70 @@
         "cronet_aml_base_allocator_partition_allocator_partition_alloc",
         "cronet_aml_base_base",
         "cronet_aml_base_base_static",
+        "cronet_aml_base_nodebug_assertion",
         "cronet_aml_base_third_party_double_conversion_double_conversion",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations",
         "cronet_aml_crypto_crypto",
+        "cronet_aml_net_dns_dns",
+        "cronet_aml_net_dns_public_public",
+        "cronet_aml_net_http_transport_security_state_generated_files",
+        "cronet_aml_net_net_deps",
+        "cronet_aml_net_net_public_deps",
         "cronet_aml_net_preload_decoder",
         "cronet_aml_net_third_party_quiche_quiche",
+        "cronet_aml_net_traffic_annotation_traffic_annotation",
         "cronet_aml_net_uri_template",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access",
+        "cronet_aml_third_party_android_ndk_cpu_features",
+        "cronet_aml_third_party_ashmem_ashmem",
         "cronet_aml_third_party_boringssl_boringssl",
+        "cronet_aml_third_party_boringssl_boringssl_asm",
         "cronet_aml_third_party_brotli_common",
         "cronet_aml_third_party_brotli_dec",
         "cronet_aml_third_party_icu_icui18n",
@@ -12914,32 +14730,12 @@
         "cronet_aml_url_url",
     ],
     generated_headers: [
-        "cronet_aml_base_debugging_buildflags",
-        "cronet_aml_base_logging_buildflags",
-        "cronet_aml_build_branding_buildflags",
         "cronet_aml_build_chromeos_buildflags",
-        "cronet_aml_net_base_registry_controlled_domains_registry_controlled_domains",
-        "cronet_aml_net_buildflags",
         "cronet_aml_net_ios_cronet_buildflags",
-        "cronet_aml_net_isolation_info_proto_gen_headers",
-        "cronet_aml_net_net_jni_headers",
-        "cronet_aml_net_net_nqe_proto_gen_headers",
-        "cronet_aml_net_third_party_quiche_net_quic_test_tools_proto_gen_headers",
-        "cronet_aml_url_buildflags",
     ],
     export_generated_headers: [
-        "cronet_aml_base_debugging_buildflags",
-        "cronet_aml_base_logging_buildflags",
-        "cronet_aml_build_branding_buildflags",
         "cronet_aml_build_chromeos_buildflags",
-        "cronet_aml_net_base_registry_controlled_domains_registry_controlled_domains",
-        "cronet_aml_net_buildflags",
         "cronet_aml_net_ios_cronet_buildflags",
-        "cronet_aml_net_isolation_info_proto_gen_headers",
-        "cronet_aml_net_net_jni_headers",
-        "cronet_aml_net_net_nqe_proto_gen_headers",
-        "cronet_aml_net_third_party_quiche_net_quic_test_tools_proto_gen_headers",
-        "cronet_aml_url_buildflags",
     ],
     export_static_lib_headers: [
         "cronet_aml_crypto_crypto",
@@ -13058,12 +14854,6 @@
 cc_library_static {
     name: "cronet_aml_net_net__testing",
     srcs: [
-        ":cronet_aml_net_dns_dns__testing",
-        ":cronet_aml_net_dns_public_public__testing",
-        ":cronet_aml_net_http_transport_security_state_generated_files__testing",
-        ":cronet_aml_net_net_deps__testing",
-        ":cronet_aml_net_net_public_deps__testing",
-        ":cronet_aml_net_traffic_annotation_traffic_annotation__testing",
         "net/android/android_http_util.cc",
         "net/android/cert_verify_result_android.cc",
         "net/android/gurl_utils.cc",
@@ -13556,13 +15346,70 @@
         "cronet_aml_base_allocator_partition_allocator_partition_alloc__testing",
         "cronet_aml_base_base__testing",
         "cronet_aml_base_base_static__testing",
+        "cronet_aml_base_nodebug_assertion__testing",
         "cronet_aml_base_third_party_double_conversion_double_conversion__testing",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations__testing",
         "cronet_aml_crypto_crypto__testing",
+        "cronet_aml_net_dns_dns__testing",
+        "cronet_aml_net_dns_public_public__testing",
+        "cronet_aml_net_http_transport_security_state_generated_files__testing",
+        "cronet_aml_net_net_deps__testing",
+        "cronet_aml_net_net_public_deps__testing",
         "cronet_aml_net_preload_decoder__testing",
         "cronet_aml_net_third_party_quiche_quiche__testing",
+        "cronet_aml_net_traffic_annotation_traffic_annotation__testing",
         "cronet_aml_net_uri_template__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access__testing",
+        "cronet_aml_third_party_android_ndk_cpu_features__testing",
+        "cronet_aml_third_party_ashmem_ashmem__testing",
         "cronet_aml_third_party_boringssl_boringssl__testing",
+        "cronet_aml_third_party_boringssl_boringssl_asm__testing",
         "cronet_aml_third_party_brotli_common__testing",
         "cronet_aml_third_party_brotli_dec__testing",
         "cronet_aml_third_party_icu_icui18n__testing",
@@ -13573,32 +15420,12 @@
         "cronet_aml_url_url__testing",
     ],
     generated_headers: [
-        "cronet_aml_base_debugging_buildflags__testing",
-        "cronet_aml_base_logging_buildflags__testing",
-        "cronet_aml_build_branding_buildflags__testing",
         "cronet_aml_build_chromeos_buildflags__testing",
-        "cronet_aml_net_base_registry_controlled_domains_registry_controlled_domains__testing",
-        "cronet_aml_net_buildflags__testing",
         "cronet_aml_net_ios_cronet_buildflags__testing",
-        "cronet_aml_net_isolation_info_proto__testing_gen_headers",
-        "cronet_aml_net_net_jni_headers__testing",
-        "cronet_aml_net_net_nqe_proto__testing_gen_headers",
-        "cronet_aml_net_third_party_quiche_net_quic_test_tools_proto__testing_gen_headers",
-        "cronet_aml_url_buildflags__testing",
     ],
     export_generated_headers: [
-        "cronet_aml_base_debugging_buildflags__testing",
-        "cronet_aml_base_logging_buildflags__testing",
-        "cronet_aml_build_branding_buildflags__testing",
         "cronet_aml_build_chromeos_buildflags__testing",
-        "cronet_aml_net_base_registry_controlled_domains_registry_controlled_domains__testing",
-        "cronet_aml_net_buildflags__testing",
         "cronet_aml_net_ios_cronet_buildflags__testing",
-        "cronet_aml_net_isolation_info_proto__testing_gen_headers",
-        "cronet_aml_net_net_jni_headers__testing",
-        "cronet_aml_net_net_nqe_proto__testing_gen_headers",
-        "cronet_aml_net_third_party_quiche_net_quic_test_tools_proto__testing_gen_headers",
-        "cronet_aml_url_buildflags__testing",
     ],
     defaults: [
         "cronet_aml_defaults",
@@ -13710,7 +15537,7 @@
 }
 
 // GN: //net:net_deps
-cc_object {
+cc_library_static {
     name: "cronet_aml_net_net_deps",
     srcs: [
         ":cronet_aml_net_isolation_info_proto_gen",
@@ -13725,10 +15552,61 @@
         "cronet_aml_base_allocator_partition_allocator_partition_alloc",
         "cronet_aml_base_base",
         "cronet_aml_base_base_static",
+        "cronet_aml_base_nodebug_assertion",
         "cronet_aml_base_third_party_double_conversion_double_conversion",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations",
         "cronet_aml_net_preload_decoder",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access",
+        "cronet_aml_third_party_android_ndk_cpu_features",
+        "cronet_aml_third_party_ashmem_ashmem",
         "cronet_aml_third_party_boringssl_boringssl",
+        "cronet_aml_third_party_boringssl_boringssl_asm",
         "cronet_aml_third_party_brotli_common",
         "cronet_aml_third_party_brotli_dec",
         "cronet_aml_third_party_icu_icui18n",
@@ -13746,6 +15624,15 @@
         "cronet_aml_net_net_jni_headers",
         "cronet_aml_url_buildflags",
     ],
+    export_generated_headers: [
+        "cronet_aml_base_debugging_buildflags",
+        "cronet_aml_base_logging_buildflags",
+        "cronet_aml_build_chromeos_buildflags",
+        "cronet_aml_net_base_registry_controlled_domains_registry_controlled_domains",
+        "cronet_aml_net_isolation_info_proto_gen_headers",
+        "cronet_aml_net_net_jni_headers",
+        "cronet_aml_url_buildflags",
+    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -13792,6 +15679,27 @@
         "third_party/protobuf/src/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+        "-Wl,--script,external/cronet/base/android/library_loader/anchor_functions.lds",
+        "-Wl,-wrap,asprintf",
+        "-Wl,-wrap,calloc",
+        "-Wl,-wrap,free",
+        "-Wl,-wrap,getcwd",
+        "-Wl,-wrap,malloc",
+        "-Wl,-wrap,malloc_usable_size",
+        "-Wl,-wrap,memalign",
+        "-Wl,-wrap,posix_memalign",
+        "-Wl,-wrap,pvalloc",
+        "-Wl,-wrap,realloc",
+        "-Wl,-wrap,realpath",
+        "-Wl,-wrap,strdup",
+        "-Wl,-wrap,strndup",
+        "-Wl,-wrap,valloc",
+        "-Wl,-wrap,vasprintf",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -13820,7 +15728,7 @@
 }
 
 // GN: //net:net_deps__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_net_net_deps__testing",
     srcs: [
         ":cronet_aml_net_isolation_info_proto__testing_gen",
@@ -13835,10 +15743,61 @@
         "cronet_aml_base_allocator_partition_allocator_partition_alloc__testing",
         "cronet_aml_base_base__testing",
         "cronet_aml_base_base_static__testing",
+        "cronet_aml_base_nodebug_assertion__testing",
         "cronet_aml_base_third_party_double_conversion_double_conversion__testing",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations__testing",
         "cronet_aml_net_preload_decoder__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access__testing",
+        "cronet_aml_third_party_android_ndk_cpu_features__testing",
+        "cronet_aml_third_party_ashmem_ashmem__testing",
         "cronet_aml_third_party_boringssl_boringssl__testing",
+        "cronet_aml_third_party_boringssl_boringssl_asm__testing",
         "cronet_aml_third_party_brotli_common__testing",
         "cronet_aml_third_party_brotli_dec__testing",
         "cronet_aml_third_party_icu_icui18n__testing",
@@ -13856,6 +15815,15 @@
         "cronet_aml_net_net_jni_headers__testing",
         "cronet_aml_url_buildflags__testing",
     ],
+    export_generated_headers: [
+        "cronet_aml_base_debugging_buildflags__testing",
+        "cronet_aml_base_logging_buildflags__testing",
+        "cronet_aml_build_chromeos_buildflags__testing",
+        "cronet_aml_net_base_registry_controlled_domains_registry_controlled_domains__testing",
+        "cronet_aml_net_isolation_info_proto__testing_gen_headers",
+        "cronet_aml_net_net_jni_headers__testing",
+        "cronet_aml_url_buildflags__testing",
+    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -13902,6 +15870,27 @@
         "third_party/protobuf/src/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+        "-Wl,--script,external/cronet/base/android/library_loader/anchor_functions.lds",
+        "-Wl,-wrap,asprintf",
+        "-Wl,-wrap,calloc",
+        "-Wl,-wrap,free",
+        "-Wl,-wrap,getcwd",
+        "-Wl,-wrap,malloc",
+        "-Wl,-wrap,malloc_usable_size",
+        "-Wl,-wrap,memalign",
+        "-Wl,-wrap,posix_memalign",
+        "-Wl,-wrap,pvalloc",
+        "-Wl,-wrap,realloc",
+        "-Wl,-wrap,realpath",
+        "-Wl,-wrap,strdup",
+        "-Wl,-wrap,strndup",
+        "-Wl,-wrap,valloc",
+        "-Wl,-wrap,vasprintf",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -14222,7 +16211,7 @@
 }
 
 // GN: //net:net_public_deps
-cc_object {
+cc_library_static {
     name: "cronet_aml_net_net_public_deps",
     srcs: [
         ":cronet_aml_net_net_nqe_proto_gen",
@@ -14238,12 +16227,64 @@
         "cronet_aml_base_allocator_partition_allocator_partition_alloc",
         "cronet_aml_base_base",
         "cronet_aml_base_base_static",
+        "cronet_aml_base_nodebug_assertion",
         "cronet_aml_base_third_party_double_conversion_double_conversion",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations",
         "cronet_aml_crypto_crypto",
         "cronet_aml_net_third_party_quiche_quiche",
+        "cronet_aml_net_traffic_annotation_traffic_annotation",
         "cronet_aml_net_uri_template",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access",
+        "cronet_aml_third_party_android_ndk_cpu_features",
+        "cronet_aml_third_party_ashmem_ashmem",
         "cronet_aml_third_party_boringssl_boringssl",
+        "cronet_aml_third_party_boringssl_boringssl_asm",
         "cronet_aml_third_party_icu_icui18n",
         "cronet_aml_third_party_icu_icuuc_private",
         "cronet_aml_third_party_libevent_libevent",
@@ -14252,7 +16293,11 @@
         "cronet_aml_url_url",
     ],
     generated_headers: [
-        "cronet_aml_build_chromeos_buildflags",
+        "cronet_aml_net_buildflags",
+        "cronet_aml_net_net_nqe_proto_gen_headers",
+        "cronet_aml_net_third_party_quiche_net_quic_test_tools_proto_gen_headers",
+    ],
+    export_generated_headers: [
         "cronet_aml_net_buildflags",
         "cronet_aml_net_net_nqe_proto_gen_headers",
         "cronet_aml_net_third_party_quiche_net_quic_test_tools_proto_gen_headers",
@@ -14303,6 +16348,27 @@
         "third_party/protobuf/src/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+        "-Wl,--script,external/cronet/base/android/library_loader/anchor_functions.lds",
+        "-Wl,-wrap,asprintf",
+        "-Wl,-wrap,calloc",
+        "-Wl,-wrap,free",
+        "-Wl,-wrap,getcwd",
+        "-Wl,-wrap,malloc",
+        "-Wl,-wrap,malloc_usable_size",
+        "-Wl,-wrap,memalign",
+        "-Wl,-wrap,posix_memalign",
+        "-Wl,-wrap,pvalloc",
+        "-Wl,-wrap,realloc",
+        "-Wl,-wrap,realpath",
+        "-Wl,-wrap,strdup",
+        "-Wl,-wrap,strndup",
+        "-Wl,-wrap,valloc",
+        "-Wl,-wrap,vasprintf",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -14331,7 +16397,7 @@
 }
 
 // GN: //net:net_public_deps__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_net_net_public_deps__testing",
     srcs: [
         ":cronet_aml_net_net_nqe_proto__testing_gen",
@@ -14347,12 +16413,64 @@
         "cronet_aml_base_allocator_partition_allocator_partition_alloc__testing",
         "cronet_aml_base_base__testing",
         "cronet_aml_base_base_static__testing",
+        "cronet_aml_base_nodebug_assertion__testing",
         "cronet_aml_base_third_party_double_conversion_double_conversion__testing",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations__testing",
         "cronet_aml_crypto_crypto__testing",
         "cronet_aml_net_third_party_quiche_quiche__testing",
+        "cronet_aml_net_traffic_annotation_traffic_annotation__testing",
         "cronet_aml_net_uri_template__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access__testing",
+        "cronet_aml_third_party_android_ndk_cpu_features__testing",
+        "cronet_aml_third_party_ashmem_ashmem__testing",
         "cronet_aml_third_party_boringssl_boringssl__testing",
+        "cronet_aml_third_party_boringssl_boringssl_asm__testing",
         "cronet_aml_third_party_icu_icui18n__testing",
         "cronet_aml_third_party_icu_icuuc_private__testing",
         "cronet_aml_third_party_libevent_libevent__testing",
@@ -14361,7 +16479,11 @@
         "cronet_aml_url_url__testing",
     ],
     generated_headers: [
-        "cronet_aml_build_chromeos_buildflags__testing",
+        "cronet_aml_net_buildflags__testing",
+        "cronet_aml_net_net_nqe_proto__testing_gen_headers",
+        "cronet_aml_net_third_party_quiche_net_quic_test_tools_proto__testing_gen_headers",
+    ],
+    export_generated_headers: [
         "cronet_aml_net_buildflags__testing",
         "cronet_aml_net_net_nqe_proto__testing_gen_headers",
         "cronet_aml_net_third_party_quiche_net_quic_test_tools_proto__testing_gen_headers",
@@ -14412,6 +16534,27 @@
         "third_party/protobuf/src/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+        "-Wl,--script,external/cronet/base/android/library_loader/anchor_functions.lds",
+        "-Wl,-wrap,asprintf",
+        "-Wl,-wrap,calloc",
+        "-Wl,-wrap,free",
+        "-Wl,-wrap,getcwd",
+        "-Wl,-wrap,malloc",
+        "-Wl,-wrap,malloc_usable_size",
+        "-Wl,-wrap,memalign",
+        "-Wl,-wrap,posix_memalign",
+        "-Wl,-wrap,pvalloc",
+        "-Wl,-wrap,realloc",
+        "-Wl,-wrap,realpath",
+        "-Wl,-wrap,strdup",
+        "-Wl,-wrap,strndup",
+        "-Wl,-wrap,valloc",
+        "-Wl,-wrap,vasprintf",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -14453,9 +16596,60 @@
         "cronet_aml_base_allocator_partition_allocator_partition_alloc",
         "cronet_aml_base_base",
         "cronet_aml_base_base_static",
+        "cronet_aml_base_nodebug_assertion",
         "cronet_aml_base_third_party_double_conversion_double_conversion",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access",
+        "cronet_aml_third_party_android_ndk_cpu_features",
+        "cronet_aml_third_party_ashmem_ashmem",
         "cronet_aml_third_party_boringssl_boringssl",
+        "cronet_aml_third_party_boringssl_boringssl_asm",
         "cronet_aml_third_party_icu_icui18n",
         "cronet_aml_third_party_icu_icuuc_private",
         "cronet_aml_third_party_libevent_libevent",
@@ -14561,9 +16755,60 @@
         "cronet_aml_base_allocator_partition_allocator_partition_alloc__testing",
         "cronet_aml_base_base__testing",
         "cronet_aml_base_base_static__testing",
+        "cronet_aml_base_nodebug_assertion__testing",
         "cronet_aml_base_third_party_double_conversion_double_conversion__testing",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access__testing",
+        "cronet_aml_third_party_android_ndk_cpu_features__testing",
+        "cronet_aml_third_party_ashmem_ashmem__testing",
         "cronet_aml_third_party_boringssl_boringssl__testing",
+        "cronet_aml_third_party_boringssl_boringssl_asm__testing",
         "cronet_aml_third_party_icu_icui18n__testing",
         "cronet_aml_third_party_icu_icuuc_private__testing",
         "cronet_aml_third_party_libevent_libevent__testing",
@@ -14656,7 +16901,7 @@
 }
 
 // GN: //net:quic_test_flags_utils__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_net_quic_test_flags_utils__testing",
     srcs: [
         "net/quic/platform/impl/quic_test_flags_utils.cc",
@@ -14670,14 +16915,71 @@
         "cronet_aml_base_allocator_partition_allocator_partition_alloc__testing",
         "cronet_aml_base_base__testing",
         "cronet_aml_base_base_static__testing",
+        "cronet_aml_base_nodebug_assertion__testing",
         "cronet_aml_base_third_party_double_conversion_double_conversion__testing",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations__testing",
         "cronet_aml_crypto_crypto__testing",
+        "cronet_aml_net_dns_dns__testing",
+        "cronet_aml_net_dns_public_public__testing",
+        "cronet_aml_net_http_transport_security_state_generated_files__testing",
         "cronet_aml_net_net__testing",
+        "cronet_aml_net_net_deps__testing",
+        "cronet_aml_net_net_public_deps__testing",
         "cronet_aml_net_preload_decoder__testing",
         "cronet_aml_net_third_party_quiche_quiche__testing",
+        "cronet_aml_net_traffic_annotation_traffic_annotation__testing",
         "cronet_aml_net_uri_template__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access__testing",
+        "cronet_aml_third_party_android_ndk_cpu_features__testing",
+        "cronet_aml_third_party_ashmem_ashmem__testing",
         "cronet_aml_third_party_boringssl_boringssl__testing",
+        "cronet_aml_third_party_boringssl_boringssl_asm__testing",
         "cronet_aml_third_party_brotli_common__testing",
         "cronet_aml_third_party_brotli_dec__testing",
         "cronet_aml_third_party_icu_icui18n__testing",
@@ -14733,6 +17035,27 @@
         "third_party/protobuf/src/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+        "-Wl,--script,external/cronet/base/android/library_loader/anchor_functions.lds",
+        "-Wl,-wrap,asprintf",
+        "-Wl,-wrap,calloc",
+        "-Wl,-wrap,free",
+        "-Wl,-wrap,getcwd",
+        "-Wl,-wrap,malloc",
+        "-Wl,-wrap,malloc_usable_size",
+        "-Wl,-wrap,memalign",
+        "-Wl,-wrap,posix_memalign",
+        "-Wl,-wrap,pvalloc",
+        "-Wl,-wrap,realloc",
+        "-Wl,-wrap,realpath",
+        "-Wl,-wrap,strdup",
+        "-Wl,-wrap,strndup",
+        "-Wl,-wrap,valloc",
+        "-Wl,-wrap,vasprintf",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -14761,7 +17084,7 @@
 }
 
 // GN: //net:simple_quic_tools__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_net_simple_quic_tools__testing",
     srcs: [
         "net/tools/quic/quic_client_message_loop_network_helper.cc",
@@ -14781,15 +17104,72 @@
         "cronet_aml_base_allocator_partition_allocator_partition_alloc__testing",
         "cronet_aml_base_base__testing",
         "cronet_aml_base_base_static__testing",
+        "cronet_aml_base_nodebug_assertion__testing",
         "cronet_aml_base_third_party_double_conversion_double_conversion__testing",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations__testing",
         "cronet_aml_crypto_crypto__testing",
+        "cronet_aml_net_dns_dns__testing",
+        "cronet_aml_net_dns_public_public__testing",
+        "cronet_aml_net_http_transport_security_state_generated_files__testing",
         "cronet_aml_net_net__testing",
+        "cronet_aml_net_net_deps__testing",
+        "cronet_aml_net_net_public_deps__testing",
         "cronet_aml_net_preload_decoder__testing",
         "cronet_aml_net_third_party_quiche_quiche__testing",
         "cronet_aml_net_third_party_quiche_quiche_tool_support__testing",
+        "cronet_aml_net_traffic_annotation_traffic_annotation__testing",
         "cronet_aml_net_uri_template__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access__testing",
+        "cronet_aml_third_party_android_ndk_cpu_features__testing",
+        "cronet_aml_third_party_ashmem_ashmem__testing",
         "cronet_aml_third_party_boringssl_boringssl__testing",
+        "cronet_aml_third_party_boringssl_boringssl_asm__testing",
         "cronet_aml_third_party_brotli_common__testing",
         "cronet_aml_third_party_brotli_dec__testing",
         "cronet_aml_third_party_icu_icui18n__testing",
@@ -14845,6 +17225,27 @@
         "third_party/protobuf/src/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+        "-Wl,--script,external/cronet/base/android/library_loader/anchor_functions.lds",
+        "-Wl,-wrap,asprintf",
+        "-Wl,-wrap,calloc",
+        "-Wl,-wrap,free",
+        "-Wl,-wrap,getcwd",
+        "-Wl,-wrap,malloc",
+        "-Wl,-wrap,malloc_usable_size",
+        "-Wl,-wrap,memalign",
+        "-Wl,-wrap,posix_memalign",
+        "-Wl,-wrap,pvalloc",
+        "-Wl,-wrap,realloc",
+        "-Wl,-wrap,realpath",
+        "-Wl,-wrap,strdup",
+        "-Wl,-wrap,strndup",
+        "-Wl,-wrap,valloc",
+        "-Wl,-wrap,vasprintf",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -14876,60 +17277,6 @@
 cc_library_static {
     name: "cronet_aml_net_test_support__testing",
     srcs: [
-        ":cronet_aml_net_dns_test_support__testing",
-        ":cronet_aml_net_quic_test_flags_utils__testing",
-        ":cronet_aml_net_simple_quic_tools__testing",
-        ":cronet_aml_net_tools_tld_cleanup_tld_cleanup__testing",
-        ":cronet_aml_net_traffic_annotation_traffic_annotation__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_strerror__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_hash_city__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_hash_hash__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_distributions__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_randen__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_status_status__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_status_statusor__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_cord__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access__testing",
-        ":cronet_aml_third_party_googletest_gmock__testing",
-        ":cronet_aml_third_party_googletest_gtest__testing",
         "net/base/connection_endpoint_metadata_test_util.cc",
         "net/base/load_timing_info_test_util.cc",
         "net/base/mock_file_stream.cc",
@@ -15016,22 +17363,85 @@
         "cronet_aml_base_base__testing",
         "cronet_aml_base_base_static__testing",
         "cronet_aml_base_i18n__testing",
+        "cronet_aml_base_nodebug_assertion__testing",
         "cronet_aml_base_test_test_config__testing",
         "cronet_aml_base_test_test_support__testing",
         "cronet_aml_base_third_party_double_conversion_double_conversion__testing",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations__testing",
         "cronet_aml_crypto_crypto__testing",
+        "cronet_aml_net_dns_dns__testing",
+        "cronet_aml_net_dns_public_public__testing",
+        "cronet_aml_net_dns_test_support__testing",
         "cronet_aml_net_gtest_util__testing",
+        "cronet_aml_net_http_transport_security_state_generated_files__testing",
         "cronet_aml_net_net__testing",
+        "cronet_aml_net_net_deps__testing",
+        "cronet_aml_net_net_public_deps__testing",
         "cronet_aml_net_preload_decoder__testing",
+        "cronet_aml_net_quic_test_flags_utils__testing",
+        "cronet_aml_net_simple_quic_tools__testing",
         "cronet_aml_net_third_party_quiche_quiche__testing",
         "cronet_aml_net_third_party_quiche_quiche_tool_support__testing",
+        "cronet_aml_net_tools_tld_cleanup_tld_cleanup__testing",
+        "cronet_aml_net_traffic_annotation_traffic_annotation__testing",
         "cronet_aml_net_uri_template__testing",
         "cronet_aml_testing_gtest_gtest__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access__testing",
+        "cronet_aml_third_party_android_ndk_cpu_features__testing",
+        "cronet_aml_third_party_ashmem_ashmem__testing",
         "cronet_aml_third_party_boringssl_boringssl__testing",
+        "cronet_aml_third_party_boringssl_boringssl_asm__testing",
         "cronet_aml_third_party_brotli_common__testing",
         "cronet_aml_third_party_brotli_dec__testing",
         "cronet_aml_third_party_ced_ced__testing",
+        "cronet_aml_third_party_googletest_gmock__testing",
+        "cronet_aml_third_party_googletest_gtest__testing",
         "cronet_aml_third_party_icu_icui18n__testing",
         "cronet_aml_third_party_icu_icuuc_private__testing",
         "cronet_aml_third_party_libevent_libevent__testing",
@@ -15043,11 +17453,9 @@
         "cronet_aml_url_url__testing",
     ],
     generated_headers: [
-        "cronet_aml_build_chromeos_buildflags__testing",
         "cronet_aml_net_http_transport_security_state_unittest_data_default__testing",
     ],
     export_generated_headers: [
-        "cronet_aml_build_chromeos_buildflags__testing",
         "cronet_aml_net_http_transport_security_state_unittest_data_default__testing",
     ],
     defaults: [
@@ -15349,53 +17757,6 @@
     name: "cronet_aml_net_third_party_quiche_quiche",
     srcs: [
         ":cronet_aml_net_third_party_quiche_net_quic_proto_gen",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_base",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_strerror",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
-        ":cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler",
-        ":cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set",
-        ":cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
-        ":cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
-        ":cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack",
-        ":cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler",
-        ":cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
-        ":cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
-        ":cronet_aml_third_party_abseil_cpp_absl_hash_city",
-        ":cronet_aml_third_party_abseil_cpp_absl_hash_hash",
-        ":cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash",
-        ":cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
-        ":cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_distributions",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_randen",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences",
-        ":cronet_aml_third_party_abseil_cpp_absl_status_status",
-        ":cronet_aml_third_party_abseil_cpp_absl_status_statusor",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_cord",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_internal",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_strings",
-        ":cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
-        ":cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
-        ":cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
-        ":cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
-        ":cronet_aml_third_party_abseil_cpp_absl_time_time",
-        ":cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
-        ":cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access",
         "net/third_party/quiche/overrides/quiche_platform_impl/quiche_mutex_impl.cc",
         "net/third_party/quiche/overrides/quiche_platform_impl/quiche_time_utils_impl.cc",
         "net/third_party/quiche/overrides/quiche_platform_impl/quiche_url_utils_impl.cc",
@@ -15687,10 +18048,61 @@
         "cronet_aml_base_allocator_partition_allocator_partition_alloc",
         "cronet_aml_base_base",
         "cronet_aml_base_base_static",
+        "cronet_aml_base_nodebug_assertion",
         "cronet_aml_base_third_party_double_conversion_double_conversion",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations",
         "cronet_aml_net_uri_template",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access",
+        "cronet_aml_third_party_android_ndk_cpu_features",
+        "cronet_aml_third_party_ashmem_ashmem",
         "cronet_aml_third_party_boringssl_boringssl",
+        "cronet_aml_third_party_boringssl_boringssl_asm",
         "cronet_aml_third_party_icu_icui18n",
         "cronet_aml_third_party_icu_icuuc_private",
         "cronet_aml_third_party_libevent_libevent",
@@ -15699,11 +18111,9 @@
         "cronet_aml_url_url",
     ],
     generated_headers: [
-        "cronet_aml_build_chromeos_buildflags",
         "cronet_aml_net_third_party_quiche_net_quic_proto_gen_headers",
     ],
     export_generated_headers: [
-        "cronet_aml_build_chromeos_buildflags",
         "cronet_aml_net_third_party_quiche_net_quic_proto_gen_headers",
     ],
     defaults: [
@@ -15806,53 +18216,6 @@
     name: "cronet_aml_net_third_party_quiche_quiche__testing",
     srcs: [
         ":cronet_aml_net_third_party_quiche_net_quic_proto__testing_gen",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_strerror__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_hash_city__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_hash_hash__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_distributions__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_randen__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_status_status__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_status_statusor__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_cord__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access__testing",
         "net/third_party/quiche/overrides/quiche_platform_impl/quiche_mutex_impl.cc",
         "net/third_party/quiche/overrides/quiche_platform_impl/quiche_time_utils_impl.cc",
         "net/third_party/quiche/overrides/quiche_platform_impl/quiche_url_utils_impl.cc",
@@ -16144,10 +18507,61 @@
         "cronet_aml_base_allocator_partition_allocator_partition_alloc__testing",
         "cronet_aml_base_base__testing",
         "cronet_aml_base_base_static__testing",
+        "cronet_aml_base_nodebug_assertion__testing",
         "cronet_aml_base_third_party_double_conversion_double_conversion__testing",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations__testing",
         "cronet_aml_net_uri_template__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access__testing",
+        "cronet_aml_third_party_android_ndk_cpu_features__testing",
+        "cronet_aml_third_party_ashmem_ashmem__testing",
         "cronet_aml_third_party_boringssl_boringssl__testing",
+        "cronet_aml_third_party_boringssl_boringssl_asm__testing",
         "cronet_aml_third_party_icu_icui18n__testing",
         "cronet_aml_third_party_icu_icuuc_private__testing",
         "cronet_aml_third_party_libevent_libevent__testing",
@@ -16156,11 +18570,9 @@
         "cronet_aml_url_url__testing",
     ],
     generated_headers: [
-        "cronet_aml_build_chromeos_buildflags__testing",
         "cronet_aml_net_third_party_quiche_net_quic_proto__testing_gen_headers",
     ],
     export_generated_headers: [
-        "cronet_aml_build_chromeos_buildflags__testing",
         "cronet_aml_net_third_party_quiche_net_quic_proto__testing_gen_headers",
     ],
     defaults: [
@@ -16296,14 +18708,71 @@
         "cronet_aml_base_allocator_partition_allocator_partition_alloc__testing",
         "cronet_aml_base_base__testing",
         "cronet_aml_base_base_static__testing",
+        "cronet_aml_base_nodebug_assertion__testing",
         "cronet_aml_base_third_party_double_conversion_double_conversion__testing",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations__testing",
         "cronet_aml_crypto_crypto__testing",
+        "cronet_aml_net_dns_dns__testing",
+        "cronet_aml_net_dns_public_public__testing",
+        "cronet_aml_net_http_transport_security_state_generated_files__testing",
         "cronet_aml_net_net__testing",
+        "cronet_aml_net_net_deps__testing",
+        "cronet_aml_net_net_public_deps__testing",
         "cronet_aml_net_preload_decoder__testing",
         "cronet_aml_net_third_party_quiche_quiche__testing",
+        "cronet_aml_net_traffic_annotation_traffic_annotation__testing",
         "cronet_aml_net_uri_template__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access__testing",
+        "cronet_aml_third_party_android_ndk_cpu_features__testing",
+        "cronet_aml_third_party_ashmem_ashmem__testing",
         "cronet_aml_third_party_boringssl_boringssl__testing",
+        "cronet_aml_third_party_boringssl_boringssl_asm__testing",
         "cronet_aml_third_party_brotli_common__testing",
         "cronet_aml_third_party_brotli_dec__testing",
         "cronet_aml_third_party_icu_icui18n__testing",
@@ -16408,7 +18877,7 @@
 }
 
 // GN: //net/tools/huffman_trie:huffman_trie_generator_sources__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_net_tools_huffman_trie_huffman_trie_generator_sources__testing",
     srcs: [
         "net/tools/huffman_trie/bit_writer.cc",
@@ -16421,9 +18890,58 @@
         "cronet_aml_base_allocator_partition_allocator_partition_alloc__testing",
         "cronet_aml_base_base__testing",
         "cronet_aml_base_base_static__testing",
+        "cronet_aml_base_nodebug_assertion__testing",
         "cronet_aml_base_third_party_double_conversion_double_conversion__testing",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access__testing",
         "cronet_aml_third_party_boringssl_boringssl__testing",
+        "cronet_aml_third_party_boringssl_boringssl_asm__testing",
         "cronet_aml_third_party_icu_icui18n__testing",
         "cronet_aml_third_party_icu_icuuc_private__testing",
         "cronet_aml_third_party_libevent_libevent__testing",
@@ -16475,10 +18993,15 @@
         "third_party/boringssl/src/include/",
     ],
     cpp_std: "c++20",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
 }
 
 // GN: //net/tools/tld_cleanup:tld_cleanup__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_net_tools_tld_cleanup_tld_cleanup__testing",
     srcs: [
         "net/tools/tld_cleanup/tld_cleanup_util.cc",
@@ -16491,9 +19014,60 @@
         "cronet_aml_base_allocator_partition_allocator_partition_alloc__testing",
         "cronet_aml_base_base__testing",
         "cronet_aml_base_base_static__testing",
+        "cronet_aml_base_nodebug_assertion__testing",
         "cronet_aml_base_third_party_double_conversion_double_conversion__testing",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access__testing",
+        "cronet_aml_third_party_android_ndk_cpu_features__testing",
+        "cronet_aml_third_party_ashmem_ashmem__testing",
         "cronet_aml_third_party_boringssl_boringssl__testing",
+        "cronet_aml_third_party_boringssl_boringssl_asm__testing",
         "cronet_aml_third_party_icu_icui18n__testing",
         "cronet_aml_third_party_icu_icuuc_private__testing",
         "cronet_aml_third_party_libevent_libevent__testing",
@@ -16538,6 +19112,27 @@
         "third_party/boringssl/src/include/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+        "-Wl,--script,external/cronet/base/android/library_loader/anchor_functions.lds",
+        "-Wl,-wrap,asprintf",
+        "-Wl,-wrap,calloc",
+        "-Wl,-wrap,free",
+        "-Wl,-wrap,getcwd",
+        "-Wl,-wrap,malloc",
+        "-Wl,-wrap,malloc_usable_size",
+        "-Wl,-wrap,memalign",
+        "-Wl,-wrap,posix_memalign",
+        "-Wl,-wrap,pvalloc",
+        "-Wl,-wrap,realloc",
+        "-Wl,-wrap,realpath",
+        "-Wl,-wrap,strdup",
+        "-Wl,-wrap,strndup",
+        "-Wl,-wrap,valloc",
+        "-Wl,-wrap,vasprintf",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -16569,20 +19164,69 @@
 cc_binary {
     name: "cronet_aml_net_tools_transport_security_state_generator_transport_security_state_generator__testing",
     srcs: [
-        ":cronet_aml_buildtools_third_party_libc___libc____testing",
-        ":cronet_aml_buildtools_third_party_libc__abi_libc__abi__testing",
-        ":cronet_aml_net_tools_huffman_trie_huffman_trie_generator_sources__testing",
-        ":cronet_aml_net_tools_transport_security_state_generator_transport_security_state_generator_sources__testing",
         "net/tools/transport_security_state_generator/transport_security_state_generator.cc",
     ],
     static_libs: [
         "cronet_aml_base_allocator_partition_allocator_partition_alloc__testing",
         "cronet_aml_base_base__testing",
         "cronet_aml_base_base_static__testing",
+        "cronet_aml_base_nodebug_assertion__testing",
         "cronet_aml_base_third_party_double_conversion_double_conversion__testing",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations__testing",
+        "cronet_aml_buildtools_third_party_libc___libc____testing",
+        "cronet_aml_buildtools_third_party_libc__abi_libc__abi__testing",
         "cronet_aml_crypto_crypto__testing",
+        "cronet_aml_net_tools_huffman_trie_huffman_trie_generator_sources__testing",
+        "cronet_aml_net_tools_transport_security_state_generator_transport_security_state_generator_sources__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access__testing",
         "cronet_aml_third_party_boringssl_boringssl__testing",
+        "cronet_aml_third_party_boringssl_boringssl_asm__testing",
         "cronet_aml_third_party_icu_icui18n__testing",
         "cronet_aml_third_party_icu_icuuc_private__testing",
         "cronet_aml_third_party_libevent_libevent__testing",
@@ -16642,7 +19286,7 @@
 }
 
 // GN: //net/tools/transport_security_state_generator:transport_security_state_generator_sources__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_net_tools_transport_security_state_generator_transport_security_state_generator_sources__testing",
     srcs: [
         "net/tools/transport_security_state_generator/cert_util.cc",
@@ -16657,9 +19301,59 @@
         "cronet_aml_base_allocator_partition_allocator_partition_alloc__testing",
         "cronet_aml_base_base__testing",
         "cronet_aml_base_base_static__testing",
+        "cronet_aml_base_nodebug_assertion__testing",
         "cronet_aml_base_third_party_double_conversion_double_conversion__testing",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations__testing",
+        "cronet_aml_net_tools_huffman_trie_huffman_trie_generator_sources__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access__testing",
         "cronet_aml_third_party_boringssl_boringssl__testing",
+        "cronet_aml_third_party_boringssl_boringssl_asm__testing",
         "cronet_aml_third_party_icu_icui18n__testing",
         "cronet_aml_third_party_icu_icuuc_private__testing",
         "cronet_aml_third_party_libevent_libevent__testing",
@@ -16711,10 +19405,15 @@
         "third_party/boringssl/src/include/",
     ],
     cpp_std: "c++20",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
 }
 
 // GN: //net/traffic_annotation:traffic_annotation
-cc_object {
+cc_library_static {
     name: "cronet_aml_net_traffic_annotation_traffic_annotation",
     srcs: [
         "net/traffic_annotation/network_traffic_annotation_android.cc",
@@ -16727,9 +19426,60 @@
         "cronet_aml_base_allocator_partition_allocator_partition_alloc",
         "cronet_aml_base_base",
         "cronet_aml_base_base_static",
+        "cronet_aml_base_nodebug_assertion",
         "cronet_aml_base_third_party_double_conversion_double_conversion",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access",
+        "cronet_aml_third_party_android_ndk_cpu_features",
+        "cronet_aml_third_party_ashmem_ashmem",
         "cronet_aml_third_party_boringssl_boringssl",
+        "cronet_aml_third_party_boringssl_boringssl_asm",
         "cronet_aml_third_party_icu_icui18n",
         "cronet_aml_third_party_icu_icuuc_private",
         "cronet_aml_third_party_libevent_libevent",
@@ -16738,6 +19488,9 @@
     generated_headers: [
         "cronet_aml_build_chromeos_buildflags",
     ],
+    export_generated_headers: [
+        "cronet_aml_build_chromeos_buildflags",
+    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -16776,6 +19529,27 @@
         "third_party/boringssl/src/include/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+        "-Wl,--script,external/cronet/base/android/library_loader/anchor_functions.lds",
+        "-Wl,-wrap,asprintf",
+        "-Wl,-wrap,calloc",
+        "-Wl,-wrap,free",
+        "-Wl,-wrap,getcwd",
+        "-Wl,-wrap,malloc",
+        "-Wl,-wrap,malloc_usable_size",
+        "-Wl,-wrap,memalign",
+        "-Wl,-wrap,posix_memalign",
+        "-Wl,-wrap,pvalloc",
+        "-Wl,-wrap,realloc",
+        "-Wl,-wrap,realpath",
+        "-Wl,-wrap,strdup",
+        "-Wl,-wrap,strndup",
+        "-Wl,-wrap,valloc",
+        "-Wl,-wrap,vasprintf",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -16804,7 +19578,7 @@
 }
 
 // GN: //net/traffic_annotation:traffic_annotation__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_net_traffic_annotation_traffic_annotation__testing",
     srcs: [
         "net/traffic_annotation/network_traffic_annotation_android.cc",
@@ -16817,9 +19591,60 @@
         "cronet_aml_base_allocator_partition_allocator_partition_alloc__testing",
         "cronet_aml_base_base__testing",
         "cronet_aml_base_base_static__testing",
+        "cronet_aml_base_nodebug_assertion__testing",
         "cronet_aml_base_third_party_double_conversion_double_conversion__testing",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access__testing",
+        "cronet_aml_third_party_android_ndk_cpu_features__testing",
+        "cronet_aml_third_party_ashmem_ashmem__testing",
         "cronet_aml_third_party_boringssl_boringssl__testing",
+        "cronet_aml_third_party_boringssl_boringssl_asm__testing",
         "cronet_aml_third_party_icu_icui18n__testing",
         "cronet_aml_third_party_icu_icuuc_private__testing",
         "cronet_aml_third_party_libevent_libevent__testing",
@@ -16828,6 +19653,9 @@
     generated_headers: [
         "cronet_aml_build_chromeos_buildflags__testing",
     ],
+    export_generated_headers: [
+        "cronet_aml_build_chromeos_buildflags__testing",
+    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -16866,6 +19694,27 @@
         "third_party/boringssl/src/include/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+        "-Wl,--script,external/cronet/base/android/library_loader/anchor_functions.lds",
+        "-Wl,-wrap,asprintf",
+        "-Wl,-wrap,calloc",
+        "-Wl,-wrap,free",
+        "-Wl,-wrap,getcwd",
+        "-Wl,-wrap,malloc",
+        "-Wl,-wrap,malloc_usable_size",
+        "-Wl,-wrap,memalign",
+        "-Wl,-wrap,posix_memalign",
+        "-Wl,-wrap,pvalloc",
+        "-Wl,-wrap,realloc",
+        "-Wl,-wrap,realpath",
+        "-Wl,-wrap,strdup",
+        "-Wl,-wrap,strndup",
+        "-Wl,-wrap,valloc",
+        "-Wl,-wrap,vasprintf",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -16907,9 +19756,60 @@
         "cronet_aml_base_allocator_partition_allocator_partition_alloc",
         "cronet_aml_base_base",
         "cronet_aml_base_base_static",
+        "cronet_aml_base_nodebug_assertion",
         "cronet_aml_base_third_party_double_conversion_double_conversion",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access",
+        "cronet_aml_third_party_android_ndk_cpu_features",
+        "cronet_aml_third_party_ashmem_ashmem",
         "cronet_aml_third_party_boringssl_boringssl",
+        "cronet_aml_third_party_boringssl_boringssl_asm",
         "cronet_aml_third_party_icu_icui18n",
         "cronet_aml_third_party_icu_icuuc_private",
         "cronet_aml_third_party_libevent_libevent",
@@ -17016,9 +19916,60 @@
         "cronet_aml_base_allocator_partition_allocator_partition_alloc__testing",
         "cronet_aml_base_base__testing",
         "cronet_aml_base_base_static__testing",
+        "cronet_aml_base_nodebug_assertion__testing",
         "cronet_aml_base_third_party_double_conversion_double_conversion__testing",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access__testing",
+        "cronet_aml_third_party_android_ndk_cpu_features__testing",
+        "cronet_aml_third_party_ashmem_ashmem__testing",
         "cronet_aml_third_party_boringssl_boringssl__testing",
+        "cronet_aml_third_party_boringssl_boringssl_asm__testing",
         "cronet_aml_third_party_icu_icui18n__testing",
         "cronet_aml_third_party_icu_icuuc_private__testing",
         "cronet_aml_third_party_libevent_libevent__testing",
@@ -17150,7 +20101,7 @@
 }
 
 // GN: //testing/android/native_test:native_test_native_code__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_testing_android_native_test_native_test_native_code__testing",
     srcs: [
         "testing/android/native_test/native_test_jni_onload.cc",
@@ -17165,13 +20116,67 @@
         "cronet_aml_base_base__testing",
         "cronet_aml_base_base_static__testing",
         "cronet_aml_base_i18n__testing",
+        "cronet_aml_base_nodebug_assertion__testing",
         "cronet_aml_base_test_test_config__testing",
         "cronet_aml_base_test_test_support__testing",
         "cronet_aml_base_third_party_double_conversion_double_conversion__testing",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations__testing",
+        "cronet_aml_testing_android_native_test_native_test_support__testing",
         "cronet_aml_testing_gtest_gtest__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access__testing",
+        "cronet_aml_third_party_android_ndk_cpu_features__testing",
+        "cronet_aml_third_party_ashmem_ashmem__testing",
         "cronet_aml_third_party_boringssl_boringssl__testing",
+        "cronet_aml_third_party_boringssl_boringssl_asm__testing",
         "cronet_aml_third_party_ced_ced__testing",
+        "cronet_aml_third_party_googletest_gmock__testing",
+        "cronet_aml_third_party_googletest_gtest__testing",
         "cronet_aml_third_party_icu_icui18n__testing",
         "cronet_aml_third_party_icu_icuuc_private__testing",
         "cronet_aml_third_party_libevent_libevent__testing",
@@ -17180,12 +20185,6 @@
         "cronet_aml_third_party_libxml_xml_reader__testing",
         "cronet_aml_third_party_modp_b64_modp_b64__testing",
     ],
-    generated_headers: [
-        "cronet_aml_base_debugging_buildflags__testing",
-        "cronet_aml_base_logging_buildflags__testing",
-        "cronet_aml_build_chromeos_buildflags__testing",
-        "cronet_aml_testing_android_native_test_native_test_jni_headers__testing",
-    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -17224,6 +20223,27 @@
         "third_party/boringssl/src/include/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+        "-Wl,--script,external/cronet/base/android/library_loader/anchor_functions.lds",
+        "-Wl,-wrap,asprintf",
+        "-Wl,-wrap,calloc",
+        "-Wl,-wrap,free",
+        "-Wl,-wrap,getcwd",
+        "-Wl,-wrap,malloc",
+        "-Wl,-wrap,malloc_usable_size",
+        "-Wl,-wrap,memalign",
+        "-Wl,-wrap,posix_memalign",
+        "-Wl,-wrap,pvalloc",
+        "-Wl,-wrap,realloc",
+        "-Wl,-wrap,realpath",
+        "-Wl,-wrap,strdup",
+        "-Wl,-wrap,strndup",
+        "-Wl,-wrap,valloc",
+        "-Wl,-wrap,vasprintf",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -17252,7 +20272,7 @@
 }
 
 // GN: //testing/android/native_test:native_test_support__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_testing_android_native_test_native_test_support__testing",
     srcs: [
         "testing/android/native_test/main_runner.cc",
@@ -17269,13 +20289,66 @@
         "cronet_aml_base_base__testing",
         "cronet_aml_base_base_static__testing",
         "cronet_aml_base_i18n__testing",
+        "cronet_aml_base_nodebug_assertion__testing",
         "cronet_aml_base_test_test_config__testing",
         "cronet_aml_base_test_test_support__testing",
         "cronet_aml_base_third_party_double_conversion_double_conversion__testing",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations__testing",
         "cronet_aml_testing_gtest_gtest__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access__testing",
+        "cronet_aml_third_party_android_ndk_cpu_features__testing",
+        "cronet_aml_third_party_ashmem_ashmem__testing",
         "cronet_aml_third_party_boringssl_boringssl__testing",
+        "cronet_aml_third_party_boringssl_boringssl_asm__testing",
         "cronet_aml_third_party_ced_ced__testing",
+        "cronet_aml_third_party_googletest_gmock__testing",
+        "cronet_aml_third_party_googletest_gtest__testing",
         "cronet_aml_third_party_icu_icui18n__testing",
         "cronet_aml_third_party_icu_icuuc_private__testing",
         "cronet_aml_third_party_libevent_libevent__testing",
@@ -17290,6 +20363,12 @@
         "cronet_aml_build_chromeos_buildflags__testing",
         "cronet_aml_testing_android_native_test_native_test_jni_headers__testing",
     ],
+    export_generated_headers: [
+        "cronet_aml_base_debugging_buildflags__testing",
+        "cronet_aml_base_logging_buildflags__testing",
+        "cronet_aml_build_chromeos_buildflags__testing",
+        "cronet_aml_testing_android_native_test_native_test_jni_headers__testing",
+    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -17347,6 +20426,27 @@
         "third_party/icu/source/i18n/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+        "-Wl,--script,external/cronet/base/android/library_loader/anchor_functions.lds",
+        "-Wl,-wrap,asprintf",
+        "-Wl,-wrap,calloc",
+        "-Wl,-wrap,free",
+        "-Wl,-wrap,getcwd",
+        "-Wl,-wrap,malloc",
+        "-Wl,-wrap,malloc_usable_size",
+        "-Wl,-wrap,memalign",
+        "-Wl,-wrap,posix_memalign",
+        "-Wl,-wrap,pvalloc",
+        "-Wl,-wrap,realloc",
+        "-Wl,-wrap,realpath",
+        "-Wl,-wrap,strdup",
+        "-Wl,-wrap,strndup",
+        "-Wl,-wrap,valloc",
+        "-Wl,-wrap,vasprintf",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -17378,54 +20478,6 @@
 cc_library_static {
     name: "cronet_aml_testing_gtest_gtest__testing",
     srcs: [
-        ":cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_strerror__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_hash_city__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_hash_hash__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_distributions__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_randen__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_status_status__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_status_statusor__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_cord__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
-        ":cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access__testing",
-        ":cronet_aml_third_party_googletest_gtest__testing",
         "testing/gtest/empty.cc",
         "testing/multiprocess_func_list.cc",
     ],
@@ -17437,20 +20489,66 @@
         "cronet_aml_base_allocator_partition_allocator_partition_alloc__testing",
         "cronet_aml_base_base__testing",
         "cronet_aml_base_base_static__testing",
+        "cronet_aml_base_nodebug_assertion__testing",
         "cronet_aml_base_third_party_double_conversion_double_conversion__testing",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access__testing",
+        "cronet_aml_third_party_android_ndk_cpu_features__testing",
+        "cronet_aml_third_party_ashmem_ashmem__testing",
         "cronet_aml_third_party_boringssl_boringssl__testing",
+        "cronet_aml_third_party_boringssl_boringssl_asm__testing",
+        "cronet_aml_third_party_googletest_gtest__testing",
         "cronet_aml_third_party_icu_icui18n__testing",
         "cronet_aml_third_party_icu_icuuc_private__testing",
         "cronet_aml_third_party_libevent_libevent__testing",
         "cronet_aml_third_party_modp_b64_modp_b64__testing",
     ],
-    generated_headers: [
-        "cronet_aml_build_chromeos_buildflags__testing",
-    ],
-    export_generated_headers: [
-        "cronet_aml_build_chromeos_buildflags__testing",
-    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -17545,7 +20643,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/base:base
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_base_base",
     srcs: [
         "third_party/abseil-cpp/absl/base/internal/cycleclock.cc",
@@ -17554,6 +20652,11 @@
         "third_party/abseil-cpp/absl/base/internal/thread_identity.cc",
         "third_party/abseil-cpp/absl/base/internal/unscaledcycleclock.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -17589,6 +20692,11 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -17617,7 +20725,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/base:base__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
     srcs: [
         "third_party/abseil-cpp/absl/base/internal/cycleclock.cc",
@@ -17626,6 +20734,11 @@
         "third_party/abseil-cpp/absl/base/internal/thread_identity.cc",
         "third_party/abseil-cpp/absl/base/internal/unscaledcycleclock.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+    ],
     host_supported: true,
     defaults: [
         "cronet_aml_defaults",
@@ -17657,6 +20770,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
         "third_party/abseil-cpp/",
     ],
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -17716,7 +20834,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/base:log_severity
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
     srcs: [
         "third_party/abseil-cpp/absl/base/log_severity.cc",
@@ -17756,6 +20874,11 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -17784,7 +20907,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/base:log_severity__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
     srcs: [
         "third_party/abseil-cpp/absl/base/log_severity.cc",
@@ -17820,6 +20943,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
         "third_party/abseil-cpp/",
     ],
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -17879,11 +21007,17 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/base:malloc_internal
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
     srcs: [
         "third_party/abseil-cpp/absl/base/internal/low_level_alloc.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -17919,6 +21053,11 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -17947,11 +21086,17 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/base:malloc_internal__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
     srcs: [
         "third_party/abseil-cpp/absl/base/internal/low_level_alloc.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+    ],
     host_supported: true,
     defaults: [
         "cronet_aml_defaults",
@@ -17983,6 +21128,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
         "third_party/abseil-cpp/",
     ],
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -18042,11 +21192,14 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/base:raw_logging_internal
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
     srcs: [
         "third_party/abseil-cpp/absl/base/internal/raw_logging.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -18082,6 +21235,11 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -18110,11 +21268,14 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/base:raw_logging_internal__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
     srcs: [
         "third_party/abseil-cpp/absl/base/internal/raw_logging.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+    ],
     host_supported: true,
     defaults: [
         "cronet_aml_defaults",
@@ -18146,6 +21307,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
         "third_party/abseil-cpp/",
     ],
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -18205,7 +21371,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/base:spinlock_wait
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
     srcs: [
         "third_party/abseil-cpp/absl/base/internal/spinlock_wait.cc",
@@ -18245,6 +21411,11 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -18273,7 +21444,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/base:spinlock_wait__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
     srcs: [
         "third_party/abseil-cpp/absl/base/internal/spinlock_wait.cc",
@@ -18309,6 +21480,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
         "third_party/abseil-cpp/",
     ],
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -18368,7 +21544,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/base:strerror
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_base_strerror",
     srcs: [
         "third_party/abseil-cpp/absl/base/internal/strerror.cc",
@@ -18408,6 +21584,11 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -18436,7 +21617,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/base:strerror__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_base_strerror__testing",
     srcs: [
         "third_party/abseil-cpp/absl/base/internal/strerror.cc",
@@ -18472,6 +21653,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
         "third_party/abseil-cpp/",
     ],
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -18531,11 +21717,15 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/base:throw_delegate
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
     srcs: [
         "third_party/abseil-cpp/absl/base/internal/throw_delegate.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -18571,6 +21761,11 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -18599,11 +21794,15 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/base:throw_delegate__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
     srcs: [
         "third_party/abseil-cpp/absl/base/internal/throw_delegate.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+    ],
     host_supported: true,
     defaults: [
         "cronet_aml_defaults",
@@ -18635,6 +21834,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
         "third_party/abseil-cpp/",
     ],
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -18694,12 +21898,33 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/container:hashtablez_sampler
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler",
     srcs: [
         "third_party/abseil-cpp/absl/container/internal/hashtablez_sampler.cc",
         "third_party/abseil-cpp/absl/container/internal/hashtablez_sampler_force_weak_definition.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time",
+    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -18735,6 +21960,11 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -18763,12 +21993,33 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/container:hashtablez_sampler__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler__testing",
     srcs: [
         "third_party/abseil-cpp/absl/container/internal/hashtablez_sampler.cc",
         "third_party/abseil-cpp/absl/container/internal/hashtablez_sampler_force_weak_definition.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+    ],
     host_supported: true,
     defaults: [
         "cronet_aml_defaults",
@@ -18800,6 +22051,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
         "third_party/abseil-cpp/",
     ],
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -18859,11 +22115,34 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/container:raw_hash_set
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set",
     srcs: [
         "third_party/abseil-cpp/absl/container/internal/raw_hash_set.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
+    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -18899,6 +22178,11 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -18927,11 +22211,34 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/container:raw_hash_set__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set__testing",
     srcs: [
         "third_party/abseil-cpp/absl/container/internal/raw_hash_set.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+    ],
     host_supported: true,
     defaults: [
         "cronet_aml_defaults",
@@ -18963,6 +22270,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
         "third_party/abseil-cpp/",
     ],
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -19022,13 +22334,17 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/debugging:debugging_internal
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
     srcs: [
         "third_party/abseil-cpp/absl/debugging/internal/address_is_readable.cc",
         "third_party/abseil-cpp/absl/debugging/internal/elf_mem_image.cc",
         "third_party/abseil-cpp/absl/debugging/internal/vdso_support.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -19064,6 +22380,11 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -19092,13 +22413,17 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/debugging:debugging_internal__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
     srcs: [
         "third_party/abseil-cpp/absl/debugging/internal/address_is_readable.cc",
         "third_party/abseil-cpp/absl/debugging/internal/elf_mem_image.cc",
         "third_party/abseil-cpp/absl/debugging/internal/vdso_support.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+    ],
     host_supported: true,
     defaults: [
         "cronet_aml_defaults",
@@ -19130,6 +22455,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
         "third_party/abseil-cpp/",
     ],
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -19189,11 +22519,17 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/debugging:demangle_internal
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
     srcs: [
         "third_party/abseil-cpp/absl/debugging/internal/demangle.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -19229,6 +22565,11 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -19257,11 +22598,17 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/debugging:demangle_internal__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
     srcs: [
         "third_party/abseil-cpp/absl/debugging/internal/demangle.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+    ],
     host_supported: true,
     defaults: [
         "cronet_aml_defaults",
@@ -19293,6 +22640,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
         "third_party/abseil-cpp/",
     ],
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -19352,11 +22704,26 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/debugging:examine_stack
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack",
     srcs: [
         "third_party/abseil-cpp/absl/debugging/internal/examine_stack.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -19392,6 +22759,11 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -19420,11 +22792,26 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/debugging:examine_stack__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack__testing",
     srcs: [
         "third_party/abseil-cpp/absl/debugging/internal/examine_stack.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+    ],
     host_supported: true,
     defaults: [
         "cronet_aml_defaults",
@@ -19456,6 +22843,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
         "third_party/abseil-cpp/",
     ],
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -19515,11 +22907,27 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/debugging:failure_signal_handler
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler",
     srcs: [
         "third_party/abseil-cpp/absl/debugging/failure_signal_handler.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -19555,6 +22963,11 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -19583,11 +22996,27 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/debugging:failure_signal_handler__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler__testing",
     srcs: [
         "third_party/abseil-cpp/absl/debugging/failure_signal_handler.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+    ],
     host_supported: true,
     defaults: [
         "cronet_aml_defaults",
@@ -19619,6 +23048,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
         "third_party/abseil-cpp/",
     ],
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -19678,11 +23112,16 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/debugging:stacktrace
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
     srcs: [
         "third_party/abseil-cpp/absl/debugging/stacktrace.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -19718,6 +23157,11 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -19746,11 +23190,16 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/debugging:stacktrace__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
     srcs: [
         "third_party/abseil-cpp/absl/debugging/stacktrace.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+    ],
     host_supported: true,
     defaults: [
         "cronet_aml_defaults",
@@ -19782,6 +23231,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
         "third_party/abseil-cpp/",
     ],
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -19841,11 +23295,24 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/debugging:symbolize
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
     srcs: [
         "third_party/abseil-cpp/absl/debugging/symbolize.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -19881,6 +23348,11 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -19909,11 +23381,24 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/debugging:symbolize__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
     srcs: [
         "third_party/abseil-cpp/absl/debugging/symbolize.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+    ],
     host_supported: true,
     defaults: [
         "cronet_aml_defaults",
@@ -19945,6 +23430,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
         "third_party/abseil-cpp/",
     ],
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -20004,11 +23494,17 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/hash:city
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_hash_city",
     srcs: [
         "third_party/abseil-cpp/absl/hash/internal/city.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -20044,6 +23540,11 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -20072,11 +23573,17 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/hash:city__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_hash_city__testing",
     srcs: [
         "third_party/abseil-cpp/absl/hash/internal/city.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+    ],
     host_supported: true,
     defaults: [
         "cronet_aml_defaults",
@@ -20108,6 +23615,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
         "third_party/abseil-cpp/",
     ],
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -20167,11 +23679,25 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/hash:hash
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_hash_hash",
     srcs: [
         "third_party/abseil-cpp/absl/hash/internal/hash.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access",
+    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -20207,6 +23733,11 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -20235,11 +23766,25 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/hash:hash__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_hash_hash__testing",
     srcs: [
         "third_party/abseil-cpp/absl/hash/internal/hash.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access__testing",
+    ],
     host_supported: true,
     defaults: [
         "cronet_aml_defaults",
@@ -20271,6 +23816,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
         "third_party/abseil-cpp/",
     ],
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -20330,11 +23880,18 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/hash:low_level_hash
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash",
     srcs: [
         "third_party/abseil-cpp/absl/hash/internal/low_level_hash.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -20370,6 +23927,11 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -20398,11 +23960,18 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/hash:low_level_hash__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash__testing",
     srcs: [
         "third_party/abseil-cpp/absl/hash/internal/low_level_hash.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+    ],
     host_supported: true,
     defaults: [
         "cronet_aml_defaults",
@@ -20434,6 +24003,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
         "third_party/abseil-cpp/",
     ],
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -20493,7 +24067,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/numeric:int128
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
     srcs: [
         "third_party/abseil-cpp/absl/numeric/int128.cc",
@@ -20533,6 +24107,11 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -20561,7 +24140,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/numeric:int128__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
     srcs: [
         "third_party/abseil-cpp/absl/numeric/int128.cc",
@@ -20597,6 +24176,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
         "third_party/abseil-cpp/",
     ],
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -20656,7 +24240,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/profiling:exponential_biased
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
     srcs: [
         "third_party/abseil-cpp/absl/profiling/internal/exponential_biased.cc",
@@ -20696,6 +24280,11 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -20724,7 +24313,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/profiling:exponential_biased__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
     srcs: [
         "third_party/abseil-cpp/absl/profiling/internal/exponential_biased.cc",
@@ -20760,6 +24349,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
         "third_party/abseil-cpp/",
     ],
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -20819,12 +24413,22 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/random:distributions
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_random_distributions",
     srcs: [
         "third_party/abseil-cpp/absl/random/discrete_distribution.cc",
         "third_party/abseil-cpp/absl/random/gaussian_distribution.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -20860,6 +24464,11 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -20888,12 +24497,22 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/random:distributions__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_random_distributions__testing",
     srcs: [
         "third_party/abseil-cpp/absl/random/discrete_distribution.cc",
         "third_party/abseil-cpp/absl/random/gaussian_distribution.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+    ],
     host_supported: true,
     defaults: [
         "cronet_aml_defaults",
@@ -20925,6 +24544,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
         "third_party/abseil-cpp/",
     ],
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -20984,7 +24608,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/random/internal:platform
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
     srcs: [
         "third_party/abseil-cpp/absl/random/internal/randen_round_keys.cc",
@@ -20992,6 +24616,9 @@
     generated_headers: [
         "cronet_aml_build_chromeos_buildflags",
     ],
+    export_generated_headers: [
+        "cronet_aml_build_chromeos_buildflags",
+    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -21027,6 +24654,11 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -21055,7 +24687,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/random/internal:platform__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
     srcs: [
         "third_party/abseil-cpp/absl/random/internal/randen_round_keys.cc",
@@ -21064,6 +24696,9 @@
     generated_headers: [
         "cronet_aml_build_chromeos_buildflags__testing",
     ],
+    export_generated_headers: [
+        "cronet_aml_build_chromeos_buildflags__testing",
+    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -21094,6 +24729,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
         "third_party/abseil-cpp/",
     ],
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -21153,13 +24793,28 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/random/internal:pool_urbg
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg",
     srcs: [
         "third_party/abseil-cpp/absl/random/internal/pool_urbg.cc",
     ],
-    generated_headers: [
-        "cronet_aml_build_chromeos_buildflags",
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
     ],
     defaults: [
         "cronet_aml_defaults",
@@ -21196,6 +24851,11 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -21224,15 +24884,30 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/random/internal:pool_urbg__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg__testing",
     srcs: [
         "third_party/abseil-cpp/absl/random/internal/pool_urbg.cc",
     ],
-    host_supported: true,
-    generated_headers: [
-        "cronet_aml_build_chromeos_buildflags__testing",
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
     ],
+    host_supported: true,
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -21263,6 +24938,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
         "third_party/abseil-cpp/",
     ],
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -21322,13 +25002,21 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/random/internal:randen
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen",
     srcs: [
         "third_party/abseil-cpp/absl/random/internal/randen.cc",
     ],
-    generated_headers: [
-        "cronet_aml_build_chromeos_buildflags",
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow",
     ],
     defaults: [
         "cronet_aml_defaults",
@@ -21365,6 +25053,11 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -21393,15 +25086,23 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/random/internal:randen__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen__testing",
     srcs: [
         "third_party/abseil-cpp/absl/random/internal/randen.cc",
     ],
-    host_supported: true,
-    generated_headers: [
-        "cronet_aml_build_chromeos_buildflags__testing",
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
     ],
+    host_supported: true,
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -21432,6 +25133,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
         "third_party/abseil-cpp/",
     ],
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -21491,13 +25197,15 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/random/internal:randen_hwaes
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes",
     srcs: [
         "third_party/abseil-cpp/absl/random/internal/randen_detect.cc",
     ],
-    generated_headers: [
-        "cronet_aml_build_chromeos_buildflags",
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl",
     ],
     defaults: [
         "cronet_aml_defaults",
@@ -21534,6 +25242,11 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -21562,15 +25275,17 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/random/internal:randen_hwaes__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
     srcs: [
         "third_party/abseil-cpp/absl/random/internal/randen_detect.cc",
     ],
-    host_supported: true,
-    generated_headers: [
-        "cronet_aml_build_chromeos_buildflags__testing",
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
     ],
+    host_supported: true,
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -21601,6 +25316,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
         "third_party/abseil-cpp/",
     ],
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -21660,13 +25380,14 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/random/internal:randen_hwaes_impl
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl",
     srcs: [
         "third_party/abseil-cpp/absl/random/internal/randen_hwaes.cc",
     ],
-    generated_headers: [
-        "cronet_aml_build_chromeos_buildflags",
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
     ],
     defaults: [
         "cronet_aml_defaults",
@@ -21703,6 +25424,11 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -21731,15 +25457,16 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/random/internal:randen_hwaes_impl__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
     srcs: [
         "third_party/abseil-cpp/absl/random/internal/randen_hwaes.cc",
     ],
-    host_supported: true,
-    generated_headers: [
-        "cronet_aml_build_chromeos_buildflags__testing",
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
     ],
+    host_supported: true,
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -21770,6 +25497,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
         "third_party/abseil-cpp/",
     ],
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -21829,13 +25561,18 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/random/internal:randen_slow
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow",
     srcs: [
         "third_party/abseil-cpp/absl/random/internal/randen_slow.cc",
     ],
-    generated_headers: [
-        "cronet_aml_build_chromeos_buildflags",
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
     ],
     defaults: [
         "cronet_aml_defaults",
@@ -21872,6 +25609,11 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -21900,15 +25642,20 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/random/internal:randen_slow__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
     srcs: [
         "third_party/abseil-cpp/absl/random/internal/randen_slow.cc",
     ],
-    host_supported: true,
-    generated_headers: [
-        "cronet_aml_build_chromeos_buildflags__testing",
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
     ],
+    host_supported: true,
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -21939,6 +25686,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
         "third_party/abseil-cpp/",
     ],
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -21998,11 +25750,22 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/random/internal:seed_material
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material",
     srcs: [
         "third_party/abseil-cpp/absl/random/internal/seed_material.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
+    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -22038,6 +25801,11 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -22066,11 +25834,22 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/random/internal:seed_material__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material__testing",
     srcs: [
         "third_party/abseil-cpp/absl/random/internal/seed_material.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+    ],
     host_supported: true,
     defaults: [
         "cronet_aml_defaults",
@@ -22102,6 +25881,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
         "third_party/abseil-cpp/",
     ],
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -22161,7 +25945,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/random:seed_gen_exception
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception",
     srcs: [
         "third_party/abseil-cpp/absl/random/seed_gen_exception.cc",
@@ -22201,6 +25985,11 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -22229,7 +26018,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/random:seed_gen_exception__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception__testing",
     srcs: [
         "third_party/abseil-cpp/absl/random/seed_gen_exception.cc",
@@ -22265,6 +26054,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
         "third_party/abseil-cpp/",
     ],
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -22324,13 +26118,29 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/random:seed_sequences
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences",
     srcs: [
         "third_party/abseil-cpp/absl/random/seed_sequences.cc",
     ],
-    generated_headers: [
-        "cronet_aml_build_chromeos_buildflags",
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
     ],
     defaults: [
         "cronet_aml_defaults",
@@ -22367,6 +26177,11 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -22395,15 +26210,31 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/random:seed_sequences__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences__testing",
     srcs: [
         "third_party/abseil-cpp/absl/random/seed_sequences.cc",
     ],
-    host_supported: true,
-    generated_headers: [
-        "cronet_aml_build_chromeos_buildflags__testing",
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
     ],
+    host_supported: true,
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -22434,6 +26265,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
         "third_party/abseil-cpp/",
     ],
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -22493,12 +26329,41 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/status:status
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_status_status",
     srcs: [
         "third_party/abseil-cpp/absl/status/status.cc",
         "third_party/abseil-cpp/absl/status/status_payload_printer.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
+    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -22534,6 +26399,11 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -22562,12 +26432,41 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/status:status__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_status_status__testing",
     srcs: [
         "third_party/abseil-cpp/absl/status/status.cc",
         "third_party/abseil-cpp/absl/status/status_payload_printer.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+    ],
     host_supported: true,
     defaults: [
         "cronet_aml_defaults",
@@ -22599,6 +26498,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
         "third_party/abseil-cpp/",
     ],
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -22658,11 +26562,42 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/status:statusor
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_status_statusor",
     srcs: [
         "third_party/abseil-cpp/absl/status/statusor.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access",
+    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -22698,6 +26633,11 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -22726,11 +26666,42 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/status:statusor__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_status_statusor__testing",
     srcs: [
         "third_party/abseil-cpp/absl/status/statusor.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access__testing",
+    ],
     host_supported: true,
     defaults: [
         "cronet_aml_defaults",
@@ -22762,6 +26733,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
         "third_party/abseil-cpp/",
     ],
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -22821,13 +26797,40 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/strings:cord
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_strings_cord",
     srcs: [
         "third_party/abseil-cpp/absl/strings/cord.cc",
         "third_party/abseil-cpp/absl/strings/cord_analysis.cc",
         "third_party/abseil-cpp/absl/strings/cord_buffer.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
+    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -22863,6 +26866,11 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -22891,13 +26899,40 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/strings:cord__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_strings_cord__testing",
     srcs: [
         "third_party/abseil-cpp/absl/strings/cord.cc",
         "third_party/abseil-cpp/absl/strings/cord_analysis.cc",
         "third_party/abseil-cpp/absl/strings/cord_buffer.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+    ],
     host_supported: true,
     defaults: [
         "cronet_aml_defaults",
@@ -22929,6 +26964,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
         "third_party/abseil-cpp/",
     ],
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -22988,7 +27028,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/strings:cord_internal
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal",
     srcs: [
         "third_party/abseil-cpp/absl/strings/internal/cord_internal.cc",
@@ -22999,6 +27039,16 @@
         "third_party/abseil-cpp/absl/strings/internal/cord_rep_crc.cc",
         "third_party/abseil-cpp/absl/strings/internal/cord_rep_ring.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -23034,6 +27084,11 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -23062,7 +27117,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/strings:cord_internal__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
     srcs: [
         "third_party/abseil-cpp/absl/strings/internal/cord_internal.cc",
@@ -23073,6 +27128,16 @@
         "third_party/abseil-cpp/absl/strings/internal/cord_rep_crc.cc",
         "third_party/abseil-cpp/absl/strings/internal/cord_rep_ring.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+    ],
     host_supported: true,
     defaults: [
         "cronet_aml_defaults",
@@ -23104,6 +27169,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
         "third_party/abseil-cpp/",
     ],
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -23163,11 +27233,16 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/strings:cordz_functions
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions",
     srcs: [
         "third_party/abseil-cpp/absl/strings/internal/cordz_functions.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
+    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -23203,6 +27278,11 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -23231,11 +27311,16 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/strings:cordz_functions__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
     srcs: [
         "third_party/abseil-cpp/absl/strings/internal/cordz_functions.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
+    ],
     host_supported: true,
     defaults: [
         "cronet_aml_defaults",
@@ -23267,6 +27352,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
         "third_party/abseil-cpp/",
     ],
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -23326,11 +27416,31 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/strings:cordz_handle
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle",
     srcs: [
         "third_party/abseil-cpp/absl/strings/internal/cordz_handle.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time",
+    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -23366,6 +27476,11 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -23394,11 +27509,31 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/strings:cordz_handle__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
     srcs: [
         "third_party/abseil-cpp/absl/strings/internal/cordz_handle.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+    ],
     host_supported: true,
     defaults: [
         "cronet_aml_defaults",
@@ -23430,6 +27565,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
         "third_party/abseil-cpp/",
     ],
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -23489,11 +27629,35 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/strings:cordz_info
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info",
     srcs: [
         "third_party/abseil-cpp/absl/strings/internal/cordz_info.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time",
+    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -23529,6 +27693,11 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -23557,11 +27726,35 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/strings:cordz_info__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info__testing",
     srcs: [
         "third_party/abseil-cpp/absl/strings/internal/cordz_info.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+    ],
     host_supported: true,
     defaults: [
         "cronet_aml_defaults",
@@ -23593,6 +27786,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
         "third_party/abseil-cpp/",
     ],
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -23652,13 +27850,19 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/strings:internal
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
     srcs: [
         "third_party/abseil-cpp/absl/strings/internal/escaping.cc",
         "third_party/abseil-cpp/absl/strings/internal/ostringstream.cc",
         "third_party/abseil-cpp/absl/strings/internal/utf8.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -23694,6 +27898,11 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -23722,13 +27931,19 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/strings:internal__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
     srcs: [
         "third_party/abseil-cpp/absl/strings/internal/escaping.cc",
         "third_party/abseil-cpp/absl/strings/internal/ostringstream.cc",
         "third_party/abseil-cpp/absl/strings/internal/utf8.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+    ],
     host_supported: true,
     defaults: [
         "cronet_aml_defaults",
@@ -23760,6 +27975,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
         "third_party/abseil-cpp/",
     ],
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -23819,7 +28039,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/strings:str_format_internal
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal",
     srcs: [
         "third_party/abseil-cpp/absl/strings/internal/str_format/arg.cc",
@@ -23829,6 +28049,17 @@
         "third_party/abseil-cpp/absl/strings/internal/str_format/output.cc",
         "third_party/abseil-cpp/absl/strings/internal/str_format/parser.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
+    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -23864,6 +28095,11 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -23892,7 +28128,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/strings:str_format_internal__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal__testing",
     srcs: [
         "third_party/abseil-cpp/absl/strings/internal/str_format/arg.cc",
@@ -23902,6 +28138,17 @@
         "third_party/abseil-cpp/absl/strings/internal/str_format/output.cc",
         "third_party/abseil-cpp/absl/strings/internal/str_format/parser.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+    ],
     host_supported: true,
     defaults: [
         "cronet_aml_defaults",
@@ -23933,6 +28180,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
         "third_party/abseil-cpp/",
     ],
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -23992,7 +28244,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/strings:strings
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
     srcs: [
         "third_party/abseil-cpp/absl/strings/ascii.cc",
@@ -24009,6 +28261,15 @@
         "third_party/abseil-cpp/absl/strings/string_view.cc",
         "third_party/abseil-cpp/absl/strings/substitute.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -24044,6 +28305,11 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -24072,7 +28338,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/strings:strings__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
     srcs: [
         "third_party/abseil-cpp/absl/strings/ascii.cc",
@@ -24089,6 +28355,15 @@
         "third_party/abseil-cpp/absl/strings/string_view.cc",
         "third_party/abseil-cpp/absl/strings/substitute.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+    ],
     host_supported: true,
     defaults: [
         "cronet_aml_defaults",
@@ -24120,6 +28395,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
         "third_party/abseil-cpp/",
     ],
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -24179,11 +28459,18 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/synchronization:graphcycles_internal
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
     srcs: [
         "third_party/abseil-cpp/absl/synchronization/internal/graphcycles.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -24219,6 +28506,11 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -24247,11 +28539,18 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/synchronization:graphcycles_internal__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
     srcs: [
         "third_party/abseil-cpp/absl/synchronization/internal/graphcycles.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+    ],
     host_supported: true,
     defaults: [
         "cronet_aml_defaults",
@@ -24283,6 +28582,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
         "third_party/abseil-cpp/",
     ],
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -24342,7 +28646,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/synchronization:synchronization
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
     srcs: [
         "third_party/abseil-cpp/absl/synchronization/barrier.cc",
@@ -24353,6 +28657,25 @@
         "third_party/abseil-cpp/absl/synchronization/mutex.cc",
         "third_party/abseil-cpp/absl/synchronization/notification.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time",
+    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -24388,6 +28711,11 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -24416,7 +28744,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/synchronization:synchronization__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
     srcs: [
         "third_party/abseil-cpp/absl/synchronization/barrier.cc",
@@ -24427,6 +28755,25 @@
         "third_party/abseil-cpp/absl/synchronization/mutex.cc",
         "third_party/abseil-cpp/absl/synchronization/notification.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+    ],
     host_supported: true,
     defaults: [
         "cronet_aml_defaults",
@@ -24458,6 +28805,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
         "third_party/abseil-cpp/",
     ],
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -24517,7 +28869,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/time/internal/cctz:civil_time
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
     srcs: [
         "third_party/abseil-cpp/absl/time/internal/cctz/src/civil_time_detail.cc",
@@ -24557,6 +28909,11 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -24585,7 +28942,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/time/internal/cctz:civil_time__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
     srcs: [
         "third_party/abseil-cpp/absl/time/internal/cctz/src/civil_time_detail.cc",
@@ -24621,6 +28978,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
         "third_party/abseil-cpp/",
     ],
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -24680,7 +29042,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/time/internal/cctz:time_zone
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
     srcs: [
         "third_party/abseil-cpp/absl/time/internal/cctz/src/time_zone_fixed.cc",
@@ -24693,6 +29055,9 @@
         "third_party/abseil-cpp/absl/time/internal/cctz/src/time_zone_posix.cc",
         "third_party/abseil-cpp/absl/time/internal/cctz/src/zone_info_source.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -24728,6 +29093,11 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -24756,7 +29126,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/time/internal/cctz:time_zone__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
     srcs: [
         "third_party/abseil-cpp/absl/time/internal/cctz/src/time_zone_fixed.cc",
@@ -24769,6 +29139,9 @@
         "third_party/abseil-cpp/absl/time/internal/cctz/src/time_zone_posix.cc",
         "third_party/abseil-cpp/absl/time/internal/cctz/src/zone_info_source.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+    ],
     host_supported: true,
     defaults: [
         "cronet_aml_defaults",
@@ -24800,6 +29173,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
         "third_party/abseil-cpp/",
     ],
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -24859,7 +29237,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/time:time
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_time_time",
     srcs: [
         "third_party/abseil-cpp/absl/time/civil_time.cc",
@@ -24868,6 +29246,18 @@
         "third_party/abseil-cpp/absl/time/format.cc",
         "third_party/abseil-cpp/absl/time/time.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -24903,6 +29293,11 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -24931,7 +29326,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/time:time__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
     srcs: [
         "third_party/abseil-cpp/absl/time/civil_time.cc",
@@ -24940,6 +29335,18 @@
         "third_party/abseil-cpp/absl/time/format.cc",
         "third_party/abseil-cpp/absl/time/time.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+    ],
     host_supported: true,
     defaults: [
         "cronet_aml_defaults",
@@ -24971,6 +29378,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
         "third_party/abseil-cpp/",
     ],
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -25030,11 +29442,15 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/types:bad_optional_access
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
     srcs: [
         "third_party/abseil-cpp/absl/types/bad_optional_access.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -25070,6 +29486,11 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -25098,11 +29519,15 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/types:bad_optional_access__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
     srcs: [
         "third_party/abseil-cpp/absl/types/bad_optional_access.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+    ],
     host_supported: true,
     defaults: [
         "cronet_aml_defaults",
@@ -25134,6 +29559,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
         "third_party/abseil-cpp/",
     ],
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -25193,11 +29623,15 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/types:bad_variant_access
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access",
     srcs: [
         "third_party/abseil-cpp/absl/types/bad_variant_access.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -25233,6 +29667,11 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -25261,11 +29700,15 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/types:bad_variant_access__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access__testing",
     srcs: [
         "third_party/abseil-cpp/absl/types/bad_variant_access.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+    ],
     host_supported: true,
     defaults: [
         "cronet_aml_defaults",
@@ -25297,6 +29740,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
         "third_party/abseil-cpp/",
     ],
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -25356,7 +29804,7 @@
 }
 
 // GN: //third_party/android_ndk:cpu_features
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_android_ndk_cpu_features",
     srcs: [
         "third_party/android_ndk/sources/android/cpufeatures/cpu-features.c",
@@ -25395,6 +29843,11 @@
         "third_party/android_ndk/sources/android/cpufeatures/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -25423,7 +29876,7 @@
 }
 
 // GN: //third_party/android_ndk:cpu_features__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_android_ndk_cpu_features__testing",
     srcs: [
         "third_party/android_ndk/sources/android/cpufeatures/cpu-features.c",
@@ -25462,6 +29915,11 @@
         "third_party/android_ndk/sources/android/cpufeatures/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -25490,7 +29948,7 @@
 }
 
 // GN: //third_party/ashmem:ashmem
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_ashmem_ashmem",
     srcs: [
         "third_party/ashmem/ashmem-dev.c",
@@ -25531,6 +29989,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -25559,7 +30022,7 @@
 }
 
 // GN: //third_party/ashmem:ashmem__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_ashmem_ashmem__testing",
     srcs: [
         "third_party/ashmem/ashmem-dev.c",
@@ -25600,6 +30063,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -25631,7 +30099,6 @@
 cc_library_static {
     name: "cronet_aml_third_party_boringssl_boringssl",
     srcs: [
-        ":cronet_aml_third_party_boringssl_boringssl_asm",
         "third_party/boringssl/err_data.c",
         "third_party/boringssl/src/crypto/asn1/a_bitstr.c",
         "third_party/boringssl/src/crypto/asn1/a_bool.c",
@@ -25899,6 +30366,9 @@
         "third_party/boringssl/src/ssl/tls_method.cc",
         "third_party/boringssl/src/ssl/tls_record.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_boringssl_boringssl_asm",
+    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -25973,7 +30443,6 @@
 cc_library_static {
     name: "cronet_aml_third_party_boringssl_boringssl__testing",
     srcs: [
-        ":cronet_aml_third_party_boringssl_boringssl_asm__testing",
         "third_party/boringssl/err_data.c",
         "third_party/boringssl/src/crypto/asn1/a_bitstr.c",
         "third_party/boringssl/src/crypto/asn1/a_bool.c",
@@ -26241,6 +30710,9 @@
         "third_party/boringssl/src/ssl/tls_method.cc",
         "third_party/boringssl/src/ssl/tls_record.cc",
     ],
+    static_libs: [
+        "cronet_aml_third_party_boringssl_boringssl_asm__testing",
+    ],
     host_supported: true,
     defaults: [
         "cronet_aml_defaults",
@@ -26339,7 +30811,7 @@
 }
 
 // GN: //third_party/boringssl:boringssl_asm
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_boringssl_boringssl_asm",
     defaults: [
         "cronet_aml_defaults",
@@ -26378,6 +30850,11 @@
         "third_party/boringssl/src/include/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             srcs: [
@@ -26473,7 +30950,7 @@
 }
 
 // GN: //third_party/boringssl:boringssl_asm__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_boringssl_boringssl_asm__testing",
     host_supported: true,
     defaults: [
@@ -26508,6 +30985,11 @@
         "buildtools/third_party/libc++abi/trunk/include",
         "third_party/boringssl/src/include/",
     ],
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+    ],
     target: {
         android_arm: {
             srcs: [
@@ -27049,7 +31531,7 @@
 }
 
 // GN: //third_party/googletest:gmock__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_googletest_gmock__testing",
     srcs: [
         "third_party/googletest/src/googlemock/src/gmock-cardinalities.cc",
@@ -27066,17 +31548,66 @@
         "cronet_aml_base_allocator_partition_allocator_partition_alloc__testing",
         "cronet_aml_base_base__testing",
         "cronet_aml_base_base_static__testing",
+        "cronet_aml_base_nodebug_assertion__testing",
         "cronet_aml_base_third_party_double_conversion_double_conversion__testing",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access__testing",
+        "cronet_aml_third_party_android_ndk_cpu_features__testing",
+        "cronet_aml_third_party_ashmem_ashmem__testing",
         "cronet_aml_third_party_boringssl_boringssl__testing",
+        "cronet_aml_third_party_boringssl_boringssl_asm__testing",
+        "cronet_aml_third_party_googletest_gtest__testing",
         "cronet_aml_third_party_icu_icui18n__testing",
         "cronet_aml_third_party_icu_icuuc_private__testing",
         "cronet_aml_third_party_libevent_libevent__testing",
         "cronet_aml_third_party_modp_b64_modp_b64__testing",
     ],
-    generated_headers: [
-        "cronet_aml_build_chromeos_buildflags__testing",
-    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -27122,6 +31653,27 @@
         "third_party/googletest/src/googletest/include/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+        "-Wl,--script,external/cronet/base/android/library_loader/anchor_functions.lds",
+        "-Wl,-wrap,asprintf",
+        "-Wl,-wrap,calloc",
+        "-Wl,-wrap,free",
+        "-Wl,-wrap,getcwd",
+        "-Wl,-wrap,malloc",
+        "-Wl,-wrap,malloc_usable_size",
+        "-Wl,-wrap,memalign",
+        "-Wl,-wrap,posix_memalign",
+        "-Wl,-wrap,pvalloc",
+        "-Wl,-wrap,realloc",
+        "-Wl,-wrap,realpath",
+        "-Wl,-wrap,strdup",
+        "-Wl,-wrap,strndup",
+        "-Wl,-wrap,valloc",
+        "-Wl,-wrap,vasprintf",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -27150,7 +31702,7 @@
 }
 
 // GN: //third_party/googletest:gtest__testing
-cc_object {
+cc_library_static {
     name: "cronet_aml_third_party_googletest_gtest__testing",
     srcs: [
         "third_party/googletest/custom/gtest/internal/custom/chrome_custom_temp_dir.cc",
@@ -27173,17 +31725,65 @@
         "cronet_aml_base_allocator_partition_allocator_partition_alloc__testing",
         "cronet_aml_base_base__testing",
         "cronet_aml_base_base_static__testing",
+        "cronet_aml_base_nodebug_assertion__testing",
         "cronet_aml_base_third_party_double_conversion_double_conversion__testing",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access__testing",
+        "cronet_aml_third_party_android_ndk_cpu_features__testing",
+        "cronet_aml_third_party_ashmem_ashmem__testing",
         "cronet_aml_third_party_boringssl_boringssl__testing",
+        "cronet_aml_third_party_boringssl_boringssl_asm__testing",
         "cronet_aml_third_party_icu_icui18n__testing",
         "cronet_aml_third_party_icu_icuuc_private__testing",
         "cronet_aml_third_party_libevent_libevent__testing",
         "cronet_aml_third_party_modp_b64_modp_b64__testing",
     ],
-    generated_headers: [
-        "cronet_aml_build_chromeos_buildflags__testing",
-    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -27227,6 +31827,27 @@
         "third_party/googletest/src/googletest/include/",
     ],
     cpp_std: "c++17",
+    ldflags: [
+        "-Wl,--as-needed",
+        "-Wl,--gc-sections",
+        "-Wl,--icf=all",
+        "-Wl,--script,external/cronet/base/android/library_loader/anchor_functions.lds",
+        "-Wl,-wrap,asprintf",
+        "-Wl,-wrap,calloc",
+        "-Wl,-wrap,free",
+        "-Wl,-wrap,getcwd",
+        "-Wl,-wrap,malloc",
+        "-Wl,-wrap,malloc_usable_size",
+        "-Wl,-wrap,memalign",
+        "-Wl,-wrap,posix_memalign",
+        "-Wl,-wrap,pvalloc",
+        "-Wl,-wrap,realloc",
+        "-Wl,-wrap,realpath",
+        "-Wl,-wrap,strdup",
+        "-Wl,-wrap,strndup",
+        "-Wl,-wrap,valloc",
+        "-Wl,-wrap,vasprintf",
+    ],
     target: {
         android_arm: {
             cflags: [
@@ -29879,14 +34500,14 @@
 cc_binary {
     name: "cronet_aml_third_party_protobuf_protoc",
     srcs: [
-        ":cronet_aml_buildtools_third_party_libc___libc__",
-        ":cronet_aml_buildtools_third_party_libc__abi_libc__abi",
         "third_party/protobuf/src/google/protobuf/compiler/main.cc",
     ],
     shared_libs: [
         "libz",
     ],
     static_libs: [
+        "cronet_aml_buildtools_third_party_libc___libc__",
+        "cronet_aml_buildtools_third_party_libc__abi_libc__abi",
         "cronet_aml_third_party_protobuf_protobuf_full",
         "cronet_aml_third_party_protobuf_protoc_lib",
     ],
@@ -30173,9 +34794,60 @@
         "cronet_aml_base_allocator_partition_allocator_partition_alloc",
         "cronet_aml_base_base",
         "cronet_aml_base_base_static",
+        "cronet_aml_base_nodebug_assertion",
         "cronet_aml_base_third_party_double_conversion_double_conversion",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access",
+        "cronet_aml_third_party_android_ndk_cpu_features",
+        "cronet_aml_third_party_ashmem_ashmem",
         "cronet_aml_third_party_boringssl_boringssl",
+        "cronet_aml_third_party_boringssl_boringssl_asm",
         "cronet_aml_third_party_icu_icui18n",
         "cronet_aml_third_party_icu_icuuc_private",
         "cronet_aml_third_party_libevent_libevent",
@@ -30317,9 +34989,60 @@
         "cronet_aml_base_allocator_partition_allocator_partition_alloc__testing",
         "cronet_aml_base_base__testing",
         "cronet_aml_base_base_static__testing",
+        "cronet_aml_base_nodebug_assertion__testing",
         "cronet_aml_base_third_party_double_conversion_double_conversion__testing",
         "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_strerror__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_city__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_distributions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_status__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_status_statusor__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+        "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access__testing",
+        "cronet_aml_third_party_android_ndk_cpu_features__testing",
+        "cronet_aml_third_party_ashmem_ashmem__testing",
         "cronet_aml_third_party_boringssl_boringssl__testing",
+        "cronet_aml_third_party_boringssl_boringssl_asm__testing",
         "cronet_aml_third_party_icu_icui18n__testing",
         "cronet_aml_third_party_icu_icuuc_private__testing",
         "cronet_aml_third_party_libevent_libevent__testing",
diff --git a/tools/gn2bp/gen_android_bp b/tools/gn2bp/gen_android_bp
index 2c970a5..d714a90 100755
--- a/tools/gn2bp/gen_android_bp
+++ b/tools/gn2bp/gen_android_bp
@@ -549,7 +549,13 @@
     return self.type == "cc_genrule"
 
   def has_input_files(self):
-    return len(self.srcs) > 0 or any([len(target.srcs) > 0 for target in self.target.values()])
+    if len(self.srcs) > 0:
+      return True
+    if any([len(target.srcs) > 0 for target in self.target.values()]):
+      return True
+    # Allow cc_static_library with export_generated_headers as those are crucial for
+    # the depending modules
+    return len(self.export_generated_headers) > 0
 
   def merge_attribute(self, key, source_module, allowed_archs, source_key = None):
     """
@@ -591,8 +597,8 @@
 
   def to_string(self, output):
     for m in sorted(self.modules.values(), key=lambda m: m.name):
-      if m.type != "cc_object" or m.has_input_files():
-        # Don't print cc_object with empty srcs. These attributes are already
+      if m.type != "cc_library_static" or m.has_input_files():
+        # Don't print cc_library_static with empty srcs. These attributes are already
         # propagated up the tree. Printing them messes the presubmits because
         # every module is compiled while those targets are not reachable in
         # a normal compilation path.
@@ -1345,10 +1351,9 @@
 
 def set_module_flags(module, module_type, cflags, defines, ldflags, libs):
   module.cflags.update(_get_cflags(cflags, defines))
-  if module_type != 'cc_object':
-    module.ldflags.update({flag for flag in ldflags
-            if flag in ldflag_allowlist or flag.startswith("-Wl,-wrap,")})
-    _set_linker_script(module, libs)
+  module.ldflags.update({flag for flag in ldflags
+                         if flag in ldflag_allowlist or flag.startswith("-Wl,-wrap,")})
+  _set_linker_script(module, libs)
   # TODO: implement proper cflag parsing.
   for flag in cflags:
     if '-std=' in flag:
@@ -1397,12 +1402,10 @@
       # Can be used for both host and device targets.
       module_type = 'cc_binary'
     module = Module(module_type, bp_module_name, gn_target_name)
-  elif target.type == 'static_library':
+  elif target.type in ['static_library', 'source_set']:
     module = Module('cc_library_static', bp_module_name, gn_target_name)
   elif target.type == 'shared_library':
     module = Module('cc_library_shared', bp_module_name, gn_target_name)
-  elif target.type == 'source_set':
-    module = Module('cc_object', bp_module_name, gn_target_name)
   elif target.type == 'group':
     # "group" targets are resolved recursively by gn_utils.get_target().
     # There's nothing we need to do at this level for them.
@@ -1525,27 +1528,21 @@
     if not module.is_compiled() or module.is_genrule():
       continue
 
+    # Drop compiled modules that doesn't provide any benefit. This is mostly
+    # applicable to source_sets when converted to cc_static_library, sometimes
+    # the source set only has header files which are dropped so the module becomes empty.
+    if dep_module.is_compiled() and not dep_module.has_input_files():
+      continue
+
     if dep_module.type == 'cc_library_shared':
       module.shared_libs.add(dep_module.name)
     elif dep_module.type == 'cc_library_static':
       module.static_libs.add(dep_module.name)
-    elif dep_module.type == 'cc_object':
-      module.merge_attribute('generated_headers', dep_module, target.arch.keys())
-      if module.type != 'cc_object':
-        if dep_module.has_input_files():
-          # Only add it as part of srcs if the dep_module has input files otherwise
-          # this would throw an error.
-          module.srcs.add(":" + dep_module.name)
-        module.merge_attribute('export_generated_headers', dep_module,
-                         target.arch.keys(), 'generated_headers')
     elif dep_module.type == 'cc_genrule':
       module.merge_attribute('generated_headers', dep_module, [], 'genrule_headers')
       module.merge_attribute('srcs', dep_module, [], 'genrule_srcs')
       module.merge_attribute('shared_libs', dep_module, [], 'genrule_shared_libs')
       module.merge_attribute('header_libs', dep_module, [], 'genrule_header_libs')
-      if module.type not in ["cc_object"]:
-        module.merge_attribute('export_generated_headers', dep_module, [],
-                         'genrule_headers')
     elif dep_module.type == 'cc_binary':
       continue  # Ignore executables deps (used by cmdline integration tests).
     else:
@@ -1563,20 +1560,13 @@
       # Arch-specific dependencies currently only include cc_library_static.
       # Revisit this approach once we need to support more target types.
       if dep_module.type == 'cc_library_static':
-        module.target[arch_name].static_libs.add(dep_module.name)
+        if dep_module.has_input_files():
+          module.target[arch_name].static_libs.add(dep_module.name)
       elif dep_module.type == 'cc_genrule':
         module.target[arch_name].generated_headers.update(dep_module.genrule_headers)
         module.target[arch_name].srcs.update(dep_module.genrule_srcs)
         module.target[arch_name].shared_libs.update(dep_module.genrule_shared_libs)
         module.target[arch_name].header_libs.update(dep_module.genrule_header_libs)
-        if module.type not in ["cc_object"]:
-          module.target[arch_name].export_generated_headers.update(
-            dep_module.genrule_headers)
-      elif dep_module.type == 'cc_object':
-        if dep_module.has_input_files():
-          # Only add it as part of srcs if the dep_module has input files otherwise
-          # this would throw an error.
-          module.target[arch_name].srcs.add(":" + dep_module.name)
       else:
         raise Error('Unsupported arch-specific dependency %s of target %s with type %s' %
                     (dep_module.name, target.name, dep_module.type))
diff --git a/tools/gn2bp/gn_utils.py b/tools/gn2bp/gn_utils.py
index 09a7b80..4066673 100644
--- a/tools/gn2bp/gn_utils.py
+++ b/tools/gn2bp/gn_utils.py
@@ -429,14 +429,6 @@
         target.transitive_proto_deps.add(dep.name)
         target.proto_paths.update(dep.proto_paths)
         target.transitive_proto_deps.update(dep.transitive_proto_deps)
-      elif dep.type == 'source_set':
-        target.arch[arch].source_set_deps.add(dep.name)
-        target.arch[arch].source_set_deps.update(dep.arch[arch].source_set_deps)
-        # flatten source_set deps
-        if target.is_linker_unit_type():
-          # This ensure that all transitive source set dependencies are
-          # propagated upward to the linker units.
-          target.arch[arch].deps.update(target.arch[arch].source_set_deps)
       elif dep.type == 'group':
         target.update(dep, arch)  # Bubble up groups's cflags/ldflags etc.
       elif dep.type in ['action', 'action_foreach', 'copy']:
@@ -450,12 +442,11 @@
         # java_library.
         pass
 
-      # Source set bubble up transitive source sets but can't be combined with this
-      # if they are combined then source sets will bubble up static libraries
-      # while we only want to have source sets bubble up only source sets.
-      if dep.type == 'static_library':
-        # Bubble up static_libs. Necessary, since soong does not propagate
+      if dep.type in ['static_library', 'source_set']:
+        # Bubble up static_libs and source_set. Necessary, since soong does not propagate
         # static_libs up the build tree.
+        # Source sets are later translated to static_libraries, so it makes sense
+        # to reuse transitive_static_libs_deps.
         target.arch[arch].transitive_static_libs_deps.add(dep.name)
 
       if arch in dep.arch: