diff --git a/Cronet/tests/cts/Android.bp b/Cronet/tests/cts/Android.bp
index d969b54..7b440cd 100644
--- a/Cronet/tests/cts/Android.bp
+++ b/Cronet/tests/cts/Android.bp
@@ -64,6 +64,7 @@
         "junit",
         "hamcrest-library",
         "kotlin-test",
+        "mockito-target",
     ],
     libs: [
         "android.test.base",
diff --git a/Cronet/tests/cts/src/android/net/http/cts/ConnectionMigrationOptionsTest.kt b/Cronet/tests/cts/src/android/net/http/cts/ConnectionMigrationOptionsTest.kt
index 279bcc8..77cb30e 100644
--- a/Cronet/tests/cts/src/android/net/http/cts/ConnectionMigrationOptionsTest.kt
+++ b/Cronet/tests/cts/src/android/net/http/cts/ConnectionMigrationOptionsTest.kt
@@ -18,6 +18,7 @@
 
 import android.net.http.ConnectionMigrationOptions
 import android.net.http.ConnectionMigrationOptions.MIGRATION_OPTION_ENABLED
+import android.net.http.ConnectionMigrationOptions.MIGRATION_OPTION_UNSPECIFIED
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import kotlin.test.Test
 import kotlin.test.assertEquals
@@ -27,6 +28,16 @@
 class ConnectionMigrationOptionsTest {
 
     @Test
+    fun testConnectionMigrationOptions_defaultValues() {
+        val options =
+                ConnectionMigrationOptions.Builder().build()
+
+        assertEquals(MIGRATION_OPTION_UNSPECIFIED, options.allowNonDefaultNetworkUsageEnabled)
+        assertEquals(MIGRATION_OPTION_UNSPECIFIED, options.defaultNetworkMigrationEnabled)
+        assertEquals(MIGRATION_OPTION_UNSPECIFIED, options.pathDegradationMigrationEnabled)
+    }
+
+    @Test
     fun testConnectionMigrationOptions_enableDefaultNetworkMigration_returnSetValue() {
         val options =
             ConnectionMigrationOptions.Builder()
@@ -45,4 +56,13 @@
 
         assertEquals(MIGRATION_OPTION_ENABLED, options.pathDegradationMigrationEnabled)
     }
+
+    @Test
+    fun testConnectionMigrationOptions_allowNonDefaultNetworkUsage_returnSetValue() {
+        val options =
+                ConnectionMigrationOptions.Builder()
+                        .setAllowNonDefaultNetworkUsageEnabled(MIGRATION_OPTION_ENABLED).build()
+
+        assertEquals(MIGRATION_OPTION_ENABLED, options.allowNonDefaultNetworkUsageEnabled)
+    }
 }
diff --git a/Cronet/tests/cts/src/android/net/http/cts/HttpEngineTest.java b/Cronet/tests/cts/src/android/net/http/cts/HttpEngineTest.java
index d247201..816596c 100644
--- a/Cronet/tests/cts/src/android/net/http/cts/HttpEngineTest.java
+++ b/Cronet/tests/cts/src/android/net/http/cts/HttpEngineTest.java
@@ -29,6 +29,7 @@
 import static org.junit.Assert.assertTrue;
 
 import android.content.Context;
+import android.net.Network;
 import android.net.http.HttpEngine;
 import android.net.http.UrlRequest;
 import android.net.http.UrlResponseInfo;
@@ -43,6 +44,7 @@
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
+import org.mockito.Mockito;
 
 @RunWith(AndroidJUnit4.class)
 public class HttpEngineTest {
@@ -51,6 +53,7 @@
 
     private HttpEngine.Builder mEngineBuilder;
     private TestUrlRequestCallback mCallback;
+    private HttpCtsTestServer mTestServer;
     private UrlRequest mRequest;
     private HttpEngine mEngine;
     private Context mContext;
@@ -61,6 +64,7 @@
         skipIfNoInternetConnection(mContext);
         mEngineBuilder = new HttpEngine.Builder(mContext);
         mCallback = new TestUrlRequestCallback();
+        mTestServer = new HttpCtsTestServer(mContext);
     }
 
     @After
@@ -72,6 +76,9 @@
         if (mEngine != null) {
             mEngine.shutdown();
         }
+        if (mTestServer != null) {
+            mTestServer.shutdown();
+        }
     }
 
     private boolean isQuic(String negotiatedProtocol) {
@@ -253,4 +260,45 @@
                 .replaceFirst(".*<title>", "")
                 .replaceFirst("</title>.*", "");
     }
-}
+
+    @Test
+    public void testHttpEngine_bindToNetwork() throws Exception {
+        // Create a fake Android.net.Network. Since that network doesn't exist, binding to
+        // that should end up in a failed request.
+        Network mockNetwork = Mockito.mock(Network.class);
+        Mockito.when(mockNetwork.getNetworkHandle()).thenReturn(123L);
+        String url = mTestServer.getSuccessUrl();
+
+        mEngine = mEngineBuilder.build();
+        mEngine.bindToNetwork(mockNetwork);
+        UrlRequest.Builder builder =
+                mEngine.newUrlRequestBuilder(url, mCallback.getExecutor(), mCallback);
+        mRequest = builder.build();
+        mRequest.start();
+
+        mCallback.expectCallback(ResponseStep.ON_FAILED);
+    }
+
+    @Test
+    public void testHttpEngine_unbindFromNetwork() throws Exception {
+        // Create a fake Android.net.Network. Since that network doesn't exist, binding to
+        // that should end up in a failed request.
+        Network mockNetwork = Mockito.mock(Network.class);
+        Mockito.when(mockNetwork.getNetworkHandle()).thenReturn(123L);
+        String url = mTestServer.getSuccessUrl();
+
+        mEngine = mEngineBuilder.build();
+        // Bind to the fake network but then unbind. This should result in a successful
+        // request.
+        mEngine.bindToNetwork(mockNetwork);
+        mEngine.bindToNetwork(null);
+        UrlRequest.Builder builder =
+                mEngine.newUrlRequestBuilder(url, mCallback.getExecutor(), mCallback);
+        mRequest = builder.build();
+        mRequest.start();
+
+        mCallback.expectCallback(ResponseStep.ON_SUCCEEDED);
+        UrlResponseInfo info = mCallback.mResponseInfo;
+        assertOKStatusCode(info);
+    }
+}
\ No newline at end of file
diff --git a/Cronet/tests/cts/src/android/net/http/cts/UrlRequestTest.java b/Cronet/tests/cts/src/android/net/http/cts/UrlRequestTest.java
index 19742e5..2ec035b 100644
--- a/Cronet/tests/cts/src/android/net/http/cts/UrlRequestTest.java
+++ b/Cronet/tests/cts/src/android/net/http/cts/UrlRequestTest.java
@@ -19,6 +19,8 @@
 import static android.net.http.cts.util.TestUtilsKt.assertOKStatusCode;
 import static android.net.http.cts.util.TestUtilsKt.skipIfNoInternetConnection;
 
+import static com.google.common.truth.Truth.assertThat;
+
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.greaterThan;
 import static org.junit.Assert.assertEquals;
@@ -40,15 +42,21 @@
 import android.net.http.cts.util.TestUploadDataProvider;
 import android.net.http.cts.util.TestUrlRequestCallback;
 import android.net.http.cts.util.TestUrlRequestCallback.ResponseStep;
+import android.net.http.cts.util.UploadDataProviders;
 
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 import androidx.test.core.app.ApplicationProvider;
 import androidx.test.ext.junit.runners.AndroidJUnit4;
 
+import com.google.common.base.Strings;
+
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 
+import java.net.URLEncoder;
 import java.nio.ByteBuffer;
 import java.nio.charset.StandardCharsets;
 import java.util.concurrent.ArrayBlockingQueue;
@@ -279,7 +287,32 @@
         assertTrue(e.getCause().getMessage().contains("full"));
     }
 
-    private static class StubUrlRequestCallback extends UrlRequest.Callback {
+    @Test
+    public void testUrlRequestPost_withRedirect() throws Exception {
+        String body = Strings.repeat(
+                "Hello, this is a really interesting body, so write this 100 times.", 100);
+
+        String redirectUrlParameter =
+                URLEncoder.encode(mTestServer.getEchoBodyUrl(), "UTF-8");
+        createUrlRequestBuilder(
+                String.format(
+                        "%s/alt_redirect?dest=%s&statusCode=307",
+                        mTestServer.getBaseUri(),
+                        redirectUrlParameter))
+                .setHttpMethod("POST")
+                .addHeader("Content-Type", "text/plain")
+                .setUploadDataProvider(
+                        UploadDataProviders.create(body.getBytes(StandardCharsets.UTF_8)),
+                        mCallback.getExecutor())
+                .build()
+                .start();
+        mCallback.expectCallback(ResponseStep.ON_SUCCEEDED);
+
+        assertOKStatusCode(mCallback.mResponseInfo);
+        assertThat(mCallback.mResponseAsString).isEqualTo(body);
+    }
+
+    private static class StubUrlRequestCallback implements UrlRequest.Callback {
 
         @Override
         public void onRedirectReceived(
@@ -307,6 +340,11 @@
         public void onFailed(UrlRequest request, UrlResponseInfo info, HttpException error) {
             throw new UnsupportedOperationException(error);
         }
+
+        @Override
+        public void onCanceled(@NonNull UrlRequest request, @Nullable UrlResponseInfo info) {
+            throw new UnsupportedOperationException();
+        }
     }
 
     private static class InMemoryUploadDataProvider extends UploadDataProvider {
diff --git a/Cronet/tests/cts/src/android/net/http/cts/util/TestUrlRequestCallback.java b/Cronet/tests/cts/src/android/net/http/cts/util/TestUrlRequestCallback.java
index efbcff6..28443b7 100644
--- a/Cronet/tests/cts/src/android/net/http/cts/util/TestUrlRequestCallback.java
+++ b/Cronet/tests/cts/src/android/net/http/cts/util/TestUrlRequestCallback.java
@@ -50,7 +50,7 @@
  * method to block thread until the request completes on another thread.
  * Allows us to cancel, block request or throw an exception from an arbitrary step.
  */
-public class TestUrlRequestCallback extends UrlRequest.Callback {
+public class TestUrlRequestCallback implements UrlRequest.Callback {
     private static final int TIMEOUT_MS = 12_000;
     public ArrayList<UrlResponseInfo> mRedirectResponseInfoList = new ArrayList<>();
     public ArrayList<String> mRedirectUrlList = new ArrayList<>();
diff --git a/Cronet/tests/cts/src/android/net/http/cts/util/UploadDataProviders.java b/Cronet/tests/cts/src/android/net/http/cts/util/UploadDataProviders.java
new file mode 100644
index 0000000..889f8f2
--- /dev/null
+++ b/Cronet/tests/cts/src/android/net/http/cts/util/UploadDataProviders.java
@@ -0,0 +1,198 @@
+/*
+ * 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.util;
+
+import android.net.http.UploadDataProvider;
+import android.net.http.UploadDataSink;
+import android.os.ParcelFileDescriptor;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.channels.FileChannel;
+
+/**
+ * Provides implementations of {@link UploadDataProvider} for common use cases. Corresponds to
+ * {@code android.net.http.apihelpers.UploadDataProviders} which is not an exposed API.
+ */
+public final class UploadDataProviders {
+    /**
+     * Uploads an entire file.
+     *
+     * @param file The file to upload
+     * @return A new UploadDataProvider for the given file
+     */
+    public static UploadDataProvider create(final File file) {
+        return new FileUploadProvider(() -> new FileInputStream(file).getChannel());
+    }
+
+    /**
+     * Uploads an entire file, closing the descriptor when it is no longer needed.
+     *
+     * @param fd The file descriptor to upload
+     * @throws IllegalArgumentException if {@code fd} is not a file.
+     * @return A new UploadDataProvider for the given file descriptor
+     */
+    public static UploadDataProvider create(final ParcelFileDescriptor fd) {
+        return new FileUploadProvider(() -> {
+            if (fd.getStatSize() != -1) {
+                return new ParcelFileDescriptor.AutoCloseInputStream(fd).getChannel();
+            } else {
+                fd.close();
+                throw new IllegalArgumentException("Not a file: " + fd);
+            }
+        });
+    }
+
+    /**
+     * Uploads a ByteBuffer, from the current {@code buffer.position()} to {@code buffer.limit()}
+     *
+     * @param buffer The data to upload
+     * @return A new UploadDataProvider for the given buffer
+     */
+    public static UploadDataProvider create(ByteBuffer buffer) {
+        return new ByteBufferUploadProvider(buffer.slice());
+    }
+
+    /**
+     * Uploads {@code length} bytes from {@code data}, starting from {@code offset}
+     *
+     * @param data Array containing data to upload
+     * @param offset Offset within data to start with
+     * @param length Number of bytes to upload
+     * @return A new UploadDataProvider for the given data
+     */
+    public static UploadDataProvider create(byte[] data, int offset, int length) {
+        return new ByteBufferUploadProvider(ByteBuffer.wrap(data, offset, length).slice());
+    }
+
+    /**
+     * Uploads the contents of {@code data}
+     *
+     * @param data Array containing data to upload
+     * @return A new UploadDataProvider for the given data
+     */
+    public static UploadDataProvider create(byte[] data) {
+        return create(data, 0, data.length);
+    }
+
+    private interface FileChannelProvider {
+        FileChannel getChannel() throws IOException;
+    }
+
+    private static final class FileUploadProvider extends UploadDataProvider {
+        private volatile FileChannel mChannel;
+        private final FileChannelProvider mProvider;
+        /** Guards initialization of {@code mChannel} */
+        private final Object mLock = new Object();
+
+        private FileUploadProvider(FileChannelProvider provider) {
+            this.mProvider = provider;
+        }
+
+        @Override
+        public long getLength() throws IOException {
+            return getChannel().size();
+        }
+
+        @Override
+        public void read(UploadDataSink uploadDataSink, ByteBuffer byteBuffer) throws IOException {
+            if (!byteBuffer.hasRemaining()) {
+                throw new IllegalStateException("Cronet passed a buffer with no bytes remaining");
+            }
+            FileChannel channel = getChannel();
+            int bytesRead = 0;
+            while (bytesRead == 0) {
+                int read = channel.read(byteBuffer);
+                if (read == -1) {
+                    break;
+                } else {
+                    bytesRead += read;
+                }
+            }
+            uploadDataSink.onReadSucceeded(false);
+        }
+
+        @Override
+        public void rewind(UploadDataSink uploadDataSink) throws IOException {
+            getChannel().position(0);
+            uploadDataSink.onRewindSucceeded();
+        }
+
+        /**
+         * Lazily initializes the channel so that a blocking operation isn't performed
+         * on a non-executor thread.
+         */
+        private FileChannel getChannel() throws IOException {
+            if (mChannel == null) {
+                synchronized (mLock) {
+                    if (mChannel == null) {
+                        mChannel = mProvider.getChannel();
+                    }
+                }
+            }
+            return mChannel;
+        }
+
+        @Override
+        public void close() throws IOException {
+            FileChannel channel = mChannel;
+            if (channel != null) {
+                channel.close();
+            }
+        }
+    }
+
+    private static final class ByteBufferUploadProvider extends UploadDataProvider {
+        private final ByteBuffer mUploadBuffer;
+
+        private ByteBufferUploadProvider(ByteBuffer uploadBuffer) {
+            this.mUploadBuffer = uploadBuffer;
+        }
+
+        @Override
+        public long getLength() {
+            return mUploadBuffer.limit();
+        }
+
+        @Override
+        public void read(UploadDataSink uploadDataSink, ByteBuffer byteBuffer) {
+            if (!byteBuffer.hasRemaining()) {
+                throw new IllegalStateException("Cronet passed a buffer with no bytes remaining");
+            }
+            if (byteBuffer.remaining() >= mUploadBuffer.remaining()) {
+                byteBuffer.put(mUploadBuffer);
+            } else {
+                int oldLimit = mUploadBuffer.limit();
+                mUploadBuffer.limit(mUploadBuffer.position() + byteBuffer.remaining());
+                byteBuffer.put(mUploadBuffer);
+                mUploadBuffer.limit(oldLimit);
+            }
+            uploadDataSink.onReadSucceeded(false);
+        }
+
+        @Override
+        public void rewind(UploadDataSink uploadDataSink) {
+            mUploadBuffer.position(0);
+            uploadDataSink.onRewindSucceeded();
+        }
+    }
+
+    // Prevent instantiation
+    private UploadDataProviders() {}
+}
diff --git a/Cronet/tests/mts/Android.bp b/Cronet/tests/mts/Android.bp
index 03d163c..ac71653 100644
--- a/Cronet/tests/mts/Android.bp
+++ b/Cronet/tests/mts/Android.bp
@@ -19,7 +19,7 @@
 
 android_library {
     name: "NetHttpTestsLibPreJarJar",
-    srcs: [":cronet_aml_javatests_sources"],
+    srcs: ["//external/cronet:cronet_aml_javatests_sources"],
     sdk_version: "test_current",
     min_sdk_version: "30",
     static_libs: [
diff --git a/Tethering/apex/Android.bp b/Tethering/apex/Android.bp
index 67206cd..ff5acf5 100644
--- a/Tethering/apex/Android.bp
+++ b/Tethering/apex/Android.bp
@@ -66,11 +66,19 @@
 
 apex_defaults {
     name: "CronetInTetheringApexDefaultsEnabled",
-    jni_libs: ["cronet_aml_components_cronet_android_cronet"],
+    jni_libs: [
+        "//external/cronet:cronet_aml_components_cronet_android_cronet",
+        "//external/cronet/third_party/boringssl:libcrypto",
+        "//external/cronet/third_party/boringssl:libssl",
+    ],
     arch: {
         riscv64: {
             // TODO: remove this when there is a riscv64 libcronet
-            exclude_jni_libs: ["cronet_aml_components_cronet_android_cronet"],
+            exclude_jni_libs: [
+                "//external/cronet:cronet_aml_components_cronet_android_cronet",
+                "//external/cronet/third_party/boringssl:libcrypto",
+                "//external/cronet/third_party/boringssl:libssl",
+            ],
         },
     },
 }
diff --git a/Tethering/common/TetheringLib/Android.bp b/Tethering/common/TetheringLib/Android.bp
index 4080029..b99c9e4 100644
--- a/Tethering/common/TetheringLib/Android.bp
+++ b/Tethering/common/TetheringLib/Android.bp
@@ -75,12 +75,12 @@
 
 java_defaults {
     name: "CronetJavaDefaultsEnabled",
-    srcs: [":cronet_aml_api_sources"],
+    srcs: ["//external/cronet:cronet_aml_api_sources"],
     libs: [
         "androidx.annotation_annotation",
     ],
     impl_only_static_libs: [
-        "cronet_aml_java",
+        "//external/cronet:cronet_aml_java",
     ],
     api_dir: "cronet_enabled/api",
 }
@@ -101,8 +101,8 @@
 java_defaults {
   name: "CronetJavaPrejarjarDefaultsEnabled",
   static_libs: [
-    "cronet_aml_api_java",
-    "cronet_aml_java"
+    "//external/cronet:cronet_aml_api_java",
+    "//external/cronet:cronet_aml_java"
   ],
 }
 
diff --git a/Tethering/common/TetheringLib/cronet_enabled/api/current.txt b/Tethering/common/TetheringLib/cronet_enabled/api/current.txt
index cf441ce..66a0295 100644
--- a/Tethering/common/TetheringLib/cronet_enabled/api/current.txt
+++ b/Tethering/common/TetheringLib/cronet_enabled/api/current.txt
@@ -241,14 +241,13 @@
     method @NonNull public abstract android.net.http.UrlRequest.Builder setUploadDataProvider(@NonNull android.net.http.UploadDataProvider, @NonNull java.util.concurrent.Executor);
   }
 
-  public abstract static class UrlRequest.Callback {
-    ctor public UrlRequest.Callback();
+  public static interface UrlRequest.Callback {
     method public void onCanceled(@NonNull android.net.http.UrlRequest, @Nullable android.net.http.UrlResponseInfo);
-    method public abstract void onFailed(@NonNull android.net.http.UrlRequest, @Nullable android.net.http.UrlResponseInfo, @NonNull android.net.http.HttpException);
-    method public abstract void onReadCompleted(@NonNull android.net.http.UrlRequest, @NonNull android.net.http.UrlResponseInfo, @NonNull java.nio.ByteBuffer) throws java.lang.Exception;
-    method public abstract void onRedirectReceived(@NonNull android.net.http.UrlRequest, @NonNull android.net.http.UrlResponseInfo, @NonNull String) throws java.lang.Exception;
-    method public abstract void onResponseStarted(@NonNull android.net.http.UrlRequest, @NonNull android.net.http.UrlResponseInfo) throws java.lang.Exception;
-    method public abstract void onSucceeded(@NonNull android.net.http.UrlRequest, @NonNull android.net.http.UrlResponseInfo);
+    method public void onFailed(@NonNull android.net.http.UrlRequest, @Nullable android.net.http.UrlResponseInfo, @NonNull android.net.http.HttpException);
+    method public void onReadCompleted(@NonNull android.net.http.UrlRequest, @NonNull android.net.http.UrlResponseInfo, @NonNull java.nio.ByteBuffer) throws java.lang.Exception;
+    method public void onRedirectReceived(@NonNull android.net.http.UrlRequest, @NonNull android.net.http.UrlResponseInfo, @NonNull String) throws java.lang.Exception;
+    method public void onResponseStarted(@NonNull android.net.http.UrlRequest, @NonNull android.net.http.UrlResponseInfo) throws java.lang.Exception;
+    method public void onSucceeded(@NonNull android.net.http.UrlRequest, @NonNull android.net.http.UrlResponseInfo);
   }
 
   public static class UrlRequest.Status {
diff --git a/Tethering/tests/unit/src/com/android/networkstack/tethering/metrics/TetheringMetricsTest.java b/Tethering/tests/unit/src/com/android/networkstack/tethering/metrics/TetheringMetricsTest.java
index 7fdde97..95afa56 100644
--- a/Tethering/tests/unit/src/com/android/networkstack/tethering/metrics/TetheringMetricsTest.java
+++ b/Tethering/tests/unit/src/com/android/networkstack/tethering/metrics/TetheringMetricsTest.java
@@ -99,86 +99,87 @@
         mTetheringMetrics.sendReport(downstream);
     }
 
-    private void runDownstreamTypesTest(final Pair<Integer, DownstreamType>... testPairs)
+    private void runDownstreamTypesTest(final Pair<Integer, DownstreamType> testPair)
             throws Exception {
-        for (Pair<Integer, DownstreamType> testPair : testPairs) {
-            final int type = testPair.first;
-            final DownstreamType expectedResult = testPair.second;
+        final int type = testPair.first;
+        final DownstreamType expectedResult = testPair.second;
 
-            mTetheringMetrics.createBuilder(type, TEST_CALLER_PKG);
-            updateErrorAndSendReport(type, TETHER_ERROR_NO_ERROR);
-            verifyReport(expectedResult, ErrorCode.EC_NO_ERROR, UserType.USER_UNKNOWN);
-            reset(mTetheringMetrics);
-        }
+        mTetheringMetrics.createBuilder(type, TEST_CALLER_PKG);
+        updateErrorAndSendReport(type, TETHER_ERROR_NO_ERROR);
+        verifyReport(expectedResult, ErrorCode.EC_NO_ERROR, UserType.USER_UNKNOWN);
+        reset(mTetheringMetrics);
     }
 
     @Test
     public void testDownstreamTypes() throws Exception {
-        runDownstreamTypesTest(new Pair<>(TETHERING_WIFI, DownstreamType.DS_TETHERING_WIFI),
-                new Pair<>(TETHERING_WIFI_P2P, DownstreamType.DS_TETHERING_WIFI_P2P),
-                new Pair<>(TETHERING_BLUETOOTH, DownstreamType.DS_TETHERING_BLUETOOTH),
-                new Pair<>(TETHERING_USB, DownstreamType.DS_TETHERING_USB),
-                new Pair<>(TETHERING_NCM, DownstreamType.DS_TETHERING_NCM),
-                new Pair<>(TETHERING_ETHERNET, DownstreamType.DS_TETHERING_ETHERNET));
+        runDownstreamTypesTest(new Pair<>(TETHERING_WIFI, DownstreamType.DS_TETHERING_WIFI));
+        runDownstreamTypesTest(new Pair<>(TETHERING_WIFI_P2P,
+                DownstreamType.DS_TETHERING_WIFI_P2P));
+        runDownstreamTypesTest(new Pair<>(TETHERING_BLUETOOTH,
+                DownstreamType.DS_TETHERING_BLUETOOTH));
+        runDownstreamTypesTest(new Pair<>(TETHERING_USB, DownstreamType.DS_TETHERING_USB));
+        runDownstreamTypesTest(new Pair<>(TETHERING_NCM, DownstreamType.DS_TETHERING_NCM));
+        runDownstreamTypesTest(new Pair<>(TETHERING_ETHERNET,
+                DownstreamType.DS_TETHERING_ETHERNET));
     }
 
-    private void runErrorCodesTest(final Pair<Integer, ErrorCode>... testPairs)
+    private void runErrorCodesTest(final Pair<Integer, ErrorCode> testPair)
             throws Exception {
-        for (Pair<Integer, ErrorCode> testPair : testPairs) {
-            final int errorCode = testPair.first;
-            final ErrorCode expectedResult = testPair.second;
+        final int errorCode = testPair.first;
+        final ErrorCode expectedResult = testPair.second;
 
-            mTetheringMetrics.createBuilder(TETHERING_WIFI, TEST_CALLER_PKG);
-            updateErrorAndSendReport(TETHERING_WIFI, errorCode);
-            verifyReport(DownstreamType.DS_TETHERING_WIFI, expectedResult, UserType.USER_UNKNOWN);
-            reset(mTetheringMetrics);
-        }
+        mTetheringMetrics.createBuilder(TETHERING_WIFI, TEST_CALLER_PKG);
+        updateErrorAndSendReport(TETHERING_WIFI, errorCode);
+        verifyReport(DownstreamType.DS_TETHERING_WIFI, expectedResult, UserType.USER_UNKNOWN);
     }
 
     @Test
     public void testErrorCodes() throws Exception {
-        runErrorCodesTest(new Pair<>(TETHER_ERROR_NO_ERROR, ErrorCode.EC_NO_ERROR),
-                new Pair<>(TETHER_ERROR_UNKNOWN_IFACE, ErrorCode.EC_UNKNOWN_IFACE),
-                new Pair<>(TETHER_ERROR_SERVICE_UNAVAIL, ErrorCode.EC_SERVICE_UNAVAIL),
-                new Pair<>(TETHER_ERROR_UNSUPPORTED, ErrorCode.EC_UNSUPPORTED),
-                new Pair<>(TETHER_ERROR_UNAVAIL_IFACE, ErrorCode.EC_UNAVAIL_IFACE),
-                new Pair<>(TETHER_ERROR_INTERNAL_ERROR, ErrorCode.EC_INTERNAL_ERROR),
-                new Pair<>(TETHER_ERROR_TETHER_IFACE_ERROR, ErrorCode.EC_TETHER_IFACE_ERROR),
-                new Pair<>(TETHER_ERROR_UNTETHER_IFACE_ERROR, ErrorCode.EC_UNTETHER_IFACE_ERROR),
-                new Pair<>(TETHER_ERROR_ENABLE_FORWARDING_ERROR,
-                ErrorCode.EC_ENABLE_FORWARDING_ERROR),
-                new Pair<>(TETHER_ERROR_DISABLE_FORWARDING_ERROR,
-                ErrorCode.EC_DISABLE_FORWARDING_ERROR),
-                new Pair<>(TETHER_ERROR_IFACE_CFG_ERROR, ErrorCode.EC_IFACE_CFG_ERROR),
-                new Pair<>(TETHER_ERROR_PROVISIONING_FAILED, ErrorCode.EC_PROVISIONING_FAILED),
-                new Pair<>(TETHER_ERROR_DHCPSERVER_ERROR, ErrorCode.EC_DHCPSERVER_ERROR),
-                new Pair<>(TETHER_ERROR_ENTITLEMENT_UNKNOWN, ErrorCode.EC_ENTITLEMENT_UNKNOWN),
-                new Pair<>(TETHER_ERROR_NO_CHANGE_TETHERING_PERMISSION,
-                ErrorCode.EC_NO_CHANGE_TETHERING_PERMISSION),
-                new Pair<>(TETHER_ERROR_NO_ACCESS_TETHERING_PERMISSION,
-                ErrorCode.EC_NO_ACCESS_TETHERING_PERMISSION),
-                new Pair<>(TETHER_ERROR_UNKNOWN_TYPE, ErrorCode.EC_UNKNOWN_TYPE));
+        runErrorCodesTest(new Pair<>(TETHER_ERROR_NO_ERROR, ErrorCode.EC_NO_ERROR));
+        runErrorCodesTest(new Pair<>(TETHER_ERROR_UNKNOWN_IFACE, ErrorCode.EC_UNKNOWN_IFACE));
+        runErrorCodesTest(new Pair<>(TETHER_ERROR_SERVICE_UNAVAIL, ErrorCode.EC_SERVICE_UNAVAIL));
+        runErrorCodesTest(new Pair<>(TETHER_ERROR_UNSUPPORTED, ErrorCode.EC_UNSUPPORTED));
+        runErrorCodesTest(new Pair<>(TETHER_ERROR_UNAVAIL_IFACE, ErrorCode.EC_UNAVAIL_IFACE));
+        runErrorCodesTest(new Pair<>(TETHER_ERROR_INTERNAL_ERROR, ErrorCode.EC_INTERNAL_ERROR));
+        runErrorCodesTest(new Pair<>(TETHER_ERROR_TETHER_IFACE_ERROR,
+                ErrorCode.EC_TETHER_IFACE_ERROR));
+        runErrorCodesTest(new Pair<>(TETHER_ERROR_UNTETHER_IFACE_ERROR,
+                ErrorCode.EC_UNTETHER_IFACE_ERROR));
+        runErrorCodesTest(new Pair<>(TETHER_ERROR_ENABLE_FORWARDING_ERROR,
+                ErrorCode.EC_ENABLE_FORWARDING_ERROR));
+        runErrorCodesTest(new Pair<>(TETHER_ERROR_DISABLE_FORWARDING_ERROR,
+                ErrorCode.EC_DISABLE_FORWARDING_ERROR));
+        runErrorCodesTest(new Pair<>(TETHER_ERROR_IFACE_CFG_ERROR, ErrorCode.EC_IFACE_CFG_ERROR));
+        runErrorCodesTest(new Pair<>(TETHER_ERROR_PROVISIONING_FAILED,
+                ErrorCode.EC_PROVISIONING_FAILED));
+        runErrorCodesTest(new Pair<>(TETHER_ERROR_DHCPSERVER_ERROR,
+                ErrorCode.EC_DHCPSERVER_ERROR));
+        runErrorCodesTest(new Pair<>(TETHER_ERROR_ENTITLEMENT_UNKNOWN,
+                ErrorCode.EC_ENTITLEMENT_UNKNOWN));
+        runErrorCodesTest(new Pair<>(TETHER_ERROR_NO_CHANGE_TETHERING_PERMISSION,
+                ErrorCode.EC_NO_CHANGE_TETHERING_PERMISSION));
+        runErrorCodesTest(new Pair<>(TETHER_ERROR_NO_ACCESS_TETHERING_PERMISSION,
+                ErrorCode.EC_NO_ACCESS_TETHERING_PERMISSION));
+        runErrorCodesTest(new Pair<>(TETHER_ERROR_UNKNOWN_TYPE, ErrorCode.EC_UNKNOWN_TYPE));
     }
 
-    private void runUserTypesTest(final Pair<String, UserType>... testPairs)
+    private void runUserTypesTest(final Pair<String, UserType> testPair)
             throws Exception {
-        for (Pair<String, UserType> testPair : testPairs) {
-            final String callerPkg = testPair.first;
-            final UserType expectedResult = testPair.second;
+        final String callerPkg = testPair.first;
+        final UserType expectedResult = testPair.second;
 
-            mTetheringMetrics.createBuilder(TETHERING_WIFI, callerPkg);
-            updateErrorAndSendReport(TETHERING_WIFI, TETHER_ERROR_NO_ERROR);
-            verifyReport(DownstreamType.DS_TETHERING_WIFI, ErrorCode.EC_NO_ERROR, expectedResult);
-            reset(mTetheringMetrics);
-        }
+        mTetheringMetrics.createBuilder(TETHERING_WIFI, callerPkg);
+        updateErrorAndSendReport(TETHERING_WIFI, TETHER_ERROR_NO_ERROR);
+        verifyReport(DownstreamType.DS_TETHERING_WIFI, ErrorCode.EC_NO_ERROR, expectedResult);
+        reset(mTetheringMetrics);
     }
 
     @Test
     public void testUserTypes() throws Exception {
-        runUserTypesTest(new Pair<>(TEST_CALLER_PKG, UserType.USER_UNKNOWN),
-                new Pair<>(SETTINGS_PKG, UserType.USER_SETTINGS),
-                new Pair<>(SYSTEMUI_PKG, UserType.USER_SYSTEMUI),
-                new Pair<>(GMS_PKG, UserType.USER_GMS));
+        runUserTypesTest(new Pair<>(TEST_CALLER_PKG, UserType.USER_UNKNOWN));
+        runUserTypesTest(new Pair<>(SETTINGS_PKG, UserType.USER_SETTINGS));
+        runUserTypesTest(new Pair<>(SYSTEMUI_PKG, UserType.USER_SYSTEMUI));
+        runUserTypesTest(new Pair<>(GMS_PKG, UserType.USER_GMS));
     }
 
     @Test
diff --git a/framework/api/system-current.txt b/framework/api/system-current.txt
index 196e023..4a2ed8a 100644
--- a/framework/api/system-current.txt
+++ b/framework/api/system-current.txt
@@ -470,7 +470,7 @@
   }
 
   public abstract class SocketKeepalive implements java.lang.AutoCloseable {
-    method public final void start(@IntRange(from=0xa, to=0xe10) int, int, @NonNull android.net.Network);
+    method public final void start(@IntRange(from=0xa, to=0xe10) int, int, @Nullable android.net.Network);
     field public static final int ERROR_NO_SUCH_SLOT = -33; // 0xffffffdf
     field public static final int FLAG_AUTOMATIC_ON_OFF = 1; // 0x1
     field public static final int SUCCESS = 0; // 0x0
diff --git a/framework/src/android/net/SocketKeepalive.java b/framework/src/android/net/SocketKeepalive.java
index 311126e..10daf17 100644
--- a/framework/src/android/net/SocketKeepalive.java
+++ b/framework/src/android/net/SocketKeepalive.java
@@ -21,6 +21,7 @@
 import android.annotation.IntDef;
 import android.annotation.IntRange;
 import android.annotation.NonNull;
+import android.annotation.Nullable;
 import android.annotation.SystemApi;
 import android.os.Binder;
 import android.os.ParcelFileDescriptor;
@@ -374,12 +375,14 @@
      *                    the supplied {@link Callback} will see a call to
      *                    {@link Callback#onError(int)} with {@link #ERROR_INVALID_INTERVAL}.
      * @param flags Flags to enable/disable available options on this keepalive.
-     * @param underpinnedNetwork The underpinned network of this keepalive.
+     * @param underpinnedNetwork an optional network running over mNetwork that this
+     *                           keepalive is intended to keep up, e.g. an IPSec
+     *                           tunnel running over mNetwork.
      * @hide
      */
     @SystemApi(client = PRIVILEGED_APPS)
     public final void start(@IntRange(from = MIN_INTERVAL_SEC, to = MAX_INTERVAL_SEC)
-            int intervalSec, @StartFlags int flags, @NonNull Network underpinnedNetwork) {
+            int intervalSec, @StartFlags int flags, @Nullable Network underpinnedNetwork) {
         startImpl(intervalSec, flags, underpinnedNetwork);
     }
 
diff --git a/framework/src/android/net/TcpSocketKeepalive.java b/framework/src/android/net/TcpSocketKeepalive.java
index b548f6d..696889f 100644
--- a/framework/src/android/net/TcpSocketKeepalive.java
+++ b/framework/src/android/net/TcpSocketKeepalive.java
@@ -55,6 +55,12 @@
             throw new IllegalArgumentException("Illegal flag value for "
                     + this.getClass().getSimpleName() + " : " + flags);
         }
+
+        if (underpinnedNetwork != null) {
+            throw new IllegalArgumentException("Illegal underpinned network for "
+                    + this.getClass().getSimpleName() + " : " + underpinnedNetwork);
+        }
+
         mExecutor.execute(() -> {
             try {
                 mService.startTcpKeepalive(mNetwork, mPfd, intervalSec, mCallback);
diff --git a/service-t/native/libs/libnetworkstats/Android.bp b/service-t/native/libs/libnetworkstats/Android.bp
index f2c569f..f40d388 100644
--- a/service-t/native/libs/libnetworkstats/Android.bp
+++ b/service-t/native/libs/libnetworkstats/Android.bp
@@ -62,6 +62,7 @@
     header_libs: ["bpf_connectivity_headers"],
     srcs: [
         "BpfNetworkStatsTest.cpp",
+        "NetworkTraceHandlerTest.cpp",
         "NetworkTracePollerTest.cpp",
     ],
     cflags: [
@@ -74,6 +75,8 @@
         "libgmock",
         "libnetworkstats",
         "libperfetto_client_experimental",
+        "libprotobuf-cpp-lite",
+        "perfetto_trace_protos",
     ],
     shared_libs: [
         "libbase",
diff --git a/service-t/native/libs/libnetworkstats/NetworkTraceHandler.cpp b/service-t/native/libs/libnetworkstats/NetworkTraceHandler.cpp
index 8e70950..cd62bc5 100644
--- a/service-t/native/libs/libnetworkstats/NetworkTraceHandler.cpp
+++ b/service-t/native/libs/libnetworkstats/NetworkTraceHandler.cpp
@@ -57,11 +57,16 @@
 }
 
 // static
-NetworkTracePoller NetworkTraceHandler::sPoller([](const PacketTrace& pkt) {
-  NetworkTraceHandler::Trace([pkt](NetworkTraceHandler::TraceContext ctx) {
-    NetworkTraceHandler::Fill(pkt, *ctx.NewTracePacket());
-  });
-});
+NetworkTracePoller NetworkTraceHandler::sPoller(
+    [](const std::vector<PacketTrace>& packets) {
+      // Trace calls the provided callback for each active session. The context
+      // gets a reference to the NetworkTraceHandler instance associated with
+      // the session and delegates writing. The corresponding handler will write
+      // with the setting specified in the trace config.
+      NetworkTraceHandler::Trace([&](NetworkTraceHandler::TraceContext ctx) {
+        ctx.GetDataSourceLocked()->Write(packets, ctx);
+      });
+    });
 
 void NetworkTraceHandler::OnSetup(const SetupArgs& args) {
   const std::string& raw = args.config->network_packet_trace_config_raw();
@@ -72,6 +77,12 @@
     ALOGI("poll_ms is missing or below the 100ms minimum. Increasing to 100ms");
     mPollMs = 100;
   }
+
+  mInternLimit = config.intern_limit();
+  mAggregationThreshold = config.aggregation_threshold();
+  mDropLocalPort = config.drop_local_port();
+  mDropRemotePort = config.drop_remote_port();
+  mDropTcpFlags = config.drop_tcp_flags();
 }
 
 void NetworkTraceHandler::OnStart(const StartArgs&) {
@@ -83,6 +94,13 @@
   mStarted = false;
 }
 
+void NetworkTraceHandler::Write(const std::vector<PacketTrace>& packets,
+                                NetworkTraceHandler::TraceContext& ctx) {
+  for (const PacketTrace& pkt : packets) {
+    Fill(pkt, *ctx.NewTracePacket());
+  }
+}
+
 // static class method
 void NetworkTraceHandler::Fill(const PacketTrace& src, TracePacket& dst) {
   dst.set_timestamp(src.timestampNs);
diff --git a/service-t/native/libs/libnetworkstats/NetworkTraceHandlerTest.cpp b/service-t/native/libs/libnetworkstats/NetworkTraceHandlerTest.cpp
new file mode 100644
index 0000000..2318da5
--- /dev/null
+++ b/service-t/native/libs/libnetworkstats/NetworkTraceHandlerTest.cpp
@@ -0,0 +1,166 @@
+/*
+ * 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.
+ */
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include <vector>
+
+#include "netdbpf/NetworkTraceHandler.h"
+#include "protos/perfetto/trace/android/network_trace.pb.h"
+#include "protos/perfetto/trace/trace.pb.h"
+#include "protos/perfetto/trace/trace_packet.pb.h"
+
+namespace android {
+namespace bpf {
+using ::perfetto::protos::NetworkPacketEvent;
+using ::perfetto::protos::Trace;
+using ::perfetto::protos::TracePacket;
+using ::perfetto::protos::TrafficDirection;
+
+// This handler makes OnStart and OnStop a no-op so that tracing is not really
+// started on the device.
+class HandlerForTest : public NetworkTraceHandler {
+ public:
+  void OnStart(const StartArgs&) override {}
+  void OnStop(const StopArgs&) override {}
+};
+
+class NetworkTraceHandlerTest : public testing::Test {
+ protected:
+  // Starts a tracing session with the handler under test.
+  std::unique_ptr<perfetto::TracingSession> StartTracing() {
+    perfetto::TracingInitArgs args;
+    args.backends = perfetto::kInProcessBackend;
+    perfetto::Tracing::Initialize(args);
+
+    perfetto::DataSourceDescriptor dsd;
+    dsd.set_name("test.network_packets");
+    HandlerForTest::Register(dsd);
+
+    perfetto::TraceConfig cfg;
+    cfg.add_buffers()->set_size_kb(1024);
+    cfg.add_data_sources()->mutable_config()->set_name("test.network_packets");
+
+    auto session = perfetto::Tracing::NewTrace(perfetto::kInProcessBackend);
+    session->Setup(cfg);
+    session->StartBlocking();
+    return session;
+  }
+
+  // Stops the trace session and reports all relevant trace packets.
+  bool StopTracing(perfetto::TracingSession* session,
+                   std::vector<TracePacket>* output) {
+    session->StopBlocking();
+
+    Trace trace;
+    std::vector<char> raw_trace = session->ReadTraceBlocking();
+    if (!trace.ParseFromArray(raw_trace.data(), raw_trace.size())) {
+      ADD_FAILURE() << "trace.ParseFromArray failed";
+      return false;
+    }
+
+    // This is a real trace and includes irrelevant trace packets such as trace
+    // metadata. The following strips the results to just the packets we want.
+    for (const auto& pkt : trace.packet()) {
+      if (pkt.has_network_packet()) {
+        output->emplace_back(pkt);
+      }
+    }
+
+    return true;
+  }
+
+  // This runs a trace with a single call to Write.
+  bool TraceAndSortPackets(const std::vector<PacketTrace>& input,
+                           std::vector<TracePacket>* output) {
+    auto session = StartTracing();
+    HandlerForTest::Trace([&](HandlerForTest::TraceContext ctx) {
+      ctx.GetDataSourceLocked()->Write(input, ctx);
+      ctx.Flush();
+    });
+
+    if (!StopTracing(session.get(), output)) {
+      return false;
+    }
+
+    // Sort to provide deterministic ordering regardless of Perfetto internals
+    // or implementation-defined (e.g. hash map) reshuffling.
+    std::sort(output->begin(), output->end(),
+              [](const TracePacket& a, const TracePacket& b) {
+                return a.timestamp() < b.timestamp();
+              });
+
+    return true;
+  }
+};
+
+TEST_F(NetworkTraceHandlerTest, WriteBasicFields) {
+  std::vector<PacketTrace> input = {
+      PacketTrace{
+          .timestampNs = 1000,
+          .length = 100,
+          .uid = 10,
+          .tag = 123,
+          .ipProto = 6,
+          .tcpFlags = 1,
+      },
+  };
+
+  std::vector<TracePacket> events;
+  ASSERT_TRUE(TraceAndSortPackets(input, &events));
+
+  ASSERT_EQ(events.size(), 1);
+  EXPECT_THAT(events[0].timestamp(), 1000);
+  EXPECT_THAT(events[0].network_packet().length(), 100);
+  EXPECT_THAT(events[0].network_packet().uid(), 10);
+  EXPECT_THAT(events[0].network_packet().tag(), 123);
+  EXPECT_THAT(events[0].network_packet().ip_proto(), 6);
+  EXPECT_THAT(events[0].network_packet().tcp_flags(), 1);
+}
+
+TEST_F(NetworkTraceHandlerTest, WriteDirectionAndPorts) {
+  std::vector<PacketTrace> input = {
+      PacketTrace{
+          .timestampNs = 1,
+          .sport = htons(8080),
+          .dport = htons(443),
+          .egress = true,
+      },
+      PacketTrace{
+          .timestampNs = 2,
+          .sport = htons(443),
+          .dport = htons(8080),
+          .egress = false,
+      },
+  };
+
+  std::vector<TracePacket> events;
+  ASSERT_TRUE(TraceAndSortPackets(input, &events));
+
+  ASSERT_EQ(events.size(), 2);
+  EXPECT_THAT(events[0].network_packet().local_port(), 8080);
+  EXPECT_THAT(events[0].network_packet().remote_port(), 443);
+  EXPECT_THAT(events[0].network_packet().direction(),
+              TrafficDirection::DIR_EGRESS);
+  EXPECT_THAT(events[1].network_packet().local_port(), 8080);
+  EXPECT_THAT(events[1].network_packet().remote_port(), 443);
+  EXPECT_THAT(events[1].network_packet().direction(),
+              TrafficDirection::DIR_INGRESS);
+}
+
+}  // namespace bpf
+}  // namespace android
diff --git a/service-t/native/libs/libnetworkstats/NetworkTracePoller.cpp b/service-t/native/libs/libnetworkstats/NetworkTracePoller.cpp
index 34dbf9e..3abb49a 100644
--- a/service-t/native/libs/libnetworkstats/NetworkTracePoller.cpp
+++ b/service-t/native/libs/libnetworkstats/NetworkTracePoller.cpp
@@ -116,12 +116,16 @@
     return false;
   }
 
-  base::Result<int> ret = mRingBuffer->ConsumeAll(mCallback);
+  std::vector<PacketTrace> packets;
+  base::Result<int> ret = mRingBuffer->ConsumeAll(
+      [&](const PacketTrace& pkt) { packets.push_back(pkt); });
   if (!ret.ok()) {
     ALOGW("Failed to poll ringbuf: %s", ret.error().message().c_str());
     return false;
   }
 
+  mCallback(packets);
+
   return true;
 }
 
diff --git a/service-t/native/libs/libnetworkstats/NetworkTracePollerTest.cpp b/service-t/native/libs/libnetworkstats/NetworkTracePollerTest.cpp
index 28ec208..725cec1 100644
--- a/service-t/native/libs/libnetworkstats/NetworkTracePollerTest.cpp
+++ b/service-t/native/libs/libnetworkstats/NetworkTracePollerTest.cpp
@@ -100,7 +100,7 @@
 };
 
 TEST_F(NetworkTracePollerTest, PollWhileInactive) {
-  NetworkTracePoller handler([&](const PacketTrace& pkt) {});
+  NetworkTracePoller handler([&](const std::vector<PacketTrace>& pkt) {});
 
   // One succeed after start and before stop.
   EXPECT_FALSE(handler.ConsumeAll());
@@ -113,7 +113,7 @@
 TEST_F(NetworkTracePollerTest, ConcurrentSessions) {
   // Simulate two concurrent sessions (two starts followed by two stops). Check
   // that tracing is stopped only after both sessions finish.
-  NetworkTracePoller handler([&](const PacketTrace& pkt) {});
+  NetworkTracePoller handler([&](const std::vector<PacketTrace>& pkt) {});
 
   ASSERT_TRUE(handler.Start(kNeverPoll));
   EXPECT_TRUE(handler.ConsumeAll());
@@ -135,10 +135,12 @@
   // Record all packets with the bound address and current uid. This callback is
   // involked only within ConsumeAll, at which point the port should have
   // already been filled in and all packets have been processed.
-  NetworkTracePoller handler([&](const PacketTrace& pkt) {
-    if (pkt.sport != server_port && pkt.dport != server_port) return;
-    if (pkt.uid != getuid()) return;
-    packets.push_back(pkt);
+  NetworkTracePoller handler([&](const std::vector<PacketTrace>& pkts) {
+    for (const PacketTrace& pkt : pkts) {
+      if (pkt.sport != server_port && pkt.dport != server_port) return;
+      if (pkt.uid != getuid()) return;
+      packets.push_back(pkt);
+    }
   });
 
   ASSERT_TRUE(handler.Start(kNeverPoll));
diff --git a/service-t/native/libs/libnetworkstats/include/netdbpf/NetworkTraceHandler.h b/service-t/native/libs/libnetworkstats/include/netdbpf/NetworkTraceHandler.h
index 1266237..9520d7b 100644
--- a/service-t/native/libs/libnetworkstats/include/netdbpf/NetworkTraceHandler.h
+++ b/service-t/native/libs/libnetworkstats/include/netdbpf/NetworkTraceHandler.h
@@ -46,14 +46,26 @@
   void OnStart(const StartArgs&) override;
   void OnStop(const StopArgs&) override;
 
+  // Writes the packets as Perfetto TracePackets, creating packets as needed
+  // using the provided callback (which allows easy testing).
+  void Write(const std::vector<PacketTrace>& packets,
+             NetworkTraceHandler::TraceContext& ctx);
+
  private:
   // Convert a PacketTrace into a Perfetto trace packet.
   static void Fill(const PacketTrace& src,
                    ::perfetto::protos::pbzero::TracePacket& dst);
 
   static internal::NetworkTracePoller sPoller;
-  uint32_t mPollMs;
   bool mStarted;
+
+  // Values from config, see proto for details.
+  uint32_t mPollMs;
+  uint32_t mInternLimit;
+  uint32_t mAggregationThreshold;
+  bool mDropLocalPort;
+  bool mDropRemotePort;
+  bool mDropTcpFlags;
 };
 
 }  // namespace bpf
diff --git a/service-t/native/libs/libnetworkstats/include/netdbpf/NetworkTracePoller.h b/service-t/native/libs/libnetworkstats/include/netdbpf/NetworkTracePoller.h
index b0189a7..adde51e 100644
--- a/service-t/native/libs/libnetworkstats/include/netdbpf/NetworkTracePoller.h
+++ b/service-t/native/libs/libnetworkstats/include/netdbpf/NetworkTracePoller.h
@@ -38,9 +38,10 @@
 // it is not meant to be used elsewhere.
 class NetworkTracePoller {
  public:
+  using EventSink = std::function<void(const std::vector<PacketTrace>&)>;
+
   // Testonly: initialize with a callback capable of intercepting data.
-  NetworkTracePoller(std::function<void(const PacketTrace&)> callback)
-      : mCallback(std::move(callback)) {}
+  NetworkTracePoller(EventSink callback) : mCallback(std::move(callback)) {}
 
   // Starts tracing with the given poll interval.
   bool Start(uint32_t pollMs) EXCLUDES(mMutex);
@@ -67,7 +68,7 @@
   uint32_t mPollMs GUARDED_BY(mMutex);
 
   // The function to process PacketTrace, typically a Perfetto sink.
-  std::function<void(const PacketTrace&)> mCallback GUARDED_BY(mMutex);
+  EventSink mCallback GUARDED_BY(mMutex);
 
   // The BPF ring buffer handle.
   std::unique_ptr<BpfRingbuf<PacketTrace>> mRingBuffer GUARDED_BY(mMutex);
diff --git a/service/jni/com_android_server_connectivity_ClatCoordinator.cpp b/service/jni/com_android_server_connectivity_ClatCoordinator.cpp
index 5b42659..dae45f3 100644
--- a/service/jni/com_android_server_connectivity_ClatCoordinator.cpp
+++ b/service/jni/com_android_server_connectivity_ClatCoordinator.cpp
@@ -177,7 +177,7 @@
                                                                               jobject clazz) {
     // Will eventually be bound to htons(ETH_P_IPV6) protocol,
     // but only after appropriate bpf filter is attached.
-    int sock = socket(AF_PACKET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
+    const int sock = socket(AF_PACKET, SOCK_RAW | SOCK_CLOEXEC, 0);
     if (sock < 0) {
         throwIOException(env, "packet socket failed", errno);
         return -1;
diff --git a/service/native/libs/libclat/Android.bp b/service/native/libs/libclat/Android.bp
index 54d40ac..996706e 100644
--- a/service/native/libs/libclat/Android.bp
+++ b/service/native/libs/libclat/Android.bp
@@ -23,6 +23,9 @@
         "clatutils.cpp",
     ],
     stl: "libc++_static",
+    header_libs: [
+        "bpf_headers",
+    ],
     static_libs: [
         "libip_checksum",
     ],
diff --git a/service/native/libs/libclat/clatutils.cpp b/service/native/libs/libclat/clatutils.cpp
index c6a9781..6c5c9e3 100644
--- a/service/native/libs/libclat/clatutils.cpp
+++ b/service/native/libs/libclat/clatutils.cpp
@@ -25,6 +25,8 @@
 #include <string.h>
 #include <unistd.h>
 
+#include <bpf/BpfClassic.h>
+
 extern "C" {
 #include "checksum.h"
 }
@@ -33,11 +35,9 @@
 namespace net {
 namespace clat {
 
-bool isIpv4AddressFree(in_addr_t addr) {
-    int s = socket(AF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
-    if (s == -1) {
-        return 0;
-    }
+bool isIpv4AddressFree(const in_addr_t addr) {
+    const int s = socket(AF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
+    if (s == -1) return 0;
 
     // Attempt to connect to the address. If the connection succeeds and getsockname returns the
     // same then the address is already assigned to the system and we can't use it.
@@ -47,9 +47,10 @@
             .sin_addr = {addr},
     };
     socklen_t len = sizeof(sin);
-    bool inuse = connect(s, (struct sockaddr*)&sin, sizeof(sin)) == 0 &&
-                 getsockname(s, (struct sockaddr*)&sin, &len) == 0 && (size_t)len >= sizeof(sin) &&
-                 sin.sin_addr.s_addr == addr;
+    const bool inuse = !connect(s, (struct sockaddr*)&sin, sizeof(sin)) &&
+                       !getsockname(s, (struct sockaddr*)&sin, &len) &&
+                       len == (socklen_t)sizeof(sin) &&
+                       sin.sin_addr.s_addr == addr;
 
     close(s);
     return !inuse;
@@ -59,36 +60,30 @@
 //   ip        - the IP address from the configuration file
 //   prefixlen - the length of the prefix from which addresses may be selected.
 //   returns: the IPv4 address, or INADDR_NONE if no addresses were available
-in_addr_t selectIpv4Address(const in_addr ip, int16_t prefixlen) {
+in_addr_t selectIpv4Address(const in_addr ip, const int16_t prefixlen) {
     return selectIpv4AddressInternal(ip, prefixlen, isIpv4AddressFree);
 }
 
 // Only allow testing to use this function directly. Otherwise call selectIpv4Address(ip, pfxlen)
 // which has applied valid isIpv4AddressFree function pointer.
-in_addr_t selectIpv4AddressInternal(const in_addr ip, int16_t prefixlen,
-                                    isIpv4AddrFreeFn isIpv4AddressFreeFunc) {
+in_addr_t selectIpv4AddressInternal(const in_addr ip, const int16_t prefixlen,
+                                    const isIpv4AddrFreeFn isIpv4AddressFreeFunc) {
     // Impossible! Only test allows to apply fn.
-    if (isIpv4AddressFreeFunc == nullptr) {
-        return INADDR_NONE;
-    }
+    if (isIpv4AddressFreeFunc == nullptr) return INADDR_NONE;
 
     // Don't accept prefixes that are too large because we scan addresses one by one.
-    if (prefixlen < 16 || prefixlen > 32) {
-        return INADDR_NONE;
-    }
+    if (prefixlen < 16 || prefixlen > 32) return INADDR_NONE;
 
     // All these are in host byte order.
-    in_addr_t mask = 0xffffffff >> (32 - prefixlen) << (32 - prefixlen);
-    in_addr_t ipv4 = ntohl(ip.s_addr);
-    in_addr_t first_ipv4 = ipv4;
-    in_addr_t prefix = ipv4 & mask;
+    const uint32_t mask = 0xffffffff >> (32 - prefixlen) << (32 - prefixlen);
+    uint32_t ipv4 = ntohl(ip.s_addr);
+    const uint32_t first_ipv4 = ipv4;
+    const uint32_t prefix = ipv4 & mask;
 
     // Pick the first IPv4 address in the pool, wrapping around if necessary.
     // So, for example, 192.0.0.4 -> 192.0.0.5 -> 192.0.0.6 -> 192.0.0.7 -> 192.0.0.0.
     do {
-        if (isIpv4AddressFreeFunc(htonl(ipv4))) {
-            return htonl(ipv4);
-        }
+        if (isIpv4AddressFreeFunc(htonl(ipv4))) return htonl(ipv4);
         ipv4 = prefix | ((ipv4 + 1) & ~mask);
     } while (ipv4 != first_ipv4);
 
@@ -96,7 +91,7 @@
 }
 
 // Alters the bits in the IPv6 address to make them checksum neutral with v4 and nat64Prefix.
-void makeChecksumNeutral(in6_addr* v6, const in_addr v4, const in6_addr& nat64Prefix) {
+void makeChecksumNeutral(in6_addr* const v6, const in_addr v4, const in6_addr& nat64Prefix) {
     // Fill last 8 bytes of IPv6 address with random bits.
     arc4random_buf(&v6->s6_addr[8], 8);
 
@@ -118,33 +113,35 @@
 }
 
 // Picks a random interface ID that is checksum neutral with the IPv4 address and the NAT64 prefix.
-int generateIpv6Address(const char* iface, const in_addr v4, const in6_addr& nat64Prefix,
-                        in6_addr* v6, uint32_t mark) {
-    int s = socket(AF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, 0);
+int generateIpv6Address(const char* const iface, const in_addr v4, const in6_addr& nat64Prefix,
+                        in6_addr* const v6, const uint32_t mark) {
+    const int s = socket(AF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, 0);
     if (s == -1) return -errno;
 
     // Socket's mark affects routing decisions (network selection)
     // An fwmark is necessary for clat to bypass the VPN during initialization.
     if (setsockopt(s, SOL_SOCKET, SO_MARK, &mark, sizeof(mark))) {
-        int ret = errno;
-        ALOGE("setsockopt(SOL_SOCKET, SO_MARK) failed: %s", strerror(errno));
+        const int err = errno;
+        ALOGE("setsockopt(SOL_SOCKET, SO_MARK) failed: %s", strerror(err));
         close(s);
-        return -ret;
+        return -err;
     }
 
-    if (setsockopt(s, SOL_SOCKET, SO_BINDTODEVICE, iface, strlen(iface) + 1) == -1) {
+    if (setsockopt(s, SOL_SOCKET, SO_BINDTODEVICE, iface, strlen(iface) + 1)) {
+        const int err = errno;
+        ALOGE("setsockopt(SOL_SOCKET, SO_BINDTODEVICE, '%s') failed: %s", iface, strerror(err));
         close(s);
-        return -errno;
+        return -err;
     }
 
     sockaddr_in6 sin6 = {.sin6_family = AF_INET6, .sin6_addr = nat64Prefix};
-    if (connect(s, reinterpret_cast<struct sockaddr*>(&sin6), sizeof(sin6)) == -1) {
+    if (connect(s, reinterpret_cast<struct sockaddr*>(&sin6), sizeof(sin6))) {
         close(s);
         return -errno;
     }
 
     socklen_t len = sizeof(sin6);
-    if (getsockname(s, reinterpret_cast<struct sockaddr*>(&sin6), &len) == -1) {
+    if (getsockname(s, reinterpret_cast<struct sockaddr*>(&sin6), &len)) {
         close(s);
         return -errno;
     }
@@ -163,21 +160,22 @@
     return 0;
 }
 
-int detect_mtu(const struct in6_addr* plat_subnet, uint32_t plat_suffix, uint32_t mark) {
+int detect_mtu(const struct in6_addr* const plat_subnet, const uint32_t plat_suffix,
+               const uint32_t mark) {
     // Create an IPv6 UDP socket.
-    int s = socket(AF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, 0);
+    const int s = socket(AF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, 0);
     if (s < 0) {
-        int ret = errno;
-        ALOGE("socket(AF_INET6, SOCK_DGRAM, 0) failed: %s", strerror(errno));
-        return -ret;
+        const int err = errno;
+        ALOGE("socket(AF_INET6, SOCK_DGRAM, 0) failed: %s", strerror(err));
+        return -err;
     }
 
     // Socket's mark affects routing decisions (network selection)
     if (setsockopt(s, SOL_SOCKET, SO_MARK, &mark, sizeof(mark))) {
-        int ret = errno;
-        ALOGE("setsockopt(SOL_SOCKET, SO_MARK) failed: %s", strerror(errno));
+        const int err = errno;
+        ALOGE("setsockopt(SOL_SOCKET, SO_MARK) failed: %s", strerror(err));
         close(s);
-        return -ret;
+        return -err;
     }
 
     // Try to connect udp socket to plat_subnet(96 bits):plat_suffix(32 bits)
@@ -187,20 +185,20 @@
     };
     dst.sin6_addr.s6_addr32[3] = plat_suffix;
     if (connect(s, (struct sockaddr*)&dst, sizeof(dst))) {
-        int ret = errno;
-        ALOGE("connect() failed: %s", strerror(errno));
+        const int err = errno;
+        ALOGE("connect() failed: %s", strerror(err));
         close(s);
-        return -ret;
+        return -err;
     }
 
     // Fetch the socket's IPv6 mtu - this is effectively fetching mtu from routing table
     int mtu;
     socklen_t sz_mtu = sizeof(mtu);
     if (getsockopt(s, SOL_IPV6, IPV6_MTU, &mtu, &sz_mtu)) {
-        int ret = errno;
-        ALOGE("getsockopt(SOL_IPV6, IPV6_MTU) failed: %s", strerror(errno));
+        const int err = errno;
+        ALOGE("getsockopt(SOL_IPV6, IPV6_MTU) failed: %s", strerror(err));
         close(s);
-        return -ret;
+        return -err;
     }
     if (sz_mtu != sizeof(mtu)) {
         ALOGE("getsockopt(SOL_IPV6, IPV6_MTU) returned unexpected size: %d", sz_mtu);
@@ -219,34 +217,26 @@
  *   ifindex - index of interface to add the filter to
  * returns: 0 on success, -errno on failure
  */
-int configure_packet_socket(int sock, in6_addr* addr, int ifindex) {
-    uint32_t* ipv6 = addr->s6_addr32;
-
+int configure_packet_socket(const int sock, const in6_addr* const addr, const int ifindex) {
     // clang-format off
     struct sock_filter filter_code[] = {
-    // Load the first four bytes of the IPv6 destination address (starts 24 bytes in).
-    // Compare it against the first four bytes of our IPv6 address, in host byte order (BPF loads
-    // are always in host byte order). If it matches, continue with next instruction (JMP 0). If it
-    // doesn't match, jump ahead to statement that returns 0 (ignore packet). Repeat for the other
-    // three words of the IPv6 address, and if they all match, return full packet (accept packet).
-        BPF_STMT(BPF_LD  | BPF_W   | BPF_ABS,  24),
-        BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K,    htonl(ipv6[0]), 0, 7),
-        BPF_STMT(BPF_LD  | BPF_W   | BPF_ABS,  28),
-        BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K,    htonl(ipv6[1]), 0, 5),
-        BPF_STMT(BPF_LD  | BPF_W   | BPF_ABS,  32),
-        BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K,    htonl(ipv6[2]), 0, 3),
-        BPF_STMT(BPF_LD  | BPF_W   | BPF_ABS,  36),
-        BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K,    htonl(ipv6[3]), 0, 1),
-        BPF_STMT(BPF_RET | BPF_K,              0xFFFFFFFF),
-        BPF_STMT(BPF_RET | BPF_K,              0),
+        BPF_LOAD_IPV6_BE32(daddr.s6_addr32[0]),
+        BPF2_REJECT_IF_NOT_EQUAL(ntohl(addr->s6_addr32[0])),
+        BPF_LOAD_IPV6_BE32(daddr.s6_addr32[1]),
+        BPF2_REJECT_IF_NOT_EQUAL(ntohl(addr->s6_addr32[1])),
+        BPF_LOAD_IPV6_BE32(daddr.s6_addr32[2]),
+        BPF2_REJECT_IF_NOT_EQUAL(ntohl(addr->s6_addr32[2])),
+        BPF_LOAD_IPV6_BE32(daddr.s6_addr32[3]),
+        BPF2_REJECT_IF_NOT_EQUAL(ntohl(addr->s6_addr32[3])),
+        BPF_ACCEPT,
     };
     // clang-format on
     struct sock_fprog filter = {sizeof(filter_code) / sizeof(filter_code[0]), filter_code};
 
     if (setsockopt(sock, SOL_SOCKET, SO_ATTACH_FILTER, &filter, sizeof(filter))) {
-        int res = errno;
-        ALOGE("attach packet filter failed: %s", strerror(errno));
-        return -res;
+        const int err = errno;
+        ALOGE("attach packet filter failed: %s", strerror(err));
+        return -err;
     }
 
     struct sockaddr_ll sll = {
@@ -257,9 +247,9 @@
                     PACKET_OTHERHOST,  // The 464xlat IPv6 address is not assigned to the kernel.
     };
     if (bind(sock, (struct sockaddr*)&sll, sizeof(sll))) {
-        int res = errno;
-        ALOGE("binding packet socket: %s", strerror(errno));
-        return -res;
+        const int err = errno;
+        ALOGE("binding packet socket: %s", strerror(err));
+        return -err;
     }
 
     return 0;
diff --git a/service/native/libs/libclat/clatutils_test.cpp b/service/native/libs/libclat/clatutils_test.cpp
index abd4e81..f4f97db 100644
--- a/service/native/libs/libclat/clatutils_test.cpp
+++ b/service/native/libs/libclat/clatutils_test.cpp
@@ -165,7 +165,7 @@
     TunInterface v6Iface;
     ASSERT_EQ(0, v6Iface.init());
 
-    int s = socket(AF_PACKET, SOCK_DGRAM | SOCK_CLOEXEC, htons(ETH_P_IPV6));
+    const int s = socket(AF_PACKET, SOCK_RAW | SOCK_CLOEXEC, htons(ETH_P_IPV6));
     EXPECT_LE(0, s);
     struct in6_addr addr6;
     EXPECT_EQ(1, inet_pton(AF_INET6, "2001:db8::f00", &addr6));
diff --git a/service/native/libs/libclat/include/libclat/clatutils.h b/service/native/libs/libclat/include/libclat/clatutils.h
index 991b193..6e17e67 100644
--- a/service/native/libs/libclat/include/libclat/clatutils.h
+++ b/service/native/libs/libclat/include/libclat/clatutils.h
@@ -20,17 +20,19 @@
 namespace net {
 namespace clat {
 
-bool isIpv4AddressFree(in_addr_t addr);
-in_addr_t selectIpv4Address(const in_addr ip, int16_t prefixlen);
-void makeChecksumNeutral(in6_addr* v6, const in_addr v4, const in6_addr& nat64Prefix);
-int generateIpv6Address(const char* iface, const in_addr v4, const in6_addr& nat64Prefix,
-                        in6_addr* v6, uint32_t mark);
-int detect_mtu(const struct in6_addr* plat_subnet, uint32_t plat_suffix, uint32_t mark);
-int configure_packet_socket(int sock, in6_addr* addr, int ifindex);
+bool isIpv4AddressFree(const in_addr_t addr);
+in_addr_t selectIpv4Address(const in_addr ip, const int16_t prefixlen);
+void makeChecksumNeutral(in6_addr* const v6, const in_addr v4, const in6_addr& nat64Prefix);
+int generateIpv6Address(const char* const iface, const in_addr v4, const in6_addr& nat64Prefix,
+                        in6_addr* const v6, const uint32_t mark);
+int detect_mtu(const struct in6_addr* const plat_subnet, const uint32_t plat_suffix,
+               const uint32_t mark);
+int configure_packet_socket(const int sock, const in6_addr* const addr, const int ifindex);
 
 // For testing
-typedef bool (*isIpv4AddrFreeFn)(in_addr_t);
-in_addr_t selectIpv4AddressInternal(const in_addr ip, int16_t prefixlen, isIpv4AddrFreeFn fn);
+typedef bool (*isIpv4AddrFreeFn)(const in_addr_t);
+in_addr_t selectIpv4AddressInternal(const in_addr ip, const int16_t prefixlen,
+                                    const isIpv4AddrFreeFn fn);
 
 }  // namespace clat
 }  // namespace net
diff --git a/service/src/com/android/server/ConnectivityService.java b/service/src/com/android/server/ConnectivityService.java
index 5f51971..e969cd6 100755
--- a/service/src/com/android/server/ConnectivityService.java
+++ b/service/src/com/android/server/ConnectivityService.java
@@ -911,7 +911,7 @@
 
     // This is the cache for the packageName -> ApplicationSelfCertifiedNetworkCapabilities. This
     // value can be accessed from both handler thread and any random binder thread. Therefore,
-    // accessing this value requires holding a lock.
+    // accessing this value requires holding a lock. The cache is the same across all the users.
     @GuardedBy("mSelfCertifiedCapabilityCache")
     private final Map<String, ApplicationSelfCertifiedNetworkCapabilities>
             mSelfCertifiedCapabilityCache = new HashMap<>();
@@ -7001,6 +7001,7 @@
             return;
         }
         ApplicationSelfCertifiedNetworkCapabilities applicationNetworkCapabilities;
+        final long ident = Binder.clearCallingIdentity();
         try {
             synchronized (mSelfCertifiedCapabilityCache) {
                 applicationNetworkCapabilities = mSelfCertifiedCapabilityCache.get(
@@ -7027,6 +7028,8 @@
                             + " property");
         } catch (XmlPullParserException | IOException | InvalidTagException e) {
             throw new SecurityException(e.getMessage());
+        } finally {
+            Binder.restoreCallingIdentity(ident);
         }
 
         applicationNetworkCapabilities.enforceSelfCertifiedNetworkCapabilitiesDeclared(
@@ -8467,6 +8470,7 @@
         exemptUids[1] = nai.networkCapabilities.getOwnerUid();
         UidRangeParcel[] ranges = toUidRangeStableParcels(uidRanges);
 
+        // Close sockets before modifying uid ranges so that RST packets can reach to the server.
         maybeCloseSockets(nai, ranges, exemptUids);
         try {
             if (add) {
@@ -8480,6 +8484,7 @@
             loge("Exception while " + (add ? "adding" : "removing") + " uid ranges " + uidRanges +
                     " on netId " + nai.network.netId + ". " + e);
         }
+        // Close sockets that established connection while requesting netd.
         maybeCloseSockets(nai, ranges, exemptUids);
     }
 
diff --git a/tests/cts/net/src/android/net/cts/ConnectivityManagerTest.java b/tests/cts/net/src/android/net/cts/ConnectivityManagerTest.java
index 0bb6000..774176f 100644
--- a/tests/cts/net/src/android/net/cts/ConnectivityManagerTest.java
+++ b/tests/cts/net/src/android/net/cts/ConnectivityManagerTest.java
@@ -2708,6 +2708,7 @@
         // Cannot use @IgnoreUpTo(Build.VERSION_CODES.R) because this test also requires API 31
         // shims, and @IgnoreUpTo does not check that.
         assumeTrue(TestUtils.shouldTestSApis());
+        assumeTrue(mPackageManager.hasSystemFeature(FEATURE_WIFI));
 
         final TestNetworkTracker tnt = callWithShellPermissionIdentity(
                 () -> initTestNetwork(mContext, TEST_LINKADDR, NETWORK_CALLBACK_TIMEOUT_MS));
@@ -2721,7 +2722,8 @@
                     OemNetworkPreferences.OEM_NETWORK_PREFERENCE_TEST_ONLY);
             registerTestOemNetworkPreferenceCallbacks(defaultCallback, systemDefaultCallback);
             waitForAvailable(defaultCallback, tnt.getNetwork());
-            waitForAvailable(systemDefaultCallback, wifiNetwork);
+            systemDefaultCallback.eventuallyExpect(CallbackEntry.AVAILABLE,
+                    NETWORK_CALLBACK_TIMEOUT_MS, cb -> wifiNetwork.equals(cb.getNetwork()));
         }, /* cleanup */ () -> {
                 runWithShellPermissionIdentity(tnt::teardown);
                 defaultCallback.expect(CallbackEntry.LOST, tnt, NETWORK_CALLBACK_TIMEOUT_MS);
@@ -3406,6 +3408,9 @@
 
     private static final boolean EXPECT_PASS = false;
     private static final boolean EXPECT_BLOCK = true;
+
+    // ALLOWLIST means the firewall denies all by default, uids must be explicitly allowed
+    // DENYLIST means the firewall allows all by default, uids must be explicitly denyed
     private static final boolean ALLOWLIST = true;
     private static final boolean DENYLIST = false;
 
@@ -3471,17 +3476,49 @@
 
     @Test @IgnoreUpTo(SC_V2) @ConnectivityModuleTest
     @AppModeFull(reason = "Socket cannot bind in instant app mode")
-    public void testFirewallBlocking() {
-        // ALLOWLIST means the firewall denies all by default, uids must be explicitly allowed
+    public void testFirewallBlockingDozable() {
         doTestFirewallBlocking(FIREWALL_CHAIN_DOZABLE, ALLOWLIST);
-        doTestFirewallBlocking(FIREWALL_CHAIN_POWERSAVE, ALLOWLIST);
-        doTestFirewallBlocking(FIREWALL_CHAIN_RESTRICTED, ALLOWLIST);
-        doTestFirewallBlocking(FIREWALL_CHAIN_LOW_POWER_STANDBY, ALLOWLIST);
+    }
 
-        // DENYLIST means the firewall allows all by default, uids must be explicitly denyed
+    @Test @IgnoreUpTo(SC_V2) @ConnectivityModuleTest
+    @AppModeFull(reason = "Socket cannot bind in instant app mode")
+    public void testFirewallBlockingPowersave() {
+        doTestFirewallBlocking(FIREWALL_CHAIN_POWERSAVE, ALLOWLIST);
+    }
+
+    @Test @IgnoreUpTo(SC_V2) @ConnectivityModuleTest
+    @AppModeFull(reason = "Socket cannot bind in instant app mode")
+    public void testFirewallBlockingRestricted() {
+        doTestFirewallBlocking(FIREWALL_CHAIN_RESTRICTED, ALLOWLIST);
+    }
+
+    @Test @IgnoreUpTo(SC_V2) @ConnectivityModuleTest
+    @AppModeFull(reason = "Socket cannot bind in instant app mode")
+    public void testFirewallBlockingLowPowerStandby() {
+        doTestFirewallBlocking(FIREWALL_CHAIN_LOW_POWER_STANDBY, ALLOWLIST);
+    }
+
+    @Test @IgnoreUpTo(SC_V2) @ConnectivityModuleTest
+    @AppModeFull(reason = "Socket cannot bind in instant app mode")
+    public void testFirewallBlockingStandby() {
         doTestFirewallBlocking(FIREWALL_CHAIN_STANDBY, DENYLIST);
+    }
+
+    @Test @IgnoreUpTo(SC_V2) @ConnectivityModuleTest
+    @AppModeFull(reason = "Socket cannot bind in instant app mode")
+    public void testFirewallBlockingOemDeny1() {
         doTestFirewallBlocking(FIREWALL_CHAIN_OEM_DENY_1, DENYLIST);
+    }
+
+    @Test @IgnoreUpTo(SC_V2) @ConnectivityModuleTest
+    @AppModeFull(reason = "Socket cannot bind in instant app mode")
+    public void testFirewallBlockingOemDeny2() {
         doTestFirewallBlocking(FIREWALL_CHAIN_OEM_DENY_2, DENYLIST);
+    }
+
+    @Test @IgnoreUpTo(SC_V2) @ConnectivityModuleTest
+    @AppModeFull(reason = "Socket cannot bind in instant app mode")
+    public void testFirewallBlockingOemDeny3() {
         doTestFirewallBlocking(FIREWALL_CHAIN_OEM_DENY_3, DENYLIST);
     }
 
diff --git a/tests/cts/net/src/android/net/cts/NsdManagerTest.kt b/tests/cts/net/src/android/net/cts/NsdManagerTest.kt
index 3f197c4..6fd2321 100644
--- a/tests/cts/net/src/android/net/cts/NsdManagerTest.kt
+++ b/tests/cts/net/src/android/net/cts/NsdManagerTest.kt
@@ -68,6 +68,7 @@
 import android.system.ErrnoException
 import android.system.Os
 import android.system.OsConstants.AF_INET6
+import android.system.OsConstants.EADDRNOTAVAIL
 import android.system.OsConstants.ENETUNREACH
 import android.system.OsConstants.IPPROTO_UDP
 import android.system.OsConstants.SOCK_DGRAM
@@ -404,7 +405,7 @@
                 Os.connect(sock, parseNumericAddress("ff02::fb%$ifaceName"), 12345)
                 true
             }.catch<ErrnoException> {
-                if (it.errno != ENETUNREACH) {
+                if (it.errno != ENETUNREACH && it.errno != EADDRNOTAVAIL) {
                     throw it
                 }
                 false
diff --git a/tools/gn2bp/Android.bp.swp b/tools/gn2bp/Android.bp.swp
index d22a576..a0696d9 100644
--- a/tools/gn2bp/Android.bp.swp
+++ b/tools/gn2bp/Android.bp.swp
@@ -16,7 +16,7 @@
 
 build = ["Android.extras.bp"]
 
-// GN: PACKAGE
+// The actual license can be found in Android.extras.bp
 package {
     default_applicable_licenses: [
         "external_cronet_license",
@@ -36,6 +36,7 @@
         "components/cronet/android/api/src/android/net/http/ExperimentalBidirectionalStream.java",
         "components/cronet/android/api/src/android/net/http/ExperimentalHttpEngine.java",
         "components/cronet/android/api/src/android/net/http/ExperimentalUrlRequest.java",
+        "components/cronet/android/api/src/android/net/http/HeaderBlock.java",
         "components/cronet/android/api/src/android/net/http/HttpEngine.java",
         "components/cronet/android/api/src/android/net/http/HttpException.java",
         "components/cronet/android/api/src/android/net/http/IHttpEngineBuilder.java",
@@ -292,6 +293,7 @@
 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",
@@ -345,9 +347,6 @@
         "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",
@@ -559,15 +558,13 @@
     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",
@@ -580,15 +577,13 @@
         },
         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",
@@ -604,15 +599,13 @@
         },
         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",
@@ -625,15 +618,13 @@
         },
         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",
@@ -943,6 +934,56 @@
 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",
@@ -1378,66 +1419,16 @@
         "base/vlog.cc",
     ],
     shared_libs: [
+        "//external/cronet/third_party/boringssl:libcrypto",
+        "//external/cronet/third_party/boringssl:libssl",
         "libandroid",
         "liblog",
     ],
     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",
@@ -1616,6 +1607,54 @@
 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",
@@ -1983,58 +2022,9 @@
     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",
@@ -2146,6 +2136,8 @@
         },
         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",
@@ -2222,10 +2214,6 @@
                 "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",
@@ -2242,6 +2230,13 @@
                 "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",
@@ -2262,6 +2257,8 @@
         },
         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",
@@ -2334,10 +2331,6 @@
                 "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",
@@ -2356,6 +2349,13 @@
                 "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",
@@ -2376,6 +2376,8 @@
         },
         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,10 +2450,6 @@
                 "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",
@@ -2468,6 +2466,13 @@
                 "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",
@@ -2488,6 +2493,8 @@
         },
         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",
@@ -2560,10 +2567,6 @@
                 "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",
@@ -2581,6 +2584,13 @@
                 "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",
@@ -3396,7 +3406,7 @@
 cc_genrule {
     name: "cronet_aml_base_build_date",
     cmd: "$(location build/write_build_date_header.py) $(out) " +
-         "1674644139",
+         "1678293768",
     out: [
         "base/generated_build_date.h",
     ],
@@ -3412,7 +3422,7 @@
 cc_genrule {
     name: "cronet_aml_base_build_date__testing",
     cmd: "$(location build/write_build_date_header.py) $(out) " +
-         "1674644139",
+         "1678293768",
     host_supported: true,
     out: [
         "base/generated_build_date.h",
@@ -3735,60 +3745,9 @@
         "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",
@@ -4094,7 +4053,7 @@
 }
 
 // GN: //base:nodebug_assertion
-cc_library_static {
+cc_object {
     name: "cronet_aml_base_nodebug_assertion",
     srcs: [
         "base/nodebug_assertion.cc",
@@ -4139,11 +4098,6 @@
         "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: [
@@ -4172,7 +4126,7 @@
 }
 
 // GN: //base:nodebug_assertion__testing
-cc_library_static {
+cc_object {
     name: "cronet_aml_base_nodebug_assertion__testing",
     srcs: [
         "base/nodebug_assertion.cc",
@@ -4213,11 +4167,6 @@
         "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: [
@@ -4701,60 +4650,9 @@
         "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",
@@ -4858,6 +4756,55 @@
 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",
@@ -4935,65 +4882,12 @@
         "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",
@@ -5931,7 +5825,7 @@
 }
 
 // GN: //buildtools/third_party/libc++:libc++
-cc_library_static {
+cc_object {
     name: "cronet_aml_buildtools_third_party_libc___libc__",
     srcs: [
         "buildtools/third_party/libc++/trunk/src/algorithm.cpp",
@@ -5977,9 +5871,6 @@
         "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",
@@ -6015,11 +5906,6 @@
         "buildtools/third_party/libc++abi/trunk/include",
     ],
     cpp_std: "c++20",
-    ldflags: [
-        "-Wl,--as-needed",
-        "-Wl,--gc-sections",
-        "-Wl,--icf=all",
-    ],
     cppflags: [
         "-fexceptions",
     ],
@@ -6083,7 +5969,7 @@
 }
 
 // GN: //buildtools/third_party/libc++:libc++__testing
-cc_library_static {
+cc_object {
     name: "cronet_aml_buildtools_third_party_libc___libc____testing",
     srcs: [
         "buildtools/third_party/libc++/trunk/src/algorithm.cpp",
@@ -6129,9 +6015,6 @@
         "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",
@@ -6167,11 +6050,6 @@
         "buildtools/third_party/libc++abi/trunk/include",
     ],
     cpp_std: "c++20",
-    ldflags: [
-        "-Wl,--as-needed",
-        "-Wl,--gc-sections",
-        "-Wl,--icf=all",
-    ],
     cppflags: [
         "-fexceptions",
     ],
@@ -6235,7 +6113,7 @@
 }
 
 // GN: //buildtools/third_party/libc++abi:libc++abi
-cc_library_static {
+cc_object {
     name: "cronet_aml_buildtools_third_party_libc__abi_libc__abi",
     srcs: [
         "buildtools/third_party/libc++abi/trunk/src/abort_message.cpp",
@@ -6289,11 +6167,6 @@
         "buildtools/third_party/libc++abi/trunk/include",
     ],
     cpp_std: "c++20",
-    ldflags: [
-        "-Wl,--as-needed",
-        "-Wl,--gc-sections",
-        "-Wl,--icf=all",
-    ],
     cppflags: [
         "-fexceptions",
     ],
@@ -6372,7 +6245,7 @@
 }
 
 // GN: //buildtools/third_party/libc++abi:libc++abi__testing
-cc_library_static {
+cc_object {
     name: "cronet_aml_buildtools_third_party_libc__abi_libc__abi__testing",
     srcs: [
         "buildtools/third_party/libc++abi/trunk/src/abort_message.cpp",
@@ -6426,11 +6299,6 @@
         "buildtools/third_party/libc++abi/trunk/include",
     ],
     cpp_std: "c++20",
-    ldflags: [
-        "-Wl,--as-needed",
-        "-Wl,--gc-sections",
-        "-Wl,--icf=all",
-    ],
     cppflags: [
         "-fexceptions",
     ],
@@ -6558,9 +6426,17 @@
 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: [
+        "//external/cronet/third_party/boringssl:libcrypto",
+        "//external/cronet/third_party/boringssl:libssl",
         "libandroid",
         "liblog",
         "libz",
@@ -6569,79 +6445,14 @@
         "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",
@@ -6651,6 +6462,30 @@
         "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",
     ],
@@ -7033,6 +6868,7 @@
         "components/cronet/android/java/src/org/chromium/net/impl/CronetUploadDataStream.java",
         "components/cronet/android/java/src/org/chromium/net/impl/CronetUrlRequest.java",
         "components/cronet/android/java/src/org/chromium/net/impl/CronetUrlRequestContext.java",
+        "components/cronet/android/java/src/org/chromium/net/impl/HeaderBlockImpl.java",
         "components/cronet/android/java/src/org/chromium/net/impl/NativeCronetEngineBuilderImpl.java",
         "components/cronet/android/java/src/org/chromium/net/impl/NetworkExceptionImpl.java",
         "components/cronet/android/java/src/org/chromium/net/impl/NoOpLogger.java",
@@ -7286,6 +7122,7 @@
         "components/cronet/android/java/src/org/chromium/net/impl/CronetUploadDataStream.java",
         "components/cronet/android/java/src/org/chromium/net/impl/CronetUrlRequest.java",
         "components/cronet/android/java/src/org/chromium/net/impl/CronetUrlRequestContext.java",
+        "components/cronet/android/java/src/org/chromium/net/impl/HeaderBlockImpl.java",
         "components/cronet/android/java/src/org/chromium/net/impl/NativeCronetEngineBuilderImpl.java",
         "components/cronet/android/java/src/org/chromium/net/impl/NetworkExceptionImpl.java",
         "components/cronet/android/java/src/org/chromium/net/impl/NoOpLogger.java",
@@ -7535,6 +7372,7 @@
         "components/cronet/android/java/src/org/chromium/net/impl/CronetUploadDataStream.java",
         "components/cronet/android/java/src/org/chromium/net/impl/CronetUrlRequest.java",
         "components/cronet/android/java/src/org/chromium/net/impl/CronetUrlRequestContext.java",
+        "components/cronet/android/java/src/org/chromium/net/impl/HeaderBlockImpl.java",
         "components/cronet/android/java/src/org/chromium/net/impl/NativeCronetEngineBuilderImpl.java",
         "components/cronet/android/java/src/org/chromium/net/impl/NetworkExceptionImpl.java",
         "components/cronet/android/java/src/org/chromium/net/impl/NoOpLogger.java",
@@ -7782,6 +7620,7 @@
         "components/cronet/android/java/src/org/chromium/net/impl/CronetUploadDataStream.java",
         "components/cronet/android/java/src/org/chromium/net/impl/CronetUrlRequest.java",
         "components/cronet/android/java/src/org/chromium/net/impl/CronetUrlRequestContext.java",
+        "components/cronet/android/java/src/org/chromium/net/impl/HeaderBlockImpl.java",
         "components/cronet/android/java/src/org/chromium/net/impl/NativeCronetEngineBuilderImpl.java",
         "components/cronet/android/java/src/org/chromium/net/impl/NetworkExceptionImpl.java",
         "components/cronet/android/java/src/org/chromium/net/impl/NoOpLogger.java",
@@ -7861,7 +7700,7 @@
 }
 
 // GN: //components/cronet/android:cronet_static
-cc_library_static {
+cc_object {
     name: "cronet_aml_components_cronet_android_cronet_static",
     srcs: [
         "components/cronet/android/cronet_bidirectional_stream_adapter.cc",
@@ -7873,6 +7712,8 @@
         "components/cronet/android/url_request_error.cc",
     ],
     shared_libs: [
+        "//external/cronet/third_party/boringssl:libcrypto",
+        "//external/cronet/third_party/boringssl:libssl",
         "libandroid",
         "liblog",
         "libz",
@@ -7881,76 +7722,14 @@
         "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",
@@ -7967,15 +7746,9 @@
         "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",
-    ],
-    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: [
@@ -8024,27 +7797,6 @@
         "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: [
@@ -8073,7 +7825,7 @@
 }
 
 // GN: //components/cronet/android:cronet_static__testing
-cc_library_static {
+cc_object {
     name: "cronet_aml_components_cronet_android_cronet_static__testing",
     srcs: [
         "components/cronet/android/cronet_bidirectional_stream_adapter.cc",
@@ -8093,76 +7845,15 @@
         "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",
@@ -8179,15 +7870,9 @@
         "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",
-    ],
-    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_third_party_metrics_proto_metrics_proto__testing_gen_headers",
         "cronet_aml_url_buildflags__testing",
     ],
     defaults: [
@@ -8236,27 +7921,6 @@
         "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: [
@@ -8288,6 +7952,15 @@
 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: [
@@ -8300,98 +7973,25 @@
         "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",
@@ -8402,6 +8002,32 @@
         "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",
     ],
@@ -8812,7 +8438,7 @@
 }
 
 // GN: //components/cronet:cronet_common
-cc_library_static {
+cc_object {
     name: "cronet_aml_components_cronet_cronet_common",
     srcs: [
         "components/cronet/cronet_context.cc",
@@ -8824,6 +8450,8 @@
         "components/cronet/url_request_context_config.cc",
     ],
     shared_libs: [
+        "//external/cronet/third_party/boringssl:libcrypto",
+        "//external/cronet/third_party/boringssl:libssl",
         "libandroid",
         "liblog",
         "libz",
@@ -8832,74 +8460,14 @@
         "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",
@@ -8911,9 +8479,8 @@
     ],
     generated_headers: [
         "cronet_aml_components_cronet_cronet_buildflags",
-    ],
-    export_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",
     ],
     defaults: [
         "cronet_aml_defaults",
@@ -8961,27 +8528,6 @@
         "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: [
@@ -9010,7 +8556,7 @@
 }
 
 // GN: //components/cronet:cronet_common__testing
-cc_library_static {
+cc_object {
     name: "cronet_aml_components_cronet_cronet_common__testing",
     srcs: [
         "components/cronet/cronet_context.cc",
@@ -9030,74 +8576,15 @@
         "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",
@@ -9109,9 +8596,8 @@
     ],
     generated_headers: [
         "cronet_aml_components_cronet_cronet_buildflags__testing",
-    ],
-    export_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",
@@ -9159,27 +8645,6 @@
         "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: [
@@ -9208,7 +8673,7 @@
 }
 
 // GN: //components/cronet:cronet_common_unittests__testing
-cc_library_static {
+cc_object {
     name: "cronet_aml_components_cronet_cronet_common_unittests__testing",
     srcs: [
         "components/cronet/host_cache_persistence_manager_unittest.cc",
@@ -9226,91 +8691,25 @@
         "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",
@@ -9321,6 +8720,11 @@
         "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",
     ],
@@ -9387,181 +8791,6 @@
         "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: [
@@ -9642,12 +8871,14 @@
 }
 
 // GN: //components/cronet:metrics_util
-cc_library_static {
+cc_object {
     name: "cronet_aml_components_cronet_metrics_util",
     srcs: [
         "components/cronet/metrics_util.cc",
     ],
     shared_libs: [
+        "//external/cronet/third_party/boringssl:libcrypto",
+        "//external/cronet/third_party/boringssl:libssl",
         "libandroid",
         "liblog",
     ],
@@ -9655,60 +8886,8 @@
         "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",
@@ -9752,27 +8931,6 @@
         "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: [
@@ -9801,7 +8959,7 @@
 }
 
 // GN: //components/cronet:metrics_util__testing
-cc_library_static {
+cc_object {
     name: "cronet_aml_components_cronet_metrics_util__testing",
     srcs: [
         "components/cronet/metrics_util.cc",
@@ -9814,60 +8972,9 @@
         "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",
@@ -9911,27 +9018,6 @@
         "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: [
@@ -9960,7 +9046,7 @@
 }
 
 // GN: //components/metrics:library_support
-cc_library_static {
+cc_object {
     name: "cronet_aml_components_metrics_library_support",
     srcs: [
         ":cronet_aml_third_party_metrics_proto_metrics_proto_gen",
@@ -9968,6 +9054,8 @@
         "components/metrics/library_support/histogram_manager.cc",
     ],
     shared_libs: [
+        "//external/cronet/third_party/boringssl:libcrypto",
+        "//external/cronet/third_party/boringssl:libssl",
         "libandroid",
         "liblog",
         "libprotobuf-cpp-lite",
@@ -9976,60 +9064,8 @@
         "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",
@@ -10039,9 +9075,6 @@
     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",
     ],
@@ -10085,27 +9118,6 @@
         "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: [
@@ -10134,7 +9146,7 @@
 }
 
 // GN: //components/metrics:library_support__testing
-cc_library_static {
+cc_object {
     name: "cronet_aml_components_metrics_library_support__testing",
     srcs: [
         ":cronet_aml_third_party_metrics_proto_metrics_proto__testing_gen",
@@ -10150,60 +9162,9 @@
         "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",
@@ -10213,9 +9174,6 @@
     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",
     ],
@@ -10259,27 +9217,6 @@
         "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: [
@@ -10400,6 +9337,8 @@
         "components/prefs/writeable_pref_store.cc",
     ],
     shared_libs: [
+        "//external/cronet/third_party/boringssl:libcrypto",
+        "//external/cronet/third_party/boringssl:libssl",
         "libandroid",
         "liblog",
     ],
@@ -10407,60 +9346,8 @@
         "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",
@@ -10599,60 +9486,9 @@
         "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",
@@ -10761,6 +9597,55 @@
 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",
@@ -10777,67 +9662,14 @@
         "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",
@@ -10846,6 +9678,12 @@
         "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",
     ],
@@ -11023,6 +9861,8 @@
         "crypto/unexportable_key_metrics.cc",
     ],
     shared_libs: [
+        "//external/cronet/third_party/boringssl:libcrypto",
+        "//external/cronet/third_party/boringssl:libssl",
         "libandroid",
         "liblog",
     ],
@@ -11030,60 +9870,8 @@
         "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",
@@ -11210,58 +9998,9 @@
         "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",
@@ -11322,10 +10061,6 @@
             ],
         },
         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",
@@ -11352,10 +10087,6 @@
             ],
         },
         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",
@@ -11384,10 +10115,6 @@
             ],
         },
         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",
@@ -11414,10 +10141,6 @@
             ],
         },
         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",
@@ -11462,6 +10185,115 @@
     },
 }
 
+// GN: //crypto:test_support__testing
+cc_library_static {
+    name: "cronet_aml_crypto_test_support__testing",
+    srcs: [
+        "crypto/scoped_mock_unexportable_key_provider.cc",
+    ],
+    shared_libs: [
+        "libandroid",
+        "liblog",
+    ],
+    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_third_party_double_conversion_double_conversion__testing",
+        "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations__testing",
+        "cronet_aml_crypto_crypto__testing",
+        "cronet_aml_third_party_boringssl_boringssl__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",
+    ],
+    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",
+        "third_party/abseil-cpp/",
+        "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: [
+                "-fstack-protector",
+            ],
+        },
+        android_arm64: {
+            cflags: [
+                "-fstack-protector",
+                "-mno-outline",
+                "-mno-outline-atomics",
+            ],
+        },
+        android_x86: {
+            cflags: [
+                "-msse3",
+            ],
+        },
+        android_x86_64: {
+            cflags: [
+                "-fstack-protector",
+                "-msse3",
+            ],
+        },
+    },
+}
+
 // GN: //gn:default_deps
 cc_defaults {
     name: "cronet_aml_defaults",
@@ -11700,6 +10532,7 @@
         "components/cronet/android/java/src/org/chromium/net/impl/CronetUploadDataStream.java",
         "components/cronet/android/java/src/org/chromium/net/impl/CronetUrlRequest.java",
         "components/cronet/android/java/src/org/chromium/net/impl/CronetUrlRequestContext.java",
+        "components/cronet/android/java/src/org/chromium/net/impl/HeaderBlockImpl.java",
         "components/cronet/android/java/src/org/chromium/net/impl/NativeCronetEngineBuilderImpl.java",
         "components/cronet/android/java/src/org/chromium/net/impl/NetworkExceptionImpl.java",
         "components/cronet/android/java/src/org/chromium/net/impl/NoOpLogger.java",
@@ -11977,6 +10810,7 @@
         "components/cronet/android/java/src/org/chromium/net/impl/CronetUploadDataStream.java",
         "components/cronet/android/java/src/org/chromium/net/impl/CronetUrlRequest.java",
         "components/cronet/android/java/src/org/chromium/net/impl/CronetUrlRequestContext.java",
+        "components/cronet/android/java/src/org/chromium/net/impl/HeaderBlockImpl.java",
         "components/cronet/android/java/src/org/chromium/net/impl/NativeCronetEngineBuilderImpl.java",
         "components/cronet/android/java/src/org/chromium/net/impl/NetworkExceptionImpl.java",
         "components/cronet/android/java/src/org/chromium/net/impl/NoOpLogger.java",
@@ -12151,33 +10985,92 @@
     ],
 }
 
+// GN: //net/base/registry_controlled_domains:lookup_strings_test_sets__testing
+cc_genrule {
+    name: "cronet_aml_net_base_registry_controlled_domains_lookup_strings_test_sets__testing",
+    cmd: "$(location net/tools/dafsa/make_dafsa.py) $(location net/base/registry_controlled_domains/effective_tld_names.gperf) " +
+         "$(location net/base/registry_controlled_domains/effective_tld_names-inc.cc) " +
+         "&& " +
+         "python3 $(location net/tools/dafsa/make_dafsa.py) " +
+         "$(location net/base/registry_controlled_domains/effective_tld_names_unittest1.gperf) " +
+         "$(location net/base/registry_controlled_domains/effective_tld_names_unittest1-inc.cc) " +
+         "&& " +
+         "python3 $(location net/tools/dafsa/make_dafsa.py) " +
+         "$(location net/base/registry_controlled_domains/effective_tld_names_unittest2.gperf) " +
+         "$(location net/base/registry_controlled_domains/effective_tld_names_unittest2-inc.cc) " +
+         "&& " +
+         "python3 $(location net/tools/dafsa/make_dafsa.py) " +
+         "$(location net/base/registry_controlled_domains/effective_tld_names_unittest3.gperf) " +
+         "$(location net/base/registry_controlled_domains/effective_tld_names_unittest3-inc.cc) " +
+         "&& " +
+         "python3 $(location net/tools/dafsa/make_dafsa.py) " +
+         "$(location net/base/registry_controlled_domains/effective_tld_names_unittest4.gperf) " +
+         "$(location net/base/registry_controlled_domains/effective_tld_names_unittest4-inc.cc) " +
+         "&& " +
+         "python3 $(location net/tools/dafsa/make_dafsa.py) " +
+         "$(location net/base/registry_controlled_domains/effective_tld_names_unittest5.gperf) " +
+         "$(location net/base/registry_controlled_domains/effective_tld_names_unittest5-inc.cc) " +
+         "&& " +
+         "python3 $(location net/tools/dafsa/make_dafsa.py) " +
+         "$(location net/base/registry_controlled_domains/effective_tld_names_unittest6.gperf) " +
+         "$(location net/base/registry_controlled_domains/effective_tld_names_unittest6-inc.cc)",
+    out: [
+        "net/base/registry_controlled_domains/effective_tld_names-inc.cc",
+        "net/base/registry_controlled_domains/effective_tld_names_unittest1-inc.cc",
+        "net/base/registry_controlled_domains/effective_tld_names_unittest2-inc.cc",
+        "net/base/registry_controlled_domains/effective_tld_names_unittest3-inc.cc",
+        "net/base/registry_controlled_domains/effective_tld_names_unittest4-inc.cc",
+        "net/base/registry_controlled_domains/effective_tld_names_unittest5-inc.cc",
+        "net/base/registry_controlled_domains/effective_tld_names_unittest6-inc.cc",
+    ],
+    tool_files: [
+        "net/base/registry_controlled_domains/effective_tld_names.gperf",
+        "net/base/registry_controlled_domains/effective_tld_names_unittest1.gperf",
+        "net/base/registry_controlled_domains/effective_tld_names_unittest2.gperf",
+        "net/base/registry_controlled_domains/effective_tld_names_unittest3.gperf",
+        "net/base/registry_controlled_domains/effective_tld_names_unittest4.gperf",
+        "net/base/registry_controlled_domains/effective_tld_names_unittest5.gperf",
+        "net/base/registry_controlled_domains/effective_tld_names_unittest6.gperf",
+        "net/tools/dafsa/make_dafsa.py",
+    ],
+    apex_available: [
+        "com.android.tethering",
+    ],
+}
+
 // GN: //net/base/registry_controlled_domains:registry_controlled_domains
 cc_genrule {
     name: "cronet_aml_net_base_registry_controlled_domains_registry_controlled_domains",
     cmd: "$(location net/tools/dafsa/make_dafsa.py) --reverse " +
          "$(location net/base/registry_controlled_domains/effective_tld_names.gperf) " +
          "$(location net/base/registry_controlled_domains/effective_tld_names-reversed-inc.cc) " +
-         "&& python3 $(location net/tools/dafsa/make_dafsa.py) " +
+         "&& " +
+         "python3 $(location net/tools/dafsa/make_dafsa.py) " +
          "--reverse " +
          "$(location net/base/registry_controlled_domains/effective_tld_names_unittest1.gperf) " +
          "$(location net/base/registry_controlled_domains/effective_tld_names_unittest1-reversed-inc.cc) " +
-         "&& python3 $(location net/tools/dafsa/make_dafsa.py) " +
+         "&& " +
+         "python3 $(location net/tools/dafsa/make_dafsa.py) " +
          "--reverse " +
          "$(location net/base/registry_controlled_domains/effective_tld_names_unittest2.gperf) " +
          "$(location net/base/registry_controlled_domains/effective_tld_names_unittest2-reversed-inc.cc) " +
-         "&& python3 $(location net/tools/dafsa/make_dafsa.py) " +
+         "&& " +
+         "python3 $(location net/tools/dafsa/make_dafsa.py) " +
          "--reverse " +
          "$(location net/base/registry_controlled_domains/effective_tld_names_unittest3.gperf) " +
          "$(location net/base/registry_controlled_domains/effective_tld_names_unittest3-reversed-inc.cc) " +
-         "&& python3 $(location net/tools/dafsa/make_dafsa.py) " +
+         "&& " +
+         "python3 $(location net/tools/dafsa/make_dafsa.py) " +
          "--reverse " +
          "$(location net/base/registry_controlled_domains/effective_tld_names_unittest4.gperf) " +
          "$(location net/base/registry_controlled_domains/effective_tld_names_unittest4-reversed-inc.cc) " +
-         "&& python3 $(location net/tools/dafsa/make_dafsa.py) " +
+         "&& " +
+         "python3 $(location net/tools/dafsa/make_dafsa.py) " +
          "--reverse " +
          "$(location net/base/registry_controlled_domains/effective_tld_names_unittest5.gperf) " +
          "$(location net/base/registry_controlled_domains/effective_tld_names_unittest5-reversed-inc.cc) " +
-         "&& python3 $(location net/tools/dafsa/make_dafsa.py) " +
+         "&& " +
+         "python3 $(location net/tools/dafsa/make_dafsa.py) " +
          "--reverse " +
          "$(location net/base/registry_controlled_domains/effective_tld_names_unittest6.gperf) " +
          "$(location net/base/registry_controlled_domains/effective_tld_names_unittest6-reversed-inc.cc)",
@@ -12211,27 +11104,33 @@
     cmd: "$(location net/tools/dafsa/make_dafsa.py) --reverse " +
          "$(location net/base/registry_controlled_domains/effective_tld_names.gperf) " +
          "$(location net/base/registry_controlled_domains/effective_tld_names-reversed-inc.cc) " +
-         "&& python3 $(location net/tools/dafsa/make_dafsa.py) " +
+         "&& " +
+         "python3 $(location net/tools/dafsa/make_dafsa.py) " +
          "--reverse " +
          "$(location net/base/registry_controlled_domains/effective_tld_names_unittest1.gperf) " +
          "$(location net/base/registry_controlled_domains/effective_tld_names_unittest1-reversed-inc.cc) " +
-         "&& python3 $(location net/tools/dafsa/make_dafsa.py) " +
+         "&& " +
+         "python3 $(location net/tools/dafsa/make_dafsa.py) " +
          "--reverse " +
          "$(location net/base/registry_controlled_domains/effective_tld_names_unittest2.gperf) " +
          "$(location net/base/registry_controlled_domains/effective_tld_names_unittest2-reversed-inc.cc) " +
-         "&& python3 $(location net/tools/dafsa/make_dafsa.py) " +
+         "&& " +
+         "python3 $(location net/tools/dafsa/make_dafsa.py) " +
          "--reverse " +
          "$(location net/base/registry_controlled_domains/effective_tld_names_unittest3.gperf) " +
          "$(location net/base/registry_controlled_domains/effective_tld_names_unittest3-reversed-inc.cc) " +
-         "&& python3 $(location net/tools/dafsa/make_dafsa.py) " +
+         "&& " +
+         "python3 $(location net/tools/dafsa/make_dafsa.py) " +
          "--reverse " +
          "$(location net/base/registry_controlled_domains/effective_tld_names_unittest4.gperf) " +
          "$(location net/base/registry_controlled_domains/effective_tld_names_unittest4-reversed-inc.cc) " +
-         "&& python3 $(location net/tools/dafsa/make_dafsa.py) " +
+         "&& " +
+         "python3 $(location net/tools/dafsa/make_dafsa.py) " +
          "--reverse " +
          "$(location net/base/registry_controlled_domains/effective_tld_names_unittest5.gperf) " +
          "$(location net/base/registry_controlled_domains/effective_tld_names_unittest5-reversed-inc.cc) " +
-         "&& python3 $(location net/tools/dafsa/make_dafsa.py) " +
+         "&& " +
+         "python3 $(location net/tools/dafsa/make_dafsa.py) " +
          "--reverse " +
          "$(location net/base/registry_controlled_domains/effective_tld_names_unittest6.gperf) " +
          "$(location net/base/registry_controlled_domains/effective_tld_names_unittest6-reversed-inc.cc)",
@@ -12383,8 +11282,54 @@
     ],
 }
 
+// GN: //net:cronet_buildflags
+cc_genrule {
+    name: "cronet_aml_net_cronet_buildflags",
+    cmd: "echo '--flags CRONET_BUILD=\"true\"' | " +
+         "$(location build/write_buildflag_header.py) --output " +
+         "$(out) " +
+         "--rulename " +
+         "//net:cronet_buildflags " +
+         "--gen-dir " +
+         ". " +
+         "--definitions " +
+         "/dev/stdin",
+    out: [
+        "net/base/cronet_buildflags.h",
+    ],
+    tool_files: [
+        "build/write_buildflag_header.py",
+    ],
+    apex_available: [
+        "com.android.tethering",
+    ],
+}
+
+// GN: //net:cronet_buildflags__testing
+cc_genrule {
+    name: "cronet_aml_net_cronet_buildflags__testing",
+    cmd: "echo '--flags CRONET_BUILD=\"true\"' | " +
+         "$(location build/write_buildflag_header.py) --output " +
+         "$(out) " +
+         "--rulename " +
+         "//net:cronet_buildflags " +
+         "--gen-dir " +
+         ". " +
+         "--definitions " +
+         "/dev/stdin",
+    out: [
+        "net/base/cronet_buildflags.h",
+    ],
+    tool_files: [
+        "build/write_buildflag_header.py",
+    ],
+    apex_available: [
+        "com.android.tethering",
+    ],
+}
+
 // GN: //net/dns:dns
-cc_library_static {
+cc_object {
     name: "cronet_aml_net_dns_dns",
     srcs: [
         "net/dns/address_info.cc",
@@ -12426,6 +11371,8 @@
         "net/dns/test_dns_config_service.cc",
     ],
     shared_libs: [
+        "//external/cronet/third_party/boringssl:libcrypto",
+        "//external/cronet/third_party/boringssl:libssl",
         "libandroid",
         "liblog",
         "libz",
@@ -12434,68 +11381,12 @@
         "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",
@@ -12505,6 +11396,18 @@
         "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",
     ],
@@ -12554,27 +11457,6 @@
         "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: [
@@ -12603,7 +11485,7 @@
 }
 
 // GN: //net/dns:dns__testing
-cc_library_static {
+cc_object {
     name: "cronet_aml_net_dns_dns__testing",
     srcs: [
         "net/dns/address_info.cc",
@@ -12653,68 +11535,13 @@
         "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",
@@ -12724,6 +11551,18 @@
         "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",
     ],
@@ -12773,27 +11612,6 @@
         "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: [
@@ -12822,7 +11640,7 @@
 }
 
 // GN: //net/dns/public:public
-cc_library_static {
+cc_object {
     name: "cronet_aml_net_dns_public_public",
     srcs: [
         "net/dns/public/dns_config_overrides.cc",
@@ -12835,6 +11653,8 @@
         "net/dns/public/util.cc",
     ],
     shared_libs: [
+        "//external/cronet/third_party/boringssl:libcrypto",
+        "//external/cronet/third_party/boringssl:libssl",
         "libandroid",
         "liblog",
         "libz",
@@ -12843,67 +11663,12 @@
         "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",
@@ -12913,6 +11678,18 @@
         "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",
     ],
@@ -12962,27 +11739,6 @@
         "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: [
@@ -13011,7 +11767,7 @@
 }
 
 // GN: //net/dns/public:public__testing
-cc_library_static {
+cc_object {
     name: "cronet_aml_net_dns_public_public__testing",
     srcs: [
         "net/dns/public/dns_config_overrides.cc",
@@ -13032,67 +11788,13 @@
         "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",
@@ -13102,6 +11804,18 @@
         "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",
     ],
@@ -13151,27 +11865,6 @@
         "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: [
@@ -13199,13 +11892,13 @@
     },
 }
 
-// GN: //net/dns:test_support__testing
-cc_library_static {
-    name: "cronet_aml_net_dns_test_support__testing",
+// GN: //net/dns/public:tests__testing
+cc_object {
+    name: "cronet_aml_net_dns_public_tests__testing",
     srcs: [
-        "net/dns/dns_test_util.cc",
-        "net/dns/host_resolver_results_test_util.cc",
-        "net/dns/mock_host_resolver.cc",
+        "net/dns/public/dns_over_https_config_unittest.cc",
+        "net/dns/public/dns_over_https_server_config_unittest.cc",
+        "net/dns/public/doh_provider_entry_unittest.cc",
     ],
     shared_libs: [
         "libandroid",
@@ -13216,76 +11909,17 @@
         "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",
@@ -13293,6 +11927,9 @@
         "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",
     ],
@@ -13348,27 +11985,291 @@
         "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: //net/dns:test_support__testing
+cc_object {
+    name: "cronet_aml_net_dns_test_support__testing",
+    srcs: [
+        "net/dns/dns_test_util.cc",
+        "net/dns/host_resolver_results_test_util.cc",
+        "net/dns/mock_host_resolver.cc",
     ],
+    shared_libs: [
+        "libandroid",
+        "liblog",
+        "libz",
+    ],
+    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_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__testing",
+        "cronet_aml_net_preload_decoder__testing",
+        "cronet_aml_net_third_party_quiche_quiche__testing",
+        "cronet_aml_net_uri_template__testing",
+        "cronet_aml_testing_gtest_gtest__testing",
+        "cronet_aml_third_party_boringssl_boringssl__testing",
+        "cronet_aml_third_party_brotli_common__testing",
+        "cronet_aml_third_party_brotli_dec__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",
+        "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",
+    ],
+    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",
+        "-DGOOGLE_PROTOBUF_INTERNAL_DONATE_STEAL_INLINE=0",
+        "-DGOOGLE_PROTOBUF_NO_RTTI",
+        "-DGOOGLE_PROTOBUF_NO_STATIC_INITIALIZER",
+        "-DGTEST_API_=",
+        "-DGTEST_HAS_ABSL=1",
+        "-DGTEST_HAS_POSIX_RE=0",
+        "-DGTEST_HAS_TR1_TUPLE=0",
+        "-DGTEST_LANG_CXX11=1",
+        "-DHAVE_PTHREAD",
+        "-DHAVE_SYS_UIO_H",
+        "-DNDEBUG",
+        "-DNO_UNWIND_TABLES",
+        "-DNVALGRIND",
+        "-DOFFICIAL_BUILD",
+        "-DUNIT_TEST",
+        "-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",
+        "net/third_party/quiche/overrides/",
+        "net/third_party/quiche/src/",
+        "net/third_party/quiche/src/quiche/common/platform/default/",
+        "third_party/abseil-cpp/",
+        "third_party/boringssl/src/include/",
+        "third_party/googletest/custom/",
+        "third_party/googletest/src/googlemock/include/",
+        "third_party/googletest/src/googletest/include/",
+        "third_party/protobuf/src/",
+    ],
+    cpp_std: "c++17",
+    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: //net/dns:tests__testing
+cc_object {
+    name: "cronet_aml_net_dns_tests__testing",
+    srcs: [
+        "net/dns/address_info_unittest.cc",
+        "net/dns/address_sorter_posix_unittest.cc",
+        "net/dns/address_sorter_unittest.cc",
+        "net/dns/context_host_resolver_unittest.cc",
+        "net/dns/dns_alias_utility_unittest.cc",
+        "net/dns/dns_client_unittest.cc",
+        "net/dns/dns_config_service_android_unittest.cc",
+        "net/dns/dns_config_service_unittest.cc",
+        "net/dns/dns_hosts_unittest.cc",
+        "net/dns/dns_query_unittest.cc",
+        "net/dns/dns_response_result_extractor_unittest.cc",
+        "net/dns/dns_response_unittest.cc",
+        "net/dns/dns_transaction_unittest.cc",
+        "net/dns/dns_udp_tracker_unittest.cc",
+        "net/dns/dns_util_unittest.cc",
+        "net/dns/host_cache_unittest.cc",
+        "net/dns/host_resolver_manager_unittest.cc",
+        "net/dns/https_record_rdata_unittest.cc",
+        "net/dns/httpssvc_metrics_unittest.cc",
+        "net/dns/mapped_host_resolver_unittest.cc",
+        "net/dns/nsswitch_reader_unittest.cc",
+        "net/dns/opt_record_rdata_unittest.cc",
+        "net/dns/record_parsed_unittest.cc",
+        "net/dns/record_rdata_unittest.cc",
+        "net/dns/resolve_context_unittest.cc",
+        "net/dns/serial_worker_unittest.cc",
+        "net/dns/system_dns_config_change_notifier_unittest.cc",
+    ],
+    shared_libs: [
+        "libandroid",
+        "liblog",
+        "libz",
+    ],
+    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_i18n__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_gtest_util__testing",
+        "cronet_aml_net_net__testing",
+        "cronet_aml_net_preload_decoder__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_uri_template__testing",
+        "cronet_aml_testing_gtest_gtest__testing",
+        "cronet_aml_third_party_boringssl_boringssl__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_icu_icui18n__testing",
+        "cronet_aml_third_party_icu_icuuc_private__testing",
+        "cronet_aml_third_party_libevent_libevent__testing",
+        "cronet_aml_third_party_libxml_libxml__testing",
+        "cronet_aml_third_party_libxml_libxml_utils__testing",
+        "cronet_aml_third_party_libxml_xml_reader__testing",
+        "cronet_aml_third_party_modp_b64_modp_b64__testing",
+        "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",
+    ],
+    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",
+        "-DGOOGLE_PROTOBUF_INTERNAL_DONATE_STEAL_INLINE=0",
+        "-DGOOGLE_PROTOBUF_NO_RTTI",
+        "-DGOOGLE_PROTOBUF_NO_STATIC_INITIALIZER",
+        "-DGTEST_API_=",
+        "-DGTEST_HAS_ABSL=1",
+        "-DGTEST_HAS_POSIX_RE=0",
+        "-DGTEST_HAS_TR1_TUPLE=0",
+        "-DGTEST_LANG_CXX11=1",
+        "-DHAVE_PTHREAD",
+        "-DHAVE_SYS_UIO_H",
+        "-DICU_UTIL_DATA_IMPL=ICU_UTIL_DATA_FILE",
+        "-DNDEBUG",
+        "-DNO_UNWIND_TABLES",
+        "-DNVALGRIND",
+        "-DOFFICIAL_BUILD",
+        "-DUNIT_TEST",
+        "-DUSE_CHROMIUM_ICU=1",
+        "-DUSE_REMOTE_TEST_SERVER",
+        "-DU_ENABLE_DYLOAD=0",
+        "-DU_ENABLE_RESOURCE_TRACING=0",
+        "-DU_ENABLE_TRACING=1",
+        "-DU_STATIC_IMPLEMENTATION",
+        "-DU_USING_ICU_NAMESPACE=0",
+        "-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",
+        "net/third_party/quiche/overrides/",
+        "net/third_party/quiche/src/",
+        "net/third_party/quiche/src/quiche/common/platform/default/",
+        "third_party/abseil-cpp/",
+        "third_party/boringssl/src/include/",
+        "third_party/ced/src/",
+        "third_party/googletest/custom/",
+        "third_party/googletest/src/googlemock/include/",
+        "third_party/googletest/src/googletest/include/",
+        "third_party/icu/source/common/",
+        "third_party/icu/source/i18n/",
+        "third_party/protobuf/src/",
+    ],
+    cpp_std: "c++17",
     target: {
         android_arm: {
             cflags: [
@@ -13419,6 +12320,55 @@
 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: [
@@ -13431,79 +12381,20 @@
         "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",
@@ -13514,6 +12405,12 @@
         "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",
     ],
@@ -13628,12 +12525,14 @@
 }
 
 // GN: //net/http:transport_security_state_generated_files
-cc_library_static {
+cc_object {
     name: "cronet_aml_net_http_transport_security_state_generated_files",
     srcs: [
         "net/http/transport_security_state.cc",
     ],
     shared_libs: [
+        "//external/cronet/third_party/boringssl:libcrypto",
+        "//external/cronet/third_party/boringssl:libssl",
         "libandroid",
         "liblog",
         "libz",
@@ -13642,69 +12541,12 @@
         "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",
@@ -13715,10 +12557,17 @@
         "cronet_aml_url_url",
     ],
     generated_headers: [
+        "cronet_aml_base_debugging_buildflags",
+        "cronet_aml_base_logging_buildflags",
         "cronet_aml_build_branding_buildflags",
-    ],
-    export_generated_headers: [
-        "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",
     ],
     defaults: [
         "cronet_aml_defaults",
@@ -13769,27 +12618,6 @@
         "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: [
@@ -13818,7 +12646,7 @@
 }
 
 // GN: //net/http:transport_security_state_generated_files__testing
-cc_library_static {
+cc_object {
     name: "cronet_aml_net_http_transport_security_state_generated_files__testing",
     srcs: [
         "net/http/transport_security_state.cc",
@@ -13832,69 +12660,13 @@
         "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",
@@ -13905,10 +12677,17 @@
         "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",
-    ],
-    export_generated_headers: [
-        "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",
     ],
     defaults: [
         "cronet_aml_defaults",
@@ -13959,27 +12738,6 @@
         "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: [
@@ -14007,6 +12765,47 @@
     },
 }
 
+// GN: //net/http:transport_security_state_unittest_data__testing
+cc_genrule {
+    name: "cronet_aml_net_http_transport_security_state_unittest_data__testing",
+    tools: [
+        "cronet_aml_net_tools_transport_security_state_generator_transport_security_state_generator__testing",
+    ],
+    cmd: "$(location cronet_aml_net_tools_transport_security_state_generator_transport_security_state_generator__testing) " +
+         "$(location net/http/transport_security_state_static_unittest1.json) " +
+         "$(location net/http/transport_security_state_static_unittest.pins) " +
+         "$(location net/http/transport_security_state_static_unittest.template) " +
+         "$(location net/http/transport_security_state_static_unittest1.h) " +
+         "&& " +
+         "$(location cronet_aml_net_tools_transport_security_state_generator_transport_security_state_generator__testing) " +
+         "$(location net/http/transport_security_state_static_unittest2.json) " +
+         "$(location net/http/transport_security_state_static_unittest.pins) " +
+         "$(location net/http/transport_security_state_static_unittest.template) " +
+         "$(location net/http/transport_security_state_static_unittest2.h) " +
+         "&& " +
+         "$(location cronet_aml_net_tools_transport_security_state_generator_transport_security_state_generator__testing) " +
+         "$(location net/http/transport_security_state_static_unittest3.json) " +
+         "$(location net/http/transport_security_state_static_unittest.pins) " +
+         "$(location net/http/transport_security_state_static_unittest.template) " +
+         "$(location net/http/transport_security_state_static_unittest3.h)",
+    out: [
+        "net/http/transport_security_state_static_unittest1.h",
+        "net/http/transport_security_state_static_unittest2.h",
+        "net/http/transport_security_state_static_unittest3.h",
+    ],
+    tool_files: [
+        "build/gn_run_binary.py",
+        "net/http/transport_security_state_static_unittest.pins",
+        "net/http/transport_security_state_static_unittest.template",
+        "net/http/transport_security_state_static_unittest1.json",
+        "net/http/transport_security_state_static_unittest2.json",
+        "net/http/transport_security_state_static_unittest3.json",
+    ],
+    apex_available: [
+        "com.android.tethering",
+    ],
+}
+
 // GN: //net/http:transport_security_state_unittest_data_default__testing
 cc_genrule {
     name: "cronet_aml_net_http_transport_security_state_unittest_data_default__testing",
@@ -14032,52 +12831,6 @@
     ],
 }
 
-// GN: //net:ios_cronet_buildflags
-cc_genrule {
-    name: "cronet_aml_net_ios_cronet_buildflags",
-    cmd: "echo '--flags CRONET_BUILD=\"true\"' | " +
-         "$(location build/write_buildflag_header.py) --output " +
-         "$(out) " +
-         "--rulename " +
-         "//net:ios_cronet_buildflags " +
-         "--gen-dir " +
-         ". " +
-         "--definitions " +
-         "/dev/stdin",
-    out: [
-        "net/socket/ios_cronet_buildflags.h",
-    ],
-    tool_files: [
-        "build/write_buildflag_header.py",
-    ],
-    apex_available: [
-        "com.android.tethering",
-    ],
-}
-
-// GN: //net:ios_cronet_buildflags__testing
-cc_genrule {
-    name: "cronet_aml_net_ios_cronet_buildflags__testing",
-    cmd: "echo '--flags CRONET_BUILD=\"true\"' | " +
-         "$(location build/write_buildflag_header.py) --output " +
-         "$(out) " +
-         "--rulename " +
-         "//net:ios_cronet_buildflags " +
-         "--gen-dir " +
-         ". " +
-         "--definitions " +
-         "/dev/stdin",
-    out: [
-        "net/socket/ios_cronet_buildflags.h",
-    ],
-    tool_files: [
-        "build/write_buildflag_header.py",
-    ],
-    apex_available: [
-        "com.android.tethering",
-    ],
-}
-
 // GN: //net:isolation_info_proto__testing
 cc_genrule {
     name: "cronet_aml_net_isolation_info_proto__testing_gen",
@@ -14164,6 +12917,12 @@
 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",
@@ -14648,6 +13407,8 @@
         "net/url_request/websocket_handshake_userdata_key.cc",
     ],
     shared_libs: [
+        "//external/cronet/third_party/boringssl:libcrypto",
+        "//external/cronet/third_party/boringssl:libssl",
         "libandroid",
         "liblog",
         "libz",
@@ -14656,70 +13417,12 @@
         "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",
@@ -14730,12 +13433,32 @@
         "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_ios_cronet_buildflags",
+        "cronet_aml_net_base_registry_controlled_domains_registry_controlled_domains",
+        "cronet_aml_net_buildflags",
+        "cronet_aml_net_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_ios_cronet_buildflags",
+        "cronet_aml_net_base_registry_controlled_domains_registry_controlled_domains",
+        "cronet_aml_net_buildflags",
+        "cronet_aml_net_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",
@@ -14854,6 +13577,12 @@
 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",
@@ -15346,70 +14075,13 @@
         "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",
@@ -15420,12 +14092,32 @@
         "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_ios_cronet_buildflags__testing",
+        "cronet_aml_net_base_registry_controlled_domains_registry_controlled_domains__testing",
+        "cronet_aml_net_buildflags__testing",
+        "cronet_aml_net_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_ios_cronet_buildflags__testing",
+        "cronet_aml_net_base_registry_controlled_domains_registry_controlled_domains__testing",
+        "cronet_aml_net_buildflags__testing",
+        "cronet_aml_net_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",
@@ -15537,12 +14229,14 @@
 }
 
 // GN: //net:net_deps
-cc_library_static {
+cc_object {
     name: "cronet_aml_net_net_deps",
     srcs: [
         ":cronet_aml_net_isolation_info_proto_gen",
     ],
     shared_libs: [
+        "//external/cronet/third_party/boringssl:libcrypto",
+        "//external/cronet/third_party/boringssl:libssl",
         "libandroid",
         "liblog",
         "libprotobuf-cpp-lite",
@@ -15552,61 +14246,9 @@
         "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",
@@ -15624,15 +14266,6 @@
         "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",
     ],
@@ -15679,27 +14312,6 @@
         "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: [
@@ -15728,7 +14340,7 @@
 }
 
 // GN: //net:net_deps__testing
-cc_library_static {
+cc_object {
     name: "cronet_aml_net_net_deps__testing",
     srcs: [
         ":cronet_aml_net_isolation_info_proto__testing_gen",
@@ -15743,61 +14355,10 @@
         "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",
@@ -15815,15 +14376,6 @@
         "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",
     ],
@@ -15870,27 +14422,6 @@
         "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: [
@@ -16211,13 +14742,15 @@
 }
 
 // GN: //net:net_public_deps
-cc_library_static {
+cc_object {
     name: "cronet_aml_net_net_public_deps",
     srcs: [
         ":cronet_aml_net_net_nqe_proto_gen",
         ":cronet_aml_net_third_party_quiche_net_quic_test_tools_proto_gen",
     ],
     shared_libs: [
+        "//external/cronet/third_party/boringssl:libcrypto",
+        "//external/cronet/third_party/boringssl:libssl",
         "libandroid",
         "liblog",
         "libprotobuf-cpp-lite",
@@ -16227,64 +14760,11 @@
         "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",
@@ -16293,11 +14773,7 @@
         "cronet_aml_url_url",
     ],
     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",
-    ],
-    export_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",
@@ -16348,27 +14824,6 @@
         "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: [
@@ -16397,7 +14852,7 @@
 }
 
 // GN: //net:net_public_deps__testing
-cc_library_static {
+cc_object {
     name: "cronet_aml_net_net_public_deps__testing",
     srcs: [
         ":cronet_aml_net_net_nqe_proto__testing_gen",
@@ -16413,64 +14868,12 @@
         "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",
@@ -16479,11 +14882,7 @@
         "cronet_aml_url_url__testing",
     ],
     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",
-    ],
-    export_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",
@@ -16534,6 +14933,627 @@
         "third_party/protobuf/src/",
     ],
     cpp_std: "c++17",
+    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: //net:net_test_jni_headers__testing
+cc_genrule {
+    name: "cronet_aml_net_net_test_jni_headers__testing",
+    srcs: [
+        "net/android/javatests/src/org/chromium/net/AndroidKeyStoreTestUtil.java",
+        "net/android/javatests/src/org/chromium/net/AndroidProxyConfigServiceTestUtil.java",
+        "net/test/android/javatests/src/org/chromium/net/AndroidNetworkLibraryTestUtil.java",
+        "net/test/android/javatests/src/org/chromium/net/test/DummySpnegoAuthenticator.java",
+        "net/test/android/javatests/src/org/chromium/net/test/EmbeddedTestServerImpl.java",
+    ],
+    cmd: "$(location base/android/jni_generator/jni_generator.py) --ptr_type " +
+         "long " +
+         "--output_dir " +
+         "$(genDir)/net/net_test_jni_headers " +
+         "--includes " +
+         "base/android/jni_generator/jni_generator_helper.h " +
+         "--use_proxy_hash " +
+         "--output_name " +
+         "AndroidKeyStoreTestUtil_jni.h " +
+         "--output_name " +
+         "AndroidProxyConfigServiceTestUtil_jni.h " +
+         "--output_name " +
+         "AndroidNetworkLibraryTestUtil_jni.h " +
+         "--output_name " +
+         "DummySpnegoAuthenticator_jni.h " +
+         "--output_name " +
+         "EmbeddedTestServerImpl_jni.h " +
+         "--input_file " +
+         "$(location net/android/javatests/src/org/chromium/net/AndroidKeyStoreTestUtil.java) " +
+         "--input_file " +
+         "$(location net/android/javatests/src/org/chromium/net/AndroidProxyConfigServiceTestUtil.java) " +
+         "--input_file " +
+         "$(location net/test/android/javatests/src/org/chromium/net/AndroidNetworkLibraryTestUtil.java) " +
+         "--input_file " +
+         "$(location net/test/android/javatests/src/org/chromium/net/test/DummySpnegoAuthenticator.java) " +
+         "--input_file " +
+         "$(location net/test/android/javatests/src/org/chromium/net/test/EmbeddedTestServerImpl.java)",
+    out: [
+        "net/net_test_jni_headers/AndroidKeyStoreTestUtil_jni.h",
+        "net/net_test_jni_headers/AndroidNetworkLibraryTestUtil_jni.h",
+        "net/net_test_jni_headers/AndroidProxyConfigServiceTestUtil_jni.h",
+        "net/net_test_jni_headers/DummySpnegoAuthenticator_jni.h",
+        "net/net_test_jni_headers/EmbeddedTestServerImpl_jni.h",
+    ],
+    tool_files: [
+        "base/android/jni_generator/android_jar.classes",
+        "base/android/jni_generator/jni_generator.py",
+        "build/android/gyp/util/__init__.py",
+        "build/android/gyp/util/build_utils.py",
+        "build/gn_helpers.py",
+    ],
+    apex_available: [
+        "com.android.tethering",
+    ],
+}
+
+// GN: //net:net_unittests__library__testing
+cc_library_shared {
+    name: "cronet_aml_net_net_unittests__library__testing",
+    srcs: [
+        ":cronet_aml_buildtools_third_party_libc___libc____testing",
+        ":cronet_aml_buildtools_third_party_libc__abi_libc__abi__testing",
+        ":cronet_aml_net_dns_public_tests__testing",
+        ":cronet_aml_net_dns_tests__testing",
+        ":cronet_aml_net_quic_test_flags_utils__testing",
+        ":cronet_aml_net_quic_test_tools__testing",
+        ":cronet_aml_net_simple_quic_tools__testing",
+        ":cronet_aml_net_spdy_test_tools__testing",
+        ":cronet_aml_net_third_party_quiche_quiche_tests__testing",
+        ":cronet_aml_net_tools_huffman_trie_huffman_trie_generator_sources__testing",
+        ":cronet_aml_testing_android_native_test_native_test_native_code__testing",
+        ":cronet_aml_testing_android_native_test_native_test_support__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/android/dummy_spnego_authenticator.cc",
+        "net/android/http_auth_negotiate_android_unittest.cc",
+        "net/android/network_change_notifier_android_unittest.cc",
+        "net/android/network_library_unittest.cc",
+        "net/android/traffic_stats_unittest.cc",
+        "net/base/address_family_unittest.cc",
+        "net/base/address_list_unittest.cc",
+        "net/base/address_tracker_linux_unittest.cc",
+        "net/base/backoff_entry_serializer_unittest.cc",
+        "net/base/backoff_entry_unittest.cc",
+        "net/base/chunked_upload_data_stream_unittest.cc",
+        "net/base/data_url_unittest.cc",
+        "net/base/datagram_buffer_unittest.cc",
+        "net/base/elements_upload_data_stream_unittest.cc",
+        "net/base/expiring_cache_unittest.cc",
+        "net/base/file_stream_unittest.cc",
+        "net/base/host_mapping_rules_unittest.cc",
+        "net/base/host_port_pair_unittest.cc",
+        "net/base/interval_test.cc",
+        "net/base/ip_address_unittest.cc",
+        "net/base/ip_endpoint_unittest.cc",
+        "net/base/isolation_info_unittest.cc",
+        "net/base/lookup_string_in_fixed_set_unittest.cc",
+        "net/base/mime_sniffer_unittest.cc",
+        "net/base/mime_util_unittest.cc",
+        "net/base/net_errors_unittest.cc",
+        "net/base/net_string_util_unittest.cc",
+        "net/base/network_activity_monitor_unittest.cc",
+        "net/base/network_anonymization_key_unittest.cc",
+        "net/base/network_change_notifier_posix_unittest.cc",
+        "net/base/network_change_notifier_unittest.cc",
+        "net/base/network_delegate_unittest.cc",
+        "net/base/network_interfaces_getifaddrs_unittest.cc",
+        "net/base/network_interfaces_linux_unittest.cc",
+        "net/base/network_interfaces_unittest.cc",
+        "net/base/network_isolation_key_unittest.cc",
+        "net/base/parse_number_unittest.cc",
+        "net/base/port_util_unittest.cc",
+        "net/base/prioritized_dispatcher_unittest.cc",
+        "net/base/prioritized_task_runner_unittest.cc",
+        "net/base/priority_queue_unittest.cc",
+        "net/base/proxy_server_unittest.cc",
+        "net/base/proxy_string_util_unittest.cc",
+        "net/base/registry_controlled_domains/registry_controlled_domain_unittest.cc",
+        "net/base/scheme_host_port_matcher_rule_unittest.cc",
+        "net/base/scheme_host_port_matcher_unittest.cc",
+        "net/base/schemeful_site_unittest.cc",
+        "net/base/sockaddr_util_posix_unittest.cc",
+        "net/base/test_completion_callback_unittest.cc",
+        "net/base/test_proxy_delegate.cc",
+        "net/base/upload_bytes_element_reader_unittest.cc",
+        "net/base/upload_file_element_reader_unittest.cc",
+        "net/cert/caching_cert_verifier_unittest.cc",
+        "net/cert/cert_and_ct_verifier_unittest.cc",
+        "net/cert/cert_verifier_unittest.cc",
+        "net/cert/cert_verify_proc_android_unittest.cc",
+        "net/cert/cert_verify_proc_builtin_unittest.cc",
+        "net/cert/cert_verify_proc_unittest.cc",
+        "net/cert/coalescing_cert_verifier_unittest.cc",
+        "net/cert/crl_set_unittest.cc",
+        "net/cert/ct_log_response_parser_unittest.cc",
+        "net/cert/ct_log_verifier_unittest.cc",
+        "net/cert/ct_objects_extractor_unittest.cc",
+        "net/cert/ct_serialization_unittest.cc",
+        "net/cert/ev_root_ca_metadata_unittest.cc",
+        "net/cert/internal/cert_issuer_source_aia_unittest.cc",
+        "net/cert/internal/cert_issuer_source_sync_unittest.cc",
+        "net/cert/internal/crl_unittest.cc",
+        "net/cert/internal/general_names_unittest.cc",
+        "net/cert/internal/revocation_checker_unittest.cc",
+        "net/cert/internal/revocation_util_unittest.cc",
+        "net/cert/internal/system_trust_store_unittest.cc",
+        "net/cert/known_roots_unittest.cc",
+        "net/cert/merkle_audit_proof_unittest.cc",
+        "net/cert/merkle_tree_leaf_unittest.cc",
+        "net/cert/multi_log_ct_verifier_unittest.cc",
+        "net/cert/multi_threaded_cert_verifier_unittest.cc",
+        "net/cert/pem_unittest.cc",
+        "net/cert/pki/cert_issuer_source_static_unittest.cc",
+        "net/cert/pki/certificate_policies_unittest.cc",
+        "net/cert/pki/extended_key_usage_unittest.cc",
+        "net/cert/pki/name_constraints_unittest.cc",
+        "net/cert/pki/nist_pkits_unittest.cc",
+        "net/cert/pki/ocsp_unittest.cc",
+        "net/cert/pki/parse_certificate_unittest.cc",
+        "net/cert/pki/parse_name_unittest.cc",
+        "net/cert/pki/parsed_certificate_unittest.cc",
+        "net/cert/pki/path_builder_pkits_unittest.cc",
+        "net/cert/pki/path_builder_unittest.cc",
+        "net/cert/pki/path_builder_verify_certificate_chain_unittest.cc",
+        "net/cert/pki/signature_algorithm_unittest.cc",
+        "net/cert/pki/simple_path_builder_delegate_unittest.cc",
+        "net/cert/pki/string_util_unittest.cc",
+        "net/cert/pki/test_helpers.cc",
+        "net/cert/pki/trust_store_collection_unittest.cc",
+        "net/cert/pki/verify_certificate_chain_pkits_unittest.cc",
+        "net/cert/pki/verify_certificate_chain_unittest.cc",
+        "net/cert/pki/verify_name_match_unittest.cc",
+        "net/cert/pki/verify_signed_data_unittest.cc",
+        "net/cert/signed_certificate_timestamp_unittest.cc",
+        "net/cert/symantec_certs_unittest.cc",
+        "net/cert/test_root_certs_unittest.cc",
+        "net/cert/x509_cert_types_unittest.cc",
+        "net/cert/x509_util_unittest.cc",
+        "net/cert_net/cert_net_fetcher_url_request_unittest.cc",
+        "net/cookies/canonical_cookie_unittest.cc",
+        "net/cookies/cookie_constants_unittest.cc",
+        "net/cookies/cookie_deletion_info_unittest.cc",
+        "net/cookies/cookie_inclusion_status_unittest.cc",
+        "net/cookies/cookie_monster_unittest.cc",
+        "net/cookies/cookie_options_unittest.cc",
+        "net/cookies/cookie_partition_key_collection_unittest.cc",
+        "net/cookies/cookie_partition_key_unittest.cc",
+        "net/cookies/cookie_util_unittest.cc",
+        "net/cookies/parsed_cookie_unittest.cc",
+        "net/cookies/site_for_cookies_unittest.cc",
+        "net/cookies/static_cookie_policy_unittest.cc",
+        "net/der/encode_values_unittest.cc",
+        "net/der/input_unittest.cc",
+        "net/der/parse_values_unittest.cc",
+        "net/der/parser_unittest.cc",
+        "net/disk_cache/backend_cleanup_tracker_unittest.cc",
+        "net/disk_cache/backend_unittest.cc",
+        "net/disk_cache/blockfile/addr_unittest.cc",
+        "net/disk_cache/blockfile/bitmap_unittest.cc",
+        "net/disk_cache/blockfile/block_files_unittest.cc",
+        "net/disk_cache/blockfile/mapped_file_unittest.cc",
+        "net/disk_cache/blockfile/stats_unittest.cc",
+        "net/disk_cache/blockfile/storage_block_unittest.cc",
+        "net/disk_cache/cache_util_unittest.cc",
+        "net/disk_cache/entry_unittest.cc",
+        "net/disk_cache/simple/simple_file_enumerator_unittest.cc",
+        "net/disk_cache/simple/simple_file_tracker_unittest.cc",
+        "net/disk_cache/simple/simple_index_file_unittest.cc",
+        "net/disk_cache/simple/simple_index_unittest.cc",
+        "net/disk_cache/simple/simple_test_util.cc",
+        "net/disk_cache/simple/simple_util_unittest.cc",
+        "net/disk_cache/simple/simple_version_upgrade_unittest.cc",
+        "net/filter/brotli_source_stream_unittest.cc",
+        "net/filter/filter_source_stream_unittest.cc",
+        "net/filter/gzip_source_stream_unittest.cc",
+        "net/first_party_sets/addition_overlaps_union_find_unittest.cc",
+        "net/first_party_sets/first_party_sets_cache_filter_unittest.cc",
+        "net/first_party_sets/first_party_sets_context_config_unittest.cc",
+        "net/first_party_sets/global_first_party_sets_unittest.cc",
+        "net/http/alternative_service_unittest.cc",
+        "net/http/bidirectional_stream_unittest.cc",
+        "net/http/broken_alternative_services_unittest.cc",
+        "net/http/http_auth_cache_unittest.cc",
+        "net/http/http_auth_challenge_tokenizer_unittest.cc",
+        "net/http/http_auth_controller_unittest.cc",
+        "net/http/http_auth_filter_unittest.cc",
+        "net/http/http_auth_handler_basic_unittest.cc",
+        "net/http/http_auth_handler_digest_unittest.cc",
+        "net/http/http_auth_handler_factory_unittest.cc",
+        "net/http/http_auth_handler_mock.cc",
+        "net/http/http_auth_handler_negotiate_unittest.cc",
+        "net/http/http_auth_handler_ntlm_portable_unittest.cc",
+        "net/http/http_auth_handler_unittest.cc",
+        "net/http/http_auth_multi_round_parse_unittest.cc",
+        "net/http/http_auth_preferences_unittest.cc",
+        "net/http/http_auth_unittest.cc",
+        "net/http/http_basic_state_unittest.cc",
+        "net/http/http_byte_range_unittest.cc",
+        "net/http/http_cache_lookup_manager_unittest.cc",
+        "net/http/http_cache_unittest.cc",
+        "net/http/http_cache_writers_unittest.cc",
+        "net/http/http_chunked_decoder_unittest.cc",
+        "net/http/http_content_disposition_unittest.cc",
+        "net/http/http_log_util_unittest.cc",
+        "net/http/http_network_layer_unittest.cc",
+        "net/http/http_network_transaction_unittest.cc",
+        "net/http/http_proxy_client_socket_unittest.cc",
+        "net/http/http_proxy_connect_job_unittest.cc",
+        "net/http/http_request_headers_unittest.cc",
+        "net/http/http_request_info_unittest.cc",
+        "net/http/http_response_body_drainer_unittest.cc",
+        "net/http/http_response_headers_unittest.cc",
+        "net/http/http_response_info_unittest.cc",
+        "net/http/http_security_headers_unittest.cc",
+        "net/http/http_server_properties_manager_unittest.cc",
+        "net/http/http_server_properties_unittest.cc",
+        "net/http/http_status_code_unittest.cc",
+        "net/http/http_stream_factory_job_controller_unittest.cc",
+        "net/http/http_stream_factory_unittest.cc",
+        "net/http/http_stream_parser_unittest.cc",
+        "net/http/http_stream_request_unittest.cc",
+        "net/http/http_util_unittest.cc",
+        "net/http/http_vary_data_unittest.cc",
+        "net/http/mock_allow_http_auth_preferences.cc",
+        "net/http/test_upload_data_stream_not_allow_http1.cc",
+        "net/http/transport_security_persister_unittest.cc",
+        "net/http/transport_security_state_unittest.cc",
+        "net/http/url_security_manager_unittest.cc",
+        "net/http/webfonts_histogram_unittest.cc",
+        "net/log/file_net_log_observer_unittest.cc",
+        "net/log/net_log_capture_mode_unittest.cc",
+        "net/log/net_log_unittest.cc",
+        "net/log/net_log_util_unittest.cc",
+        "net/log/net_log_values_unittest.cc",
+        "net/network_error_logging/mock_persistent_nel_store_unittest.cc",
+        "net/network_error_logging/network_error_logging_service_unittest.cc",
+        "net/nqe/effective_connection_type_unittest.cc",
+        "net/nqe/event_creator_unittest.cc",
+        "net/nqe/network_id_unittest.cc",
+        "net/nqe/network_qualities_prefs_manager_unittest.cc",
+        "net/nqe/network_quality_estimator_params_unittest.cc",
+        "net/nqe/network_quality_estimator_unittest.cc",
+        "net/nqe/network_quality_estimator_util_unittest.cc",
+        "net/nqe/network_quality_store_unittest.cc",
+        "net/nqe/observation_buffer_unittest.cc",
+        "net/nqe/socket_watcher_unittest.cc",
+        "net/nqe/throughput_analyzer_unittest.cc",
+        "net/ntlm/ntlm_buffer_reader_unittest.cc",
+        "net/ntlm/ntlm_buffer_writer_unittest.cc",
+        "net/ntlm/ntlm_client_unittest.cc",
+        "net/ntlm/ntlm_unittest.cc",
+        "net/proxy_resolution/configured_proxy_resolution_service_unittest.cc",
+        "net/proxy_resolution/multi_threaded_proxy_resolver_unittest.cc",
+        "net/proxy_resolution/network_delegate_error_observer_unittest.cc",
+        "net/proxy_resolution/pac_file_decider_unittest.cc",
+        "net/proxy_resolution/pac_file_fetcher_impl_unittest.cc",
+        "net/proxy_resolution/proxy_bypass_rules_unittest.cc",
+        "net/proxy_resolution/proxy_config_service_android_unittest.cc",
+        "net/proxy_resolution/proxy_config_unittest.cc",
+        "net/proxy_resolution/proxy_info_unittest.cc",
+        "net/proxy_resolution/proxy_list_unittest.cc",
+        "net/quic/bidirectional_stream_quic_impl_unittest.cc",
+        "net/quic/crypto/proof_test_chromium.cc",
+        "net/quic/crypto/proof_verifier_chromium_test.cc",
+        "net/quic/dedicated_web_transport_http3_client_test.cc",
+        "net/quic/mock_quic_data.cc",
+        "net/quic/network_connection_unittest.cc",
+        "net/quic/platform/impl/quic_chromium_clock_test.cc",
+        "net/quic/properties_based_quic_server_info_test.cc",
+        "net/quic/quic_address_mismatch_test.cc",
+        "net/quic/quic_chromium_alarm_factory_test.cc",
+        "net/quic/quic_chromium_client_session_peer.cc",
+        "net/quic/quic_chromium_client_session_test.cc",
+        "net/quic/quic_chromium_client_stream_test.cc",
+        "net/quic/quic_chromium_connection_helper_test.cc",
+        "net/quic/quic_clock_skew_detector_test.cc",
+        "net/quic/quic_end_to_end_unittest.cc",
+        "net/quic/quic_http_stream_test.cc",
+        "net/quic/quic_http_utils_test.cc",
+        "net/quic/quic_network_transaction_unittest.cc",
+        "net/quic/quic_proxy_client_socket_unittest.cc",
+        "net/quic/quic_stream_factory_peer.cc",
+        "net/quic/quic_stream_factory_test.cc",
+        "net/quic/quic_test_packet_maker.cc",
+        "net/quic/set_quic_flag_test.cc",
+        "net/quic/test_quic_crypto_client_config_handle.cc",
+        "net/reporting/mock_persistent_reporting_store_unittest.cc",
+        "net/reporting/reporting_browsing_data_remover_unittest.cc",
+        "net/reporting/reporting_cache_unittest.cc",
+        "net/reporting/reporting_delivery_agent_unittest.cc",
+        "net/reporting/reporting_endpoint_manager_unittest.cc",
+        "net/reporting/reporting_garbage_collector_unittest.cc",
+        "net/reporting/reporting_header_parser_unittest.cc",
+        "net/reporting/reporting_network_change_observer_unittest.cc",
+        "net/reporting/reporting_service_unittest.cc",
+        "net/reporting/reporting_uploader_unittest.cc",
+        "net/socket/client_socket_pool_base_unittest.cc",
+        "net/socket/client_socket_pool_unittest.cc",
+        "net/socket/connect_job_factory_unittest.cc",
+        "net/socket/connect_job_test_util.cc",
+        "net/socket/connect_job_unittest.cc",
+        "net/socket/mock_client_socket_pool_manager.cc",
+        "net/socket/sequenced_socket_data_unittest.cc",
+        "net/socket/socket_bio_adapter_unittest.cc",
+        "net/socket/socket_tag_unittest.cc",
+        "net/socket/socks5_client_socket_unittest.cc",
+        "net/socket/socks_client_socket_unittest.cc",
+        "net/socket/socks_connect_job_unittest.cc",
+        "net/socket/ssl_client_socket_unittest.cc",
+        "net/socket/ssl_connect_job_unittest.cc",
+        "net/socket/ssl_server_socket_unittest.cc",
+        "net/socket/tcp_client_socket_unittest.cc",
+        "net/socket/tcp_server_socket_unittest.cc",
+        "net/socket/tcp_socket_unittest.cc",
+        "net/socket/transport_client_socket_pool_test_util.cc",
+        "net/socket/transport_client_socket_pool_unittest.cc",
+        "net/socket/transport_client_socket_unittest.cc",
+        "net/socket/transport_connect_job_unittest.cc",
+        "net/socket/udp_socket_unittest.cc",
+        "net/socket/unix_domain_client_socket_posix_unittest.cc",
+        "net/socket/unix_domain_server_socket_posix_unittest.cc",
+        "net/socket/websocket_endpoint_lock_manager_unittest.cc",
+        "net/socket/websocket_transport_client_socket_pool_unittest.cc",
+        "net/spdy/alps_decoder_test.cc",
+        "net/spdy/bidirectional_stream_spdy_impl_unittest.cc",
+        "net/spdy/buffered_spdy_framer_unittest.cc",
+        "net/spdy/fuzzing/hpack_fuzz_util_test.cc",
+        "net/spdy/header_coalescer_test.cc",
+        "net/spdy/http2_priority_dependencies_unittest.cc",
+        "net/spdy/http2_push_promise_index_test.cc",
+        "net/spdy/spdy_buffer_unittest.cc",
+        "net/spdy/spdy_http_stream_unittest.cc",
+        "net/spdy/spdy_http_utils_unittest.cc",
+        "net/spdy/spdy_log_util_unittest.cc",
+        "net/spdy/spdy_network_transaction_unittest.cc",
+        "net/spdy/spdy_proxy_client_socket_unittest.cc",
+        "net/spdy/spdy_read_queue_unittest.cc",
+        "net/spdy/spdy_session_pool_unittest.cc",
+        "net/spdy/spdy_session_test_util.cc",
+        "net/spdy/spdy_session_unittest.cc",
+        "net/spdy/spdy_stream_test_util.cc",
+        "net/spdy/spdy_stream_unittest.cc",
+        "net/spdy/spdy_write_queue_unittest.cc",
+        "net/ssl/client_cert_identity_unittest.cc",
+        "net/ssl/ssl_cipher_suite_names_unittest.cc",
+        "net/ssl/ssl_client_auth_cache_unittest.cc",
+        "net/ssl/ssl_client_session_cache_unittest.cc",
+        "net/ssl/ssl_config_service_unittest.cc",
+        "net/ssl/ssl_config_unittest.cc",
+        "net/ssl/ssl_connection_status_flags_unittest.cc",
+        "net/ssl/ssl_platform_key_android_unittest.cc",
+        "net/ssl/ssl_platform_key_util_unittest.cc",
+        "net/test/embedded_test_server/embedded_test_server_unittest.cc",
+        "net/test/embedded_test_server/http_request_unittest.cc",
+        "net/test/embedded_test_server/http_response_unittest.cc",
+        "net/test/run_all_unittests.cc",
+        "net/third_party/uri_template/uri_template_test.cc",
+        "net/tools/content_decoder_tool/content_decoder_tool.cc",
+        "net/tools/content_decoder_tool/content_decoder_tool_unittest.cc",
+        "net/tools/quic/quic_simple_client_test.cc",
+        "net/tools/tld_cleanup/tld_cleanup_util_unittest.cc",
+        "net/url_request/http_with_dns_over_https_unittest.cc",
+        "net/url_request/redirect_info_unittest.cc",
+        "net/url_request/redirect_util_unittest.cc",
+        "net/url_request/report_sender_unittest.cc",
+        "net/url_request/url_request_context_builder_unittest.cc",
+        "net/url_request/url_request_filter_unittest.cc",
+        "net/url_request/url_request_http_job_unittest.cc",
+        "net/url_request/url_request_job_factory_unittest.cc",
+        "net/url_request/url_request_quic_unittest.cc",
+        "net/url_request/url_request_throttler_simulation_unittest.cc",
+        "net/url_request/url_request_throttler_test_support.cc",
+        "net/url_request/url_request_throttler_unittest.cc",
+        "net/url_request/url_request_unittest.cc",
+        "net/url_request/view_cache_helper_unittest.cc",
+    ],
+    shared_libs: [
+        "libandroid",
+        "liblog",
+        "libz",
+    ],
+    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_i18n__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_crypto_test_support__testing",
+        "cronet_aml_net_gtest_util__testing",
+        "cronet_aml_net_net__testing",
+        "cronet_aml_net_preload_decoder__testing",
+        "cronet_aml_net_test_support__testing",
+        "cronet_aml_net_third_party_quiche_quiche__testing",
+        "cronet_aml_net_third_party_quiche_quiche_test_support__testing",
+        "cronet_aml_net_third_party_quiche_quiche_tool_support__testing",
+        "cronet_aml_net_uri_template__testing",
+        "cronet_aml_testing_gtest_gtest__testing",
+        "cronet_aml_third_party_boringssl_boringssl__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_icu_icui18n__testing",
+        "cronet_aml_third_party_icu_icuuc_private__testing",
+        "cronet_aml_third_party_libevent_libevent__testing",
+        "cronet_aml_third_party_libxml_libxml__testing",
+        "cronet_aml_third_party_libxml_libxml_utils__testing",
+        "cronet_aml_third_party_libxml_xml_reader__testing",
+        "cronet_aml_third_party_modp_b64_modp_b64__testing",
+        "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_lookup_strings_test_sets__testing",
+        "cronet_aml_net_base_registry_controlled_domains_registry_controlled_domains__testing",
+        "cronet_aml_net_http_transport_security_state_unittest_data__testing",
+        "cronet_aml_net_http_transport_security_state_unittest_data_default__testing",
+        "cronet_aml_net_net_test_jni_headers__testing",
+        "cronet_aml_testing_android_native_test_native_test_jni_headers__testing",
+        "cronet_aml_third_party_quic_trace_quic_trace_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_net_base_registry_controlled_domains_lookup_strings_test_sets__testing",
+        "cronet_aml_net_base_registry_controlled_domains_registry_controlled_domains__testing",
+        "cronet_aml_net_http_transport_security_state_unittest_data__testing",
+        "cronet_aml_net_http_transport_security_state_unittest_data_default__testing",
+        "cronet_aml_net_net_test_jni_headers__testing",
+        "cronet_aml_testing_android_native_test_native_test_jni_headers__testing",
+        "cronet_aml_third_party_quic_trace_quic_trace_proto__testing_gen_headers",
+        "cronet_aml_url_buildflags__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",
+        "-DGOOGLE_PROTOBUF_INTERNAL_DONATE_STEAL_INLINE=0",
+        "-DGOOGLE_PROTOBUF_NO_RTTI",
+        "-DGOOGLE_PROTOBUF_NO_STATIC_INITIALIZER",
+        "-DGTEST_API_=",
+        "-DGTEST_HAS_ABSL=1",
+        "-DGTEST_HAS_POSIX_RE=0",
+        "-DGTEST_HAS_TR1_TUPLE=0",
+        "-DGTEST_LANG_CXX11=1",
+        "-DHAVE_PTHREAD",
+        "-DHAVE_SYS_UIO_H",
+        "-DICU_UTIL_DATA_IMPL=ICU_UTIL_DATA_FILE",
+        "-DNDEBUG",
+        "-DNO_UNWIND_TABLES",
+        "-DNVALGRIND",
+        "-DOFFICIAL_BUILD",
+        "-DUNIT_TEST",
+        "-DUSE_CHROMIUM_ICU=1",
+        "-DUSE_REMOTE_TEST_SERVER",
+        "-DU_ENABLE_DYLOAD=0",
+        "-DU_ENABLE_RESOURCE_TRACING=0",
+        "-DU_ENABLE_TRACING=1",
+        "-DU_STATIC_IMPLEMENTATION",
+        "-DU_USING_ICU_NAMESPACE=0",
+        "-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",
+        "net/third_party/quiche/overrides/",
+        "net/third_party/quiche/src/",
+        "net/third_party/quiche/src/quiche/common/platform/default/",
+        "third_party/abseil-cpp/",
+        "third_party/boringssl/src/include/",
+        "third_party/ced/src/",
+        "third_party/googletest/custom/",
+        "third_party/googletest/src/googlemock/include/",
+        "third_party/googletest/src/googletest/include/",
+        "third_party/icu/source/common/",
+        "third_party/icu/source/i18n/",
+        "third_party/protobuf/src/",
+    ],
+    cpp_std: "c++17",
     ldflags: [
         "-Wl,--as-needed",
         "-Wl,--gc-sections",
@@ -16555,6 +15575,7 @@
         "-Wl,-wrap,valloc",
         "-Wl,-wrap,vasprintf",
     ],
+    stem: "libnet_unittests__library",
     target: {
         android_arm: {
             cflags: [
@@ -16589,6 +15610,8 @@
         "net/extras/preload_data/decoder.cc",
     ],
     shared_libs: [
+        "//external/cronet/third_party/boringssl:libcrypto",
+        "//external/cronet/third_party/boringssl:libssl",
         "libandroid",
         "liblog",
     ],
@@ -16596,60 +15619,8 @@
         "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",
@@ -16755,60 +15726,9 @@
         "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",
@@ -16901,7 +15821,7 @@
 }
 
 // GN: //net:quic_test_flags_utils__testing
-cc_library_static {
+cc_object {
     name: "cronet_aml_net_quic_test_flags_utils__testing",
     srcs: [
         "net/quic/platform/impl/quic_test_flags_utils.cc",
@@ -16915,71 +15835,14 @@
         "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",
@@ -17035,27 +15898,156 @@
         "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: //net:quic_test_tools__testing
+cc_object {
+    name: "cronet_aml_net_quic_test_tools__testing",
+    srcs: [
+        ":cronet_aml_third_party_quic_trace_quic_trace_proto__testing_gen",
+        "net/quic/crypto_test_utils_chromium.cc",
+        "net/quic/mock_crypto_client_stream.cc",
+        "net/quic/mock_crypto_client_stream_factory.cc",
+        "net/quic/mock_decrypter.cc",
+        "net/quic/mock_encrypter.cc",
+        "net/quic/mock_quic_context.cc",
+        "net/quic/test_task_runner.cc",
     ],
+    shared_libs: [
+        "libandroid",
+        "liblog",
+        "libprotobuf-cpp-lite",
+        "libz",
+    ],
+    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_i18n__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_crypto_test_support__testing",
+        "cronet_aml_net_gtest_util__testing",
+        "cronet_aml_net_net__testing",
+        "cronet_aml_net_preload_decoder__testing",
+        "cronet_aml_net_test_support__testing",
+        "cronet_aml_net_third_party_quiche_quiche__testing",
+        "cronet_aml_net_third_party_quiche_quiche_test_support__testing",
+        "cronet_aml_net_third_party_quiche_quiche_tool_support__testing",
+        "cronet_aml_net_uri_template__testing",
+        "cronet_aml_testing_gtest_gtest__testing",
+        "cronet_aml_third_party_boringssl_boringssl__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_icu_icui18n__testing",
+        "cronet_aml_third_party_icu_icuuc_private__testing",
+        "cronet_aml_third_party_libevent_libevent__testing",
+        "cronet_aml_third_party_libxml_libxml__testing",
+        "cronet_aml_third_party_libxml_libxml_utils__testing",
+        "cronet_aml_third_party_libxml_xml_reader__testing",
+        "cronet_aml_third_party_modp_b64_modp_b64__testing",
+        "cronet_aml_third_party_protobuf_protobuf_lite__testing",
+        "cronet_aml_url_url__testing",
+    ],
+    generated_headers: [
+        "cronet_aml_build_chromeos_buildflags__testing",
+        "cronet_aml_third_party_quic_trace_quic_trace_proto__testing_gen_headers",
+    ],
+    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",
+        "-DGOOGLE_PROTOBUF_INTERNAL_DONATE_STEAL_INLINE=0",
+        "-DGOOGLE_PROTOBUF_NO_RTTI",
+        "-DGOOGLE_PROTOBUF_NO_STATIC_INITIALIZER",
+        "-DGTEST_API_=",
+        "-DGTEST_HAS_ABSL=1",
+        "-DGTEST_HAS_POSIX_RE=0",
+        "-DGTEST_HAS_TR1_TUPLE=0",
+        "-DGTEST_LANG_CXX11=1",
+        "-DHAVE_PTHREAD",
+        "-DHAVE_SYS_UIO_H",
+        "-DICU_UTIL_DATA_IMPL=ICU_UTIL_DATA_FILE",
+        "-DNDEBUG",
+        "-DNO_UNWIND_TABLES",
+        "-DNVALGRIND",
+        "-DOFFICIAL_BUILD",
+        "-DUNIT_TEST",
+        "-DUSE_CHROMIUM_ICU=1",
+        "-DUSE_REMOTE_TEST_SERVER",
+        "-DU_ENABLE_DYLOAD=0",
+        "-DU_ENABLE_RESOURCE_TRACING=0",
+        "-DU_ENABLE_TRACING=1",
+        "-DU_STATIC_IMPLEMENTATION",
+        "-DU_USING_ICU_NAMESPACE=0",
+        "-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",
+        "net/third_party/quiche/overrides/",
+        "net/third_party/quiche/src/",
+        "net/third_party/quiche/src/quiche/common/platform/default/",
+        "third_party/abseil-cpp/",
+        "third_party/boringssl/src/include/",
+        "third_party/ced/src/",
+        "third_party/googletest/custom/",
+        "third_party/googletest/src/googlemock/include/",
+        "third_party/googletest/src/googletest/include/",
+        "third_party/icu/source/common/",
+        "third_party/icu/source/i18n/",
+        "third_party/protobuf/src/",
+    ],
+    cpp_std: "c++17",
     target: {
         android_arm: {
             cflags: [
@@ -17084,7 +16076,7 @@
 }
 
 // GN: //net:simple_quic_tools__testing
-cc_library_static {
+cc_object {
     name: "cronet_aml_net_simple_quic_tools__testing",
     srcs: [
         "net/tools/quic/quic_client_message_loop_network_helper.cc",
@@ -17104,72 +16096,15 @@
         "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",
@@ -17225,27 +16160,124 @@
         "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: //net:spdy_test_tools__testing
+cc_object {
+    name: "cronet_aml_net_spdy_test_tools__testing",
+    srcs: [
+        "net/spdy/fuzzing/hpack_fuzz_util.cc",
     ],
+    shared_libs: [
+        "libandroid",
+        "liblog",
+        "libz",
+    ],
+    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_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__testing",
+        "cronet_aml_net_preload_decoder__testing",
+        "cronet_aml_net_third_party_quiche_quiche__testing",
+        "cronet_aml_net_uri_template__testing",
+        "cronet_aml_testing_gtest_gtest__testing",
+        "cronet_aml_third_party_boringssl_boringssl__testing",
+        "cronet_aml_third_party_brotli_common__testing",
+        "cronet_aml_third_party_brotli_dec__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",
+        "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",
+    ],
+    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",
+        "-DGOOGLE_PROTOBUF_INTERNAL_DONATE_STEAL_INLINE=0",
+        "-DGOOGLE_PROTOBUF_NO_RTTI",
+        "-DGOOGLE_PROTOBUF_NO_STATIC_INITIALIZER",
+        "-DGTEST_API_=",
+        "-DGTEST_HAS_ABSL=1",
+        "-DGTEST_HAS_POSIX_RE=0",
+        "-DGTEST_HAS_TR1_TUPLE=0",
+        "-DGTEST_LANG_CXX11=1",
+        "-DHAVE_PTHREAD",
+        "-DHAVE_SYS_UIO_H",
+        "-DNDEBUG",
+        "-DNO_UNWIND_TABLES",
+        "-DNVALGRIND",
+        "-DOFFICIAL_BUILD",
+        "-DUNIT_TEST",
+        "-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",
+        "net/third_party/quiche/overrides/",
+        "net/third_party/quiche/src/",
+        "net/third_party/quiche/src/quiche/common/platform/default/",
+        "third_party/abseil-cpp/",
+        "third_party/boringssl/src/include/",
+        "third_party/googletest/custom/",
+        "third_party/googletest/src/googlemock/include/",
+        "third_party/googletest/src/googletest/include/",
+        "third_party/protobuf/src/",
+    ],
+    cpp_std: "c++17",
     target: {
         android_arm: {
             cflags: [
@@ -17277,6 +16309,60 @@
 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",
@@ -17363,85 +16449,22 @@
         "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",
@@ -17453,9 +16476,13 @@
         "cronet_aml_url_url__testing",
     ],
     generated_headers: [
+        "cronet_aml_build_chromeos_buildflags__testing",
+        "cronet_aml_net_cronet_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_cronet_buildflags__testing",
         "cronet_aml_net_http_transport_security_state_unittest_data_default__testing",
     ],
     defaults: [
@@ -17629,6 +16656,10 @@
         "net/third_party/quiche/src/quiche/quic/core/proto/crypto_server_config.proto",
         "net/third_party/quiche/src/quiche/quic/core/proto/source_address_token.proto",
     ],
+    shared_libs: [
+        "//external/cronet/third_party/boringssl:libcrypto",
+        "//external/cronet/third_party/boringssl:libssl",
+    ],
     tools: [
         "cronet_aml_third_party_protobuf_protoc",
     ],
@@ -17757,6 +16788,53 @@
     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",
@@ -18039,6 +17117,8 @@
         "net/third_party/quiche/src/quiche/spdy/core/spdy_simple_arena.cc",
     ],
     shared_libs: [
+        "//external/cronet/third_party/boringssl:libcrypto",
+        "//external/cronet/third_party/boringssl:libssl",
         "libandroid",
         "liblog",
         "libprotobuf-cpp-lite",
@@ -18048,61 +17128,9 @@
         "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",
@@ -18111,9 +17139,11 @@
         "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: [
@@ -18216,6 +17246,53 @@
     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",
@@ -18507,61 +17584,10 @@
         "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",
@@ -18570,9 +17596,11 @@
         "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: [
@@ -18670,6 +17698,681 @@
     },
 }
 
+// GN: //net/third_party/quiche:quiche_test_support__testing
+cc_library_static {
+    name: "cronet_aml_net_third_party_quiche_quiche_test_support__testing",
+    srcs: [
+        ":cronet_aml_net_quic_test_flags_utils__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",
+        ":cronet_aml_third_party_quic_trace_quic_trace_proto__testing_gen",
+        "net/third_party/quiche/overrides/quiche_platform_impl/quiche_test_helpers_impl.cc",
+        "net/third_party/quiche/overrides/quiche_platform_impl/quiche_test_impl.cc",
+        "net/third_party/quiche/overrides/quiche_platform_impl/quiche_test_output_impl.cc",
+        "net/third_party/quiche/src/quiche/common/platform/api/quiche_test_loopback.cc",
+        "net/third_party/quiche/src/quiche/common/platform/default/quiche_platform_impl/quiche_test_loopback_impl.cc",
+        "net/third_party/quiche/src/quiche/common/test_tools/quiche_test_utils.cc",
+        "net/third_party/quiche/src/quiche/http2/adapter/test_frame_sequence.cc",
+        "net/third_party/quiche/src/quiche/http2/adapter/test_utils.cc",
+        "net/third_party/quiche/src/quiche/http2/test_tools/frame_decoder_state_test_util.cc",
+        "net/third_party/quiche/src/quiche/http2/test_tools/frame_parts.cc",
+        "net/third_party/quiche/src/quiche/http2/test_tools/frame_parts_collector.cc",
+        "net/third_party/quiche/src/quiche/http2/test_tools/frame_parts_collector_listener.cc",
+        "net/third_party/quiche/src/quiche/http2/test_tools/hpack_block_builder.cc",
+        "net/third_party/quiche/src/quiche/http2/test_tools/hpack_block_collector.cc",
+        "net/third_party/quiche/src/quiche/http2/test_tools/hpack_entry_collector.cc",
+        "net/third_party/quiche/src/quiche/http2/test_tools/hpack_example.cc",
+        "net/third_party/quiche/src/quiche/http2/test_tools/hpack_string_collector.cc",
+        "net/third_party/quiche/src/quiche/http2/test_tools/http2_constants_test_util.cc",
+        "net/third_party/quiche/src/quiche/http2/test_tools/http2_frame_builder.cc",
+        "net/third_party/quiche/src/quiche/http2/test_tools/http2_frame_decoder_listener_test_util.cc",
+        "net/third_party/quiche/src/quiche/http2/test_tools/http2_random.cc",
+        "net/third_party/quiche/src/quiche/http2/test_tools/http2_structure_decoder_test_util.cc",
+        "net/third_party/quiche/src/quiche/http2/test_tools/http2_structures_test_util.cc",
+        "net/third_party/quiche/src/quiche/http2/test_tools/payload_decoder_base_test_util.cc",
+        "net/third_party/quiche/src/quiche/http2/test_tools/random_decoder_test_base.cc",
+        "net/third_party/quiche/src/quiche/http2/test_tools/random_util.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_trace_visitor.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/bad_packet_writer.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/crypto_test_utils.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/failing_proof_source.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/fake_proof_source.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/first_flight.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/limited_mtu_test_writer.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/mock_clock.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/mock_quic_client_promised_info.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/mock_quic_dispatcher.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/mock_quic_session_visitor.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/mock_quic_spdy_client_stream.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/mock_quic_time_wait_list_manager.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/mock_random.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/packet_dropping_test_writer.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/packet_reordering_writer.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/qpack/qpack_decoder_test_utils.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/qpack/qpack_encoder_peer.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/qpack/qpack_offline_decoder.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/qpack/qpack_test_utils.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/quic_buffered_packet_store_peer.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/quic_client_promised_info_peer.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/quic_coalesced_packet_peer.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/quic_config_peer.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/quic_connection_peer.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/quic_crypto_server_config_peer.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/quic_dispatcher_peer.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/quic_flow_controller_peer.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/quic_framer_peer.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/quic_packet_creator_peer.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/quic_path_validator_peer.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/quic_sent_packet_manager_peer.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/quic_session_peer.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/quic_spdy_session_peer.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/quic_spdy_stream_peer.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/quic_stream_id_manager_peer.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/quic_stream_peer.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/quic_stream_send_buffer_peer.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/quic_stream_sequencer_buffer_peer.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/quic_stream_sequencer_peer.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/quic_sustained_bandwidth_recorder_peer.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/quic_test_backend.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/quic_test_utils.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/quic_time_wait_list_manager_peer.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/quic_unacked_packet_map_peer.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/rtt_stats_peer.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/send_algorithm_test_utils.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/simple_data_producer.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/simple_quic_framer.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/simple_session_cache.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/simple_session_notifier.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/simulator/actor.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/simulator/alarm_factory.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/simulator/link.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/simulator/packet_filter.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/simulator/port.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/simulator/queue.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/simulator/quic_endpoint.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/simulator/quic_endpoint_base.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/simulator/simulator.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/simulator/switch.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/simulator/traffic_policer.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/test_certificates.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/test_ticket_crypter.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/web_transport_resets_backend.cc",
+        "net/third_party/quiche/src/quiche/spdy/test_tools/mock_spdy_framer_visitor.cc",
+        "net/third_party/quiche/src/quiche/spdy/test_tools/spdy_test_utils.cc",
+    ],
+    shared_libs: [
+        "libandroid",
+        "liblog",
+        "libprotobuf-cpp-lite",
+        "libz",
+    ],
+    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_i18n__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_crypto_test_support__testing",
+        "cronet_aml_net_gtest_util__testing",
+        "cronet_aml_net_net__testing",
+        "cronet_aml_net_preload_decoder__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_uri_template__testing",
+        "cronet_aml_testing_gtest_gtest__testing",
+        "cronet_aml_third_party_boringssl_boringssl__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_icu_icui18n__testing",
+        "cronet_aml_third_party_icu_icuuc_private__testing",
+        "cronet_aml_third_party_libevent_libevent__testing",
+        "cronet_aml_third_party_libxml_libxml__testing",
+        "cronet_aml_third_party_libxml_libxml_utils__testing",
+        "cronet_aml_third_party_libxml_xml_reader__testing",
+        "cronet_aml_third_party_modp_b64_modp_b64__testing",
+        "cronet_aml_third_party_protobuf_protobuf_lite__testing",
+        "cronet_aml_url_url__testing",
+    ],
+    generated_headers: [
+        "cronet_aml_build_chromeos_buildflags__testing",
+        "cronet_aml_third_party_quic_trace_quic_trace_proto__testing_gen_headers",
+    ],
+    export_generated_headers: [
+        "cronet_aml_build_chromeos_buildflags__testing",
+        "cronet_aml_third_party_quic_trace_quic_trace_proto__testing_gen_headers",
+    ],
+    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",
+        "-DGOOGLE_PROTOBUF_INTERNAL_DONATE_STEAL_INLINE=0",
+        "-DGOOGLE_PROTOBUF_NO_RTTI",
+        "-DGOOGLE_PROTOBUF_NO_STATIC_INITIALIZER",
+        "-DGTEST_API_=",
+        "-DGTEST_HAS_ABSL=1",
+        "-DGTEST_HAS_POSIX_RE=0",
+        "-DGTEST_HAS_TR1_TUPLE=0",
+        "-DGTEST_LANG_CXX11=1",
+        "-DHAVE_PTHREAD",
+        "-DHAVE_SYS_UIO_H",
+        "-DICU_UTIL_DATA_IMPL=ICU_UTIL_DATA_FILE",
+        "-DNDEBUG",
+        "-DNO_UNWIND_TABLES",
+        "-DNVALGRIND",
+        "-DOFFICIAL_BUILD",
+        "-DUNIT_TEST",
+        "-DUSE_CHROMIUM_ICU=1",
+        "-DUSE_REMOTE_TEST_SERVER",
+        "-DU_ENABLE_DYLOAD=0",
+        "-DU_ENABLE_RESOURCE_TRACING=0",
+        "-DU_ENABLE_TRACING=1",
+        "-DU_STATIC_IMPLEMENTATION",
+        "-DU_USING_ICU_NAMESPACE=0",
+        "-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",
+        "net/third_party/quiche/overrides/",
+        "net/third_party/quiche/src/",
+        "net/third_party/quiche/src/quiche/common/platform/default/",
+        "third_party/abseil-cpp/",
+        "third_party/boringssl/src/include/",
+        "third_party/ced/src/",
+        "third_party/googletest/custom/",
+        "third_party/googletest/src/googlemock/include/",
+        "third_party/googletest/src/googletest/include/",
+        "third_party/icu/source/common/",
+        "third_party/icu/source/i18n/",
+        "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: //net/third_party/quiche:quiche_tests__testing
+cc_object {
+    name: "cronet_aml_net_third_party_quiche_quiche_tests__testing",
+    srcs: [
+        "net/third_party/quiche/src/quiche/common/platform/api/quiche_file_utils_test.cc",
+        "net/third_party/quiche/src/quiche/common/platform/api/quiche_hostname_utils_test.cc",
+        "net/third_party/quiche/src/quiche/common/platform/api/quiche_mem_slice_test.cc",
+        "net/third_party/quiche/src/quiche/common/platform/api/quiche_reference_counted_test.cc",
+        "net/third_party/quiche/src/quiche/common/platform/api/quiche_stack_trace_test.cc",
+        "net/third_party/quiche/src/quiche/common/platform/api/quiche_time_utils_test.cc",
+        "net/third_party/quiche/src/quiche/common/platform/api/quiche_url_utils_test.cc",
+        "net/third_party/quiche/src/quiche/common/quiche_buffer_allocator_test.cc",
+        "net/third_party/quiche/src/quiche/common/quiche_circular_deque_test.cc",
+        "net/third_party/quiche/src/quiche/common/quiche_data_reader_test.cc",
+        "net/third_party/quiche/src/quiche/common/quiche_data_writer_test.cc",
+        "net/third_party/quiche/src/quiche/common/quiche_endian_test.cc",
+        "net/third_party/quiche/src/quiche/common/quiche_ip_address_test.cc",
+        "net/third_party/quiche/src/quiche/common/quiche_linked_hash_map_test.cc",
+        "net/third_party/quiche/src/quiche/common/quiche_mem_slice_storage_test.cc",
+        "net/third_party/quiche/src/quiche/common/quiche_random_test.cc",
+        "net/third_party/quiche/src/quiche/common/quiche_text_utils_test.cc",
+        "net/third_party/quiche/src/quiche/common/simple_buffer_allocator_test.cc",
+        "net/third_party/quiche/src/quiche/common/structured_headers_generated_test.cc",
+        "net/third_party/quiche/src/quiche/common/structured_headers_test.cc",
+        "net/third_party/quiche/src/quiche/http2/adapter/event_forwarder_test.cc",
+        "net/third_party/quiche/src/quiche/http2/adapter/header_validator_test.cc",
+        "net/third_party/quiche/src/quiche/http2/adapter/noop_header_validator_test.cc",
+        "net/third_party/quiche/src/quiche/http2/adapter/oghttp2_adapter_test.cc",
+        "net/third_party/quiche/src/quiche/http2/adapter/oghttp2_session_test.cc",
+        "net/third_party/quiche/src/quiche/http2/adapter/window_manager_test.cc",
+        "net/third_party/quiche/src/quiche/http2/core/priority_write_scheduler_test.cc",
+        "net/third_party/quiche/src/quiche/http2/decoder/decode_buffer_test.cc",
+        "net/third_party/quiche/src/quiche/http2/decoder/decode_http2_structures_test.cc",
+        "net/third_party/quiche/src/quiche/http2/decoder/http2_frame_decoder_test.cc",
+        "net/third_party/quiche/src/quiche/http2/decoder/http2_structure_decoder_test.cc",
+        "net/third_party/quiche/src/quiche/http2/decoder/payload_decoders/altsvc_payload_decoder_test.cc",
+        "net/third_party/quiche/src/quiche/http2/decoder/payload_decoders/continuation_payload_decoder_test.cc",
+        "net/third_party/quiche/src/quiche/http2/decoder/payload_decoders/data_payload_decoder_test.cc",
+        "net/third_party/quiche/src/quiche/http2/decoder/payload_decoders/goaway_payload_decoder_test.cc",
+        "net/third_party/quiche/src/quiche/http2/decoder/payload_decoders/headers_payload_decoder_test.cc",
+        "net/third_party/quiche/src/quiche/http2/decoder/payload_decoders/ping_payload_decoder_test.cc",
+        "net/third_party/quiche/src/quiche/http2/decoder/payload_decoders/priority_payload_decoder_test.cc",
+        "net/third_party/quiche/src/quiche/http2/decoder/payload_decoders/priority_update_payload_decoder_test.cc",
+        "net/third_party/quiche/src/quiche/http2/decoder/payload_decoders/push_promise_payload_decoder_test.cc",
+        "net/third_party/quiche/src/quiche/http2/decoder/payload_decoders/rst_stream_payload_decoder_test.cc",
+        "net/third_party/quiche/src/quiche/http2/decoder/payload_decoders/settings_payload_decoder_test.cc",
+        "net/third_party/quiche/src/quiche/http2/decoder/payload_decoders/unknown_payload_decoder_test.cc",
+        "net/third_party/quiche/src/quiche/http2/decoder/payload_decoders/window_update_payload_decoder_test.cc",
+        "net/third_party/quiche/src/quiche/http2/hpack/decoder/hpack_block_collector_test.cc",
+        "net/third_party/quiche/src/quiche/http2/hpack/decoder/hpack_block_decoder_test.cc",
+        "net/third_party/quiche/src/quiche/http2/hpack/decoder/hpack_decoder_state_test.cc",
+        "net/third_party/quiche/src/quiche/http2/hpack/decoder/hpack_decoder_string_buffer_test.cc",
+        "net/third_party/quiche/src/quiche/http2/hpack/decoder/hpack_decoder_tables_test.cc",
+        "net/third_party/quiche/src/quiche/http2/hpack/decoder/hpack_decoder_test.cc",
+        "net/third_party/quiche/src/quiche/http2/hpack/decoder/hpack_entry_collector_test.cc",
+        "net/third_party/quiche/src/quiche/http2/hpack/decoder/hpack_entry_decoder_test.cc",
+        "net/third_party/quiche/src/quiche/http2/hpack/decoder/hpack_entry_type_decoder_test.cc",
+        "net/third_party/quiche/src/quiche/http2/hpack/decoder/hpack_string_decoder_test.cc",
+        "net/third_party/quiche/src/quiche/http2/hpack/decoder/hpack_whole_entry_buffer_test.cc",
+        "net/third_party/quiche/src/quiche/http2/hpack/http2_hpack_constants_test.cc",
+        "net/third_party/quiche/src/quiche/http2/hpack/huffman/hpack_huffman_decoder_test.cc",
+        "net/third_party/quiche/src/quiche/http2/hpack/huffman/hpack_huffman_encoder_test.cc",
+        "net/third_party/quiche/src/quiche/http2/hpack/huffman/hpack_huffman_transcoder_test.cc",
+        "net/third_party/quiche/src/quiche/http2/hpack/varint/hpack_varint_decoder_test.cc",
+        "net/third_party/quiche/src/quiche/http2/hpack/varint/hpack_varint_encoder_test.cc",
+        "net/third_party/quiche/src/quiche/http2/hpack/varint/hpack_varint_round_trip_test.cc",
+        "net/third_party/quiche/src/quiche/http2/http2_constants_test.cc",
+        "net/third_party/quiche/src/quiche/http2/http2_structures_test.cc",
+        "net/third_party/quiche/src/quiche/http2/test_tools/hpack_block_builder_test.cc",
+        "net/third_party/quiche/src/quiche/http2/test_tools/http2_random_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/congestion_control/bandwidth_sampler_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/congestion_control/bbr2_simulator_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/congestion_control/bbr_sender_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/congestion_control/cubic_bytes_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/congestion_control/general_loss_algorithm_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/congestion_control/hybrid_slow_start_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/congestion_control/pacing_sender_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/congestion_control/prr_sender_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/congestion_control/rtt_stats_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/congestion_control/send_algorithm_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/congestion_control/tcp_cubic_sender_bytes_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/congestion_control/uber_loss_algorithm_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/congestion_control/windowed_filter_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/crypto/aes_128_gcm_12_decrypter_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/crypto/aes_128_gcm_12_encrypter_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/crypto/aes_128_gcm_decrypter_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/crypto/aes_128_gcm_encrypter_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/crypto/aes_256_gcm_decrypter_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/crypto/aes_256_gcm_encrypter_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/crypto/cert_compressor_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/crypto/certificate_util_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/crypto/certificate_view_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/crypto/chacha20_poly1305_decrypter_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/crypto/chacha20_poly1305_encrypter_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/crypto/chacha20_poly1305_tls_decrypter_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/crypto/chacha20_poly1305_tls_encrypter_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/crypto/channel_id_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/crypto/client_proof_source_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/crypto/crypto_framer_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/crypto/crypto_handshake_message_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/crypto/crypto_secret_boxer_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/crypto/crypto_server_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/crypto/crypto_utils_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/crypto/curve25519_key_exchange_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/crypto/null_decrypter_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/crypto/null_encrypter_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/crypto/p256_key_exchange_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/crypto/proof_source_x509_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/crypto/quic_client_session_cache_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/crypto/quic_compressed_certs_cache_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/crypto/quic_crypto_client_config_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/crypto/quic_crypto_server_config_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/crypto/quic_hkdf_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/crypto/transport_parameters_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/crypto/web_transport_fingerprint_proof_verifier_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/frames/quic_frames_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/http/capsule_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/http/http_decoder_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/http/http_encoder_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/http/http_frames_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/http/quic_client_promised_info_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/http/quic_client_push_promise_index_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/http/quic_header_list_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/http/quic_headers_stream_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/http/quic_receive_control_stream_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/http/quic_send_control_stream_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/http/quic_server_session_base_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/http/quic_spdy_session_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/http/quic_spdy_stream_body_manager_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/http/quic_spdy_stream_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/http/spdy_server_push_utils_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/http/spdy_utils_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/http/web_transport_http3_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/legacy_quic_stream_id_manager_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/packet_number_indexed_queue_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/qpack/qpack_blocking_manager_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/qpack/qpack_decoded_headers_accumulator_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/qpack/qpack_decoder_stream_receiver_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/qpack/qpack_decoder_stream_sender_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/qpack/qpack_decoder_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/qpack/qpack_encoder_stream_receiver_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/qpack/qpack_encoder_stream_sender_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/qpack/qpack_encoder_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/qpack/qpack_header_table_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/qpack/qpack_index_conversions_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/qpack/qpack_instruction_decoder_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/qpack/qpack_instruction_encoder_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/qpack/qpack_receive_stream_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/qpack/qpack_required_insert_count_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/qpack/qpack_round_trip_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/qpack/qpack_send_stream_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/qpack/qpack_static_table_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/qpack/value_splitting_header_list_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_alarm_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_arena_scoped_ptr_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_bandwidth_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_buffered_packet_store_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_chaos_protector_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_coalesced_packet_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_config_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_connection_context_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_connection_id_manager_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_connection_id_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_connection_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_control_frame_manager_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_crypto_client_handshaker_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_crypto_client_stream_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_crypto_server_stream_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_crypto_stream_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_data_writer_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_datagram_queue_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_dispatcher_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_error_codes_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_flow_controller_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_framer_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_idle_network_detector_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_interval_deque_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_interval_set_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_interval_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_legacy_version_encapsulator_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_lru_cache_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_network_blackhole_detector_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_one_block_arena_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_packet_creator_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_packet_number_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_packets_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_path_validator_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_received_packet_manager_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_sent_packet_manager_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_server_id_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_session_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_socket_address_coder_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_stream_id_manager_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_stream_send_buffer_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_stream_sequencer_buffer_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_stream_sequencer_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_stream_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_sustained_bandwidth_recorder_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_tag_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_time_accumulator_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_time_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_time_wait_list_manager_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_trace_visitor_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_unacked_packet_map_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_utils_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_version_manager_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_versions_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/quic_write_blocked_list_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/tls_chlo_extractor_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/tls_client_handshaker_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/uber_quic_stream_id_manager_test.cc",
+        "net/third_party/quiche/src/quiche/quic/core/uber_received_packet_manager_test.cc",
+        "net/third_party/quiche/src/quiche/quic/platform/api/quic_socket_address_test.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/crypto_test_utils_test.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/quic_test_utils_test.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/simple_session_notifier_test.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/simulator/quic_endpoint_test.cc",
+        "net/third_party/quiche/src/quiche/quic/test_tools/simulator/simulator_test.cc",
+        "net/third_party/quiche/src/quiche/quic/tools/quic_memory_cache_backend_test.cc",
+        "net/third_party/quiche/src/quiche/quic/tools/quic_tcp_like_trace_converter_test.cc",
+        "net/third_party/quiche/src/quiche/quic/tools/simple_ticket_crypter_test.cc",
+        "net/third_party/quiche/src/quiche/spdy/core/array_output_buffer_test.cc",
+        "net/third_party/quiche/src/quiche/spdy/core/hpack/hpack_decoder_adapter_test.cc",
+        "net/third_party/quiche/src/quiche/spdy/core/hpack/hpack_encoder_test.cc",
+        "net/third_party/quiche/src/quiche/spdy/core/hpack/hpack_entry_test.cc",
+        "net/third_party/quiche/src/quiche/spdy/core/hpack/hpack_header_table_test.cc",
+        "net/third_party/quiche/src/quiche/spdy/core/hpack/hpack_output_stream_test.cc",
+        "net/third_party/quiche/src/quiche/spdy/core/hpack/hpack_round_trip_test.cc",
+        "net/third_party/quiche/src/quiche/spdy/core/hpack/hpack_static_table_test.cc",
+        "net/third_party/quiche/src/quiche/spdy/core/http2_header_block_test.cc",
+        "net/third_party/quiche/src/quiche/spdy/core/http2_header_storage_test.cc",
+        "net/third_party/quiche/src/quiche/spdy/core/spdy_alt_svc_wire_format_test.cc",
+        "net/third_party/quiche/src/quiche/spdy/core/spdy_frame_builder_test.cc",
+        "net/third_party/quiche/src/quiche/spdy/core/spdy_framer_test.cc",
+        "net/third_party/quiche/src/quiche/spdy/core/spdy_intrusive_list_test.cc",
+        "net/third_party/quiche/src/quiche/spdy/core/spdy_pinnable_buffer_piece_test.cc",
+        "net/third_party/quiche/src/quiche/spdy/core/spdy_prefixed_buffer_reader_test.cc",
+        "net/third_party/quiche/src/quiche/spdy/core/spdy_protocol_test.cc",
+        "net/third_party/quiche/src/quiche/spdy/core/spdy_simple_arena_test.cc",
+    ],
+    shared_libs: [
+        "libandroid",
+        "liblog",
+        "libz",
+    ],
+    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_i18n__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_crypto_test_support__testing",
+        "cronet_aml_net_gtest_util__testing",
+        "cronet_aml_net_net__testing",
+        "cronet_aml_net_preload_decoder__testing",
+        "cronet_aml_net_test_support__testing",
+        "cronet_aml_net_third_party_quiche_quiche__testing",
+        "cronet_aml_net_third_party_quiche_quiche_test_support__testing",
+        "cronet_aml_net_third_party_quiche_quiche_tool_support__testing",
+        "cronet_aml_net_uri_template__testing",
+        "cronet_aml_testing_gtest_gtest__testing",
+        "cronet_aml_third_party_boringssl_boringssl__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_icu_icui18n__testing",
+        "cronet_aml_third_party_icu_icuuc_private__testing",
+        "cronet_aml_third_party_libevent_libevent__testing",
+        "cronet_aml_third_party_libxml_libxml__testing",
+        "cronet_aml_third_party_libxml_libxml_utils__testing",
+        "cronet_aml_third_party_libxml_xml_reader__testing",
+        "cronet_aml_third_party_modp_b64_modp_b64__testing",
+        "cronet_aml_third_party_protobuf_protobuf_lite__testing",
+        "cronet_aml_url_url__testing",
+    ],
+    generated_headers: [
+        "cronet_aml_build_chromeos_buildflags__testing",
+        "cronet_aml_third_party_quic_trace_quic_trace_proto__testing_gen_headers",
+    ],
+    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",
+        "-DGOOGLE_PROTOBUF_INTERNAL_DONATE_STEAL_INLINE=0",
+        "-DGOOGLE_PROTOBUF_NO_RTTI",
+        "-DGOOGLE_PROTOBUF_NO_STATIC_INITIALIZER",
+        "-DGTEST_API_=",
+        "-DGTEST_HAS_ABSL=1",
+        "-DGTEST_HAS_POSIX_RE=0",
+        "-DGTEST_HAS_TR1_TUPLE=0",
+        "-DGTEST_LANG_CXX11=1",
+        "-DHAVE_PTHREAD",
+        "-DHAVE_SYS_UIO_H",
+        "-DNDEBUG",
+        "-DNO_UNWIND_TABLES",
+        "-DNVALGRIND",
+        "-DOFFICIAL_BUILD",
+        "-DUNIT_TEST",
+        "-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",
+        "net/third_party/quiche/overrides/",
+        "net/third_party/quiche/src/",
+        "net/third_party/quiche/src/quiche/common/platform/default/",
+        "third_party/abseil-cpp/",
+        "third_party/boringssl/src/include/",
+        "third_party/googletest/custom/",
+        "third_party/googletest/src/googlemock/include/",
+        "third_party/googletest/src/googletest/include/",
+        "third_party/protobuf/src/",
+    ],
+    cpp_std: "c++17",
+    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: //net/third_party/quiche:quiche_tool_support__testing
 cc_library_static {
     name: "cronet_aml_net_third_party_quiche_quiche_tool_support__testing",
@@ -18708,71 +18411,14 @@
         "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",
@@ -18877,7 +18523,7 @@
 }
 
 // GN: //net/tools/huffman_trie:huffman_trie_generator_sources__testing
-cc_library_static {
+cc_object {
     name: "cronet_aml_net_tools_huffman_trie_huffman_trie_generator_sources__testing",
     srcs: [
         "net/tools/huffman_trie/bit_writer.cc",
@@ -18890,99 +18536,39 @@
         "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",
         "cronet_aml_third_party_modp_b64_modp_b64__testing",
     ],
     host_supported: true,
-    device_supported: false,
     defaults: [
         "cronet_aml_defaults",
     ],
     cflags: [
         "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
         "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
-        "-DCR_SYSROOT_KEY=20220331T153654Z-0",
         "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
         "-DNDEBUG",
         "-DNO_UNWIND_TABLES",
         "-DNVALGRIND",
         "-DOFFICIAL_BUILD",
-        "-DUSE_AURA=1",
-        "-DUSE_OZONE=1",
-        "-DUSE_UDEV",
-        "-D_FILE_OFFSET_BITS=64",
         "-D_FORTIFY_SOURCE=2",
         "-D_GNU_SOURCE",
-        "-D_LARGEFILE64_SOURCE",
-        "-D_LARGEFILE_SOURCE",
         "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
         "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
         "-D__STDC_CONSTANT_MACROS",
         "-D__STDC_FORMAT_MACROS",
-        "-O2",
         "-fdata-sections",
         "-ffunction-sections",
         "-fno-asynchronous-unwind-tables",
         "-fno-unwind-tables",
-        "-fstack-protector",
         "-fvisibility-inlines-hidden",
         "-fvisibility=hidden",
         "-g1",
-        "-msse3",
     ],
     local_include_dirs: [
         "./",
@@ -18992,16 +18578,72 @@
         "third_party/abseil-cpp/",
         "third_party/boringssl/src/include/",
     ],
-    cpp_std: "c++20",
-    ldflags: [
-        "-Wl,--as-needed",
-        "-Wl,--gc-sections",
-        "-Wl,--icf=all",
-    ],
+    target: {
+        android: {
+            shared_libs: [
+                "libandroid",
+                "liblog",
+            ],
+        },
+        android_arm: {
+            cflags: [
+                "-DANDROID",
+                "-DANDROID_NDK_VERSION_ROLL=r23_1",
+                "-DHAVE_SYS_UIO_H",
+                "-Oz",
+                "-fstack-protector",
+            ],
+        },
+        android_arm64: {
+            cflags: [
+                "-DANDROID",
+                "-DANDROID_NDK_VERSION_ROLL=r23_1",
+                "-DHAVE_SYS_UIO_H",
+                "-Oz",
+                "-fstack-protector",
+                "-mno-outline",
+                "-mno-outline-atomics",
+            ],
+        },
+        android_x86: {
+            cflags: [
+                "-DANDROID",
+                "-DANDROID_NDK_VERSION_ROLL=r23_1",
+                "-DHAVE_SYS_UIO_H",
+                "-Oz",
+                "-msse3",
+            ],
+        },
+        android_x86_64: {
+            cflags: [
+                "-DANDROID",
+                "-DANDROID_NDK_VERSION_ROLL=r23_1",
+                "-DHAVE_SYS_UIO_H",
+                "-Oz",
+                "-fstack-protector",
+                "-msse3",
+            ],
+        },
+        host: {
+            cflags: [
+                "-DCR_SYSROOT_KEY=20220331T153654Z-0",
+                "-DUSE_AURA=1",
+                "-DUSE_OZONE=1",
+                "-DUSE_UDEV",
+                "-D_FILE_OFFSET_BITS=64",
+                "-D_LARGEFILE64_SOURCE",
+                "-D_LARGEFILE_SOURCE",
+                "-O2",
+                "-fstack-protector",
+                "-msse3",
+            ],
+            compile_multilib: "64",
+        },
+    },
 }
 
 // GN: //net/tools/tld_cleanup:tld_cleanup__testing
-cc_library_static {
+cc_object {
     name: "cronet_aml_net_tools_tld_cleanup_tld_cleanup__testing",
     srcs: [
         "net/tools/tld_cleanup/tld_cleanup_util.cc",
@@ -19014,60 +18656,9 @@
         "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",
@@ -19112,27 +18703,6 @@
         "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: [
@@ -19164,69 +18734,20 @@
 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",
@@ -19286,7 +18807,7 @@
 }
 
 // GN: //net/tools/transport_security_state_generator:transport_security_state_generator_sources__testing
-cc_library_static {
+cc_object {
     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",
@@ -19301,59 +18822,9 @@
         "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",
@@ -19405,20 +18876,17 @@
         "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_library_static {
+cc_object {
     name: "cronet_aml_net_traffic_annotation_traffic_annotation",
     srcs: [
         "net/traffic_annotation/network_traffic_annotation_android.cc",
     ],
     shared_libs: [
+        "//external/cronet/third_party/boringssl:libcrypto",
+        "//external/cronet/third_party/boringssl:libssl",
         "libandroid",
         "liblog",
     ],
@@ -19426,60 +18894,8 @@
         "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",
@@ -19488,9 +18904,6 @@
     generated_headers: [
         "cronet_aml_build_chromeos_buildflags",
     ],
-    export_generated_headers: [
-        "cronet_aml_build_chromeos_buildflags",
-    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -19529,27 +18942,6 @@
         "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: [
@@ -19578,7 +18970,7 @@
 }
 
 // GN: //net/traffic_annotation:traffic_annotation__testing
-cc_library_static {
+cc_object {
     name: "cronet_aml_net_traffic_annotation_traffic_annotation__testing",
     srcs: [
         "net/traffic_annotation/network_traffic_annotation_android.cc",
@@ -19591,60 +18983,9 @@
         "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",
@@ -19653,9 +18994,6 @@
     generated_headers: [
         "cronet_aml_build_chromeos_buildflags__testing",
     ],
-    export_generated_headers: [
-        "cronet_aml_build_chromeos_buildflags__testing",
-    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -19694,27 +19032,6 @@
         "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: [
@@ -19749,6 +19066,8 @@
         "net/third_party/uri_template/uri_template.cc",
     ],
     shared_libs: [
+        "//external/cronet/third_party/boringssl:libcrypto",
+        "//external/cronet/third_party/boringssl:libssl",
         "libandroid",
         "liblog",
     ],
@@ -19756,60 +19075,8 @@
         "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",
@@ -19916,60 +19183,9 @@
         "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",
@@ -20101,7 +19317,7 @@
 }
 
 // GN: //testing/android/native_test:native_test_native_code__testing
-cc_library_static {
+cc_object {
     name: "cronet_aml_testing_android_native_test_native_test_native_code__testing",
     srcs: [
         "testing/android/native_test/native_test_jni_onload.cc",
@@ -20116,67 +19332,13 @@
         "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",
@@ -20185,6 +19347,12 @@
         "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",
     ],
@@ -20223,27 +19391,6 @@
         "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: [
@@ -20272,7 +19419,7 @@
 }
 
 // GN: //testing/android/native_test:native_test_support__testing
-cc_library_static {
+cc_object {
     name: "cronet_aml_testing_android_native_test_native_test_support__testing",
     srcs: [
         "testing/android/native_test/main_runner.cc",
@@ -20289,66 +19436,13 @@
         "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",
@@ -20363,12 +19457,6 @@
         "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",
     ],
@@ -20426,27 +19514,6 @@
         "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: [
@@ -20478,6 +19545,54 @@
 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",
     ],
@@ -20489,66 +19604,20 @@
         "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",
     ],
@@ -20643,7 +19712,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/base:base
-cc_library_static {
+cc_object {
     name: "cronet_aml_third_party_abseil_cpp_absl_base_base",
     srcs: [
         "third_party/abseil-cpp/absl/base/internal/cycleclock.cc",
@@ -20652,11 +19721,6 @@
         "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",
     ],
@@ -20692,11 +19756,6 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
-    ldflags: [
-        "-Wl,--as-needed",
-        "-Wl,--gc-sections",
-        "-Wl,--icf=all",
-    ],
     target: {
         android_arm: {
             cflags: [
@@ -20725,7 +19784,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/base:base__testing
-cc_library_static {
+cc_object {
     name: "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
     srcs: [
         "third_party/abseil-cpp/absl/base/internal/cycleclock.cc",
@@ -20734,11 +19793,6 @@
         "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",
@@ -20770,11 +19824,6 @@
         "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: [
@@ -20834,7 +19883,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/base:log_severity
-cc_library_static {
+cc_object {
     name: "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
     srcs: [
         "third_party/abseil-cpp/absl/base/log_severity.cc",
@@ -20874,11 +19923,6 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
-    ldflags: [
-        "-Wl,--as-needed",
-        "-Wl,--gc-sections",
-        "-Wl,--icf=all",
-    ],
     target: {
         android_arm: {
             cflags: [
@@ -20907,7 +19951,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/base:log_severity__testing
-cc_library_static {
+cc_object {
     name: "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
     srcs: [
         "third_party/abseil-cpp/absl/base/log_severity.cc",
@@ -20943,11 +19987,6 @@
         "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: [
@@ -21007,17 +20046,11 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/base:malloc_internal
-cc_library_static {
+cc_object {
     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",
     ],
@@ -21053,11 +20086,6 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
-    ldflags: [
-        "-Wl,--as-needed",
-        "-Wl,--gc-sections",
-        "-Wl,--icf=all",
-    ],
     target: {
         android_arm: {
             cflags: [
@@ -21086,17 +20114,11 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/base:malloc_internal__testing
-cc_library_static {
+cc_object {
     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",
@@ -21128,11 +20150,6 @@
         "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: [
@@ -21192,14 +20209,11 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/base:raw_logging_internal
-cc_library_static {
+cc_object {
     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",
     ],
@@ -21235,11 +20249,6 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
-    ldflags: [
-        "-Wl,--as-needed",
-        "-Wl,--gc-sections",
-        "-Wl,--icf=all",
-    ],
     target: {
         android_arm: {
             cflags: [
@@ -21268,14 +20277,11 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/base:raw_logging_internal__testing
-cc_library_static {
+cc_object {
     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",
@@ -21307,11 +20313,6 @@
         "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: [
@@ -21371,7 +20372,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/base:spinlock_wait
-cc_library_static {
+cc_object {
     name: "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
     srcs: [
         "third_party/abseil-cpp/absl/base/internal/spinlock_wait.cc",
@@ -21411,11 +20412,6 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
-    ldflags: [
-        "-Wl,--as-needed",
-        "-Wl,--gc-sections",
-        "-Wl,--icf=all",
-    ],
     target: {
         android_arm: {
             cflags: [
@@ -21444,7 +20440,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/base:spinlock_wait__testing
-cc_library_static {
+cc_object {
     name: "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
     srcs: [
         "third_party/abseil-cpp/absl/base/internal/spinlock_wait.cc",
@@ -21480,11 +20476,6 @@
         "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: [
@@ -21544,7 +20535,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/base:strerror
-cc_library_static {
+cc_object {
     name: "cronet_aml_third_party_abseil_cpp_absl_base_strerror",
     srcs: [
         "third_party/abseil-cpp/absl/base/internal/strerror.cc",
@@ -21584,11 +20575,6 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
-    ldflags: [
-        "-Wl,--as-needed",
-        "-Wl,--gc-sections",
-        "-Wl,--icf=all",
-    ],
     target: {
         android_arm: {
             cflags: [
@@ -21617,7 +20603,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/base:strerror__testing
-cc_library_static {
+cc_object {
     name: "cronet_aml_third_party_abseil_cpp_absl_base_strerror__testing",
     srcs: [
         "third_party/abseil-cpp/absl/base/internal/strerror.cc",
@@ -21653,11 +20639,6 @@
         "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: [
@@ -21717,15 +20698,11 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/base:throw_delegate
-cc_library_static {
+cc_object {
     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",
     ],
@@ -21761,11 +20738,6 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
-    ldflags: [
-        "-Wl,--as-needed",
-        "-Wl,--gc-sections",
-        "-Wl,--icf=all",
-    ],
     target: {
         android_arm: {
             cflags: [
@@ -21794,15 +20766,11 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/base:throw_delegate__testing
-cc_library_static {
+cc_object {
     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",
@@ -21834,11 +20802,6 @@
         "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: [
@@ -21898,33 +20861,12 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/container:hashtablez_sampler
-cc_library_static {
+cc_object {
     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",
     ],
@@ -21960,11 +20902,6 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
-    ldflags: [
-        "-Wl,--as-needed",
-        "-Wl,--gc-sections",
-        "-Wl,--icf=all",
-    ],
     target: {
         android_arm: {
             cflags: [
@@ -21993,33 +20930,12 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/container:hashtablez_sampler__testing
-cc_library_static {
+cc_object {
     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",
@@ -22051,11 +20967,6 @@
         "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: [
@@ -22115,34 +21026,11 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/container:raw_hash_set
-cc_library_static {
+cc_object {
     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",
     ],
@@ -22178,11 +21066,6 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
-    ldflags: [
-        "-Wl,--as-needed",
-        "-Wl,--gc-sections",
-        "-Wl,--icf=all",
-    ],
     target: {
         android_arm: {
             cflags: [
@@ -22211,34 +21094,11 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/container:raw_hash_set__testing
-cc_library_static {
+cc_object {
     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",
@@ -22270,11 +21130,6 @@
         "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: [
@@ -22334,17 +21189,13 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/debugging:debugging_internal
-cc_library_static {
+cc_object {
     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",
     ],
@@ -22380,11 +21231,6 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
-    ldflags: [
-        "-Wl,--as-needed",
-        "-Wl,--gc-sections",
-        "-Wl,--icf=all",
-    ],
     target: {
         android_arm: {
             cflags: [
@@ -22413,17 +21259,13 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/debugging:debugging_internal__testing
-cc_library_static {
+cc_object {
     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",
@@ -22455,11 +21297,6 @@
         "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: [
@@ -22519,17 +21356,11 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/debugging:demangle_internal
-cc_library_static {
+cc_object {
     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",
     ],
@@ -22565,11 +21396,6 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
-    ldflags: [
-        "-Wl,--as-needed",
-        "-Wl,--gc-sections",
-        "-Wl,--icf=all",
-    ],
     target: {
         android_arm: {
             cflags: [
@@ -22598,17 +21424,11 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/debugging:demangle_internal__testing
-cc_library_static {
+cc_object {
     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",
@@ -22640,11 +21460,6 @@
         "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: [
@@ -22704,26 +21519,11 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/debugging:examine_stack
-cc_library_static {
+cc_object {
     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",
     ],
@@ -22759,11 +21559,6 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
-    ldflags: [
-        "-Wl,--as-needed",
-        "-Wl,--gc-sections",
-        "-Wl,--icf=all",
-    ],
     target: {
         android_arm: {
             cflags: [
@@ -22792,26 +21587,11 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/debugging:examine_stack__testing
-cc_library_static {
+cc_object {
     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",
@@ -22843,11 +21623,6 @@
         "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: [
@@ -22907,27 +21682,11 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/debugging:failure_signal_handler
-cc_library_static {
+cc_object {
     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",
     ],
@@ -22963,11 +21722,6 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
-    ldflags: [
-        "-Wl,--as-needed",
-        "-Wl,--gc-sections",
-        "-Wl,--icf=all",
-    ],
     target: {
         android_arm: {
             cflags: [
@@ -22996,27 +21750,11 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/debugging:failure_signal_handler__testing
-cc_library_static {
+cc_object {
     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",
@@ -23048,11 +21786,6 @@
         "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: [
@@ -23112,16 +21845,11 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/debugging:stacktrace
-cc_library_static {
+cc_object {
     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",
     ],
@@ -23157,11 +21885,6 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
-    ldflags: [
-        "-Wl,--as-needed",
-        "-Wl,--gc-sections",
-        "-Wl,--icf=all",
-    ],
     target: {
         android_arm: {
             cflags: [
@@ -23190,16 +21913,11 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/debugging:stacktrace__testing
-cc_library_static {
+cc_object {
     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",
@@ -23231,11 +21949,6 @@
         "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: [
@@ -23295,24 +22008,11 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/debugging:symbolize
-cc_library_static {
+cc_object {
     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",
     ],
@@ -23348,11 +22048,6 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
-    ldflags: [
-        "-Wl,--as-needed",
-        "-Wl,--gc-sections",
-        "-Wl,--icf=all",
-    ],
     target: {
         android_arm: {
             cflags: [
@@ -23381,24 +22076,11 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/debugging:symbolize__testing
-cc_library_static {
+cc_object {
     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",
@@ -23430,11 +22112,6 @@
         "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: [
@@ -23494,17 +22171,11 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/hash:city
-cc_library_static {
+cc_object {
     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",
     ],
@@ -23540,11 +22211,6 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
-    ldflags: [
-        "-Wl,--as-needed",
-        "-Wl,--gc-sections",
-        "-Wl,--icf=all",
-    ],
     target: {
         android_arm: {
             cflags: [
@@ -23573,17 +22239,11 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/hash:city__testing
-cc_library_static {
+cc_object {
     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",
@@ -23615,11 +22275,6 @@
         "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: [
@@ -23679,25 +22334,11 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/hash:hash
-cc_library_static {
+cc_object {
     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",
     ],
@@ -23733,11 +22374,6 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
-    ldflags: [
-        "-Wl,--as-needed",
-        "-Wl,--gc-sections",
-        "-Wl,--icf=all",
-    ],
     target: {
         android_arm: {
             cflags: [
@@ -23766,25 +22402,11 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/hash:hash__testing
-cc_library_static {
+cc_object {
     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",
@@ -23816,11 +22438,6 @@
         "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: [
@@ -23880,18 +22497,11 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/hash:low_level_hash
-cc_library_static {
+cc_object {
     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",
     ],
@@ -23927,11 +22537,6 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
-    ldflags: [
-        "-Wl,--as-needed",
-        "-Wl,--gc-sections",
-        "-Wl,--icf=all",
-    ],
     target: {
         android_arm: {
             cflags: [
@@ -23960,18 +22565,11 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/hash:low_level_hash__testing
-cc_library_static {
+cc_object {
     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",
@@ -24003,11 +22601,6 @@
         "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: [
@@ -24067,7 +22660,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/numeric:int128
-cc_library_static {
+cc_object {
     name: "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
     srcs: [
         "third_party/abseil-cpp/absl/numeric/int128.cc",
@@ -24107,11 +22700,6 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
-    ldflags: [
-        "-Wl,--as-needed",
-        "-Wl,--gc-sections",
-        "-Wl,--icf=all",
-    ],
     target: {
         android_arm: {
             cflags: [
@@ -24140,7 +22728,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/numeric:int128__testing
-cc_library_static {
+cc_object {
     name: "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
     srcs: [
         "third_party/abseil-cpp/absl/numeric/int128.cc",
@@ -24176,11 +22764,6 @@
         "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: [
@@ -24240,7 +22823,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/profiling:exponential_biased
-cc_library_static {
+cc_object {
     name: "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
     srcs: [
         "third_party/abseil-cpp/absl/profiling/internal/exponential_biased.cc",
@@ -24280,11 +22863,6 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
-    ldflags: [
-        "-Wl,--as-needed",
-        "-Wl,--gc-sections",
-        "-Wl,--icf=all",
-    ],
     target: {
         android_arm: {
             cflags: [
@@ -24313,7 +22891,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/profiling:exponential_biased__testing
-cc_library_static {
+cc_object {
     name: "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
     srcs: [
         "third_party/abseil-cpp/absl/profiling/internal/exponential_biased.cc",
@@ -24349,11 +22927,6 @@
         "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: [
@@ -24413,22 +22986,12 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/random:distributions
-cc_library_static {
+cc_object {
     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",
     ],
@@ -24464,11 +23027,6 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
-    ldflags: [
-        "-Wl,--as-needed",
-        "-Wl,--gc-sections",
-        "-Wl,--icf=all",
-    ],
     target: {
         android_arm: {
             cflags: [
@@ -24497,22 +23055,12 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/random:distributions__testing
-cc_library_static {
+cc_object {
     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",
@@ -24544,11 +23092,6 @@
         "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: [
@@ -24608,7 +23151,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/random/internal:platform
-cc_library_static {
+cc_object {
     name: "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
     srcs: [
         "third_party/abseil-cpp/absl/random/internal/randen_round_keys.cc",
@@ -24616,9 +23159,6 @@
     generated_headers: [
         "cronet_aml_build_chromeos_buildflags",
     ],
-    export_generated_headers: [
-        "cronet_aml_build_chromeos_buildflags",
-    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -24654,11 +23194,6 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
-    ldflags: [
-        "-Wl,--as-needed",
-        "-Wl,--gc-sections",
-        "-Wl,--icf=all",
-    ],
     target: {
         android_arm: {
             cflags: [
@@ -24687,7 +23222,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/random/internal:platform__testing
-cc_library_static {
+cc_object {
     name: "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
     srcs: [
         "third_party/abseil-cpp/absl/random/internal/randen_round_keys.cc",
@@ -24696,9 +23231,6 @@
     generated_headers: [
         "cronet_aml_build_chromeos_buildflags__testing",
     ],
-    export_generated_headers: [
-        "cronet_aml_build_chromeos_buildflags__testing",
-    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -24729,11 +23261,6 @@
         "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: [
@@ -24793,28 +23320,13 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/random/internal:pool_urbg
-cc_library_static {
+cc_object {
     name: "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg",
     srcs: [
         "third_party/abseil-cpp/absl/random/internal/pool_urbg.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_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",
+    generated_headers: [
+        "cronet_aml_build_chromeos_buildflags",
     ],
     defaults: [
         "cronet_aml_defaults",
@@ -24851,11 +23363,6 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
-    ldflags: [
-        "-Wl,--as-needed",
-        "-Wl,--gc-sections",
-        "-Wl,--icf=all",
-    ],
     target: {
         android_arm: {
             cflags: [
@@ -24884,30 +23391,15 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/random/internal:pool_urbg__testing
-cc_library_static {
+cc_object {
     name: "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg__testing",
     srcs: [
         "third_party/abseil-cpp/absl/random/internal/pool_urbg.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_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,
+    generated_headers: [
+        "cronet_aml_build_chromeos_buildflags__testing",
+    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -24938,11 +23430,6 @@
         "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: [
@@ -25002,21 +23489,13 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/random/internal:randen
-cc_library_static {
+cc_object {
     name: "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen",
     srcs: [
         "third_party/abseil-cpp/absl/random/internal/randen.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",
-        "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",
+    generated_headers: [
+        "cronet_aml_build_chromeos_buildflags",
     ],
     defaults: [
         "cronet_aml_defaults",
@@ -25053,11 +23532,6 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
-    ldflags: [
-        "-Wl,--as-needed",
-        "-Wl,--gc-sections",
-        "-Wl,--icf=all",
-    ],
     target: {
         android_arm: {
             cflags: [
@@ -25086,23 +23560,15 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/random/internal:randen__testing
-cc_library_static {
+cc_object {
     name: "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen__testing",
     srcs: [
         "third_party/abseil-cpp/absl/random/internal/randen.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",
-        "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,
+    generated_headers: [
+        "cronet_aml_build_chromeos_buildflags__testing",
+    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -25133,11 +23599,6 @@
         "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: [
@@ -25197,15 +23658,13 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/random/internal:randen_hwaes
-cc_library_static {
+cc_object {
     name: "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes",
     srcs: [
         "third_party/abseil-cpp/absl/random/internal/randen_detect.cc",
     ],
-    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",
+    generated_headers: [
+        "cronet_aml_build_chromeos_buildflags",
     ],
     defaults: [
         "cronet_aml_defaults",
@@ -25242,11 +23701,6 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
-    ldflags: [
-        "-Wl,--as-needed",
-        "-Wl,--gc-sections",
-        "-Wl,--icf=all",
-    ],
     target: {
         android_arm: {
             cflags: [
@@ -25275,17 +23729,15 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/random/internal:randen_hwaes__testing
-cc_library_static {
+cc_object {
     name: "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
     srcs: [
         "third_party/abseil-cpp/absl/random/internal/randen_detect.cc",
     ],
-    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,
+    generated_headers: [
+        "cronet_aml_build_chromeos_buildflags__testing",
+    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -25316,11 +23768,6 @@
         "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: [
@@ -25380,14 +23827,13 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/random/internal:randen_hwaes_impl
-cc_library_static {
+cc_object {
     name: "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl",
     srcs: [
         "third_party/abseil-cpp/absl/random/internal/randen_hwaes.cc",
     ],
-    static_libs: [
-        "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
-        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
+    generated_headers: [
+        "cronet_aml_build_chromeos_buildflags",
     ],
     defaults: [
         "cronet_aml_defaults",
@@ -25424,11 +23870,6 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
-    ldflags: [
-        "-Wl,--as-needed",
-        "-Wl,--gc-sections",
-        "-Wl,--icf=all",
-    ],
     target: {
         android_arm: {
             cflags: [
@@ -25457,16 +23898,15 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/random/internal:randen_hwaes_impl__testing
-cc_library_static {
+cc_object {
     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",
     ],
-    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,
+    generated_headers: [
+        "cronet_aml_build_chromeos_buildflags__testing",
+    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -25497,11 +23937,6 @@
         "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: [
@@ -25561,18 +23996,13 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/random/internal:randen_slow
-cc_library_static {
+cc_object {
     name: "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow",
     srcs: [
         "third_party/abseil-cpp/absl/random/internal/randen_slow.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",
-        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
+    generated_headers: [
+        "cronet_aml_build_chromeos_buildflags",
     ],
     defaults: [
         "cronet_aml_defaults",
@@ -25609,11 +24039,6 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
-    ldflags: [
-        "-Wl,--as-needed",
-        "-Wl,--gc-sections",
-        "-Wl,--icf=all",
-    ],
     target: {
         android_arm: {
             cflags: [
@@ -25642,20 +24067,15 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/random/internal:randen_slow__testing
-cc_library_static {
+cc_object {
     name: "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
     srcs: [
         "third_party/abseil-cpp/absl/random/internal/randen_slow.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",
-        "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
-    ],
     host_supported: true,
+    generated_headers: [
+        "cronet_aml_build_chromeos_buildflags__testing",
+    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -25686,11 +24106,6 @@
         "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: [
@@ -25750,22 +24165,11 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/random/internal:seed_material
-cc_library_static {
+cc_object {
     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",
     ],
@@ -25801,11 +24205,6 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
-    ldflags: [
-        "-Wl,--as-needed",
-        "-Wl,--gc-sections",
-        "-Wl,--icf=all",
-    ],
     target: {
         android_arm: {
             cflags: [
@@ -25834,22 +24233,11 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/random/internal:seed_material__testing
-cc_library_static {
+cc_object {
     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",
@@ -25881,11 +24269,6 @@
         "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: [
@@ -25945,7 +24328,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/random:seed_gen_exception
-cc_library_static {
+cc_object {
     name: "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception",
     srcs: [
         "third_party/abseil-cpp/absl/random/seed_gen_exception.cc",
@@ -25985,11 +24368,6 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
-    ldflags: [
-        "-Wl,--as-needed",
-        "-Wl,--gc-sections",
-        "-Wl,--icf=all",
-    ],
     target: {
         android_arm: {
             cflags: [
@@ -26018,7 +24396,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/random:seed_gen_exception__testing
-cc_library_static {
+cc_object {
     name: "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception__testing",
     srcs: [
         "third_party/abseil-cpp/absl/random/seed_gen_exception.cc",
@@ -26054,11 +24432,6 @@
         "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: [
@@ -26118,29 +24491,13 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/random:seed_sequences
-cc_library_static {
+cc_object {
     name: "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences",
     srcs: [
         "third_party/abseil-cpp/absl/random/seed_sequences.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_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",
+    generated_headers: [
+        "cronet_aml_build_chromeos_buildflags",
     ],
     defaults: [
         "cronet_aml_defaults",
@@ -26177,11 +24534,6 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
-    ldflags: [
-        "-Wl,--as-needed",
-        "-Wl,--gc-sections",
-        "-Wl,--icf=all",
-    ],
     target: {
         android_arm: {
             cflags: [
@@ -26210,31 +24562,15 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/random:seed_sequences__testing
-cc_library_static {
+cc_object {
     name: "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences__testing",
     srcs: [
         "third_party/abseil-cpp/absl/random/seed_sequences.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_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,
+    generated_headers: [
+        "cronet_aml_build_chromeos_buildflags__testing",
+    ],
     defaults: [
         "cronet_aml_defaults",
     ],
@@ -26265,11 +24601,6 @@
         "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: [
@@ -26329,41 +24660,12 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/status:status
-cc_library_static {
+cc_object {
     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",
     ],
@@ -26399,11 +24701,6 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
-    ldflags: [
-        "-Wl,--as-needed",
-        "-Wl,--gc-sections",
-        "-Wl,--icf=all",
-    ],
     target: {
         android_arm: {
             cflags: [
@@ -26432,41 +24729,12 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/status:status__testing
-cc_library_static {
+cc_object {
     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",
@@ -26498,11 +24766,6 @@
         "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: [
@@ -26562,42 +24825,11 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/status:statusor
-cc_library_static {
+cc_object {
     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",
     ],
@@ -26633,11 +24865,6 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
-    ldflags: [
-        "-Wl,--as-needed",
-        "-Wl,--gc-sections",
-        "-Wl,--icf=all",
-    ],
     target: {
         android_arm: {
             cflags: [
@@ -26666,42 +24893,11 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/status:statusor__testing
-cc_library_static {
+cc_object {
     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",
@@ -26733,11 +24929,6 @@
         "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: [
@@ -26797,40 +24988,13 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/strings:cord
-cc_library_static {
+cc_object {
     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",
     ],
@@ -26866,11 +25030,6 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
-    ldflags: [
-        "-Wl,--as-needed",
-        "-Wl,--gc-sections",
-        "-Wl,--icf=all",
-    ],
     target: {
         android_arm: {
             cflags: [
@@ -26899,40 +25058,13 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/strings:cord__testing
-cc_library_static {
+cc_object {
     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",
@@ -26964,11 +25096,6 @@
         "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: [
@@ -27028,7 +25155,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/strings:cord_internal
-cc_library_static {
+cc_object {
     name: "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal",
     srcs: [
         "third_party/abseil-cpp/absl/strings/internal/cord_internal.cc",
@@ -27039,16 +25166,6 @@
         "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",
     ],
@@ -27084,11 +25201,6 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
-    ldflags: [
-        "-Wl,--as-needed",
-        "-Wl,--gc-sections",
-        "-Wl,--icf=all",
-    ],
     target: {
         android_arm: {
             cflags: [
@@ -27117,7 +25229,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/strings:cord_internal__testing
-cc_library_static {
+cc_object {
     name: "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
     srcs: [
         "third_party/abseil-cpp/absl/strings/internal/cord_internal.cc",
@@ -27128,16 +25240,6 @@
         "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",
@@ -27169,11 +25271,6 @@
         "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: [
@@ -27233,16 +25330,11 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/strings:cordz_functions
-cc_library_static {
+cc_object {
     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",
     ],
@@ -27278,11 +25370,6 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
-    ldflags: [
-        "-Wl,--as-needed",
-        "-Wl,--gc-sections",
-        "-Wl,--icf=all",
-    ],
     target: {
         android_arm: {
             cflags: [
@@ -27311,16 +25398,11 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/strings:cordz_functions__testing
-cc_library_static {
+cc_object {
     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",
@@ -27352,11 +25434,6 @@
         "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: [
@@ -27416,31 +25493,11 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/strings:cordz_handle
-cc_library_static {
+cc_object {
     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",
     ],
@@ -27476,11 +25533,6 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
-    ldflags: [
-        "-Wl,--as-needed",
-        "-Wl,--gc-sections",
-        "-Wl,--icf=all",
-    ],
     target: {
         android_arm: {
             cflags: [
@@ -27509,31 +25561,11 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/strings:cordz_handle__testing
-cc_library_static {
+cc_object {
     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",
@@ -27565,11 +25597,6 @@
         "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: [
@@ -27629,35 +25656,11 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/strings:cordz_info
-cc_library_static {
+cc_object {
     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",
     ],
@@ -27693,11 +25696,6 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
-    ldflags: [
-        "-Wl,--as-needed",
-        "-Wl,--gc-sections",
-        "-Wl,--icf=all",
-    ],
     target: {
         android_arm: {
             cflags: [
@@ -27726,35 +25724,11 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/strings:cordz_info__testing
-cc_library_static {
+cc_object {
     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",
@@ -27786,11 +25760,6 @@
         "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: [
@@ -27850,19 +25819,13 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/strings:internal
-cc_library_static {
+cc_object {
     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",
     ],
@@ -27898,11 +25861,6 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
-    ldflags: [
-        "-Wl,--as-needed",
-        "-Wl,--gc-sections",
-        "-Wl,--icf=all",
-    ],
     target: {
         android_arm: {
             cflags: [
@@ -27931,19 +25889,13 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/strings:internal__testing
-cc_library_static {
+cc_object {
     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",
@@ -27975,11 +25927,6 @@
         "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: [
@@ -28039,7 +25986,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/strings:str_format_internal
-cc_library_static {
+cc_object {
     name: "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal",
     srcs: [
         "third_party/abseil-cpp/absl/strings/internal/str_format/arg.cc",
@@ -28049,17 +25996,6 @@
         "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",
     ],
@@ -28095,11 +26031,6 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
-    ldflags: [
-        "-Wl,--as-needed",
-        "-Wl,--gc-sections",
-        "-Wl,--icf=all",
-    ],
     target: {
         android_arm: {
             cflags: [
@@ -28128,7 +26059,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/strings:str_format_internal__testing
-cc_library_static {
+cc_object {
     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",
@@ -28138,17 +26069,6 @@
         "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",
@@ -28180,11 +26100,6 @@
         "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: [
@@ -28244,7 +26159,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/strings:strings
-cc_library_static {
+cc_object {
     name: "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
     srcs: [
         "third_party/abseil-cpp/absl/strings/ascii.cc",
@@ -28261,15 +26176,6 @@
         "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",
     ],
@@ -28305,11 +26211,6 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
-    ldflags: [
-        "-Wl,--as-needed",
-        "-Wl,--gc-sections",
-        "-Wl,--icf=all",
-    ],
     target: {
         android_arm: {
             cflags: [
@@ -28338,7 +26239,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/strings:strings__testing
-cc_library_static {
+cc_object {
     name: "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
     srcs: [
         "third_party/abseil-cpp/absl/strings/ascii.cc",
@@ -28355,15 +26256,6 @@
         "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",
@@ -28395,11 +26287,6 @@
         "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: [
@@ -28459,18 +26346,11 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/synchronization:graphcycles_internal
-cc_library_static {
+cc_object {
     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",
     ],
@@ -28506,11 +26386,6 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
-    ldflags: [
-        "-Wl,--as-needed",
-        "-Wl,--gc-sections",
-        "-Wl,--icf=all",
-    ],
     target: {
         android_arm: {
             cflags: [
@@ -28539,18 +26414,11 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/synchronization:graphcycles_internal__testing
-cc_library_static {
+cc_object {
     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",
@@ -28582,11 +26450,6 @@
         "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: [
@@ -28646,7 +26509,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/synchronization:synchronization
-cc_library_static {
+cc_object {
     name: "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
     srcs: [
         "third_party/abseil-cpp/absl/synchronization/barrier.cc",
@@ -28657,25 +26520,6 @@
         "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",
     ],
@@ -28711,11 +26555,6 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
-    ldflags: [
-        "-Wl,--as-needed",
-        "-Wl,--gc-sections",
-        "-Wl,--icf=all",
-    ],
     target: {
         android_arm: {
             cflags: [
@@ -28744,7 +26583,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/synchronization:synchronization__testing
-cc_library_static {
+cc_object {
     name: "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
     srcs: [
         "third_party/abseil-cpp/absl/synchronization/barrier.cc",
@@ -28755,25 +26594,6 @@
         "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",
@@ -28805,11 +26625,6 @@
         "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: [
@@ -28869,7 +26684,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/time/internal/cctz:civil_time
-cc_library_static {
+cc_object {
     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",
@@ -28909,11 +26724,6 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
-    ldflags: [
-        "-Wl,--as-needed",
-        "-Wl,--gc-sections",
-        "-Wl,--icf=all",
-    ],
     target: {
         android_arm: {
             cflags: [
@@ -28942,7 +26752,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/time/internal/cctz:civil_time__testing
-cc_library_static {
+cc_object {
     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",
@@ -28978,11 +26788,6 @@
         "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: [
@@ -29042,7 +26847,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/time/internal/cctz:time_zone
-cc_library_static {
+cc_object {
     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",
@@ -29055,9 +26860,6 @@
         "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",
     ],
@@ -29093,11 +26895,6 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
-    ldflags: [
-        "-Wl,--as-needed",
-        "-Wl,--gc-sections",
-        "-Wl,--icf=all",
-    ],
     target: {
         android_arm: {
             cflags: [
@@ -29126,7 +26923,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/time/internal/cctz:time_zone__testing
-cc_library_static {
+cc_object {
     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",
@@ -29139,9 +26936,6 @@
         "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",
@@ -29173,11 +26967,6 @@
         "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: [
@@ -29237,7 +27026,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/time:time
-cc_library_static {
+cc_object {
     name: "cronet_aml_third_party_abseil_cpp_absl_time_time",
     srcs: [
         "third_party/abseil-cpp/absl/time/civil_time.cc",
@@ -29246,18 +27035,6 @@
         "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",
     ],
@@ -29293,11 +27070,6 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
-    ldflags: [
-        "-Wl,--as-needed",
-        "-Wl,--gc-sections",
-        "-Wl,--icf=all",
-    ],
     target: {
         android_arm: {
             cflags: [
@@ -29326,7 +27098,7 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/time:time__testing
-cc_library_static {
+cc_object {
     name: "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
     srcs: [
         "third_party/abseil-cpp/absl/time/civil_time.cc",
@@ -29335,18 +27107,6 @@
         "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",
@@ -29378,11 +27138,6 @@
         "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: [
@@ -29442,15 +27197,11 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/types:bad_optional_access
-cc_library_static {
+cc_object {
     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",
     ],
@@ -29486,11 +27237,6 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
-    ldflags: [
-        "-Wl,--as-needed",
-        "-Wl,--gc-sections",
-        "-Wl,--icf=all",
-    ],
     target: {
         android_arm: {
             cflags: [
@@ -29519,15 +27265,11 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/types:bad_optional_access__testing
-cc_library_static {
+cc_object {
     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",
@@ -29559,11 +27301,6 @@
         "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: [
@@ -29623,15 +27360,11 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/types:bad_variant_access
-cc_library_static {
+cc_object {
     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",
     ],
@@ -29667,11 +27400,6 @@
         "third_party/abseil-cpp/",
     ],
     cpp_std: "c++17",
-    ldflags: [
-        "-Wl,--as-needed",
-        "-Wl,--gc-sections",
-        "-Wl,--icf=all",
-    ],
     target: {
         android_arm: {
             cflags: [
@@ -29700,15 +27428,11 @@
 }
 
 // GN: //third_party/abseil-cpp/absl/types:bad_variant_access__testing
-cc_library_static {
+cc_object {
     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",
@@ -29740,11 +27464,6 @@
         "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: [
@@ -29804,7 +27523,7 @@
 }
 
 // GN: //third_party/android_ndk:cpu_features
-cc_library_static {
+cc_object {
     name: "cronet_aml_third_party_android_ndk_cpu_features",
     srcs: [
         "third_party/android_ndk/sources/android/cpufeatures/cpu-features.c",
@@ -29843,11 +27562,6 @@
         "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: [
@@ -29876,7 +27590,7 @@
 }
 
 // GN: //third_party/android_ndk:cpu_features__testing
-cc_library_static {
+cc_object {
     name: "cronet_aml_third_party_android_ndk_cpu_features__testing",
     srcs: [
         "third_party/android_ndk/sources/android/cpufeatures/cpu-features.c",
@@ -29915,11 +27629,6 @@
         "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: [
@@ -29948,7 +27657,7 @@
 }
 
 // GN: //third_party/ashmem:ashmem
-cc_library_static {
+cc_object {
     name: "cronet_aml_third_party_ashmem_ashmem",
     srcs: [
         "third_party/ashmem/ashmem-dev.c",
@@ -29989,11 +27698,6 @@
         "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: [
@@ -30022,7 +27726,7 @@
 }
 
 // GN: //third_party/ashmem:ashmem__testing
-cc_library_static {
+cc_object {
     name: "cronet_aml_third_party_ashmem_ashmem__testing",
     srcs: [
         "third_party/ashmem/ashmem-dev.c",
@@ -30063,355 +27767,6 @@
         "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: //third_party/boringssl:boringssl
-cc_library_static {
-    name: "cronet_aml_third_party_boringssl_boringssl",
-    srcs: [
-        "third_party/boringssl/err_data.c",
-        "third_party/boringssl/src/crypto/asn1/a_bitstr.c",
-        "third_party/boringssl/src/crypto/asn1/a_bool.c",
-        "third_party/boringssl/src/crypto/asn1/a_d2i_fp.c",
-        "third_party/boringssl/src/crypto/asn1/a_dup.c",
-        "third_party/boringssl/src/crypto/asn1/a_gentm.c",
-        "third_party/boringssl/src/crypto/asn1/a_i2d_fp.c",
-        "third_party/boringssl/src/crypto/asn1/a_int.c",
-        "third_party/boringssl/src/crypto/asn1/a_mbstr.c",
-        "third_party/boringssl/src/crypto/asn1/a_object.c",
-        "third_party/boringssl/src/crypto/asn1/a_octet.c",
-        "third_party/boringssl/src/crypto/asn1/a_print.c",
-        "third_party/boringssl/src/crypto/asn1/a_strex.c",
-        "third_party/boringssl/src/crypto/asn1/a_strnid.c",
-        "third_party/boringssl/src/crypto/asn1/a_time.c",
-        "third_party/boringssl/src/crypto/asn1/a_type.c",
-        "third_party/boringssl/src/crypto/asn1/a_utctm.c",
-        "third_party/boringssl/src/crypto/asn1/a_utf8.c",
-        "third_party/boringssl/src/crypto/asn1/asn1_lib.c",
-        "third_party/boringssl/src/crypto/asn1/asn1_par.c",
-        "third_party/boringssl/src/crypto/asn1/asn_pack.c",
-        "third_party/boringssl/src/crypto/asn1/f_int.c",
-        "third_party/boringssl/src/crypto/asn1/f_string.c",
-        "third_party/boringssl/src/crypto/asn1/posix_time.c",
-        "third_party/boringssl/src/crypto/asn1/tasn_dec.c",
-        "third_party/boringssl/src/crypto/asn1/tasn_enc.c",
-        "third_party/boringssl/src/crypto/asn1/tasn_fre.c",
-        "third_party/boringssl/src/crypto/asn1/tasn_new.c",
-        "third_party/boringssl/src/crypto/asn1/tasn_typ.c",
-        "third_party/boringssl/src/crypto/asn1/tasn_utl.c",
-        "third_party/boringssl/src/crypto/base64/base64.c",
-        "third_party/boringssl/src/crypto/bio/bio.c",
-        "third_party/boringssl/src/crypto/bio/bio_mem.c",
-        "third_party/boringssl/src/crypto/bio/connect.c",
-        "third_party/boringssl/src/crypto/bio/fd.c",
-        "third_party/boringssl/src/crypto/bio/file.c",
-        "third_party/boringssl/src/crypto/bio/hexdump.c",
-        "third_party/boringssl/src/crypto/bio/pair.c",
-        "third_party/boringssl/src/crypto/bio/printf.c",
-        "third_party/boringssl/src/crypto/bio/socket.c",
-        "third_party/boringssl/src/crypto/bio/socket_helper.c",
-        "third_party/boringssl/src/crypto/blake2/blake2.c",
-        "third_party/boringssl/src/crypto/bn_extra/bn_asn1.c",
-        "third_party/boringssl/src/crypto/bn_extra/convert.c",
-        "third_party/boringssl/src/crypto/buf/buf.c",
-        "third_party/boringssl/src/crypto/bytestring/asn1_compat.c",
-        "third_party/boringssl/src/crypto/bytestring/ber.c",
-        "third_party/boringssl/src/crypto/bytestring/cbb.c",
-        "third_party/boringssl/src/crypto/bytestring/cbs.c",
-        "third_party/boringssl/src/crypto/bytestring/unicode.c",
-        "third_party/boringssl/src/crypto/chacha/chacha.c",
-        "third_party/boringssl/src/crypto/cipher_extra/cipher_extra.c",
-        "third_party/boringssl/src/crypto/cipher_extra/derive_key.c",
-        "third_party/boringssl/src/crypto/cipher_extra/e_aesctrhmac.c",
-        "third_party/boringssl/src/crypto/cipher_extra/e_aesgcmsiv.c",
-        "third_party/boringssl/src/crypto/cipher_extra/e_chacha20poly1305.c",
-        "third_party/boringssl/src/crypto/cipher_extra/e_des.c",
-        "third_party/boringssl/src/crypto/cipher_extra/e_null.c",
-        "third_party/boringssl/src/crypto/cipher_extra/e_rc2.c",
-        "third_party/boringssl/src/crypto/cipher_extra/e_rc4.c",
-        "third_party/boringssl/src/crypto/cipher_extra/e_tls.c",
-        "third_party/boringssl/src/crypto/cipher_extra/tls_cbc.c",
-        "third_party/boringssl/src/crypto/conf/conf.c",
-        "third_party/boringssl/src/crypto/cpu_aarch64_apple.c",
-        "third_party/boringssl/src/crypto/cpu_aarch64_fuchsia.c",
-        "third_party/boringssl/src/crypto/cpu_aarch64_linux.c",
-        "third_party/boringssl/src/crypto/cpu_aarch64_win.c",
-        "third_party/boringssl/src/crypto/cpu_arm.c",
-        "third_party/boringssl/src/crypto/cpu_arm_linux.c",
-        "third_party/boringssl/src/crypto/cpu_intel.c",
-        "third_party/boringssl/src/crypto/cpu_ppc64le.c",
-        "third_party/boringssl/src/crypto/crypto.c",
-        "third_party/boringssl/src/crypto/curve25519/curve25519.c",
-        "third_party/boringssl/src/crypto/curve25519/spake25519.c",
-        "third_party/boringssl/src/crypto/des/des.c",
-        "third_party/boringssl/src/crypto/dh_extra/dh_asn1.c",
-        "third_party/boringssl/src/crypto/dh_extra/params.c",
-        "third_party/boringssl/src/crypto/digest_extra/digest_extra.c",
-        "third_party/boringssl/src/crypto/dsa/dsa.c",
-        "third_party/boringssl/src/crypto/dsa/dsa_asn1.c",
-        "third_party/boringssl/src/crypto/ec_extra/ec_asn1.c",
-        "third_party/boringssl/src/crypto/ec_extra/ec_derive.c",
-        "third_party/boringssl/src/crypto/ec_extra/hash_to_curve.c",
-        "third_party/boringssl/src/crypto/ecdh_extra/ecdh_extra.c",
-        "third_party/boringssl/src/crypto/ecdsa_extra/ecdsa_asn1.c",
-        "third_party/boringssl/src/crypto/engine/engine.c",
-        "third_party/boringssl/src/crypto/err/err.c",
-        "third_party/boringssl/src/crypto/evp/evp.c",
-        "third_party/boringssl/src/crypto/evp/evp_asn1.c",
-        "third_party/boringssl/src/crypto/evp/evp_ctx.c",
-        "third_party/boringssl/src/crypto/evp/p_dsa_asn1.c",
-        "third_party/boringssl/src/crypto/evp/p_ec.c",
-        "third_party/boringssl/src/crypto/evp/p_ec_asn1.c",
-        "third_party/boringssl/src/crypto/evp/p_ed25519.c",
-        "third_party/boringssl/src/crypto/evp/p_ed25519_asn1.c",
-        "third_party/boringssl/src/crypto/evp/p_hkdf.c",
-        "third_party/boringssl/src/crypto/evp/p_rsa.c",
-        "third_party/boringssl/src/crypto/evp/p_rsa_asn1.c",
-        "third_party/boringssl/src/crypto/evp/p_x25519.c",
-        "third_party/boringssl/src/crypto/evp/p_x25519_asn1.c",
-        "third_party/boringssl/src/crypto/evp/pbkdf.c",
-        "third_party/boringssl/src/crypto/evp/print.c",
-        "third_party/boringssl/src/crypto/evp/scrypt.c",
-        "third_party/boringssl/src/crypto/evp/sign.c",
-        "third_party/boringssl/src/crypto/ex_data.c",
-        "third_party/boringssl/src/crypto/fipsmodule/bcm.c",
-        "third_party/boringssl/src/crypto/fipsmodule/fips_shared_support.c",
-        "third_party/boringssl/src/crypto/hkdf/hkdf.c",
-        "third_party/boringssl/src/crypto/hpke/hpke.c",
-        "third_party/boringssl/src/crypto/hrss/hrss.c",
-        "third_party/boringssl/src/crypto/lhash/lhash.c",
-        "third_party/boringssl/src/crypto/mem.c",
-        "third_party/boringssl/src/crypto/obj/obj.c",
-        "third_party/boringssl/src/crypto/obj/obj_xref.c",
-        "third_party/boringssl/src/crypto/pem/pem_all.c",
-        "third_party/boringssl/src/crypto/pem/pem_info.c",
-        "third_party/boringssl/src/crypto/pem/pem_lib.c",
-        "third_party/boringssl/src/crypto/pem/pem_oth.c",
-        "third_party/boringssl/src/crypto/pem/pem_pk8.c",
-        "third_party/boringssl/src/crypto/pem/pem_pkey.c",
-        "third_party/boringssl/src/crypto/pem/pem_x509.c",
-        "third_party/boringssl/src/crypto/pem/pem_xaux.c",
-        "third_party/boringssl/src/crypto/pkcs7/pkcs7.c",
-        "third_party/boringssl/src/crypto/pkcs7/pkcs7_x509.c",
-        "third_party/boringssl/src/crypto/pkcs8/p5_pbev2.c",
-        "third_party/boringssl/src/crypto/pkcs8/pkcs8.c",
-        "third_party/boringssl/src/crypto/pkcs8/pkcs8_x509.c",
-        "third_party/boringssl/src/crypto/poly1305/poly1305.c",
-        "third_party/boringssl/src/crypto/poly1305/poly1305_arm.c",
-        "third_party/boringssl/src/crypto/poly1305/poly1305_vec.c",
-        "third_party/boringssl/src/crypto/pool/pool.c",
-        "third_party/boringssl/src/crypto/rand_extra/deterministic.c",
-        "third_party/boringssl/src/crypto/rand_extra/forkunsafe.c",
-        "third_party/boringssl/src/crypto/rand_extra/fuchsia.c",
-        "third_party/boringssl/src/crypto/rand_extra/passive.c",
-        "third_party/boringssl/src/crypto/rand_extra/rand_extra.c",
-        "third_party/boringssl/src/crypto/rand_extra/windows.c",
-        "third_party/boringssl/src/crypto/rc4/rc4.c",
-        "third_party/boringssl/src/crypto/refcount_c11.c",
-        "third_party/boringssl/src/crypto/refcount_lock.c",
-        "third_party/boringssl/src/crypto/rsa_extra/rsa_asn1.c",
-        "third_party/boringssl/src/crypto/rsa_extra/rsa_print.c",
-        "third_party/boringssl/src/crypto/siphash/siphash.c",
-        "third_party/boringssl/src/crypto/stack/stack.c",
-        "third_party/boringssl/src/crypto/thread.c",
-        "third_party/boringssl/src/crypto/thread_none.c",
-        "third_party/boringssl/src/crypto/thread_pthread.c",
-        "third_party/boringssl/src/crypto/thread_win.c",
-        "third_party/boringssl/src/crypto/trust_token/pmbtoken.c",
-        "third_party/boringssl/src/crypto/trust_token/trust_token.c",
-        "third_party/boringssl/src/crypto/trust_token/voprf.c",
-        "third_party/boringssl/src/crypto/x509/a_digest.c",
-        "third_party/boringssl/src/crypto/x509/a_sign.c",
-        "third_party/boringssl/src/crypto/x509/a_verify.c",
-        "third_party/boringssl/src/crypto/x509/algorithm.c",
-        "third_party/boringssl/src/crypto/x509/asn1_gen.c",
-        "third_party/boringssl/src/crypto/x509/by_dir.c",
-        "third_party/boringssl/src/crypto/x509/by_file.c",
-        "third_party/boringssl/src/crypto/x509/i2d_pr.c",
-        "third_party/boringssl/src/crypto/x509/name_print.c",
-        "third_party/boringssl/src/crypto/x509/rsa_pss.c",
-        "third_party/boringssl/src/crypto/x509/t_crl.c",
-        "third_party/boringssl/src/crypto/x509/t_req.c",
-        "third_party/boringssl/src/crypto/x509/t_x509.c",
-        "third_party/boringssl/src/crypto/x509/t_x509a.c",
-        "third_party/boringssl/src/crypto/x509/x509.c",
-        "third_party/boringssl/src/crypto/x509/x509_att.c",
-        "third_party/boringssl/src/crypto/x509/x509_cmp.c",
-        "third_party/boringssl/src/crypto/x509/x509_d2.c",
-        "third_party/boringssl/src/crypto/x509/x509_def.c",
-        "third_party/boringssl/src/crypto/x509/x509_ext.c",
-        "third_party/boringssl/src/crypto/x509/x509_lu.c",
-        "third_party/boringssl/src/crypto/x509/x509_obj.c",
-        "third_party/boringssl/src/crypto/x509/x509_req.c",
-        "third_party/boringssl/src/crypto/x509/x509_set.c",
-        "third_party/boringssl/src/crypto/x509/x509_trs.c",
-        "third_party/boringssl/src/crypto/x509/x509_txt.c",
-        "third_party/boringssl/src/crypto/x509/x509_v3.c",
-        "third_party/boringssl/src/crypto/x509/x509_vfy.c",
-        "third_party/boringssl/src/crypto/x509/x509_vpm.c",
-        "third_party/boringssl/src/crypto/x509/x509cset.c",
-        "third_party/boringssl/src/crypto/x509/x509name.c",
-        "third_party/boringssl/src/crypto/x509/x509rset.c",
-        "third_party/boringssl/src/crypto/x509/x509spki.c",
-        "third_party/boringssl/src/crypto/x509/x_algor.c",
-        "third_party/boringssl/src/crypto/x509/x_all.c",
-        "third_party/boringssl/src/crypto/x509/x_attrib.c",
-        "third_party/boringssl/src/crypto/x509/x_crl.c",
-        "third_party/boringssl/src/crypto/x509/x_exten.c",
-        "third_party/boringssl/src/crypto/x509/x_info.c",
-        "third_party/boringssl/src/crypto/x509/x_name.c",
-        "third_party/boringssl/src/crypto/x509/x_pkey.c",
-        "third_party/boringssl/src/crypto/x509/x_pubkey.c",
-        "third_party/boringssl/src/crypto/x509/x_req.c",
-        "third_party/boringssl/src/crypto/x509/x_sig.c",
-        "third_party/boringssl/src/crypto/x509/x_spki.c",
-        "third_party/boringssl/src/crypto/x509/x_val.c",
-        "third_party/boringssl/src/crypto/x509/x_x509.c",
-        "third_party/boringssl/src/crypto/x509/x_x509a.c",
-        "third_party/boringssl/src/crypto/x509v3/pcy_cache.c",
-        "third_party/boringssl/src/crypto/x509v3/pcy_data.c",
-        "third_party/boringssl/src/crypto/x509v3/pcy_map.c",
-        "third_party/boringssl/src/crypto/x509v3/pcy_node.c",
-        "third_party/boringssl/src/crypto/x509v3/pcy_tree.c",
-        "third_party/boringssl/src/crypto/x509v3/v3_akey.c",
-        "third_party/boringssl/src/crypto/x509v3/v3_akeya.c",
-        "third_party/boringssl/src/crypto/x509v3/v3_alt.c",
-        "third_party/boringssl/src/crypto/x509v3/v3_bcons.c",
-        "third_party/boringssl/src/crypto/x509v3/v3_bitst.c",
-        "third_party/boringssl/src/crypto/x509v3/v3_conf.c",
-        "third_party/boringssl/src/crypto/x509v3/v3_cpols.c",
-        "third_party/boringssl/src/crypto/x509v3/v3_crld.c",
-        "third_party/boringssl/src/crypto/x509v3/v3_enum.c",
-        "third_party/boringssl/src/crypto/x509v3/v3_extku.c",
-        "third_party/boringssl/src/crypto/x509v3/v3_genn.c",
-        "third_party/boringssl/src/crypto/x509v3/v3_ia5.c",
-        "third_party/boringssl/src/crypto/x509v3/v3_info.c",
-        "third_party/boringssl/src/crypto/x509v3/v3_int.c",
-        "third_party/boringssl/src/crypto/x509v3/v3_lib.c",
-        "third_party/boringssl/src/crypto/x509v3/v3_ncons.c",
-        "third_party/boringssl/src/crypto/x509v3/v3_ocsp.c",
-        "third_party/boringssl/src/crypto/x509v3/v3_pci.c",
-        "third_party/boringssl/src/crypto/x509v3/v3_pcia.c",
-        "third_party/boringssl/src/crypto/x509v3/v3_pcons.c",
-        "third_party/boringssl/src/crypto/x509v3/v3_pmaps.c",
-        "third_party/boringssl/src/crypto/x509v3/v3_prn.c",
-        "third_party/boringssl/src/crypto/x509v3/v3_purp.c",
-        "third_party/boringssl/src/crypto/x509v3/v3_skey.c",
-        "third_party/boringssl/src/crypto/x509v3/v3_utl.c",
-        "third_party/boringssl/src/ssl/bio_ssl.cc",
-        "third_party/boringssl/src/ssl/d1_both.cc",
-        "third_party/boringssl/src/ssl/d1_lib.cc",
-        "third_party/boringssl/src/ssl/d1_pkt.cc",
-        "third_party/boringssl/src/ssl/d1_srtp.cc",
-        "third_party/boringssl/src/ssl/dtls_method.cc",
-        "third_party/boringssl/src/ssl/dtls_record.cc",
-        "third_party/boringssl/src/ssl/encrypted_client_hello.cc",
-        "third_party/boringssl/src/ssl/extensions.cc",
-        "third_party/boringssl/src/ssl/handoff.cc",
-        "third_party/boringssl/src/ssl/handshake.cc",
-        "third_party/boringssl/src/ssl/handshake_client.cc",
-        "third_party/boringssl/src/ssl/handshake_server.cc",
-        "third_party/boringssl/src/ssl/s3_both.cc",
-        "third_party/boringssl/src/ssl/s3_lib.cc",
-        "third_party/boringssl/src/ssl/s3_pkt.cc",
-        "third_party/boringssl/src/ssl/ssl_aead_ctx.cc",
-        "third_party/boringssl/src/ssl/ssl_asn1.cc",
-        "third_party/boringssl/src/ssl/ssl_buffer.cc",
-        "third_party/boringssl/src/ssl/ssl_cert.cc",
-        "third_party/boringssl/src/ssl/ssl_cipher.cc",
-        "third_party/boringssl/src/ssl/ssl_file.cc",
-        "third_party/boringssl/src/ssl/ssl_key_share.cc",
-        "third_party/boringssl/src/ssl/ssl_lib.cc",
-        "third_party/boringssl/src/ssl/ssl_privkey.cc",
-        "third_party/boringssl/src/ssl/ssl_session.cc",
-        "third_party/boringssl/src/ssl/ssl_stat.cc",
-        "third_party/boringssl/src/ssl/ssl_transcript.cc",
-        "third_party/boringssl/src/ssl/ssl_versions.cc",
-        "third_party/boringssl/src/ssl/ssl_x509.cc",
-        "third_party/boringssl/src/ssl/t1_enc.cc",
-        "third_party/boringssl/src/ssl/tls13_both.cc",
-        "third_party/boringssl/src/ssl/tls13_client.cc",
-        "third_party/boringssl/src/ssl/tls13_enc.cc",
-        "third_party/boringssl/src/ssl/tls13_server.cc",
-        "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",
-    ],
-    cflags: [
-        "-DANDROID",
-        "-DANDROID_NDK_VERSION_ROLL=r23_1",
-        "-DBORINGSSL_ALLOW_CXX_RUNTIME",
-        "-DBORINGSSL_IMPLEMENTATION",
-        "-DBORINGSSL_NO_STATIC_INITIALIZER",
-        "-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",
-        "-DOPENSSL_SMALL",
-        "-D_GNU_SOURCE",
-        "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
-        "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
-        "-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",
-        "third_party/boringssl/src/include/",
-    ],
-    cpp_std: "c++17",
-    ldflags: [
-        "-Wl,--as-needed",
-        "-Wl,--gc-sections",
-        "-Wl,--icf=all",
-    ],
     target: {
         android_arm: {
             cflags: [
@@ -30443,6 +27798,7 @@
 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",
@@ -30710,9 +28066,6 @@
         "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",
@@ -30810,147 +28163,8 @@
     },
 }
 
-// GN: //third_party/boringssl:boringssl_asm
-cc_library_static {
-    name: "cronet_aml_third_party_boringssl_boringssl_asm",
-    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",
-        "third_party/boringssl/src/include/",
-    ],
-    cpp_std: "c++17",
-    ldflags: [
-        "-Wl,--as-needed",
-        "-Wl,--gc-sections",
-        "-Wl,--icf=all",
-    ],
-    target: {
-        android_arm: {
-            srcs: [
-                "third_party/boringssl/linux-arm/crypto/chacha/chacha-armv4.S",
-                "third_party/boringssl/linux-arm/crypto/fipsmodule/aesv8-armx32.S",
-                "third_party/boringssl/linux-arm/crypto/fipsmodule/armv4-mont.S",
-                "third_party/boringssl/linux-arm/crypto/fipsmodule/bsaes-armv7.S",
-                "third_party/boringssl/linux-arm/crypto/fipsmodule/ghash-armv4.S",
-                "third_party/boringssl/linux-arm/crypto/fipsmodule/ghashv8-armx32.S",
-                "third_party/boringssl/linux-arm/crypto/fipsmodule/sha1-armv4-large.S",
-                "third_party/boringssl/linux-arm/crypto/fipsmodule/sha256-armv4.S",
-                "third_party/boringssl/linux-arm/crypto/fipsmodule/sha512-armv4.S",
-                "third_party/boringssl/linux-arm/crypto/fipsmodule/vpaes-armv7.S",
-                "third_party/boringssl/linux-arm/crypto/test/trampoline-armv4.S",
-                "third_party/boringssl/src/crypto/curve25519/asm/x25519-asm-arm.S",
-                "third_party/boringssl/src/crypto/poly1305/poly1305_arm_asm.S",
-            ],
-            cflags: [
-                "-fstack-protector",
-            ],
-        },
-        android_arm64: {
-            srcs: [
-                "third_party/boringssl/linux-aarch64/crypto/chacha/chacha-armv8.S",
-                "third_party/boringssl/linux-aarch64/crypto/cipher_extra/chacha20_poly1305_armv8.S",
-                "third_party/boringssl/linux-aarch64/crypto/fipsmodule/aesv8-armx64.S",
-                "third_party/boringssl/linux-aarch64/crypto/fipsmodule/armv8-mont.S",
-                "third_party/boringssl/linux-aarch64/crypto/fipsmodule/ghash-neon-armv8.S",
-                "third_party/boringssl/linux-aarch64/crypto/fipsmodule/ghashv8-armx64.S",
-                "third_party/boringssl/linux-aarch64/crypto/fipsmodule/p256-armv8-asm.S",
-                "third_party/boringssl/linux-aarch64/crypto/fipsmodule/p256_beeu-armv8-asm.S",
-                "third_party/boringssl/linux-aarch64/crypto/fipsmodule/sha1-armv8.S",
-                "third_party/boringssl/linux-aarch64/crypto/fipsmodule/sha256-armv8.S",
-                "third_party/boringssl/linux-aarch64/crypto/fipsmodule/sha512-armv8.S",
-                "third_party/boringssl/linux-aarch64/crypto/fipsmodule/vpaes-armv8.S",
-                "third_party/boringssl/linux-aarch64/crypto/test/trampoline-armv8.S",
-            ],
-            cflags: [
-                "-fstack-protector",
-                "-mno-outline",
-                "-mno-outline-atomics",
-            ],
-        },
-        android_x86: {
-            srcs: [
-                "third_party/boringssl/linux-x86/crypto/chacha/chacha-x86.S",
-                "third_party/boringssl/linux-x86/crypto/fipsmodule/aesni-x86.S",
-                "third_party/boringssl/linux-x86/crypto/fipsmodule/bn-586.S",
-                "third_party/boringssl/linux-x86/crypto/fipsmodule/co-586.S",
-                "third_party/boringssl/linux-x86/crypto/fipsmodule/ghash-ssse3-x86.S",
-                "third_party/boringssl/linux-x86/crypto/fipsmodule/ghash-x86.S",
-                "third_party/boringssl/linux-x86/crypto/fipsmodule/md5-586.S",
-                "third_party/boringssl/linux-x86/crypto/fipsmodule/sha1-586.S",
-                "third_party/boringssl/linux-x86/crypto/fipsmodule/sha256-586.S",
-                "third_party/boringssl/linux-x86/crypto/fipsmodule/sha512-586.S",
-                "third_party/boringssl/linux-x86/crypto/fipsmodule/vpaes-x86.S",
-                "third_party/boringssl/linux-x86/crypto/fipsmodule/x86-mont.S",
-                "third_party/boringssl/linux-x86/crypto/test/trampoline-x86.S",
-            ],
-            cflags: [
-                "-msse3",
-            ],
-        },
-        android_x86_64: {
-            srcs: [
-                "third_party/boringssl/linux-x86_64/crypto/chacha/chacha-x86_64.S",
-                "third_party/boringssl/linux-x86_64/crypto/cipher_extra/aes128gcmsiv-x86_64.S",
-                "third_party/boringssl/linux-x86_64/crypto/cipher_extra/chacha20_poly1305_x86_64.S",
-                "third_party/boringssl/linux-x86_64/crypto/fipsmodule/aesni-gcm-x86_64.S",
-                "third_party/boringssl/linux-x86_64/crypto/fipsmodule/aesni-x86_64.S",
-                "third_party/boringssl/linux-x86_64/crypto/fipsmodule/ghash-ssse3-x86_64.S",
-                "third_party/boringssl/linux-x86_64/crypto/fipsmodule/ghash-x86_64.S",
-                "third_party/boringssl/linux-x86_64/crypto/fipsmodule/md5-x86_64.S",
-                "third_party/boringssl/linux-x86_64/crypto/fipsmodule/p256-x86_64-asm.S",
-                "third_party/boringssl/linux-x86_64/crypto/fipsmodule/p256_beeu-x86_64-asm.S",
-                "third_party/boringssl/linux-x86_64/crypto/fipsmodule/rdrand-x86_64.S",
-                "third_party/boringssl/linux-x86_64/crypto/fipsmodule/rsaz-avx2.S",
-                "third_party/boringssl/linux-x86_64/crypto/fipsmodule/sha1-x86_64.S",
-                "third_party/boringssl/linux-x86_64/crypto/fipsmodule/sha256-x86_64.S",
-                "third_party/boringssl/linux-x86_64/crypto/fipsmodule/sha512-x86_64.S",
-                "third_party/boringssl/linux-x86_64/crypto/fipsmodule/vpaes-x86_64.S",
-                "third_party/boringssl/linux-x86_64/crypto/fipsmodule/x86_64-mont.S",
-                "third_party/boringssl/linux-x86_64/crypto/fipsmodule/x86_64-mont5.S",
-                "third_party/boringssl/linux-x86_64/crypto/test/trampoline-x86_64.S",
-                "third_party/boringssl/src/crypto/hrss/asm/poly_rq_mul.S",
-            ],
-            cflags: [
-                "-fstack-protector",
-                "-msse3",
-            ],
-        },
-    },
-}
-
 // GN: //third_party/boringssl:boringssl_asm__testing
-cc_library_static {
+cc_object {
     name: "cronet_aml_third_party_boringssl_boringssl_asm__testing",
     host_supported: true,
     defaults: [
@@ -30985,11 +28199,6 @@
         "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: [
@@ -31531,7 +28740,7 @@
 }
 
 // GN: //third_party/googletest:gmock__testing
-cc_library_static {
+cc_object {
     name: "cronet_aml_third_party_googletest_gmock__testing",
     srcs: [
         "third_party/googletest/src/googlemock/src/gmock-cardinalities.cc",
@@ -31548,66 +28757,17 @@
         "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",
     ],
@@ -31653,27 +28813,6 @@
         "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: [
@@ -31702,7 +28841,7 @@
 }
 
 // GN: //third_party/googletest:gtest__testing
-cc_library_static {
+cc_object {
     name: "cronet_aml_third_party_googletest_gtest__testing",
     srcs: [
         "third_party/googletest/custom/gtest/internal/custom/chrome_custom_temp_dir.cc",
@@ -31725,65 +28864,17 @@
         "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",
     ],
@@ -31827,27 +28918,6 @@
         "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: [
@@ -34500,14 +31570,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",
     ],
@@ -34713,6 +31783,47 @@
     ],
 }
 
+// GN: //third_party/quic_trace:quic_trace_proto__testing
+cc_genrule {
+    name: "cronet_aml_third_party_quic_trace_quic_trace_proto__testing_gen",
+    srcs: [
+        "third_party/quic_trace/src/quic_trace/quic_trace.proto",
+    ],
+    tools: [
+        "cronet_aml_third_party_protobuf_protoc",
+    ],
+    cmd: "$(location cronet_aml_third_party_protobuf_protoc) --proto_path=external/cronet/third_party/quic_trace/src/quic_trace --cpp_out=lite=true:$(genDir)/external/cronet/third_party/quic_trace/src/quic_trace/ $(in)",
+    out: [
+        "external/cronet/third_party/quic_trace/src/quic_trace/quic_trace.pb.cc",
+    ],
+    apex_available: [
+        "com.android.tethering",
+    ],
+}
+
+// GN: //third_party/quic_trace:quic_trace_proto__testing
+cc_genrule {
+    name: "cronet_aml_third_party_quic_trace_quic_trace_proto__testing_gen_headers",
+    srcs: [
+        "third_party/quic_trace/src/quic_trace/quic_trace.proto",
+    ],
+    tools: [
+        "cronet_aml_third_party_protobuf_protoc",
+    ],
+    cmd: "$(location cronet_aml_third_party_protobuf_protoc) --proto_path=external/cronet/third_party/quic_trace/src/quic_trace --cpp_out=lite=true:$(genDir)/external/cronet/third_party/quic_trace/src/quic_trace/ $(in)",
+    out: [
+        "external/cronet/third_party/quic_trace/src/quic_trace/quic_trace.pb.h",
+    ],
+    export_include_dirs: [
+        ".",
+        "protos",
+        "third_party/quic_trace/src/quic_trace",
+    ],
+    apex_available: [
+        "com.android.tethering",
+    ],
+}
+
 // GN: //url:buildflags
 cc_genrule {
     name: "cronet_aml_url_buildflags",
@@ -34787,6 +31898,8 @@
         "url/url_util.cc",
     ],
     shared_libs: [
+        "//external/cronet/third_party/boringssl:libcrypto",
+        "//external/cronet/third_party/boringssl:libssl",
         "libandroid",
         "liblog",
     ],
@@ -34794,60 +31907,8 @@
         "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",
@@ -34989,60 +32050,9 @@
         "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",
@@ -35227,51 +32237,3 @@
     ],
 }
 
-// GN: LICENSE
-license {
-    name: "external_cronet_license",
-    license_kinds: [
-        "SPDX-license-identifier-AFL-2.0",
-        "SPDX-license-identifier-Apache-2.0",
-        "SPDX-license-identifier-BSD",
-        "SPDX-license-identifier-BSL-1.0",
-        "SPDX-license-identifier-ICU",
-        "SPDX-license-identifier-ISC",
-        "SPDX-license-identifier-MIT",
-        "SPDX-license-identifier-MPL",
-        "SPDX-license-identifier-MPL-1.1",
-        "SPDX-license-identifier-MPL-2.0",
-        "SPDX-license-identifier-NCSA",
-        "SPDX-license-identifier-OpenSSL",
-        "SPDX-license-identifier-Unicode-DFS",
-        "legacy_unencumbered",
-    ],
-    license_text: [
-        "LICENSE",
-        "base/third_party/double_conversion/LICENSE",
-        "base/third_party/dynamic_annotations/LICENSE",
-        "base/third_party/icu/LICENSE",
-        "base/third_party/nspr/LICENSE",
-        "base/third_party/superfasthash/LICENSE",
-        "base/third_party/symbolize/LICENSE",
-        "base/third_party/valgrind/LICENSE",
-        "base/third_party/xdg_user_dirs/LICENSE",
-        "net/third_party/quiche/src/LICENSE",
-        "net/third_party/uri_template/LICENSE",
-        "third_party/abseil-cpp/LICENSE",
-        "third_party/ashmem/LICENSE",
-        "third_party/boringssl/src/LICENSE",
-        "third_party/boringssl/src/third_party/fiat/LICENSE",
-        "third_party/boringssl/src/third_party/googletest/LICENSE",
-        "third_party/boringssl/src/third_party/wycheproof_testvectors/LICENSE",
-        "third_party/brotli/LICENSE",
-        "third_party/icu/LICENSE",
-        "third_party/icu/scripts/LICENSE",
-        "third_party/libevent/LICENSE",
-        "third_party/metrics_proto/LICENSE",
-        "third_party/modp_b64/LICENSE",
-        "third_party/protobuf/LICENSE",
-        "third_party/protobuf/third_party/utf8_range/LICENSE",
-    ],
-}
-
diff --git a/tools/gn2bp/desc_arm.json b/tools/gn2bp/desc_arm.json
index 87b86e3..8087bc9 100644
--- a/tools/gn2bp/desc_arm.json
+++ b/tools/gn2bp/desc_arm.json
Binary files differ
diff --git a/tools/gn2bp/desc_arm64.json b/tools/gn2bp/desc_arm64.json
index 7b8bfe3..99e2332 100644
--- a/tools/gn2bp/desc_arm64.json
+++ b/tools/gn2bp/desc_arm64.json
Binary files differ
diff --git a/tools/gn2bp/desc_x64.json b/tools/gn2bp/desc_x64.json
index df8635a..bba6b56 100644
--- a/tools/gn2bp/desc_x64.json
+++ b/tools/gn2bp/desc_x64.json
Binary files differ
diff --git a/tools/gn2bp/desc_x86.json b/tools/gn2bp/desc_x86.json
index 707b9c7..a5d4891 100644
--- a/tools/gn2bp/desc_x86.json
+++ b/tools/gn2bp/desc_x86.json
Binary files differ
diff --git a/tools/gn2bp/gen_android_bp b/tools/gn2bp/gen_android_bp
index d714a90..df12d42 100755
--- a/tools/gn2bp/gen_android_bp
+++ b/tools/gn2bp/gen_android_bp
@@ -39,6 +39,8 @@
 
 ROOT_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 
+CRONET_LICENSE_NAME = "external_cronet_license"
+
 # Default targets to translate to the blueprint file.
 DEFAULT_TARGETS = [
     '//components/cronet/android:cronet',
@@ -47,6 +49,7 @@
 
 DEFAULT_TESTS = [
   '//components/cronet/android:cronet_unittests_android__library',
+  '//net:net_unittests__library',
 ]
 
 EXTRAS_ANDROID_BP_FILE = "Android.extras.bp"
@@ -188,6 +191,9 @@
     ],
 }
 
+def always_disable(module, arch):
+  return None
+
 def enable_brotli(module, arch):
   # Requires crrev/c/4111690
   if arch is None:
@@ -213,25 +219,40 @@
   else:
     module.arch[arch].shared_libs.add('libz')
 
+def enable_boringssl(module, arch):
+  if arch is None:
+    shared_libs = module.shared_libs
+  else:
+    shared_libs = module.arch[arch].shared_libs
+  shared_libs.add('//external/cronet/third_party/boringssl:libcrypto')
+  shared_libs.add('//external/cronet/third_party/boringssl:libssl')
+
 # Android equivalents for third-party libraries that the upstream project
 # depends on.
 builtin_deps = {
     '//buildtools/third_party/libunwind:libunwind':
-        lambda m, a: None, # disable libunwind
+        always_disable,
     '//buildtools/third_party/libunwind:libunwind__testing':
-        lambda m, a: None, # disable libunwind
+        always_disable,
     '//net/data/ssl/chrome_root_store:gen_root_store_inc':
-        lambda m, a: None,
+        always_disable,
     '//net/data/ssl/chrome_root_store:gen_root_store_inc__testing':
-        lambda m, a: None,
+        always_disable,
     '//net/tools/root_store_tool:root_store_tool':
-        lambda m, a: None,
+        always_disable,
     '//net/tools/root_store_tool:root_store_tool__testing':
-        lambda m, a: None,
+        always_disable,
     '//third_party/zlib:zlib':
         enable_zlib,
     '//third_party/zlib:zlib__testing':
         enable_zlib,
+    '//third_party/boringssl:boringssl':
+        enable_boringssl,
+    '//third_party/boringssl:boringssl_asm':
+        # Due to FIPS requirements, downstream BoringSSL has a different "shape" than upstream's.
+        # We're guaranteed that if X depends on :boringssl it will also depend on :boringssl_asm.
+        # Hence, always drop :boringssl_asm and handle the translation entirely in :boringssl.
+        always_disable,
 }
 
 experimental_android_deps = {
@@ -549,13 +570,7 @@
     return self.type == "cc_genrule"
 
   def has_input_files(self):
-    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
+    return len(self.srcs) > 0 or any([len(target.srcs) > 0 for target in self.target.values()])
 
   def merge_attribute(self, key, source_module, allowed_archs, source_key = None):
     """
@@ -597,8 +612,8 @@
 
   def to_string(self, output):
     for m in sorted(self.modules.values(), key=lambda m: m.name):
-      if m.type != "cc_library_static" or m.has_input_files():
-        # Don't print cc_library_static with empty srcs. These attributes are already
+      if m.type != "cc_object" or m.has_input_files():
+        # Don't print cc_object 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.
@@ -1026,10 +1041,19 @@
       return "$(location %s)" % arg.replace("gen/", "")
     return arg
 
+  def _replace_binary(self, arg):
+    if arg in self.binary_to_target:
+      return '$(location %s)' % self.binary
+    return arg
+
+  def _remove_python_args(self):
+    self.target.args = [arg for arg in self.target.args if "python3" not in arg]
+
   def _sanitize_args(self):
     self._update_all_args(self._sanitize_filepath_with_location_tag)
     self._update_all_args(self._replace_gen_with_location_tag)
-    self._set_arg_at(0, '$(location %s)' % self.binary)
+    self._update_all_args(self._replace_binary)
+    self._remove_python_args()
     super()._sanitize_args()
 
   def get_tools(self):
@@ -1223,7 +1247,8 @@
     # don't add script arg for the first source -- create_action_module
     # already does this.
     if i != 0:
-      new_args.append('&& python3 $(location %s)' %
+      new_args.append('&&')
+      new_args.append('python3 $(location %s)' %
                    gn_utils.label_to_path(target.script))
     for arg in target.args:
       if '{{source}}' in arg:
@@ -1237,6 +1262,10 @@
         for out in target.outputs:
           if out.endswith(file_name):
             new_args.append('$(location %s)' % out)
+
+        for file in target.sources:
+          if file.endswith(file_name):
+            new_args.append('$(location %s)' % gn_utils.label_to_path(file))
       else:
         new_args.append(arg)
 
@@ -1351,9 +1380,10 @@
 
 def set_module_flags(module, module_type, cflags, defines, ldflags, libs):
   module.cflags.update(_get_cflags(cflags, defines))
-  module.ldflags.update({flag for flag in ldflags
-                         if flag in ldflag_allowlist or flag.startswith("-Wl,-wrap,")})
-  _set_linker_script(module, libs)
+  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)
   # TODO: implement proper cflag parsing.
   for flag in cflags:
     if '-std=' in flag:
@@ -1402,10 +1432,12 @@
       # 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 in ['static_library', 'source_set']:
+  elif target.type == 'static_library':
     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.
@@ -1528,21 +1560,27 @@
     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:
@@ -1560,13 +1598,20 @@
       # 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':
-        if dep_module.has_input_files():
-          module.target[arch_name].static_libs.add(dep_module.name)
+        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))
@@ -1764,54 +1809,10 @@
 
   return blueprint
 
-def create_license_module(blueprint):
-  module = Module("license", "external_cronet_license", "LICENSE")
-  module.license_kinds.update({
-      'SPDX-license-identifier-MPL',
-      'SPDX-license-identifier-MPL-1.1',
-      'SPDX-license-identifier-ISC',
-      'SPDX-license-identifier-AFL-2.0',
-      'SPDX-license-identifier-MPL-2.0',
-      'SPDX-license-identifier-BSD',
-      'SPDX-license-identifier-Apache-2.0',
-      'SPDX-license-identifier-BSL-1.0',
-      'SPDX-license-identifier-Unicode-DFS',
-      'SPDX-license-identifier-NCSA',
-      'SPDX-license-identifier-OpenSSL',
-      'SPDX-license-identifier-MIT',
-      "SPDX-license-identifier-ICU",
-      'legacy_unencumbered',
-  })
-  module.license_text.update({
-      "LICENSE",
-      "net/third_party/uri_template/LICENSE",
-      "net/third_party/quiche/src/LICENSE",
-      "base/third_party/symbolize/LICENSE",
-      "base/third_party/superfasthash/LICENSE",
-      "base/third_party/xdg_user_dirs/LICENSE",
-      "base/third_party/double_conversion/LICENSE",
-      "base/third_party/nspr/LICENSE",
-      "base/third_party/dynamic_annotations/LICENSE",
-      "base/third_party/icu/LICENSE",
-      "base/third_party/valgrind/LICENSE",
-      "third_party/brotli/LICENSE",
-      "third_party/protobuf/LICENSE",
-      "third_party/protobuf/third_party/utf8_range/LICENSE",
-      "third_party/metrics_proto/LICENSE",
-      "third_party/boringssl/src/LICENSE",
-      "third_party/boringssl/src/third_party/googletest/LICENSE",
-      "third_party/boringssl/src/third_party/wycheproof_testvectors/LICENSE",
-      "third_party/boringssl/src/third_party/fiat/LICENSE",
-      "third_party/libevent/LICENSE",
-      "third_party/ashmem/LICENSE",
-      "third_party/icu/LICENSE",
-      "third_party/icu/scripts/LICENSE",
-      "third_party/abseil-cpp/LICENSE",
-      "third_party/modp_b64/LICENSE",
-  })
+def create_default_license_module(blueprint):
   default_license = Module("package", "", "PACKAGE")
-  default_license.default_applicable_licenses.add(module.name)
-  blueprint.add_module(module)
+  default_license.comment = "The actual license can be found in Android.extras.bp"
+  default_license.default_applicable_licenses.add(CRONET_LICENSE_NAME)
   blueprint.add_module(default_license)
 
 def main():
@@ -1866,7 +1867,7 @@
   # Add any proto groups to the blueprint.
   for l_name, t_names in proto_groups.items():
     create_proto_group_modules(blueprint, gn, l_name, t_names)
-  create_license_module(blueprint)
+  create_default_license_module(blueprint)
   output = [
       """// Copyright (C) 2022 The Android Open Source Project
 //
diff --git a/tools/gn2bp/gn_utils.py b/tools/gn2bp/gn_utils.py
index 4066673..09a7b80 100644
--- a/tools/gn2bp/gn_utils.py
+++ b/tools/gn2bp/gn_utils.py
@@ -429,6 +429,14 @@
         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']:
@@ -442,11 +450,12 @@
         # java_library.
         pass
 
-      if dep.type in ['static_library', 'source_set']:
-        # Bubble up static_libs and source_set. Necessary, since soong does not propagate
+      # 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
         # 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: