Merge "Update ConnectivityManager javadoc"
diff --git a/Cronet/tests/common/Android.bp b/Cronet/tests/common/Android.bp
new file mode 100644
index 0000000..939a81c
--- /dev/null
+++ b/Cronet/tests/common/Android.bp
@@ -0,0 +1,41 @@
+// 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.
+//
+
+// Tests in this folder are included both in unit tests and CTS.
+// They must be fast and stable, and exercise public or test APIs.
+
+package {
+ // See: http://go/android-license-faq
+ default_applicable_licenses: ["Android-Apache-2.0"],
+}
+
+// TODO: Consider merging with ConnectivityCoverageTests which is a collection of all
+// Connectivity tests being used for coverage. This will depend on how far we decide to
+// go with merging NetHttp and Tethering targets.
+android_test {
+ name: "NetHttpCoverageTests",
+ defaults: ["CronetTestJavaDefaults"],
+ enforce_default_target_sdk_version: true,
+ sdk_version: "test_current",
+ min_sdk_version: "30",
+ test_suites: ["general-tests", "mts-tethering"],
+ static_libs: [
+ "modules-utils-native-coverage-listener",
+ "CtsNetHttpTestsLib",
+ "NetHttpTestsLibPreJarJar",
+ ],
+ jarjar_rules: ":framework-tethering-jarjar-rules",
+ compile_multilib: "both", // Include both the 32 and 64 bit versions
+}
diff --git a/Cronet/tests/common/AndroidManifest.xml b/Cronet/tests/common/AndroidManifest.xml
new file mode 100644
index 0000000..b00fc90
--- /dev/null
+++ b/Cronet/tests/common/AndroidManifest.xml
@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ ~ 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.
+ -->
+
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ xmlns:tools="http://schemas.android.com/tools"
+ package="com.android.net.http.tests.coverage">
+
+ <!-- NetHttpCoverageTests combines CtsNetHttpTestCases and NetHttpTests targets,
+ so permissions and others are declared in their respective manifests -->
+ <application tools:replace="android:label"
+ android:label="NetHttp coverage tests">
+ <uses-library android:name="android.test.runner" />
+ </application>
+ <instrumentation android:name="androidx.test.runner.AndroidJUnitRunner"
+ android:targetPackage="com.android.net.http.tests.coverage"
+ android:label="NetHttp coverage tests">
+ </instrumentation>
+</manifest>
diff --git a/Cronet/tests/common/AndroidTest.xml b/Cronet/tests/common/AndroidTest.xml
new file mode 100644
index 0000000..2ac418f
--- /dev/null
+++ b/Cronet/tests/common/AndroidTest.xml
@@ -0,0 +1,36 @@
+<!--
+ ~ 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.
+ -->
+<configuration description="Runs coverage tests for NetHttp">
+ <target_preparer class="com.android.tradefed.targetprep.suite.SuiteApkInstaller">
+ <option name="test-file-name" value="NetHttpCoverageTests.apk" />
+ <option name="install-arg" value="-t" />
+ </target_preparer>
+ <option name="test-tag" value="NetHttpCoverageTests" />
+ <!-- Tethering/Connectivity is a SDK 30+ module -->
+ <!-- TODO Switch back to Sdk30 when b/270049141 is fixed -->
+ <object type="module_controller"
+ class="com.android.tradefed.testtype.suite.module.Sdk31ModuleController" />
+ <option name="config-descriptor:metadata" key="mainline-param"
+ value="CaptivePortalLoginGoogle.apk+NetworkStackGoogle.apk+com.google.android.resolv.apex+com.google.android.tethering.apex" />
+ <test class="com.android.tradefed.testtype.AndroidJUnitTest" >
+ <option name="package" value="com.android.net.http.tests.coverage" />
+ <option name="runner" value="androidx.test.runner.AndroidJUnitRunner" />
+ <option name="hidden-api-checks" value="false"/>
+ <option
+ name="device-listeners"
+ value="com.android.modules.utils.testing.NativeCoverageHackInstrumentationListener" />
+ </test>
+</configuration>
diff --git a/Cronet/tests/cts/Android.bp b/Cronet/tests/cts/Android.bp
index 2c28b8d..d969b54 100644
--- a/Cronet/tests/cts/Android.bp
+++ b/Cronet/tests/cts/Android.bp
@@ -29,6 +29,10 @@
java_defaults {
name: "CronetTestJavaDefaultsEnabled",
enabled: true,
+ // TODO(danstahr): move to unconditional static_libs once the T branch is abandoned
+ static_libs: [
+ "truth",
+ ],
}
java_defaults {
@@ -41,35 +45,43 @@
defaults: [cronet_test_java_defaults],
}
-android_test {
- name: "CtsNetHttpTestCases",
- compile_multilib: "both", // Include both the 32 and 64 bit versions
+android_library {
+ name: "CtsNetHttpTestsLib",
defaults: [
- "CronetTestJavaDefaults",
"cts_defaults",
+ "CronetTestJavaDefaults",
],
sdk_version: "test_current",
+ min_sdk_version: "30",
srcs: [
"src/**/*.java",
"src/**/*.kt",
],
static_libs: [
- "androidx.test.rules",
- "androidx.core_core",
+ "androidx.test.ext.junit",
"ctstestrunner-axt",
"ctstestserver",
"junit",
"hamcrest-library",
+ "kotlin-test",
],
libs: [
- "android.test.runner",
"android.test.base",
- "android.test.mock",
"androidx.annotation_annotation",
"framework-tethering",
"org.apache.http.legacy",
],
+ lint: { test: true }
+}
+android_test {
+ name: "CtsNetHttpTestCases",
+ defaults: [
+ "cts_defaults",
+ "CronetTestJavaDefaults",
+ ],
+ sdk_version: "test_current",
+ static_libs: ["CtsNetHttpTestsLib"],
// Tag this as a cts test artifact
test_suites: [
"cts",
diff --git a/Cronet/tests/cts/AndroidManifest.xml b/Cronet/tests/cts/AndroidManifest.xml
index eaa24aa..26900b2 100644
--- a/Cronet/tests/cts/AndroidManifest.xml
+++ b/Cronet/tests/cts/AndroidManifest.xml
@@ -31,7 +31,5 @@
android:name="androidx.test.runner.AndroidJUnitRunner"
android:targetPackage="android.net.http.cts"
android:label="CTS tests of android.net.http">
- <meta-data android:name="listener"
- android:value="com.android.cts.runner.CtsTestRunListener"/>
</instrumentation>
</manifest>
diff --git a/Cronet/tests/cts/src/android/net/http/cts/BidirectionalStreamTest.kt b/Cronet/tests/cts/src/android/net/http/cts/BidirectionalStreamTest.kt
new file mode 100644
index 0000000..bead1f8
--- /dev/null
+++ b/Cronet/tests/cts/src/android/net/http/cts/BidirectionalStreamTest.kt
@@ -0,0 +1,81 @@
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.net.http.cts
+
+import android.content.Context
+import android.net.http.BidirectionalStream
+import android.net.http.HttpEngine
+import android.net.http.cts.util.TestBidirectionalStreamCallback
+import android.net.http.cts.util.TestBidirectionalStreamCallback.ResponseStep
+import android.net.http.cts.util.assumeOKStatusCode
+import android.net.http.cts.util.skipIfNoInternetConnection
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import org.hamcrest.MatcherAssert
+import org.hamcrest.Matchers
+import org.junit.After
+import org.junit.Before
+import org.junit.runner.RunWith
+
+private const val URL = "https://source.android.com"
+
+/**
+ * This tests uses a non-hermetic server. Instead of asserting, assume the next callback. This way,
+ * if the request were to fail, the test would just be skipped instead of failing.
+ */
+@RunWith(AndroidJUnit4::class)
+class BidirectionalStreamTest {
+ private val context: Context = ApplicationProvider.getApplicationContext()
+ private val callback = TestBidirectionalStreamCallback()
+ private val httpEngine = HttpEngine.Builder(context).build()
+ private var stream: BidirectionalStream? = null
+
+ @Before
+ fun setUp() {
+ skipIfNoInternetConnection(context)
+ }
+
+ @After
+ @Throws(Exception::class)
+ fun tearDown() {
+ // cancel active requests to enable engine shutdown.
+ stream?.let {
+ it.cancel()
+ callback.blockForDone()
+ }
+ httpEngine.shutdown()
+ }
+
+ private fun createBidirectionalStreamBuilder(url: String): BidirectionalStream.Builder {
+ return httpEngine.newBidirectionalStreamBuilder(url, callback.executor, callback)
+ }
+
+ @Test
+ @Throws(Exception::class)
+ fun testBidirectionalStream_GetStream_CompletesSuccessfully() {
+ stream = createBidirectionalStreamBuilder(URL).setHttpMethod("GET").build()
+ stream!!.start()
+ callback.assumeCallback(ResponseStep.ON_SUCCEEDED)
+ val info = callback.mResponseInfo
+ assumeOKStatusCode(info)
+ MatcherAssert.assertThat(
+ "Received byte count must be > 0", info.receivedByteCount, Matchers.greaterThan(0L))
+ assertEquals("h2", info.negotiatedProtocol)
+ }
+}
diff --git a/Cronet/tests/cts/src/android/net/http/cts/CallbackExceptionTest.kt b/Cronet/tests/cts/src/android/net/http/cts/CallbackExceptionTest.kt
new file mode 100644
index 0000000..e17b63f
--- /dev/null
+++ b/Cronet/tests/cts/src/android/net/http/cts/CallbackExceptionTest.kt
@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.net.http.cts
+
+import android.content.Context
+import android.net.http.CallbackException
+import android.net.http.HttpEngine
+import android.net.http.cts.util.HttpCtsTestServer
+import android.net.http.cts.util.TestUrlRequestCallback
+import android.net.http.cts.util.TestUrlRequestCallback.FailureType
+import android.net.http.cts.util.TestUrlRequestCallback.ResponseStep
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertIs
+import kotlin.test.assertSame
+import kotlin.test.assertTrue
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class CallbackExceptionTest {
+
+ @Test
+ fun testCallbackException_returnsInputParameters() {
+ val message = "failed"
+ val cause = Throwable("exception")
+ val callbackException = object : CallbackException(message, cause) {}
+
+ assertEquals(message, callbackException.message)
+ assertSame(cause, callbackException.cause)
+ }
+
+ @Test
+ fun testCallbackException_thrownFromUrlRequest() {
+ val context: Context = ApplicationProvider.getApplicationContext()
+ val server = HttpCtsTestServer(context)
+ val httpEngine = HttpEngine.Builder(context).build()
+ val callback = TestUrlRequestCallback()
+ callback.setFailure(FailureType.THROW_SYNC, ResponseStep.ON_RESPONSE_STARTED)
+ val request = httpEngine
+ .newUrlRequestBuilder(server.successUrl, callback, callback.executor)
+ .build()
+
+ request.start()
+ callback.blockForDone()
+
+ assertTrue(request.isDone)
+ assertIs<CallbackException>(callback.mError)
+ server.shutdown()
+ httpEngine.shutdown()
+ }
+}
diff --git a/Cronet/tests/cts/src/android/net/http/cts/ConnectionMigrationOptionsTest.kt b/Cronet/tests/cts/src/android/net/http/cts/ConnectionMigrationOptionsTest.kt
new file mode 100644
index 0000000..2701ed0
--- /dev/null
+++ b/Cronet/tests/cts/src/android/net/http/cts/ConnectionMigrationOptionsTest.kt
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.net.http.cts
+
+import android.net.http.ConnectionMigrationOptions
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import kotlin.test.Test
+import kotlin.test.assertNotNull
+import kotlin.test.assertTrue
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class ConnectionMigrationOptionsTest {
+
+ @Test
+ fun testConnectionMigrationOptions_enableDefaultNetworkMigration_returnSetValue() {
+ val options =
+ ConnectionMigrationOptions.Builder().setEnableDefaultNetworkMigration(true).build()
+
+ assertNotNull(options.enableDefaultNetworkMigration)
+ assertTrue(options.enableDefaultNetworkMigration!!)
+ }
+
+ @Test
+ fun testConnectionMigrationOptions_enablePathDegradationMigration_returnSetValue() {
+ val options =
+ ConnectionMigrationOptions.Builder().setEnablePathDegradationMigration(true).build()
+
+ assertNotNull(options.enablePathDegradationMigration)
+ assertTrue(options.enablePathDegradationMigration!!)
+ }
+}
diff --git a/Cronet/tests/cts/src/android/net/http/cts/DnsOptionsTest.kt b/Cronet/tests/cts/src/android/net/http/cts/DnsOptionsTest.kt
new file mode 100644
index 0000000..b96e931
--- /dev/null
+++ b/Cronet/tests/cts/src/android/net/http/cts/DnsOptionsTest.kt
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.net.http.cts
+
+import android.net.http.DnsOptions
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import java.time.Duration
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertNotNull
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class DnsOptionsTest {
+
+ @Test
+ fun testDnsOptions_defaultValues() {
+ val options = DnsOptions.Builder().build()
+
+ assertNull(options.persistHostCache)
+ assertNull(options.persistHostCachePeriod)
+ assertNull(options.enableStaleDns)
+ assertNull(options.staleDnsOptions)
+ assertNull(options.useHttpStackDnsResolver)
+ assertNull(options.preestablishConnectionsToStaleDnsResults)
+ }
+
+ @Test
+ fun testDnsOptions_persistHostCache_returnSetValue() {
+ val options = DnsOptions.Builder().setPersistHostCache(true).build()
+
+ assertNotNull(options.persistHostCache)
+ assertTrue(options.persistHostCache!!)
+ }
+
+ @Test
+ fun testDnsOptions_persistHostCachePeriod_returnSetValue() {
+ val period = Duration.ofMillis(12345)
+ val options = DnsOptions.Builder().setPersistHostCachePeriod(period).build()
+
+ assertEquals(period, options.persistHostCachePeriod)
+ }
+
+ @Test
+ fun testDnsOptions_enableStaleDns_returnSetValue() {
+ val options = DnsOptions.Builder().setEnableStaleDns(true).build()
+
+ assertNotNull(options.enableStaleDns)
+ assertTrue(options.enableStaleDns!!)
+ }
+
+ @Test
+ fun testDnsOptions_useHttpStackDnsResolver_returnsSetValue() {
+ val options = DnsOptions.Builder().setUseHttpStackDnsResolver(true).build()
+
+ assertNotNull(options.useHttpStackDnsResolver)
+ assertTrue(options.useHttpStackDnsResolver!!)
+ }
+
+ @Test
+ fun testDnsOptions_preestablishConnectionsToStaleDnsResults_returnsSetValue() {
+ val options = DnsOptions.Builder().setPreestablishConnectionsToStaleDnsResults(true).build()
+
+ assertNotNull(options.preestablishConnectionsToStaleDnsResults)
+ assertTrue(options.preestablishConnectionsToStaleDnsResults!!)
+ }
+
+ @Test
+ fun testStaleDnsOptions_defaultValues() {
+ val options = DnsOptions.StaleDnsOptions.Builder().build()
+
+ assertNull(options.allowCrossNetworkUsage)
+ assertNull(options.freshLookupTimeoutMillis)
+ assertNull(options.maxExpiredDelayMillis)
+ assertNull(options.useStaleOnNameNotResolved)
+ }
+
+ @Test
+ fun testStaleDnsOptions_allowCrossNetworkUsage_returnsSetValue() {
+ val options = DnsOptions.StaleDnsOptions.Builder().setAllowCrossNetworkUsage(true).build()
+
+ assertNotNull(options.allowCrossNetworkUsage)
+ assertTrue(options.allowCrossNetworkUsage!!)
+ }
+
+ @Test
+ fun testStaleDnsOptions_freshLookupTimeout_returnsSetValue() {
+ val duration = Duration.ofMillis(12345)
+ val options = DnsOptions.StaleDnsOptions.Builder().setFreshLookupTimeout(duration).build()
+
+ assertNotNull(options.freshLookupTimeoutMillis)
+ assertEquals(duration.toMillis(), options.freshLookupTimeoutMillis!!)
+ }
+
+ @Test
+ fun testStaleDnsOptions_useStaleOnNameNotResolved_returnsSetValue() {
+ val options =
+ DnsOptions.StaleDnsOptions.Builder().setUseStaleOnNameNotResolved(true).build()
+
+ assertNotNull(options.useStaleOnNameNotResolved)
+ assertTrue(options.useStaleOnNameNotResolved!!)
+ }
+
+ @Test
+ fun testStaleDnsOptions_maxExpiredDelayMillis_returnsSetValue() {
+ val duration = Duration.ofMillis(12345)
+ val options = DnsOptions.StaleDnsOptions.Builder().setMaxExpiredDelay(duration).build()
+
+ assertNotNull(options.maxExpiredDelayMillis)
+ assertEquals(duration.toMillis(), options.maxExpiredDelayMillis!!)
+ }
+}
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 6d27b43..34baedf 100644
--- a/Cronet/tests/cts/src/android/net/http/cts/HttpEngineTest.java
+++ b/Cronet/tests/cts/src/android/net/http/cts/HttpEngineTest.java
@@ -23,6 +23,7 @@
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.containsString;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import android.content.Context;
@@ -32,8 +33,8 @@
import android.net.http.cts.util.TestUrlRequestCallback;
import android.net.http.cts.util.TestUrlRequestCallback.ResponseStep;
-import androidx.test.platform.app.InstrumentationRegistry;
-import androidx.test.runner.AndroidJUnit4;
+import androidx.test.core.app.ApplicationProvider;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
import org.junit.After;
import org.junit.Before;
@@ -47,18 +48,24 @@
private HttpEngine.Builder mEngineBuilder;
private TestUrlRequestCallback mCallback;
+ private UrlRequest mRequest;
private HttpEngine mEngine;
+ private Context mContext;
@Before
public void setUp() throws Exception {
- Context context = InstrumentationRegistry.getInstrumentation().getContext();
- skipIfNoInternetConnection(context);
- mEngineBuilder = new HttpEngine.Builder(context);
+ mContext = ApplicationProvider.getApplicationContext();
+ skipIfNoInternetConnection(mContext);
+ mEngineBuilder = new HttpEngine.Builder(mContext);
mCallback = new TestUrlRequestCallback();
}
@After
public void tearDown() throws Exception {
+ if (mRequest != null) {
+ mRequest.cancel();
+ mCallback.blockForDone();
+ }
if (mEngine != null) {
mEngine.shutdown();
}
@@ -72,29 +79,97 @@
public void testHttpEngine_Default() throws Exception {
mEngine = mEngineBuilder.build();
UrlRequest.Builder builder =
- mEngine.newUrlRequestBuilder(URL, mCallback, mCallback.getExecutor());
- builder.build().start();
+ mEngine.newUrlRequestBuilder(URL, mCallback.getExecutor(), mCallback);
+ mRequest = builder.build();
+ mRequest.start();
- mCallback.expectCallback(ResponseStep.ON_SUCCEEDED);
+ // This tests uses a non-hermetic server. Instead of asserting, assume the next callback.
+ // This way, if the request were to fail, the test would just be skipped instead of failing.
+ mCallback.assumeCallback(ResponseStep.ON_SUCCEEDED);
UrlResponseInfo info = mCallback.mResponseInfo;
assertOKStatusCode(info);
assertEquals("h2", info.getNegotiatedProtocol());
}
@Test
+ public void testHttpEngine_EnableHttpCache() {
+ // We need a server which sets cache-control != no-cache.
+ String url = "https://www.example.com";
+ mEngine =
+ mEngineBuilder
+ .setStoragePath(mContext.getApplicationInfo().dataDir)
+ .setEnableHttpCache(HttpEngine.Builder.HTTP_CACHE_DISK,
+ /* maxSize */ 100 * 1024)
+ .build();
+
+ UrlRequest.Builder builder =
+ mEngine.newUrlRequestBuilder(url, mCallback, mCallback.getExecutor());
+ mRequest = builder.build();
+ mRequest.start();
+ // This tests uses a non-hermetic server. Instead of asserting, assume the next callback.
+ // This way, if the request were to fail, the test would just be skipped instead of failing.
+ mCallback.assumeCallback(ResponseStep.ON_SUCCEEDED);
+ UrlResponseInfo info = mCallback.mResponseInfo;
+ assumeOKStatusCode(info);
+ assertFalse(info.wasCached());
+
+ mCallback = new TestUrlRequestCallback();
+ builder = mEngine.newUrlRequestBuilder(url, mCallback, mCallback.getExecutor());
+ mRequest = builder.build();
+ mRequest.start();
+ mCallback.assumeCallback(ResponseStep.ON_SUCCEEDED);
+ info = mCallback.mResponseInfo;
+ assertOKStatusCode(info);
+ assertTrue(info.wasCached());
+ }
+
+ @Test
public void testHttpEngine_DisableHttp2() throws Exception {
mEngine = mEngineBuilder.setEnableHttp2(false).build();
UrlRequest.Builder builder =
- mEngine.newUrlRequestBuilder(URL, mCallback, mCallback.getExecutor());
- builder.build().start();
+ mEngine.newUrlRequestBuilder(URL, mCallback.getExecutor(), mCallback);
+ mRequest = builder.build();
+ mRequest.start();
- mCallback.expectCallback(ResponseStep.ON_SUCCEEDED);
+ // This tests uses a non-hermetic server. Instead of asserting, assume the next callback.
+ // This way, if the request were to fail, the test would just be skipped instead of failing.
+ mCallback.assumeCallback(ResponseStep.ON_SUCCEEDED);
UrlResponseInfo info = mCallback.mResponseInfo;
assertOKStatusCode(info);
assertEquals("http/1.1", info.getNegotiatedProtocol());
}
@Test
+ public void testHttpEngine_EnablePublicKeyPinningBypassForLocalTrustAnchors() {
+ // For known hosts, requests should succeed whether we're bypassing the local trust anchor
+ // or not.
+ mEngine = mEngineBuilder.setEnablePublicKeyPinningBypassForLocalTrustAnchors(false).build();
+ UrlRequest.Builder builder =
+ mEngine.newUrlRequestBuilder(URL, mCallback, mCallback.getExecutor());
+ mRequest = builder.build();
+ mRequest.start();
+ mCallback.expectCallback(ResponseStep.ON_SUCCEEDED);
+
+ mEngine.shutdown();
+ mEngine = mEngineBuilder.setEnablePublicKeyPinningBypassForLocalTrustAnchors(true).build();
+ mCallback = new TestUrlRequestCallback();
+ builder = mEngine.newUrlRequestBuilder(URL, mCallback, mCallback.getExecutor());
+ mRequest = builder.build();
+ mRequest.start();
+ mCallback.expectCallback(ResponseStep.ON_SUCCEEDED);
+
+ // TODO(b/270918920): We should also test with a certificate not present in the device's
+ // trusted store.
+ // This requires either:
+ // * Mocking the underlying CertificateVerifier.
+ // * Or, having the server return a root certificate not present in the device's trusted
+ // store.
+ // The former doesn't make sense for a CTS test as it would depend on the underlying
+ // implementation. The latter is something we should support once we write a proper test
+ // server.
+ }
+
+ @Test
public void testHttpEngine_EnableQuic() throws Exception {
mEngine = mEngineBuilder.setEnableQuic(true).addQuicHint(HOST, 443, 443).build();
// The hint doesn't guarantee that QUIC will win the race, just that it will race TCP.
@@ -103,10 +178,14 @@
for (int i = 0; i < 5; i++) {
mCallback = new TestUrlRequestCallback();
UrlRequest.Builder builder =
- mEngine.newUrlRequestBuilder(URL, mCallback, mCallback.getExecutor());
- builder.build().start();
+ mEngine.newUrlRequestBuilder(URL, mCallback.getExecutor(), mCallback);
+ mRequest = builder.build();
+ mRequest.start();
- mCallback.expectCallback(ResponseStep.ON_SUCCEEDED);
+ // This tests uses a non-hermetic server. Instead of asserting, assume the next
+ // callback. This way, if the request were to fail, the test would just be skipped
+ // instead of failing.
+ mCallback.assumeCallback(ResponseStep.ON_SUCCEEDED);
UrlResponseInfo info = mCallback.mResponseInfo;
assumeOKStatusCode(info);
quicWasUsed = isQuic(info.getNegotiatedProtocol());
diff --git a/Cronet/tests/cts/src/android/net/http/cts/NetworkExceptionTest.kt b/Cronet/tests/cts/src/android/net/http/cts/NetworkExceptionTest.kt
new file mode 100644
index 0000000..dd07a41
--- /dev/null
+++ b/Cronet/tests/cts/src/android/net/http/cts/NetworkExceptionTest.kt
@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.net.http.cts
+
+import android.net.http.HttpEngine
+import android.net.http.NetworkException
+import android.net.http.cts.util.TestUrlRequestCallback
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import kotlin.test.assertEquals
+import kotlin.test.assertIs
+import kotlin.test.assertSame
+import kotlin.test.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class NetworkExceptionTest {
+
+ @Test
+ fun testNetworkException_returnsInputParameters() {
+ val message = "failed"
+ val cause = Throwable("thrown")
+ val networkException =
+ object : NetworkException(message, cause) {
+ override fun getErrorCode() = 0
+ override fun isImmediatelyRetryable() = false
+ }
+
+ assertEquals(message, networkException.message)
+ assertSame(cause, networkException.cause)
+ }
+
+ @Test
+ fun testNetworkException_thrownFromUrlRequest() {
+ val httpEngine = HttpEngine.Builder(ApplicationProvider.getApplicationContext()).build()
+ val callback = TestUrlRequestCallback()
+ val request =
+ httpEngine.newUrlRequestBuilder("http://localhost", callback, callback.executor).build()
+
+ request.start()
+ callback.blockForDone()
+
+ assertTrue(request.isDone)
+ assertIs<NetworkException>(callback.mError)
+ httpEngine.shutdown()
+ }
+}
diff --git a/Cronet/tests/cts/src/android/net/http/cts/QuicOptionsTest.kt b/Cronet/tests/cts/src/android/net/http/cts/QuicOptionsTest.kt
new file mode 100644
index 0000000..1888962
--- /dev/null
+++ b/Cronet/tests/cts/src/android/net/http/cts/QuicOptionsTest.kt
@@ -0,0 +1,70 @@
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package android.net.http.cts
+
+import android.net.http.QuicOptions
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.google.common.truth.Truth.assertThat
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class QuicOptionsTest {
+ @Test
+ fun testQuicOptions_defaultValues() {
+ val quicOptions = QuicOptions.Builder().build()
+ assertThat(quicOptions.quicHostAllowlist).isEmpty()
+ assertThat(quicOptions.handshakeUserAgent).isNull()
+ // TODO(danstahr): idleConnectionTimeout getter should be public
+ // assertThat(quicOptions.idleConnectionTimeout).isNull()
+ assertThat(quicOptions.inMemoryServerConfigsCacheSize).isNull()
+ }
+
+ @Test
+ fun testQuicOptions_quicHostAllowlist_returnsAddedValues() {
+ val quicOptions = QuicOptions.Builder()
+ .addAllowedQuicHost("foo")
+ .addAllowedQuicHost("bar")
+ .addAllowedQuicHost("foo")
+ .addAllowedQuicHost("baz")
+ .build()
+ assertThat(quicOptions.quicHostAllowlist)
+ .containsExactly("foo", "bar", "baz")
+ .inOrder()
+ }
+
+ // TODO(danstahr): idleConnectionTimeout getter should be public
+ /*
+ @Test
+ fun testQuicOptions_idleConnectionTimeout_returnsSetValue() {
+ val timeout = Duration.ofMinutes(10)
+ val quicOptions = QuicOptions.Builder()
+ .setIdleConnectionTimeout(timeout)
+ .build()
+ assertThat(quicOptions.idleConnectionTimeout)
+ .isEqualTo(timeout)
+ }
+ */
+
+ @Test
+ fun testQuicOptions_inMemoryServerConfigsCacheSize_returnsSetValue() {
+ val quicOptions = QuicOptions.Builder()
+ .setInMemoryServerConfigsCacheSize(42)
+ .build()
+ assertThat(quicOptions.inMemoryServerConfigsCacheSize)
+ .isEqualTo(42)
+ }
+}
diff --git a/Cronet/tests/cts/src/android/net/http/cts/UrlRequestTest.java b/Cronet/tests/cts/src/android/net/http/cts/UrlRequestTest.java
index f96d651..735bdc6 100644
--- a/Cronet/tests/cts/src/android/net/http/cts/UrlRequestTest.java
+++ b/Cronet/tests/cts/src/android/net/http/cts/UrlRequestTest.java
@@ -35,8 +35,8 @@
import android.net.http.cts.util.TestUrlRequestCallback;
import android.net.http.cts.util.TestUrlRequestCallback.ResponseStep;
-import androidx.test.platform.app.InstrumentationRegistry;
-import androidx.test.runner.AndroidJUnit4;
+import androidx.test.core.app.ApplicationProvider;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
import org.junit.After;
import org.junit.Before;
@@ -51,7 +51,7 @@
@Before
public void setUp() throws Exception {
- Context context = InstrumentationRegistry.getInstrumentation().getContext();
+ Context context = ApplicationProvider.getApplicationContext();
skipIfNoInternetConnection(context);
HttpEngine.Builder builder = new HttpEngine.Builder(context);
mHttpEngine = builder.build();
@@ -70,7 +70,7 @@
}
private UrlRequest.Builder createUrlRequestBuilder(String url) {
- return mHttpEngine.newUrlRequestBuilder(url, mCallback, mCallback.getExecutor());
+ return mHttpEngine.newUrlRequestBuilder(url, mCallback.getExecutor(), mCallback);
}
@Test
@@ -113,8 +113,9 @@
String testData = "test";
UrlRequest.Builder builder = createUrlRequestBuilder(mTestServer.getEchoBodyUrl());
- TestUploadDataProvider dataProvider = new TestUploadDataProvider(
- TestUploadDataProvider.SuccessCallbackMode.SYNC, mCallback.getExecutor());
+ TestUploadDataProvider dataProvider =
+ new TestUploadDataProvider(
+ TestUploadDataProvider.SuccessCallbackMode.SYNC, mCallback.getExecutor());
dataProvider.addRead(testData.getBytes());
builder.setUploadDataProvider(dataProvider, mCallback.getExecutor());
builder.addHeader("Content-Type", "text/html");
@@ -125,4 +126,10 @@
assertEquals(testData, mCallback.mResponseAsString);
dataProvider.assertClosed();
}
+
+ @Test
+ public void testUrlRequestFail_FailedCalled() throws Exception {
+ createUrlRequestBuilder("http://0.0.0.0:0/").build().start();
+ mCallback.expectCallback(ResponseStep.ON_FAILED);
+ }
}
diff --git a/Cronet/tests/cts/src/android/net/http/cts/util/TestBidirectionalStreamCallback.java b/Cronet/tests/cts/src/android/net/http/cts/util/TestBidirectionalStreamCallback.java
new file mode 100644
index 0000000..e82b24d
--- /dev/null
+++ b/Cronet/tests/cts/src/android/net/http/cts/util/TestBidirectionalStreamCallback.java
@@ -0,0 +1,484 @@
+/*
+ * 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 static org.hamcrest.Matchers.equalTo;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assume.assumeThat;
+import static org.junit.Assume.assumeTrue;
+
+import android.net.http.BidirectionalStream;
+import android.net.http.HttpException;
+import android.net.http.UrlResponseInfo;
+import android.os.ConditionVariable;
+
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.concurrent.Executor;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ThreadFactory;
+
+/**
+ * Callback that tracks information from different callbacks and has a method to block thread until
+ * the stream completes on another thread. Allows to cancel, block stream or throw an exception from
+ * an arbitrary step.
+ */
+public class TestBidirectionalStreamCallback extends BidirectionalStream.Callback {
+ private static final int TIMEOUT_MS = 12_000;
+ public UrlResponseInfo mResponseInfo;
+ public HttpException mError;
+
+ public ResponseStep mResponseStep = ResponseStep.NOTHING;
+
+ public boolean mOnErrorCalled;
+ public boolean mOnCanceledCalled;
+
+ public int mHttpResponseDataLength;
+ public String mResponseAsString = "";
+
+ public UrlResponseInfo.HeaderBlock mTrailers;
+
+ private static final int READ_BUFFER_SIZE = 32 * 1024;
+
+ // When false, the consumer is responsible for all calls into the stream
+ // that advance it.
+ private boolean mAutoAdvance = true;
+
+ // Conditionally fail on certain steps.
+ private FailureType mFailureType = FailureType.NONE;
+ private ResponseStep mFailureStep = ResponseStep.NOTHING;
+
+ // Signals when the stream is done either successfully or not.
+ private final ConditionVariable mDone = new ConditionVariable();
+
+ // Signaled on each step when mAutoAdvance is false.
+ private final ConditionVariable mReadStepBlock = new ConditionVariable();
+ private final ConditionVariable mWriteStepBlock = new ConditionVariable();
+
+ // Executor Service for Cronet callbacks.
+ private final ExecutorService mExecutorService =
+ Executors.newSingleThreadExecutor(new ExecutorThreadFactory());
+ private Thread mExecutorThread;
+
+ // position() of ByteBuffer prior to read() call.
+ private int mBufferPositionBeforeRead;
+
+ // Data to write.
+ private final ArrayList<WriteBuffer> mWriteBuffers = new ArrayList<WriteBuffer>();
+
+ // Buffers that we yet to receive the corresponding onWriteCompleted callback.
+ private final ArrayList<WriteBuffer> mWriteBuffersToBeAcked = new ArrayList<WriteBuffer>();
+
+ // Whether to use a direct executor.
+ private final boolean mUseDirectExecutor;
+ private final DirectExecutor mDirectExecutor;
+
+ private class ExecutorThreadFactory implements ThreadFactory {
+ @Override
+ public Thread newThread(Runnable r) {
+ mExecutorThread = new Thread(r);
+ return mExecutorThread;
+ }
+ }
+
+ private static class WriteBuffer {
+ final ByteBuffer mBuffer;
+ final boolean mFlush;
+
+ WriteBuffer(ByteBuffer buffer, boolean flush) {
+ mBuffer = buffer;
+ mFlush = flush;
+ }
+ }
+
+ private static class DirectExecutor implements Executor {
+ @Override
+ public void execute(Runnable task) {
+ task.run();
+ }
+ }
+
+ public enum ResponseStep {
+ NOTHING,
+ ON_STREAM_READY,
+ ON_RESPONSE_STARTED,
+ ON_READ_COMPLETED,
+ ON_WRITE_COMPLETED,
+ ON_TRAILERS,
+ ON_CANCELED,
+ ON_FAILED,
+ ON_SUCCEEDED,
+ }
+
+ public enum FailureType {
+ NONE,
+ CANCEL_SYNC,
+ CANCEL_ASYNC,
+ // Same as above, but continues to advance the stream after posting
+ // the cancellation task.
+ CANCEL_ASYNC_WITHOUT_PAUSE,
+ THROW_SYNC
+ }
+
+ private boolean isTerminalCallback(ResponseStep step) {
+ switch (step) {
+ case ON_SUCCEEDED:
+ case ON_CANCELED:
+ case ON_FAILED:
+ return true;
+ default:
+ return false;
+ }
+ }
+
+ public TestBidirectionalStreamCallback() {
+ mUseDirectExecutor = false;
+ mDirectExecutor = null;
+ }
+
+ public TestBidirectionalStreamCallback(boolean useDirectExecutor) {
+ mUseDirectExecutor = useDirectExecutor;
+ mDirectExecutor = new DirectExecutor();
+ }
+
+ public void setAutoAdvance(boolean autoAdvance) {
+ mAutoAdvance = autoAdvance;
+ }
+
+ public void setFailure(FailureType failureType, ResponseStep failureStep) {
+ mFailureStep = failureStep;
+ mFailureType = failureType;
+ }
+
+ public boolean blockForDone() {
+ return mDone.block(TIMEOUT_MS);
+ }
+
+ /**
+ * Waits for a terminal callback to complete execution before failing if the callback is not the
+ * expected one
+ *
+ * @param expectedStep the expected callback step
+ */
+ public void expectCallback(ResponseStep expectedStep) {
+ if (isTerminalCallback(expectedStep)) {
+ assertTrue(String.format(
+ "Request timed out. Expected %s callback. Current callback is %s",
+ expectedStep, mResponseStep),
+ blockForDone());
+ }
+ assertSame(expectedStep, mResponseStep);
+ }
+
+ /**
+ * Waits for a terminal callback to complete execution before skipping the test if the callback
+ * is not the expected one
+ *
+ * @param expectedStep the expected callback step
+ */
+ public void assumeCallback(ResponseStep expectedStep) {
+ if (isTerminalCallback(expectedStep)) {
+ assumeTrue(
+ String.format(
+ "Request timed out. Expected %s callback. Current callback is %s",
+ expectedStep, mResponseStep),
+ blockForDone());
+ }
+ assumeThat(expectedStep, equalTo(mResponseStep));
+ }
+
+ public void waitForNextReadStep() {
+ mReadStepBlock.block();
+ mReadStepBlock.close();
+ }
+
+ public void waitForNextWriteStep() {
+ mWriteStepBlock.block();
+ mWriteStepBlock.close();
+ }
+
+ public Executor getExecutor() {
+ if (mUseDirectExecutor) {
+ return mDirectExecutor;
+ }
+ return mExecutorService;
+ }
+
+ public void shutdownExecutor() {
+ if (mUseDirectExecutor) {
+ throw new UnsupportedOperationException("DirectExecutor doesn't support shutdown");
+ }
+ mExecutorService.shutdown();
+ }
+
+ public void addWriteData(byte[] data) {
+ addWriteData(data, true);
+ }
+
+ public void addWriteData(byte[] data, boolean flush) {
+ ByteBuffer writeBuffer = ByteBuffer.allocateDirect(data.length);
+ writeBuffer.put(data);
+ writeBuffer.flip();
+ mWriteBuffers.add(new WriteBuffer(writeBuffer, flush));
+ mWriteBuffersToBeAcked.add(new WriteBuffer(writeBuffer, flush));
+ }
+
+ @Override
+ public void onStreamReady(BidirectionalStream stream) {
+ checkOnValidThread();
+ assertFalse(stream.isDone());
+ assertEquals(ResponseStep.NOTHING, mResponseStep);
+ assertNull(mError);
+ mResponseStep = ResponseStep.ON_STREAM_READY;
+ if (maybeThrowCancelOrPause(stream, mWriteStepBlock)) {
+ return;
+ }
+ startNextWrite(stream);
+ }
+
+ @Override
+ public void onResponseHeadersReceived(BidirectionalStream stream, UrlResponseInfo info) {
+ checkOnValidThread();
+ assertFalse(stream.isDone());
+ assertTrue(
+ mResponseStep == ResponseStep.NOTHING
+ || mResponseStep == ResponseStep.ON_STREAM_READY
+ || mResponseStep == ResponseStep.ON_WRITE_COMPLETED);
+ assertNull(mError);
+
+ mResponseStep = ResponseStep.ON_RESPONSE_STARTED;
+ mResponseInfo = info;
+ if (maybeThrowCancelOrPause(stream, mReadStepBlock)) {
+ return;
+ }
+ startNextRead(stream);
+ }
+
+ @Override
+ public void onReadCompleted(
+ BidirectionalStream stream,
+ UrlResponseInfo info,
+ ByteBuffer byteBuffer,
+ boolean endOfStream) {
+ checkOnValidThread();
+ assertFalse(stream.isDone());
+ assertTrue(
+ mResponseStep == ResponseStep.ON_RESPONSE_STARTED
+ || mResponseStep == ResponseStep.ON_READ_COMPLETED
+ || mResponseStep == ResponseStep.ON_WRITE_COMPLETED
+ || mResponseStep == ResponseStep.ON_TRAILERS);
+ assertNull(mError);
+
+ mResponseStep = ResponseStep.ON_READ_COMPLETED;
+ mResponseInfo = info;
+
+ final int bytesRead = byteBuffer.position() - mBufferPositionBeforeRead;
+ mHttpResponseDataLength += bytesRead;
+ final byte[] lastDataReceivedAsBytes = new byte[bytesRead];
+ // Rewind byteBuffer.position() to pre-read() position.
+ byteBuffer.position(mBufferPositionBeforeRead);
+ // This restores byteBuffer.position() to its value on entrance to
+ // this function.
+ byteBuffer.get(lastDataReceivedAsBytes);
+
+ mResponseAsString += new String(lastDataReceivedAsBytes);
+
+ if (maybeThrowCancelOrPause(stream, mReadStepBlock)) {
+ return;
+ }
+ // Do not read if EOF has been reached.
+ if (!endOfStream) {
+ startNextRead(stream);
+ }
+ }
+
+ @Override
+ public void onWriteCompleted(
+ BidirectionalStream stream,
+ UrlResponseInfo info,
+ ByteBuffer buffer,
+ boolean endOfStream) {
+ checkOnValidThread();
+ assertFalse(stream.isDone());
+ assertNull(mError);
+ mResponseStep = ResponseStep.ON_WRITE_COMPLETED;
+ mResponseInfo = info;
+ if (!mWriteBuffersToBeAcked.isEmpty()) {
+ assertEquals(buffer, mWriteBuffersToBeAcked.get(0).mBuffer);
+ mWriteBuffersToBeAcked.remove(0);
+ }
+ if (maybeThrowCancelOrPause(stream, mWriteStepBlock)) {
+ return;
+ }
+ startNextWrite(stream);
+ }
+
+ @Override
+ public void onResponseTrailersReceived(
+ BidirectionalStream stream,
+ UrlResponseInfo info,
+ UrlResponseInfo.HeaderBlock trailers) {
+ checkOnValidThread();
+ assertFalse(stream.isDone());
+ assertNull(mError);
+ mResponseStep = ResponseStep.ON_TRAILERS;
+ mResponseInfo = info;
+ mTrailers = trailers;
+ if (maybeThrowCancelOrPause(stream, mReadStepBlock)) {
+ return;
+ }
+ }
+
+ @Override
+ public void onSucceeded(BidirectionalStream stream, UrlResponseInfo info) {
+ checkOnValidThread();
+ assertTrue(stream.isDone());
+ assertTrue(
+ mResponseStep == ResponseStep.ON_RESPONSE_STARTED
+ || mResponseStep == ResponseStep.ON_READ_COMPLETED
+ || mResponseStep == ResponseStep.ON_WRITE_COMPLETED
+ || mResponseStep == ResponseStep.ON_TRAILERS);
+ assertFalse(mOnErrorCalled);
+ assertFalse(mOnCanceledCalled);
+ assertNull(mError);
+ assertEquals(0, mWriteBuffers.size());
+ assertEquals(0, mWriteBuffersToBeAcked.size());
+
+ mResponseStep = ResponseStep.ON_SUCCEEDED;
+ mResponseInfo = info;
+ openDone();
+ maybeThrowCancelOrPause(stream, mReadStepBlock);
+ }
+
+ @Override
+ public void onFailed(BidirectionalStream stream, UrlResponseInfo info, HttpException error) {
+ checkOnValidThread();
+ assertTrue(stream.isDone());
+ // Shouldn't happen after success.
+ assertTrue(mResponseStep != ResponseStep.ON_SUCCEEDED);
+ // Should happen at most once for a single stream.
+ assertFalse(mOnErrorCalled);
+ assertFalse(mOnCanceledCalled);
+ assertNull(mError);
+ mResponseStep = ResponseStep.ON_FAILED;
+ mResponseInfo = info;
+
+ mOnErrorCalled = true;
+ mError = error;
+ openDone();
+ maybeThrowCancelOrPause(stream, mReadStepBlock);
+ }
+
+ @Override
+ public void onCanceled(BidirectionalStream stream, UrlResponseInfo info) {
+ checkOnValidThread();
+ assertTrue(stream.isDone());
+ // Should happen at most once for a single stream.
+ assertFalse(mOnCanceledCalled);
+ assertFalse(mOnErrorCalled);
+ assertNull(mError);
+ mResponseStep = ResponseStep.ON_CANCELED;
+ mResponseInfo = info;
+
+ mOnCanceledCalled = true;
+ openDone();
+ maybeThrowCancelOrPause(stream, mReadStepBlock);
+ }
+
+ public void startNextRead(BidirectionalStream stream) {
+ startNextRead(stream, ByteBuffer.allocateDirect(READ_BUFFER_SIZE));
+ }
+
+ public void startNextRead(BidirectionalStream stream, ByteBuffer buffer) {
+ mBufferPositionBeforeRead = buffer.position();
+ stream.read(buffer);
+ }
+
+ public void startNextWrite(BidirectionalStream stream) {
+ if (!mWriteBuffers.isEmpty()) {
+ Iterator<WriteBuffer> iterator = mWriteBuffers.iterator();
+ while (iterator.hasNext()) {
+ WriteBuffer b = iterator.next();
+ stream.write(b.mBuffer, !iterator.hasNext());
+ iterator.remove();
+ if (b.mFlush) {
+ stream.flush();
+ break;
+ }
+ }
+ }
+ }
+
+ public boolean isDone() {
+ // It's not mentioned by the Android docs, but block(0) seems to block
+ // indefinitely, so have to block for one millisecond to get state
+ // without blocking.
+ return mDone.block(1);
+ }
+
+ /** Returns the number of pending Writes. */
+ public int numPendingWrites() {
+ return mWriteBuffers.size();
+ }
+
+ protected void openDone() {
+ mDone.open();
+ }
+
+ /** Returns {@code false} if the callback should continue to advance the stream. */
+ private boolean maybeThrowCancelOrPause(
+ final BidirectionalStream stream, ConditionVariable stepBlock) {
+ if (mResponseStep != mFailureStep || mFailureType == FailureType.NONE) {
+ if (!mAutoAdvance) {
+ stepBlock.open();
+ return true;
+ }
+ return false;
+ }
+
+ if (mFailureType == FailureType.THROW_SYNC) {
+ throw new IllegalStateException("Callback Exception.");
+ }
+ Runnable task =
+ new Runnable() {
+ @Override
+ public void run() {
+ stream.cancel();
+ }
+ };
+ if (mFailureType == FailureType.CANCEL_ASYNC
+ || mFailureType == FailureType.CANCEL_ASYNC_WITHOUT_PAUSE) {
+ getExecutor().execute(task);
+ } else {
+ task.run();
+ }
+ return mFailureType != FailureType.CANCEL_ASYNC_WITHOUT_PAUSE;
+ }
+
+ /** Checks whether callback methods are invoked on the correct thread. */
+ private void checkOnValidThread() {
+ if (!mUseDirectExecutor) {
+ assertEquals(mExecutorThread, Thread.currentThread());
+ }
+ }
+}
diff --git a/Cronet/tests/cts/src/android/net/http/cts/util/TestStatusListener.kt b/Cronet/tests/cts/src/android/net/http/cts/util/TestStatusListener.kt
index e526c7d..3a4486f 100644
--- a/Cronet/tests/cts/src/android/net/http/cts/util/TestStatusListener.kt
+++ b/Cronet/tests/cts/src/android/net/http/cts/util/TestStatusListener.kt
@@ -24,7 +24,7 @@
private const val TIMEOUT_MS = 12000L
/** Test status listener for requests */
-class TestStatusListener : StatusListener() {
+class TestStatusListener : StatusListener {
private val statusFuture = CompletableFuture<Int>()
override fun onStatus(status: Int) {
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 0b9e90f..efbcff6 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
@@ -16,13 +16,19 @@
package android.net.http.cts.util;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.core.AnyOf.anyOf;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
+import static org.junit.Assume.assumeThat;
+import static org.junit.Assume.assumeTrue;
import android.net.http.CallbackException;
import android.net.http.HttpException;
@@ -232,6 +238,19 @@
}
/**
+ * Waits for a terminal callback to complete execution before skipping the test if the
+ * callback is not the expected one
+ *
+ * @param expectedStep the expected callback step
+ */
+ public void assumeCallback(ResponseStep expectedStep) {
+ if (isTerminalCallback(expectedStep)) {
+ assumeTrue("Did not receive terminal callback before timeout", blockForDone());
+ }
+ assumeThat(expectedStep, equalTo(mResponseStep));
+ }
+
+ /**
* Blocks the calling thread until one of the final states has been called.
* This is called before the callback has finished executed.
*/
@@ -272,8 +291,9 @@
UrlRequest request, UrlResponseInfo info, String newLocationUrl) {
checkExecutorThread();
assertFalse(request.isDone());
- assertTrue(mResponseStep == ResponseStep.NOTHING
- || mResponseStep == ResponseStep.ON_RECEIVED_REDIRECT);
+ assertThat(mResponseStep, anyOf(
+ equalTo(ResponseStep.NOTHING),
+ equalTo(ResponseStep.ON_RECEIVED_REDIRECT)));
assertNull(mError);
mResponseStep = ResponseStep.ON_RECEIVED_REDIRECT;
@@ -290,8 +310,9 @@
public void onResponseStarted(UrlRequest request, UrlResponseInfo info) {
checkExecutorThread();
assertFalse(request.isDone());
- assertTrue(mResponseStep == ResponseStep.NOTHING
- || mResponseStep == ResponseStep.ON_RECEIVED_REDIRECT);
+ assertThat(mResponseStep, anyOf(
+ equalTo(ResponseStep.NOTHING),
+ equalTo(ResponseStep.ON_RECEIVED_REDIRECT)));
assertNull(mError);
mResponseStep = ResponseStep.ON_RESPONSE_STARTED;
@@ -306,8 +327,9 @@
public void onReadCompleted(UrlRequest request, UrlResponseInfo info, ByteBuffer byteBuffer) {
checkExecutorThread();
assertFalse(request.isDone());
- assertTrue(mResponseStep == ResponseStep.ON_RESPONSE_STARTED
- || mResponseStep == ResponseStep.ON_READ_COMPLETED);
+ assertThat(mResponseStep, anyOf(
+ equalTo(ResponseStep.ON_RESPONSE_STARTED),
+ equalTo(ResponseStep.ON_READ_COMPLETED)));
assertNull(mError);
mResponseStep = ResponseStep.ON_READ_COMPLETED;
@@ -333,8 +355,9 @@
public void onSucceeded(UrlRequest request, UrlResponseInfo info) {
checkExecutorThread();
assertTrue(request.isDone());
- assertTrue(mResponseStep == ResponseStep.ON_RESPONSE_STARTED
- || mResponseStep == ResponseStep.ON_READ_COMPLETED);
+ assertThat(mResponseStep, anyOf(
+ equalTo(ResponseStep.ON_RESPONSE_STARTED),
+ equalTo(ResponseStep.ON_READ_COMPLETED)));
assertFalse(mOnErrorCalled);
assertFalse(mOnCanceledCalled);
assertNull(mError);
@@ -357,7 +380,7 @@
checkExecutorThread();
assertTrue(request.isDone());
// Shouldn't happen after success.
- assertTrue(mResponseStep != ResponseStep.ON_SUCCEEDED);
+ assertNotEquals(ResponseStep.ON_SUCCEEDED, mResponseStep);
// Should happen at most once for a single request.
assertFalse(mOnErrorCalled);
assertFalse(mOnCanceledCalled);
diff --git a/Cronet/tests/cts/src/android/net/http/cts/util/TestUtils.kt b/Cronet/tests/cts/src/android/net/http/cts/util/TestUtils.kt
index 23ec2c8..7fc005a 100644
--- a/Cronet/tests/cts/src/android/net/http/cts/util/TestUtils.kt
+++ b/Cronet/tests/cts/src/android/net/http/cts/util/TestUtils.kt
@@ -27,7 +27,8 @@
fun skipIfNoInternetConnection(context: Context) {
val connectivityManager = context.getSystemService(ConnectivityManager::class.java)
assumeNotNull(
- "This test requires a working Internet connection", connectivityManager.getActiveNetwork())
+ "This test requires a working Internet connection", connectivityManager!!.activeNetwork
+ )
}
fun assertOKStatusCode(info: UrlResponseInfo) {
@@ -35,5 +36,5 @@
}
fun assumeOKStatusCode(info: UrlResponseInfo) {
- assumeThat("Status code must be 200 OK", info.getHttpStatusCode(), equalTo(200))
+ assumeThat("Status code must be 200 OK", info.httpStatusCode, equalTo(200))
}
diff --git a/Cronet/tests/mts/Android.bp b/Cronet/tests/mts/Android.bp
new file mode 100644
index 0000000..03d163c
--- /dev/null
+++ b/Cronet/tests/mts/Android.bp
@@ -0,0 +1,51 @@
+// 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 {
+ // See: http://go/android-license-faq
+ default_applicable_licenses: ["Android-Apache-2.0"],
+}
+
+android_library {
+ name: "NetHttpTestsLibPreJarJar",
+ srcs: [":cronet_aml_javatests_sources"],
+ sdk_version: "test_current",
+ min_sdk_version: "30",
+ static_libs: [
+ "androidx.test.ext.junit",
+ "androidx.test.rules",
+ "junit",
+ ],
+ libs: [
+ "android.test.base",
+ "framework-tethering-pre-jarjar",
+ ],
+ lint: { test: true }
+}
+
+android_test {
+ name: "NetHttpTests",
+ defaults: [
+ "CronetTestJavaDefaults",
+ "mts-target-sdk-version-current",
+ ],
+ sdk_version: "test_current",
+ static_libs: ["NetHttpTestsLibPreJarJar"],
+ jarjar_rules: ":framework-tethering-jarjar-rules",
+ test_suites: [
+ "general-tests",
+ "mts-tethering",
+ ],
+}
+
diff --git a/Cronet/tests/mts/AndroidManifest.xml b/Cronet/tests/mts/AndroidManifest.xml
new file mode 100644
index 0000000..62c2060
--- /dev/null
+++ b/Cronet/tests/mts/AndroidManifest.xml
@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ ~ 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.
+ -->
+
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ package="android.net.http.mts">
+
+ <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+ <uses-permission android:name="android.permission.INTERNET"/>
+
+ <application>
+ <uses-library android:name="android.test.runner" />
+ </application>
+ <instrumentation android:name="androidx.test.runner.AndroidJUnitRunner"
+ android:targetPackage="android.net.http.mts"
+ android:label="MTS tests of android.net.http">
+ </instrumentation>
+
+</manifest>
\ No newline at end of file
diff --git a/Cronet/tests/mts/AndroidTest.xml b/Cronet/tests/mts/AndroidTest.xml
new file mode 100644
index 0000000..0d780a1
--- /dev/null
+++ b/Cronet/tests/mts/AndroidTest.xml
@@ -0,0 +1,39 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ ~ 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.
+ -->
+<configuration description="Runs NetHttp Mainline Tests.">
+ <!-- Only run tests if the device under test is SDK version 30 or above. -->
+ <!-- TODO Switch back to Sdk30 when b/270049141 is fixed -->
+ <object type="module_controller"
+ class="com.android.tradefed.testtype.suite.module.Sdk31ModuleController" />
+
+ <target_preparer class="com.android.tradefed.targetprep.suite.SuiteApkInstaller">
+ <option name="test-file-name" value="NetHttpTests.apk" />
+ </target_preparer>
+
+ <option name="test-tag" value="NetHttpTests" />
+ <test class="com.android.tradefed.testtype.AndroidJUnitTest" >
+ <option name="package" value="android.net.http.mts" />
+ <option name="runner" value="androidx.test.runner.AndroidJUnitRunner" />
+ <option name="hidden-api-checks" value="false"/>
+ </test>
+
+ <!-- Only run NetHttpTests in MTS if the Tethering Mainline module is installed. -->
+ <object type="module_controller"
+ class="com.android.tradefed.testtype.suite.module.MainlineTestModuleController">
+ <option name="mainline-module-package-name" value="com.google.android.tethering" />
+ </object>
+</configuration>
\ No newline at end of file
diff --git a/Cronet/tools/import/copy.bara.sky b/Cronet/tools/import/copy.bara.sky
new file mode 100644
index 0000000..2acf8cd
--- /dev/null
+++ b/Cronet/tools/import/copy.bara.sky
@@ -0,0 +1,110 @@
+# Copyright 2023 Google Inc. All rights reserved.
+#
+# 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.
+
+common_excludes = [
+ # Exclude all Android build files
+ "**/Android.bp",
+ "**/Android.mk",
+
+ # Exclude existing *OWNERS files
+ "**/*OWNERS",
+]
+
+cronet_origin_files = glob(
+ include = [
+ "base/**",
+ "build/**",
+ "build/buildflag.h",
+ "chrome/VERSION",
+ "components/cronet/**",
+ "components/grpc_suport/**",
+ "components/metrics/**",
+ "components/nacl/**",
+ "components/prefs/**",
+ "crypto/**",
+ "ipc/**",
+ "net/**",
+ "url/**",
+ "LICENSE",
+ ],
+ exclude = common_excludes + [
+ # Per aosp/2367109
+ "build/android/CheckInstallApk-debug.apk",
+ "build/android/unused_resources/**",
+ "build/linux/**",
+
+ # Per aosp/2374766
+ "components/cronet/ios/**",
+ "components/cronet/native/**",
+
+
+ # Exclude all third-party directories. Those are specified explicitly
+ # below, so no dependency can accidentally creep in.
+ "**/third_party/**",
+ ],
+) + glob(
+ # Explicitly include third-party dependencies.
+ # Note: some third-party dependencies include a third_party folder within
+ # them. So far, this has not become a problem.
+ include = [
+ "base/third_party/cityhash/**",
+ "base/third_party/cityhash_v103/**",
+ "base/third_party/double_conversion/**",
+ "base/third_party/dynamic_annotations/**",
+ "base/third_party/icu/**",
+ "base/third_party/nspr/**",
+ "base/third_party/superfasthash/**",
+ # TODO: we should be able to remove this dependency.
+ "base/third_party/symbolize/**",
+ "base/third_party/valgrind/**",
+ "base/third_party/xdg_user_dirs/**",
+ # Not present in source repo; requires gclient sync.
+ "buildtools/third_party/libc++/**",
+ # Not present in source repo; requires gclient sync.
+ "buildtools/third_party/libc++abi/**",
+ "net/third_party/quiche/**",
+ "net/third_party/uri_template/**",
+ "third_party/abseil-cpp/**",
+ "third_party/android_ndk/sources/android/cpufeatures/**",
+ "third_party/ashmem/**",
+ "third_party/boringssl/**",
+ "third_party/brotli/**",
+ # Not present in source repo; requires gclient sync.
+ "third_party/icu/**",
+ "third_party/libevent/**",
+ "third_party/metrics_proto/**",
+ "third_party/modp_b64/**",
+ "third_party/protobuf/**",
+ "third_party/zlib/**",
+ ],
+ exclude = common_excludes,
+)
+
+core.workflow(
+ name = "import_cronet",
+ authoring = authoring.overwrite("Cronet Mainline Eng <cronet-mainline-eng+copybara@google.com>"),
+ origin = git.origin(
+ url = "rpc://chromium/chromium/src",
+ # Source ref is set by the invoking script.
+ ref = "overwritten-by-script",
+ partial_fetch = True,
+ ),
+ origin_files = cronet_origin_files,
+ destination = git.destination(
+ # The destination URL is set by the invoking script.
+ url = "overwritten/by/script",
+ push = "upstream-import",
+ ),
+ mode = "SQUASH",
+)
diff --git a/Cronet/tools/import/import_cronet.sh b/Cronet/tools/import/import_cronet.sh
new file mode 100755
index 0000000..7642914
--- /dev/null
+++ b/Cronet/tools/import/import_cronet.sh
@@ -0,0 +1,76 @@
+#!/bin/bash
+
+# Copyright 2023 Google Inc. All rights reserved.
+#
+# 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.
+
+# Script to invoke copybara locally to import Cronet into Android.
+# Inputs:
+# Environment:
+# ANDROID_BUILD_TOP: path the root of the current Android directory.
+# Arguments:
+# -l: The last revision that was imported.
+# -n: The new revision to import.
+
+OPTSTRING=l:n:
+
+usage() {
+ cat <<EOF
+Usage: import_cronet.sh -l last-rev -n new-rev
+EOF
+ exit 1
+}
+
+#######################################
+# Runs the copybara import of Chromium
+# Globals:
+# ANDROID_BUILD_TOP
+# Arguments:
+# last_rev, string
+# new_rev, string
+#######################################
+do_run_copybara() {
+ local _last_rev=$1
+ local _new_rev=$2
+
+ /google/bin/releases/copybara/public/copybara/copybara \
+ --git-destination-url="file://${ANDROID_BUILD_TOP}/external/cronet" \
+ --last-rev "${_last_rev}" \
+ --repo-timeout 3h \
+ "${ANDROID_BUILD_TOP}/packages/modules/Connectivity/Cronet/tools/import/copy.bara.sky" \
+ import_cronet "${_new_rev}"
+}
+
+while getopts $OPTSTRING opt; do
+ case "${opt}" in
+ l) last_rev="${OPTARG}" ;;
+ n) new_rev="${OPTARG}" ;;
+ ?) usage ;;
+ *) echo "'${opt}' '${OPTARG}'"
+ esac
+done
+
+# TODO: Get last-rev from METADATA file.
+# Setting last-rev may only be required for the first commit.
+if [ -z "${last_rev}" ]; then
+ echo "-l argument required"
+ usage
+fi
+
+if [ -z "${new_rev}" ]; then
+ echo "-n argument required"
+ usage
+fi
+
+do_run_copybara "${last_rev}" "${new_rev}"
+
diff --git a/TEST_MAPPING b/TEST_MAPPING
index a1e81c8..70c5f85 100644
--- a/TEST_MAPPING
+++ b/TEST_MAPPING
@@ -58,6 +58,17 @@
]
},
{
+ "name": "CtsNetTestCasesMaxTargetSdk33",
+ "options": [
+ {
+ "exclude-annotation": "com.android.testutils.SkipPresubmit"
+ },
+ {
+ "exclude-annotation": "androidx.test.filters.RequiresDevice"
+ }
+ ]
+ },
+ {
"name": "bpf_existence_test"
},
{
@@ -102,6 +113,11 @@
},
{
"name": "FrameworksNetDeflakeTest"
+ },
+ // Run in postsubmit to confirm test passes continously since this is a new test setup
+ // TODO: move tests to presubmit
+ {
+ "name": "NetHttpTests"
}
],
"mainline-presubmit": [
@@ -138,6 +154,17 @@
}
]
},
+ {
+ "name": "CtsNetTestCasesMaxTargetSdk33[CaptivePortalLoginGoogle.apk+NetworkStackGoogle.apk+com.google.android.resolv.apex+com.google.android.tethering.apex]",
+ "options": [
+ {
+ "exclude-annotation": "com.android.testutils.SkipPresubmit"
+ },
+ {
+ "exclude-annotation": "androidx.test.filters.RequiresDevice"
+ }
+ ]
+ },
// Test with APK modules only, in cases where APEX is not supported, or the other modules
// were simply not updated
{
@@ -186,6 +213,9 @@
},
{
"name": "libnetworkstats_test[CaptivePortalLoginGoogle.apk+NetworkStackGoogle.apk+com.google.android.resolv.apex+com.google.android.tethering.apex]"
+ },
+ {
+ "name": "NetHttpCoverageTests[CaptivePortalLoginGoogle.apk+NetworkStackGoogle.apk+com.google.android.resolv.apex+com.google.android.tethering.apex]"
}
],
"mainline-postsubmit": [
diff --git a/Tethering/AndroidManifest.xml b/Tethering/AndroidManifest.xml
index 23467e7..6a363b0 100644
--- a/Tethering/AndroidManifest.xml
+++ b/Tethering/AndroidManifest.xml
@@ -45,7 +45,6 @@
<!-- Sending non-protected broadcast from system uid is not allowed. -->
<protected-broadcast android:name="com.android.server.connectivity.tethering.DISABLE_TETHERING" />
- <protected-broadcast android:name="com.android.server.connectivity.KeepaliveTracker.TCP_POLLING_ALARM" />
<application
android:process="com.android.networkstack.process"
diff --git a/Tethering/apex/Android.bp b/Tethering/apex/Android.bp
index b26911c..67206cd 100644
--- a/Tethering/apex/Android.bp
+++ b/Tethering/apex/Android.bp
@@ -144,7 +144,6 @@
compat_configs: [
"connectivity-platform-compat-config",
- "connectivity-t-platform-compat-config",
],
}
diff --git a/Tethering/common/TetheringLib/cronet_enabled/api/current.txt b/Tethering/common/TetheringLib/cronet_enabled/api/current.txt
index c0157b7..e954074 100644
--- a/Tethering/common/TetheringLib/cronet_enabled/api/current.txt
+++ b/Tethering/common/TetheringLib/cronet_enabled/api/current.txt
@@ -1,38 +1,105 @@
// Signature format: 2.0
package android.net.http {
+ public abstract class BidirectionalStream {
+ ctor public BidirectionalStream();
+ method public abstract void cancel();
+ method public abstract void flush();
+ method public abstract boolean isDone();
+ method public abstract void read(java.nio.ByteBuffer);
+ method public abstract void start();
+ method public abstract void write(java.nio.ByteBuffer, boolean);
+ }
+
+ public abstract static class BidirectionalStream.Builder {
+ ctor public BidirectionalStream.Builder();
+ method public abstract android.net.http.BidirectionalStream.Builder addHeader(String, String);
+ method public abstract android.net.http.BidirectionalStream build();
+ method public abstract android.net.http.BidirectionalStream.Builder delayRequestHeadersUntilFirstFlush(boolean);
+ method public abstract android.net.http.BidirectionalStream.Builder setHttpMethod(String);
+ method public abstract android.net.http.BidirectionalStream.Builder setPriority(int);
+ method public abstract android.net.http.BidirectionalStream.Builder setTrafficStatsTag(int);
+ method public abstract android.net.http.BidirectionalStream.Builder setTrafficStatsUid(int);
+ field public static final int STREAM_PRIORITY_HIGHEST = 4; // 0x4
+ field public static final int STREAM_PRIORITY_IDLE = 0; // 0x0
+ field public static final int STREAM_PRIORITY_LOW = 2; // 0x2
+ field public static final int STREAM_PRIORITY_LOWEST = 1; // 0x1
+ field public static final int STREAM_PRIORITY_MEDIUM = 3; // 0x3
+ }
+
+ public abstract static class BidirectionalStream.Callback {
+ ctor public BidirectionalStream.Callback();
+ method public void onCanceled(android.net.http.BidirectionalStream, android.net.http.UrlResponseInfo);
+ method public abstract void onFailed(android.net.http.BidirectionalStream, android.net.http.UrlResponseInfo, android.net.http.HttpException);
+ method public abstract void onReadCompleted(android.net.http.BidirectionalStream, android.net.http.UrlResponseInfo, java.nio.ByteBuffer, boolean);
+ method public abstract void onResponseHeadersReceived(android.net.http.BidirectionalStream, android.net.http.UrlResponseInfo);
+ method public void onResponseTrailersReceived(android.net.http.BidirectionalStream, android.net.http.UrlResponseInfo, android.net.http.UrlResponseInfo.HeaderBlock);
+ method public abstract void onStreamReady(android.net.http.BidirectionalStream);
+ method public abstract void onSucceeded(android.net.http.BidirectionalStream, android.net.http.UrlResponseInfo);
+ method public abstract void onWriteCompleted(android.net.http.BidirectionalStream, android.net.http.UrlResponseInfo, java.nio.ByteBuffer, boolean);
+ }
+
public abstract class CallbackException extends android.net.http.HttpException {
ctor protected CallbackException(String, Throwable);
}
public class ConnectionMigrationOptions {
+ method @Nullable public Boolean getAllowNonDefaultNetworkUsage();
method @Nullable public Boolean getEnableDefaultNetworkMigration();
method @Nullable public Boolean getEnablePathDegradationMigration();
}
- public static class ConnectionMigrationOptions.Builder {
+ public static final class ConnectionMigrationOptions.Builder {
ctor public ConnectionMigrationOptions.Builder();
method public android.net.http.ConnectionMigrationOptions build();
+ method public android.net.http.ConnectionMigrationOptions.Builder setAllowNonDefaultNetworkUsage(boolean);
method public android.net.http.ConnectionMigrationOptions.Builder setEnableDefaultNetworkMigration(boolean);
method public android.net.http.ConnectionMigrationOptions.Builder setEnablePathDegradationMigration(boolean);
}
public final class DnsOptions {
+ method @Nullable public Boolean getEnableStaleDns();
method @Nullable public Boolean getPersistHostCache();
method @Nullable public java.time.Duration getPersistHostCachePeriod();
+ method @Nullable public Boolean getPreestablishConnectionsToStaleDnsResults();
+ method @Nullable public android.net.http.DnsOptions.StaleDnsOptions getStaleDnsOptions();
+ method @Nullable public Boolean getUseHttpStackDnsResolver();
}
public static final class DnsOptions.Builder {
ctor public DnsOptions.Builder();
method public android.net.http.DnsOptions build();
+ method public android.net.http.DnsOptions.Builder setEnableStaleDns(boolean);
method public android.net.http.DnsOptions.Builder setPersistHostCache(boolean);
method public android.net.http.DnsOptions.Builder setPersistHostCachePeriod(java.time.Duration);
+ method public android.net.http.DnsOptions.Builder setPreestablishConnectionsToStaleDnsResults(boolean);
+ method public android.net.http.DnsOptions.Builder setStaleDnsOptions(android.net.http.DnsOptions.StaleDnsOptions);
+ method public android.net.http.DnsOptions.Builder setUseHttpStackDnsResolver(boolean);
+ }
+
+ public static class DnsOptions.StaleDnsOptions {
+ method @Nullable public Boolean getAllowCrossNetworkUsage();
+ method @Nullable public Long getFreshLookupTimeoutMillis();
+ method @Nullable public Long getMaxExpiredDelayMillis();
+ method @Nullable public Boolean getUseStaleOnNameNotResolved();
+ }
+
+ public static final class DnsOptions.StaleDnsOptions.Builder {
+ ctor public DnsOptions.StaleDnsOptions.Builder();
+ method public android.net.http.DnsOptions.StaleDnsOptions build();
+ method public android.net.http.DnsOptions.StaleDnsOptions.Builder setAllowCrossNetworkUsage(boolean);
+ method public android.net.http.DnsOptions.StaleDnsOptions.Builder setFreshLookupTimeout(java.time.Duration);
+ method public android.net.http.DnsOptions.StaleDnsOptions.Builder setMaxExpiredDelay(java.time.Duration);
+ method public android.net.http.DnsOptions.StaleDnsOptions.Builder setUseStaleOnNameNotResolved(boolean);
}
public abstract class HttpEngine {
- method public abstract java.net.URLStreamHandlerFactory createURLStreamHandlerFactory();
- method public abstract String getVersionString();
- method public abstract android.net.http.UrlRequest.Builder newUrlRequestBuilder(String, android.net.http.UrlRequest.Callback, java.util.concurrent.Executor);
+ method public void bindToNetwork(@Nullable android.net.Network);
+ method public abstract java.net.URLStreamHandlerFactory createUrlStreamHandlerFactory();
+ method public static String getVersionString();
+ method public abstract android.net.http.BidirectionalStream.Builder newBidirectionalStreamBuilder(String, java.util.concurrent.Executor, android.net.http.BidirectionalStream.Callback);
+ method public abstract android.net.http.UrlRequest.Builder newUrlRequestBuilder(String, java.util.concurrent.Executor, android.net.http.UrlRequest.Callback);
+ method public android.net.http.UrlRequest.Builder newUrlRequestBuilder(String, android.net.http.UrlRequest.Callback, java.util.concurrent.Executor);
method public abstract java.net.URLConnection openConnection(java.net.URL) throws java.io.IOException;
method public abstract void shutdown();
}
@@ -60,7 +127,7 @@
}
public class HttpException extends java.io.IOException {
- ctor public HttpException(String, Throwable);
+ ctor public HttpException(@Nullable String, @Nullable Throwable);
}
public final class InlineExecutionProhibitedException extends java.util.concurrent.RejectedExecutionException {
@@ -68,7 +135,7 @@
}
public abstract class NetworkException extends android.net.http.HttpException {
- ctor public NetworkException(String, Throwable);
+ ctor public NetworkException(@Nullable String, @Nullable Throwable);
method public abstract int getErrorCode();
method public abstract boolean isImmediatelyRetryable();
field public static final int ERROR_ADDRESS_UNREACHABLE = 9; // 0x9
@@ -85,56 +152,60 @@
}
public abstract class QuicException extends android.net.http.NetworkException {
- ctor protected QuicException(String, Throwable);
+ ctor protected QuicException(@Nullable String, @Nullable Throwable);
}
public class QuicOptions {
method @Nullable public String getHandshakeUserAgent();
method @Nullable public Integer getInMemoryServerConfigsCacheSize();
- method public java.util.Set<java.lang.String> getQuicHostAllowlist();
+ method @NonNull public java.util.Set<java.lang.String> getQuicHostAllowlist();
}
- public static class QuicOptions.Builder {
+ public static final class QuicOptions.Builder {
ctor public QuicOptions.Builder();
- method public android.net.http.QuicOptions.Builder addAllowedQuicHost(String);
- method public android.net.http.QuicOptions build();
- method public android.net.http.QuicOptions.Builder setHandshakeUserAgent(String);
- method public android.net.http.QuicOptions.Builder setInMemoryServerConfigsCacheSize(int);
+ method @NonNull public android.net.http.QuicOptions.Builder addAllowedQuicHost(@NonNull String);
+ method @NonNull public android.net.http.QuicOptions build();
+ method @NonNull public android.net.http.QuicOptions.Builder setHandshakeUserAgent(@NonNull String);
+ method public android.net.http.QuicOptions.Builder setIdleConnectionTimeout(java.time.Duration);
+ method @NonNull public android.net.http.QuicOptions.Builder setInMemoryServerConfigsCacheSize(int);
}
public abstract class UploadDataProvider implements java.io.Closeable {
ctor public UploadDataProvider();
method public void close() throws java.io.IOException;
method public abstract long getLength() throws java.io.IOException;
- method public abstract void read(android.net.http.UploadDataSink, java.nio.ByteBuffer) throws java.io.IOException;
- method public abstract void rewind(android.net.http.UploadDataSink) throws java.io.IOException;
+ method public abstract void read(@NonNull android.net.http.UploadDataSink, @NonNull java.nio.ByteBuffer) throws java.io.IOException;
+ method public abstract void rewind(@NonNull android.net.http.UploadDataSink) throws java.io.IOException;
}
public abstract class UploadDataSink {
ctor public UploadDataSink();
- method public abstract void onReadError(Exception);
+ method public abstract void onReadError(@NonNull Exception);
method public abstract void onReadSucceeded(boolean);
- method public abstract void onRewindError(Exception);
+ method public abstract void onRewindError(@NonNull Exception);
method public abstract void onRewindSucceeded();
}
public abstract class UrlRequest {
method public abstract void cancel();
method public abstract void followRedirect();
- method public abstract void getStatus(android.net.http.UrlRequest.StatusListener);
+ method public abstract void getStatus(@NonNull android.net.http.UrlRequest.StatusListener);
method public abstract boolean isDone();
- method public abstract void read(java.nio.ByteBuffer);
+ method public abstract void read(@NonNull java.nio.ByteBuffer);
method public abstract void start();
}
public abstract static class UrlRequest.Builder {
- method public abstract android.net.http.UrlRequest.Builder addHeader(String, String);
- method public abstract android.net.http.UrlRequest.Builder allowDirectExecutor();
- method public abstract android.net.http.UrlRequest build();
- method public abstract android.net.http.UrlRequest.Builder disableCache();
- method public abstract android.net.http.UrlRequest.Builder setHttpMethod(String);
- method public abstract android.net.http.UrlRequest.Builder setPriority(int);
- method public abstract android.net.http.UrlRequest.Builder setUploadDataProvider(android.net.http.UploadDataProvider, java.util.concurrent.Executor);
+ method @NonNull public abstract android.net.http.UrlRequest.Builder addHeader(@NonNull String, @NonNull String);
+ method @NonNull public abstract android.net.http.UrlRequest.Builder bindToNetwork(@Nullable android.net.Network);
+ method @NonNull public abstract android.net.http.UrlRequest build();
+ method @NonNull public abstract android.net.http.UrlRequest.Builder setAllowDirectExecutor(boolean);
+ method @NonNull public abstract android.net.http.UrlRequest.Builder setDisableCache(boolean);
+ method @NonNull public abstract android.net.http.UrlRequest.Builder setHttpMethod(@NonNull String);
+ method @NonNull public abstract android.net.http.UrlRequest.Builder setPriority(int);
+ method public abstract android.net.http.UrlRequest.Builder setTrafficStatsTag(int);
+ method public abstract android.net.http.UrlRequest.Builder setTrafficStatsUid(int);
+ method @NonNull public abstract android.net.http.UrlRequest.Builder setUploadDataProvider(@NonNull android.net.http.UploadDataProvider, @NonNull java.util.concurrent.Executor);
field public static final int REQUEST_PRIORITY_HIGHEST = 4; // 0x4
field public static final int REQUEST_PRIORITY_IDLE = 0; // 0x0
field public static final int REQUEST_PRIORITY_LOW = 2; // 0x2
@@ -144,12 +215,12 @@
public abstract static class UrlRequest.Callback {
ctor public UrlRequest.Callback();
- method public void onCanceled(android.net.http.UrlRequest, android.net.http.UrlResponseInfo);
- method public abstract void onFailed(android.net.http.UrlRequest, android.net.http.UrlResponseInfo, android.net.http.HttpException);
- method public abstract void onReadCompleted(android.net.http.UrlRequest, android.net.http.UrlResponseInfo, java.nio.ByteBuffer) throws java.lang.Exception;
- method public abstract void onRedirectReceived(android.net.http.UrlRequest, android.net.http.UrlResponseInfo, String) throws java.lang.Exception;
- method public abstract void onResponseStarted(android.net.http.UrlRequest, android.net.http.UrlResponseInfo) throws java.lang.Exception;
- method public abstract void onSucceeded(android.net.http.UrlRequest, android.net.http.UrlResponseInfo);
+ 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);
}
public static class UrlRequest.Status {
@@ -171,24 +242,27 @@
field public static final int WAITING_FOR_STALLED_SOCKET_POOL = 1; // 0x1
}
- public abstract static class UrlRequest.StatusListener {
- ctor public UrlRequest.StatusListener();
- method public abstract void onStatus(int);
+ public static interface UrlRequest.StatusListener {
+ method public void onStatus(int);
}
public abstract class UrlResponseInfo {
ctor public UrlResponseInfo();
- method public abstract java.util.Map<java.lang.String,java.util.List<java.lang.String>> getAllHeaders();
- method public abstract java.util.List<java.util.Map.Entry<java.lang.String,java.lang.String>> getAllHeadersAsList();
+ method @NonNull public abstract android.net.http.UrlResponseInfo.HeaderBlock getHeaders();
method public abstract int getHttpStatusCode();
- method public abstract String getHttpStatusText();
- method public abstract String getNegotiatedProtocol();
- method public abstract String getProxyServer();
+ method @NonNull public abstract String getHttpStatusText();
+ method @NonNull public abstract String getNegotiatedProtocol();
method public abstract long getReceivedByteCount();
- method public abstract String getUrl();
- method public abstract java.util.List<java.lang.String> getUrlChain();
+ method @NonNull public abstract String getUrl();
+ method @NonNull public abstract java.util.List<java.lang.String> getUrlChain();
method public abstract boolean wasCached();
}
+ public abstract static class UrlResponseInfo.HeaderBlock {
+ ctor public UrlResponseInfo.HeaderBlock();
+ method public abstract java.util.List<java.util.Map.Entry<java.lang.String,java.lang.String>> getAsList();
+ method public abstract java.util.Map<java.lang.String,java.util.List<java.lang.String>> getAsMap();
+ }
+
}
diff --git a/Tethering/src/android/net/ip/RouterAdvertisementDaemon.java b/Tethering/src/android/net/ip/RouterAdvertisementDaemon.java
index c452e55..775c36f 100644
--- a/Tethering/src/android/net/ip/RouterAdvertisementDaemon.java
+++ b/Tethering/src/android/net/ip/RouterAdvertisementDaemon.java
@@ -88,13 +88,13 @@
private static final int MIN_RTR_ADV_INTERVAL_SEC = 300;
private static final int MAX_RTR_ADV_INTERVAL_SEC = 600;
// In general, router, prefix, and DNS lifetimes are all advised to be
- // greater than or equal to 3 * MAX_RTR_ADV_INTERVAL. Here, we double
+ // greater than or equal to 3 * MAX_RTR_ADV_INTERVAL. Here, we quadruple
// that to allow for multicast packet loss.
//
// This MAX_RTR_ADV_INTERVAL_SEC and DEFAULT_LIFETIME are also consistent
// with the https://tools.ietf.org/html/rfc7772#section-4 discussion of
// "approximately 7 RAs per hour".
- private static final int DEFAULT_LIFETIME = 6 * MAX_RTR_ADV_INTERVAL_SEC;
+ private static final int DEFAULT_LIFETIME = 12 * MAX_RTR_ADV_INTERVAL_SEC;
// From https://tools.ietf.org/html/rfc4861#section-10 .
private static final int MIN_DELAY_BETWEEN_RAS_SEC = 3;
// Both initial and final RAs, but also for changes in RA contents.
diff --git a/Tethering/tests/integration/Android.bp b/Tethering/tests/integration/Android.bp
index 11e3dc0..5e08aba 100644
--- a/Tethering/tests/integration/Android.bp
+++ b/Tethering/tests/integration/Android.bp
@@ -21,8 +21,7 @@
name: "TetheringIntegrationTestsDefaults",
defaults: ["framework-connectivity-test-defaults"],
srcs: [
- "src/**/*.java",
- "src/**/*.kt",
+ "base/**/*.java",
],
min_sdk_version: "30",
static_libs: [
@@ -47,6 +46,16 @@
],
}
+android_library {
+ name: "TetheringIntegrationTestsBaseLib",
+ target_sdk_version: "current",
+ platform_apis: true,
+ defaults: ["TetheringIntegrationTestsDefaults"],
+ visibility: [
+ "//packages/modules/Connectivity/Tethering/tests/mts",
+ ]
+}
+
// Library including tethering integration tests targeting the latest stable SDK.
// Use with NetworkStackJarJarRules.
android_library {
@@ -54,6 +63,9 @@
target_sdk_version: "33",
platform_apis: true,
defaults: ["TetheringIntegrationTestsDefaults"],
+ srcs: [
+ "src/**/*.java",
+ ],
visibility: [
"//packages/modules/Connectivity/tests/cts/tethering",
"//packages/modules/Connectivity/tests:__subpackages__",
@@ -68,12 +80,16 @@
target_sdk_version: "current",
platform_apis: true,
defaults: ["TetheringIntegrationTestsDefaults"],
+ srcs: [
+ "src/**/*.java",
+ ],
visibility: [
"//packages/modules/Connectivity/tests/cts/tethering",
"//packages/modules/Connectivity/Tethering/tests/mts",
]
}
+// TODO: remove because TetheringIntegrationTests has been covered by ConnectivityCoverageTests.
android_test {
name: "TetheringIntegrationTests",
platform_apis: true,
@@ -81,6 +97,9 @@
test_suites: [
"device-tests",
],
+ srcs: [
+ "src/**/*.java",
+ ],
compile_multilib: "both",
jarjar_rules: ":NetworkStackJarJarRules",
}
diff --git a/Tethering/tests/integration/src/android/net/EthernetTetheringTestBase.java b/Tethering/tests/integration/base/android/net/EthernetTetheringTestBase.java
similarity index 100%
rename from Tethering/tests/integration/src/android/net/EthernetTetheringTestBase.java
rename to Tethering/tests/integration/base/android/net/EthernetTetheringTestBase.java
diff --git a/Tethering/tests/integration/src/android/net/TetheringTester.java b/Tethering/tests/integration/base/android/net/TetheringTester.java
similarity index 100%
rename from Tethering/tests/integration/src/android/net/TetheringTester.java
rename to Tethering/tests/integration/base/android/net/TetheringTester.java
diff --git a/Tethering/tests/integration/src/android/net/CtsEthernetTetheringTest.java b/Tethering/tests/integration/src/android/net/EthernetTetheringTest.java
similarity index 78%
rename from Tethering/tests/integration/src/android/net/CtsEthernetTetheringTest.java
rename to Tethering/tests/integration/src/android/net/EthernetTetheringTest.java
index aea6728..fb4b9fa 100644
--- a/Tethering/tests/integration/src/android/net/CtsEthernetTetheringTest.java
+++ b/Tethering/tests/integration/src/android/net/EthernetTetheringTest.java
@@ -16,7 +16,6 @@
package android.net;
-import static android.Manifest.permission.DUMP;
import static android.net.InetAddresses.parseNumericAddress;
import static android.net.TetheringManager.CONNECTIVITY_SCOPE_LOCAL;
import static android.net.TetheringManager.TETHERING_ETHERNET;
@@ -26,7 +25,6 @@
import static android.system.OsConstants.ICMP_ECHO;
import static android.system.OsConstants.ICMP_ECHOREPLY;
import static android.system.OsConstants.IPPROTO_ICMP;
-import static android.system.OsConstants.IPPROTO_UDP;
import static com.android.net.module.util.ConnectivityUtils.isIPv6ULA;
import static com.android.net.module.util.HexDump.dumpHexString;
@@ -39,39 +37,28 @@
import static com.android.net.module.util.NetworkStackConstants.IPV4_CHECKSUM_OFFSET;
import static com.android.net.module.util.NetworkStackConstants.IPV4_HEADER_MIN_LEN;
import static com.android.net.module.util.NetworkStackConstants.IPV4_LENGTH_OFFSET;
-import static com.android.testutils.DeviceInfoUtils.KVersion;
-import static com.android.testutils.TestPermissionUtil.runAsShell;
import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.junit.Assume.assumeFalse;
import static org.junit.Assume.assumeTrue;
-import android.content.Context;
import android.net.TetheringManager.TetheringRequest;
import android.net.TetheringTester.TetheredDevice;
import android.os.Build;
import android.os.SystemClock;
import android.os.SystemProperties;
-import android.os.VintfRuntimeInfo;
import android.util.Log;
-import android.util.Pair;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.test.filters.MediumTest;
import androidx.test.runner.AndroidJUnit4;
-import com.android.net.module.util.BpfDump;
import com.android.net.module.util.Ipv6Utils;
import com.android.net.module.util.Struct;
-import com.android.net.module.util.bpf.Tether4Key;
-import com.android.net.module.util.bpf.Tether4Value;
-import com.android.net.module.util.bpf.TetherStatsKey;
-import com.android.net.module.util.bpf.TetherStatsValue;
import com.android.net.module.util.structs.EthernetHeader;
import com.android.net.module.util.structs.Icmpv4Header;
import com.android.net.module.util.structs.Ipv4Header;
@@ -79,8 +66,6 @@
import com.android.net.module.util.structs.UdpHeader;
import com.android.testutils.DevSdkIgnoreRule;
import com.android.testutils.DevSdkIgnoreRule.IgnoreUpTo;
-import com.android.testutils.DeviceInfoUtils;
-import com.android.testutils.DumpTestUtils;
import com.android.testutils.TapPacketReader;
import org.junit.Rule;
@@ -96,9 +81,7 @@
import java.nio.ByteBuffer;
import java.util.Arrays;
import java.util.Collection;
-import java.util.HashMap;
import java.util.List;
-import java.util.Map;
import java.util.Random;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;
@@ -106,34 +89,13 @@
@RunWith(AndroidJUnit4.class)
@MediumTest
-public class CtsEthernetTetheringTest extends EthernetTetheringTestBase {
+public class EthernetTetheringTest extends EthernetTetheringTestBase {
@Rule
public final DevSdkIgnoreRule mIgnoreRule = new DevSdkIgnoreRule();
- private static final String TAG = CtsEthernetTetheringTest.class.getSimpleName();
-
- private static final int DUMP_POLLING_MAX_RETRY = 100;
- private static final int DUMP_POLLING_INTERVAL_MS = 50;
- // Kernel treats a confirmed UDP connection which active after two seconds as stream mode.
- // See upstream commit b7b1d02fc43925a4d569ec221715db2dfa1ce4f5.
- private static final int UDP_STREAM_TS_MS = 2000;
- // Give slack time for waiting UDP stream mode because handling conntrack event in user space
- // may not in precise time. Used to reduce the flaky rate.
- private static final int UDP_STREAM_SLACK_MS = 500;
- // Per RX UDP packet size: iphdr (20) + udphdr (8) + payload (2) = 30 bytes.
- private static final int RX_UDP_PACKET_SIZE = 30;
- private static final int RX_UDP_PACKET_COUNT = 456;
- // Per TX UDP packet size: ethhdr (14) + iphdr (20) + udphdr (8) + payload (2) = 44 bytes.
- private static final int TX_UDP_PACKET_SIZE = 44;
- private static final int TX_UDP_PACKET_COUNT = 123;
+ private static final String TAG = EthernetTetheringTest.class.getSimpleName();
private static final short DNS_PORT = 53;
-
- private static final String DUMPSYS_TETHERING_RAWMAP_ARG = "bpfRawMap";
- private static final String DUMPSYS_RAWMAP_ARG_STATS = "--stats";
- private static final String DUMPSYS_RAWMAP_ARG_UPSTREAM4 = "--upstream4";
- private static final String LINE_DELIMITER = "\\n";
-
private static final short ICMPECHO_CODE = 0x0;
private static final short ICMPECHO_ID = 0x0;
private static final short ICMPECHO_SEQ = 0x0;
@@ -529,7 +491,7 @@
// remote ip public ip private ip
// 8.8.8.8:443 <Upstream ip>:9876 <TetheredDevice ip>:9876
//
- private void runUdp4Test(boolean verifyBpf) throws Exception {
+ private void runUdp4Test() throws Exception {
final TetheringTester tester = initTetheringTester(toList(TEST_IP4_ADDR),
toList(TEST_IP4_DNS));
final TetheredDevice tethered = tester.createTetheredDevice(TEST_MAC, false /* hasIpv6 */);
@@ -549,123 +511,6 @@
final InetAddress clientIp = tethered.ipv4Addr;
sendUploadPacketUdp(srcMac, dstMac, clientIp, remoteIp, tester, false /* is4To6 */);
sendDownloadPacketUdp(remoteIp, tetheringUpstreamIp, tester, false /* is6To4 */);
-
- if (verifyBpf) {
- // Send second UDP packet in original direction.
- // The BPF coordinator only offloads the ASSURED conntrack entry. The "request + reply"
- // packets can make status IPS_SEEN_REPLY to be set. Need one more packet to make
- // conntrack status IPS_ASSURED_BIT to be set. Note the third packet needs to delay
- // 2 seconds because kernel monitors a UDP connection which still alive after 2 seconds
- // and apply ASSURED flag.
- // See kernel upstream commit b7b1d02fc43925a4d569ec221715db2dfa1ce4f5 and
- // nf_conntrack_udp_packet in net/netfilter/nf_conntrack_proto_udp.c
- Thread.sleep(UDP_STREAM_TS_MS);
- sendUploadPacketUdp(srcMac, dstMac, clientIp, remoteIp, tester, false /* is4To6 */);
-
- // Give a slack time for handling conntrack event in user space.
- Thread.sleep(UDP_STREAM_SLACK_MS);
-
- // [1] Verify IPv4 upstream rule map.
- final HashMap<Tether4Key, Tether4Value> upstreamMap = pollRawMapFromDump(
- Tether4Key.class, Tether4Value.class, DUMPSYS_RAWMAP_ARG_UPSTREAM4);
- assertNotNull(upstreamMap);
- assertEquals(1, upstreamMap.size());
-
- final Map.Entry<Tether4Key, Tether4Value> rule =
- upstreamMap.entrySet().iterator().next();
-
- final Tether4Key upstream4Key = rule.getKey();
- assertEquals(IPPROTO_UDP, upstream4Key.l4proto);
- assertTrue(Arrays.equals(tethered.ipv4Addr.getAddress(), upstream4Key.src4));
- assertEquals(LOCAL_PORT, upstream4Key.srcPort);
- assertTrue(Arrays.equals(REMOTE_IP4_ADDR.getAddress(), upstream4Key.dst4));
- assertEquals(REMOTE_PORT, upstream4Key.dstPort);
-
- final Tether4Value upstream4Value = rule.getValue();
- assertTrue(Arrays.equals(tetheringUpstreamIp.getAddress(),
- InetAddress.getByAddress(upstream4Value.src46).getAddress()));
- assertEquals(LOCAL_PORT, upstream4Value.srcPort);
- assertTrue(Arrays.equals(REMOTE_IP4_ADDR.getAddress(),
- InetAddress.getByAddress(upstream4Value.dst46).getAddress()));
- assertEquals(REMOTE_PORT, upstream4Value.dstPort);
-
- // [2] Verify stats map.
- // Transmit packets on both direction for verifying stats. Because we only care the
- // packet count in stats test, we just reuse the existing packets to increaes
- // the packet count on both direction.
-
- // Send packets on original direction.
- for (int i = 0; i < TX_UDP_PACKET_COUNT; i++) {
- sendUploadPacketUdp(srcMac, dstMac, clientIp, remoteIp, tester,
- false /* is4To6 */);
- }
-
- // Send packets on reply direction.
- for (int i = 0; i < RX_UDP_PACKET_COUNT; i++) {
- sendDownloadPacketUdp(remoteIp, tetheringUpstreamIp, tester, false /* is6To4 */);
- }
-
- // Dump stats map to verify.
- final HashMap<TetherStatsKey, TetherStatsValue> statsMap = pollRawMapFromDump(
- TetherStatsKey.class, TetherStatsValue.class, DUMPSYS_RAWMAP_ARG_STATS);
- assertNotNull(statsMap);
- assertEquals(1, statsMap.size());
-
- final Map.Entry<TetherStatsKey, TetherStatsValue> stats =
- statsMap.entrySet().iterator().next();
-
- // TODO: verify the upstream index in TetherStatsKey.
-
- final TetherStatsValue statsValue = stats.getValue();
- assertEquals(RX_UDP_PACKET_COUNT, statsValue.rxPackets);
- assertEquals(RX_UDP_PACKET_COUNT * RX_UDP_PACKET_SIZE, statsValue.rxBytes);
- assertEquals(0, statsValue.rxErrors);
- assertEquals(TX_UDP_PACKET_COUNT, statsValue.txPackets);
- assertEquals(TX_UDP_PACKET_COUNT * TX_UDP_PACKET_SIZE, statsValue.txBytes);
- assertEquals(0, statsValue.txErrors);
- }
- }
-
- private static boolean isUdpOffloadSupportedByKernel(final String kernelVersion) {
- final KVersion current = DeviceInfoUtils.getMajorMinorSubminorVersion(kernelVersion);
- return current.isInRange(new KVersion(4, 14, 222), new KVersion(4, 19, 0))
- || current.isInRange(new KVersion(4, 19, 176), new KVersion(5, 4, 0))
- || current.isAtLeast(new KVersion(5, 4, 98));
- }
-
- @Test
- public void testIsUdpOffloadSupportedByKernel() throws Exception {
- assertFalse(isUdpOffloadSupportedByKernel("4.14.221"));
- assertTrue(isUdpOffloadSupportedByKernel("4.14.222"));
- assertTrue(isUdpOffloadSupportedByKernel("4.16.0"));
- assertTrue(isUdpOffloadSupportedByKernel("4.18.0"));
- assertFalse(isUdpOffloadSupportedByKernel("4.19.0"));
-
- assertFalse(isUdpOffloadSupportedByKernel("4.19.175"));
- assertTrue(isUdpOffloadSupportedByKernel("4.19.176"));
- assertTrue(isUdpOffloadSupportedByKernel("5.2.0"));
- assertTrue(isUdpOffloadSupportedByKernel("5.3.0"));
- assertFalse(isUdpOffloadSupportedByKernel("5.4.0"));
-
- assertFalse(isUdpOffloadSupportedByKernel("5.4.97"));
- assertTrue(isUdpOffloadSupportedByKernel("5.4.98"));
- assertTrue(isUdpOffloadSupportedByKernel("5.10.0"));
- }
-
- private static void assumeKernelSupportBpfOffloadUdpV4() {
- final String kernelVersion = VintfRuntimeInfo.getKernelVersion();
- assumeTrue("Kernel version " + kernelVersion + " doesn't support IPv4 UDP BPF offload",
- isUdpOffloadSupportedByKernel(kernelVersion));
- }
-
- @Test
- public void testKernelSupportBpfOffloadUdpV4() throws Exception {
- assumeKernelSupportBpfOffloadUdpV4();
- }
-
- @Test
- public void testTetherConfigBpfOffloadEnabled() throws Exception {
- assumeTrue(isTetherConfigBpfOffloadEnabled());
}
/**
@@ -674,73 +519,7 @@
*/
@Test
public void testTetherUdpV4() throws Exception {
- runUdp4Test(false /* verifyBpf */);
- }
-
- /**
- * BPF offload IPv4 UDP tethering test. Verify that UDP tethered packets are offloaded by BPF.
- * Minimum test requirement:
- * 1. S+ device.
- * 2. Tethering config enables tethering BPF offload.
- * 3. Kernel supports IPv4 UDP BPF offload. See #isUdpOffloadSupportedByKernel.
- *
- * TODO: consider enabling the test even tethering config disables BPF offload. See b/238288883
- */
- @Test
- @IgnoreUpTo(Build.VERSION_CODES.R)
- public void testTetherUdpV4_VerifyBpf() throws Exception {
- assumeTrue("Tethering config disabled BPF offload", isTetherConfigBpfOffloadEnabled());
- assumeKernelSupportBpfOffloadUdpV4();
-
- runUdp4Test(true /* verifyBpf */);
- }
-
- @NonNull
- private <K extends Struct, V extends Struct> HashMap<K, V> dumpAndParseRawMap(
- Class<K> keyClass, Class<V> valueClass, @NonNull String mapArg)
- throws Exception {
- final String[] args = new String[] {DUMPSYS_TETHERING_RAWMAP_ARG, mapArg};
- final String rawMapStr = runAsShell(DUMP, () ->
- DumpTestUtils.dumpService(Context.TETHERING_SERVICE, args));
- final HashMap<K, V> map = new HashMap<>();
-
- for (final String line : rawMapStr.split(LINE_DELIMITER)) {
- final Pair<K, V> rule =
- BpfDump.fromBase64EncodedString(keyClass, valueClass, line.trim());
- map.put(rule.first, rule.second);
- }
- return map;
- }
-
- @Nullable
- private <K extends Struct, V extends Struct> HashMap<K, V> pollRawMapFromDump(
- Class<K> keyClass, Class<V> valueClass, @NonNull String mapArg)
- throws Exception {
- for (int retryCount = 0; retryCount < DUMP_POLLING_MAX_RETRY; retryCount++) {
- final HashMap<K, V> map = dumpAndParseRawMap(keyClass, valueClass, mapArg);
- if (!map.isEmpty()) return map;
-
- Thread.sleep(DUMP_POLLING_INTERVAL_MS);
- }
-
- fail("Cannot get rules after " + DUMP_POLLING_MAX_RETRY * DUMP_POLLING_INTERVAL_MS + "ms");
- return null;
- }
-
- private boolean isTetherConfigBpfOffloadEnabled() throws Exception {
- final String dumpStr = runAsShell(DUMP, () ->
- DumpTestUtils.dumpService(Context.TETHERING_SERVICE, "--short"));
-
- // BPF offload tether config can be overridden by "config_tether_enable_bpf_offload" in
- // packages/modules/Connectivity/Tethering/res/values/config.xml. OEM may disable config by
- // RRO to override the enabled default value. Get the tethering config via dumpsys.
- // $ dumpsys tethering
- // mIsBpfEnabled: true
- boolean enabled = dumpStr.contains("mIsBpfEnabled: true");
- if (!enabled) {
- Log.d(TAG, "BPF offload tether config not enabled: " + dumpStr);
- }
- return enabled;
+ runUdp4Test();
}
@NonNull
diff --git a/Tethering/tests/mts/Android.bp b/Tethering/tests/mts/Android.bp
index ae36499..4f4b03c 100644
--- a/Tethering/tests/mts/Android.bp
+++ b/Tethering/tests/mts/Android.bp
@@ -33,6 +33,7 @@
],
static_libs: [
+ "TetheringIntegrationTestsBaseLib",
"androidx.test.rules",
// mockito-target-extended-minus-junit4 used in this lib have dependency with
// jni_libs libdexmakerjvmtiagent and libstaticjvmtiagent.
diff --git a/Tethering/tests/mts/AndroidManifest.xml b/Tethering/tests/mts/AndroidManifest.xml
index 6d2abca..42f2da9 100644
--- a/Tethering/tests/mts/AndroidManifest.xml
+++ b/Tethering/tests/mts/AndroidManifest.xml
@@ -27,8 +27,6 @@
<instrumentation android:name="androidx.test.runner.AndroidJUnitRunner"
android:targetPackage="android.tethering.mts"
android:label="MTS tests of android.tethering">
- <meta-data android:name="listener"
- android:value="com.android.cts.runner.CtsTestRunListener" />
</instrumentation>
</manifest>
diff --git a/Tethering/tests/mts/src/android/tethering/mts/MtsEthernetTetheringTest.java b/Tethering/tests/mts/src/android/tethering/mts/MtsEthernetTetheringTest.java
new file mode 100644
index 0000000..cb57d13
--- /dev/null
+++ b/Tethering/tests/mts/src/android/tethering/mts/MtsEthernetTetheringTest.java
@@ -0,0 +1,304 @@
+/*
+ * Copyright (C) 2022 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;
+
+import static android.Manifest.permission.DUMP;
+import static android.system.OsConstants.IPPROTO_UDP;
+
+import static com.android.testutils.DeviceInfoUtils.KVersion;
+import static com.android.testutils.TestPermissionUtil.runAsShell;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.junit.Assume.assumeTrue;
+
+import android.content.Context;
+import android.net.TetheringTester.TetheredDevice;
+import android.os.Build;
+import android.os.VintfRuntimeInfo;
+import android.util.Log;
+import android.util.Pair;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.test.filters.MediumTest;
+import androidx.test.runner.AndroidJUnit4;
+
+import com.android.net.module.util.BpfDump;
+import com.android.net.module.util.Struct;
+import com.android.net.module.util.bpf.Tether4Key;
+import com.android.net.module.util.bpf.Tether4Value;
+import com.android.net.module.util.bpf.TetherStatsKey;
+import com.android.net.module.util.bpf.TetherStatsValue;
+import com.android.testutils.DevSdkIgnoreRule;
+import com.android.testutils.DevSdkIgnoreRule.IgnoreUpTo;
+import com.android.testutils.DeviceInfoUtils;
+import com.android.testutils.DumpTestUtils;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.net.InetAddress;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+
+@RunWith(AndroidJUnit4.class)
+@MediumTest
+public class MtsEthernetTetheringTest extends EthernetTetheringTestBase {
+ @Rule
+ public final DevSdkIgnoreRule mIgnoreRule = new DevSdkIgnoreRule();
+
+ private static final String TAG = MtsEthernetTetheringTest.class.getSimpleName();
+
+ private static final int DUMP_POLLING_MAX_RETRY = 100;
+ private static final int DUMP_POLLING_INTERVAL_MS = 50;
+ // Kernel treats a confirmed UDP connection which active after two seconds as stream mode.
+ // See upstream commit b7b1d02fc43925a4d569ec221715db2dfa1ce4f5.
+ private static final int UDP_STREAM_TS_MS = 2000;
+ // Give slack time for waiting UDP stream mode because handling conntrack event in user space
+ // may not in precise time. Used to reduce the flaky rate.
+ private static final int UDP_STREAM_SLACK_MS = 500;
+ // Per RX UDP packet size: iphdr (20) + udphdr (8) + payload (2) = 30 bytes.
+ private static final int RX_UDP_PACKET_SIZE = 30;
+ private static final int RX_UDP_PACKET_COUNT = 456;
+ // Per TX UDP packet size: ethhdr (14) + iphdr (20) + udphdr (8) + payload (2) = 44 bytes.
+ private static final int TX_UDP_PACKET_SIZE = 44;
+ private static final int TX_UDP_PACKET_COUNT = 123;
+
+ private static final String DUMPSYS_TETHERING_RAWMAP_ARG = "bpfRawMap";
+ private static final String DUMPSYS_RAWMAP_ARG_STATS = "--stats";
+ private static final String DUMPSYS_RAWMAP_ARG_UPSTREAM4 = "--upstream4";
+ private static final String LINE_DELIMITER = "\\n";
+
+ private static boolean isUdpOffloadSupportedByKernel(final String kernelVersion) {
+ final KVersion current = DeviceInfoUtils.getMajorMinorSubminorVersion(kernelVersion);
+ return current.isInRange(new KVersion(4, 14, 222), new KVersion(4, 19, 0))
+ || current.isInRange(new KVersion(4, 19, 176), new KVersion(5, 4, 0))
+ || current.isAtLeast(new KVersion(5, 4, 98));
+ }
+
+ @Test
+ public void testIsUdpOffloadSupportedByKernel() throws Exception {
+ assertFalse(isUdpOffloadSupportedByKernel("4.14.221"));
+ assertTrue(isUdpOffloadSupportedByKernel("4.14.222"));
+ assertTrue(isUdpOffloadSupportedByKernel("4.16.0"));
+ assertTrue(isUdpOffloadSupportedByKernel("4.18.0"));
+ assertFalse(isUdpOffloadSupportedByKernel("4.19.0"));
+
+ assertFalse(isUdpOffloadSupportedByKernel("4.19.175"));
+ assertTrue(isUdpOffloadSupportedByKernel("4.19.176"));
+ assertTrue(isUdpOffloadSupportedByKernel("5.2.0"));
+ assertTrue(isUdpOffloadSupportedByKernel("5.3.0"));
+ assertFalse(isUdpOffloadSupportedByKernel("5.4.0"));
+
+ assertFalse(isUdpOffloadSupportedByKernel("5.4.97"));
+ assertTrue(isUdpOffloadSupportedByKernel("5.4.98"));
+ assertTrue(isUdpOffloadSupportedByKernel("5.10.0"));
+ }
+
+ private static void assumeKernelSupportBpfOffloadUdpV4() {
+ final String kernelVersion = VintfRuntimeInfo.getKernelVersion();
+ assumeTrue("Kernel version " + kernelVersion + " doesn't support IPv4 UDP BPF offload",
+ isUdpOffloadSupportedByKernel(kernelVersion));
+ }
+
+ @Test
+ public void testKernelSupportBpfOffloadUdpV4() throws Exception {
+ assumeKernelSupportBpfOffloadUdpV4();
+ }
+
+ private boolean isTetherConfigBpfOffloadEnabled() throws Exception {
+ final String dumpStr = runAsShell(DUMP, () ->
+ DumpTestUtils.dumpService(Context.TETHERING_SERVICE, "--short"));
+
+ // BPF offload tether config can be overridden by "config_tether_enable_bpf_offload" in
+ // packages/modules/Connectivity/Tethering/res/values/config.xml. OEM may disable config by
+ // RRO to override the enabled default value. Get the tethering config via dumpsys.
+ // $ dumpsys tethering
+ // mIsBpfEnabled: true
+ boolean enabled = dumpStr.contains("mIsBpfEnabled: true");
+ if (!enabled) {
+ Log.d(TAG, "BPF offload tether config not enabled: " + dumpStr);
+ }
+ return enabled;
+ }
+
+ @Test
+ public void testTetherConfigBpfOffloadEnabled() throws Exception {
+ assumeTrue(isTetherConfigBpfOffloadEnabled());
+ }
+
+ @NonNull
+ private <K extends Struct, V extends Struct> HashMap<K, V> dumpAndParseRawMap(
+ Class<K> keyClass, Class<V> valueClass, @NonNull String mapArg)
+ throws Exception {
+ final String[] args = new String[] {DUMPSYS_TETHERING_RAWMAP_ARG, mapArg};
+ final String rawMapStr = runAsShell(DUMP, () ->
+ DumpTestUtils.dumpService(Context.TETHERING_SERVICE, args));
+ final HashMap<K, V> map = new HashMap<>();
+
+ for (final String line : rawMapStr.split(LINE_DELIMITER)) {
+ final Pair<K, V> rule =
+ BpfDump.fromBase64EncodedString(keyClass, valueClass, line.trim());
+ map.put(rule.first, rule.second);
+ }
+ return map;
+ }
+
+ @Nullable
+ private <K extends Struct, V extends Struct> HashMap<K, V> pollRawMapFromDump(
+ Class<K> keyClass, Class<V> valueClass, @NonNull String mapArg)
+ throws Exception {
+ for (int retryCount = 0; retryCount < DUMP_POLLING_MAX_RETRY; retryCount++) {
+ final HashMap<K, V> map = dumpAndParseRawMap(keyClass, valueClass, mapArg);
+ if (!map.isEmpty()) return map;
+
+ Thread.sleep(DUMP_POLLING_INTERVAL_MS);
+ }
+
+ fail("Cannot get rules after " + DUMP_POLLING_MAX_RETRY * DUMP_POLLING_INTERVAL_MS + "ms");
+ return null;
+ }
+
+ // Test network topology:
+ //
+ // public network (rawip) private network
+ // | UE |
+ // +------------+ V +------------+------------+ V +------------+
+ // | Sever +---------+ Upstream | Downstream +---------+ Client |
+ // +------------+ +------------+------------+ +------------+
+ // remote ip public ip private ip
+ // 8.8.8.8:443 <Upstream ip>:9876 <TetheredDevice ip>:9876
+ //
+ private void runUdp4Test() throws Exception {
+ final TetheringTester tester = initTetheringTester(toList(TEST_IP4_ADDR),
+ toList(TEST_IP4_DNS));
+ final TetheredDevice tethered = tester.createTetheredDevice(TEST_MAC, false /* hasIpv6 */);
+
+ // TODO: remove the connectivity verification for upstream connected notification race.
+ // Because async upstream connected notification can't guarantee the tethering routing is
+ // ready to use. Need to test tethering connectivity before testing.
+ // For short term plan, consider using IPv6 RA to get MAC address because the prefix comes
+ // from upstream. That can guarantee that the routing is ready. Long term plan is that
+ // refactors upstream connected notification from async to sync.
+ probeV4TetheringConnectivity(tester, tethered, false /* is4To6 */);
+
+ final MacAddress srcMac = tethered.macAddr;
+ final MacAddress dstMac = tethered.routerMacAddr;
+ final InetAddress remoteIp = REMOTE_IP4_ADDR;
+ final InetAddress tetheringUpstreamIp = TEST_IP4_ADDR.getAddress();
+ final InetAddress clientIp = tethered.ipv4Addr;
+ sendUploadPacketUdp(srcMac, dstMac, clientIp, remoteIp, tester, false /* is4To6 */);
+ sendDownloadPacketUdp(remoteIp, tetheringUpstreamIp, tester, false /* is6To4 */);
+
+ // Send second UDP packet in original direction.
+ // The BPF coordinator only offloads the ASSURED conntrack entry. The "request + reply"
+ // packets can make status IPS_SEEN_REPLY to be set. Need one more packet to make
+ // conntrack status IPS_ASSURED_BIT to be set. Note the third packet needs to delay
+ // 2 seconds because kernel monitors a UDP connection which still alive after 2 seconds
+ // and apply ASSURED flag.
+ // See kernel upstream commit b7b1d02fc43925a4d569ec221715db2dfa1ce4f5 and
+ // nf_conntrack_udp_packet in net/netfilter/nf_conntrack_proto_udp.c
+ Thread.sleep(UDP_STREAM_TS_MS);
+ sendUploadPacketUdp(srcMac, dstMac, clientIp, remoteIp, tester, false /* is4To6 */);
+
+ // Give a slack time for handling conntrack event in user space.
+ Thread.sleep(UDP_STREAM_SLACK_MS);
+
+ // [1] Verify IPv4 upstream rule map.
+ final HashMap<Tether4Key, Tether4Value> upstreamMap = pollRawMapFromDump(
+ Tether4Key.class, Tether4Value.class, DUMPSYS_RAWMAP_ARG_UPSTREAM4);
+ assertNotNull(upstreamMap);
+ assertEquals(1, upstreamMap.size());
+
+ final Map.Entry<Tether4Key, Tether4Value> rule =
+ upstreamMap.entrySet().iterator().next();
+
+ final Tether4Key upstream4Key = rule.getKey();
+ assertEquals(IPPROTO_UDP, upstream4Key.l4proto);
+ assertTrue(Arrays.equals(tethered.ipv4Addr.getAddress(), upstream4Key.src4));
+ assertEquals(LOCAL_PORT, upstream4Key.srcPort);
+ assertTrue(Arrays.equals(REMOTE_IP4_ADDR.getAddress(), upstream4Key.dst4));
+ assertEquals(REMOTE_PORT, upstream4Key.dstPort);
+
+ final Tether4Value upstream4Value = rule.getValue();
+ assertTrue(Arrays.equals(tetheringUpstreamIp.getAddress(),
+ InetAddress.getByAddress(upstream4Value.src46).getAddress()));
+ assertEquals(LOCAL_PORT, upstream4Value.srcPort);
+ assertTrue(Arrays.equals(REMOTE_IP4_ADDR.getAddress(),
+ InetAddress.getByAddress(upstream4Value.dst46).getAddress()));
+ assertEquals(REMOTE_PORT, upstream4Value.dstPort);
+
+ // [2] Verify stats map.
+ // Transmit packets on both direction for verifying stats. Because we only care the
+ // packet count in stats test, we just reuse the existing packets to increaes
+ // the packet count on both direction.
+
+ // Send packets on original direction.
+ for (int i = 0; i < TX_UDP_PACKET_COUNT; i++) {
+ sendUploadPacketUdp(srcMac, dstMac, clientIp, remoteIp, tester,
+ false /* is4To6 */);
+ }
+
+ // Send packets on reply direction.
+ for (int i = 0; i < RX_UDP_PACKET_COUNT; i++) {
+ sendDownloadPacketUdp(remoteIp, tetheringUpstreamIp, tester, false /* is6To4 */);
+ }
+
+ // Dump stats map to verify.
+ final HashMap<TetherStatsKey, TetherStatsValue> statsMap = pollRawMapFromDump(
+ TetherStatsKey.class, TetherStatsValue.class, DUMPSYS_RAWMAP_ARG_STATS);
+ assertNotNull(statsMap);
+ assertEquals(1, statsMap.size());
+
+ final Map.Entry<TetherStatsKey, TetherStatsValue> stats =
+ statsMap.entrySet().iterator().next();
+
+ // TODO: verify the upstream index in TetherStatsKey.
+
+ final TetherStatsValue statsValue = stats.getValue();
+ assertEquals(RX_UDP_PACKET_COUNT, statsValue.rxPackets);
+ assertEquals(RX_UDP_PACKET_COUNT * RX_UDP_PACKET_SIZE, statsValue.rxBytes);
+ assertEquals(0, statsValue.rxErrors);
+ assertEquals(TX_UDP_PACKET_COUNT, statsValue.txPackets);
+ assertEquals(TX_UDP_PACKET_COUNT * TX_UDP_PACKET_SIZE, statsValue.txBytes);
+ assertEquals(0, statsValue.txErrors);
+ }
+
+ /**
+ * BPF offload IPv4 UDP tethering test. Verify that UDP tethered packets are offloaded by BPF.
+ * Minimum test requirement:
+ * 1. S+ device.
+ * 2. Tethering config enables tethering BPF offload.
+ * 3. Kernel supports IPv4 UDP BPF offload. See #isUdpOffloadSupportedByKernel.
+ *
+ * TODO: consider enabling the test even tethering config disables BPF offload. See b/238288883
+ */
+ @Test
+ @IgnoreUpTo(Build.VERSION_CODES.R)
+ public void testTetherBpfOffloadUdpV4() throws Exception {
+ assumeTrue("Tethering config disabled BPF offload", isTetherConfigBpfOffloadEnabled());
+ assumeKernelSupportBpfOffloadUdpV4();
+
+ runUdp4Test();
+ }
+}
diff --git a/Tethering/tests/unit/src/com/android/networkstack/tethering/TetheringTest.java b/Tethering/tests/unit/src/com/android/networkstack/tethering/TetheringTest.java
index 98a3b1d..79590b7 100644
--- a/Tethering/tests/unit/src/com/android/networkstack/tethering/TetheringTest.java
+++ b/Tethering/tests/unit/src/com/android/networkstack/tethering/TetheringTest.java
@@ -29,6 +29,7 @@
import static android.net.ConnectivityManager.TYPE_WIFI;
import static android.net.NetworkCapabilities.NET_CAPABILITY_DUN;
import static android.net.NetworkCapabilities.NET_CAPABILITY_INTERNET;
+import static android.net.NetworkCapabilities.NET_CAPABILITY_VALIDATED;
import static android.net.NetworkCapabilities.TRANSPORT_BLUETOOTH;
import static android.net.NetworkCapabilities.TRANSPORT_CELLULAR;
import static android.net.NetworkCapabilities.TRANSPORT_WIFI;
@@ -2678,35 +2679,67 @@
public void testUpstreamNetworkChanged() {
final Tethering.TetherMainSM stateMachine = (Tethering.TetherMainSM)
mTetheringDependencies.mUpstreamNetworkMonitorSM;
+ final InOrder inOrder = inOrder(mNotificationUpdater);
+
// Gain upstream.
final UpstreamNetworkState upstreamState = buildMobileIPv4UpstreamState();
initTetheringUpstream(upstreamState);
stateMachine.chooseUpstreamType(true);
mTetheringEventCallback.expectUpstreamChanged(upstreamState.network);
- verify(mNotificationUpdater)
+ inOrder.verify(mNotificationUpdater)
.onUpstreamCapabilitiesChanged(upstreamState.networkCapabilities);
+ // Set the upstream with the same network ID but different object and the same capability.
+ final UpstreamNetworkState upstreamState2 = buildMobileIPv4UpstreamState();
+ initTetheringUpstream(upstreamState2);
+ stateMachine.chooseUpstreamType(true);
+ // Bug: duplicated upstream change event.
+ mTetheringEventCallback.expectUpstreamChanged(upstreamState2.network);
+ inOrder.verify(mNotificationUpdater)
+ .onUpstreamCapabilitiesChanged(upstreamState2.networkCapabilities);
+
+ // Set the upstream with the same network ID but different object and different capability.
+ final UpstreamNetworkState upstreamState3 = buildMobileIPv4UpstreamState();
+ assertFalse(upstreamState3.networkCapabilities.hasCapability(NET_CAPABILITY_VALIDATED));
+ upstreamState3.networkCapabilities.addCapability(NET_CAPABILITY_VALIDATED);
+ initTetheringUpstream(upstreamState3);
+ stateMachine.chooseUpstreamType(true);
+ // Bug: duplicated upstream change event.
+ mTetheringEventCallback.expectUpstreamChanged(upstreamState3.network);
+ inOrder.verify(mNotificationUpdater)
+ .onUpstreamCapabilitiesChanged(upstreamState3.networkCapabilities);
+
// Lose upstream.
initTetheringUpstream(null);
stateMachine.chooseUpstreamType(true);
mTetheringEventCallback.expectUpstreamChanged(NULL_NETWORK);
- verify(mNotificationUpdater).onUpstreamCapabilitiesChanged(null);
+ inOrder.verify(mNotificationUpdater).onUpstreamCapabilitiesChanged(null);
}
@Test
public void testUpstreamCapabilitiesChanged() {
final Tethering.TetherMainSM stateMachine = (Tethering.TetherMainSM)
mTetheringDependencies.mUpstreamNetworkMonitorSM;
+ final InOrder inOrder = inOrder(mNotificationUpdater);
final UpstreamNetworkState upstreamState = buildMobileIPv4UpstreamState();
initTetheringUpstream(upstreamState);
+
stateMachine.chooseUpstreamType(true);
+ inOrder.verify(mNotificationUpdater)
+ .onUpstreamCapabilitiesChanged(upstreamState.networkCapabilities);
stateMachine.handleUpstreamNetworkMonitorCallback(EVENT_ON_CAPABILITIES, upstreamState);
- // Should have two onUpstreamCapabilitiesChanged().
- // One is called by reportUpstreamChanged(). One is called by EVENT_ON_CAPABILITIES.
- verify(mNotificationUpdater, times(2))
+ inOrder.verify(mNotificationUpdater)
.onUpstreamCapabilitiesChanged(upstreamState.networkCapabilities);
- reset(mNotificationUpdater);
+
+ // Verify that onUpstreamCapabilitiesChanged is called if current upstream network
+ // capabilities changed.
+ // Expect that capability is changed with new capability VALIDATED.
+ assertFalse(upstreamState.networkCapabilities.hasCapability(NET_CAPABILITY_VALIDATED));
+ upstreamState.networkCapabilities.addCapability(NET_CAPABILITY_VALIDATED);
+ stateMachine.handleUpstreamNetworkMonitorCallback(EVENT_ON_CAPABILITIES, upstreamState);
+ inOrder.verify(mNotificationUpdater)
+ .onUpstreamCapabilitiesChanged(upstreamState.networkCapabilities);
// Verify that onUpstreamCapabilitiesChanged won't be called if not current upstream network
// capabilities changed.
@@ -2714,7 +2747,7 @@
upstreamState.linkProperties, upstreamState.networkCapabilities,
new Network(WIFI_NETID));
stateMachine.handleUpstreamNetworkMonitorCallback(EVENT_ON_CAPABILITIES, upstreamState2);
- verify(mNotificationUpdater, never()).onUpstreamCapabilitiesChanged(any());
+ inOrder.verify(mNotificationUpdater, never()).onUpstreamCapabilitiesChanged(any());
}
@Test
diff --git a/bpf_progs/netd.c b/bpf_progs/netd.c
index 84da79d..e068d8a 100644
--- a/bpf_progs/netd.c
+++ b/bpf_progs/netd.c
@@ -350,10 +350,10 @@
static __always_inline inline int bpf_owner_match(struct __sk_buff* skb, uint32_t uid,
bool egress, const unsigned kver) {
- if (skip_owner_match(skb, kver)) return PASS;
-
if (is_system_uid(uid)) return PASS;
+ if (skip_owner_match(skb, kver)) return PASS;
+
BpfConfig enabledRules = getConfig(UID_RULES_CONFIGURATION_KEY);
UidOwnerValue* uidEntry = bpf_uid_owner_map_lookup_elem(&uid);
@@ -415,11 +415,6 @@
}
int match = bpf_owner_match(skb, sock_uid, egress, kver);
- if (egress && (match == DROP)) {
- // If an outbound packet is going to be dropped, we do not count that
- // traffic.
- return match;
- }
// Workaround for secureVPN with VpnIsolation enabled, refer to b/159994981 for details.
// Keep TAG_SYSTEM_DNS in sync with DnsResolver/include/netd_resolv/resolv.h
@@ -432,6 +427,9 @@
if (match == DROP_UNLESS_DNS) match = DROP;
}
+ // If an outbound packet is going to be dropped, we do not count that traffic.
+ if (egress && (match == DROP)) return DROP;
+
StatsKey key = {.uid = uid, .tag = tag, .counterSet = 0, .ifaceIndex = skb->ifindex};
uint8_t* counterSet = bpf_uid_counterset_map_lookup_elem(&uid);
diff --git a/framework-t/Android.bp b/framework-t/Android.bp
index d40fad9..7ef20c5 100644
--- a/framework-t/Android.bp
+++ b/framework-t/Android.bp
@@ -164,6 +164,7 @@
],
}
+// This rule is not used anymore(b/268440216).
platform_compat_config {
name: "connectivity-t-platform-compat-config",
src: ":framework-connectivity-t",
diff --git a/framework-t/src/android/net/NetworkStatsAccess.java b/framework-t/src/android/net/NetworkStatsAccess.java
index b64fbdb..0585756 100644
--- a/framework-t/src/android/net/NetworkStatsAccess.java
+++ b/framework-t/src/android/net/NetworkStatsAccess.java
@@ -111,17 +111,18 @@
final DevicePolicyManager mDpm = context.getSystemService(DevicePolicyManager.class);
final TelephonyManager tm = (TelephonyManager)
context.getSystemService(Context.TELEPHONY_SERVICE);
- boolean hasCarrierPrivileges;
- final long token = Binder.clearCallingIdentity();
+ final boolean hasCarrierPrivileges;
+ final boolean isDeviceOwner;
+ long token = Binder.clearCallingIdentity();
try {
hasCarrierPrivileges = tm != null
&& tm.checkCarrierPrivilegesForPackageAnyPhone(callingPackage)
== TelephonyManager.CARRIER_PRIVILEGE_STATUS_HAS_ACCESS;
+ isDeviceOwner = mDpm != null && mDpm.isDeviceOwnerApp(callingPackage);
} finally {
Binder.restoreCallingIdentity(token);
}
- final boolean isDeviceOwner = mDpm != null && mDpm.isDeviceOwnerApp(callingPackage);
final int appId = UserHandle.getAppId(callingUid);
final boolean isNetworkStack = context.checkPermission(
@@ -135,15 +136,20 @@
return NetworkStatsAccess.Level.DEVICE;
}
- boolean hasAppOpsPermission = hasAppOpsPermission(context, callingUid, callingPackage);
+ final boolean hasAppOpsPermission =
+ hasAppOpsPermission(context, callingUid, callingPackage);
if (hasAppOpsPermission || context.checkCallingOrSelfPermission(
READ_NETWORK_USAGE_HISTORY) == PackageManager.PERMISSION_GRANTED) {
return NetworkStatsAccess.Level.DEVICESUMMARY;
}
- //TODO(b/169395065) Figure out if this flow makes sense in Device Owner mode.
- boolean isProfileOwner = mDpm != null && (mDpm.isProfileOwnerApp(callingPackage)
- || mDpm.isDeviceOwnerApp(callingPackage));
+ final boolean isProfileOwner;
+ token = Binder.clearCallingIdentity();
+ try {
+ isProfileOwner = mDpm != null && mDpm.isProfileOwnerApp(callingPackage);
+ } finally {
+ Binder.restoreCallingIdentity(token);
+ }
if (isProfileOwner) {
// Apps with the AppOps permission, profile owners, and apps with the privileged
// permission can access data usage for all apps in this user/profile.
diff --git a/framework-t/src/android/net/NetworkTemplate.java b/framework-t/src/android/net/NetworkTemplate.java
index f633a8f..55fcc4a 100644
--- a/framework-t/src/android/net/NetworkTemplate.java
+++ b/framework-t/src/android/net/NetworkTemplate.java
@@ -48,8 +48,10 @@
import android.os.Parcel;
import android.os.Parcelable;
import android.util.ArraySet;
+import android.util.Log;
import com.android.internal.annotations.VisibleForTesting;
+import com.android.modules.utils.build.SdkLevel;
import com.android.net.module.util.CollectionUtils;
import com.android.net.module.util.NetworkIdentityUtils;
@@ -70,6 +72,8 @@
*/
@SystemApi(client = MODULE_LIBRARIES)
public final class NetworkTemplate implements Parcelable {
+ private static final String TAG = NetworkTemplate.class.getSimpleName();
+
/** @hide */
@Retention(RetentionPolicy.SOURCE)
@IntDef(prefix = { "MATCH_" }, value = {
@@ -243,6 +247,38 @@
return new NetworkTemplate.Builder(MATCH_ETHERNET).build();
}
+ /**
+ * Template to combine all {@link ConnectivityManager#TYPE_BLUETOOTH} style
+ * networks together.
+ *
+ * @hide
+ */
+ // TODO(b/270089918): Remove this method. This can only be done after there are no more callers,
+ // including in OEM code which can access this by linking against the framework.
+ public static NetworkTemplate buildTemplateBluetooth() {
+ if (SdkLevel.isAtLeastU()) {
+ throw new UnsupportedOperationException(
+ "buildTemplateBluetooth is not supported on Android U devices or above");
+ }
+ return new NetworkTemplate.Builder(MATCH_BLUETOOTH).build();
+ }
+
+ /**
+ * Template to combine all {@link ConnectivityManager#TYPE_PROXY} style
+ * networks together.
+ *
+ * @hide
+ */
+ // TODO(b/270089918): Remove this method. This can only be done after there are no more callers,
+ // including in OEM code which can access this by linking against the framework.
+ public static NetworkTemplate buildTemplateProxy() {
+ if (SdkLevel.isAtLeastU()) {
+ throw new UnsupportedOperationException(
+ "buildTemplateProxy is not supported on Android U devices or above");
+ }
+ return new NetworkTemplate(MATCH_PROXY, null, null);
+ }
+
private final int mMatchRule;
/**
@@ -270,12 +306,17 @@
private static void checkValidMatchSubscriberIds(int matchRule, String[] matchSubscriberIds) {
switch (matchRule) {
+ // CARRIER templates must always specify a valid subscriber ID.
+ // MOBILE templates can have empty matchSubscriberIds but it must not contain a null
+ // subscriber ID.
case MATCH_CARRIER:
- // CARRIER templates must always specify a valid subscriber ID.
if (matchSubscriberIds.length == 0) {
throw new IllegalArgumentException("checkValidMatchSubscriberIds with empty"
+ " list of ids for rule" + getMatchRuleName(matchRule));
- } else if (CollectionUtils.contains(matchSubscriberIds, null)) {
+ }
+ // fall through
+ case MATCH_MOBILE:
+ if (CollectionUtils.contains(matchSubscriberIds, null)) {
throw new IllegalArgumentException("checkValidMatchSubscriberIds list of ids"
+ " may not contain null for rule " + getMatchRuleName(matchRule));
}
@@ -296,12 +337,77 @@
// Older versions used to only match MATCH_MOBILE and MATCH_MOBILE_WILDCARD templates
// to metered networks. It is now possible to match mobile with any meteredness, but
// in order to preserve backward compatibility of @UnsupportedAppUsage methods, this
- //constructor passes METERED_YES for these types.
- this(matchRule, new String[] { subscriberId },
+ // constructor passes METERED_YES for these types.
+ // For backwards compatibility, still accept old wildcard match rules (6 and 7 for
+ // MATCH_{MOBILE,WIFI}_WILDCARD) but convert into functionally equivalent non-wildcard
+ // ones.
+ this(getBackwardsCompatibleMatchRule(matchRule),
+ subscriberId != null ? new String[] { subscriberId } : new String[0],
wifiNetworkKey != null ? new String[] { wifiNetworkKey } : new String[0],
- (matchRule == MATCH_MOBILE || matchRule == MATCH_CARRIER)
- ? METERED_YES : METERED_ALL, ROAMING_ALL, DEFAULT_NETWORK_ALL,
- NETWORK_TYPE_ALL, OEM_MANAGED_ALL);
+ getMeterednessForBackwardsCompatibility(matchRule), ROAMING_ALL,
+ DEFAULT_NETWORK_ALL, NETWORK_TYPE_ALL, OEM_MANAGED_ALL);
+ if (matchRule == 6 || matchRule == 7) {
+ Log.e(TAG, "Use MATCH_MOBILE with empty subscriberIds or MATCH_WIFI with empty "
+ + "wifiNetworkKeys instead of template with matchRule=" + matchRule);
+ if (SdkLevel.isAtLeastU()) {
+ throw new UnsupportedOperationException(
+ "Wildcard templates are not supported on Android U devices or above");
+ }
+ }
+ }
+
+ private static int getBackwardsCompatibleMatchRule(int matchRule) {
+ // Backwards compatibility old constants
+ // Old MATCH_MOBILE_WILDCARD
+ if (6 == matchRule) return MATCH_MOBILE;
+ // Old MATCH_WIFI_WILDCARD
+ if (7 == matchRule) return MATCH_WIFI;
+ return matchRule;
+ }
+
+ private static int getMeterednessForBackwardsCompatibility(int matchRule) {
+ if (getBackwardsCompatibleMatchRule(matchRule) == MATCH_MOBILE
+ || matchRule == MATCH_CARRIER) {
+ return METERED_YES;
+ }
+ return METERED_ALL;
+ }
+
+ /** @hide */
+ // TODO(b/270089918): Remove this method after no callers.
+ public NetworkTemplate(int matchRule, String subscriberId, String[] matchSubscriberIds,
+ String wifiNetworkKey) {
+ // Older versions used to only match MATCH_MOBILE and MATCH_MOBILE_WILDCARD templates
+ // to metered networks. It is now possible to match mobile with any meteredness, but
+ // in order to preserve backward compatibility of @UnsupportedAppUsage methods, this
+ // constructor passes METERED_YES for these types.
+ this(getBackwardsCompatibleMatchRule(matchRule), matchSubscriberIds,
+ wifiNetworkKey != null ? new String[] { wifiNetworkKey } : new String[0],
+ getMeterednessForBackwardsCompatibility(matchRule),
+ ROAMING_ALL, DEFAULT_NETWORK_ALL, NETWORK_TYPE_ALL,
+ OEM_MANAGED_ALL);
+ if (SdkLevel.isAtLeastU()) {
+ throw new UnsupportedOperationException(
+ "This constructor is not supported on Android U devices or above");
+ }
+ }
+
+ /** @hide */
+ // TODO(b/269974916): Remove this method after Android U is released.
+ // This is only used by CTS of Android T.
+ public NetworkTemplate(int matchRule, String subscriberId, String[] matchSubscriberIds,
+ String[] matchWifiNetworkKeys, int metered, int roaming,
+ int defaultNetwork, int ratType, int oemManaged, int subscriberIdMatchRule) {
+ // subscriberId and subscriberIdMatchRule aren't used since they are replaced by
+ // matchSubscriberIds, which could be null to indicate the intention of matching any
+ // subscriberIds.
+ this(getBackwardsCompatibleMatchRule(matchRule),
+ matchSubscriberIds == null ? new String[]{} : matchSubscriberIds,
+ matchWifiNetworkKeys, metered, roaming, defaultNetwork, ratType, oemManaged);
+ if (SdkLevel.isAtLeastU()) {
+ throw new UnsupportedOperationException(
+ "This constructor is not supported on Android U devices or above");
+ }
}
/** @hide */
@@ -383,8 +489,9 @@
@Override
public int hashCode() {
- return Objects.hash(mMatchRule, Arrays.hashCode(mMatchWifiNetworkKeys),
- mMetered, mRoaming, mDefaultNetwork, mRatType, mOemManaged);
+ return Objects.hash(mMatchRule, Arrays.hashCode(mMatchSubscriberIds),
+ Arrays.hashCode(mMatchWifiNetworkKeys), mMetered, mRoaming, mDefaultNetwork,
+ mRatType, mOemManaged);
}
@Override
@@ -397,11 +504,30 @@
&& mDefaultNetwork == other.mDefaultNetwork
&& mRatType == other.mRatType
&& mOemManaged == other.mOemManaged
+ && Arrays.equals(mMatchSubscriberIds, other.mMatchSubscriberIds)
&& Arrays.equals(mMatchWifiNetworkKeys, other.mMatchWifiNetworkKeys);
}
return false;
}
+ // TODO(b/270089918): Remove this method. This can only be done after there are no more callers,
+ // including in OEM code which can access this by linking against the framework.
+ /** @hide */
+ public boolean isMatchRuleMobile() {
+ if (SdkLevel.isAtLeastU()) {
+ throw new UnsupportedOperationException(
+ "isMatchRuleMobile is not supported on Android U devices or above");
+ }
+ switch (mMatchRule) {
+ case MATCH_MOBILE:
+ // Old MATCH_MOBILE_WILDCARD
+ case 6:
+ return true;
+ default:
+ return false;
+ }
+ }
+
/**
* Get match rule of the template. See {@code MATCH_*}.
*/
diff --git a/framework-t/src/android/net/nsd/NsdManager.java b/framework-t/src/android/net/nsd/NsdManager.java
index e38ae8e..b4f8897 100644
--- a/framework-t/src/android/net/nsd/NsdManager.java
+++ b/framework-t/src/android/net/nsd/NsdManager.java
@@ -16,6 +16,8 @@
package android.net.nsd;
+import static android.net.connectivity.ConnectivityCompatChanges.RUN_NATIVE_NSD_ONLY_IF_LEGACY_APPS_T_AND_LATER;
+
import android.annotation.IntDef;
import android.annotation.NonNull;
import android.annotation.Nullable;
@@ -24,8 +26,6 @@
import android.annotation.SdkConstant.SdkConstantType;
import android.annotation.SystemService;
import android.app.compat.CompatChanges;
-import android.compat.annotation.ChangeId;
-import android.compat.annotation.EnabledSince;
import android.content.Context;
import android.net.ConnectivityManager;
import android.net.ConnectivityManager.NetworkCallback;
@@ -137,28 +137,6 @@
private static final boolean DBG = false;
/**
- * When enabled, apps targeting < Android 12 are considered legacy for
- * the NSD native daemon.
- * The platform will only keep the daemon running as long as there are
- * any legacy apps connected.
- *
- * After Android 12, direct communication with the native daemon might not work since the native
- * daemon won't always stay alive. Using the NSD APIs from NsdManager as the replacement is
- * recommended.
- * Another alternative could be bundling your own mdns solutions instead of
- * depending on the system mdns native daemon.
- *
- * This compatibility change applies to Android 13 and later only. To toggle behavior on
- * Android 12 and Android 12L, use RUN_NATIVE_NSD_ONLY_IF_LEGACY_APPS.
- *
- * @hide
- */
- @ChangeId
- @EnabledSince(targetSdkVersion = android.os.Build.VERSION_CODES.S)
- // This was a platform change ID with value 191844585L before T
- public static final long RUN_NATIVE_NSD_ONLY_IF_LEGACY_APPS_T_AND_LATER = 235355681L;
-
- /**
* Broadcast intent action to indicate whether network service discovery is
* enabled or disabled. An extra {@link #EXTRA_NSD_STATE} provides the state
* information as int.
diff --git a/framework/api/current.txt b/framework/api/current.txt
index 547b7e2..672e3e2 100644
--- a/framework/api/current.txt
+++ b/framework/api/current.txt
@@ -360,6 +360,7 @@
field public static final int TRANSPORT_CELLULAR = 0; // 0x0
field public static final int TRANSPORT_ETHERNET = 3; // 0x3
field public static final int TRANSPORT_LOWPAN = 6; // 0x6
+ field public static final int TRANSPORT_THREAD = 9; // 0x9
field public static final int TRANSPORT_USB = 8; // 0x8
field public static final int TRANSPORT_VPN = 4; // 0x4
field public static final int TRANSPORT_WIFI = 1; // 0x1
diff --git a/framework/api/module-lib-current.txt b/framework/api/module-lib-current.txt
index f623b05..193bd92 100644
--- a/framework/api/module-lib-current.txt
+++ b/framework/api/module-lib-current.txt
@@ -15,7 +15,7 @@
method @Nullable @RequiresPermission(anyOf={android.net.NetworkStack.PERMISSION_MAINLINE_NETWORK_STACK, android.Manifest.permission.NETWORK_STACK, android.Manifest.permission.NETWORK_SETTINGS}) public android.net.LinkProperties getRedactedLinkPropertiesForPackage(@NonNull android.net.LinkProperties, int, @NonNull String);
method @Nullable @RequiresPermission(anyOf={android.net.NetworkStack.PERMISSION_MAINLINE_NETWORK_STACK, android.Manifest.permission.NETWORK_STACK, android.Manifest.permission.NETWORK_SETTINGS}) public android.net.NetworkCapabilities getRedactedNetworkCapabilitiesForPackage(@NonNull android.net.NetworkCapabilities, int, @NonNull String);
method @RequiresPermission(anyOf={android.net.NetworkStack.PERMISSION_MAINLINE_NETWORK_STACK, android.Manifest.permission.NETWORK_SETTINGS}) public void registerDefaultNetworkCallbackForUid(int, @NonNull android.net.ConnectivityManager.NetworkCallback, @NonNull android.os.Handler);
- method @RequiresPermission(anyOf={android.net.NetworkStack.PERMISSION_MAINLINE_NETWORK_STACK, android.Manifest.permission.NETWORK_SETTINGS, android.Manifest.permission.CONNECTIVITY_USE_RESTRICTED_NETWORKS}) public void registerSystemDefaultNetworkCallback(@NonNull android.net.ConnectivityManager.NetworkCallback, @NonNull android.os.Handler);
+ method @RequiresPermission(anyOf={android.net.NetworkStack.PERMISSION_MAINLINE_NETWORK_STACK, android.Manifest.permission.NETWORK_SETTINGS, android.Manifest.permission.NETWORK_SETUP_WIZARD, android.Manifest.permission.CONNECTIVITY_USE_RESTRICTED_NETWORKS}) public void registerSystemDefaultNetworkCallback(@NonNull android.net.ConnectivityManager.NetworkCallback, @NonNull android.os.Handler);
method @RequiresPermission(anyOf={android.Manifest.permission.NETWORK_SETTINGS, android.Manifest.permission.NETWORK_STACK, android.net.NetworkStack.PERMISSION_MAINLINE_NETWORK_STACK}) public void removeUidFromMeteredNetworkAllowList(int);
method @RequiresPermission(anyOf={android.Manifest.permission.NETWORK_SETTINGS, android.Manifest.permission.NETWORK_STACK, android.net.NetworkStack.PERMISSION_MAINLINE_NETWORK_STACK}) public void removeUidFromMeteredNetworkDenyList(int);
method @RequiresPermission(anyOf={android.Manifest.permission.NETWORK_SETTINGS, android.Manifest.permission.NETWORK_STACK, android.net.NetworkStack.PERMISSION_MAINLINE_NETWORK_STACK}) public void replaceFirewallChain(int, @NonNull int[]);
diff --git a/framework/api/system-current.txt b/framework/api/system-current.txt
index 0b03983..196e023 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);
+ method public final void start(@IntRange(from=0xa, to=0xe10) int, int, @NonNull 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/ConnectivityManager.java b/framework/src/android/net/ConnectivityManager.java
index 96ab0e5..381a18a 100644
--- a/framework/src/android/net/ConnectivityManager.java
+++ b/framework/src/android/net/ConnectivityManager.java
@@ -1502,6 +1502,22 @@
}
/**
+ * Temporarily set automaticOnOff keeplaive TCP polling alarm timer to 1 second.
+ *
+ * TODO: Remove this when the TCP polling design is replaced with callback.
+ * @param timeMs The time of expiry, with System.currentTimeMillis() base. The value should be
+ * set no more than 5 minutes in the future.
+ * @hide
+ */
+ public void setTestLowTcpPollingTimerForKeepalive(long timeMs) {
+ try {
+ mService.setTestLowTcpPollingTimerForKeepalive(timeMs);
+ } catch (RemoteException e) {
+ throw e.rethrowFromSystemServer();
+ }
+ }
+
+ /**
* Informs ConnectivityService of whether the legacy lockdown VPN, as implemented by
* LockdownVpnTracker, is in use. This is deprecated for new devices starting from Android 12
* but is still supported for backwards compatibility.
@@ -2213,9 +2229,13 @@
/** The requested keepalive was successfully started. */
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
public void onStarted() {}
+ /** The keepalive was resumed after being paused by the system. */
+ public void onResumed() {}
/** The keepalive was successfully stopped. */
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
public void onStopped() {}
+ /** The keepalive was paused automatically by the system. */
+ public void onPaused() {}
/** An error occurred. */
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
public void onError(int error) {}
@@ -2314,6 +2334,18 @@
}
@Override
+ public void onResumed() {
+ final long token = Binder.clearCallingIdentity();
+ try {
+ mExecutor.execute(() -> {
+ callback.onResumed();
+ });
+ } finally {
+ Binder.restoreCallingIdentity(token);
+ }
+ }
+
+ @Override
public void onStopped() {
final long token = Binder.clearCallingIdentity();
try {
@@ -2327,6 +2359,19 @@
}
@Override
+ public void onPaused() {
+ final long token = Binder.clearCallingIdentity();
+ try {
+ mExecutor.execute(() -> {
+ callback.onPaused();
+ });
+ } finally {
+ Binder.restoreCallingIdentity(token);
+ }
+ mExecutor.shutdown();
+ }
+
+ @Override
public void onError(int error) {
final long token = Binder.clearCallingIdentity();
try {
@@ -4856,6 +4901,7 @@
@RequiresPermission(anyOf = {
NetworkStack.PERMISSION_MAINLINE_NETWORK_STACK,
android.Manifest.permission.NETWORK_SETTINGS,
+ android.Manifest.permission.NETWORK_SETUP_WIZARD,
android.Manifest.permission.CONNECTIVITY_USE_RESTRICTED_NETWORKS})
public void registerSystemDefaultNetworkCallback(@NonNull NetworkCallback networkCallback,
@NonNull Handler handler) {
@@ -5990,6 +6036,30 @@
}
/**
+ * Get firewall rule of specified firewall chain on specified uid.
+ *
+ * @param chain target chain.
+ * @param uid target uid
+ * @return either FIREWALL_RULE_ALLOW or FIREWALL_RULE_DENY
+ * @throws UnsupportedOperationException if called on pre-T devices.
+ * @throws ServiceSpecificException in case of failure, with an error code indicating the
+ * cause of the failure.
+ * @hide
+ */
+ @RequiresPermission(anyOf = {
+ android.Manifest.permission.NETWORK_SETTINGS,
+ android.Manifest.permission.NETWORK_STACK,
+ NetworkStack.PERMISSION_MAINLINE_NETWORK_STACK
+ })
+ public int getUidFirewallRule(@FirewallChain final int chain, final int uid) {
+ try {
+ return mService.getUidFirewallRule(chain, uid);
+ } catch (RemoteException e) {
+ throw e.rethrowFromSystemServer();
+ }
+ }
+
+ /**
* Enables or disables the specified firewall chain.
*
* @param chain target chain.
diff --git a/framework/src/android/net/IConnectivityManager.aidl b/framework/src/android/net/IConnectivityManager.aidl
index acbc31e..1372e9a 100644
--- a/framework/src/android/net/IConnectivityManager.aidl
+++ b/framework/src/android/net/IConnectivityManager.aidl
@@ -188,7 +188,7 @@
void startNattKeepaliveWithFd(in Network network, in ParcelFileDescriptor pfd, int resourceId,
int intervalSeconds, in ISocketKeepaliveCallback cb, String srcAddr,
- String dstAddr, boolean automaticOnOffKeepalives);
+ String dstAddr, boolean automaticOnOffKeepalives, in Network underpinnedNetwork);
void startTcpKeepalive(in Network network, in ParcelFileDescriptor pfd, int intervalSeconds,
in ISocketKeepaliveCallback cb);
@@ -242,6 +242,8 @@
void setUidFirewallRule(int chain, int uid, int rule);
+ int getUidFirewallRule(int chain, int uid);
+
void setFirewallChainEnabled(int chain, boolean enable);
boolean getFirewallChainEnabled(int chain);
@@ -251,4 +253,6 @@
IBinder getCompanionDeviceManagerProxyService();
void setVpnNetworkPreference(String session, in UidRange[] ranges);
+
+ void setTestLowTcpPollingTimerForKeepalive(long timeMs);
}
diff --git a/framework/src/android/net/ISocketKeepaliveCallback.aidl b/framework/src/android/net/ISocketKeepaliveCallback.aidl
index 1240e37..0a1de6c 100644
--- a/framework/src/android/net/ISocketKeepaliveCallback.aidl
+++ b/framework/src/android/net/ISocketKeepaliveCallback.aidl
@@ -31,4 +31,8 @@
void onError(int error);
/** The keepalive on a TCP socket was stopped because the socket received data. */
void onDataReceived();
+ /** The keepalive was paused by the system because it's not necessary right now. */
+ void onPaused();
+ /** The keepalive was resumed by the system after being suspended. */
+ void onResumed();
}
diff --git a/framework/src/android/net/LinkProperties.java b/framework/src/android/net/LinkProperties.java
index b7ee846..e0926e9 100644
--- a/framework/src/android/net/LinkProperties.java
+++ b/framework/src/android/net/LinkProperties.java
@@ -16,19 +16,18 @@
package android.net;
+import static android.net.connectivity.ConnectivityCompatChanges.EXCLUDED_ROUTES;
+
import android.annotation.NonNull;
import android.annotation.Nullable;
import android.annotation.SystemApi;
import android.app.compat.CompatChanges;
-import android.compat.annotation.ChangeId;
-import android.compat.annotation.EnabledAfter;
import android.compat.annotation.UnsupportedAppUsage;
import android.os.Build;
import android.os.Parcel;
import android.os.Parcelable;
import android.text.TextUtils;
-import com.android.internal.annotations.VisibleForTesting;
import com.android.modules.utils.build.SdkLevel;
import com.android.net.module.util.CollectionUtils;
import com.android.net.module.util.LinkPropertiesUtils;
@@ -58,17 +57,6 @@
*
*/
public final class LinkProperties implements Parcelable {
- /**
- * The {@link #getRoutes()} now can contain excluded as well as included routes. Use
- * {@link RouteInfo#getType()} to determine route type.
- *
- * @hide
- */
- @ChangeId
- @EnabledAfter(targetSdkVersion = Build.VERSION_CODES.S_V2)
- @VisibleForTesting
- public static final long EXCLUDED_ROUTES = 186082280;
-
// The interface described by the network link.
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P, trackingBug = 115609023)
private String mIfaceName;
diff --git a/framework/src/android/net/NattSocketKeepalive.java b/framework/src/android/net/NattSocketKeepalive.java
index 77137f4..a83b5b4 100644
--- a/framework/src/android/net/NattSocketKeepalive.java
+++ b/framework/src/android/net/NattSocketKeepalive.java
@@ -66,10 +66,12 @@
* 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.
+ *
* @hide
*/
@Override
- protected void startImpl(int intervalSec, int flags) {
+ protected void startImpl(int intervalSec, int flags, Network underpinnedNetwork) {
if (0 != (flags & ~FLAG_AUTOMATIC_ON_OFF)) {
throw new IllegalArgumentException("Illegal flag value for "
+ this.getClass().getSimpleName() + " : " + flags);
@@ -79,7 +81,8 @@
try {
mService.startNattKeepaliveWithFd(mNetwork, mPfd, mResourceId,
intervalSec, mCallback, mSource.getHostAddress(),
- mDestination.getHostAddress(), automaticOnOffKeepalives);
+ mDestination.getHostAddress(), automaticOnOffKeepalives,
+ underpinnedNetwork);
} catch (RemoteException e) {
Log.e(TAG, "Error starting socket keepalive: ", e);
throw e.rethrowFromSystemServer();
diff --git a/framework/src/android/net/NetworkCapabilities.java b/framework/src/android/net/NetworkCapabilities.java
index e70d75d..324f565 100644
--- a/framework/src/android/net/NetworkCapabilities.java
+++ b/framework/src/android/net/NetworkCapabilities.java
@@ -53,18 +53,70 @@
import java.util.StringJoiner;
/**
- * Representation of the capabilities of an active network. Instances are
- * typically obtained through
- * {@link NetworkCallback#onCapabilitiesChanged(Network, NetworkCapabilities)}
- * or {@link ConnectivityManager#getNetworkCapabilities(Network)}.
- * <p>
- * This replaces the old {@link ConnectivityManager#TYPE_MOBILE} method of
- * network selection. Rather than indicate a need for Wi-Fi because an
- * application needs high bandwidth and risk obsolescence when a new, fast
- * network appears (like LTE), the application should specify it needs high
- * bandwidth. Similarly if an application needs an unmetered network for a bulk
- * transfer it can specify that rather than assuming all cellular based
- * connections are metered and all Wi-Fi based connections are not.
+ * Representation of the capabilities of an active network.
+ *
+ * <p>@see <a href="https://developer.android.com/training/basics/network-ops/reading-network-state>
+ * this general guide</a> on how to use NetworkCapabilities and related classes.
+ *
+ * <p>NetworkCapabilities represent what a network can do and what its
+ * characteristics are like. The principal attribute of NetworkCapabilities
+ * is in the capabilities bits, which are checked with
+ * {@link #hasCapability(int)}. See the list of capabilities and each
+ * capability for a description of what it means.
+ *
+ * <p>Some prime examples include {@code NET_CAPABILITY_MMS}, which means that the
+ * network is capable of sending MMS. A network without this capability
+ * is not capable of sending MMS.
+ * <p>The {@code NET_CAPABILITY_INTERNET} capability means that the network is
+ * configured to reach the general Internet. It may or may not actually
+ * provide connectivity ; the {@code NET_CAPABILITY_VALIDATED} bit indicates that
+ * the system found actual connectivity to the general Internet the last
+ * time it checked. Apps interested in actual connectivity should usually
+ * look at both these capabilities.
+ * <p>The {@code NET_CAPABILITY_NOT_METERED} capability is set for networks that
+ * do not bill the user for consumption of bytes. Applications are
+ * encouraged to consult this to determine appropriate usage, and to
+ * limit usage of metered network where possible, including deferring
+ * big downloads until such a time that an unmetered network is connected.
+ * Also see {@link android.app.job.JobScheduler} to help with scheduling such
+ * downloads, in particular
+ * {@link android.app.job.JobInfo.Builder#setRequiredNetwork(NetworkRequest)}.
+ * <p>NetworkCapabilities contain a number of other capabilities that
+ * represent what modern networks can and can't do. Look up the individual
+ * capabilities in this class to learn about each of them.
+ *
+ * <p>NetworkCapabilities typically represent attributes that can apply to
+ * any network. The attributes that apply only to specific transports like
+ * cellular or Wi-Fi can be found in the specifier (for requestable attributes)
+ * or in the transport info (for non-requestable ones). See
+ * {@link #getNetworkSpecifier} and {@link #getTransportInfo}. An app would
+ * downcast these to the specific class for the transport they need if they
+ * are interested in transport-specific attributes. Also see
+ * {@link android.net.wifi.WifiNetworkSpecifier} or
+ * {@link android.net.wifi.WifiInfo} for some examples of each of these.
+ *
+ * <p>NetworkCapabilities also contains other attributes like the estimated
+ * upstream and downstream bandwidth and the specific transport of that
+ * network (e.g. {@link #TRANSPORT_CELLULAR}). Generally, apps should normally
+ * have little reason to check for the type of transport ; for example, to
+ * query whether a network costs money to the user, do not look at the
+ * transport, but instead look at the absence or presence of
+ * {@link #NET_CAPABILITY_NOT_METERED} which will correctly account for
+ * metered Wi-Fis and free of charge cell connections.
+ *
+ * <p>The system communicates with apps about connected networks and uses
+ * NetworkCapabilities to express these capabilities about these networks.
+ * Apps should register callbacks with the {@link ConnectivityManager#requestNetwork}
+ * or {@link ConnectivityManager#registerNetworkCallback} family of methods
+ * to learn about the capabilities of a network on a continuous basis
+ * and be able to react to changes to capabilities. For quick debugging Android also
+ * provides {@link ConnectivityManager#getNetworkCapabilities(Network)},
+ * but the dynamic nature of networking makes this ill-suited to production
+ * code since capabilities obtained in this way can go stale immediately.
+ *
+ * <p>Also see {@link NetworkRequest} which uses the same capabilities
+ * together with {@link ConnectivityManager#requestNetwork} for how to
+ * request the system brings up the kind of network your application needs.
*/
public final class NetworkCapabilities implements Parcelable {
private static final String TAG = "NetworkCapabilities";
@@ -622,11 +674,19 @@
/**
* Indicates that this network should be able to prioritize latency for the internet.
+ *
+ * Starting with {@link Build.VERSION_CODES#UPSIDE_DOWN_CAKE}, requesting this capability with
+ * {@link ConnectivityManager#requestNetwork} requires declaration in the self-certified
+ * network capabilities. See {@link NetworkRequest} for the self-certification documentation.
*/
public static final int NET_CAPABILITY_PRIORITIZE_LATENCY = 34;
/**
* Indicates that this network should be able to prioritize bandwidth for the internet.
+ *
+ * Starting with {@link Build.VERSION_CODES#UPSIDE_DOWN_CAKE}, requesting this capability with
+ * {@link ConnectivityManager#requestNetwork} requires declaration in the self-certified
+ * network capabilities. See {@link NetworkRequest} for the self-certification documentation.
*/
public static final int NET_CAPABILITY_PRIORITIZE_BANDWIDTH = 35;
@@ -1110,6 +1170,7 @@
TRANSPORT_LOWPAN,
TRANSPORT_TEST,
TRANSPORT_USB,
+ TRANSPORT_THREAD,
})
public @interface Transport { }
@@ -1161,10 +1222,15 @@
*/
public static final int TRANSPORT_USB = 8;
+ /**
+ * Indicates this network uses a Thread transport.
+ */
+ public static final int TRANSPORT_THREAD = 9;
+
/** @hide */
public static final int MIN_TRANSPORT = TRANSPORT_CELLULAR;
/** @hide */
- public static final int MAX_TRANSPORT = TRANSPORT_USB;
+ public static final int MAX_TRANSPORT = TRANSPORT_THREAD;
private static final int ALL_VALID_TRANSPORTS;
static {
@@ -1189,7 +1255,8 @@
"WIFI_AWARE",
"LOWPAN",
"TEST",
- "USB"
+ "USB",
+ "THREAD",
};
/**
diff --git a/framework/src/android/net/NetworkRequest.java b/framework/src/android/net/NetworkRequest.java
index b7a6076..6c351d0 100644
--- a/framework/src/android/net/NetworkRequest.java
+++ b/framework/src/android/net/NetworkRequest.java
@@ -54,9 +54,92 @@
import java.util.Set;
/**
- * Defines a request for a network, made through {@link NetworkRequest.Builder} and used
- * to request a network via {@link ConnectivityManager#requestNetwork} or listen for changes
- * via {@link ConnectivityManager#registerNetworkCallback}.
+ * An object describing a network that the application is interested in.
+ *
+ * <p>@see <a href="https://developer.android.com/training/basics/network-ops/reading-network-state>
+ * this general guide</a> on how to use NetworkCapabilities and related classes.
+ *
+ * NetworkRequest defines a request for a network, made through
+ * {@link NetworkRequest.Builder} and used to request a network via
+ * {@link ConnectivityManager#requestNetwork} or to listen for changes
+ * via the {@link ConnectivityManager#registerNetworkCallback} family of
+ * functions.
+ *
+ * <p>{@link ConnectivityManager#requestNetwork} will try to find a connected
+ * network matching the NetworkRequest, and return it if there is one.
+ * As long as the request is outstanding, the system will try to find the best
+ * possible network that matches the request. The request will keep up the
+ * currently best connected network, and if a better one is found (e.g. cheaper
+ * or faster) the system will bring up that better network to better serve the
+ * request. A request filed with {@link ConnectivityManager#requestNetwork} will
+ * only match one network at a time (the one the system thinks is best), even if
+ * other networks can match the request that are being kept up by other requests.
+ *
+ * For example, an application needing a network with
+ * {@link NetworkCapabilities#NET_CAPABILITY_INTERNET} should use
+ * {@link ConnectivityManager#requestNetwork} to request the system keeps one up.
+ * A general cellular network can satisfy this request, but if the system finds
+ * a free Wi-Fi network which is expected to be faster, it will try and connect
+ * to that Wi-Fi network and switch the request over to it once it is connected.
+ * The cell network may stay connected if there are outstanding requests (from
+ * the same app or from other apps on the system) that match the cell network
+ * but not the Wi-Fi network, such as a request with {@link NetworkCapabilities#NET_CAPABILITY_MMS}.
+ *
+ * When a network is no longer needed to serve any request, the system can
+ * tear it down at any time and usually does so immediately, so make sure to
+ * keep up requests for the networks your app needs.
+ *
+ * <p>By contrast, requests filed with {@link ConnectivityManager#registerNetworkCallback}
+ * will receive callbacks for all matching networks, and will not cause the system to
+ * keep up the networks they match. Use this to listen to networks that the device is
+ * connected to, but that you don't want the system to keep up for your use case.
+ *
+ * <p>Applications build a NetworkRequest and pass it to one of the
+ * {@link ConnectivityManager} methods above together with a
+ * {@link ConnectivityManager.NetworkCallback} object. The callback
+ * will then start receiving method calls about networks that match
+ * the request.
+ *
+ * <p>Networks are brought up and/or matched according to the capabilities
+ * set in the builder. For example, a request with
+ * {@link NetworkCapabilities#NET_CAPABILITY_MMS} lets the system match
+ * and/or bring up a network that is capable to send MMS. A request with
+ * {@link NetworkCapabilities#NET_CAPABILITY_NOT_METERED} matches a network
+ * that doesn't charge the user for usage. See
+ * {@link NetworkCapabilities} for a list of capabilities and their
+ * description.
+ *
+ * <p>While all capabilities can be matched with the
+ * {@link ConnectivityManager#registerNetworkCallback} family of methods,
+ * not all capabilities can be used to request that the system brings
+ * up a network with {@link ConnectivityManager#requestNetwork}. For example,
+ * an application cannot use {@link ConnectivityManager#requestNetwork} to
+ * ask the system to bring up a network with
+ * {@link NetworkCapabilities#NET_CAPABILITY_CAPTIVE_PORTAL}, because the
+ * system won't know if a network has a captive portal before it connects
+ * to that network. Similarly, some capabilities may require a specific
+ * permission or privilege to be requested.
+ *
+ * Look up the specific capability and the {@link ConnectivityManager#requestNetwork}
+ * method for limitations applicable to each capability.
+ *
+ * <p>Also, starting with {@link Build.VERSION_CODES#UPSIDE_DOWN_CAKE}, some capabilities
+ * require the application to self-certify by explicitly adding the
+ * {@link android.content.pm.PackageManager#PROPERTY_SELF_CERTIFIED_NETWORK_CAPABILITIES}
+ * property in the AndroidManifest.xml, which points to an XML resource file. In the
+ * XML resource file, the application declares what kind of network capabilities the application
+ * wants to have.
+ *
+ * Here is an example self-certification XML resource file :
+ * <pre>
+ * {@code
+ * <network-capabilities-declaration xmlns:android="http://schemas.android.com/apk/res/android">
+ * <uses-network-capability android:name="NET_CAPABILITY_PRIORITIZE_LATENCY"/>
+ * <uses-network-capability android:name="NET_CAPABILITY_PRIORITIZE_BANDWIDTH"/>
+ * </network-capabilities-declaration>
+ * }
+ * </pre>
+ * Look up the specific capability to learn whether its usage requires this self-certification.
*/
public class NetworkRequest implements Parcelable {
/**
diff --git a/framework/src/android/net/SocketKeepalive.java b/framework/src/android/net/SocketKeepalive.java
index 2911ce7..311126e 100644
--- a/framework/src/android/net/SocketKeepalive.java
+++ b/framework/src/android/net/SocketKeepalive.java
@@ -64,6 +64,12 @@
public static final int SUCCESS = 0;
/**
+ * Success when trying to suspend.
+ * @hide
+ */
+ public static final int SUCCESS_PAUSED = 1;
+
+ /**
* No keepalive. This should only be internally as it indicates There is no keepalive.
* It should not propagate to applications.
* @hide
@@ -271,6 +277,18 @@
}
@Override
+ public void onResumed() {
+ final long token = Binder.clearCallingIdentity();
+ try {
+ mExecutor.execute(() -> {
+ callback.onResumed();
+ });
+ } finally {
+ Binder.restoreCallingIdentity(token);
+ }
+ }
+
+ @Override
public void onStopped() {
final long token = Binder.clearCallingIdentity();
try {
@@ -283,6 +301,18 @@
}
@Override
+ public void onPaused() {
+ final long token = Binder.clearCallingIdentity();
+ try {
+ executor.execute(() -> {
+ callback.onPaused();
+ });
+ } finally {
+ Binder.restoreCallingIdentity(token);
+ }
+ }
+
+ @Override
public void onError(int error) {
final long token = Binder.clearCallingIdentity();
try {
@@ -325,7 +355,7 @@
*/
public final void start(@IntRange(from = MIN_INTERVAL_SEC, to = MAX_INTERVAL_SEC)
int intervalSec) {
- startImpl(intervalSec, 0 /* flags */);
+ startImpl(intervalSec, 0 /* flags */, null /* underpinnedNetwork */);
}
/**
@@ -344,16 +374,18 @@
* 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.
* @hide
*/
@SystemApi(client = PRIVILEGED_APPS)
public final void start(@IntRange(from = MIN_INTERVAL_SEC, to = MAX_INTERVAL_SEC)
- int intervalSec, @StartFlags int flags) {
- startImpl(intervalSec, flags);
+ int intervalSec, @StartFlags int flags, @NonNull Network underpinnedNetwork) {
+ startImpl(intervalSec, flags, underpinnedNetwork);
}
/** @hide */
- protected abstract void startImpl(int intervalSec, @StartFlags int flags);
+ protected abstract void startImpl(int intervalSec, @StartFlags int flags,
+ Network underpinnedNetwork);
/**
* Requests that keepalive be stopped. The application must wait for {@link Callback#onStopped}
@@ -387,8 +419,18 @@
public static class Callback {
/** The requested keepalive was successfully started. */
public void onStarted() {}
+ /**
+ * The keepalive was resumed by the system after being suspended.
+ * @hide
+ **/
+ public void onResumed() {}
/** The keepalive was successfully stopped. */
public void onStopped() {}
+ /**
+ * The keepalive was paused by the system because it's not necessary right now.
+ * @hide
+ **/
+ public void onPaused() {}
/** An error occurred. */
public void onError(@ErrorCode int error) {}
/** The keepalive on a TCP socket was stopped because the socket received data. This is
diff --git a/framework/src/android/net/TcpSocketKeepalive.java b/framework/src/android/net/TcpSocketKeepalive.java
index cda5830..b548f6d 100644
--- a/framework/src/android/net/TcpSocketKeepalive.java
+++ b/framework/src/android/net/TcpSocketKeepalive.java
@@ -50,7 +50,7 @@
* acknowledgement.
*/
@Override
- protected void startImpl(int intervalSec, int flags) {
+ protected void startImpl(int intervalSec, int flags, Network underpinnedNetwork) {
if (0 != flags) {
throw new IllegalArgumentException("Illegal flag value for "
+ this.getClass().getSimpleName() + " : " + flags);
diff --git a/framework/src/android/net/connectivity/ConnectivityCompatChanges.java b/framework/src/android/net/connectivity/ConnectivityCompatChanges.java
new file mode 100644
index 0000000..2cfda9e
--- /dev/null
+++ b/framework/src/android/net/connectivity/ConnectivityCompatChanges.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (C) 2022 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.connectivity;
+
+import android.compat.annotation.ChangeId;
+import android.compat.annotation.EnabledAfter;
+import android.compat.annotation.EnabledSince;
+import android.os.Build;
+
+/**
+ * The class contains all CompatChanges for the Connectivity module.
+ *
+ * <p>This is the centralized place for the CompatChanges used in the Connectivity module.
+ * Putting all the CompatChanges in single place makes it possible to manage them under a single
+ * platform_compat_config.
+ * @hide
+ */
+public final class ConnectivityCompatChanges {
+
+ /**
+ * The {@link android.net.LinkProperties#getRoutes()} now can contain excluded as well as
+ * included routes. Use {@link android.net.RouteInfo#getType()} to determine route type.
+ *
+ * @hide
+ */
+ @ChangeId
+ @EnabledAfter(targetSdkVersion = Build.VERSION_CODES.S_V2)
+ public static final long EXCLUDED_ROUTES = 186082280;
+
+ /**
+ * When enabled, apps targeting < Android 12 are considered legacy for
+ * the NSD native daemon.
+ * The platform will only keep the daemon running as long as there are
+ * any legacy apps connected.
+ *
+ * After Android 12, direct communication with the native daemon might not work since the native
+ * daemon won't always stay alive. Using the NSD APIs from NsdManager as the replacement is
+ * recommended.
+ * Another alternative could be bundling your own mdns solutions instead of
+ * depending on the system mdns native daemon.
+ *
+ * This compatibility change applies to Android 13 and later only. To toggle behavior on
+ * Android 12 and Android 12L, use RUN_NATIVE_NSD_ONLY_IF_LEGACY_APPS.
+ *
+ * @hide
+ */
+ @ChangeId
+ @EnabledSince(targetSdkVersion = android.os.Build.VERSION_CODES.S)
+ // This was a platform change ID with value 191844585L before T
+ public static final long RUN_NATIVE_NSD_ONLY_IF_LEGACY_APPS_T_AND_LATER = 235355681L;
+
+ /**
+ * The self certified capabilities check should be enabled after android 13.
+ *
+ * <p> See {@link android.net.NetworkCapabilities} for more details.
+ *
+ * @hide
+ */
+ @ChangeId
+ @EnabledAfter(targetSdkVersion = Build.VERSION_CODES.TIRAMISU)
+ public static final long ENABLE_SELF_CERTIFIED_CAPABILITIES_DECLARATION = 266524688;
+
+ private ConnectivityCompatChanges() {
+ }
+}
diff --git a/nearby/halfsheet/res/values-ky/strings.xml b/nearby/halfsheet/res/values-ky/strings.xml
index 812e0e8..b0dfe20 100644
--- a/nearby/halfsheet/res/values-ky/strings.xml
+++ b/nearby/halfsheet/res/values-ky/strings.xml
@@ -25,5 +25,5 @@
<string name="paring_action_save" msgid="6259357442067880136">"Сактоо"</string>
<string name="paring_action_connect" msgid="4801102939608129181">"Туташуу"</string>
<string name="paring_action_launch" msgid="8940808384126591230">"Жөндөө"</string>
- <string name="paring_action_settings" msgid="424875657242864302">"Жөндөөлөр"</string>
+ <string name="paring_action_settings" msgid="424875657242864302">"Параметрлер"</string>
</resources>
diff --git a/nearby/tests/cts/fastpair/AndroidManifest.xml b/nearby/tests/cts/fastpair/AndroidManifest.xml
index 96e2783..9e1ec70 100644
--- a/nearby/tests/cts/fastpair/AndroidManifest.xml
+++ b/nearby/tests/cts/fastpair/AndroidManifest.xml
@@ -30,7 +30,5 @@
<instrumentation android:name="androidx.test.runner.AndroidJUnitRunner"
android:targetPackage="android.nearby.cts"
android:label="CTS tests for android.nearby Fast Pair">
- <meta-data android:name="listener"
- android:value="com.android.cts.runner.CtsTestRunListener"/>
</instrumentation>
</manifest>
diff --git a/netd/BpfHandler.cpp b/netd/BpfHandler.cpp
index 7950ff7..2b773c9 100644
--- a/netd/BpfHandler.cpp
+++ b/netd/BpfHandler.cpp
@@ -93,7 +93,7 @@
// cgroup if the program is pinned properly.
// TODO: delete the if statement once all devices should support cgroup
// socket filter (ie. the minimum kernel version required is 4.14).
- if (!access(CGROUP_SOCKET_PROG_PATH, F_OK)) {
+ if (bpf::isAtLeastKernelVersion(4, 14, 0)) {
RETURN_IF_NOT_OK(
attachProgramToCgroup(CGROUP_SOCKET_PROG_PATH, cg_fd, BPF_CGROUP_INET_SOCK_CREATE));
}
diff --git a/service-t/jni/com_android_server_net_NetworkStatsFactory.cpp b/service-t/jni/com_android_server_net_NetworkStatsFactory.cpp
index a3299a7..2dbe771 100644
--- a/service-t/jni/com_android_server_net_NetworkStatsFactory.cpp
+++ b/service-t/jni/com_android_server_net_NetworkStatsFactory.cpp
@@ -210,7 +210,8 @@
};
int register_android_server_net_NetworkStatsFactory(JNIEnv* env) {
- int err = jniRegisterNativeMethods(env, "com/android/server/net/NetworkStatsFactory", gMethods,
+ int err = jniRegisterNativeMethods(env,
+ "android/net/connectivity/com/android/server/net/NetworkStatsFactory", gMethods,
NELEM(gMethods));
gStringClass = env->FindClass("java/lang/String");
gStringClass = static_cast<jclass>(env->NewGlobalRef(gStringClass));
diff --git a/service-t/jni/com_android_server_net_NetworkStatsService.cpp b/service-t/jni/com_android_server_net_NetworkStatsService.cpp
index af0b8d8..dab9d07 100644
--- a/service-t/jni/com_android_server_net_NetworkStatsService.cpp
+++ b/service-t/jni/com_android_server_net_NetworkStatsService.cpp
@@ -116,8 +116,9 @@
};
int register_android_server_net_NetworkStatsService(JNIEnv* env) {
- return jniRegisterNativeMethods(env, "com/android/server/net/NetworkStatsService", gMethods,
- NELEM(gMethods));
+ return jniRegisterNativeMethods(env,
+ "android/net/connectivity/com/android/server/net/NetworkStatsService", gMethods,
+ NELEM(gMethods));
}
}
diff --git a/service-t/native/libs/libnetworkstats/NetworkTraceHandler.cpp b/service-t/native/libs/libnetworkstats/NetworkTraceHandler.cpp
index aeadb4a..be4ffe3 100644
--- a/service-t/native/libs/libnetworkstats/NetworkTraceHandler.cpp
+++ b/service-t/native/libs/libnetworkstats/NetworkTraceHandler.cpp
@@ -55,13 +55,12 @@
NetworkTraceHandler::RegisterDataSource();
}
-NetworkTraceHandler::NetworkTraceHandler()
- : NetworkTraceHandler([this](const PacketTrace& pkt) {
- NetworkTraceHandler::Trace(
- [this, pkt](NetworkTraceHandler::TraceContext ctx) {
- Fill(pkt, *ctx.NewTracePacket());
- });
- }) {}
+// static
+NetworkTracePoller NetworkTraceHandler::sPoller([](const PacketTrace& pkt) {
+ NetworkTraceHandler::Trace([pkt](NetworkTraceHandler::TraceContext ctx) {
+ NetworkTraceHandler::Fill(pkt, *ctx.NewTracePacket());
+ });
+});
void NetworkTraceHandler::OnSetup(const SetupArgs& args) {
const std::string& raw = args.config->network_packet_trace_config_raw();
@@ -75,21 +74,27 @@
}
void NetworkTraceHandler::OnStart(const StartArgs&) {
- if (!Start()) return;
- mTaskRunner = perfetto::Platform::GetDefaultPlatform()->CreateTaskRunner({});
- Loop();
+ mStarted = sPoller.Start(mPollMs);
}
void NetworkTraceHandler::OnStop(const StopArgs&) {
- Stop();
- mTaskRunner.reset();
+ if (mStarted) sPoller.Stop();
+ mStarted = false;
}
-void NetworkTraceHandler::Loop() {
- mTaskRunner->PostDelayedTask([this]() { Loop(); }, mPollMs);
- ConsumeAll();
+void NetworkTracePoller::SchedulePolling() {
+ // Schedules another run of ourselves to recursively poll periodically.
+ mTaskRunner->PostDelayedTask(
+ [this]() {
+ mMutex.lock();
+ SchedulePolling();
+ ConsumeAllLocked();
+ mMutex.unlock();
+ },
+ mPollMs);
}
+// static class method
void NetworkTraceHandler::Fill(const PacketTrace& src, TracePacket& dst) {
dst.set_timestamp(src.timestampNs);
auto* event = dst.set_network_packet();
@@ -113,9 +118,23 @@
}
}
-bool NetworkTraceHandler::Start() {
+bool NetworkTracePoller::Start(uint32_t pollMs) {
ALOGD("Starting datasource");
+ std::scoped_lock<std::mutex> lock(mMutex);
+ if (mSessionCount > 0) {
+ if (mPollMs != pollMs) {
+ // Nothing technical prevents mPollMs from changing, it's just unclear
+ // what the right behavior is. Taking the min of active values could poll
+ // too frequently giving some sessions too much data. Taking the max could
+ // be too infrequent. For now, do nothing.
+ ALOGI("poll_ms can't be changed while running, ignoring poll_ms=%d",
+ pollMs);
+ }
+ mSessionCount++;
+ return true;
+ }
+
auto status = mConfigurationMap.init(PACKET_TRACE_ENABLED_MAP_PATH);
if (!status.ok()) {
ALOGW("Failed to bind config map: %s", status.error().message().c_str());
@@ -136,24 +155,41 @@
return false;
}
+ // Start a task runner to run ConsumeAll every mPollMs milliseconds.
+ mTaskRunner = perfetto::Platform::GetDefaultPlatform()->CreateTaskRunner({});
+ mPollMs = pollMs;
+ SchedulePolling();
+
+ mSessionCount++;
return true;
}
-bool NetworkTraceHandler::Stop() {
+bool NetworkTracePoller::Stop() {
ALOGD("Stopping datasource");
+ std::scoped_lock<std::mutex> lock(mMutex);
+ if (mSessionCount == 0) return false; // This should never happen
+
+ // If this isn't the last session, don't clean up yet.
+ if (--mSessionCount > 0) return true;
+
auto res = mConfigurationMap.writeValue(0, false, BPF_ANY);
if (!res.ok()) {
ALOGW("Failed to disable tracing: %s", res.error().message().c_str());
- return false;
}
+ mTaskRunner.reset();
mRingBuffer.reset();
- return true;
+ return res.ok();
}
-bool NetworkTraceHandler::ConsumeAll() {
+bool NetworkTracePoller::ConsumeAll() {
+ std::scoped_lock<std::mutex> lock(mMutex);
+ return ConsumeAllLocked();
+}
+
+bool NetworkTracePoller::ConsumeAllLocked() {
if (mRingBuffer == nullptr) {
ALOGW("Tracing is not active");
return false;
diff --git a/service-t/native/libs/libnetworkstats/NetworkTraceHandlerTest.cpp b/service-t/native/libs/libnetworkstats/NetworkTraceHandlerTest.cpp
index 560194f..543be21 100644
--- a/service-t/native/libs/libnetworkstats/NetworkTraceHandlerTest.cpp
+++ b/service-t/native/libs/libnetworkstats/NetworkTraceHandlerTest.cpp
@@ -39,6 +39,9 @@
namespace android {
namespace bpf {
+// Use uint32 max to cause the handler to never Loop. Instead, the tests will
+// manually drive things by calling ConsumeAll explicitly.
+constexpr uint32_t kNeverPoll = std::numeric_limits<uint32_t>::max();
__be16 bindAndListen(int s) {
sockaddr_in sin = {.sin_family = AF_INET};
@@ -83,7 +86,7 @@
}
};
-class NetworkTraceHandlerTest : public testing::Test {
+class NetworkTracePollerTest : public testing::Test {
protected:
void SetUp() {
if (access(PACKET_TRACE_RINGBUF_PATH, R_OK)) {
@@ -95,31 +98,49 @@
}
};
-TEST_F(NetworkTraceHandlerTest, PollWhileInactive) {
- NetworkTraceHandler handler([&](const PacketTrace& pkt) {});
+TEST_F(NetworkTracePollerTest, PollWhileInactive) {
+ NetworkTracePoller handler([&](const PacketTrace& pkt) {});
// One succeed after start and before stop.
EXPECT_FALSE(handler.ConsumeAll());
- ASSERT_TRUE(handler.Start());
+ ASSERT_TRUE(handler.Start(kNeverPoll));
EXPECT_TRUE(handler.ConsumeAll());
ASSERT_TRUE(handler.Stop());
EXPECT_FALSE(handler.ConsumeAll());
}
-TEST_F(NetworkTraceHandlerTest, TraceTcpSession) {
+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) {});
+
+ ASSERT_TRUE(handler.Start(kNeverPoll));
+ EXPECT_TRUE(handler.ConsumeAll());
+
+ ASSERT_TRUE(handler.Start(kNeverPoll));
+ EXPECT_TRUE(handler.ConsumeAll());
+
+ ASSERT_TRUE(handler.Stop());
+ EXPECT_TRUE(handler.ConsumeAll());
+
+ ASSERT_TRUE(handler.Stop());
+ EXPECT_FALSE(handler.ConsumeAll());
+}
+
+TEST_F(NetworkTracePollerTest, TraceTcpSession) {
__be16 server_port = 0;
std::vector<PacketTrace> packets;
// 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.
- NetworkTraceHandler handler([&](const PacketTrace& pkt) {
+ NetworkTracePoller handler([&](const PacketTrace& pkt) {
if (pkt.sport != server_port && pkt.dport != server_port) return;
if (pkt.uid != getuid()) return;
packets.push_back(pkt);
});
- ASSERT_TRUE(handler.Start());
+ ASSERT_TRUE(handler.Start(kNeverPoll));
const uint32_t kClientTag = 2468;
const uint32_t kServerTag = 1357;
diff --git a/service-t/native/libs/libnetworkstats/include/netdbpf/NetworkTraceHandler.h b/service-t/native/libs/libnetworkstats/include/netdbpf/NetworkTraceHandler.h
index c257aa0..3f244b3 100644
--- a/service-t/native/libs/libnetworkstats/include/netdbpf/NetworkTraceHandler.h
+++ b/service-t/native/libs/libnetworkstats/include/netdbpf/NetworkTraceHandler.h
@@ -22,6 +22,7 @@
#include <string>
#include <unordered_map>
+#include "android-base/thread_annotations.h"
#include "bpf/BpfMap.h"
#include "bpf/BpfRingbuf.h"
@@ -31,6 +32,56 @@
namespace android {
namespace bpf {
+// NetworkTracePoller is responsible for interactions with the BPF ring buffer
+// including polling. This class is an internal helper for NetworkTraceHandler,
+// it is not meant to be used elsewhere.
+class NetworkTracePoller {
+ public:
+ // Testonly: initialize with a callback capable of intercepting data.
+ NetworkTracePoller(std::function<void(const PacketTrace&)> callback)
+ : mCallback(std::move(callback)) {}
+
+ // Starts tracing with the given poll interval.
+ bool Start(uint32_t pollMs) EXCLUDES(mMutex);
+
+ // Stops tracing and release any held state.
+ bool Stop() EXCLUDES(mMutex);
+
+ // Consumes all available events from the ringbuffer.
+ bool ConsumeAll() EXCLUDES(mMutex);
+
+ private:
+ void SchedulePolling() REQUIRES(mMutex);
+ bool ConsumeAllLocked() REQUIRES(mMutex);
+
+ std::mutex mMutex;
+
+ // Records the number of successfully started active sessions so that only the
+ // first active session attempts setup and only the last cleans up. Note that
+ // the session count will remain zero if Start fails. It is expected that Stop
+ // will not be called for any trace session where Start fails.
+ int mSessionCount GUARDED_BY(mMutex);
+
+ // How often to poll the ring buffer, defined by the trace config.
+ uint32_t mPollMs GUARDED_BY(mMutex);
+
+ // The function to process PacketTrace, typically a Perfetto sink.
+ std::function<void(const PacketTrace&)> mCallback GUARDED_BY(mMutex);
+
+ // The BPF ring buffer handle.
+ std::unique_ptr<BpfRingbuf<PacketTrace>> mRingBuffer GUARDED_BY(mMutex);
+
+ // The packet tracing config map (really a 1-element array).
+ BpfMap<uint32_t, bool> mConfigurationMap GUARDED_BY(mMutex);
+
+ // This must be the last member, causing it to be the first deleted. If it is
+ // not, members required for callbacks can be deleted before it's stopped.
+ std::unique_ptr<perfetto::base::TaskRunner> mTaskRunner GUARDED_BY(mMutex);
+};
+
+// NetworkTraceHandler implements the android.network_packets data source. This
+// class is registered with Perfetto and is instantiated when tracing starts and
+// destroyed when tracing ends. There is one instance per trace session.
class NetworkTraceHandler : public perfetto::DataSource<NetworkTraceHandler> {
public:
// Registers this DataSource.
@@ -39,45 +90,19 @@
// Connects to the system Perfetto daemon and registers the trace handler.
static void InitPerfettoTracing();
- // Initialize with the default Perfetto callback.
- NetworkTraceHandler();
-
- // Testonly: initialize with a callback capable of intercepting data.
- NetworkTraceHandler(std::function<void(const PacketTrace&)> callback)
- : mCallback(std::move(callback)) {}
-
- // Testonly: standalone functions without perfetto dependency.
- bool Start();
- bool Stop();
- bool ConsumeAll();
-
// perfetto::DataSource overrides:
- void OnSetup(const SetupArgs&) override;
+ void OnSetup(const SetupArgs& args) override;
void OnStart(const StartArgs&) override;
void OnStop(const StopArgs&) override;
- // Convert a PacketTrace into a Perfetto trace packet.
- void Fill(const PacketTrace& src,
- ::perfetto::protos::pbzero::TracePacket& dst);
-
private:
- void Loop();
+ // Convert a PacketTrace into a Perfetto trace packet.
+ static void Fill(const PacketTrace& src,
+ ::perfetto::protos::pbzero::TracePacket& dst);
- // How often to poll the ring buffer, defined by the trace config.
+ static NetworkTracePoller sPoller;
uint32_t mPollMs;
-
- // The function to process PacketTrace, typically a Perfetto sink.
- std::function<void(const PacketTrace&)> mCallback;
-
- // The BPF ring buffer handle.
- std::unique_ptr<BpfRingbuf<PacketTrace>> mRingBuffer;
-
- // The packet tracing config map (really a 1-element array).
- BpfMap<uint32_t, bool> mConfigurationMap;
-
- // This must be the last member, causing it to be the first deleted. If it is
- // not, members required for callbacks can be deleted before it's stopped.
- std::unique_ptr<perfetto::base::TaskRunner> mTaskRunner;
+ bool mStarted;
};
} // namespace bpf
diff --git a/service-t/src/com/android/server/IpSecService.java b/service-t/src/com/android/server/IpSecService.java
index 9e71eb3..a884840 100644
--- a/service-t/src/com/android/server/IpSecService.java
+++ b/service-t/src/com/android/server/IpSecService.java
@@ -17,6 +17,7 @@
package com.android.server;
import static android.Manifest.permission.DUMP;
+import static android.Manifest.permission.NETWORK_SETTINGS;
import static android.net.IpSecManager.FEATURE_IPSEC_TUNNEL_MIGRATION;
import static android.net.IpSecManager.INVALID_RESOURCE_ID;
import static android.system.OsConstants.AF_INET;
@@ -65,6 +66,7 @@
import com.android.internal.annotations.GuardedBy;
import com.android.internal.annotations.VisibleForTesting;
import com.android.internal.util.Preconditions;
+import com.android.modules.utils.build.SdkLevel;
import com.android.net.module.util.BinderUtils;
import com.android.net.module.util.NetdUtils;
import com.android.net.module.util.PermissionUtils;
@@ -102,6 +104,7 @@
private static final int NETD_FETCH_TIMEOUT_MS = 5000; // ms
private static final InetAddress INADDR_ANY;
+ private static final InetAddress IN6ADDR_ANY;
@VisibleForTesting static final int MAX_PORT_BIND_ATTEMPTS = 10;
@@ -110,6 +113,8 @@
static {
try {
INADDR_ANY = InetAddress.getByAddress(new byte[] {0, 0, 0, 0});
+ IN6ADDR_ANY = InetAddress.getByAddress(
+ new byte[] {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0});
} catch (UnknownHostException e) {
throw new RuntimeException(e);
}
@@ -1013,11 +1018,13 @@
private final class EncapSocketRecord extends OwnedResourceRecord {
private FileDescriptor mSocket;
private final int mPort;
+ private final int mFamily; // TODO: what about IPV6_ADDRFORM?
- EncapSocketRecord(int resourceId, FileDescriptor socket, int port) {
+ EncapSocketRecord(int resourceId, FileDescriptor socket, int port, int family) {
super(resourceId);
mSocket = socket;
mPort = port;
+ mFamily = family;
}
/** always guarded by IpSecService#this */
@@ -1038,6 +1045,10 @@
return mSocket;
}
+ public int getFamily() {
+ return mFamily;
+ }
+
@Override
protected ResourceTracker getResourceTracker() {
return getUserRecord().mSocketQuotaTracker;
@@ -1210,15 +1221,16 @@
* and re-binding, during which the system could *technically* hand that port out to someone
* else.
*/
- private int bindToRandomPort(FileDescriptor sockFd) throws IOException {
+ private int bindToRandomPort(FileDescriptor sockFd, int family, InetAddress localAddr)
+ throws IOException {
for (int i = MAX_PORT_BIND_ATTEMPTS; i > 0; i--) {
try {
- FileDescriptor probeSocket = Os.socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
- Os.bind(probeSocket, INADDR_ANY, 0);
+ FileDescriptor probeSocket = Os.socket(family, SOCK_DGRAM, IPPROTO_UDP);
+ Os.bind(probeSocket, localAddr, 0);
int port = ((InetSocketAddress) Os.getsockname(probeSocket)).getPort();
Os.close(probeSocket);
Log.v(TAG, "Binding to port " + port);
- Os.bind(sockFd, INADDR_ANY, port);
+ Os.bind(sockFd, localAddr, port);
return port;
} catch (ErrnoException e) {
// Someone miraculously claimed the port just after we closed probeSocket.
@@ -1260,6 +1272,19 @@
@Override
public synchronized IpSecUdpEncapResponse openUdpEncapsulationSocket(int port, IBinder binder)
throws RemoteException {
+ // Experimental support for IPv6 UDP encap.
+ final int family;
+ final InetAddress localAddr;
+ if (SdkLevel.isAtLeastU() && port >= 65536) {
+ PermissionUtils.enforceNetworkStackPermissionOr(mContext, NETWORK_SETTINGS);
+ port -= 65536;
+ family = AF_INET6;
+ localAddr = IN6ADDR_ANY;
+ } else {
+ family = AF_INET;
+ localAddr = INADDR_ANY;
+ }
+
if (port != 0 && (port < FREE_PORT_MIN || port > PORT_MAX)) {
throw new IllegalArgumentException(
"Specified port number must be a valid non-reserved UDP port");
@@ -1278,7 +1303,7 @@
FileDescriptor sockFd = null;
try {
- sockFd = Os.socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+ sockFd = Os.socket(family, SOCK_DGRAM, IPPROTO_UDP);
pFd = ParcelFileDescriptor.dup(sockFd);
} finally {
IoUtils.closeQuietly(sockFd);
@@ -1295,15 +1320,16 @@
mNetd.ipSecSetEncapSocketOwner(pFd, callingUid);
if (port != 0) {
Log.v(TAG, "Binding to port " + port);
- Os.bind(pFd.getFileDescriptor(), INADDR_ANY, port);
+ Os.bind(pFd.getFileDescriptor(), localAddr, port);
} else {
- port = bindToRandomPort(pFd.getFileDescriptor());
+ port = bindToRandomPort(pFd.getFileDescriptor(), family, localAddr);
}
userRecord.mEncapSocketRecords.put(
resourceId,
new RefcountedResource<EncapSocketRecord>(
- new EncapSocketRecord(resourceId, pFd.getFileDescriptor(), port),
+ new EncapSocketRecord(resourceId, pFd.getFileDescriptor(), port,
+ family),
binder));
return new IpSecUdpEncapResponse(IpSecManager.Status.OK, resourceId, port,
pFd.getFileDescriptor());
@@ -1580,6 +1606,7 @@
*/
private void checkIpSecConfig(IpSecConfig config) {
UserRecord userRecord = mUserResourceTracker.getUserRecord(Binder.getCallingUid());
+ EncapSocketRecord encapSocketRecord = null;
switch (config.getEncapType()) {
case IpSecTransform.ENCAP_NONE:
@@ -1587,7 +1614,7 @@
case IpSecTransform.ENCAP_ESPINUDP:
case IpSecTransform.ENCAP_ESPINUDP_NON_IKE:
// Retrieve encap socket record; will throw IllegalArgumentException if not found
- userRecord.mEncapSocketRecords.getResourceOrThrow(
+ encapSocketRecord = userRecord.mEncapSocketRecords.getResourceOrThrow(
config.getEncapSocketResourceId());
int port = config.getEncapRemotePort();
@@ -1641,10 +1668,9 @@
+ ") have different address families.");
}
- // Throw an error if UDP Encapsulation is not used in IPv4.
- if (config.getEncapType() != IpSecTransform.ENCAP_NONE && sourceFamily != AF_INET) {
+ if (encapSocketRecord != null && encapSocketRecord.getFamily() != destinationFamily) {
throw new IllegalArgumentException(
- "UDP Encapsulation is not supported for this address family");
+ "UDP encapsulation socket and destination address families must match");
}
switch (config.getMode()) {
diff --git a/service-t/src/com/android/server/NsdService.java b/service-t/src/com/android/server/NsdService.java
index 4ad39e1..619b64d 100644
--- a/service-t/src/com/android/server/NsdService.java
+++ b/service-t/src/com/android/server/NsdService.java
@@ -20,6 +20,7 @@
import static android.net.nsd.NsdManager.MDNS_DISCOVERY_MANAGER_EVENT;
import static android.net.nsd.NsdManager.MDNS_SERVICE_EVENT;
import static android.provider.DeviceConfig.NAMESPACE_CONNECTIVITY;
+import static android.provider.DeviceConfig.NAMESPACE_TETHERING;
import android.annotation.NonNull;
import android.annotation.Nullable;
@@ -79,6 +80,7 @@
import java.nio.charset.Charset;
import java.nio.charset.CharsetEncoder;
import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@@ -110,6 +112,34 @@
*/
private static final String MDNS_ADVERTISER_VERSION = "mdns_advertiser_version";
+ /**
+ * Comma-separated list of type:flag mappings indicating the flags to use to allowlist
+ * discovery/advertising using MdnsDiscoveryManager / MdnsAdvertiser for a given type.
+ *
+ * For example _mytype._tcp.local and _othertype._tcp.local would be configured with:
+ * _mytype._tcp:mytype,_othertype._tcp.local:othertype
+ *
+ * In which case the flags:
+ * "mdns_discovery_manager_allowlist_mytype_version",
+ * "mdns_advertiser_allowlist_mytype_version",
+ * "mdns_discovery_manager_allowlist_othertype_version",
+ * "mdns_advertiser_allowlist_othertype_version"
+ * would be used to toggle MdnsDiscoveryManager / MdnsAdvertiser for each type. The flags will
+ * be read with
+ * {@link DeviceConfigUtils#isFeatureEnabled(Context, String, String, String, boolean)}.
+ *
+ * @see #MDNS_DISCOVERY_MANAGER_ALLOWLIST_FLAG_PREFIX
+ * @see #MDNS_ADVERTISER_ALLOWLIST_FLAG_PREFIX
+ * @see #MDNS_ALLOWLIST_FLAG_SUFFIX
+ */
+ private static final String MDNS_TYPE_ALLOWLIST_FLAGS = "mdns_type_allowlist_flags";
+
+ private static final String MDNS_DISCOVERY_MANAGER_ALLOWLIST_FLAG_PREFIX =
+ "mdns_discovery_manager_allowlist_";
+ private static final String MDNS_ADVERTISER_ALLOWLIST_FLAG_PREFIX =
+ "mdns_advertiser_allowlist_";
+ private static final String MDNS_ALLOWLIST_FLAG_SUFFIX = "_version";
+
public static final boolean DBG = Log.isLoggable(TAG, Log.DEBUG);
private static final long CLEANUP_DELAY_MS = 10000;
private static final int IFACE_IDX_ANY = 0;
@@ -317,7 +347,7 @@
if (!mIsMonitoringSocketsStarted) return;
if (isAnyRequestActive()) return;
- mMdnsSocketProvider.stopMonitoringSockets();
+ mMdnsSocketProvider.requestStopWhenInactive();
mIsMonitoringSocketsStarted = false;
}
@@ -496,31 +526,6 @@
clientInfo.mClientIdForServiceUpdates = 0;
}
- /**
- * Check the given service type is valid and construct it to a service type
- * which can use for discovery / resolution service.
- *
- * <p> The valid service type should be 2 labels, or 3 labels if the query is for a
- * subtype (see RFC6763 7.1). Each label is up to 63 characters and must start with an
- * underscore; they are alphanumerical characters or dashes or underscore, except the
- * last one that is just alphanumerical. The last label must be _tcp or _udp.
- *
- * @param serviceType the request service type for discovery / resolution service
- * @return constructed service type or null if the given service type is invalid.
- */
- @Nullable
- private String constructServiceType(String serviceType) {
- if (TextUtils.isEmpty(serviceType)) return null;
-
- final Pattern serviceTypePattern = Pattern.compile(
- "^(_[a-zA-Z0-9-_]{1,61}[a-zA-Z0-9]\\.)?"
- + "(_[a-zA-Z0-9-_]{1,61}[a-zA-Z0-9]\\._(?:tcp|udp))$");
- final Matcher matcher = serviceTypePattern.matcher(serviceType);
- if (!matcher.matches()) return null;
- return matcher.group(1) == null
- ? serviceType
- : matcher.group(1) + "_sub." + matcher.group(2);
- }
/**
* Truncate a service name to up to 63 UTF-8 bytes.
@@ -545,6 +550,12 @@
return new String(out.array(), 0, out.position(), utf8);
}
+ private void stopDiscoveryManagerRequest(ClientRequest request, int clientId, int id,
+ ClientInfo clientInfo) {
+ clientInfo.unregisterMdnsListenerFromRequest(request);
+ removeRequestMap(clientId, id, clientInfo);
+ }
+
@Override
public boolean processMessage(Message msg) {
final ClientInfo clientInfo;
@@ -572,8 +583,9 @@
final NsdServiceInfo info = args.serviceInfo;
id = getUniqueId();
- if (mDeps.isMdnsDiscoveryManagerEnabled(mContext)) {
- final String serviceType = constructServiceType(info.getServiceType());
+ final String serviceType = constructServiceType(info.getServiceType());
+ if (mDeps.isMdnsDiscoveryManagerEnabled(mContext)
+ || useDiscoveryManagerForType(serviceType)) {
if (serviceType == null) {
clientInfo.onDiscoverServicesFailed(clientId,
NsdManager.FAILURE_INTERNAL_ERROR);
@@ -631,11 +643,7 @@
// point, so this needs to check the type of the original request to
// unregister instead of looking at the flag value.
if (request instanceof DiscoveryManagerRequest) {
- final MdnsListener listener =
- ((DiscoveryManagerRequest) request).mListener;
- mMdnsDiscoveryManager.unregisterListener(
- listener.getListenedServiceType(), listener);
- removeRequestMap(clientId, id, clientInfo);
+ stopDiscoveryManagerRequest(request, clientId, id, clientInfo);
clientInfo.onStopDiscoverySucceeded(clientId);
} else {
removeRequestMap(clientId, id, clientInfo);
@@ -667,10 +675,11 @@
}
id = getUniqueId();
- if (mDeps.isMdnsAdvertiserEnabled(mContext)) {
- final NsdServiceInfo serviceInfo = args.serviceInfo;
- final String serviceType = serviceInfo.getServiceType();
- final String registerServiceType = constructServiceType(serviceType);
+ final NsdServiceInfo serviceInfo = args.serviceInfo;
+ final String serviceType = serviceInfo.getServiceType();
+ final String registerServiceType = constructServiceType(serviceType);
+ if (mDeps.isMdnsAdvertiserEnabled(mContext)
+ || useAdvertiserForType(registerServiceType)) {
if (registerServiceType == null) {
Log.e(TAG, "Invalid service type: " + serviceType);
clientInfo.onRegisterServiceFailed(clientId,
@@ -686,7 +695,7 @@
storeAdvertiserRequestMap(clientId, id, clientInfo);
} else {
maybeStartDaemon();
- if (registerService(id, args.serviceInfo)) {
+ if (registerService(id, serviceInfo)) {
if (DBG) Log.d(TAG, "Register " + clientId + " " + id);
storeLegacyRequestMap(clientId, id, clientInfo, msg.what);
// Return success after mDns reports success
@@ -748,8 +757,9 @@
final NsdServiceInfo info = args.serviceInfo;
id = getUniqueId();
- if (mDeps.isMdnsDiscoveryManagerEnabled(mContext)) {
- final String serviceType = constructServiceType(info.getServiceType());
+ final String serviceType = constructServiceType(info.getServiceType());
+ if (mDeps.isMdnsDiscoveryManagerEnabled(mContext)
+ || useDiscoveryManagerForType(serviceType)) {
if (serviceType == null) {
clientInfo.onResolveServiceFailed(clientId,
NsdManager.FAILURE_INTERNAL_ERROR);
@@ -763,6 +773,7 @@
final MdnsSearchOptions options = MdnsSearchOptions.newBuilder()
.setNetwork(info.getNetwork())
.setIsPassiveMode(true)
+ .setResolveInstanceName(info.getServiceName())
.build();
mMdnsDiscoveryManager.registerListener(
resolveServiceType, listener, options);
@@ -775,7 +786,7 @@
}
maybeStartDaemon();
- if (resolveService(id, args.serviceInfo)) {
+ if (resolveService(id, info)) {
clientInfo.mResolvedService = new NsdServiceInfo();
storeLegacyRequestMap(clientId, id, clientInfo, msg.what);
} else {
@@ -803,15 +814,22 @@
break;
}
id = request.mGlobalId;
- removeRequestMap(clientId, id, clientInfo);
- if (stopResolveService(id)) {
+ // Note isMdnsDiscoveryManagerEnabled may have changed to false at this
+ // point, so this needs to check the type of the original request to
+ // unregister instead of looking at the flag value.
+ if (request instanceof DiscoveryManagerRequest) {
+ stopDiscoveryManagerRequest(request, clientId, id, clientInfo);
clientInfo.onStopResolutionSucceeded(clientId);
} else {
- clientInfo.onStopResolutionFailed(
- clientId, NsdManager.FAILURE_OPERATION_NOT_RUNNING);
+ removeRequestMap(clientId, id, clientInfo);
+ if (stopResolveService(id)) {
+ clientInfo.onStopResolutionSucceeded(clientId);
+ } else {
+ clientInfo.onStopResolutionFailed(
+ clientId, NsdManager.FAILURE_OPERATION_NOT_RUNNING);
+ }
+ clientInfo.mResolvedService = null;
}
- clientInfo.mResolvedService = null;
- // TODO: Implement the stop resolution with MdnsDiscoveryManager.
break;
}
case NsdManager.REGISTER_SERVICE_CALLBACK:
@@ -1144,17 +1162,27 @@
Log.e(TAG, "Invalid attribute", e);
}
}
- try {
- if (serviceInfo.getIpv4Address() != null) {
- info.setHost(InetAddresses.parseNumericAddress(
- serviceInfo.getIpv4Address()));
- } else {
- info.setHost(InetAddresses.parseNumericAddress(
- serviceInfo.getIpv6Address()));
+ final List<InetAddress> addresses = new ArrayList<>();
+ for (String ipv4Address : serviceInfo.getIpv4Addresses()) {
+ try {
+ addresses.add(InetAddresses.parseNumericAddress(ipv4Address));
+ } catch (IllegalArgumentException e) {
+ Log.wtf(TAG, "Invalid ipv4 address", e);
}
+ }
+ for (String ipv6Address : serviceInfo.getIpv6Addresses()) {
+ try {
+ addresses.add(InetAddresses.parseNumericAddress(ipv6Address));
+ } catch (IllegalArgumentException e) {
+ Log.wtf(TAG, "Invalid ipv6 address", e);
+ }
+ }
+
+ if (addresses.size() != 0) {
+ info.setHostAddresses(addresses);
clientInfo.onResolveServiceSucceeded(clientId, info);
- } catch (IllegalArgumentException e) {
- Log.wtf(TAG, "Invalid address in RESOLVE_SERVICE_SUCCEEDED", e);
+ } else {
+ // No address. Notify resolution failure.
clientInfo.onResolveServiceFailed(
clientId, NsdManager.FAILURE_INTERNAL_ERROR);
}
@@ -1164,10 +1192,7 @@
Log.wtf(TAG, "non-DiscoveryManager request in DiscoveryManager event");
break;
}
- final MdnsListener listener = ((DiscoveryManagerRequest) request).mListener;
- mMdnsDiscoveryManager.unregisterListener(
- listener.getListenedServiceType(), listener);
- removeRequestMap(clientId, transactionId, clientInfo);
+ stopDiscoveryManagerRequest(request, clientId, transactionId, clientInfo);
break;
}
default:
@@ -1227,6 +1252,34 @@
return sb.toString();
}
+ /**
+ * Check the given service type is valid and construct it to a service type
+ * which can use for discovery / resolution service.
+ *
+ * <p> The valid service type should be 2 labels, or 3 labels if the query is for a
+ * subtype (see RFC6763 7.1). Each label is up to 63 characters and must start with an
+ * underscore; they are alphanumerical characters or dashes or underscore, except the
+ * last one that is just alphanumerical. The last label must be _tcp or _udp.
+ *
+ * @param serviceType the request service type for discovery / resolution service
+ * @return constructed service type or null if the given service type is invalid.
+ */
+ @Nullable
+ public static String constructServiceType(String serviceType) {
+ if (TextUtils.isEmpty(serviceType)) return null;
+
+ final Pattern serviceTypePattern = Pattern.compile(
+ "^(_[a-zA-Z0-9-_]{1,61}[a-zA-Z0-9]\\.)?"
+ + "(_[a-zA-Z0-9-_]{1,61}[a-zA-Z0-9]\\._(?:tcp|udp))"
+ // Drop '.' at the end of service type that is compatible with old backend.
+ + "\\.?$");
+ final Matcher matcher = serviceTypePattern.matcher(serviceType);
+ if (!matcher.matches()) return null;
+ return matcher.group(1) == null
+ ? matcher.group(2)
+ : matcher.group(1) + "_sub." + matcher.group(2);
+ }
+
@VisibleForTesting
NsdService(Context ctx, Handler handler, long cleanupDelayMs) {
this(ctx, handler, cleanupDelayMs, new Dependencies());
@@ -1280,6 +1333,24 @@
}
/**
+ * Get the type allowlist flag value.
+ * @see #MDNS_TYPE_ALLOWLIST_FLAGS
+ */
+ @Nullable
+ public String getTypeAllowlistFlags() {
+ return DeviceConfigUtils.getDeviceConfigProperty(NAMESPACE_TETHERING,
+ MDNS_TYPE_ALLOWLIST_FLAGS, null);
+ }
+
+ /**
+ * @see DeviceConfigUtils#isFeatureEnabled(Context, String, String, String, boolean)
+ */
+ public boolean isFeatureEnabled(Context context, String feature) {
+ return DeviceConfigUtils.isFeatureEnabled(context, NAMESPACE_TETHERING,
+ feature, DeviceConfigUtils.TETHERING_MODULE_NAME, false /* defaultEnabled */);
+ }
+
+ /**
* @see MdnsDiscoveryManager
*/
public MdnsDiscoveryManager makeMdnsDiscoveryManager(
@@ -1304,6 +1375,41 @@
}
}
+ /**
+ * Return whether a type is allowlisted to use the Java backend.
+ * @param type The service type
+ * @param flagPrefix One of {@link #MDNS_ADVERTISER_ALLOWLIST_FLAG_PREFIX} or
+ * {@link #MDNS_DISCOVERY_MANAGER_ALLOWLIST_FLAG_PREFIX}.
+ */
+ private boolean isTypeAllowlistedForJavaBackend(@Nullable String type,
+ @NonNull String flagPrefix) {
+ if (type == null) return false;
+ final String typesConfig = mDeps.getTypeAllowlistFlags();
+ if (TextUtils.isEmpty(typesConfig)) return false;
+
+ final String mappingPrefix = type + ":";
+ String mappedFlag = null;
+ for (String mapping : TextUtils.split(typesConfig, ",")) {
+ if (mapping.startsWith(mappingPrefix)) {
+ mappedFlag = mapping.substring(mappingPrefix.length());
+ break;
+ }
+ }
+
+ if (mappedFlag == null) return false;
+
+ return mDeps.isFeatureEnabled(mContext,
+ flagPrefix + mappedFlag + MDNS_ALLOWLIST_FLAG_SUFFIX);
+ }
+
+ private boolean useDiscoveryManagerForType(@Nullable String type) {
+ return isTypeAllowlistedForJavaBackend(type, MDNS_DISCOVERY_MANAGER_ALLOWLIST_FLAG_PREFIX);
+ }
+
+ private boolean useAdvertiserForType(@Nullable String type) {
+ return isTypeAllowlistedForJavaBackend(type, MDNS_ADVERTISER_ALLOWLIST_FLAG_PREFIX);
+ }
+
public static NsdService create(Context context) {
HandlerThread thread = new HandlerThread(TAG);
thread.start();
@@ -1694,6 +1800,13 @@
mIsPreSClient = true;
}
+ private void unregisterMdnsListenerFromRequest(ClientRequest request) {
+ final MdnsListener listener =
+ ((DiscoveryManagerRequest) request).mListener;
+ mMdnsDiscoveryManager.unregisterListener(
+ listener.getListenedServiceType(), listener);
+ }
+
// Remove any pending requests from the global map when we get rid of a client,
// and send cancellations to the daemon.
private void expungeAllRequests() {
@@ -1709,10 +1822,7 @@
}
if (request instanceof DiscoveryManagerRequest) {
- final MdnsListener listener =
- ((DiscoveryManagerRequest) request).mListener;
- mMdnsDiscoveryManager.unregisterListener(
- listener.getListenedServiceType(), listener);
+ unregisterMdnsListenerFromRequest(request);
continue;
}
diff --git a/service-t/src/com/android/server/connectivity/mdns/EnqueueMdnsQueryCallable.java b/service-t/src/com/android/server/connectivity/mdns/EnqueueMdnsQueryCallable.java
index fdd1478..9a67007 100644
--- a/service-t/src/com/android/server/connectivity/mdns/EnqueueMdnsQueryCallable.java
+++ b/service-t/src/com/android/server/connectivity/mdns/EnqueueMdnsQueryCallable.java
@@ -60,13 +60,21 @@
}
}
+ @NonNull
private final WeakReference<MdnsSocketClientBase> weakRequestSender;
+ @NonNull
private final MdnsPacketWriter packetWriter;
+ @NonNull
private final String[] serviceTypeLabels;
+ @NonNull
private final List<String> subtypes;
private final boolean expectUnicastResponse;
private final int transactionId;
+ @Nullable
private final Network network;
+ private final boolean sendDiscoveryQueries;
+ @NonNull
+ private final List<MdnsResponse> servicesToResolve;
EnqueueMdnsQueryCallable(
@NonNull MdnsSocketClientBase requestSender,
@@ -75,7 +83,9 @@
@NonNull Collection<String> subtypes,
boolean expectUnicastResponse,
int transactionId,
- @Nullable Network network) {
+ @Nullable Network network,
+ boolean sendDiscoveryQueries,
+ @NonNull Collection<MdnsResponse> servicesToResolve) {
weakRequestSender = new WeakReference<>(requestSender);
this.packetWriter = packetWriter;
serviceTypeLabels = TextUtils.split(serviceType, "\\.");
@@ -83,6 +93,8 @@
this.expectUnicastResponse = expectUnicastResponse;
this.transactionId = transactionId;
this.network = network;
+ this.sendDiscoveryQueries = sendDiscoveryQueries;
+ this.servicesToResolve = new ArrayList<>(servicesToResolve);
}
// Incompatible return type for override of Callable#call().
@@ -96,9 +108,44 @@
return null;
}
- int numQuestions = 1;
- if (!subtypes.isEmpty()) {
- numQuestions += subtypes.size();
+ int numQuestions = 0;
+
+ if (sendDiscoveryQueries) {
+ numQuestions++; // Base service type
+ if (!subtypes.isEmpty()) {
+ numQuestions += subtypes.size();
+ }
+ }
+
+ // List of (name, type) to query
+ final ArrayList<Pair<String[], Integer>> missingKnownAnswerRecords = new ArrayList<>();
+ for (MdnsResponse response : servicesToResolve) {
+ // TODO: also send queries to renew record TTL (as per RFC6762 7.1 no need to query
+ // if remaining TTL is more than half the original one, so send the queries if half
+ // the TTL has passed).
+ if (response.isComplete()) continue;
+ final String[] serviceName = response.getServiceName();
+ if (serviceName == null) continue;
+ if (!response.hasTextRecord()) {
+ missingKnownAnswerRecords.add(new Pair<>(serviceName, MdnsRecord.TYPE_TXT));
+ }
+ if (!response.hasServiceRecord()) {
+ missingKnownAnswerRecords.add(new Pair<>(serviceName, MdnsRecord.TYPE_SRV));
+ // The hostname is not yet known, so queries for address records will be sent
+ // the next time the EnqueueMdnsQueryCallable is enqueued if the reply does not
+ // contain them. In practice, advertisers should include the address records
+ // when queried for SRV, although it's not a MUST requirement (RFC6763 12.2).
+ } else if (!response.hasInet4AddressRecord() && !response.hasInet6AddressRecord()) {
+ final String[] host = response.getServiceRecord().getServiceHost();
+ missingKnownAnswerRecords.add(new Pair<>(host, MdnsRecord.TYPE_A));
+ missingKnownAnswerRecords.add(new Pair<>(host, MdnsRecord.TYPE_AAAA));
+ }
+ }
+ numQuestions += missingKnownAnswerRecords.size();
+
+ if (numQuestions == 0) {
+ // No query to send
+ return null;
}
// Header.
@@ -109,28 +156,25 @@
packetWriter.writeUInt16(0); // number of authority entries
packetWriter.writeUInt16(0); // number of additional records
- // Question(s). There will be one question for each (fqdn+subtype, recordType)
- // combination,
- // as well as one for each (fqdn, recordType) combination.
-
- for (String subtype : subtypes) {
- String[] labels = new String[serviceTypeLabels.length + 2];
- labels[0] = MdnsConstants.SUBTYPE_PREFIX + subtype;
- labels[1] = MdnsConstants.SUBTYPE_LABEL;
- System.arraycopy(serviceTypeLabels, 0, labels, 2, serviceTypeLabels.length);
-
- packetWriter.writeLabels(labels);
- packetWriter.writeUInt16(MdnsRecord.TYPE_PTR);
- packetWriter.writeUInt16(
- MdnsConstants.QCLASS_INTERNET
- | (expectUnicastResponse ? MdnsConstants.QCLASS_UNICAST : 0));
+ // Question(s) for missing records on known answers
+ for (Pair<String[], Integer> question : missingKnownAnswerRecords) {
+ writeQuestion(question.first, question.second);
}
- packetWriter.writeLabels(serviceTypeLabels);
- packetWriter.writeUInt16(MdnsRecord.TYPE_PTR);
- packetWriter.writeUInt16(
- MdnsConstants.QCLASS_INTERNET
- | (expectUnicastResponse ? MdnsConstants.QCLASS_UNICAST : 0));
+ // Question(s) for discovering other services with the type. There will be one question
+ // for each (fqdn+subtype, recordType) combination, as well as one for each (fqdn,
+ // recordType) combination.
+ if (sendDiscoveryQueries) {
+ for (String subtype : subtypes) {
+ String[] labels = new String[serviceTypeLabels.length + 2];
+ labels[0] = MdnsConstants.SUBTYPE_PREFIX + subtype;
+ labels[1] = MdnsConstants.SUBTYPE_LABEL;
+ System.arraycopy(serviceTypeLabels, 0, labels, 2, serviceTypeLabels.length);
+
+ writeQuestion(labels, MdnsRecord.TYPE_PTR);
+ }
+ writeQuestion(serviceTypeLabels, MdnsRecord.TYPE_PTR);
+ }
if (requestSender instanceof MdnsMultinetworkSocketClient) {
sendPacketToIpv4AndIpv6(requestSender, MdnsConstants.MDNS_PORT, network);
@@ -159,6 +203,14 @@
}
}
+ private void writeQuestion(String[] labels, int type) throws IOException {
+ packetWriter.writeLabels(labels);
+ packetWriter.writeUInt16(type);
+ packetWriter.writeUInt16(
+ MdnsConstants.QCLASS_INTERNET
+ | (expectUnicastResponse ? MdnsConstants.QCLASS_UNICAST : 0));
+ }
+
private void sendPacketTo(MdnsSocketClientBase requestSender, InetSocketAddress address)
throws IOException {
DatagramPacket packet = packetWriter.getPacket(address);
diff --git a/service-t/src/com/android/server/connectivity/mdns/MdnsAdvertiser.java b/service-t/src/com/android/server/connectivity/mdns/MdnsAdvertiser.java
index 977478a..ec3e997 100644
--- a/service-t/src/com/android/server/connectivity/mdns/MdnsAdvertiser.java
+++ b/service-t/src/com/android/server/connectivity/mdns/MdnsAdvertiser.java
@@ -31,6 +31,7 @@
import java.util.List;
import java.util.Map;
+import java.util.UUID;
import java.util.function.BiPredicate;
import java.util.function.Consumer;
@@ -43,6 +44,9 @@
private static final String TAG = MdnsAdvertiser.class.getSimpleName();
static final boolean DBG = Log.isLoggable(TAG, Log.DEBUG);
+ // Top-level domain for link-local queries, as per RFC6762 3.
+ private static final String LOCAL_TLD = "local";
+
private final Looper mLooper;
private final AdvertiserCallback mCb;
@@ -60,6 +64,8 @@
private final SparseArray<Registration> mRegistrations = new SparseArray<>();
private final Dependencies mDeps;
+ private String[] mDeviceHostName;
+
/**
* Dependencies for {@link MdnsAdvertiser}, useful for testing.
*/
@@ -71,11 +77,32 @@
public MdnsInterfaceAdvertiser makeAdvertiser(@NonNull MdnsInterfaceSocket socket,
@NonNull List<LinkAddress> initialAddresses,
@NonNull Looper looper, @NonNull byte[] packetCreationBuffer,
- @NonNull MdnsInterfaceAdvertiser.Callback cb) {
+ @NonNull MdnsInterfaceAdvertiser.Callback cb,
+ @NonNull String[] deviceHostName) {
// Note NetworkInterface is final and not mockable
final String logTag = socket.getInterface().getName();
return new MdnsInterfaceAdvertiser(logTag, socket, initialAddresses, looper,
- packetCreationBuffer, cb);
+ packetCreationBuffer, cb, deviceHostName);
+ }
+
+ /**
+ * Generates a unique hostname to be used by the device.
+ */
+ @NonNull
+ public String[] generateHostname() {
+ // Generate a very-probably-unique hostname. This allows minimizing possible conflicts
+ // to the point that probing for it is no longer necessary (as per RFC6762 8.1 last
+ // paragraph), and does not leak more information than what could already be obtained by
+ // looking at the mDNS packets source address.
+ // This differs from historical behavior that just used "Android.local" for many
+ // devices, creating a lot of conflicts.
+ // Having a different hostname per interface is an acceptable option as per RFC6762 14.
+ // This hostname will change every time the interface is reconnected, so this does not
+ // allow tracking the device.
+ // TODO: consider deriving a hostname from other sources, such as the IPv6 addresses
+ // (reusing the same privacy-protecting mechanics).
+ return new String[] {
+ "Android_" + UUID.randomUUID().toString().replace("-", ""), LOCAL_TLD };
}
}
@@ -260,7 +287,7 @@
MdnsInterfaceAdvertiser advertiser = mAllAdvertisers.get(socket);
if (advertiser == null) {
advertiser = mDeps.makeAdvertiser(socket, addresses, mLooper, mPacketCreationBuffer,
- mInterfaceAdvertiserCb);
+ mInterfaceAdvertiserCb, mDeviceHostName);
mAllAdvertisers.put(socket, advertiser);
advertiser.start();
}
@@ -389,6 +416,7 @@
mCb = cb;
mSocketProvider = socketProvider;
mDeps = deps;
+ mDeviceHostName = deps.generateHostname();
}
private void checkThread() {
@@ -453,6 +481,10 @@
advertiser.removeService(id);
}
mRegistrations.remove(id);
+ // Regenerates host name when registrations removed.
+ if (mRegistrations.size() == 0) {
+ mDeviceHostName = mDeps.generateHostname();
+ }
}
private static <K, V> boolean any(@NonNull ArrayMap<K, V> map,
diff --git a/service-t/src/com/android/server/connectivity/mdns/MdnsDiscoveryManager.java b/service-t/src/com/android/server/connectivity/mdns/MdnsDiscoveryManager.java
index cc6b98b..67059e7 100644
--- a/service-t/src/com/android/server/connectivity/mdns/MdnsDiscoveryManager.java
+++ b/service-t/src/com/android/server/connectivity/mdns/MdnsDiscoveryManager.java
@@ -19,6 +19,7 @@
import android.Manifest.permission;
import android.annotation.NonNull;
import android.annotation.RequiresPermission;
+import android.net.Network;
import android.text.TextUtils;
import android.util.ArrayMap;
import android.util.Log;
@@ -27,7 +28,6 @@
import com.android.server.connectivity.mdns.util.MdnsLogger;
import java.io.IOException;
-import java.util.Arrays;
import java.util.Map;
/**
@@ -119,22 +119,10 @@
}
@Override
- public synchronized void onResponseReceived(@NonNull MdnsResponse response) {
- String[] name =
- response.getPointerRecords().isEmpty()
- ? null
- : response.getPointerRecords().get(0).getName();
- if (name != null) {
- for (MdnsServiceTypeClient serviceTypeClient : serviceTypeClients.values()) {
- String[] serviceType = serviceTypeClient.getServiceTypeLabels();
- if ((Arrays.equals(name, serviceType)
- || ((name.length == (serviceType.length + 2))
- && name[1].equals(MdnsConstants.SUBTYPE_LABEL)
- && MdnsRecord.labelsAreSuffix(serviceType, name)))) {
- serviceTypeClient.processResponse(response);
- return;
- }
- }
+ public synchronized void onResponseReceived(@NonNull MdnsPacket packet,
+ int interfaceIndex, Network network) {
+ for (MdnsServiceTypeClient serviceTypeClient : serviceTypeClients.values()) {
+ serviceTypeClient.processResponse(packet, interfaceIndex, network);
}
}
diff --git a/service-t/src/com/android/server/connectivity/mdns/MdnsInterfaceAdvertiser.java b/service-t/src/com/android/server/connectivity/mdns/MdnsInterfaceAdvertiser.java
index c616e01..79cddce 100644
--- a/service-t/src/com/android/server/connectivity/mdns/MdnsInterfaceAdvertiser.java
+++ b/service-t/src/com/android/server/connectivity/mdns/MdnsInterfaceAdvertiser.java
@@ -141,8 +141,9 @@
public static class Dependencies {
/** @see MdnsRecordRepository */
@NonNull
- public MdnsRecordRepository makeRecordRepository(@NonNull Looper looper) {
- return new MdnsRecordRepository(looper);
+ public MdnsRecordRepository makeRecordRepository(@NonNull Looper looper,
+ @NonNull String[] deviceHostName) {
+ return new MdnsRecordRepository(looper, deviceHostName);
}
/** @see MdnsReplySender */
@@ -169,17 +170,18 @@
public MdnsInterfaceAdvertiser(@NonNull String logTag,
@NonNull MdnsInterfaceSocket socket, @NonNull List<LinkAddress> initialAddresses,
- @NonNull Looper looper, @NonNull byte[] packetCreationBuffer, @NonNull Callback cb) {
+ @NonNull Looper looper, @NonNull byte[] packetCreationBuffer, @NonNull Callback cb,
+ @NonNull String[] deviceHostName) {
this(logTag, socket, initialAddresses, looper, packetCreationBuffer, cb,
- new Dependencies());
+ new Dependencies(), deviceHostName);
}
public MdnsInterfaceAdvertiser(@NonNull String logTag,
@NonNull MdnsInterfaceSocket socket, @NonNull List<LinkAddress> initialAddresses,
@NonNull Looper looper, @NonNull byte[] packetCreationBuffer, @NonNull Callback cb,
- @NonNull Dependencies deps) {
+ @NonNull Dependencies deps, @NonNull String[] deviceHostName) {
mTag = MdnsInterfaceAdvertiser.class.getSimpleName() + "/" + logTag;
- mRecordRepository = deps.makeRecordRepository(looper);
+ mRecordRepository = deps.makeRecordRepository(looper, deviceHostName);
mRecordRepository.updateAddresses(initialAddresses);
mSocket = socket;
mCb = cb;
diff --git a/service-t/src/com/android/server/connectivity/mdns/MdnsMultinetworkSocketClient.java b/service-t/src/com/android/server/connectivity/mdns/MdnsMultinetworkSocketClient.java
index d959065..93972d9 100644
--- a/service-t/src/com/android/server/connectivity/mdns/MdnsMultinetworkSocketClient.java
+++ b/service-t/src/com/android/server/connectivity/mdns/MdnsMultinetworkSocketClient.java
@@ -33,7 +33,6 @@
import java.net.Inet4Address;
import java.net.Inet6Address;
import java.net.InetSocketAddress;
-import java.util.ArrayList;
import java.util.List;
import java.util.Map;
@@ -48,7 +47,6 @@
@NonNull private final Handler mHandler;
@NonNull private final MdnsSocketProvider mSocketProvider;
- @NonNull private final MdnsResponseDecoder mResponseDecoder;
private final Map<MdnsServiceBrowserListener, InterfaceSocketCallback> mRequestedNetworks =
new ArrayMap<>();
@@ -62,8 +60,6 @@
@NonNull MdnsSocketProvider provider) {
mHandler = new Handler(looper);
mSocketProvider = provider;
- mResponseDecoder = new MdnsResponseDecoder(
- new MdnsResponseDecoder.Clock(), null /* serviceType */);
}
private class InterfaceSocketCallback implements MdnsSocketProvider.SocketCallback {
@@ -170,19 +166,21 @@
@NonNull Network network) {
int packetNumber = ++mReceivedPacketNumber;
- final List<MdnsResponse> responses = new ArrayList<>();
- final int errorCode = mResponseDecoder.decode(
- recvbuf, length, responses, interfaceIndex, network);
- if (errorCode == MdnsResponseDecoder.SUCCESS) {
- for (MdnsResponse response : responses) {
+ final MdnsPacket response;
+ try {
+ response = MdnsResponseDecoder.parseResponse(recvbuf, length);
+ } catch (MdnsPacket.ParseException e) {
+ if (e.code != MdnsResponseErrorCode.ERROR_NOT_RESPONSE_MESSAGE) {
+ Log.e(TAG, e.getMessage(), e);
if (mCallback != null) {
- mCallback.onResponseReceived(response);
+ mCallback.onFailedToParseMdnsResponse(packetNumber, e.code);
}
}
- } else if (errorCode != MdnsResponseErrorCode.ERROR_NOT_RESPONSE_MESSAGE) {
- if (mCallback != null) {
- mCallback.onFailedToParseMdnsResponse(packetNumber, errorCode);
- }
+ return;
+ }
+
+ if (mCallback != null) {
+ mCallback.onResponseReceived(response, interfaceIndex, network);
}
}
diff --git a/service-t/src/com/android/server/connectivity/mdns/MdnsRecordRepository.java b/service-t/src/com/android/server/connectivity/mdns/MdnsRecordRepository.java
index e975ab4..1329172 100644
--- a/service-t/src/com/android/server/connectivity/mdns/MdnsRecordRepository.java
+++ b/service-t/src/com/android/server/connectivity/mdns/MdnsRecordRepository.java
@@ -47,7 +47,6 @@
import java.util.Random;
import java.util.Set;
import java.util.TreeMap;
-import java.util.UUID;
import java.util.concurrent.TimeUnit;
/**
@@ -90,15 +89,16 @@
@NonNull
private final Looper mLooper;
@NonNull
- private String[] mDeviceHostname;
+ private final String[] mDeviceHostname;
- public MdnsRecordRepository(@NonNull Looper looper) {
- this(looper, new Dependencies());
+ public MdnsRecordRepository(@NonNull Looper looper, @NonNull String[] deviceHostname) {
+ this(looper, new Dependencies(), deviceHostname);
}
@VisibleForTesting
- public MdnsRecordRepository(@NonNull Looper looper, @NonNull Dependencies deps) {
- mDeviceHostname = deps.getHostname();
+ public MdnsRecordRepository(@NonNull Looper looper, @NonNull Dependencies deps,
+ @NonNull String[] deviceHostname) {
+ mDeviceHostname = deviceHostname;
mLooper = looper;
}
@@ -107,25 +107,6 @@
*/
@VisibleForTesting
public static class Dependencies {
- /**
- * Get a unique hostname to be used by the device.
- */
- @NonNull
- public String[] getHostname() {
- // Generate a very-probably-unique hostname. This allows minimizing possible conflicts
- // to the point that probing for it is no longer necessary (as per RFC6762 8.1 last
- // paragraph), and does not leak more information than what could already be obtained by
- // looking at the mDNS packets source address.
- // This differs from historical behavior that just used "Android.local" for many
- // devices, creating a lot of conflicts.
- // Having a different hostname per interface is an acceptable option as per RFC6762 14.
- // This hostname will change every time the interface is reconnected, so this does not
- // allow tracking the device.
- // TODO: consider deriving a hostname from other sources, such as the IPv6 addresses
- // (reusing the same privacy-protecting mechanics).
- return new String[] {
- "Android_" + UUID.randomUUID().toString().replace("-", ""), LOCAL_TLD };
- }
/**
* @see NetworkInterface#getInetAddresses().
diff --git a/service-t/src/com/android/server/connectivity/mdns/MdnsResponse.java b/service-t/src/com/android/server/connectivity/mdns/MdnsResponse.java
index 3a41978..be2555b 100644
--- a/service-t/src/com/android/server/connectivity/mdns/MdnsResponse.java
+++ b/service-t/src/com/android/server/connectivity/mdns/MdnsResponse.java
@@ -16,16 +16,20 @@
package com.android.server.connectivity.mdns;
+import android.annotation.NonNull;
import android.annotation.Nullable;
import android.net.Network;
import com.android.internal.annotations.VisibleForTesting;
import java.io.IOException;
+import java.util.ArrayList;
import java.util.Arrays;
+import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
+import java.util.Objects;
/** An mDNS response. */
public class MdnsResponse {
@@ -33,42 +37,72 @@
private final List<MdnsPointerRecord> pointerRecords;
private MdnsServiceRecord serviceRecord;
private MdnsTextRecord textRecord;
- private MdnsInetAddressRecord inet4AddressRecord;
- private MdnsInetAddressRecord inet6AddressRecord;
+ @NonNull private List<MdnsInetAddressRecord> inet4AddressRecords;
+ @NonNull private List<MdnsInetAddressRecord> inet6AddressRecords;
private long lastUpdateTime;
private final int interfaceIndex;
@Nullable private final Network network;
+ @NonNull private final String[] serviceName;
/** Constructs a new, empty response. */
- public MdnsResponse(long now, int interfaceIndex, @Nullable Network network) {
+ public MdnsResponse(long now, @NonNull String[] serviceName, int interfaceIndex,
+ @Nullable Network network) {
lastUpdateTime = now;
records = new LinkedList<>();
pointerRecords = new LinkedList<>();
+ inet4AddressRecords = new ArrayList<>();
+ inet6AddressRecords = new ArrayList<>();
this.interfaceIndex = interfaceIndex;
this.network = network;
+ this.serviceName = serviceName;
}
- // This generic typed helper compares records for equality.
- // Returns True if records are the same.
- private <T> boolean recordsAreSame(T a, T b) {
- return ((a == null) && (b == null)) || ((a != null) && (b != null) && a.equals(b));
+ public MdnsResponse(@NonNull MdnsResponse base) {
+ records = new ArrayList<>(base.records);
+ pointerRecords = new ArrayList<>(base.pointerRecords);
+ serviceRecord = base.serviceRecord;
+ textRecord = base.textRecord;
+ inet4AddressRecords = new ArrayList<>(base.inet4AddressRecords);
+ inet6AddressRecords = new ArrayList<>(base.inet6AddressRecords);
+ lastUpdateTime = base.lastUpdateTime;
+ serviceName = base.serviceName;
+ interfaceIndex = base.interfaceIndex;
+ network = base.network;
+ }
+
+ /**
+ * Compare records for equality, including their TTL.
+ *
+ * MdnsRecord#equals ignores TTL and receiptTimeMillis, but methods in this class need to update
+ * records when the TTL changes (especially for goodbye announcements).
+ */
+ private boolean recordsAreSame(MdnsRecord a, MdnsRecord b) {
+ if (!Objects.equals(a, b)) return false;
+ return a == null || a.getTtl() == b.getTtl();
}
/**
* Adds a pointer record.
*
* @return <code>true</code> if the record was added, or <code>false</code> if a matching
- * pointer
- * record is already present in the response.
+ * pointer record is already present in the response with the same TTL.
*/
public synchronized boolean addPointerRecord(MdnsPointerRecord pointerRecord) {
- if (!pointerRecords.contains(pointerRecord)) {
- pointerRecords.add(pointerRecord);
- records.add(pointerRecord);
- return true;
+ if (!Arrays.equals(serviceName, pointerRecord.getPointer())) {
+ throw new IllegalArgumentException(
+ "Pointer records for different service names cannot be added");
}
-
- return false;
+ final int existing = pointerRecords.indexOf(pointerRecord);
+ if (existing >= 0) {
+ if (recordsAreSame(pointerRecord, pointerRecords.get(existing))) {
+ return false;
+ }
+ final MdnsRecord record = pointerRecords.remove(existing);
+ records.remove(record);
+ }
+ pointerRecords.add(pointerRecord);
+ records.add(pointerRecord);
+ return true;
}
/** Gets the pointer records. */
@@ -170,44 +204,60 @@
return textRecord != null;
}
- /** Sets the IPv4 address record. */
- public synchronized boolean setInet4AddressRecord(
- @Nullable MdnsInetAddressRecord newInet4AddressRecord) {
- if (recordsAreSame(this.inet4AddressRecord, newInet4AddressRecord)) {
- return false;
+ /** Add the IPv4 address record. */
+ public synchronized boolean addInet4AddressRecord(
+ @NonNull MdnsInetAddressRecord newInet4AddressRecord) {
+ final int existing = inet4AddressRecords.indexOf(newInet4AddressRecord);
+ if (existing >= 0) {
+ if (recordsAreSame(newInet4AddressRecord, inet4AddressRecords.get(existing))) {
+ return false;
+ }
+ final MdnsRecord record = inet4AddressRecords.remove(existing);
+ records.remove(record);
}
- if (this.inet4AddressRecord != null) {
- records.remove(this.inet4AddressRecord);
- }
- if (newInet4AddressRecord != null && newInet4AddressRecord.getInet4Address() != null) {
- this.inet4AddressRecord = newInet4AddressRecord;
- records.add(this.inet4AddressRecord);
- }
+ inet4AddressRecords.add(newInet4AddressRecord);
+ records.add(newInet4AddressRecord);
return true;
}
- /** Gets the IPv4 address record. */
+ /** Gets the IPv4 address records. */
+ @NonNull
+ public synchronized List<MdnsInetAddressRecord> getInet4AddressRecords() {
+ return Collections.unmodifiableList(inet4AddressRecords);
+ }
+
+ /** Return the first IPv4 address record or null if no record. */
+ @Nullable
public synchronized MdnsInetAddressRecord getInet4AddressRecord() {
- return inet4AddressRecord;
+ return inet4AddressRecords.isEmpty() ? null : inet4AddressRecords.get(0);
}
+ /** Check whether response has IPv4 address record */
public synchronized boolean hasInet4AddressRecord() {
- return inet4AddressRecord != null;
+ return !inet4AddressRecords.isEmpty();
}
- /** Sets the IPv6 address record. */
- public synchronized boolean setInet6AddressRecord(
- @Nullable MdnsInetAddressRecord newInet6AddressRecord) {
- if (recordsAreSame(this.inet6AddressRecord, newInet6AddressRecord)) {
- return false;
+ /** Clear all IPv4 address records */
+ synchronized void clearInet4AddressRecords() {
+ for (MdnsInetAddressRecord record : inet4AddressRecords) {
+ records.remove(record);
}
- if (this.inet6AddressRecord != null) {
- records.remove(this.inet6AddressRecord);
+ inet4AddressRecords.clear();
+ }
+
+ /** Sets the IPv6 address records. */
+ public synchronized boolean addInet6AddressRecord(
+ @NonNull MdnsInetAddressRecord newInet6AddressRecord) {
+ final int existing = inet6AddressRecords.indexOf(newInet6AddressRecord);
+ if (existing >= 0) {
+ if (recordsAreSame(newInet6AddressRecord, inet6AddressRecords.get(existing))) {
+ return false;
+ }
+ final MdnsRecord record = inet6AddressRecords.remove(existing);
+ records.remove(record);
}
- if (newInet6AddressRecord != null && newInet6AddressRecord.getInet6Address() != null) {
- this.inet6AddressRecord = newInet6AddressRecord;
- records.add(this.inet6AddressRecord);
- }
+ inet6AddressRecords.add(newInet6AddressRecord);
+ records.add(newInet6AddressRecord);
return true;
}
@@ -227,13 +277,28 @@
return network;
}
- /** Gets the IPv6 address record. */
- public synchronized MdnsInetAddressRecord getInet6AddressRecord() {
- return inet6AddressRecord;
+ /** Gets all IPv6 address records. */
+ public synchronized List<MdnsInetAddressRecord> getInet6AddressRecords() {
+ return Collections.unmodifiableList(inet6AddressRecords);
}
+ /** Return the first IPv6 address record or null if no record. */
+ @Nullable
+ public synchronized MdnsInetAddressRecord getInet6AddressRecord() {
+ return inet6AddressRecords.isEmpty() ? null : inet6AddressRecords.get(0);
+ }
+
+ /** Check whether response has IPv6 address record */
public synchronized boolean hasInet6AddressRecord() {
- return inet6AddressRecord != null;
+ return !inet6AddressRecords.isEmpty();
+ }
+
+ /** Clear all IPv6 address records */
+ synchronized void clearInet6AddressRecords() {
+ for (MdnsInetAddressRecord record : inet6AddressRecords) {
+ records.remove(record);
+ }
+ inet6AddressRecords.clear();
}
/** Gets all of the records. */
@@ -242,101 +307,58 @@
}
/**
- * Merges any records that are present in another response into this one.
+ * Drop address records if they are for a hostname that does not match the service record.
*
- * @return <code>true</code> if any records were added or updated.
+ * @return True if the records were dropped.
*/
- public synchronized boolean mergeRecordsFrom(MdnsResponse other) {
- lastUpdateTime = other.lastUpdateTime;
+ public synchronized boolean dropUnmatchedAddressRecords() {
+ if (this.serviceRecord == null) return false;
+ boolean dropAddressRecords = false;
- boolean updated = false;
-
- List<MdnsPointerRecord> pointerRecords = other.getPointerRecords();
- if (pointerRecords != null) {
- for (MdnsPointerRecord pointerRecord : pointerRecords) {
- if (addPointerRecord(pointerRecord)) {
- updated = true;
- }
+ for (MdnsInetAddressRecord inetAddressRecord : getInet4AddressRecords()) {
+ if (!Arrays.equals(
+ this.serviceRecord.getServiceHost(), inetAddressRecord.getName())) {
+ dropAddressRecords = true;
+ }
+ }
+ for (MdnsInetAddressRecord inetAddressRecord : getInet6AddressRecords()) {
+ if (!Arrays.equals(
+ this.serviceRecord.getServiceHost(), inetAddressRecord.getName())) {
+ dropAddressRecords = true;
}
}
- MdnsServiceRecord serviceRecord = other.getServiceRecord();
- if (serviceRecord != null) {
- if (setServiceRecord(serviceRecord)) {
- updated = true;
- }
+ if (dropAddressRecords) {
+ clearInet4AddressRecords();
+ clearInet6AddressRecords();
+ return true;
}
-
- MdnsTextRecord textRecord = other.getTextRecord();
- if (textRecord != null) {
- if (setTextRecord(textRecord)) {
- updated = true;
- }
- }
-
- MdnsInetAddressRecord otherInet4AddressRecord = other.getInet4AddressRecord();
- if (otherInet4AddressRecord != null && otherInet4AddressRecord.getInet4Address() != null) {
- if (setInet4AddressRecord(otherInet4AddressRecord)) {
- updated = true;
- }
- }
-
- MdnsInetAddressRecord otherInet6AddressRecord = other.getInet6AddressRecord();
- if (otherInet6AddressRecord != null && otherInet6AddressRecord.getInet6Address() != null) {
- if (setInet6AddressRecord(otherInet6AddressRecord)) {
- updated = true;
- }
- }
-
- // If the hostname in the service record no longer matches the hostname in either of the
- // address records, then drop the address records.
- if (this.serviceRecord != null) {
- boolean dropAddressRecords = false;
-
- if (this.inet4AddressRecord != null) {
- if (!Arrays.equals(
- this.serviceRecord.getServiceHost(), this.inet4AddressRecord.getName())) {
- dropAddressRecords = true;
- }
- }
- if (this.inet6AddressRecord != null) {
- if (!Arrays.equals(
- this.serviceRecord.getServiceHost(), this.inet6AddressRecord.getName())) {
- dropAddressRecords = true;
- }
- }
-
- if (dropAddressRecords) {
- setInet4AddressRecord(null);
- setInet6AddressRecord(null);
- updated = true;
- }
- }
-
- return updated;
+ return false;
}
/**
- * Tests if the response is complete. A response is considered complete if it contains PTR, SRV,
- * TXT, and A (for IPv4) or AAAA (for IPv6) records.
+ * Tests if the response is complete. A response is considered complete if it contains SRV,
+ * TXT, and A (for IPv4) or AAAA (for IPv6) records. The service type->name mapping is always
+ * known when constructing a MdnsResponse, so this may return true when there is no PTR record.
*/
public synchronized boolean isComplete() {
- return !pointerRecords.isEmpty()
- && (serviceRecord != null)
+ return (serviceRecord != null)
&& (textRecord != null)
- && (inet4AddressRecord != null || inet6AddressRecord != null);
+ && (!inet4AddressRecords.isEmpty() || !inet6AddressRecords.isEmpty());
}
/**
* Returns the key for this response. The key uniquely identifies the response by its service
* name.
*/
- public synchronized String getServiceInstanceName() {
- if (pointerRecords.isEmpty()) {
- return null;
- }
- String[] pointers = pointerRecords.get(0).getPointer();
- return ((pointers != null) && (pointers.length > 0)) ? pointers[0] : null;
+ @Nullable
+ public String getServiceInstanceName() {
+ return serviceName.length > 0 ? serviceName[0] : null;
+ }
+
+ @NonNull
+ public String[] getServiceName() {
+ return serviceName;
}
/**
@@ -388,13 +410,13 @@
++count;
}
- if (inet4AddressRecord != null) {
- inet4AddressRecord.write(writer, now);
+ for (MdnsInetAddressRecord inetAddressRecord : inet4AddressRecords) {
+ inetAddressRecord.write(writer, now);
++count;
}
- if (inet6AddressRecord != null) {
- inet6AddressRecord.write(writer, now);
+ for (MdnsInetAddressRecord inetAddressRecord : inet6AddressRecords) {
+ inetAddressRecord.write(writer, now);
++count;
}
diff --git a/service-t/src/com/android/server/connectivity/mdns/MdnsResponseDecoder.java b/service-t/src/com/android/server/connectivity/mdns/MdnsResponseDecoder.java
index 82da2e4..0151202 100644
--- a/service-t/src/com/android/server/connectivity/mdns/MdnsResponseDecoder.java
+++ b/service-t/src/com/android/server/connectivity/mdns/MdnsResponseDecoder.java
@@ -20,18 +20,18 @@
import android.annotation.Nullable;
import android.net.Network;
import android.os.SystemClock;
+import android.util.ArraySet;
import com.android.server.connectivity.mdns.util.MdnsLogger;
import java.io.EOFException;
-import java.net.DatagramPacket;
import java.util.ArrayList;
import java.util.Arrays;
+import java.util.Collection;
import java.util.List;
/** A class that decodes mDNS responses from UDP packets. */
public class MdnsResponseDecoder {
-
public static final int SUCCESS = 0;
private static final String TAG = "MdnsResponseDecoder";
private static final MdnsLogger LOGGER = new MdnsLogger(TAG);
@@ -50,14 +50,8 @@
List<MdnsResponse> responses, String[] pointer) {
if (responses != null) {
for (MdnsResponse response : responses) {
- List<MdnsPointerRecord> pointerRecords = response.getPointerRecords();
- if (pointerRecords == null) {
- continue;
- }
- for (MdnsPointerRecord pointerRecord : pointerRecords) {
- if (Arrays.equals(pointerRecord.getPointer(), pointer)) {
- return response;
- }
+ if (Arrays.equals(response.getServiceName(), pointer)) {
+ return response;
}
}
}
@@ -82,34 +76,16 @@
/**
* Decodes all mDNS responses for the desired service type from a packet. The class does not
- * check
- * the responses for completeness; the caller should do that.
- *
- * @param packet The packet to read from.
- * @param interfaceIndex the network interface index (or {@link
- * MdnsSocket#INTERFACE_INDEX_UNSPECIFIED} if not known) at which the packet was received
- * @param network the network at which the packet was received, or null if it is unknown.
- * @return A list of mDNS responses, or null if the packet contained no appropriate responses.
- */
- public int decode(@NonNull DatagramPacket packet, @NonNull List<MdnsResponse> responses,
- int interfaceIndex, @Nullable Network network) {
- return decode(packet.getData(), packet.getLength(), responses, interfaceIndex, network);
- }
-
- /**
- * Decodes all mDNS responses for the desired service type from a packet. The class does not
- * check
- * the responses for completeness; the caller should do that.
+ * check the responses for completeness; the caller should do that.
*
* @param recvbuf The received data buffer to read from.
* @param length The length of received data buffer.
- * @param interfaceIndex the network interface index (or {@link
- * MdnsSocket#INTERFACE_INDEX_UNSPECIFIED} if not known) at which the packet was received
- * @param network the network at which the packet was received, or null if it is unknown.
- * @return A list of mDNS responses, or null if the packet contained no appropriate responses.
+ * @return A decoded {@link MdnsPacket}.
+ * @throws MdnsPacket.ParseException if a response packet could not be parsed.
*/
- public int decode(@NonNull byte[] recvbuf, int length, @NonNull List<MdnsResponse> responses,
- int interfaceIndex, @Nullable Network network) {
+ @NonNull
+ public static MdnsPacket parseResponse(@NonNull byte[] recvbuf, int length)
+ throws MdnsPacket.ParseException {
MdnsPacketReader reader = new MdnsPacketReader(recvbuf, length);
final MdnsPacket mdnsPacket;
@@ -117,21 +93,37 @@
reader.readUInt16(); // transaction ID (not used)
int flags = reader.readUInt16();
if ((flags & MdnsConstants.FLAGS_RESPONSE_MASK) != MdnsConstants.FLAGS_RESPONSE) {
- return MdnsResponseErrorCode.ERROR_NOT_RESPONSE_MESSAGE;
+ throw new MdnsPacket.ParseException(
+ MdnsResponseErrorCode.ERROR_NOT_RESPONSE_MESSAGE, "Not a response", null);
}
mdnsPacket = MdnsPacket.parseRecordsSection(reader, flags);
if (mdnsPacket.answers.size() < 1) {
- return MdnsResponseErrorCode.ERROR_NO_ANSWERS;
+ throw new MdnsPacket.ParseException(
+ MdnsResponseErrorCode.ERROR_NO_ANSWERS, "Response has no answers",
+ null);
}
+ return mdnsPacket;
} catch (EOFException e) {
- LOGGER.e("Reached the end of the mDNS response unexpectedly.", e);
- return MdnsResponseErrorCode.ERROR_END_OF_FILE;
- } catch (MdnsPacket.ParseException e) {
- LOGGER.e(e.getMessage(), e);
- return e.code;
+ throw new MdnsPacket.ParseException(MdnsResponseErrorCode.ERROR_END_OF_FILE,
+ "Reached the end of the mDNS response unexpectedly.", e);
}
+ }
+ /**
+ * Augments a list of {@link MdnsResponse} with records from a packet. The class does not check
+ * the resulting responses for completeness; the caller should do that.
+ *
+ * @param mdnsPacket the response packet with the new records
+ * @param existingResponses list of existing responses. Will not be modified.
+ * @param interfaceIndex the network interface index (or
+ * {@link MdnsSocket#INTERFACE_INDEX_UNSPECIFIED} if not known) at which the packet was received
+ * @param network the network at which the packet was received, or null if it is unknown.
+ * @return The set of response instances that were modified or newly added.
+ */
+ public ArraySet<MdnsResponse> augmentResponses(@NonNull MdnsPacket mdnsPacket,
+ @NonNull Collection<MdnsResponse> existingResponses, int interfaceIndex,
+ @Nullable Network network) {
final ArrayList<MdnsRecord> records = new ArrayList<>(
mdnsPacket.questions.size() + mdnsPacket.answers.size()
+ mdnsPacket.authorityRecords.size() + mdnsPacket.additionalRecords.size());
@@ -139,6 +131,11 @@
records.addAll(mdnsPacket.authorityRecords);
records.addAll(mdnsPacket.additionalRecords);
+ final ArraySet<MdnsResponse> modified = new ArraySet<>();
+ final ArrayList<MdnsResponse> responses = new ArrayList<>(existingResponses.size());
+ for (MdnsResponse existing : existingResponses) {
+ responses.add(new MdnsResponse(existing));
+ }
// The response records are structured in a hierarchy, where some records reference
// others, as follows:
//
@@ -178,12 +175,14 @@
MdnsResponse response = findResponseWithPointer(responses,
pointerRecord.getPointer());
if (response == null) {
- response = new MdnsResponse(now, interfaceIndex, network);
+ response = new MdnsResponse(now, pointerRecord.getPointer(), interfaceIndex,
+ network);
responses.add(response);
}
- // Set interface index earlier because some responses have PTR record only.
- // Need to know every response is getting from which interface.
- response.addPointerRecord((MdnsPointerRecord) record);
+
+ if (response.addPointerRecord((MdnsPointerRecord) record)) {
+ modified.add(response);
+ }
}
}
}
@@ -193,47 +192,94 @@
if (record instanceof MdnsServiceRecord) {
MdnsServiceRecord serviceRecord = (MdnsServiceRecord) record;
MdnsResponse response = findResponseWithPointer(responses, serviceRecord.getName());
- if (response != null) {
- response.setServiceRecord(serviceRecord);
+ if (response != null && response.setServiceRecord(serviceRecord)) {
+ response.dropUnmatchedAddressRecords();
+ modified.add(response);
}
} else if (record instanceof MdnsTextRecord) {
MdnsTextRecord textRecord = (MdnsTextRecord) record;
MdnsResponse response = findResponseWithPointer(responses, textRecord.getName());
- if (response != null) {
- response.setTextRecord(textRecord);
+ if (response != null && response.setTextRecord(textRecord)) {
+ modified.add(response);
}
}
}
- // Loop 3: find A and AAAA records, which reference the host name in the SRV record.
+ // Loop 3-1: find A and AAAA records and clear addresses if the cache-flush bit set, which
+ // reference the host name in the SRV record.
+ final List<MdnsInetAddressRecord> inetRecords = new ArrayList<>();
for (MdnsRecord record : records) {
if (record instanceof MdnsInetAddressRecord) {
MdnsInetAddressRecord inetRecord = (MdnsInetAddressRecord) record;
+ inetRecords.add(inetRecord);
if (allowMultipleSrvRecordsPerHost) {
List<MdnsResponse> matchingResponses =
findResponsesWithHostName(responses, inetRecord.getName());
for (MdnsResponse response : matchingResponses) {
- assignInetRecord(response, inetRecord);
+ // Per RFC6762 10.2, clear all address records if the cache-flush bit set.
+ // This bit, the cache-flush bit, tells neighboring hosts
+ // that this is not a shared record type. Instead of merging this new
+ // record additively into the cache in addition to any previous records with
+ // the same name, rrtype, and rrclass, all old records with that name,
+ // rrtype, and rrclass that were received more than one second ago are
+ // declared invalid, and marked to expire from the cache in one second.
+ if (inetRecord.getCacheFlush()) {
+ response.clearInet4AddressRecords();
+ response.clearInet6AddressRecords();
+ }
}
} else {
MdnsResponse response =
findResponseWithHostName(responses, inetRecord.getName());
if (response != null) {
- assignInetRecord(response, inetRecord);
+ // Per RFC6762 10.2, clear all address records if the cache-flush bit set.
+ // This bit, the cache-flush bit, tells neighboring hosts
+ // that this is not a shared record type. Instead of merging this new
+ // record additively into the cache in addition to any previous records with
+ // the same name, rrtype, and rrclass, all old records with that name,
+ // rrtype, and rrclass that were received more than one second ago are
+ // declared invalid, and marked to expire from the cache in one second.
+ if (inetRecord.getCacheFlush()) {
+ response.clearInet4AddressRecords();
+ response.clearInet6AddressRecords();
+ }
}
}
}
}
- return SUCCESS;
+ // Loop 3-2: Assign addresses, which reference the host name in the SRV record.
+ for (MdnsInetAddressRecord inetRecord : inetRecords) {
+ if (allowMultipleSrvRecordsPerHost) {
+ List<MdnsResponse> matchingResponses =
+ findResponsesWithHostName(responses, inetRecord.getName());
+ for (MdnsResponse response : matchingResponses) {
+ if (assignInetRecord(response, inetRecord)) {
+ modified.add(response);
+ }
+ }
+ } else {
+ MdnsResponse response =
+ findResponseWithHostName(responses, inetRecord.getName());
+ if (response != null) {
+ if (assignInetRecord(response, inetRecord)) {
+ modified.add(response);
+ }
+ }
+ }
+ }
+
+ return modified;
}
- private static void assignInetRecord(MdnsResponse response, MdnsInetAddressRecord inetRecord) {
+ private static boolean assignInetRecord(
+ MdnsResponse response, MdnsInetAddressRecord inetRecord) {
if (inetRecord.getInet4Address() != null) {
- response.setInet4AddressRecord(inetRecord);
+ return response.addInet4AddressRecord(inetRecord);
} else if (inetRecord.getInet6Address() != null) {
- response.setInet6AddressRecord(inetRecord);
+ return response.addInet6AddressRecord(inetRecord);
}
+ return false;
}
private static List<MdnsResponse> findResponsesWithHostName(
diff --git a/service-t/src/com/android/server/connectivity/mdns/MdnsSearchOptions.java b/service-t/src/com/android/server/connectivity/mdns/MdnsSearchOptions.java
index 583c4a9..3da6bd0 100644
--- a/service-t/src/com/android/server/connectivity/mdns/MdnsSearchOptions.java
+++ b/service-t/src/com/android/server/connectivity/mdns/MdnsSearchOptions.java
@@ -46,7 +46,8 @@
public MdnsSearchOptions createFromParcel(Parcel source) {
return new MdnsSearchOptions(source.createStringArrayList(),
source.readBoolean(), source.readBoolean(),
- source.readParcelable(null));
+ source.readParcelable(null),
+ source.readString());
}
@Override
@@ -56,6 +57,8 @@
};
private static MdnsSearchOptions defaultOptions;
private final List<String> subtypes;
+ @Nullable
+ private final String resolveInstanceName;
private final boolean isPassiveMode;
private final boolean removeExpiredService;
@@ -64,7 +67,7 @@
/** Parcelable constructs for a {@link MdnsSearchOptions}. */
MdnsSearchOptions(List<String> subtypes, boolean isPassiveMode, boolean removeExpiredService,
- @Nullable Network network) {
+ @Nullable Network network, @Nullable String resolveInstanceName) {
this.subtypes = new ArrayList<>();
if (subtypes != null) {
this.subtypes.addAll(subtypes);
@@ -72,6 +75,7 @@
this.isPassiveMode = isPassiveMode;
this.removeExpiredService = removeExpiredService;
mNetwork = network;
+ this.resolveInstanceName = resolveInstanceName;
}
/** Returns a {@link Builder} for {@link MdnsSearchOptions}. */
@@ -115,6 +119,15 @@
return mNetwork;
}
+ /**
+ * If non-null, queries should try to resolve all records of this specific service, rather than
+ * discovering all services.
+ */
+ @Nullable
+ public String getResolveInstanceName() {
+ return resolveInstanceName;
+ }
+
@Override
public int describeContents() {
return 0;
@@ -126,6 +139,7 @@
out.writeBoolean(isPassiveMode);
out.writeBoolean(removeExpiredService);
out.writeParcelable(mNetwork, 0);
+ out.writeString(resolveInstanceName);
}
/** A builder to create {@link MdnsSearchOptions}. */
@@ -134,6 +148,7 @@
private boolean isPassiveMode = true;
private boolean removeExpiredService;
private Network mNetwork;
+ private String resolveInstanceName;
private Builder() {
subtypes = new ArraySet<>();
@@ -194,10 +209,22 @@
return this;
}
+ /**
+ * Set the instance name to resolve.
+ *
+ * If non-null, queries should try to resolve all records of this specific service,
+ * rather than discovering all services.
+ * @param name The instance name.
+ */
+ public Builder setResolveInstanceName(String name) {
+ resolveInstanceName = name;
+ return this;
+ }
+
/** Builds a {@link MdnsSearchOptions} with the arguments supplied to this builder. */
public MdnsSearchOptions build() {
return new MdnsSearchOptions(new ArrayList<>(subtypes), isPassiveMode,
- removeExpiredService, mNetwork);
+ removeExpiredService, mNetwork, resolveInstanceName);
}
}
}
\ No newline at end of file
diff --git a/service-t/src/com/android/server/connectivity/mdns/MdnsServiceInfo.java b/service-t/src/com/android/server/connectivity/mdns/MdnsServiceInfo.java
index 938fc3f..78df6df 100644
--- a/service-t/src/com/android/server/connectivity/mdns/MdnsServiceInfo.java
+++ b/service-t/src/com/android/server/connectivity/mdns/MdnsServiceInfo.java
@@ -31,10 +31,10 @@
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
-import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
+import java.util.TreeMap;
/**
* A class representing a discovered mDNS service instance.
@@ -57,8 +57,8 @@
source.createStringArrayList(),
source.createStringArray(),
source.readInt(),
- source.readString(),
- source.readString(),
+ source.createStringArrayList(),
+ source.createStringArrayList(),
source.createStringArrayList(),
source.createTypedArrayList(TextEntry.CREATOR),
source.readInt(),
@@ -76,10 +76,10 @@
private final List<String> subtypes;
private final String[] hostName;
private final int port;
- @Nullable
- private final String ipv4Address;
- @Nullable
- private final String ipv6Address;
+ @NonNull
+ private final List<String> ipv4Addresses;
+ @NonNull
+ private final List<String> ipv6Addresses;
final List<String> textStrings;
@Nullable
final List<TextEntry> textEntries;
@@ -105,8 +105,8 @@
subtypes,
hostName,
port,
- ipv4Address,
- ipv6Address,
+ List.of(ipv4Address),
+ List.of(ipv6Address),
textStrings,
/* textEntries= */ null,
/* interfaceIndex= */ INTERFACE_INDEX_UNSPECIFIED,
@@ -130,8 +130,8 @@
subtypes,
hostName,
port,
- ipv4Address,
- ipv6Address,
+ List.of(ipv4Address),
+ List.of(ipv6Address),
textStrings,
textEntries,
/* interfaceIndex= */ INTERFACE_INDEX_UNSPECIFIED,
@@ -160,8 +160,8 @@
subtypes,
hostName,
port,
- ipv4Address,
- ipv6Address,
+ List.of(ipv4Address),
+ List.of(ipv6Address),
textStrings,
textEntries,
interfaceIndex,
@@ -179,8 +179,8 @@
@Nullable List<String> subtypes,
String[] hostName,
int port,
- @Nullable String ipv4Address,
- @Nullable String ipv6Address,
+ @NonNull List<String> ipv4Addresses,
+ @NonNull List<String> ipv6Addresses,
@Nullable List<String> textStrings,
@Nullable List<TextEntry> textEntries,
int interfaceIndex,
@@ -193,8 +193,8 @@
}
this.hostName = hostName;
this.port = port;
- this.ipv4Address = ipv4Address;
- this.ipv6Address = ipv6Address;
+ this.ipv4Addresses = new ArrayList<>(ipv4Addresses);
+ this.ipv6Addresses = new ArrayList<>(ipv6Addresses);
this.textStrings = new ArrayList<>();
if (textStrings != null) {
this.textStrings.addAll(textStrings);
@@ -205,17 +205,14 @@
// compatibility. We should prefer only {@code textEntries} if it's not null.
List<TextEntry> entries =
(this.textEntries != null) ? this.textEntries : parseTextStrings(this.textStrings);
- Map<String, byte[]> attributes = new HashMap<>(entries.size());
+ // The map of attributes is case-insensitive.
+ final Map<String, byte[]> attributes = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
for (TextEntry entry : entries) {
- String key = entry.getKey().toLowerCase(Locale.ENGLISH);
-
// Per https://datatracker.ietf.org/doc/html/rfc6763#section-6.4, only the first entry
// of the same key should be accepted:
// If a client receives a TXT record containing the same key more than once, then the
// client MUST silently ignore all but the first occurrence of that attribute.
- if (!attributes.containsKey(key)) {
- attributes.put(key, entry.getValue());
- }
+ attributes.putIfAbsent(entry.getKey(), entry.getValue());
}
this.attributes = Collections.unmodifiableMap(attributes);
this.interfaceIndex = interfaceIndex;
@@ -263,16 +260,41 @@
return port;
}
- /** Returns the IPV4 address of this service instance. */
+ /** Returns the IPV4 addresses of this service instance. */
+ @NonNull
+ public List<String> getIpv4Addresses() {
+ return Collections.unmodifiableList(ipv4Addresses);
+ }
+
+ /**
+ * Returns the first IPV4 address of this service instance.
+ *
+ * @deprecated Use {@link #getIpv4Addresses()} to get the entire list of IPV4
+ * addresses for
+ * the host.
+ */
@Nullable
+ @Deprecated
public String getIpv4Address() {
- return ipv4Address;
+ return ipv4Addresses.isEmpty() ? null : ipv4Addresses.get(0);
}
/** Returns the IPV6 address of this service instance. */
+ @NonNull
+ public List<String> getIpv6Addresses() {
+ return Collections.unmodifiableList(ipv6Addresses);
+ }
+
+ /**
+ * Returns the first IPV6 address of this service instance.
+ *
+ * @deprecated Use {@link #getIpv6Addresses()} to get the entire list of IPV6 addresses for
+ * the host.
+ */
@Nullable
+ @Deprecated
public String getIpv6Address() {
- return ipv6Address;
+ return ipv6Addresses.isEmpty() ? null : ipv6Addresses.get(0);
}
/**
@@ -311,12 +333,12 @@
*/
@Nullable
public byte[] getAttributeAsBytes(@NonNull String key) {
- return attributes.get(key.toLowerCase(Locale.ENGLISH));
+ return attributes.get(key);
}
/** Returns an immutable map of all attributes. */
public Map<String, String> getAttributes() {
- Map<String, String> map = new HashMap<>(attributes.size());
+ Map<String, String> map = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
for (Map.Entry<String, byte[]> kv : attributes.entrySet()) {
final byte[] value = kv.getValue();
map.put(kv.getKey(), value == null ? null : new String(value, UTF_8));
@@ -336,8 +358,8 @@
out.writeStringList(subtypes);
out.writeStringArray(hostName);
out.writeInt(port);
- out.writeString(ipv4Address);
- out.writeString(ipv6Address);
+ out.writeStringList(ipv4Addresses);
+ out.writeStringList(ipv6Addresses);
out.writeStringList(textStrings);
out.writeTypedList(textEntries);
out.writeInt(interfaceIndex);
@@ -346,13 +368,16 @@
@Override
public String toString() {
- return String.format(
- Locale.ROOT,
- "Name: %s, subtypes: %s, ip: %s, port: %d",
- serviceInstanceName,
- TextUtils.join(",", subtypes),
- ipv4Address,
- port);
+ return "Name: " + serviceInstanceName
+ + ", type: " + TextUtils.join(".", serviceType)
+ + ", subtypes: " + TextUtils.join(",", subtypes)
+ + ", ip: " + ipv4Addresses
+ + ", ipv6: " + ipv6Addresses
+ + ", port: " + port
+ + ", interfaceIndex: " + interfaceIndex
+ + ", network: " + network
+ + ", textStrings: " + textStrings
+ + ", textEntries: " + textEntries;
}
diff --git a/service-t/src/com/android/server/connectivity/mdns/MdnsServiceTypeClient.java b/service-t/src/com/android/server/connectivity/mdns/MdnsServiceTypeClient.java
index d26fbdb..df270bb 100644
--- a/service-t/src/com/android/server/connectivity/mdns/MdnsServiceTypeClient.java
+++ b/service-t/src/com/android/server/connectivity/mdns/MdnsServiceTypeClient.java
@@ -21,8 +21,8 @@
import android.annotation.NonNull;
import android.annotation.Nullable;
import android.net.Network;
-import android.os.SystemClock;
import android.text.TextUtils;
+import android.util.ArrayMap;
import android.util.ArraySet;
import android.util.Pair;
@@ -33,12 +33,12 @@
import java.net.Inet4Address;
import java.net.Inet6Address;
import java.util.ArrayList;
+import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
-import java.util.Set;
import java.util.concurrent.Future;
import java.util.concurrent.ScheduledExecutorService;
@@ -51,18 +51,23 @@
private static final int DEFAULT_MTU = 1500;
private static final MdnsLogger LOGGER = new MdnsLogger("MdnsServiceTypeClient");
+
private final String serviceType;
private final String[] serviceTypeLabels;
private final MdnsSocketClientBase socketClient;
+ private final MdnsResponseDecoder responseDecoder;
private final ScheduledExecutorService executor;
private final Object lock = new Object();
- private final Set<MdnsServiceBrowserListener> listeners = new ArraySet<>();
+ private final ArrayMap<MdnsServiceBrowserListener, MdnsSearchOptions> listeners =
+ new ArrayMap<>();
private final Map<String, MdnsResponse> instanceNameToResponse = new HashMap<>();
private final boolean removeServiceAfterTtlExpires =
MdnsConfigs.removeServiceAfterTtlExpires();
private final boolean allowSearchOptionsToRemoveExpiredService =
MdnsConfigs.allowSearchOptionsToRemoveExpiredService();
+ private final MdnsResponseDecoder.Clock clock;
+
@Nullable private MdnsSearchOptions searchOptions;
// The session ID increases when startSendAndReceive() is called where we schedule a
@@ -84,10 +89,21 @@
@NonNull String serviceType,
@NonNull MdnsSocketClientBase socketClient,
@NonNull ScheduledExecutorService executor) {
+ this(serviceType, socketClient, executor, new MdnsResponseDecoder.Clock());
+ }
+
+ @VisibleForTesting
+ public MdnsServiceTypeClient(
+ @NonNull String serviceType,
+ @NonNull MdnsSocketClientBase socketClient,
+ @NonNull ScheduledExecutorService executor,
+ @NonNull MdnsResponseDecoder.Clock clock) {
this.serviceType = serviceType;
this.socketClient = socketClient;
this.executor = executor;
- serviceTypeLabels = TextUtils.split(serviceType, "\\.");
+ this.serviceTypeLabels = TextUtils.split(serviceType, "\\.");
+ this.responseDecoder = new MdnsResponseDecoder(clock, serviceTypeLabels);
+ this.clock = clock;
}
private static MdnsServiceInfo buildMdnsServiceInfoFromResponse(
@@ -99,15 +115,19 @@
port = response.getServiceRecord().getServicePort();
}
- String ipv4Address = null;
- String ipv6Address = null;
+ final List<String> ipv4Addresses = new ArrayList<>();
+ final List<String> ipv6Addresses = new ArrayList<>();
if (response.hasInet4AddressRecord()) {
- Inet4Address inet4Address = response.getInet4AddressRecord().getInet4Address();
- ipv4Address = (inet4Address == null) ? null : inet4Address.getHostAddress();
+ for (MdnsInetAddressRecord inetAddressRecord : response.getInet4AddressRecords()) {
+ final Inet4Address inet4Address = inetAddressRecord.getInet4Address();
+ ipv4Addresses.add((inet4Address == null) ? null : inet4Address.getHostAddress());
+ }
}
if (response.hasInet6AddressRecord()) {
- Inet6Address inet6Address = response.getInet6AddressRecord().getInet6Address();
- ipv6Address = (inet6Address == null) ? null : inet6Address.getHostAddress();
+ for (MdnsInetAddressRecord inetAddressRecord : response.getInet6AddressRecords()) {
+ final Inet6Address inet6Address = inetAddressRecord.getInet6Address();
+ ipv6Addresses.add((inet6Address == null) ? null : inet6Address.getHostAddress());
+ }
}
String serviceInstanceName = response.getServiceInstanceName();
if (serviceInstanceName == null) {
@@ -127,8 +147,8 @@
response.getSubtypes(),
hostName,
port,
- ipv4Address,
- ipv6Address,
+ ipv4Addresses,
+ ipv6Addresses,
textStrings,
textEntries,
response.getInterfaceIndex(),
@@ -148,7 +168,7 @@
@NonNull MdnsSearchOptions searchOptions) {
synchronized (lock) {
this.searchOptions = searchOptions;
- if (listeners.add(listener)) {
+ if (listeners.put(listener, searchOptions) == null) {
for (MdnsResponse existingResponse : instanceNameToResponse.values()) {
final MdnsServiceInfo info =
buildMdnsServiceInfoFromResponse(existingResponse, serviceTypeLabels);
@@ -197,65 +217,63 @@
return serviceTypeLabels;
}
- public synchronized void processResponse(@NonNull MdnsResponse response) {
- if (shouldRemoveServiceAfterTtlExpires()) {
- // Because {@link QueryTask} and {@link processResponse} are running in different
- // threads. We need to synchronize {@link lock} to protect
- // {@link instanceNameToResponse} won’t be modified at the same time.
- synchronized (lock) {
- if (response.isGoodbye()) {
- onGoodbyeReceived(response.getServiceInstanceName());
+ /**
+ * Process an incoming response packet.
+ */
+ public synchronized void processResponse(@NonNull MdnsPacket packet, int interfaceIndex,
+ Network network) {
+ synchronized (lock) {
+ // Augment the list of current known responses, and generated responses for resolve
+ // requests if there is no known response
+ final List<MdnsResponse> currentList = new ArrayList<>(instanceNameToResponse.values());
+ currentList.addAll(makeResponsesForResolveIfUnknown(interfaceIndex, network));
+ final ArraySet<MdnsResponse> modifiedResponses = responseDecoder.augmentResponses(
+ packet, currentList, interfaceIndex, network);
+
+ for (MdnsResponse modified : modifiedResponses) {
+ if (modified.isGoodbye()) {
+ onGoodbyeReceived(modified.getServiceInstanceName());
} else {
- onResponseReceived(response);
+ onResponseModified(modified);
}
}
- } else {
- if (response.isGoodbye()) {
- onGoodbyeReceived(response.getServiceInstanceName());
- } else {
- onResponseReceived(response);
- }
}
}
public synchronized void onFailedToParseMdnsResponse(int receivedPacketNumber, int errorCode) {
- for (MdnsServiceBrowserListener listener : listeners) {
- listener.onFailedToParseMdnsResponse(receivedPacketNumber, errorCode);
+ for (int i = 0; i < listeners.size(); i++) {
+ listeners.keyAt(i).onFailedToParseMdnsResponse(receivedPacketNumber, errorCode);
}
}
- private void onResponseReceived(@NonNull MdnsResponse response) {
- MdnsResponse currentResponse;
- currentResponse = instanceNameToResponse.get(response.getServiceInstanceName());
+ private void onResponseModified(@NonNull MdnsResponse response) {
+ final MdnsResponse currentResponse =
+ instanceNameToResponse.get(response.getServiceInstanceName());
boolean newServiceFound = false;
- boolean existingServiceChanged = false;
boolean serviceBecomesComplete = false;
if (currentResponse == null) {
newServiceFound = true;
- currentResponse = response;
String serviceInstanceName = response.getServiceInstanceName();
if (serviceInstanceName != null) {
- instanceNameToResponse.put(serviceInstanceName, currentResponse);
+ instanceNameToResponse.put(serviceInstanceName, response);
}
} else {
boolean before = currentResponse.isComplete();
- existingServiceChanged = currentResponse.mergeRecordsFrom(response);
- boolean after = currentResponse.isComplete();
+ instanceNameToResponse.put(response.getServiceInstanceName(), response);
+ boolean after = response.isComplete();
serviceBecomesComplete = !before && after;
}
- if (!newServiceFound && !existingServiceChanged) {
- return;
- }
MdnsServiceInfo serviceInfo =
- buildMdnsServiceInfoFromResponse(currentResponse, serviceTypeLabels);
+ buildMdnsServiceInfoFromResponse(response, serviceTypeLabels);
- for (MdnsServiceBrowserListener listener : listeners) {
+ for (int i = 0; i < listeners.size(); i++) {
+ final MdnsServiceBrowserListener listener = listeners.keyAt(i);
if (newServiceFound) {
listener.onServiceNameDiscovered(serviceInfo);
}
- if (currentResponse.isComplete()) {
+ if (response.isComplete()) {
if (newServiceFound || serviceBecomesComplete) {
listener.onServiceFound(serviceInfo);
} else {
@@ -270,7 +288,8 @@
if (response == null) {
return;
}
- for (MdnsServiceBrowserListener listener : listeners) {
+ for (int i = 0; i < listeners.size(); i++) {
+ final MdnsServiceBrowserListener listener = listeners.keyAt(i);
final MdnsServiceInfo serviceInfo =
buildMdnsServiceInfoFromResponse(response, serviceTypeLabels);
if (response.isComplete()) {
@@ -389,6 +408,29 @@
}
}
+ private List<MdnsResponse> makeResponsesForResolveIfUnknown(int interfaceIndex,
+ @NonNull Network network) {
+ final List<MdnsResponse> resolveResponses = new ArrayList<>();
+ for (int i = 0; i < listeners.size(); i++) {
+ final String resolveName = listeners.valueAt(i).getResolveInstanceName();
+ if (resolveName == null) {
+ continue;
+ }
+ MdnsResponse knownResponse = instanceNameToResponse.get(resolveName);
+ if (knownResponse == null) {
+ final ArrayList<String> instanceFullName = new ArrayList<>(
+ serviceTypeLabels.length + 1);
+ instanceFullName.add(resolveName);
+ instanceFullName.addAll(Arrays.asList(serviceTypeLabels));
+ knownResponse = new MdnsResponse(
+ 0L /* lastUpdateTime */, instanceFullName.toArray(new String[0]),
+ interfaceIndex, network);
+ }
+ resolveResponses.add(knownResponse);
+ }
+ return resolveResponses;
+ }
+
// A FutureTask that enqueues a single query, and schedule a new FutureTask for the next task.
private class QueryTask implements Runnable {
@@ -400,6 +442,18 @@
@Override
public void run() {
+ final List<MdnsResponse> servicesToResolve;
+ final boolean sendDiscoveryQueries;
+ synchronized (lock) {
+ // The listener is requesting to resolve a service that has no info in
+ // cache. Use the provided name to generate a minimal response, so other records are
+ // queried to complete it.
+ // Only the names are used to know which queries to send, other parameters like
+ // interfaceIndex do not matter.
+ servicesToResolve = makeResponsesForResolveIfUnknown(
+ 0 /* interfaceIndex */, config.network);
+ sendDiscoveryQueries = servicesToResolve.size() < listeners.size();
+ }
Pair<Integer, List<String>> result;
try {
result =
@@ -410,7 +464,9 @@
config.subtypes,
config.expectUnicastResponse,
config.transactionId,
- config.network)
+ config.network,
+ sendDiscoveryQueries,
+ servicesToResolve)
.call();
} catch (RuntimeException e) {
LOGGER.e(String.format("Failed to run EnqueueMdnsQueryCallable for subtype: %s",
@@ -435,8 +491,8 @@
}
}
if ((result != null)) {
- for (MdnsServiceBrowserListener listener : listeners) {
- listener.onDiscoveryQuerySent(result.second, result.first);
+ for (int i = 0; i < listeners.size(); i++) {
+ listeners.keyAt(i).onDiscoveryQuerySent(result.second, result.first);
}
}
if (shouldRemoveServiceAfterTtlExpires()) {
@@ -446,10 +502,11 @@
if (existingResponse.hasServiceRecord()
&& existingResponse
.getServiceRecord()
- .getRemainingTTL(SystemClock.elapsedRealtime())
+ .getRemainingTTL(clock.elapsedRealtime())
== 0) {
iter.remove();
- for (MdnsServiceBrowserListener listener : listeners) {
+ for (int i = 0; i < listeners.size(); i++) {
+ final MdnsServiceBrowserListener listener = listeners.keyAt(i);
String serviceInstanceName =
existingResponse.getServiceInstanceName();
if (serviceInstanceName != null) {
diff --git a/service-t/src/com/android/server/connectivity/mdns/MdnsSocketClient.java b/service-t/src/com/android/server/connectivity/mdns/MdnsSocketClient.java
index 907687e..c03e6aa 100644
--- a/service-t/src/com/android/server/connectivity/mdns/MdnsSocketClient.java
+++ b/service-t/src/com/android/server/connectivity/mdns/MdnsSocketClient.java
@@ -16,8 +16,6 @@
package com.android.server.connectivity.mdns;
-import static com.android.server.connectivity.mdns.MdnsSocketClientBase.Callback;
-
import android.Manifest.permission;
import android.annotation.NonNull;
import android.annotation.Nullable;
@@ -35,7 +33,6 @@
import java.net.DatagramPacket;
import java.util.ArrayDeque;
import java.util.ArrayList;
-import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.Timer;
@@ -73,7 +70,6 @@
private final Context context;
private final byte[] multicastReceiverBuffer = new byte[RECEIVER_BUFFER_SIZE];
@Nullable private final byte[] unicastReceiverBuffer;
- private final MdnsResponseDecoder responseDecoder;
private final MulticastLock multicastLock;
private final boolean useSeparateSocketForUnicast =
MdnsConfigs.useSeparateSocketToSendUnicastQuery();
@@ -110,7 +106,6 @@
public MdnsSocketClient(@NonNull Context context, @NonNull MulticastLock multicastLock) {
this.context = context;
this.multicastLock = multicastLock;
- responseDecoder = new MdnsResponseDecoder(new MdnsResponseDecoder.Clock(), null);
if (useSeparateSocketForUnicast) {
unicastReceiverBuffer = new byte[RECEIVER_BUFFER_SIZE];
} else {
@@ -421,37 +416,27 @@
int interfaceIndex, @Nullable Network network) {
int packetNumber = ++receivedPacketNumber;
- List<MdnsResponse> responses = new LinkedList<>();
- int errorCode = responseDecoder.decode(packet, responses, interfaceIndex, network);
- if (errorCode == MdnsResponseDecoder.SUCCESS) {
- if (responseType.equals(MULTICAST_TYPE)) {
- receivedMulticastResponse = true;
- if (cannotReceiveMulticastResponse.getAndSet(false)) {
- // If we are already in the bad state, receiving a multicast response means
- // we are recovered.
- LOGGER.e(
- "Recovered from the state where the phone can't receive any multicast"
- + " response");
- }
- } else {
- receivedUnicastResponse = true;
- }
- for (MdnsResponse response : responses) {
- String serviceInstanceName = response.getServiceInstanceName();
- LOGGER.log("mDNS %s response received: %s at ifIndex %d", responseType,
- serviceInstanceName, interfaceIndex);
- if (callback != null) {
- callback.onResponseReceived(response);
- }
- }
- } else if (errorCode != MdnsResponseErrorCode.ERROR_NOT_RESPONSE_MESSAGE) {
+ final MdnsPacket response;
+ try {
+ response = MdnsResponseDecoder.parseResponse(packet.getData(), packet.getLength());
+ } catch (MdnsPacket.ParseException e) {
LOGGER.w(String.format("Error while decoding %s packet (%d): %d",
- responseType, packetNumber, errorCode));
+ responseType, packetNumber, e.code));
if (callback != null) {
- callback.onFailedToParseMdnsResponse(packetNumber, errorCode);
+ callback.onFailedToParseMdnsResponse(packetNumber, e.code);
}
+ return e.code;
}
- return errorCode;
+
+ if (response == null) {
+ return MdnsResponseErrorCode.ERROR_NOT_RESPONSE_MESSAGE;
+ }
+
+ if (callback != null) {
+ callback.onResponseReceived(response, interfaceIndex, network);
+ }
+
+ return MdnsResponseErrorCode.SUCCESS;
}
@VisibleForTesting
diff --git a/service-t/src/com/android/server/connectivity/mdns/MdnsSocketClientBase.java b/service-t/src/com/android/server/connectivity/mdns/MdnsSocketClientBase.java
index 23504a0..796dc83 100644
--- a/service-t/src/com/android/server/connectivity/mdns/MdnsSocketClientBase.java
+++ b/service-t/src/com/android/server/connectivity/mdns/MdnsSocketClientBase.java
@@ -72,7 +72,8 @@
/*** Callback for mdns response */
interface Callback {
/*** Receive a mdns response */
- void onResponseReceived(@NonNull MdnsResponse response);
+ void onResponseReceived(@NonNull MdnsPacket packet, int interfaceIndex,
+ @Nullable Network network);
/*** Parse a mdns response failed */
void onFailedToParseMdnsResponse(int receivedPacketNumber, int errorCode);
diff --git a/service-t/src/com/android/server/connectivity/mdns/MdnsSocketProvider.java b/service-t/src/com/android/server/connectivity/mdns/MdnsSocketProvider.java
index 9298852..743f946 100644
--- a/service-t/src/com/android/server/connectivity/mdns/MdnsSocketProvider.java
+++ b/service-t/src/com/android/server/connectivity/mdns/MdnsSocketProvider.java
@@ -82,6 +82,7 @@
private final List<String> mTetheredInterfaces = new ArrayList<>();
private final byte[] mPacketReadBuffer = new byte[READ_BUFFER_SIZE];
private boolean mMonitoringSockets = false;
+ private boolean mRequestStop = false;
public MdnsSocketProvider(@NonNull Context context, @NonNull Looper looper) {
this(context, looper, new Dependencies());
@@ -179,6 +180,7 @@
/*** Start monitoring sockets by listening callbacks for sockets creation or removal */
public void startMonitoringSockets() {
ensureRunningOnHandlerThread(mHandler);
+ mRequestStop = false; // Reset stop request flag.
if (mMonitoringSockets) {
Log.d(TAG, "Already monitoring sockets.");
return;
@@ -195,22 +197,34 @@
mMonitoringSockets = true;
}
- /*** Stop monitoring sockets and unregister callbacks */
- public void stopMonitoringSockets() {
+ private void maybeStopMonitoringSockets() {
+ if (!mMonitoringSockets) return; // Already unregistered.
+ if (!mRequestStop) return; // No stop request.
+
+ // Only unregister the network callback if there is no socket request.
+ if (mCallbacksToRequestedNetworks.isEmpty()) {
+ mContext.getSystemService(ConnectivityManager.class)
+ .unregisterNetworkCallback(mNetworkCallback);
+
+ final TetheringManager tetheringManager = mContext.getSystemService(
+ TetheringManager.class);
+ tetheringManager.unregisterTetheringEventCallback(mTetheringEventCallback);
+
+ mHandler.post(mNetlinkMonitor::stop);
+ mMonitoringSockets = false;
+ }
+ }
+
+ /*** Request to stop monitoring sockets and unregister callbacks */
+ public void requestStopWhenInactive() {
ensureRunningOnHandlerThread(mHandler);
if (!mMonitoringSockets) {
Log.d(TAG, "Monitoring sockets hasn't been started.");
return;
}
- if (DBG) Log.d(TAG, "Stop monitoring sockets.");
- mContext.getSystemService(ConnectivityManager.class)
- .unregisterNetworkCallback(mNetworkCallback);
-
- final TetheringManager tetheringManager = mContext.getSystemService(TetheringManager.class);
- tetheringManager.unregisterTetheringEventCallback(mTetheringEventCallback);
-
- mHandler.post(mNetlinkMonitor::stop);
- mMonitoringSockets = false;
+ if (DBG) Log.d(TAG, "Try to stop monitoring sockets.");
+ mRequestStop = true;
+ maybeStopMonitoringSockets();
}
/*** Check whether the target network is matched current network */
@@ -450,6 +464,9 @@
cb.onInterfaceDestroyed(new Network(INetd.LOCAL_NET_ID), info.mSocket);
}
mTetherInterfaceSockets.clear();
+
+ // Try to unregister network callback.
+ maybeStopMonitoringSockets();
}
/*** Callbacks for listening socket changes */
diff --git a/service-t/src/com/android/server/ethernet/EthernetNetworkFactory.java b/service-t/src/com/android/server/ethernet/EthernetNetworkFactory.java
index 60485f1..eed9aeb 100644
--- a/service-t/src/com/android/server/ethernet/EthernetNetworkFactory.java
+++ b/service-t/src/com/android/server/ethernet/EthernetNetworkFactory.java
@@ -469,9 +469,7 @@
// TODO: Update this logic to only do a restart if required. Although a restart may
// be required due to the capabilities or ipConfiguration values, not all
// capabilities changes require a restart.
- if (mIpClient != null) {
- restart();
- }
+ maybeRestart();
}
boolean isRestricted() {
@@ -549,7 +547,7 @@
// Send a callback in case a provisioning request was in progress.
return;
}
- restart();
+ maybeRestart();
}
private void ensureRunningOnEthernetHandlerThread() {
@@ -582,7 +580,7 @@
// If there is a better network, that will become default and apps
// will be able to use internet. If ethernet gets connected again,
// and has backhaul connectivity, it will become default.
- restart();
+ maybeRestart();
}
/** Returns true if state has been modified */
@@ -656,18 +654,16 @@
.build();
}
- void restart() {
- if (DBG) Log.d(TAG, "restart IpClient");
-
+ void maybeRestart() {
if (mIpClient == null) {
- // If restart() is called from a provisioning failure, it is
+ // If maybeRestart() is called from a provisioning failure, it is
// possible that link disappeared in the meantime. In that
// case, stop() has already been called and IpClient should not
// get restarted to prevent a provisioning failure loop.
- Log.i(TAG, String.format("restart() was called on stopped interface %s", name));
+ Log.i(TAG, String.format("maybeRestart() called on stopped interface %s", name));
return;
}
-
+ if (DBG) Log.d(TAG, "restart IpClient");
stop();
start();
}
diff --git a/service-t/src/com/android/server/net/NetworkStatsService.java b/service-t/src/com/android/server/net/NetworkStatsService.java
index 1606fd0..9176ec2 100644
--- a/service-t/src/com/android/server/net/NetworkStatsService.java
+++ b/service-t/src/com/android/server/net/NetworkStatsService.java
@@ -2423,20 +2423,41 @@
xtTotal = mXtRecorder.getTotalSinceBootLocked(template);
uidTotal = mUidRecorder.getTotalSinceBootLocked(template);
- EventLog.writeEvent(LOG_TAG_NETSTATS_MOBILE_SAMPLE,
- xtTotal.rxBytes, xtTotal.rxPackets, xtTotal.txBytes, xtTotal.txPackets,
- uidTotal.rxBytes, uidTotal.rxPackets, uidTotal.txBytes, uidTotal.txPackets,
- currentTime);
+ if (SdkLevel.isAtLeastU()) {
+ EventLog.writeEvent(LOG_TAG_NETSTATS_MOBILE_SAMPLE,
+ xtTotal.rxBytes, xtTotal.txBytes, xtTotal.rxPackets, xtTotal.txPackets,
+ uidTotal.rxBytes, uidTotal.txBytes, uidTotal.rxPackets, uidTotal.txPackets,
+ currentTime);
+ } else {
+ // To keep the format of event log, here replaces the value of DevRecorder with the
+ // value of XtRecorder because they have the same content in old design.
+ EventLog.writeEvent(LOG_TAG_NETSTATS_MOBILE_SAMPLE,
+ xtTotal.rxBytes, xtTotal.rxPackets, xtTotal.txBytes, xtTotal.txPackets,
+ xtTotal.rxBytes, xtTotal.rxPackets, xtTotal.txBytes, xtTotal.txPackets,
+ uidTotal.rxBytes, uidTotal.rxPackets, uidTotal.txBytes, uidTotal.txPackets,
+ currentTime);
+ }
// collect wifi sample
template = new NetworkTemplate.Builder(MATCH_WIFI).build();
xtTotal = mXtRecorder.getTotalSinceBootLocked(template);
uidTotal = mUidRecorder.getTotalSinceBootLocked(template);
- EventLog.writeEvent(LOG_TAG_NETSTATS_WIFI_SAMPLE,
- xtTotal.rxBytes, xtTotal.rxPackets, xtTotal.txBytes, xtTotal.txPackets,
- uidTotal.rxBytes, uidTotal.rxPackets, uidTotal.txBytes, uidTotal.txPackets,
- currentTime);
+ if (SdkLevel.isAtLeastU()) {
+ EventLog.writeEvent(LOG_TAG_NETSTATS_WIFI_SAMPLE,
+ xtTotal.rxBytes, xtTotal.txBytes, xtTotal.rxPackets, xtTotal.txPackets,
+ uidTotal.rxBytes, uidTotal.txBytes, uidTotal.rxPackets, uidTotal.txPackets,
+ currentTime);
+ } else {
+ // To keep the format of event log, here replaces the value of DevRecorder with the
+ // value of XtRecorder because they have the same content in old design.
+ EventLog.writeEvent(LOG_TAG_NETSTATS_WIFI_SAMPLE,
+ xtTotal.rxBytes, xtTotal.rxPackets, xtTotal.txBytes, xtTotal.txPackets,
+ xtTotal.rxBytes, xtTotal.rxPackets, xtTotal.txBytes, xtTotal.txPackets,
+ uidTotal.rxBytes, uidTotal.rxPackets, uidTotal.txBytes, uidTotal.txPackets,
+ currentTime);
+
+ }
}
// deleteKernelTagData can ignore ENOENT; otherwise we should log an error
diff --git a/service/Android.bp b/service/Android.bp
index c8d2fdd..1523af9 100644
--- a/service/Android.bp
+++ b/service/Android.bp
@@ -171,7 +171,7 @@
"androidx.annotation_annotation",
"connectivity-net-module-utils-bpf",
"connectivity_native_aidl_interface-lateststable-java",
- "dnsresolver_aidl_interface-V9-java",
+ "dnsresolver_aidl_interface-V11-java",
"modules-utils-shell-command-handler",
"net-utils-device-common",
"net-utils-device-common-bpf",
diff --git a/service/ServiceConnectivityResources/res/values-eu/strings.xml b/service/ServiceConnectivityResources/res/values-eu/strings.xml
index 9b39fd3..13f9eb4 100644
--- a/service/ServiceConnectivityResources/res/values-eu/strings.xml
+++ b/service/ServiceConnectivityResources/res/values-eu/strings.xml
@@ -36,7 +36,7 @@
<item msgid="3004933964374161223">"datu-konexioa"</item>
<item msgid="5624324321165953608">"Wifia"</item>
<item msgid="5667906231066981731">"Bluetootha"</item>
- <item msgid="346574747471703768">"Ethernet-a"</item>
+ <item msgid="346574747471703768">"Etherneta"</item>
<item msgid="5734728378097476003">"VPNa"</item>
</string-array>
<string name="network_switch_type_name_unknown" msgid="5116448402191972082">"sare mota ezezaguna"</string>
diff --git a/service/ServiceConnectivityResources/res/values-mcc310-mnc590/config.xml b/service/ServiceConnectivityResources/res/values-mcc310-mnc590/config.xml
new file mode 120000
index 0000000..2b8e406
--- /dev/null
+++ b/service/ServiceConnectivityResources/res/values-mcc310-mnc590/config.xml
@@ -0,0 +1 @@
+../values-mcc310-mnc004/config.xml
\ No newline at end of file
diff --git a/service/ServiceConnectivityResources/res/values-mcc310-mnc599/config.xml b/service/ServiceConnectivityResources/res/values-mcc310-mnc599/config.xml
new file mode 120000
index 0000000..2b8e406
--- /dev/null
+++ b/service/ServiceConnectivityResources/res/values-mcc310-mnc599/config.xml
@@ -0,0 +1 @@
+../values-mcc310-mnc004/config.xml
\ No newline at end of file
diff --git a/service/ServiceConnectivityResources/res/values-mcc311-mnc270/config.xml b/service/ServiceConnectivityResources/res/values-mcc311-mnc270/config.xml
new file mode 120000
index 0000000..2b8e406
--- /dev/null
+++ b/service/ServiceConnectivityResources/res/values-mcc311-mnc270/config.xml
@@ -0,0 +1 @@
+../values-mcc310-mnc004/config.xml
\ No newline at end of file
diff --git a/service/ServiceConnectivityResources/res/values-mcc311-mnc280/config.xml b/service/ServiceConnectivityResources/res/values-mcc311-mnc280/config.xml
new file mode 120000
index 0000000..2b8e406
--- /dev/null
+++ b/service/ServiceConnectivityResources/res/values-mcc311-mnc280/config.xml
@@ -0,0 +1 @@
+../values-mcc310-mnc004/config.xml
\ No newline at end of file
diff --git a/service/ServiceConnectivityResources/res/values-mcc311-mnc480/config.xml b/service/ServiceConnectivityResources/res/values-mcc311-mnc480/config.xml
deleted file mode 100644
index 7e7025f..0000000
--- a/service/ServiceConnectivityResources/res/values-mcc311-mnc480/config.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
- ~ Copyright (C) 2021 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.
- -->
-
-<!-- Configuration values for ConnectivityService
- DO NOT EDIT THIS FILE for specific device configuration; instead, use a Runtime Resources
- Overlay package following the overlayable.xml configuration in the same directory:
- https://source.android.com/devices/architecture/rros -->
-<resources>
- <!-- Whether the device should automatically switch away from Wi-Fi networks that lose
- Internet access. Actual device behaviour is controlled by
- Settings.Global.NETWORK_AVOID_BAD_WIFI. This is the default value of that setting. -->
- <integer translatable="false" name="config_networkAvoidBadWifi">0</integer>
-</resources>
\ No newline at end of file
diff --git a/service/ServiceConnectivityResources/res/values-mcc311-mnc480/config.xml b/service/ServiceConnectivityResources/res/values-mcc311-mnc480/config.xml
new file mode 120000
index 0000000..2b8e406
--- /dev/null
+++ b/service/ServiceConnectivityResources/res/values-mcc311-mnc480/config.xml
@@ -0,0 +1 @@
+../values-mcc310-mnc004/config.xml
\ No newline at end of file
diff --git a/service/jarjar-excludes.txt b/service/jarjar-excludes.txt
index b0d6763..7bd3862 100644
--- a/service/jarjar-excludes.txt
+++ b/service/jarjar-excludes.txt
@@ -1,9 +1,3 @@
# Classes loaded by SystemServer via their hardcoded name, so they can't be jarjared
com\.android\.server\.ConnectivityServiceInitializer(\$.+)?
com\.android\.server\.NetworkStatsServiceInitializer(\$.+)?
-
-# Do not jarjar com.android.server, as several unit tests fail because they lose
-# package-private visibility between jarjared and non-jarjared classes.
-# TODO: fix the tests and also jarjar com.android.server, or at least only exclude a package that
-# is specific to the module like com.android.server.connectivity
-com\.android\.server\..+
diff --git a/service/jni/com_android_server_BpfNetMaps.cpp b/service/jni/com_android_server_BpfNetMaps.cpp
index 05f50b0..77cffda 100644
--- a/service/jni/com_android_server_BpfNetMaps.cpp
+++ b/service/jni/com_android_server_BpfNetMaps.cpp
@@ -236,7 +236,7 @@
// clang-format on
int register_com_android_server_BpfNetMaps(JNIEnv* env) {
- return jniRegisterNativeMethods(env, "com/android/server/BpfNetMaps",
+ return jniRegisterNativeMethods(env, "android/net/connectivity/com/android/server/BpfNetMaps",
gMethods, NELEM(gMethods));
}
diff --git a/service/jni/com_android_server_TestNetworkService.cpp b/service/jni/com_android_server_TestNetworkService.cpp
index bd74d54..7aeecfa 100644
--- a/service/jni/com_android_server_TestNetworkService.cpp
+++ b/service/jni/com_android_server_TestNetworkService.cpp
@@ -151,8 +151,9 @@
};
int register_com_android_server_TestNetworkService(JNIEnv* env) {
- return jniRegisterNativeMethods(env, "com/android/server/TestNetworkService", gMethods,
- NELEM(gMethods));
+ return jniRegisterNativeMethods(env,
+ "android/net/connectivity/com/android/server/TestNetworkService", gMethods,
+ NELEM(gMethods));
}
}; // namespace android
diff --git a/service/jni/com_android_server_connectivity_ClatCoordinator.cpp b/service/jni/com_android_server_connectivity_ClatCoordinator.cpp
index 7060958..5b42659 100644
--- a/service/jni/com_android_server_connectivity_ClatCoordinator.cpp
+++ b/service/jni/com_android_server_connectivity_ClatCoordinator.cpp
@@ -477,8 +477,9 @@
};
int register_com_android_server_connectivity_ClatCoordinator(JNIEnv* env) {
- return jniRegisterNativeMethods(env, "com/android/server/connectivity/ClatCoordinator",
- gMethods, NELEM(gMethods));
+ return jniRegisterNativeMethods(env,
+ "android/net/connectivity/com/android/server/connectivity/ClatCoordinator",
+ gMethods, NELEM(gMethods));
}
}; // namespace android
diff --git a/service/proguard.flags b/service/proguard.flags
index 864a28b..cf25f05 100644
--- a/service/proguard.flags
+++ b/service/proguard.flags
@@ -7,7 +7,7 @@
*;
}
--keepclassmembers class com.android.server.**,android.net.**,com.android.networkstack.** {
+-keepclassmembers class android.net.**,com.android.networkstack.** {
static final % POLICY_*;
static final % NOTIFY_TYPE_*;
static final % TRANSPORT_*;
diff --git a/service/src/com/android/metrics/stats.proto b/service/src/com/android/metrics/stats.proto
index 48b8316..8104632 100644
--- a/service/src/com/android/metrics/stats.proto
+++ b/service/src/com/android/metrics/stats.proto
@@ -284,3 +284,66 @@
// The latency of selection issued in milli-second
optional int32 selection_issued_latency_milli = 5;
}
+
+message NetworkSliceRequestCountSample {
+ // Bitfield representing the network's capability(e.g. NET_CAPABILITY_PRIORITIZE_LATENCY),
+ // defined in packages/modules/Connectivity/framework/src/android/net/NetworkCapabilities.java
+ optional int64 slice_id = 1;
+
+ // Bitfield representing the network's enterprise capability identifier
+ // (e.g. NET_ENTERPRISE_ID_1), defined in
+ // packages/modules/Connectivity/framework/src/android/net/NetworkCapabilities.java
+ optional int32 enterprise_id = 2;
+
+ // number of request for this slice
+ optional int32 request_count = 3;
+
+ // number of apps with outstanding request(s) for this slice
+ optional int32 distinct_app_count = 4;
+}
+
+message NetworkSliceSessionEnded {
+ // Bitfield representing the network's capability(e.g. NET_CAPABILITY_PRIORITIZE_LATENCY),
+ // defined in packages/modules/Connectivity/framework/src/android/net/NetworkCapabilities.java
+ optional int64 slice_id = 1;
+
+ // Bitfield representing the network's enterprise capability identifier
+ // (e.g. NET_ENTERPRISE_ID_1), defined in
+ // packages/modules/Connectivity/framework/src/android/net/NetworkCapabilities.java
+ optional int32 enterprise_id = 2;
+
+ // Number of bytes received at the device on this slice id
+ optional int64 rx_bytes = 3;
+
+ // Number of bytes transmitted by the device on this slice id
+ optional int64 tx_bytes = 4;
+
+ // Number of apps that have used this slice
+ optional int32 number_of_apps = 5;
+
+ // How long(in seconds) this slice has been connected
+ optional int32 slice_connection_duration_sec = 6;
+}
+
+message NetworkSliceDailyDataUsageReported {
+ // Bitfield representing the network's capability(e.g. NET_CAPABILITY_PRIORITIZE_LATENCY),
+ // defined in packages/modules/Connectivity/framework/src/android/net/NetworkCapabilities.java
+ optional int64 slice_id = 1;
+
+ // Bitfield representing the network's enterprise capability identifier
+ // (e.g. NET_ENTERPRISE_ID_1), defined in
+ // packages/modules/Connectivity/framework/src/android/net/NetworkCapabilities.java
+ optional int32 enterprise_id = 2;
+
+ // Number of bytes received at the device on this slice id
+ optional int64 rx_bytes = 3;
+
+ // Number of bytes transmitted by the device on this slice id
+ optional int64 tx_bytes = 4;
+
+ // Number of apps that have used this slice
+ optional int32 number_of_apps = 5;
+
+ // How long(in seconds) this slice has been connected
+ optional int32 slice_connection_duration_sec = 6;
+}
diff --git a/service/src/com/android/server/BpfNetMaps.java b/service/src/com/android/server/BpfNetMaps.java
index 26ec37a..b4fce37 100644
--- a/service/src/com/android/server/BpfNetMaps.java
+++ b/service/src/com/android/server/BpfNetMaps.java
@@ -721,6 +721,31 @@
}
/**
+ * Get firewall rule of specified firewall chain on specified uid.
+ *
+ * @param childChain target chain
+ * @param uid target uid
+ * @return either FIREWALL_RULE_ALLOW or FIREWALL_RULE_DENY
+ * @throws UnsupportedOperationException if called on pre-T devices.
+ * @throws ServiceSpecificException in case of failure, with an error code indicating the
+ * cause of the failure.
+ */
+ public int getUidRule(final int childChain, final int uid) {
+ throwIfPreT("isUidChainEnabled is not available on pre-T devices");
+
+ final long match = getMatchByFirewallChain(childChain);
+ final boolean isAllowList = isFirewallAllowList(childChain);
+ try {
+ final UidOwnerValue uidMatch = sUidOwnerMap.getValue(new S32(uid));
+ final boolean isMatchEnabled = uidMatch != null && (uidMatch.rule & match) != 0;
+ return isMatchEnabled == isAllowList ? FIREWALL_RULE_ALLOW : FIREWALL_RULE_DENY;
+ } catch (ErrnoException e) {
+ throw new ServiceSpecificException(e.errno,
+ "Unable to get uid rule status: " + Os.strerror(e.errno));
+ }
+ }
+
+ /**
* Add ingress interface filtering rules to a list of UIDs
*
* For a given uid, once a filtering rule is added, the kernel will only allow packets from the
diff --git a/service/src/com/android/server/ConnectivityService.java b/service/src/com/android/server/ConnectivityService.java
index a570ab1..4c55afe 100755
--- a/service/src/com/android/server/ConnectivityService.java
+++ b/service/src/com/android/server/ConnectivityService.java
@@ -113,6 +113,7 @@
import android.app.BroadcastOptions;
import android.app.PendingIntent;
import android.app.admin.DevicePolicyManager;
+import android.app.compat.CompatChanges;
import android.app.usage.NetworkStatsManager;
import android.content.BroadcastReceiver;
import android.content.ComponentName;
@@ -121,6 +122,7 @@
import android.content.Intent;
import android.content.IntentFilter;
import android.content.pm.PackageManager;
+import android.content.res.XmlResourceParser;
import android.database.ContentObserver;
import android.net.CaptivePortal;
import android.net.CaptivePortalData;
@@ -195,6 +197,7 @@
import android.net.Uri;
import android.net.VpnManager;
import android.net.VpnTransportInfo;
+import android.net.connectivity.ConnectivityCompatChanges;
import android.net.metrics.IpConnectivityLog;
import android.net.metrics.NetworkEvent;
import android.net.netd.aidl.NativeUidRangeConfig;
@@ -269,6 +272,7 @@
import com.android.networkstack.apishim.ConstantsShim;
import com.android.networkstack.apishim.common.BroadcastOptionsShim;
import com.android.networkstack.apishim.common.UnsupportedApiLevelException;
+import com.android.server.connectivity.ApplicationSelfCertifiedNetworkCapabilities;
import com.android.server.connectivity.AutodestructReference;
import com.android.server.connectivity.AutomaticOnOffKeepaliveTracker;
import com.android.server.connectivity.AutomaticOnOffKeepaliveTracker.AutomaticOnOffKeepalive;
@@ -279,6 +283,7 @@
import com.android.server.connectivity.DnsManager.PrivateDnsValidationUpdate;
import com.android.server.connectivity.DscpPolicyTracker;
import com.android.server.connectivity.FullScore;
+import com.android.server.connectivity.InvalidTagException;
import com.android.server.connectivity.KeepaliveTracker;
import com.android.server.connectivity.LingerMonitor;
import com.android.server.connectivity.MockableSystemProperties;
@@ -300,6 +305,8 @@
import libcore.io.IoUtils;
+import org.xmlpull.v1.XmlPullParserException;
+
import java.io.FileDescriptor;
import java.io.IOException;
import java.io.PrintWriter;
@@ -766,6 +773,11 @@
private static final int EVENT_SET_VPN_NETWORK_PREFERENCE = 59;
/**
+ * Event to use low TCP polling timer used in automatic on/off keepalive temporarily.
+ */
+ private static final int EVENT_SET_LOW_TCP_POLLING_UNTIL = 60;
+
+ /**
* Argument for {@link #EVENT_PROVISIONING_NOTIFICATION} to indicate that the notification
* should be shown.
*/
@@ -783,6 +795,12 @@
private static final long MAX_TEST_ALLOW_BAD_WIFI_UNTIL_MS = 5 * 60 * 1000L;
/**
+ * The maximum alive time to decrease TCP polling timer in automatic on/off keepalive for
+ * testing.
+ */
+ private static final long MAX_TEST_LOW_TCP_POLLING_UNTIL_MS = 5 * 60 * 1000L;
+
+ /**
* The priority of the tc police rate limiter -- smaller value is higher priority.
* This value needs to be coordinated with PRIO_CLAT, PRIO_TETHER4, and PRIO_TETHER6.
*/
@@ -891,6 +909,13 @@
// Only the handler thread is allowed to access this field.
private long mIngressRateLimit = -1;
+ // 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.
+ @GuardedBy("mSelfCertifiedCapabilityCache")
+ private final Map<String, ApplicationSelfCertifiedNetworkCapabilities>
+ mSelfCertifiedCapabilityCache = new HashMap<>();
+
/**
* Implements support for the legacy "one network per network type" model.
*
@@ -1305,6 +1330,14 @@
}
/**
+ * @see AutomaticOnOffKeepaliveTracker
+ */
+ public AutomaticOnOffKeepaliveTracker makeAutomaticOnOffKeepaliveTracker(
+ @NonNull Context c, @NonNull Handler h) {
+ return new AutomaticOnOffKeepaliveTracker(c, h);
+ }
+
+ /**
* @see BatteryStatsManager
*/
public void reportNetworkInterfaceForTransports(Context context, String iface,
@@ -1433,6 +1466,20 @@
public BroadcastOptionsShim makeBroadcastOptionsShim(BroadcastOptions options) {
return BroadcastOptionsShimImpl.newInstance(options);
}
+
+ /**
+ * Wrapper method for
+ * {@link android.app.compat.CompatChanges#isChangeEnabled(long, String, UserHandle)}.
+ *
+ * @param changeId The ID of the compatibility change in question.
+ * @param packageName The package name of the app in question.
+ * @param user The user that the operation is done for.
+ * @return {@code true} if the change is enabled for the specified package.
+ */
+ public boolean isChangeEnabled(long changeId, @NonNull final String packageName,
+ @NonNull final UserHandle user) {
+ return CompatChanges.isChangeEnabled(changeId, packageName, user);
+ }
}
public ConnectivityService(Context context) {
@@ -1567,7 +1614,7 @@
mSettingsObserver = new SettingsObserver(mContext, mHandler);
registerSettingsCallbacks();
- mKeepaliveTracker = new AutomaticOnOffKeepaliveTracker(mContext, mHandler);
+ mKeepaliveTracker = mDeps.makeAutomaticOnOffKeepaliveTracker(mContext, mHandler);
mNotifier = new NetworkNotificationManager(mContext, mTelephonyManager);
mQosCallbackTracker = new QosCallbackTracker(mHandler, mNetworkRequestCounter);
@@ -2863,9 +2910,10 @@
NetworkStack.PERMISSION_MAINLINE_NETWORK_STACK);
}
- private void enforceSettingsOrUseRestrictedNetworksPermission() {
+ private void enforceSettingsOrSetupWizardOrUseRestrictedNetworksPermission() {
enforceAnyPermissionOf(mContext,
android.Manifest.permission.NETWORK_SETTINGS,
+ android.Manifest.permission.NETWORK_SETUP_WIZARD,
NetworkStack.PERMISSION_MAINLINE_NETWORK_STACK,
Manifest.permission.CONNECTIVITY_USE_RESTRICTED_NETWORKS);
}
@@ -4407,7 +4455,7 @@
mQosCallbackTracker.handleNetworkReleased(nai.network);
for (String iface : nai.linkProperties.getAllInterfaceNames()) {
// Disable wakeup packet monitoring for each interface.
- wakeupModifyInterface(iface, nai.networkCapabilities, false);
+ wakeupModifyInterface(iface, nai, false);
}
nai.networkMonitor().notifyNetworkDisconnected();
mNetworkAgentInfos.remove(nai);
@@ -5001,6 +5049,19 @@
mHandler.obtainMessage(EVENT_SET_TEST_ALLOW_BAD_WIFI_UNTIL, timeMs));
}
+ @Override
+ public void setTestLowTcpPollingTimerForKeepalive(long timeMs) {
+ enforceSettingsPermission();
+
+ if (timeMs > System.currentTimeMillis() + MAX_TEST_LOW_TCP_POLLING_UNTIL_MS) {
+ throw new IllegalArgumentException("Argument should not exceed "
+ + MAX_TEST_LOW_TCP_POLLING_UNTIL_MS + "ms from now");
+ }
+
+ mHandler.sendMessage(
+ mHandler.obtainMessage(EVENT_SET_LOW_TCP_POLLING_UNTIL, timeMs));
+ }
+
private void handleSetAcceptUnvalidated(Network network, boolean accept, boolean always) {
if (DBG) log("handleSetAcceptUnvalidated network=" + network +
" accept=" + accept + " always=" + always);
@@ -5554,13 +5615,14 @@
mKeepaliveTracker.getKeepaliveForBinder((IBinder) msg.obj);
if (null == ki) return; // The callback was unregistered before the alarm fired
+ final Network underpinnedNetwork = ki.getUnderpinnedNetwork();
final Network network = ki.getNetwork();
boolean networkFound = false;
- final ArrayList<NetworkAgentInfo> vpnsRunningOnThisNetwork = new ArrayList<>();
+ boolean underpinnedNetworkFound = false;
for (NetworkAgentInfo n : mNetworkAgentInfos) {
if (n.network.equals(network)) networkFound = true;
- if (n.isVPN() && n.everConnected() && hasUnderlyingNetwork(n, network)) {
- vpnsRunningOnThisNetwork.add(n);
+ if (n.everConnected() && n.network.equals(underpinnedNetwork)) {
+ underpinnedNetworkFound = true;
}
}
@@ -5568,12 +5630,11 @@
// cleaned up already. There is no point trying to resume keepalives.
if (!networkFound) return;
- if (!vpnsRunningOnThisNetwork.isEmpty()) {
+ if (underpinnedNetworkFound) {
mKeepaliveTracker.handleMonitorAutomaticKeepalive(ki,
- // TODO: check all the VPNs running on top of this network
- vpnsRunningOnThisNetwork.get(0).network.netId);
+ underpinnedNetwork.netId);
} else {
- // If no VPN, then make sure the keepalive is running.
+ // If no underpinned network, then make sure the keepalive is running.
mKeepaliveTracker.handleMaybeResumeKeepalive(ki);
}
break;
@@ -5642,6 +5703,11 @@
case EVENT_SET_VPN_NETWORK_PREFERENCE:
handleSetVpnNetworkPreference((VpnNetworkPreferenceInfo) msg.obj);
break;
+ case EVENT_SET_LOW_TCP_POLLING_UNTIL: {
+ final long time = ((Long) msg.obj).longValue();
+ mKeepaliveTracker.handleSetTestLowTcpPollingTimer(time);
+ break;
+ }
}
}
}
@@ -6278,6 +6344,11 @@
if (isMappedInOemNetworkPreference(packageName)) {
handleSetOemNetworkPreference(mOemNetworkPreferences, null);
}
+
+ // Invalidates cache entry when the package is updated.
+ synchronized (mSelfCertifiedCapabilityCache) {
+ mSelfCertifiedCapabilityCache.remove(packageName);
+ }
}
private final BroadcastReceiver mUserIntentReceiver = new BroadcastReceiver() {
@@ -6614,8 +6685,6 @@
@Override
public void binderDied() {
- log("ConnectivityService NetworkRequestInfo binderDied(" +
- "uid/pid:" + mUid + "/" + mPid + ", " + mRequests + ", " + mBinder + ")");
// As an immutable collection, mRequests cannot change by the time the
// lambda is evaluated on the handler thread so calling .get() from a binder thread
// is acceptable. Use handleReleaseNetworkRequest and not directly
@@ -6808,7 +6877,7 @@
enforceAccessPermission();
break;
case TRACK_SYSTEM_DEFAULT:
- enforceSettingsOrUseRestrictedNetworksPermission();
+ enforceSettingsOrSetupWizardOrUseRestrictedNetworksPermission();
networkCapabilities = new NetworkCapabilities(defaultNc);
break;
case BACKGROUND_REQUEST:
@@ -6906,8 +6975,69 @@
asUid, requests, nr, msgr, binder, callbackFlags, callingAttributionTag);
}
+ private boolean shouldCheckCapabilitiesDeclaration(
+ @NonNull final NetworkCapabilities networkCapabilities, final int callingUid,
+ @NonNull final String callingPackageName) {
+ final UserHandle user = UserHandle.getUserHandleForUid(callingUid);
+ // Only run the check if the change is enabled.
+ if (!mDeps.isChangeEnabled(
+ ConnectivityCompatChanges.ENABLE_SELF_CERTIFIED_CAPABILITIES_DECLARATION,
+ callingPackageName, user)) {
+ return false;
+ }
+
+ return networkCapabilities.hasCapability(
+ NetworkCapabilities.NET_CAPABILITY_PRIORITIZE_BANDWIDTH)
+ || networkCapabilities.hasCapability(
+ NetworkCapabilities.NET_CAPABILITY_PRIORITIZE_LATENCY);
+ }
+
+ private void enforceRequestCapabilitiesDeclaration(@NonNull final String callerPackageName,
+ @NonNull final NetworkCapabilities networkCapabilities) {
+ // This check is added to fix the linter error for "current min is 30", which is not going
+ // to happen because Connectivity service always run in S+.
+ if (!SdkLevel.isAtLeastS()) {
+ Log.wtf(TAG, "Connectivity service should always run in at least SDK S");
+ return;
+ }
+ ApplicationSelfCertifiedNetworkCapabilities applicationNetworkCapabilities;
+ try {
+ synchronized (mSelfCertifiedCapabilityCache) {
+ applicationNetworkCapabilities = mSelfCertifiedCapabilityCache.get(
+ callerPackageName);
+ if (applicationNetworkCapabilities == null) {
+ final PackageManager packageManager = mContext.getPackageManager();
+ final PackageManager.Property networkSliceProperty = packageManager.getProperty(
+ ConstantsShim.PROPERTY_SELF_CERTIFIED_NETWORK_CAPABILITIES,
+ callerPackageName
+ );
+ final XmlResourceParser parser = packageManager
+ .getResourcesForApplication(callerPackageName)
+ .getXml(networkSliceProperty.getResourceId());
+ applicationNetworkCapabilities =
+ ApplicationSelfCertifiedNetworkCapabilities.createFromXml(parser);
+ mSelfCertifiedCapabilityCache.put(callerPackageName,
+ applicationNetworkCapabilities);
+ }
+
+ }
+ } catch (PackageManager.NameNotFoundException ne) {
+ throw new SecurityException(
+ "Cannot find " + ConstantsShim.PROPERTY_SELF_CERTIFIED_NETWORK_CAPABILITIES
+ + " property");
+ } catch (XmlPullParserException | IOException | InvalidTagException e) {
+ throw new SecurityException(e.getMessage());
+ }
+
+ applicationNetworkCapabilities.enforceSelfCertifiedNetworkCapabilitiesDeclared(
+ networkCapabilities);
+ }
private void enforceNetworkRequestPermissions(NetworkCapabilities networkCapabilities,
String callingPackageName, String callingAttributionTag, final int callingUid) {
+ if (shouldCheckCapabilitiesDeclaration(networkCapabilities, callingUid,
+ callingPackageName)) {
+ enforceRequestCapabilitiesDeclaration(callingPackageName, networkCapabilities);
+ }
if (networkCapabilities.hasCapability(NET_CAPABILITY_NOT_RESTRICTED) == false) {
// For T+ devices, callers with carrier privilege could request with CBS capabilities.
if (networkCapabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_CBS)
@@ -7665,7 +7795,7 @@
// the LinkProperties for the network are accurate.
networkAgent.clatd.fixupLinkProperties(oldLp, newLp);
- updateInterfaces(newLp, oldLp, netId, networkAgent.networkCapabilities);
+ updateInterfaces(newLp, oldLp, netId, networkAgent);
// update filtering rules, need to happen after the interface update so netd knows about the
// new interface (the interface name -> index map becomes initialized)
@@ -7773,10 +7903,16 @@
return captivePortalBuilder.build();
}
- private void wakeupModifyInterface(String iface, NetworkCapabilities caps, boolean add) {
+ private String makeNflogPrefix(String iface, long networkHandle) {
+ // This needs to be kept in sync and backwards compatible with the decoding logic in
+ // NetdEventListenerService, which is non-mainline code.
+ return SdkLevel.isAtLeastU() ? (networkHandle + ":" + iface) : ("iface:" + iface);
+ }
+
+ private void wakeupModifyInterface(String iface, NetworkAgentInfo nai, boolean add) {
// Marks are only available on WiFi interfaces. Checking for
// marks on unsupported interfaces is harmless.
- if (!caps.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)) {
+ if (!nai.networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)) {
return;
}
@@ -7789,7 +7925,7 @@
return;
}
- final String prefix = "iface:" + iface;
+ final String prefix = makeNflogPrefix(iface, nai.network.getNetworkHandle());
try {
if (add) {
mNetd.wakeupAddInterface(iface, prefix, mark, mask);
@@ -7799,12 +7935,11 @@
} catch (Exception e) {
loge("Exception modifying wakeup packet monitoring: " + e);
}
-
}
private void updateInterfaces(final @NonNull LinkProperties newLp,
final @Nullable LinkProperties oldLp, final int netId,
- final @NonNull NetworkCapabilities caps) {
+ final @NonNull NetworkAgentInfo nai) {
final CompareResult<String> interfaceDiff = new CompareResult<>(
oldLp != null ? oldLp.getAllInterfaceNames() : null, newLp.getAllInterfaceNames());
if (!interfaceDiff.added.isEmpty()) {
@@ -7812,9 +7947,9 @@
try {
if (DBG) log("Adding iface " + iface + " to network " + netId);
mNetd.networkAddInterface(netId, iface);
- wakeupModifyInterface(iface, caps, true);
+ wakeupModifyInterface(iface, nai, true);
mDeps.reportNetworkInterfaceForTransports(mContext, iface,
- caps.getTransportTypes());
+ nai.networkCapabilities.getTransportTypes());
} catch (Exception e) {
logw("Exception adding interface: " + e);
}
@@ -7823,7 +7958,7 @@
for (final String iface : interfaceDiff.removed) {
try {
if (DBG) log("Removing iface " + iface + " from network " + netId);
- wakeupModifyInterface(iface, caps, false);
+ wakeupModifyInterface(iface, nai, false);
mNetd.networkRemoveInterface(netId, iface);
} catch (Exception e) {
loge("Exception removing interface: " + e);
@@ -8813,6 +8948,9 @@
}
private void updateProfileAllowedNetworks() {
+ // Netd command is not implemented before U.
+ if (!SdkLevel.isAtLeastU()) return;
+
ensureRunningOnConnectivityServiceThread();
final ArrayList<NativeUidRangeConfig> configs = new ArrayList<>();
final List<UserHandle> users = mContext.getSystemService(UserManager.class)
@@ -8843,8 +8981,10 @@
mNetd.setNetworkAllowlist(configs.toArray(new NativeUidRangeConfig[0]));
} catch (ServiceSpecificException e) {
// Has the interface disappeared since the network was built?
+ Log.wtf(TAG, "Unexpected ServiceSpecificException", e);
} catch (RemoteException e) {
- // Netd died. This usually causes a runtime restart anyway.
+ // Netd died. This will cause a runtime restart anyway.
+ Log.wtf(TAG, "Unexpected RemoteException", e);
}
}
@@ -9828,21 +9968,22 @@
getNetworkAgentInfoForNetwork(network), null /* fd */,
intervalSeconds, cb, srcAddr, srcPort, dstAddr, NattSocketKeepalive.NATT_PORT,
// Keep behavior of the deprecated method as it is. Set automaticOnOffKeepalives to
- // false because there is no way and no plan to configure automaticOnOffKeepalives
- // in this deprecated method.
- false /* automaticOnOffKeepalives */);
+ // false and set the underpinned network to null because there is no way and no
+ // plan to configure automaticOnOffKeepalives or underpinnedNetwork in this
+ // deprecated method.
+ false /* automaticOnOffKeepalives */, null /* underpinnedNetwork */);
}
@Override
public void startNattKeepaliveWithFd(Network network, ParcelFileDescriptor pfd, int resourceId,
int intervalSeconds, ISocketKeepaliveCallback cb, String srcAddr,
- String dstAddr, boolean automaticOnOffKeepalives) {
+ String dstAddr, boolean automaticOnOffKeepalives, Network underpinnedNetwork) {
try {
final FileDescriptor fd = pfd.getFileDescriptor();
mKeepaliveTracker.startNattKeepalive(
getNetworkAgentInfoForNetwork(network), fd, resourceId,
- intervalSeconds, cb,
- srcAddr, dstAddr, NattSocketKeepalive.NATT_PORT, automaticOnOffKeepalives);
+ intervalSeconds, cb, srcAddr, dstAddr, NattSocketKeepalive.NATT_PORT,
+ automaticOnOffKeepalives, underpinnedNetwork);
} finally {
// FileDescriptors coming from AIDL calls must be manually closed to prevent leaks.
// startNattKeepalive calls Os.dup(fd) before returning, so we can close immediately.
@@ -11705,6 +11846,12 @@
}
}
+ @Override
+ public int getUidFirewallRule(final int chain, final int uid) {
+ enforceNetworkStackOrSettingsPermission();
+ return mBpfNetMaps.getUidRule(chain, uid);
+ }
+
private int getFirewallRuleType(int chain, int rule) {
final int defaultRule;
switch (chain) {
diff --git a/service/src/com/android/server/connectivity/ApplicationSelfCertifiedNetworkCapabilities.java b/service/src/com/android/server/connectivity/ApplicationSelfCertifiedNetworkCapabilities.java
new file mode 100644
index 0000000..76e966f
--- /dev/null
+++ b/service/src/com/android/server/connectivity/ApplicationSelfCertifiedNetworkCapabilities.java
@@ -0,0 +1,209 @@
+/*
+ * 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 com.android.server.connectivity;
+
+
+import android.annotation.NonNull;
+import android.net.NetworkCapabilities;
+import android.util.Log;
+
+import org.xmlpull.v1.XmlPullParser;
+import org.xmlpull.v1.XmlPullParserException;
+
+import java.io.IOException;
+import java.util.ArrayDeque;
+
+
+/**
+ * The class for parsing and checking the self-declared application network capabilities.
+ *
+ * ApplicationSelfCertifiedNetworkCapabilities is an immutable class that
+ * can parse the self-declared application network capabilities in the application resources. The
+ * class also provides a helper method to check whether the requested network capabilities
+ * already self-declared.
+ */
+public final class ApplicationSelfCertifiedNetworkCapabilities {
+
+ public static final String PRIORITIZE_LATENCY = "NET_CAPABILITY_PRIORITIZE_LATENCY";
+ public static final String PRIORITIZE_BANDWIDTH = "NET_CAPABILITY_PRIORITIZE_BANDWIDTH";
+
+ private static final String TAG =
+ ApplicationSelfCertifiedNetworkCapabilities.class.getSimpleName();
+ private static final String NETWORK_CAPABILITIES_DECLARATION_TAG =
+ "network-capabilities-declaration";
+ private static final String USES_NETWORK_CAPABILITY_TAG = "uses-network-capability";
+ private static final String NAME_TAG = "name";
+
+ private long mRequestedNetworkCapabilities = 0;
+
+ /**
+ * Creates {@link ApplicationSelfCertifiedNetworkCapabilities} from a xml parser.
+ *
+ * <p> Here is an example of the xml syntax:
+ *
+ * <pre>
+ * {@code
+ * <network-capabilities-declaration xmlns:android="http://schemas.android.com/apk/res/android">
+ * <uses-network-capability android:name="NET_CAPABILITY_PRIORITIZE_LATENCY"/>
+ * <uses-network-capability android:name="NET_CAPABILITY_PRIORITIZE_BANDWIDTH"/>
+ * </network-capabilities-declaration>
+ * }
+ * </pre>
+ * <p>
+ *
+ * @param xmlParser The underlying {@link XmlPullParser} that will read the xml.
+ * @return An ApplicationSelfCertifiedNetworkCapabilities object.
+ * @throws InvalidTagException if the capabilities in xml config contains invalid tag.
+ * @throws XmlPullParserException if xml parsing failed.
+ * @throws IOException if unable to read the xml file properly.
+ */
+ @NonNull
+ public static ApplicationSelfCertifiedNetworkCapabilities createFromXml(
+ @NonNull final XmlPullParser xmlParser)
+ throws InvalidTagException, XmlPullParserException, IOException {
+ return new ApplicationSelfCertifiedNetworkCapabilities(parseXml(xmlParser));
+ }
+
+ private static long parseXml(@NonNull final XmlPullParser xmlParser)
+ throws InvalidTagException, XmlPullParserException, IOException {
+ long requestedNetworkCapabilities = 0;
+ final ArrayDeque<String> openTags = new ArrayDeque<>();
+
+ while (checkedNextTag(xmlParser, openTags) != XmlPullParser.START_TAG) {
+ continue;
+ }
+
+ // Validates the tag is "network-capabilities-declaration"
+ if (!xmlParser.getName().equals(NETWORK_CAPABILITIES_DECLARATION_TAG)) {
+ throw new InvalidTagException("Invalid tag: " + xmlParser.getName());
+ }
+
+ checkedNextTag(xmlParser, openTags);
+ int eventType = xmlParser.getEventType();
+ while (eventType != XmlPullParser.END_DOCUMENT) {
+ switch (eventType) {
+ case XmlPullParser.START_TAG:
+ // USES_NETWORK_CAPABILITY_TAG should directly be declared under
+ // NETWORK_CAPABILITIES_DECLARATION_TAG.
+ if (xmlParser.getName().equals(USES_NETWORK_CAPABILITY_TAG)
+ && openTags.size() == 1) {
+ int capability = parseDeclarationTag(xmlParser);
+ if (capability >= 0) {
+ requestedNetworkCapabilities |= 1L << capability;
+ }
+ } else {
+ Log.w(TAG, "Unknown tag: " + xmlParser.getName() + " ,tags stack size: "
+ + openTags.size());
+ }
+ break;
+ default:
+ break;
+ }
+ eventType = checkedNextTag(xmlParser, openTags);
+ }
+ // Checks all the tags are parsed.
+ if (!openTags.isEmpty()) {
+ throw new InvalidTagException("Unbalanced tag: " + openTags.peek());
+ }
+ return requestedNetworkCapabilities;
+ }
+
+ private static int parseDeclarationTag(@NonNull final XmlPullParser xmlParser) {
+ String name = null;
+ for (int i = 0; i < xmlParser.getAttributeCount(); i++) {
+ final String attrName = xmlParser.getAttributeName(i);
+ if (attrName.equals(NAME_TAG)) {
+ name = xmlParser.getAttributeValue(i);
+ } else {
+ Log.w(TAG, "Unknown attribute name: " + attrName);
+ }
+ }
+ if (name != null) {
+ switch (name) {
+ case PRIORITIZE_BANDWIDTH:
+ return NetworkCapabilities.NET_CAPABILITY_PRIORITIZE_BANDWIDTH;
+ case PRIORITIZE_LATENCY:
+ return NetworkCapabilities.NET_CAPABILITY_PRIORITIZE_LATENCY;
+ default:
+ Log.w(TAG, "Unknown capability declaration name: " + name);
+ }
+ } else {
+ Log.w(TAG, "uses-network-capability name must be specified");
+ }
+ // Invalid capability
+ return -1;
+ }
+
+ private static int checkedNextTag(@NonNull final XmlPullParser xmlParser,
+ @NonNull final ArrayDeque<String> openTags)
+ throws XmlPullParserException, IOException, InvalidTagException {
+ if (xmlParser.getEventType() == XmlPullParser.START_TAG) {
+ openTags.addFirst(xmlParser.getName());
+ } else if (xmlParser.getEventType() == XmlPullParser.END_TAG) {
+ if (!openTags.isEmpty() && openTags.peekFirst().equals(xmlParser.getName())) {
+ openTags.removeFirst();
+ } else {
+ throw new InvalidTagException("Unbalanced tag: " + xmlParser.getName());
+ }
+ }
+ return xmlParser.next();
+ }
+
+ private ApplicationSelfCertifiedNetworkCapabilities(long requestedNetworkCapabilities) {
+ mRequestedNetworkCapabilities = requestedNetworkCapabilities;
+ }
+
+ /**
+ * Enforces self-certified capabilities are declared.
+ *
+ * @param networkCapabilities the input NetworkCapabilities to check against.
+ * @throws SecurityException if the capabilities are not properly self-declared.
+ */
+ public void enforceSelfCertifiedNetworkCapabilitiesDeclared(
+ @NonNull final NetworkCapabilities networkCapabilities) {
+ if (networkCapabilities.hasCapability(
+ NetworkCapabilities.NET_CAPABILITY_PRIORITIZE_BANDWIDTH)
+ && !hasPrioritizeBandwidth()) {
+ throw new SecurityException(
+ "Missing " + ApplicationSelfCertifiedNetworkCapabilities.PRIORITIZE_BANDWIDTH
+ + " declaration");
+ }
+ if (networkCapabilities.hasCapability(
+ NetworkCapabilities.NET_CAPABILITY_PRIORITIZE_LATENCY)
+ && !hasPrioritizeLatency()) {
+ throw new SecurityException(
+ "Missing " + ApplicationSelfCertifiedNetworkCapabilities.PRIORITIZE_LATENCY
+ + " declaration");
+ }
+ }
+
+ /**
+ * Checks if NET_CAPABILITY_PRIORITIZE_LATENCY is declared.
+ */
+ private boolean hasPrioritizeLatency() {
+ return (mRequestedNetworkCapabilities & (1L
+ << NetworkCapabilities.NET_CAPABILITY_PRIORITIZE_LATENCY)) != 0;
+ }
+
+ /**
+ * Checks if NET_CAPABILITY_PRIORITIZE_BANDWIDTH is declared.
+ */
+ private boolean hasPrioritizeBandwidth() {
+ return (mRequestedNetworkCapabilities & (1L
+ << NetworkCapabilities.NET_CAPABILITY_PRIORITIZE_BANDWIDTH)) != 0;
+ }
+}
diff --git a/service/src/com/android/server/connectivity/AutomaticOnOffKeepaliveTracker.java b/service/src/com/android/server/connectivity/AutomaticOnOffKeepaliveTracker.java
index 8bfbcf7..9f9b496 100644
--- a/service/src/com/android/server/connectivity/AutomaticOnOffKeepaliveTracker.java
+++ b/service/src/com/android/server/connectivity/AutomaticOnOffKeepaliveTracker.java
@@ -18,8 +18,8 @@
import static android.net.NetworkAgent.CMD_START_SOCKET_KEEPALIVE;
import static android.net.SocketKeepalive.ERROR_INVALID_SOCKET;
-import static android.net.SocketKeepalive.SUCCESS;
-import static android.provider.DeviceConfig.NAMESPACE_CONNECTIVITY;
+import static android.net.SocketKeepalive.SUCCESS_PAUSED;
+import static android.provider.DeviceConfig.NAMESPACE_TETHERING;
import static android.system.OsConstants.AF_INET;
import static android.system.OsConstants.AF_INET6;
import static android.system.OsConstants.SOL_SOCKET;
@@ -34,18 +34,13 @@
import android.annotation.NonNull;
import android.annotation.Nullable;
import android.app.AlarmManager;
-import android.app.PendingIntent;
-import android.content.BroadcastReceiver;
import android.content.Context;
-import android.content.Intent;
-import android.content.IntentFilter;
import android.net.INetd;
import android.net.ISocketKeepaliveCallback;
import android.net.MarkMaskParcel;
import android.net.Network;
import android.net.NetworkAgent;
import android.net.SocketKeepalive.InvalidSocketException;
-import android.os.Bundle;
import android.os.FileUtils;
import android.os.Handler;
import android.os.IBinder;
@@ -61,7 +56,6 @@
import com.android.internal.annotations.VisibleForTesting;
import com.android.internal.util.IndentingPrintWriter;
-import com.android.modules.utils.build.SdkLevel;
import com.android.net.module.util.BinderUtils;
import com.android.net.module.util.CollectionUtils;
import com.android.net.module.util.DeviceConfigUtils;
@@ -94,10 +88,9 @@
public class AutomaticOnOffKeepaliveTracker {
private static final String TAG = "AutomaticOnOffKeepaliveTracker";
private static final int[] ADDRESS_FAMILIES = new int[] {AF_INET6, AF_INET};
- private static final String ACTION_TCP_POLLING_ALARM =
- "com.android.server.connectivity.KeepaliveTracker.TCP_POLLING_ALARM";
private static final String EXTRA_BINDER_TOKEN = "token";
private static final long DEFAULT_TCP_POLLING_INTERVAL_MS = 120_000L;
+ private static final long LOW_TCP_POLLING_INTERVAL_MS = 1_000L;
private static final String AUTOMATIC_ON_OFF_KEEPALIVE_VERSION =
"automatic_on_off_keepalive_version";
/**
@@ -156,19 +149,8 @@
* This should be only updated in ConnectivityService handler thread.
*/
private final ArrayList<AutomaticOnOffKeepalive> mAutomaticOnOffKeepalives = new ArrayList<>();
-
- private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
- @Override
- public void onReceive(Context context, Intent intent) {
- if (ACTION_TCP_POLLING_ALARM.equals(intent.getAction())) {
- Log.d(TAG, "Received TCP polling intent");
- final IBinder token = intent.getBundleExtra(EXTRA_BINDER_TOKEN).getBinder(
- EXTRA_BINDER_TOKEN);
- mConnectivityServiceHandler.obtainMessage(
- NetworkAgent.CMD_MONITOR_AUTOMATIC_KEEPALIVE, token).sendToTarget();
- }
- }
- };
+ // TODO: Remove this when TCP polling design is replaced with callback.
+ private long mTestLowTcpPollingTimerUntilMs = 0;
/**
* Information about a managed keepalive.
@@ -182,7 +164,7 @@
* resumed if a TCP socket is open on the VPN.
* See the documentation for the states for more detail.
*/
- public class AutomaticOnOffKeepalive {
+ public class AutomaticOnOffKeepalive implements IBinder.DeathRecipient {
@NonNull
private final KeepaliveTracker.KeepaliveInfo mKi;
@NonNull
@@ -190,15 +172,21 @@
@Nullable
private final FileDescriptor mFd;
@Nullable
- private final PendingIntent mTcpPollingAlarm;
+ private final AlarmManager.OnAlarmListener mAlarmListener;
@AutomaticOnOffState
private int mAutomaticOnOffState;
+ @Nullable
+ private final Network mUnderpinnedNetwork;
AutomaticOnOffKeepalive(@NonNull final KeepaliveTracker.KeepaliveInfo ki,
- final boolean autoOnOff, @NonNull Context context) throws InvalidSocketException {
+ final boolean autoOnOff, @NonNull Context context,
+ @Nullable Network underpinnedNetwork)
+ throws InvalidSocketException {
this.mKi = Objects.requireNonNull(ki);
mCallback = ki.mCallback;
- if (autoOnOff && mDependencies.isFeatureEnabled(AUTOMATIC_ON_OFF_KEEPALIVE_VERSION)) {
+ mUnderpinnedNetwork = underpinnedNetwork;
+ if (autoOnOff && mDependencies.isFeatureEnabled(AUTOMATIC_ON_OFF_KEEPALIVE_VERSION,
+ true /* defaultEnabled */)) {
mAutomaticOnOffState = STATE_ENABLED;
if (null == ki.mFd) {
throw new IllegalArgumentException("fd can't be null with automatic "
@@ -210,34 +198,69 @@
Log.e(TAG, "Cannot dup fd: ", e);
throw new InvalidSocketException(ERROR_INVALID_SOCKET, e);
}
- mTcpPollingAlarm = createTcpPollingAlarmIntent(context, mCallback.asBinder());
+ mAlarmListener = () -> mConnectivityServiceHandler.obtainMessage(
+ NetworkAgent.CMD_MONITOR_AUTOMATIC_KEEPALIVE, mCallback.asBinder())
+ .sendToTarget();
} else {
mAutomaticOnOffState = STATE_ALWAYS_ON;
// A null fd is acceptable in KeepaliveInfo for backward compatibility of
// PacketKeepalive API, but it must never happen with automatic keepalives.
// TODO : remove mFd from KeepaliveInfo or from this class.
mFd = ki.mFd;
- mTcpPollingAlarm = null;
+ mAlarmListener = null;
}
}
+ @VisibleForTesting
+ public ISocketKeepaliveCallback getCallback() {
+ return mCallback;
+ }
+
public Network getNetwork() {
return mKi.getNai().network;
}
+ @Nullable
+ public Network getUnderpinnedNetwork() {
+ return mUnderpinnedNetwork;
+ }
+
public boolean match(Network network, int slot) {
return mKi.getNai().network().equals(network) && mKi.getSlot() == slot;
}
- private PendingIntent createTcpPollingAlarmIntent(@NonNull Context context,
- @NonNull IBinder token) {
- final Intent intent = new Intent(ACTION_TCP_POLLING_ALARM);
- // Intent doesn't expose methods to put extra Binders, but Bundle does.
- final Bundle b = new Bundle();
- b.putBinder(EXTRA_BINDER_TOKEN, token);
- intent.putExtra(EXTRA_BINDER_TOKEN, b);
- return BinderUtils.withCleanCallingIdentity(() -> PendingIntent.getBroadcast(
- context, 0 /* requestCode */, intent, PendingIntent.FLAG_IMMUTABLE));
+ @Override
+ public void binderDied() {
+ mConnectivityServiceHandler.post(() -> cleanupAutoOnOffKeepalive(this));
+ }
+
+ /** Close this automatic on/off keepalive */
+ public void close() {
+ // Close the duplicated fd that maintains the lifecycle of socket. If this fd was
+ // not duplicated this is a no-op.
+ FileUtils.closeQuietly(mFd);
+ }
+
+ private String getAutomaticOnOffStateName(int state) {
+ switch (state) {
+ case STATE_ENABLED:
+ return "STATE_ENABLED";
+ case STATE_SUSPENDED:
+ return "STATE_SUSPENDED";
+ case STATE_ALWAYS_ON:
+ return "STATE_ALWAYS_ON";
+ default:
+ Log.e(TAG, "Get unexpected state:" + state);
+ return Integer.toString(state);
+ }
+ }
+
+ @Override
+ public String toString() {
+ return "AutomaticOnOffKeepalive [ "
+ + mKi
+ + ", state=" + getAutomaticOnOffStateName(mAutomaticOnOffState)
+ + " ]";
}
}
@@ -255,18 +278,15 @@
mKeepaliveTracker = mDependencies.newKeepaliveTracker(
mContext, mConnectivityServiceHandler);
- if (SdkLevel.isAtLeastU()) {
- mContext.registerReceiver(mReceiver, new IntentFilter(ACTION_TCP_POLLING_ALARM),
- null, handler);
- }
- mAlarmManager = mContext.getSystemService(AlarmManager.class);
+ mAlarmManager = mDependencies.getAlarmManager(context);
}
- private void startTcpPollingAlarm(@NonNull PendingIntent alarm) {
+ private void startTcpPollingAlarm(@NonNull final AlarmManager.OnAlarmListener listener) {
final long triggerAtMillis =
- SystemClock.elapsedRealtime() + DEFAULT_TCP_POLLING_INTERVAL_MS;
+ SystemClock.elapsedRealtime() + getTcpPollingInterval();
// Setup a non-wake up alarm.
- mAlarmManager.setExact(AlarmManager.ELAPSED_REALTIME, triggerAtMillis, alarm);
+ mAlarmManager.setExact(AlarmManager.ELAPSED_REALTIME, triggerAtMillis, null /* tag */,
+ listener, mConnectivityServiceHandler);
}
/**
@@ -297,13 +317,13 @@
// SUSPENDED.
if (ki.mAutomaticOnOffState == STATE_ENABLED) {
ki.mAutomaticOnOffState = STATE_SUSPENDED;
- handleSuspendKeepalive(ki.mKi);
+ handlePauseKeepalive(ki.mKi);
}
} else {
handleMaybeResumeKeepalive(ki);
}
// TODO: listen to socket status instead of periodically check.
- startTcpPollingAlarm(ki.mTcpPollingAlarm);
+ startTcpPollingAlarm(ki.mAlarmListener);
}
/**
@@ -374,9 +394,16 @@
mKeepaliveTracker.handleStartKeepalive(autoKi.mKi);
// Add automatic on/off request into list to track its life cycle.
+ try {
+ autoKi.mKi.mCallback.asBinder().linkToDeath(autoKi, 0);
+ } catch (RemoteException e) {
+ // The underlying keepalive performs its own cleanup
+ autoKi.binderDied();
+ return;
+ }
mAutomaticOnOffKeepalives.add(autoKi);
if (STATE_ALWAYS_ON != autoKi.mAutomaticOnOffState) {
- startTcpPollingAlarm(autoKi.mTcpPollingAlarm);
+ startTcpPollingAlarm(autoKi.mAlarmListener);
}
}
@@ -384,10 +411,9 @@
mKeepaliveTracker.handleStartKeepalive(ki);
}
- private void handleSuspendKeepalive(@NonNull final KeepaliveTracker.KeepaliveInfo ki) {
+ private void handlePauseKeepalive(@NonNull final KeepaliveTracker.KeepaliveInfo ki) {
// TODO : mKT.handleStopKeepalive should take a KeepaliveInfo instead
- // TODO : create a separate success code for suspend
- mKeepaliveTracker.handleStopKeepalive(ki.getNai(), ki.getSlot(), SUCCESS);
+ mKeepaliveTracker.handleStopKeepalive(ki.getNai(), ki.getSlot(), SUCCESS_PAUSED);
}
/**
@@ -399,6 +425,8 @@
if (autoKi.mAutomaticOnOffState != STATE_SUSPENDED) {
final KeepaliveTracker.KeepaliveInfo ki = autoKi.mKi;
mKeepaliveTracker.handleStopKeepalive(ki.getNai(), ki.getSlot(), reason);
+ } else {
+ mKeepaliveTracker.finalizePausedKeepalive(autoKi.mKi);
}
cleanupAutoOnOffKeepalive(autoKi);
@@ -406,10 +434,15 @@
private void cleanupAutoOnOffKeepalive(@NonNull final AutomaticOnOffKeepalive autoKi) {
ensureRunningOnHandlerThread();
- if (null != autoKi.mTcpPollingAlarm) mAlarmManager.cancel(autoKi.mTcpPollingAlarm);
- // Close the duplicated fd that maintains the lifecycle of socket.
- FileUtils.closeQuietly(autoKi.mFd);
- mAutomaticOnOffKeepalives.remove(autoKi);
+ autoKi.close();
+ if (null != autoKi.mAlarmListener) mAlarmManager.cancel(autoKi.mAlarmListener);
+
+ // If the KI is not in the array, it's because it was already removed, or it was never
+ // added ; the only ways this can happen is if the keepalive is stopped by the app and the
+ // app dies immediately, or if the app died before the link to death could be registered.
+ if (!mAutomaticOnOffKeepalives.remove(autoKi)) return;
+
+ autoKi.mKi.mCallback.asBinder().unlinkToDeath(autoKi, 0);
}
/**
@@ -425,13 +458,13 @@
@NonNull String srcAddrString,
int srcPort,
@NonNull String dstAddrString,
- int dstPort, boolean automaticOnOffKeepalives) {
+ int dstPort, boolean automaticOnOffKeepalives, @Nullable Network underpinnedNetwork) {
final KeepaliveTracker.KeepaliveInfo ki = mKeepaliveTracker.makeNattKeepaliveInfo(nai, fd,
intervalSeconds, cb, srcAddrString, srcPort, dstAddrString, dstPort);
if (null == ki) return;
try {
final AutomaticOnOffKeepalive autoKi = new AutomaticOnOffKeepalive(ki,
- automaticOnOffKeepalives, mContext);
+ automaticOnOffKeepalives, mContext, underpinnedNetwork);
mConnectivityServiceHandler.obtainMessage(NetworkAgent.CMD_START_SOCKET_KEEPALIVE,
// TODO : move ConnectivityService#encodeBool to a static lib.
automaticOnOffKeepalives ? 1 : 0, 0, autoKi).sendToTarget();
@@ -454,13 +487,14 @@
@NonNull String srcAddrString,
@NonNull String dstAddrString,
int dstPort,
- boolean automaticOnOffKeepalives) {
+ boolean automaticOnOffKeepalives,
+ @Nullable Network underpinnedNetwork) {
final KeepaliveTracker.KeepaliveInfo ki = mKeepaliveTracker.makeNattKeepaliveInfo(nai, fd,
resourceId, intervalSeconds, cb, srcAddrString, dstAddrString, dstPort);
if (null == ki) return;
try {
final AutomaticOnOffKeepalive autoKi = new AutomaticOnOffKeepalive(ki,
- automaticOnOffKeepalives, mContext);
+ automaticOnOffKeepalives, mContext, underpinnedNetwork);
mConnectivityServiceHandler.obtainMessage(NetworkAgent.CMD_START_SOCKET_KEEPALIVE,
// TODO : move ConnectivityService#encodeBool to a static lib.
automaticOnOffKeepalives ? 1 : 0, 0, autoKi).sendToTarget();
@@ -489,7 +523,8 @@
if (null == ki) return;
try {
final AutomaticOnOffKeepalive autoKi = new AutomaticOnOffKeepalive(ki,
- false /* autoOnOff, tcp keepalives are never auto on/off */, mContext);
+ false /* autoOnOff, tcp keepalives are never auto on/off */,
+ mContext, null /* underpinnedNetwork, tcp keepalives do not refer to this */);
mConnectivityServiceHandler.obtainMessage(CMD_START_SOCKET_KEEPALIVE, autoKi)
.sendToTarget();
} catch (InvalidSocketException e) {
@@ -501,8 +536,19 @@
* Dump AutomaticOnOffKeepaliveTracker state.
*/
public void dump(IndentingPrintWriter pw) {
- // TODO: Dump the necessary information for automatic on/off keepalive.
mKeepaliveTracker.dump(pw);
+ // Reading DeviceConfig will check if the calling uid and calling package name are the same.
+ // Clear calling identity to align the calling uid and package so that it won't fail if cts
+ // would like to do the dump()
+ final boolean featureEnabled = BinderUtils.withCleanCallingIdentity(
+ () -> mDependencies.isFeatureEnabled(AUTOMATIC_ON_OFF_KEEPALIVE_VERSION,
+ true /* defaultEnabled */));
+ pw.println("AutomaticOnOff enabled: " + featureEnabled);
+ pw.increaseIndent();
+ for (AutomaticOnOffKeepalive autoKi : mAutomaticOnOffKeepalives) {
+ pw.println(autoKi.toString());
+ }
+ pw.decreaseIndent();
}
/**
@@ -632,6 +678,20 @@
}
}
+ private long getTcpPollingInterval() {
+ final boolean useLowTimer = mTestLowTcpPollingTimerUntilMs > System.currentTimeMillis();
+ return useLowTimer ? LOW_TCP_POLLING_INTERVAL_MS : DEFAULT_TCP_POLLING_INTERVAL_MS;
+ }
+
+ /**
+ * Temporarily use low TCP polling timer for testing.
+ * The value works when the time set is more than {@link System.currentTimeMillis()}.
+ */
+ public void handleSetTestLowTcpPollingTimer(long timeMs) {
+ Log.d(TAG, "handleSetTestLowTcpPollingTimer: " + timeMs);
+ mTestLowTcpPollingTimerUntilMs = timeMs;
+ }
+
/**
* Dependencies class for testing.
*/
@@ -681,6 +741,13 @@
}
/**
+ * Get an instance of AlarmManager
+ */
+ public AlarmManager getAlarmManager(@NonNull final Context ctx) {
+ return ctx.getSystemService(AlarmManager.class);
+ }
+
+ /**
* Receive the response message from kernel via given {@code FileDescriptor}.
* The usage should follow the {@code #sendRequest} call with the same
* FileDescriptor.
@@ -712,10 +779,13 @@
* Find out if a feature is enabled from DeviceConfig.
*
* @param name The name of the property to look up.
+ * @param defaultEnabled whether to consider the feature enabled in the absence of
+ * the flag. This MUST be a statically-known constant.
* @return whether the feature is enabled
*/
- public boolean isFeatureEnabled(@NonNull final String name) {
- return DeviceConfigUtils.isFeatureEnabled(mContext, NAMESPACE_CONNECTIVITY, name);
+ public boolean isFeatureEnabled(@NonNull final String name, final boolean defaultEnabled) {
+ return DeviceConfigUtils.isFeatureEnabled(mContext, NAMESPACE_TETHERING, name,
+ defaultEnabled);
}
}
}
diff --git a/service/src/com/android/server/connectivity/InvalidTagException.java b/service/src/com/android/server/connectivity/InvalidTagException.java
new file mode 100644
index 0000000..b924d27
--- /dev/null
+++ b/service/src/com/android/server/connectivity/InvalidTagException.java
@@ -0,0 +1,28 @@
+/*
+ * 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 com.android.server.connectivity;
+
+
+/**
+ * An exception thrown when a Tag is not valid in self_certified_network_capabilities.xml.
+ */
+public class InvalidTagException extends Exception {
+
+ public InvalidTagException(String message) {
+ super(message);
+ }
+}
diff --git a/service/src/com/android/server/connectivity/KeepaliveTracker.java b/service/src/com/android/server/connectivity/KeepaliveTracker.java
index a512b7c..06294db 100644
--- a/service/src/com/android/server/connectivity/KeepaliveTracker.java
+++ b/service/src/com/android/server/connectivity/KeepaliveTracker.java
@@ -32,6 +32,7 @@
import static android.net.SocketKeepalive.MIN_INTERVAL_SEC;
import static android.net.SocketKeepalive.NO_KEEPALIVE;
import static android.net.SocketKeepalive.SUCCESS;
+import static android.net.SocketKeepalive.SUCCESS_PAUSED;
import android.annotation.NonNull;
import android.annotation.Nullable;
@@ -57,6 +58,7 @@
import android.util.Pair;
import com.android.connectivity.resources.R;
+import com.android.internal.annotations.VisibleForTesting;
import com.android.internal.util.IndentingPrintWriter;
import com.android.net.module.util.HexDump;
import com.android.net.module.util.IpUtils;
@@ -124,7 +126,8 @@
* All information about this keepalive is known at construction time except the slot number,
* which is only returned when the hardware has successfully started the keepalive.
*/
- class KeepaliveInfo implements IBinder.DeathRecipient {
+ @VisibleForTesting
+ public class KeepaliveInfo implements IBinder.DeathRecipient {
// TODO : remove this member. Only AutoOnOffKeepalive should have a reference to this.
public final ISocketKeepaliveCallback mCallback;
// Bookkeeping data.
@@ -134,6 +137,9 @@
public final NetworkAgentInfo mNai;
private final int mType;
public final FileDescriptor mFd;
+ // True if this was resumed from a previously turned off keepalive, otherwise false.
+ // This is necessary to send the correct callbacks.
+ public final boolean mResumed;
public static final int TYPE_NATT = 1;
public static final int TYPE_TCP = 2;
@@ -160,6 +166,16 @@
int interval,
int type,
@Nullable FileDescriptor fd) throws InvalidSocketException {
+ this(callback, nai, packet, interval, type, fd, false /* resumed */);
+ }
+
+ KeepaliveInfo(@NonNull ISocketKeepaliveCallback callback,
+ @NonNull NetworkAgentInfo nai,
+ @NonNull KeepalivePacketData packet,
+ int interval,
+ int type,
+ @Nullable FileDescriptor fd,
+ boolean resumed) throws InvalidSocketException {
mCallback = callback;
mPid = Binder.getCallingPid();
mUid = Binder.getCallingUid();
@@ -169,6 +185,7 @@
mPacket = packet;
mInterval = interval;
mType = type;
+ mResumed = resumed;
// For SocketKeepalive, a dup of fd is kept in mFd so the source port from which the
// keepalives are sent cannot be reused by another app even if the fd gets closed by
@@ -232,6 +249,8 @@
/** Called when the application process is killed. */
public void binderDied() {
+ // TODO b/267106526 : this is not called on the handler thread but stop() happily
+ // assumes it is, which means this is a pretty dangerous race condition.
stop(BINDER_DIED);
}
@@ -327,6 +346,10 @@
}
void start(int slot) {
+ // BINDER_DIED can happen if the binder died before the KeepaliveInfo was created and
+ // the constructor set the state to BINDER_DIED. If that's the case, the KI is already
+ // cleaned up.
+ if (BINDER_DIED == mStartedState) return;
mSlot = slot;
int error = isValid();
if (error == SUCCESS) {
@@ -371,7 +394,10 @@
// To prevent races from re-entrance of stop(), return if the state is already stopping.
// This might happen if multiple event sources stop keepalive in a short time. Such as
// network disconnect after user calls stop(), or tear down socket after binder died.
- if (mStartedState == STOPPING) return;
+ // Note that it's always possible this method is called by the auto keepalive timer
+ // or any other way after the binder died, hence the check for BINDER_DIED. If the
+ // binder has died, then the KI has already been cleaned up.
+ if (mStartedState == STOPPING || mStartedState == BINDER_DIED) return;
// Store the reason of stopping, and report it after the keepalive is fully stopped.
if (mStopReason != ERROR_STOP_REASON_UNINITIALIZED) {
@@ -382,9 +408,10 @@
+ ": " + reason);
switch (mStartedState) {
case NOT_STARTED:
- // Remove the reference of the keepalive that meet error before starting,
+ // Remove the reference to this keepalive that had an error before starting,
// e.g. invalid parameter.
cleanupStoppedKeepalive(mNai, mSlot);
+ if (BINDER_DIED == reason) mStartedState = BINDER_DIED;
break;
default:
mStartedState = STOPPING;
@@ -422,7 +449,8 @@
* Construct a new KeepaliveInfo from existing KeepaliveInfo with a new fd.
*/
public KeepaliveInfo withFd(@NonNull FileDescriptor fd) throws InvalidSocketException {
- return new KeepaliveInfo(mCallback, mNai, mPacket, mInterval, mType, fd);
+ return new KeepaliveInfo(mCallback, mNai, mPacket, mInterval, mType, fd,
+ true /* resumed */);
}
}
@@ -523,6 +551,12 @@
} catch (RemoteException e) {
Log.w(TAG, "Discarded onStop callback: " + reason);
}
+ } else if (reason == SUCCESS_PAUSED) {
+ try {
+ ki.mCallback.onPaused();
+ } catch (RemoteException e) {
+ Log.w(TAG, "Discarded onPaused callback: " + reason);
+ }
} else if (reason == DATA_RECEIVED) {
try {
ki.mCallback.onDataReceived();
@@ -540,6 +574,25 @@
ki.unlinkDeathRecipient();
}
+ /**
+ * Finalize a paused keepalive.
+ *
+ * This will simply send the onStopped() callback after checking that this keepalive is
+ * indeed paused.
+ *
+ * @param ki the keepalive to finalize
+ */
+ public void finalizePausedKeepalive(@NonNull final KeepaliveInfo ki) {
+ if (SUCCESS_PAUSED != ki.mStopReason) {
+ throw new IllegalStateException("Keepalive is not paused");
+ }
+ try {
+ ki.mCallback.onStopped();
+ } catch (RemoteException e) {
+ Log.w(TAG, "Discarded onStopped callback while finalizing paused keepalive");
+ }
+ }
+
public void handleCheckKeepalivesStillValid(NetworkAgentInfo nai) {
HashMap <Integer, KeepaliveInfo> networkKeepalives = mKeepalives.get(nai);
if (networkKeepalives != null) {
@@ -589,9 +642,14 @@
Log.d(TAG, "Started keepalive " + slot + " on " + nai.toShortString());
ki.mStartedState = KeepaliveInfo.STARTED;
try {
- ki.mCallback.onStarted();
+ if (ki.mResumed) {
+ ki.mCallback.onResumed();
+ } else {
+ ki.mCallback.onStarted();
+ }
} catch (RemoteException e) {
- Log.w(TAG, "Discarded onStarted callback");
+ Log.w(TAG, "Discarded " + (ki.mResumed ? "onResumed" : "onStarted")
+ + " callback for slot " + slot);
}
} else {
Log.d(TAG, "Failed to start keepalive " + slot + " on " + nai.toShortString()
diff --git a/tests/common/Android.bp b/tests/common/Android.bp
index 5c9cc63..8e47235 100644
--- a/tests/common/Android.bp
+++ b/tests/common/Android.bp
@@ -65,7 +65,7 @@
defaults: ["jarjar-rules-combine-defaults"],
srcs: [
"tethering-jni-jarjar-rules.txt",
- ":connectivity-jarjar-rules",
+ ":frameworks-net-tests-jarjar-rules",
":TetheringTestsJarJarRules",
":NetworkStackJarJarRules",
],
diff --git a/tests/common/java/android/net/LinkPropertiesTest.java b/tests/common/java/android/net/LinkPropertiesTest.java
index 5ee375f..09f5d6e 100644
--- a/tests/common/java/android/net/LinkPropertiesTest.java
+++ b/tests/common/java/android/net/LinkPropertiesTest.java
@@ -32,6 +32,7 @@
import android.compat.testing.PlatformCompatChangeRule;
import android.net.LinkProperties.ProvisioningChange;
+import android.net.connectivity.ConnectivityCompatChanges;
import android.os.Build;
import android.system.OsConstants;
import android.util.ArraySet;
@@ -1261,7 +1262,7 @@
@Test @IgnoreUpTo(Build.VERSION_CODES.R)
@CtsNetTestCasesMaxTargetSdk31(reason = "Compat change cannot be overridden when targeting T+")
- @EnableCompatChanges({LinkProperties.EXCLUDED_ROUTES})
+ @EnableCompatChanges({ConnectivityCompatChanges.EXCLUDED_ROUTES})
public void testHasExcludeRoute() {
LinkProperties lp = new LinkProperties();
lp.setInterfaceName("tun0");
@@ -1274,7 +1275,7 @@
@Test @IgnoreUpTo(Build.VERSION_CODES.R)
@CtsNetTestCasesMaxTargetSdk31(reason = "Compat change cannot be overridden when targeting T+")
- @EnableCompatChanges({LinkProperties.EXCLUDED_ROUTES})
+ @EnableCompatChanges({ConnectivityCompatChanges.EXCLUDED_ROUTES})
public void testRouteAddWithSameKey() throws Exception {
LinkProperties lp = new LinkProperties();
lp.setInterfaceName("wlan0");
@@ -1348,14 +1349,14 @@
@Test @IgnoreUpTo(Build.VERSION_CODES.R)
@CtsNetTestCasesMaxTargetSdk31(reason = "Compat change cannot be overridden when targeting T+")
- @EnableCompatChanges({LinkProperties.EXCLUDED_ROUTES})
+ @EnableCompatChanges({ConnectivityCompatChanges.EXCLUDED_ROUTES})
public void testExcludedRoutesEnabledByCompatChange() {
assertExcludeRoutesVisible();
}
@Test @IgnoreUpTo(Build.VERSION_CODES.R)
@CtsNetTestCasesMaxTargetSdk31(reason = "Compat change cannot be overridden when targeting T+")
- @DisableCompatChanges({LinkProperties.EXCLUDED_ROUTES})
+ @DisableCompatChanges({ConnectivityCompatChanges.EXCLUDED_ROUTES})
public void testExcludedRoutesDisabledByCompatChange() {
checkExcludeRoutesNotVisibleAfterS();
}
diff --git a/tests/common/java/android/net/netstats/NetworkTemplateTest.kt b/tests/common/java/android/net/netstats/NetworkTemplateTest.kt
index 99f1e0b..fb6759e 100644
--- a/tests/common/java/android/net/netstats/NetworkTemplateTest.kt
+++ b/tests/common/java/android/net/netstats/NetworkTemplateTest.kt
@@ -95,6 +95,13 @@
NetworkTemplate.Builder(MATCH_CARRIER).build()
}
+ // Verify carrier and mobile template cannot contain one of subscriber Id is null.
+ listOf(MATCH_MOBILE, MATCH_CARRIER).forEach {
+ assertFailsWith<IllegalArgumentException> {
+ NetworkTemplate.Builder(it).setSubscriberIds(setOf(null)).build()
+ }
+ }
+
// Verify template which matches metered cellular networks,
// regardless of IMSI. See buildTemplateMobileWildcard.
NetworkTemplate.Builder(MATCH_MOBILE).setMeteredness(METERED_YES).build().let {
diff --git a/tests/cts/hostside/Android.bp b/tests/cts/hostside/Android.bp
index 47ea53e..891c2dd 100644
--- a/tests/cts/hostside/Android.bp
+++ b/tests/cts/hostside/Android.bp
@@ -12,6 +12,16 @@
// See the License for the specific language governing permissions and
// limitations under the License.
+next_app_data = [ ":CtsHostsideNetworkTestsAppNext" ]
+
+// The above line is put in place to prevent any future automerger merge conflict between aosp,
+// downstream branches. The CtsHostsideNetworkTestsAppNext target will not exist in
+// some downstream branches, but it should exist in aosp and some downstream branches.
+
+
+
+
+
package {
default_applicable_licenses: ["Android-Apache-2.0"],
}
@@ -37,7 +47,9 @@
data: [
":CtsHostsideNetworkTestsApp",
":CtsHostsideNetworkTestsApp2",
- ":CtsHostsideNetworkTestsAppNext",
- ],
+ ":CtsHostsideNetworkCapTestsAppWithoutProperty",
+ ":CtsHostsideNetworkCapTestsAppWithProperty",
+ ":CtsHostsideNetworkCapTestsAppSdk33",
+ ] + next_app_data,
per_testcase_directory: true,
}
diff --git a/tests/cts/hostside/app/src/com/android/cts/net/hostside/VpnTest.java b/tests/cts/hostside/app/src/com/android/cts/net/hostside/VpnTest.java
index a62ef8a..a5bf000 100755
--- a/tests/cts/hostside/app/src/com/android/cts/net/hostside/VpnTest.java
+++ b/tests/cts/hostside/app/src/com/android/cts/net/hostside/VpnTest.java
@@ -41,6 +41,7 @@
import static com.android.networkstack.apishim.ConstantsShim.RECEIVER_EXPORTED;
import static com.android.testutils.Cleanup.testAndCleanup;
import static com.android.testutils.DevSdkIgnoreRuleKt.SC_V2;
+import static com.android.testutils.RecorderCallback.CallbackEntry.BLOCKED_STATUS_INT;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
@@ -94,7 +95,6 @@
import android.system.Os;
import android.system.OsConstants;
import android.system.StructPollfd;
-import android.telephony.TelephonyManager;
import android.test.MoreAsserts;
import android.text.TextUtils;
import android.util.ArraySet;
@@ -198,8 +198,8 @@
private RemoteSocketFactoryClient mRemoteSocketFactoryClient;
private CtsNetUtils mCtsNetUtils;
private PackageManager mPackageManager;
- private TelephonyManager mTelephonyManager;
-
+ private Context mTestContext;
+ private Context mTargetContext;
Network mNetwork;
NetworkCallback mCallback;
final Object mLock = new Object();
@@ -229,21 +229,19 @@
public void setUp() throws Exception {
mNetwork = null;
mCallback = null;
+ mTestContext = getInstrumentation().getContext();
+ mTargetContext = getInstrumentation().getTargetContext();
storePrivateDnsSetting();
-
mDevice = UiDevice.getInstance(getInstrumentation());
- mActivity = launchActivity(getInstrumentation().getTargetContext().getPackageName(),
- MyActivity.class);
+ mActivity = launchActivity(mTargetContext.getPackageName(), MyActivity.class);
mPackageName = mActivity.getPackageName();
mCM = (ConnectivityManager) mActivity.getSystemService(Context.CONNECTIVITY_SERVICE);
mWifiManager = (WifiManager) mActivity.getSystemService(Context.WIFI_SERVICE);
mRemoteSocketFactoryClient = new RemoteSocketFactoryClient(mActivity);
mRemoteSocketFactoryClient.bind();
mDevice.waitForIdle();
- mCtsNetUtils = new CtsNetUtils(getInstrumentation().getContext());
- mPackageManager = getInstrumentation().getContext().getPackageManager();
- mTelephonyManager =
- getInstrumentation().getContext().getSystemService(TelephonyManager.class);
+ mCtsNetUtils = new CtsNetUtils(mTestContext);
+ mPackageManager = mTestContext.getPackageManager();
}
@After
@@ -742,7 +740,7 @@
}
private ContentResolver getContentResolver() {
- return getInstrumentation().getContext().getContentResolver();
+ return mTestContext.getContentResolver();
}
private boolean isPrivateDnsInStrictMode() {
@@ -791,7 +789,7 @@
}
private void setAndVerifyPrivateDns(boolean strictMode) throws Exception {
- final ContentResolver cr = getInstrumentation().getContext().getContentResolver();
+ final ContentResolver cr = mTestContext.getContentResolver();
String privateDnsHostname;
if (strictMode) {
@@ -929,7 +927,7 @@
}
final BlockingBroadcastReceiver receiver = new BlockingBroadcastReceiver(
- getInstrumentation().getTargetContext(), MyVpnService.ACTION_ESTABLISHED);
+ mTargetContext, MyVpnService.ACTION_ESTABLISHED);
receiver.register();
// Test the behaviour of a variety of types of network callbacks.
@@ -1525,7 +1523,7 @@
private boolean received;
public ProxyChangeBroadcastReceiver() {
- super(getInstrumentation().getContext(), Proxy.PROXY_CHANGE_ACTION);
+ super(mTestContext, Proxy.PROXY_CHANGE_ACTION);
received = false;
}
@@ -1555,12 +1553,11 @@
"" /* allowedApps */, "com.android.providers.downloads", null /* proxyInfo */,
null /* underlyingNetworks */, false /* isAlwaysMetered */);
- final Context context = getInstrumentation().getContext();
- final DownloadManager dm = context.getSystemService(DownloadManager.class);
+ final DownloadManager dm = mTestContext.getSystemService(DownloadManager.class);
final DownloadCompleteReceiver receiver = new DownloadCompleteReceiver();
try {
final int flags = SdkLevel.isAtLeastT() ? RECEIVER_EXPORTED : 0;
- context.registerReceiver(receiver,
+ mTestContext.registerReceiver(receiver,
new IntentFilter(DownloadManager.ACTION_DOWNLOAD_COMPLETE), flags);
// Enqueue a request and check only one download.
@@ -1578,7 +1575,7 @@
assertEquals(1, dm.remove(id));
assertEquals(0, getTotalNumberDownloads(dm, new Query()));
} finally {
- context.unregisterReceiver(receiver);
+ mTestContext.unregisterReceiver(receiver);
}
}
@@ -1615,8 +1612,7 @@
// Create a TUN interface
final FileDescriptor tunFd = runWithShellPermissionIdentity(() -> {
- final TestNetworkManager tnm = getInstrumentation().getContext().getSystemService(
- TestNetworkManager.class);
+ final TestNetworkManager tnm = mTestContext.getSystemService(TestNetworkManager.class);
final TestNetworkInterface iface = tnm.createTunInterface(List.of(
TEST_IP4_DST_ADDR, TEST_IP6_DST_ADDR));
return iface.getFileDescriptor().getFileDescriptor();
@@ -1643,7 +1639,8 @@
// setRequireVpnForUids setup a lockdown rule asynchronously. So it needs to wait for
// BlockedStatusCallback to be fired before checking the blocking status of incoming
// packets.
- remoteUidCallback.expectBlockedStatusCallback(network, BLOCKED_REASON_LOCKDOWN_VPN);
+ remoteUidCallback.expect(BLOCKED_STATUS_INT, network,
+ cb -> cb.getReason() == BLOCKED_REASON_LOCKDOWN_VPN);
if (SdkLevel.isAtLeastT()) {
// On T and above, lockdown rule drop packets not coming from lo regardless of the
@@ -1818,9 +1815,6 @@
super.expectAvailableCallbacks(network, false /* suspended */, true /* validated */,
BLOCKED_REASON_NONE, NETWORK_CALLBACK_TIMEOUT_MS);
}
- public void expectBlockedStatusCallback(Network network, int blockedStatus) {
- super.expectBlockedStatusCallback(blockedStatus, network, NETWORK_CALLBACK_TIMEOUT_MS);
- }
public void onBlockedStatusChanged(Network network, int blockedReasons) {
getHistory().add(new CallbackEntry.BlockedStatusInt(network, blockedReasons));
}
diff --git a/tests/cts/hostside/networkslicingtestapp/Android.bp b/tests/cts/hostside/networkslicingtestapp/Android.bp
new file mode 100644
index 0000000..2aa3f69
--- /dev/null
+++ b/tests/cts/hostside/networkslicingtestapp/Android.bp
@@ -0,0 +1,65 @@
+//
+// 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 {
+ default_applicable_licenses: ["Android-Apache-2.0"],
+}
+
+java_defaults {
+ name: "CtsHostsideNetworkCapTestsAppDefaults",
+ platform_apis: true,
+ static_libs: [
+ "androidx.test.ext.junit",
+ "androidx.test.rules",
+ "modules-utils-build",
+ "cts-net-utils",
+ ],
+ srcs: ["src/**/*.java"],
+ // Tag this module as a cts test artifact
+ test_suites: [
+ "cts",
+ "general-tests",
+ "sts",
+ ],
+}
+
+android_test_helper_app {
+ name: "CtsHostsideNetworkCapTestsAppWithoutProperty",
+ defaults: [
+ "cts_support_defaults",
+ "CtsHostsideNetworkCapTestsAppDefaults"
+ ],
+ manifest: "AndroidManifestWithoutProperty.xml",
+}
+
+android_test_helper_app {
+ name: "CtsHostsideNetworkCapTestsAppWithProperty",
+ defaults: [
+ "cts_support_defaults",
+ "CtsHostsideNetworkCapTestsAppDefaults"
+ ],
+ manifest: "AndroidManifestWithProperty.xml",
+}
+
+android_test_helper_app {
+ name: "CtsHostsideNetworkCapTestsAppSdk33",
+ defaults: [
+ "cts_support_defaults",
+ "CtsHostsideNetworkCapTestsAppDefaults"
+ ],
+ target_sdk_version: "33",
+ manifest: "AndroidManifestWithoutProperty.xml",
+}
diff --git a/tests/cts/hostside/networkslicingtestapp/AndroidManifestWithProperty.xml b/tests/cts/hostside/networkslicingtestapp/AndroidManifestWithProperty.xml
new file mode 100644
index 0000000..3ef0376
--- /dev/null
+++ b/tests/cts/hostside/networkslicingtestapp/AndroidManifestWithProperty.xml
@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ 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.
+-->
+
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ package="com.android.cts.net.hostside.networkslicingtestapp">
+
+ <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+ <uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" />
+
+ <application>
+ <uses-library android:name="android.test.runner"/>
+ <property android:name="android.net.PROPERTY_SELF_CERTIFIED_NETWORK_CAPABILITIES"
+ android:resource="@xml/self_certified_network_capabilities_both" />
+ </application>
+
+ <instrumentation android:name="androidx.test.runner.AndroidJUnitRunner"
+ android:targetPackage="com.android.cts.net.hostside.networkslicingtestapp"/>
+
+</manifest>
diff --git a/tests/cts/hostside/networkslicingtestapp/AndroidManifestWithoutProperty.xml b/tests/cts/hostside/networkslicingtestapp/AndroidManifestWithoutProperty.xml
new file mode 100644
index 0000000..fe66684
--- /dev/null
+++ b/tests/cts/hostside/networkslicingtestapp/AndroidManifestWithoutProperty.xml
@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ 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.
+-->
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ package="com.android.cts.net.hostside.networkslicingtestapp">
+
+ <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+ <uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" />
+
+ <application>
+ <uses-library android:name="android.test.runner"/>
+ </application>
+
+ <instrumentation android:name="androidx.test.runner.AndroidJUnitRunner"
+ android:targetPackage="com.android.cts.net.hostside.networkslicingtestapp"/>
+
+</manifest>
diff --git a/tests/cts/hostside/networkslicingtestapp/res/xml/self_certified_network_capabilities_both.xml b/tests/cts/hostside/networkslicingtestapp/res/xml/self_certified_network_capabilities_both.xml
new file mode 100644
index 0000000..4066be2
--- /dev/null
+++ b/tests/cts/hostside/networkslicingtestapp/res/xml/self_certified_network_capabilities_both.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+
+<network-capabilities-declaration xmlns:android="http://schemas.android.com/apk/res/android">
+ <uses-network-capability android:name="NET_CAPABILITY_PRIORITIZE_LATENCY"/>
+ <uses-network-capability android:name="NET_CAPABILITY_PRIORITIZE_BANDWIDTH"/>
+</network-capabilities-declaration>
diff --git a/tests/cts/hostside/networkslicingtestapp/src/com.android.cts.net.hostside.networkslicingtestapp/NetworkSelfDeclaredCapabilitiesTest.java b/tests/cts/hostside/networkslicingtestapp/src/com.android.cts.net.hostside.networkslicingtestapp/NetworkSelfDeclaredCapabilitiesTest.java
new file mode 100644
index 0000000..39792fc
--- /dev/null
+++ b/tests/cts/hostside/networkslicingtestapp/src/com.android.cts.net.hostside.networkslicingtestapp/NetworkSelfDeclaredCapabilitiesTest.java
@@ -0,0 +1,98 @@
+/*
+ * 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 com.android.cts.net.hostside.networkslicingtestapp;
+
+import static org.junit.Assert.assertThrows;
+
+import android.content.Context;
+import android.net.ConnectivityManager;
+import android.net.NetworkCapabilities;
+import android.net.NetworkRequest;
+import android.os.Build;
+
+import androidx.test.platform.app.InstrumentationRegistry;
+import androidx.test.runner.AndroidJUnit4;
+
+import com.android.testutils.DevSdkIgnoreRule;
+import com.android.testutils.DevSdkIgnoreRule.IgnoreUpTo;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+@RunWith(AndroidJUnit4.class)
+public class NetworkSelfDeclaredCapabilitiesTest {
+
+ @Rule
+ public final DevSdkIgnoreRule mDevSdkIgnoreRule = new DevSdkIgnoreRule();
+
+ @Test
+ @IgnoreUpTo(Build.VERSION_CODES.TIRAMISU)
+ public void requestNetwork_withoutRequestCapabilities() {
+ final ConnectivityManager cm =
+ (ConnectivityManager)
+ InstrumentationRegistry.getInstrumentation()
+ .getContext()
+ .getSystemService(Context.CONNECTIVITY_SERVICE);
+ final NetworkRequest request =
+ new NetworkRequest.Builder().build();
+ final ConnectivityManager.NetworkCallback callback =
+ new ConnectivityManager.NetworkCallback();
+ cm.requestNetwork(request, callback);
+ cm.unregisterNetworkCallback(callback);
+ }
+
+ @Test
+ @IgnoreUpTo(Build.VERSION_CODES.TIRAMISU)
+ public void requestNetwork_withSelfDeclaredCapabilities() {
+ final ConnectivityManager cm =
+ (ConnectivityManager)
+ InstrumentationRegistry.getInstrumentation()
+ .getContext()
+ .getSystemService(Context.CONNECTIVITY_SERVICE);
+ final NetworkRequest request =
+ new NetworkRequest.Builder()
+ .addCapability(NetworkCapabilities.NET_CAPABILITY_PRIORITIZE_BANDWIDTH)
+ .addCapability(NetworkCapabilities.NET_CAPABILITY_PRIORITIZE_LATENCY)
+ .build();
+ final ConnectivityManager.NetworkCallback callback =
+ new ConnectivityManager.NetworkCallback();
+ cm.requestNetwork(request, callback);
+ cm.unregisterNetworkCallback(callback);
+ }
+
+ @Test
+ @IgnoreUpTo(Build.VERSION_CODES.TIRAMISU)
+ public void requestNetwork_lackingRequiredSelfDeclaredCapabilities() {
+ final ConnectivityManager cm =
+ (ConnectivityManager)
+ InstrumentationRegistry.getInstrumentation()
+ .getContext()
+ .getSystemService(Context.CONNECTIVITY_SERVICE);
+ final NetworkRequest request =
+ new NetworkRequest.Builder()
+ .addCapability(NetworkCapabilities.NET_CAPABILITY_PRIORITIZE_BANDWIDTH)
+ .addCapability(NetworkCapabilities.NET_CAPABILITY_PRIORITIZE_LATENCY)
+ .build();
+ final ConnectivityManager.NetworkCallback callback =
+ new ConnectivityManager.NetworkCallback();
+ assertThrows(
+ SecurityException.class,
+ () -> cm.requestNetwork(request, callback));
+ }
+
+}
diff --git a/tests/cts/hostside/src/com/android/cts/net/HostsideNetworkTestCase.java b/tests/cts/hostside/src/com/android/cts/net/HostsideNetworkTestCase.java
index d0567ae..2aa1032 100644
--- a/tests/cts/hostside/src/com/android/cts/net/HostsideNetworkTestCase.java
+++ b/tests/cts/hostside/src/com/android/cts/net/HostsideNetworkTestCase.java
@@ -31,6 +31,7 @@
import com.android.tradefed.testtype.IAbi;
import com.android.tradefed.testtype.IAbiReceiver;
import com.android.tradefed.testtype.IBuildReceiver;
+import com.android.tradefed.util.RunUtil;
import java.io.FileNotFoundException;
import java.util.Map;
@@ -120,7 +121,7 @@
i++;
Log.v(TAG, "Package " + packageName + " not uninstalled yet (" + result
+ "); sleeping 1s before polling again");
- Thread.sleep(1000);
+ RunUtil.getDefault().sleep(1000);
}
fail("Package '" + packageName + "' not uinstalled after " + max_tries + " seconds");
}
diff --git a/tests/cts/hostside/src/com/android/cts/net/HostsideRestrictBackgroundNetworkTests.java b/tests/cts/hostside/src/com/android/cts/net/HostsideRestrictBackgroundNetworkTests.java
index 7a613b3..21c78b7 100644
--- a/tests/cts/hostside/src/com/android/cts/net/HostsideRestrictBackgroundNetworkTests.java
+++ b/tests/cts/hostside/src/com/android/cts/net/HostsideRestrictBackgroundNetworkTests.java
@@ -20,6 +20,7 @@
import com.android.ddmlib.Log;
import com.android.tradefed.device.DeviceNotAvailableException;
+import com.android.tradefed.util.RunUtil;
public class HostsideRestrictBackgroundNetworkTests extends HostsideNetworkTestCase {
@@ -359,7 +360,7 @@
}
Log.v(TAG, "whitelist check for uid " + uid + " doesn't match yet (expected "
+ expected + ", got " + actual + "); sleeping 1s before polling again");
- Thread.sleep(1000);
+ RunUtil.getDefault().sleep(1000);
}
fail("whitelist check for uid " + uid + " failed: expected "
+ expected + ", got " + actual);
@@ -384,7 +385,7 @@
if (result.equals(expectedResult)) return;
Log.v(TAG, "Command '" + command + "' returned '" + result + " instead of '"
+ expectedResult + "' on attempt #; sleeping 1s before polling again");
- Thread.sleep(1000);
+ RunUtil.getDefault().sleep(1000);
}
fail("Command '" + command + "' did not return '" + expectedResult + "' after " + maxTries
+ " attempts");
diff --git a/tests/cts/hostside/src/com/android/cts/net/HostsideSelfDeclaredNetworkCapabilitiesCheckTest.java b/tests/cts/hostside/src/com/android/cts/net/HostsideSelfDeclaredNetworkCapabilitiesCheckTest.java
new file mode 100644
index 0000000..4c2985d
--- /dev/null
+++ b/tests/cts/hostside/src/com/android/cts/net/HostsideSelfDeclaredNetworkCapabilitiesCheckTest.java
@@ -0,0 +1,96 @@
+/*
+ * 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 com.android.cts.net;
+
+public class HostsideSelfDeclaredNetworkCapabilitiesCheckTest extends HostsideNetworkTestCase {
+
+ private static final String TEST_WITH_PROPERTY_IN_CURRENT_SDK_APK =
+ "CtsHostsideNetworkCapTestsAppWithProperty.apk";
+ private static final String TEST_WITHOUT_PROPERTY_IN_CURRENT_SDK_APK =
+ "CtsHostsideNetworkCapTestsAppWithoutProperty.apk";
+ private static final String TEST_IN_SDK_33_APK =
+ "CtsHostsideNetworkCapTestsAppSdk33.apk";
+ private static final String TEST_APP_PKG =
+ "com.android.cts.net.hostside.networkslicingtestapp";
+ private static final String TEST_CLASS_NAME = ".NetworkSelfDeclaredCapabilitiesTest";
+ private static final String WITH_SELF_DECLARED_CAPABILITIES_METHOD =
+ "requestNetwork_withSelfDeclaredCapabilities";
+ private static final String LACKING_SELF_DECLARED_CAPABILITIES_METHOD =
+ "requestNetwork_lackingRequiredSelfDeclaredCapabilities";
+ private static final String WITHOUT_REQUEST_CAPABILITIES_METHOD =
+ "requestNetwork_withoutRequestCapabilities";
+
+
+ public void testRequestNetworkInCurrentSdkWithProperty() throws Exception {
+ uninstallPackage(TEST_APP_PKG, false);
+ installPackage(TEST_WITH_PROPERTY_IN_CURRENT_SDK_APK);
+ // If the self-declared capabilities are defined,
+ // the ConnectivityManager.requestNetwork() call should always pass.
+ runDeviceTests(TEST_APP_PKG,
+ TEST_APP_PKG + TEST_CLASS_NAME,
+ WITH_SELF_DECLARED_CAPABILITIES_METHOD);
+ runDeviceTests(TEST_APP_PKG,
+ TEST_APP_PKG + TEST_CLASS_NAME,
+ WITHOUT_REQUEST_CAPABILITIES_METHOD);
+ uninstallPackage(TEST_APP_PKG, true);
+ }
+
+ public void testRequestNetworkInCurrentSdkWithoutProperty() throws Exception {
+ uninstallPackage(TEST_APP_PKG, false);
+ installPackage(TEST_WITHOUT_PROPERTY_IN_CURRENT_SDK_APK);
+ // If the self-declared capabilities are not defined,
+ // the ConnectivityManager.requestNetwork() call will fail if the properly is not declared.
+ runDeviceTests(TEST_APP_PKG,
+ TEST_APP_PKG + TEST_CLASS_NAME,
+ LACKING_SELF_DECLARED_CAPABILITIES_METHOD);
+ runDeviceTests(TEST_APP_PKG,
+ TEST_APP_PKG + TEST_CLASS_NAME,
+ WITHOUT_REQUEST_CAPABILITIES_METHOD);
+ uninstallPackage(TEST_APP_PKG, true);
+ }
+
+ public void testRequestNetworkInSdk33() throws Exception {
+ uninstallPackage(TEST_APP_PKG, false);
+ installPackage(TEST_IN_SDK_33_APK);
+ // In Sdk33, the ConnectivityManager.requestNetwork() call should always pass.
+ runDeviceTests(TEST_APP_PKG,
+ TEST_APP_PKG + TEST_CLASS_NAME,
+ WITH_SELF_DECLARED_CAPABILITIES_METHOD);
+ runDeviceTests(TEST_APP_PKG,
+ TEST_APP_PKG + TEST_CLASS_NAME,
+ WITHOUT_REQUEST_CAPABILITIES_METHOD);
+ uninstallPackage(TEST_APP_PKG, true);
+ }
+
+ public void testReinstallPackageWillUpdateProperty() throws Exception {
+ uninstallPackage(TEST_APP_PKG, false);
+ installPackage(TEST_WITHOUT_PROPERTY_IN_CURRENT_SDK_APK);
+ runDeviceTests(TEST_APP_PKG,
+ TEST_APP_PKG + TEST_CLASS_NAME,
+ LACKING_SELF_DECLARED_CAPABILITIES_METHOD);
+ uninstallPackage(TEST_APP_PKG, true);
+
+
+ // Updates package.
+ installPackage(TEST_WITH_PROPERTY_IN_CURRENT_SDK_APK);
+ runDeviceTests(TEST_APP_PKG,
+ TEST_APP_PKG + TEST_CLASS_NAME,
+ WITH_SELF_DECLARED_CAPABILITIES_METHOD);
+ uninstallPackage(TEST_APP_PKG, true);
+
+ }
+}
+
diff --git a/tests/cts/net/Android.bp b/tests/cts/net/Android.bp
index 23cb15c..f9fe5b0 100644
--- a/tests/cts/net/Android.bp
+++ b/tests/cts/net/Android.bp
@@ -114,34 +114,39 @@
],
}
-android_test {
- name: "CtsNetTestCasesMaxTargetSdk31", // Must match CtsNetTestCasesMaxTargetSdk31 annotation.
+java_defaults {
+ name: "CtsNetTestCasesMaxTargetSdkDefaults",
defaults: [
"CtsNetTestCasesDefaults",
"CtsNetTestCasesApiStableDefaults",
],
- target_sdk_version: "31",
- package_name: "android.net.cts.maxtargetsdk31", // CTS package names must be unique.
- instrumentation_target_package: "android.net.cts.maxtargetsdk31",
test_suites: [
"cts",
"general-tests",
- "mts-networking",
+ "mts-tethering",
],
}
android_test {
+ name: "CtsNetTestCasesMaxTargetSdk33", // Must match CtsNetTestCasesMaxTargetSdk33 annotation.
+ defaults: ["CtsNetTestCasesMaxTargetSdkDefaults"],
+ target_sdk_version: "33",
+ package_name: "android.net.cts.maxtargetsdk33",
+ instrumentation_target_package: "android.net.cts.maxtargetsdk33",
+}
+
+android_test {
+ name: "CtsNetTestCasesMaxTargetSdk31", // Must match CtsNetTestCasesMaxTargetSdk31 annotation.
+ defaults: ["CtsNetTestCasesMaxTargetSdkDefaults"],
+ target_sdk_version: "31",
+ package_name: "android.net.cts.maxtargetsdk31", // CTS package names must be unique.
+ instrumentation_target_package: "android.net.cts.maxtargetsdk31",
+}
+
+android_test {
name: "CtsNetTestCasesMaxTargetSdk30", // Must match CtsNetTestCasesMaxTargetSdk30 annotation.
- defaults: [
- "CtsNetTestCasesDefaults",
- "CtsNetTestCasesApiStableDefaults",
- ],
+ defaults: ["CtsNetTestCasesMaxTargetSdkDefaults"],
target_sdk_version: "30",
package_name: "android.net.cts.maxtargetsdk30", // CTS package names must be unique.
instrumentation_target_package: "android.net.cts.maxtargetsdk30",
- test_suites: [
- "cts",
- "general-tests",
- "mts-networking",
- ],
}
diff --git a/tests/cts/net/AndroidManifest.xml b/tests/cts/net/AndroidManifest.xml
index 25490da..999614c 100644
--- a/tests/cts/net/AndroidManifest.xml
+++ b/tests/cts/net/AndroidManifest.xml
@@ -54,8 +54,6 @@
<instrumentation android:name="androidx.test.runner.AndroidJUnitRunner"
android:targetPackage="android.net.cts"
android:label="CTS tests of android.net">
- <meta-data android:name="listener"
- android:value="com.android.cts.runner.CtsTestRunListener" />
</instrumentation>
</manifest>
diff --git a/tests/cts/net/api23Test/AndroidManifest.xml b/tests/cts/net/api23Test/AndroidManifest.xml
index 69ee0dd..44c63f6 100644
--- a/tests/cts/net/api23Test/AndroidManifest.xml
+++ b/tests/cts/net/api23Test/AndroidManifest.xml
@@ -39,7 +39,5 @@
<instrumentation android:name="androidx.test.runner.AndroidJUnitRunner"
android:targetPackage="android.net.cts.api23test"
android:label="CTS tests of android.net">
- <meta-data android:name="listener"
- android:value="com.android.cts.runner.CtsTestRunListener"/>
</instrumentation>
</manifest>
diff --git a/tests/cts/net/src/android/net/cts/ConnectivityManagerTest.java b/tests/cts/net/src/android/net/cts/ConnectivityManagerTest.java
index ccba983..7985dc4 100644
--- a/tests/cts/net/src/android/net/cts/ConnectivityManagerTest.java
+++ b/tests/cts/net/src/android/net/cts/ConnectivityManagerTest.java
@@ -2385,9 +2385,10 @@
}
public void eventuallyExpectBlockedStatusCallback(Network network, int blockedStatus) {
super.eventuallyExpect(CallbackEntry.BLOCKED_STATUS_INT, NETWORK_CALLBACK_TIMEOUT_MS,
- (it) -> it.getNetwork().equals(network) && it.getBlocked() == blockedStatus);
+ (it) -> it.getNetwork().equals(network) && it.getReason() == blockedStatus);
}
public void onBlockedStatusChanged(Network network, int blockedReasons) {
+ Log.v(TAG, "onBlockedStatusChanged " + network + " " + blockedReasons);
getHistory().add(new CallbackEntry.BlockedStatusInt(network, blockedReasons));
}
private void assertNoBlockedStatusCallback() {
@@ -2408,7 +2409,11 @@
}
}
- private void doTestBlockedStatusCallback() throws Exception {
+ @Test
+ public void testBlockedStatusCallback() throws Exception {
+ // Cannot use @IgnoreUpTo(Build.VERSION_CODES.R) because this test also requires API 31
+ // shims, and @IgnoreUpTo does not check that.
+ assumeTrue(TestUtils.shouldTestSApis());
// The test will need a stable active network that is persistent during the test.
// Try to connect to a wifi network and wait for it becomes the default network before
// starting the test to prevent from sudden active network change caused by previous
@@ -2426,7 +2431,8 @@
final Handler handler = new Handler(Looper.getMainLooper());
registerDefaultNetworkCallback(myUidCallback, handler);
- registerDefaultNetworkCallbackForUid(otherUid, otherUidCallback, handler);
+ runWithShellPermissionIdentity(() -> registerDefaultNetworkCallbackForUid(
+ otherUid, otherUidCallback, handler), NETWORK_SETTINGS);
final Network defaultNetwork = mCm.getActiveNetwork();
final List<DetailedBlockedStatusCallback> allCallbacks =
@@ -2438,23 +2444,27 @@
final Range<Integer> myUidRange = new Range<>(myUid, myUid);
final Range<Integer> otherUidRange = new Range<>(otherUid, otherUid);
- setRequireVpnForUids(true, List.of(myUidRange));
+ runWithShellPermissionIdentity(() -> setRequireVpnForUids(
+ true, List.of(myUidRange)), NETWORK_SETTINGS);
myUidCallback.eventuallyExpectBlockedStatusCallback(defaultNetwork,
BLOCKED_REASON_LOCKDOWN_VPN);
otherUidCallback.assertNoBlockedStatusCallback();
- setRequireVpnForUids(true, List.of(myUidRange, otherUidRange));
+ runWithShellPermissionIdentity(() -> setRequireVpnForUids(
+ true, List.of(myUidRange, otherUidRange)), NETWORK_SETTINGS);
myUidCallback.assertNoBlockedStatusCallback();
otherUidCallback.eventuallyExpectBlockedStatusCallback(defaultNetwork,
BLOCKED_REASON_LOCKDOWN_VPN);
// setRequireVpnForUids does no deduplication or refcounting. Removing myUidRange does not
// unblock myUid because it was added to the blocked ranges twice.
- setRequireVpnForUids(false, List.of(myUidRange));
+ runWithShellPermissionIdentity(() ->
+ setRequireVpnForUids(false, List.of(myUidRange)), NETWORK_SETTINGS);
myUidCallback.assertNoBlockedStatusCallback();
otherUidCallback.assertNoBlockedStatusCallback();
- setRequireVpnForUids(false, List.of(myUidRange, otherUidRange));
+ runWithShellPermissionIdentity(() -> setRequireVpnForUids(
+ false, List.of(myUidRange, otherUidRange)), NETWORK_SETTINGS);
myUidCallback.eventuallyExpectBlockedStatusCallback(defaultNetwork, BLOCKED_REASON_NONE);
otherUidCallback.eventuallyExpectBlockedStatusCallback(defaultNetwork, BLOCKED_REASON_NONE);
@@ -2463,14 +2473,6 @@
}
@Test
- public void testBlockedStatusCallback() {
- // Cannot use @IgnoreUpTo(Build.VERSION_CODES.R) because this test also requires API 31
- // shims, and @IgnoreUpTo does not check that.
- assumeTrue(TestUtils.shouldTestSApis());
- runWithShellPermissionIdentity(() -> doTestBlockedStatusCallback(), NETWORK_SETTINGS);
- }
-
- @Test
public void testSetVpnDefaultForUids() {
assumeTrue(TestUtils.shouldTestUApis());
final String session = UUID.randomUUID().toString();
@@ -3372,7 +3374,7 @@
}
private void checkFirewallBlocking(final DatagramSocket srcSock, final DatagramSocket dstSock,
- final boolean expectBlock) throws Exception {
+ final boolean expectBlock, final int chain) throws Exception {
final Random random = new Random();
final byte[] sendData = new byte[100];
random.nextBytes(sendData);
@@ -3385,11 +3387,17 @@
if (expectBlock) {
return;
}
- fail("Expect not to be blocked by firewall but sending packet was blocked");
+ fail("Expect not to be blocked by firewall but sending packet was blocked:"
+ + " chain=" + chain
+ + " chainEnabled=" + mCm.getFirewallChainEnabled(chain)
+ + " uidFirewallRule=" + mCm.getUidFirewallRule(chain, Process.myUid()));
}
if (expectBlock) {
- fail("Expect to be blocked by firewall but sending packet was not blocked");
+ fail("Expect to be blocked by firewall but sending packet was not blocked:"
+ + " chain=" + chain
+ + " chainEnabled=" + mCm.getFirewallChainEnabled(chain)
+ + " uidFirewallRule=" + mCm.getUidFirewallRule(chain, Process.myUid()));
}
dstSock.receive(pkt);
@@ -3409,34 +3417,40 @@
runWithShellPermissionIdentity(() -> {
// Firewall chain status will be restored after the test.
final boolean wasChainEnabled = mCm.getFirewallChainEnabled(chain);
+ final int previousUidFirewallRule = mCm.getUidFirewallRule(chain, myUid);
final DatagramSocket srcSock = new DatagramSocket();
final DatagramSocket dstSock = new DatagramSocket();
testAndCleanup(() -> {
if (wasChainEnabled) {
mCm.setFirewallChainEnabled(chain, false /* enable */);
}
+ if (previousUidFirewallRule == ruleToAddMatch) {
+ mCm.setUidFirewallRule(chain, myUid, ruleToRemoveMatch);
+ }
dstSock.setSoTimeout(SOCKET_TIMEOUT_MS);
// Chain disabled, UID not on chain.
- checkFirewallBlocking(srcSock, dstSock, EXPECT_PASS);
+ checkFirewallBlocking(srcSock, dstSock, EXPECT_PASS, chain);
// Chain enabled, UID not on chain.
mCm.setFirewallChainEnabled(chain, true /* enable */);
assertTrue(mCm.getFirewallChainEnabled(chain));
- checkFirewallBlocking(srcSock, dstSock, isAllowList ? EXPECT_BLOCK : EXPECT_PASS);
+ checkFirewallBlocking(
+ srcSock, dstSock, isAllowList ? EXPECT_BLOCK : EXPECT_PASS, chain);
// Chain enabled, UID on chain.
mCm.setUidFirewallRule(chain, myUid, ruleToAddMatch);
- checkFirewallBlocking(srcSock, dstSock, isAllowList ? EXPECT_PASS : EXPECT_BLOCK);
+ checkFirewallBlocking(
+ srcSock, dstSock, isAllowList ? EXPECT_PASS : EXPECT_BLOCK, chain);
// Chain disabled, UID on chain.
mCm.setFirewallChainEnabled(chain, false /* enable */);
assertFalse(mCm.getFirewallChainEnabled(chain));
- checkFirewallBlocking(srcSock, dstSock, EXPECT_PASS);
+ checkFirewallBlocking(srcSock, dstSock, EXPECT_PASS, chain);
// Chain disabled, UID not on chain.
mCm.setUidFirewallRule(chain, myUid, ruleToRemoveMatch);
- checkFirewallBlocking(srcSock, dstSock, EXPECT_PASS);
+ checkFirewallBlocking(srcSock, dstSock, EXPECT_PASS, chain);
}, /* cleanup */ () -> {
srcSock.close();
dstSock.close();
@@ -3444,8 +3458,9 @@
// Restore the global chain status
mCm.setFirewallChainEnabled(chain, wasChainEnabled);
}, /* cleanup */ () -> {
+ // Restore the uid firewall rule status
try {
- mCm.setUidFirewallRule(chain, myUid, ruleToRemoveMatch);
+ mCm.setUidFirewallRule(chain, myUid, previousUidFirewallRule);
} catch (IllegalStateException ignored) {
// Removing match causes an exception when the rule entry for the uid does
// not exist. But this is fine and can be ignored.
diff --git a/tests/cts/net/src/android/net/cts/IpSecManagerTest.java b/tests/cts/net/src/android/net/cts/IpSecManagerTest.java
index 8234ec1..9c30811 100644
--- a/tests/cts/net/src/android/net/cts/IpSecManagerTest.java
+++ b/tests/cts/net/src/android/net/cts/IpSecManagerTest.java
@@ -16,6 +16,7 @@
package android.net.cts;
+import static android.Manifest.permission.NETWORK_SETTINGS;
import static android.net.IpSecAlgorithm.AUTH_AES_CMAC;
import static android.net.IpSecAlgorithm.AUTH_AES_XCBC;
import static android.net.IpSecAlgorithm.AUTH_CRYPT_AES_GCM;
@@ -52,7 +53,9 @@
import static com.android.compatibility.common.util.PropertyUtil.getFirstApiLevel;
import static com.android.compatibility.common.util.PropertyUtil.getVendorApiLevel;
+import static com.android.testutils.DeviceInfoUtils.isKernelVersionAtLeast;
import static com.android.testutils.MiscAsserts.assertThrows;
+import static com.android.testutils.TestPermissionUtil.runAsShell;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
@@ -62,6 +65,8 @@
import android.net.IpSecAlgorithm;
import android.net.IpSecManager;
+import android.net.IpSecManager.SecurityParameterIndex;
+import android.net.IpSecManager.UdpEncapsulationSocket;
import android.net.IpSecTransform;
import android.net.TrafficStats;
import android.os.Build;
@@ -73,6 +78,7 @@
import androidx.test.InstrumentationRegistry;
import androidx.test.runner.AndroidJUnit4;
+import com.android.modules.utils.build.SdkLevel;
import com.android.testutils.DevSdkIgnoreRule;
import com.android.testutils.DevSdkIgnoreRule.IgnoreUpTo;
@@ -120,7 +126,7 @@
@Test
public void testAllocSpi() throws Exception {
for (InetAddress addr : GOOGLE_DNS_LIST) {
- IpSecManager.SecurityParameterIndex randomSpi = null, droidSpi = null;
+ SecurityParameterIndex randomSpi, droidSpi;
randomSpi = mISM.allocateSecurityParameterIndex(addr);
assertTrue(
"Failed to receive a valid SPI",
@@ -258,6 +264,24 @@
accepted.close();
}
+ private IpSecTransform buildTransportModeTransform(
+ SecurityParameterIndex spi, InetAddress localAddr,
+ UdpEncapsulationSocket encapSocket)
+ throws Exception {
+ final IpSecTransform.Builder builder =
+ new IpSecTransform.Builder(InstrumentationRegistry.getContext())
+ .setEncryption(new IpSecAlgorithm(IpSecAlgorithm.CRYPT_AES_CBC, CRYPT_KEY))
+ .setAuthentication(
+ new IpSecAlgorithm(
+ IpSecAlgorithm.AUTH_HMAC_SHA256,
+ AUTH_KEY,
+ AUTH_KEY.length * 8));
+ if (encapSocket != null) {
+ builder.setIpv4Encapsulation(encapSocket, encapSocket.getPort());
+ }
+ return builder.buildTransportModeTransform(localAddr, spi);
+ }
+
/*
* Alloc outbound SPI
* Alloc inbound SPI
@@ -268,21 +292,8 @@
* release transform
* send data (expect exception)
*/
- @Test
- public void testCreateTransform() throws Exception {
- InetAddress localAddr = InetAddress.getByName(IPV4_LOOPBACK);
- IpSecManager.SecurityParameterIndex spi =
- mISM.allocateSecurityParameterIndex(localAddr);
-
- IpSecTransform transform =
- new IpSecTransform.Builder(InstrumentationRegistry.getContext())
- .setEncryption(new IpSecAlgorithm(IpSecAlgorithm.CRYPT_AES_CBC, CRYPT_KEY))
- .setAuthentication(
- new IpSecAlgorithm(
- IpSecAlgorithm.AUTH_HMAC_SHA256,
- AUTH_KEY,
- AUTH_KEY.length * 8))
- .buildTransportModeTransform(localAddr, spi);
+ private void doTestCreateTransform(String loopbackAddrString, boolean encap) throws Exception {
+ InetAddress localAddr = InetAddress.getByName(loopbackAddrString);
final boolean [][] applyInApplyOut = {
{false, false}, {false, true}, {true, false}, {true,true}};
@@ -291,57 +302,100 @@
byte[] in = new byte[data.length];
DatagramPacket inPacket = new DatagramPacket(in, in.length);
- DatagramSocket localSocket;
int localPort;
for(boolean[] io : applyInApplyOut) {
boolean applyIn = io[0];
boolean applyOut = io[1];
- // Bind localSocket to a random available port.
- localSocket = new DatagramSocket(0);
- localPort = localSocket.getLocalPort();
- localSocket.setSoTimeout(200);
- outPacket.setPort(localPort);
- if (applyIn) {
- mISM.applyTransportModeTransform(
- localSocket, IpSecManager.DIRECTION_IN, transform);
- }
- if (applyOut) {
- mISM.applyTransportModeTransform(
- localSocket, IpSecManager.DIRECTION_OUT, transform);
- }
- if (applyIn == applyOut) {
- localSocket.send(outPacket);
- localSocket.receive(inPacket);
- assertTrue("Encapsulated data did not match.",
- Arrays.equals(outPacket.getData(), inPacket.getData()));
- mISM.removeTransportModeTransforms(localSocket);
- localSocket.close();
- } else {
- try {
+ try (
+ SecurityParameterIndex spi = mISM.allocateSecurityParameterIndex(localAddr);
+ UdpEncapsulationSocket encapSocket = encap
+ ? getPrivilegedUdpEncapSocket(/*ipv6=*/ localAddr instanceof Inet6Address)
+ : null;
+ IpSecTransform transform = buildTransportModeTransform(spi, localAddr,
+ encapSocket);
+ // Bind localSocket to a random available port.
+ DatagramSocket localSocket = new DatagramSocket(0);
+ ) {
+ localPort = localSocket.getLocalPort();
+ localSocket.setSoTimeout(200);
+ outPacket.setPort(localPort);
+ if (applyIn) {
+ mISM.applyTransportModeTransform(
+ localSocket, IpSecManager.DIRECTION_IN, transform);
+ }
+ if (applyOut) {
+ mISM.applyTransportModeTransform(
+ localSocket, IpSecManager.DIRECTION_OUT, transform);
+ }
+ if (applyIn == applyOut) {
localSocket.send(outPacket);
localSocket.receive(inPacket);
- } catch (IOException e) {
- continue;
- } finally {
+ assertTrue("Encrypted data did not match.",
+ Arrays.equals(outPacket.getData(), inPacket.getData()));
mISM.removeTransportModeTransforms(localSocket);
- localSocket.close();
+ } else {
+ try {
+ localSocket.send(outPacket);
+ localSocket.receive(inPacket);
+ } catch (IOException e) {
+ continue;
+ } finally {
+ mISM.removeTransportModeTransforms(localSocket);
+ }
+ // FIXME: This check is disabled because sockets currently receive data
+ // if there is a valid SA for decryption, even when the input policy is
+ // not applied to a socket.
+ // fail("Data IO should fail on asymmetrical transforms! + Input="
+ // + applyIn + " Output=" + applyOut);
}
- // FIXME: This check is disabled because sockets currently receive data
- // if there is a valid SA for decryption, even when the input policy is
- // not applied to a socket.
- // fail("Data IO should fail on asymmetrical transforms! + Input="
- // + applyIn + " Output=" + applyOut);
}
}
- transform.close();
+ }
+
+ private UdpEncapsulationSocket getPrivilegedUdpEncapSocket(boolean ipv6) throws Exception {
+ return runAsShell(NETWORK_SETTINGS, () -> {
+ if (ipv6) {
+ return mISM.openUdpEncapsulationSocket(65536);
+ } else {
+ // Can't pass 0 to IpSecManager#openUdpEncapsulationSocket(int).
+ return mISM.openUdpEncapsulationSocket();
+ }
+ });
+ }
+
+ private void assumeExperimentalIpv6UdpEncapSupported() throws Exception {
+ assumeTrue("Not supported before U", SdkLevel.isAtLeastU());
+ assumeTrue("Not supported by kernel", isKernelVersionAtLeast("5.15.31")
+ || (isKernelVersionAtLeast("5.10.108") && !isKernelVersionAtLeast("5.15.0")));
+ }
+
+ @Test
+ public void testCreateTransformIpv4() throws Exception {
+ doTestCreateTransform(IPV4_LOOPBACK, false);
+ }
+
+ @Test
+ public void testCreateTransformIpv6() throws Exception {
+ doTestCreateTransform(IPV6_LOOPBACK, false);
+ }
+
+ @Test
+ public void testCreateTransformIpv4Encap() throws Exception {
+ doTestCreateTransform(IPV4_LOOPBACK, true);
+ }
+
+ @Test
+ public void testCreateTransformIpv6Encap() throws Exception {
+ assumeExperimentalIpv6UdpEncapSupported();
+ doTestCreateTransform(IPV6_LOOPBACK, true);
}
/** Snapshot of TrafficStats as of initStatsChecker call for later comparisons */
private static class StatsChecker {
private static final double ERROR_MARGIN_BYTES = 1.05;
private static final double ERROR_MARGIN_PKTS = 1.05;
- private static final int MAX_WAIT_TIME_MILLIS = 1000;
+ private static final int MAX_WAIT_TIME_MILLIS = 3000;
private static long uidTxBytes;
private static long uidRxBytes;
@@ -503,8 +557,8 @@
StatsChecker.initStatsChecker();
InetAddress local = InetAddress.getByName(localAddress);
- try (IpSecManager.UdpEncapsulationSocket encapSocket = mISM.openUdpEncapsulationSocket();
- IpSecManager.SecurityParameterIndex spi =
+ try (UdpEncapsulationSocket encapSocket = mISM.openUdpEncapsulationSocket();
+ SecurityParameterIndex spi =
mISM.allocateSecurityParameterIndex(local)) {
IpSecTransform.Builder transformBuilder =
@@ -656,7 +710,7 @@
public void testIkeOverUdpEncapSocket() throws Exception {
// IPv6 not supported for UDP-encap-ESP
InetAddress local = InetAddress.getByName(IPV4_LOOPBACK);
- try (IpSecManager.UdpEncapsulationSocket encapSocket = mISM.openUdpEncapsulationSocket()) {
+ try (UdpEncapsulationSocket encapSocket = mISM.openUdpEncapsulationSocket()) {
NativeUdpSocket wrappedEncapSocket =
new NativeUdpSocket(encapSocket.getFileDescriptor());
checkIkePacket(wrappedEncapSocket, local);
@@ -665,7 +719,7 @@
IpSecAlgorithm crypt = new IpSecAlgorithm(IpSecAlgorithm.CRYPT_AES_CBC, CRYPT_KEY);
IpSecAlgorithm auth = new IpSecAlgorithm(IpSecAlgorithm.AUTH_HMAC_MD5, getKey(128), 96);
- try (IpSecManager.SecurityParameterIndex spi =
+ try (SecurityParameterIndex spi =
mISM.allocateSecurityParameterIndex(local);
IpSecTransform transform =
new IpSecTransform.Builder(InstrumentationRegistry.getContext())
@@ -1498,7 +1552,7 @@
@Test
public void testOpenUdpEncapSocketSpecificPort() throws Exception {
- IpSecManager.UdpEncapsulationSocket encapSocket = null;
+ UdpEncapsulationSocket encapSocket = null;
int port = -1;
for (int i = 0; i < MAX_PORT_BIND_ATTEMPTS; i++) {
try {
@@ -1527,7 +1581,7 @@
@Test
public void testOpenUdpEncapSocketRandomPort() throws Exception {
- try (IpSecManager.UdpEncapsulationSocket encapSocket = mISM.openUdpEncapsulationSocket()) {
+ try (UdpEncapsulationSocket encapSocket = mISM.openUdpEncapsulationSocket()) {
assertTrue("Returned invalid port", encapSocket.getPort() != 0);
}
}
diff --git a/tests/cts/net/src/android/net/cts/NetworkAgentTest.kt b/tests/cts/net/src/android/net/cts/NetworkAgentTest.kt
index 7ae4688..f578ff3 100644
--- a/tests/cts/net/src/android/net/cts/NetworkAgentTest.kt
+++ b/tests/cts/net/src/android/net/cts/NetworkAgentTest.kt
@@ -506,9 +506,7 @@
val lp = LinkProperties(agent.lp)
lp.setInterfaceName(ifaceName)
agent.sendLinkProperties(lp)
- callback.expectLinkPropertiesThat(agent.network!!) {
- it.getInterfaceName() == ifaceName
- }
+ callback.expect<LinkPropertiesChanged>(agent.network!!) { it.lp.interfaceName == ifaceName }
val nc = NetworkCapabilities(agent.nc)
nc.addCapability(NET_CAPABILITY_NOT_METERED)
agent.sendNetworkCapabilities(nc)
diff --git a/tests/cts/net/src/android/net/cts/NsdManagerTest.kt b/tests/cts/net/src/android/net/cts/NsdManagerTest.kt
index 9b27df5..de5e46f 100644
--- a/tests/cts/net/src/android/net/cts/NsdManagerTest.kt
+++ b/tests/cts/net/src/android/net/cts/NsdManagerTest.kt
@@ -20,6 +20,8 @@
import android.net.ConnectivityManager
import android.net.ConnectivityManager.NetworkCallback
import android.net.LinkProperties
+import android.net.LocalSocket
+import android.net.LocalSocketAddress
import android.net.Network
import android.net.NetworkAgentConfig
import android.net.NetworkCapabilities
@@ -30,6 +32,7 @@
import android.net.TestNetworkInterface
import android.net.TestNetworkManager
import android.net.TestNetworkSpecifier
+import android.net.connectivity.ConnectivityCompatChanges
import android.net.cts.NsdManagerTest.NsdDiscoveryRecord.DiscoveryEvent.DiscoveryStarted
import android.net.cts.NsdManagerTest.NsdDiscoveryRecord.DiscoveryEvent.DiscoveryStopped
import android.net.cts.NsdManagerTest.NsdDiscoveryRecord.DiscoveryEvent.ServiceFound
@@ -40,8 +43,8 @@
import android.net.cts.NsdManagerTest.NsdRegistrationRecord.RegistrationEvent.ServiceRegistered
import android.net.cts.NsdManagerTest.NsdRegistrationRecord.RegistrationEvent.ServiceUnregistered
import android.net.cts.NsdManagerTest.NsdRegistrationRecord.RegistrationEvent.UnregistrationFailed
-import android.net.cts.NsdManagerTest.NsdResolveRecord.ResolveEvent.ResolveFailed
import android.net.cts.NsdManagerTest.NsdResolveRecord.ResolveEvent.ResolutionStopped
+import android.net.cts.NsdManagerTest.NsdResolveRecord.ResolveEvent.ResolveFailed
import android.net.cts.NsdManagerTest.NsdResolveRecord.ResolveEvent.ServiceResolved
import android.net.cts.NsdManagerTest.NsdResolveRecord.ResolveEvent.StopResolutionFailed
import android.net.cts.NsdManagerTest.NsdServiceInfoCallbackRecord.ServiceInfoCallbackEvent.RegisterCallbackFailed
@@ -62,6 +65,8 @@
import android.util.Log
import androidx.test.platform.app.InstrumentationRegistry
import androidx.test.runner.AndroidJUnit4
+import com.android.compatibility.common.util.PollingCheck
+import com.android.compatibility.common.util.PropertyUtil
import com.android.net.module.util.ArrayTrackRecord
import com.android.net.module.util.TrackRecord
import com.android.networkstack.apishim.NsdShimImpl
@@ -71,14 +76,17 @@
import com.android.testutils.TestableNetworkAgent
import com.android.testutils.TestableNetworkCallback
import com.android.testutils.filters.CtsNetTestCasesMaxTargetSdk30
+import com.android.testutils.filters.CtsNetTestCasesMaxTargetSdk33
import com.android.testutils.runAsShell
import com.android.testutils.tryTest
import com.android.testutils.waitForIdle
import java.io.File
+import java.io.IOException
import java.net.ServerSocket
import java.nio.charset.StandardCharsets
import java.util.Random
import java.util.concurrent.Executor
+import kotlin.math.min
import kotlin.test.assertEquals
import kotlin.test.assertFailsWith
import kotlin.test.assertNotNull
@@ -762,6 +770,69 @@
}
}
+ private fun checkConnectSocketToMdnsd(shouldFail: Boolean) {
+ val discoveryRecord = NsdDiscoveryRecord()
+ val localSocket = LocalSocket()
+ tryTest {
+ // Discover any service from NsdManager to enforce NsdService to start the mdnsd.
+ nsdManager.discoverServices(serviceType, NsdManager.PROTOCOL_DNS_SD, discoveryRecord)
+ discoveryRecord.expectCallback<DiscoveryStarted>()
+
+ // Checks the /dev/socket/mdnsd is created.
+ val socket = File("/dev/socket/mdnsd")
+ val doesSocketExist = PollingCheck.waitFor(
+ TIMEOUT_MS,
+ {
+ socket.exists()
+ },
+ { doesSocketExist ->
+ doesSocketExist
+ },
+ )
+
+ // If the socket is not created, then no need to check the access.
+ if (doesSocketExist) {
+ // Create a LocalSocket and try to connect to mdnsd.
+ assertFalse("LocalSocket is connected.", localSocket.isConnected)
+ val address = LocalSocketAddress("mdnsd", LocalSocketAddress.Namespace.RESERVED)
+ if (shouldFail) {
+ assertFailsWith<IOException>("Expect fail but socket connected") {
+ localSocket.connect(address)
+ }
+ } else {
+ localSocket.connect(address)
+ assertTrue("LocalSocket is not connected.", localSocket.isConnected)
+ }
+ }
+ } cleanup {
+ localSocket.close()
+ nsdManager.stopServiceDiscovery(discoveryRecord)
+ discoveryRecord.expectCallback<DiscoveryStopped>()
+ }
+ }
+
+ /**
+ * Starting from Android U, the access to the /dev/socket/mdnsd is blocked by the
+ * sepolicy(b/265364111).
+ */
+ @DevSdkIgnoreRule.IgnoreUpTo(Build.VERSION_CODES.TIRAMISU)
+ @Test
+ fun testCannotConnectSocketToMdnsd() {
+ val targetSdkVersion = context.packageManager
+ .getTargetSdkVersion(context.applicationInfo.packageName)
+ assumeTrue(targetSdkVersion > Build.VERSION_CODES.TIRAMISU)
+ val firstApiLevel = min(PropertyUtil.getFirstApiLevel(), PropertyUtil.getVendorApiLevel())
+ // The sepolicy is implemented in the vendor image, so the access may not be blocked if
+ // the vendor image is not update to date.
+ assumeTrue(firstApiLevel > Build.VERSION_CODES.TIRAMISU)
+ checkConnectSocketToMdnsd(shouldFail = true)
+ }
+
+ @Test @CtsNetTestCasesMaxTargetSdk33("mdnsd socket is accessible up to target SDK 33")
+ fun testCanConnectSocketToMdnsd() {
+ checkConnectSocketToMdnsd(shouldFail = false)
+ }
+
@Test @CtsNetTestCasesMaxTargetSdk30("Socket is started with the service up to target SDK 30")
fun testManagerCreatesLegacySocket() {
nsdManager // Ensure the lazy-init member is initialized, so NsdManager is created
@@ -783,7 +854,7 @@
// when the compat change is disabled.
// Note that before T the compat constant had a different int value.
assertFalse(CompatChanges.isChangeEnabled(
- NsdManager.RUN_NATIVE_NSD_ONLY_IF_LEGACY_APPS_T_AND_LATER))
+ ConnectivityCompatChanges.RUN_NATIVE_NSD_ONLY_IF_LEGACY_APPS_T_AND_LATER))
}
@Test
diff --git a/tests/cts/net/util/java/android/net/cts/util/IkeSessionTestUtils.java b/tests/cts/net/util/java/android/net/cts/util/IkeSessionTestUtils.java
index 11eb466..25534b8 100644
--- a/tests/cts/net/util/java/android/net/cts/util/IkeSessionTestUtils.java
+++ b/tests/cts/net/util/java/android/net/cts/util/IkeSessionTestUtils.java
@@ -42,8 +42,9 @@
public class IkeSessionTestUtils {
private static final String TEST_SERVER_ADDR_V4 = "192.0.2.2";
private static final String TEST_SERVER_ADDR_V6 = "2001:db8::2";
- private static final String TEST_IDENTITY = "client.cts.android.com";
+ public static final String TEST_IDENTITY = "client.cts.android.com";
private static final byte[] TEST_PSK = "ikeAndroidPsk".getBytes();
+ public static final int TEST_KEEPALIVE_TIMEOUT_UNSET = -1;
public static final IkeSessionParams IKE_PARAMS_V4 = getTestIkeSessionParams(false);
public static final IkeSessionParams IKE_PARAMS_V6 = getTestIkeSessionParams(true);
@@ -63,17 +64,26 @@
public static IkeSessionParams getTestIkeSessionParams(boolean testIpv6,
IkeIdentification identification) {
+ return getTestIkeSessionParams(testIpv6, identification, TEST_KEEPALIVE_TIMEOUT_UNSET);
+ }
+
+ public static IkeSessionParams getTestIkeSessionParams(boolean testIpv6,
+ IkeIdentification identification, int keepaliveTimer) {
final String testServer = testIpv6 ? TEST_SERVER_ADDR_V6 : TEST_SERVER_ADDR_V4;
final InetAddress addr = InetAddresses.parseNumericAddress(testServer);
final IkeSessionParams.Builder ikeOptionsBuilder =
new IkeSessionParams.Builder()
.setServerHostname(testServer)
- .setLocalIdentification(new IkeFqdnIdentification(TEST_IDENTITY))
+ .setLocalIdentification(identification)
.setRemoteIdentification(testIpv6
? new IkeIpv6AddrIdentification((Inet6Address) addr)
: new IkeIpv4AddrIdentification((Inet4Address) addr))
.setAuthPsk(TEST_PSK)
+
.addSaProposal(getIkeSaProposals());
+ if (keepaliveTimer != TEST_KEEPALIVE_TIMEOUT_UNSET) {
+ ikeOptionsBuilder.setNattKeepAliveDelaySeconds(keepaliveTimer);
+ }
return ikeOptionsBuilder.build();
}
diff --git a/tests/cts/netpermission/internetpermission/AndroidManifest.xml b/tests/cts/netpermission/internetpermission/AndroidManifest.xml
index 45ef5bd..ae7de3f 100644
--- a/tests/cts/netpermission/internetpermission/AndroidManifest.xml
+++ b/tests/cts/netpermission/internetpermission/AndroidManifest.xml
@@ -43,8 +43,6 @@
<instrumentation android:name="androidx.test.runner.AndroidJUnitRunner"
android:targetPackage="android.networkpermission.internetpermission.cts"
android:label="CTS tests for INTERNET permissions">
- <meta-data android:name="listener"
- android:value="com.android.cts.runner.CtsTestRunListener"/>
</instrumentation>
</manifest>
diff --git a/tests/cts/netpermission/updatestatspermission/AndroidManifest.xml b/tests/cts/netpermission/updatestatspermission/AndroidManifest.xml
index 6babe8f..8a7e3f7 100644
--- a/tests/cts/netpermission/updatestatspermission/AndroidManifest.xml
+++ b/tests/cts/netpermission/updatestatspermission/AndroidManifest.xml
@@ -51,8 +51,6 @@
<instrumentation android:name="androidx.test.runner.AndroidJUnitRunner"
android:targetPackage="android.networkpermission.updatestatspermission.cts"
android:label="CTS tests for UPDATE_DEVICE_STATS permissions">
- <meta-data android:name="listener"
- android:value="com.android.cts.runner.CtsTestRunListener"/>
</instrumentation>
</manifest>
diff --git a/tests/cts/tethering/AndroidManifest.xml b/tests/cts/tethering/AndroidManifest.xml
index 911dbf2..bad722b 100644
--- a/tests/cts/tethering/AndroidManifest.xml
+++ b/tests/cts/tethering/AndroidManifest.xml
@@ -27,8 +27,6 @@
<instrumentation android:name="androidx.test.runner.AndroidJUnitRunner"
android:targetPackage="android.tethering.cts"
android:label="CTS tests of android.tethering">
- <meta-data android:name="listener"
- android:value="com.android.cts.runner.CtsTestRunListener" />
</instrumentation>
</manifest>
diff --git a/tests/integration/src/com/android/server/net/integrationtests/ConnectivityServiceIntegrationTest.kt b/tests/integration/src/com/android/server/net/integrationtests/ConnectivityServiceIntegrationTest.kt
index 26b058d..3c1340d 100644
--- a/tests/integration/src/com/android/server/net/integrationtests/ConnectivityServiceIntegrationTest.kt
+++ b/tests/integration/src/com/android/server/net/integrationtests/ConnectivityServiceIntegrationTest.kt
@@ -37,7 +37,6 @@
import android.net.TestNetworkStackClient
import android.net.Uri
import android.net.metrics.IpConnectivityLog
-import com.android.server.connectivity.MultinetworkPolicyTracker
import android.os.ConditionVariable
import android.os.IBinder
import android.os.SystemConfigManager
@@ -52,7 +51,9 @@
import com.android.server.NetworkAgentWrapper
import com.android.server.TestNetIdManager
import com.android.server.connectivity.MockableSystemProperties
+import com.android.server.connectivity.MultinetworkPolicyTracker
import com.android.server.connectivity.ProxyTracker
+import com.android.testutils.RecorderCallback.CallbackEntry.LinkPropertiesChanged
import com.android.testutils.TestableNetworkCallback
import org.junit.After
import org.junit.Before
@@ -73,8 +74,6 @@
import org.mockito.MockitoAnnotations
import org.mockito.Spy
import kotlin.test.assertEquals
-import kotlin.test.assertFalse
-import kotlin.test.assertNotNull
import kotlin.test.assertTrue
import kotlin.test.fail
@@ -289,15 +288,16 @@
testCb.expectAvailableCallbacks(na.network, validated = false, tmt = TEST_TIMEOUT_MS)
- val capportData = testCb.expectLinkPropertiesThat(na, TEST_TIMEOUT_MS) {
- it.captivePortalData != null
+ val capportData = testCb.expect<LinkPropertiesChanged>(na, TEST_TIMEOUT_MS) {
+ it.lp.captivePortalData != null
}.lp.captivePortalData
- assertNotNull(capportData)
assertTrue(capportData.isCaptive)
assertEquals(Uri.parse("https://login.capport.android.com"), capportData.userPortalUrl)
assertEquals(Uri.parse("https://venueinfo.capport.android.com"), capportData.venueInfoUrl)
- val nc = testCb.expectCapabilitiesWith(NET_CAPABILITY_CAPTIVE_PORTAL, na, TEST_TIMEOUT_MS)
- assertFalse(nc.hasCapability(NET_CAPABILITY_VALIDATED))
+ testCb.expectCaps(na, TEST_TIMEOUT_MS) {
+ it.hasCapability(NET_CAPABILITY_CAPTIVE_PORTAL) &&
+ !it.hasCapability(NET_CAPABILITY_VALIDATED)
+ }
}
-}
\ No newline at end of file
+}
diff --git a/tests/unit/Android.bp b/tests/unit/Android.bp
index 8db307d..36b3356 100644
--- a/tests/unit/Android.bp
+++ b/tests/unit/Android.bp
@@ -69,6 +69,7 @@
"java/com/android/server/VpnManagerServiceTest.java",
"java/com/android/server/connectivity/IpConnectivityEventBuilderTest.java",
"java/com/android/server/connectivity/IpConnectivityMetricsTest.java",
+ "java/com/android/server/connectivity/MetricsTestUtil.java",
"java/com/android/server/connectivity/MultipathPolicyTrackerTest.java",
"java/com/android/server/connectivity/NetdEventListenerServiceTest.java",
"java/com/android/server/connectivity/VpnTest.java",
@@ -136,6 +137,37 @@
visibility: ["//packages/modules/Connectivity/tests:__subpackages__"],
}
+genrule {
+ name: "frameworks-net-tests-jarjar-rules",
+ defaults: ["jarjar-rules-combine-defaults"],
+ srcs: [
+ ":frameworks-net-tests-lib-jarjar-gen",
+ // This is necessary because the tests use framework-connectivity-internal-test-defaults,
+ // which require the user to use connectivity jarjar rules.
+ ":connectivity-jarjar-rules",
+ ],
+ out: ["frameworks-net-tests-jarjar-rules.txt"],
+ visibility: ["//packages/modules/Connectivity/tests:__subpackages__"],
+}
+
+java_genrule {
+ name: "frameworks-net-tests-lib-jarjar-gen",
+ tool_files: [
+ ":FrameworksNetTestsLib{.jar}",
+ "jarjar-excludes.txt",
+ ],
+ tools: [
+ "jarjar-rules-generator",
+ ],
+ out: ["frameworks-net-tests-lib-jarjar-rules.txt"],
+ cmd: "$(location jarjar-rules-generator) " +
+ "$(location :FrameworksNetTestsLib{.jar}) " +
+ "--prefix android.net.connectivity " +
+ "--excludes $(location jarjar-excludes.txt) " +
+ "--output $(out)",
+ visibility: ["//visibility:private"],
+}
+
android_test {
name: "FrameworksNetTests",
enabled: enable_frameworks_net_tests,
@@ -143,7 +175,7 @@
"FrameworksNetTestsDefaults",
"FrameworksNetTests-jni-defaults",
],
- jarjar_rules: ":connectivity-jarjar-rules",
+ jarjar_rules: ":frameworks-net-tests-jarjar-rules",
test_suites: ["device-tests"],
static_libs: [
"services.core",
diff --git a/tests/unit/AndroidManifest.xml b/tests/unit/AndroidManifest.xml
index 5bac2dd..5d4bdf7 100644
--- a/tests/unit/AndroidManifest.xml
+++ b/tests/unit/AndroidManifest.xml
@@ -63,7 +63,7 @@
<uses-library android:name="android.test.runner" />
<uses-library android:name="android.net.ipsec.ike" />
<activity
- android:name="com.android.server.connectivity.NetworkNotificationManagerTest$TestDialogActivity"/>
+ android:name="android.net.connectivity.com.android.server.connectivity.NetworkNotificationManagerTest$TestDialogActivity"/>
</application>
<instrumentation
diff --git a/tests/unit/jarjar-excludes.txt b/tests/unit/jarjar-excludes.txt
new file mode 100644
index 0000000..d2022bf
--- /dev/null
+++ b/tests/unit/jarjar-excludes.txt
@@ -0,0 +1,27 @@
+# Exclude some test prefixes, otherwise the classes reference below can't find
+# them after jarjared.
+android\.compat\..+
+androidx\.test\..+
+com\.android\.frameworks\.tests\..+
+com\.android\.testutils\..+
+com\.android\.dx\.mockito\..+
+com\.android\.internal\.compat\..+
+com\.android\.internal\.org\.bouncycastle\..+
+kotlin\.test\..+
+kotlin\.reflect\..+
+org\.junit\..+
+org\.mockito\..+
+
+# Auto-jarjar-gen can't handle kotlin object expression, exclude the tests which use
+# object expressions.
+#
+# For example: Illegal class access:
+# 'android.net.connectivity.com.android.net.module.util.TrackRecordTest' attempting to access
+# 'com.android.networkstack.tethering.util.TRTInterpreter' (declaration of
+# 'android.net.connectivity.com.android.net.module.util.TrackRecordTest' ...
+#
+# In coverage test, TRTInterpreter don't be jarjar'ed to
+# android.net.connectivity* by frameworks-net-tests-jarjar-rules instead it is
+# jarjar'ed by follow up TetheringTestsJarJarRules.
+# TODO(b/269259216): remove this after fixing Auto-jarjar-gen.
+com\.android\.net\.module\.util\.TrackRecord.*
diff --git a/tests/unit/java/android/net/Ikev2VpnProfileTest.java b/tests/unit/java/android/net/Ikev2VpnProfileTest.java
index 3b68120..e12e961 100644
--- a/tests/unit/java/android/net/Ikev2VpnProfileTest.java
+++ b/tests/unit/java/android/net/Ikev2VpnProfileTest.java
@@ -492,6 +492,29 @@
}
@Test
+ public void testAutomaticNattAndIpVersionConversionIsLossless() throws Exception {
+ final Ikev2VpnProfile.Builder builder = getBuilderWithDefaultOptions();
+ builder.setAutomaticNattKeepaliveTimerEnabled(true);
+ builder.setAutomaticIpVersionSelectionEnabled(true);
+
+ builder.setAuthDigitalSignature(mUserCert, mPrivateKey, mServerRootCa);
+ final Ikev2VpnProfile ikeProfile = builder.build();
+
+ assertEquals(ikeProfile, Ikev2VpnProfile.fromVpnProfile(ikeProfile.toVpnProfile()));
+ }
+
+ @Test
+ public void testAutomaticNattAndIpVersionDefaults() throws Exception {
+ final Ikev2VpnProfile.Builder builder = getBuilderWithDefaultOptions();
+
+ builder.setAuthDigitalSignature(mUserCert, mPrivateKey, mServerRootCa);
+ final Ikev2VpnProfile ikeProfile = builder.build();
+
+ assertEquals(false, ikeProfile.isAutomaticNattKeepaliveTimerEnabled());
+ assertEquals(false, ikeProfile.isAutomaticIpVersionSelectionEnabled());
+ }
+
+ @Test
public void testEquals() throws Exception {
// Verify building without IkeTunnelConnectionParams
final Ikev2VpnProfile.Builder builder = getBuilderWithDefaultOptions();
diff --git a/tests/unit/java/android/net/NetworkTemplateTest.kt b/tests/unit/java/android/net/NetworkTemplateTest.kt
index 78854fb..edbcea9 100644
--- a/tests/unit/java/android/net/NetworkTemplateTest.kt
+++ b/tests/unit/java/android/net/NetworkTemplateTest.kt
@@ -443,6 +443,35 @@
}
@Test
+ fun testEquals() {
+ val templateImsi1 = NetworkTemplate.Builder(MATCH_MOBILE).setMeteredness(METERED_YES)
+ .setSubscriberIds(setOf(TEST_IMSI1)).setRatType(TelephonyManager.NETWORK_TYPE_UMTS)
+ .build()
+ val dupTemplateImsi1 = NetworkTemplate(MATCH_MOBILE, arrayOf(TEST_IMSI1),
+ emptyArray<String>(), METERED_YES, ROAMING_ALL, DEFAULT_NETWORK_ALL,
+ TelephonyManager.NETWORK_TYPE_UMTS, OEM_MANAGED_ALL)
+ val templateImsi2 = NetworkTemplate.Builder(MATCH_MOBILE).setMeteredness(METERED_YES)
+ .setSubscriberIds(setOf(TEST_IMSI2)).setRatType(TelephonyManager.NETWORK_TYPE_UMTS)
+ .build()
+
+ assertEquals(templateImsi1, dupTemplateImsi1)
+ assertEquals(dupTemplateImsi1, templateImsi1)
+ assertNotEquals(templateImsi1, templateImsi2)
+
+ val templateWifiKey1 = NetworkTemplate.Builder(MATCH_WIFI)
+ .setWifiNetworkKeys(setOf(TEST_WIFI_KEY1)).build()
+ val dupTemplateWifiKey1 = NetworkTemplate(MATCH_WIFI, emptyArray<String>(),
+ arrayOf(TEST_WIFI_KEY1), METERED_ALL, ROAMING_ALL, DEFAULT_NETWORK_ALL,
+ NETWORK_TYPE_ALL, OEM_MANAGED_ALL)
+ val templateWifiKey2 = NetworkTemplate.Builder(MATCH_WIFI)
+ .setWifiNetworkKeys(setOf(TEST_WIFI_KEY2)).build()
+
+ assertEquals(templateWifiKey1, dupTemplateWifiKey1)
+ assertEquals(dupTemplateWifiKey1, templateWifiKey1)
+ assertNotEquals(templateWifiKey1, templateWifiKey2)
+ }
+
+ @Test
fun testParcelUnparcel() {
val templateMobile = NetworkTemplate(MATCH_MOBILE, arrayOf(TEST_IMSI1),
emptyArray<String>(), METERED_ALL, ROAMING_ALL, DEFAULT_NETWORK_ALL,
diff --git a/tests/unit/java/android/net/nsd/NsdManagerTest.java b/tests/unit/java/android/net/nsd/NsdManagerTest.java
index 8a4932b..da65b62 100644
--- a/tests/unit/java/android/net/nsd/NsdManagerTest.java
+++ b/tests/unit/java/android/net/nsd/NsdManagerTest.java
@@ -32,6 +32,7 @@
import android.compat.testing.PlatformCompatChangeRule;
import android.content.Context;
+import android.net.connectivity.ConnectivityCompatChanges;
import android.os.Build;
import androidx.test.filters.SmallTest;
@@ -81,70 +82,70 @@
}
@Test
- @EnableCompatChanges(NsdManager.RUN_NATIVE_NSD_ONLY_IF_LEGACY_APPS_T_AND_LATER)
+ @EnableCompatChanges(ConnectivityCompatChanges.RUN_NATIVE_NSD_ONLY_IF_LEGACY_APPS_T_AND_LATER)
public void testResolveServiceS() throws Exception {
verify(mServiceConn, never()).startDaemon();
doTestResolveService();
}
@Test
- @DisableCompatChanges(NsdManager.RUN_NATIVE_NSD_ONLY_IF_LEGACY_APPS_T_AND_LATER)
+ @DisableCompatChanges(ConnectivityCompatChanges.RUN_NATIVE_NSD_ONLY_IF_LEGACY_APPS_T_AND_LATER)
public void testResolveServicePreS() throws Exception {
verify(mServiceConn).startDaemon();
doTestResolveService();
}
@Test
- @EnableCompatChanges(NsdManager.RUN_NATIVE_NSD_ONLY_IF_LEGACY_APPS_T_AND_LATER)
+ @EnableCompatChanges(ConnectivityCompatChanges.RUN_NATIVE_NSD_ONLY_IF_LEGACY_APPS_T_AND_LATER)
public void testDiscoverServiceS() throws Exception {
verify(mServiceConn, never()).startDaemon();
doTestDiscoverService();
}
@Test
- @DisableCompatChanges(NsdManager.RUN_NATIVE_NSD_ONLY_IF_LEGACY_APPS_T_AND_LATER)
+ @DisableCompatChanges(ConnectivityCompatChanges.RUN_NATIVE_NSD_ONLY_IF_LEGACY_APPS_T_AND_LATER)
public void testDiscoverServicePreS() throws Exception {
verify(mServiceConn).startDaemon();
doTestDiscoverService();
}
@Test
- @EnableCompatChanges(NsdManager.RUN_NATIVE_NSD_ONLY_IF_LEGACY_APPS_T_AND_LATER)
+ @EnableCompatChanges(ConnectivityCompatChanges.RUN_NATIVE_NSD_ONLY_IF_LEGACY_APPS_T_AND_LATER)
public void testParallelResolveServiceS() throws Exception {
verify(mServiceConn, never()).startDaemon();
doTestParallelResolveService();
}
@Test
- @DisableCompatChanges(NsdManager.RUN_NATIVE_NSD_ONLY_IF_LEGACY_APPS_T_AND_LATER)
+ @DisableCompatChanges(ConnectivityCompatChanges.RUN_NATIVE_NSD_ONLY_IF_LEGACY_APPS_T_AND_LATER)
public void testParallelResolveServicePreS() throws Exception {
verify(mServiceConn).startDaemon();
doTestParallelResolveService();
}
@Test
- @EnableCompatChanges(NsdManager.RUN_NATIVE_NSD_ONLY_IF_LEGACY_APPS_T_AND_LATER)
+ @EnableCompatChanges(ConnectivityCompatChanges.RUN_NATIVE_NSD_ONLY_IF_LEGACY_APPS_T_AND_LATER)
public void testInvalidCallsS() throws Exception {
verify(mServiceConn, never()).startDaemon();
doTestInvalidCalls();
}
@Test
- @DisableCompatChanges(NsdManager.RUN_NATIVE_NSD_ONLY_IF_LEGACY_APPS_T_AND_LATER)
+ @DisableCompatChanges(ConnectivityCompatChanges.RUN_NATIVE_NSD_ONLY_IF_LEGACY_APPS_T_AND_LATER)
public void testInvalidCallsPreS() throws Exception {
verify(mServiceConn).startDaemon();
doTestInvalidCalls();
}
@Test
- @EnableCompatChanges(NsdManager.RUN_NATIVE_NSD_ONLY_IF_LEGACY_APPS_T_AND_LATER)
+ @EnableCompatChanges(ConnectivityCompatChanges.RUN_NATIVE_NSD_ONLY_IF_LEGACY_APPS_T_AND_LATER)
public void testRegisterServiceS() throws Exception {
verify(mServiceConn, never()).startDaemon();
doTestRegisterService();
}
@Test
- @DisableCompatChanges(NsdManager.RUN_NATIVE_NSD_ONLY_IF_LEGACY_APPS_T_AND_LATER)
+ @DisableCompatChanges(ConnectivityCompatChanges.RUN_NATIVE_NSD_ONLY_IF_LEGACY_APPS_T_AND_LATER)
public void testRegisterServicePreS() throws Exception {
verify(mServiceConn).startDaemon();
doTestRegisterService();
diff --git a/tests/unit/java/android/net/util/KeepaliveUtilsTest.kt b/tests/unit/java/android/net/util/KeepaliveUtilsTest.kt
index 9203f8f..cca0b66 100644
--- a/tests/unit/java/android/net/util/KeepaliveUtilsTest.kt
+++ b/tests/unit/java/android/net/util/KeepaliveUtilsTest.kt
@@ -104,7 +104,7 @@
// Check valid customization generates expected array.
val validRes = arrayOf("0,3", "1,0", "4,4")
- val expectedValidRes = intArrayOf(3, 0, 0, 0, 4, 0, 0, 0, 0)
+ val expectedValidRes = intArrayOf(3, 0, 0, 0, 4, 0, 0, 0, 0, 0)
val mockContext = getMockedContextWithStringArrayRes(
R.array.config_networkSupportedKeepaliveCount,
diff --git a/tests/unit/java/com/android/internal/net/VpnProfileTest.java b/tests/unit/java/com/android/internal/net/VpnProfileTest.java
index 0a6d2f2..b2dff2e 100644
--- a/tests/unit/java/com/android/internal/net/VpnProfileTest.java
+++ b/tests/unit/java/com/android/internal/net/VpnProfileTest.java
@@ -20,6 +20,7 @@
import static android.net.cts.util.IkeSessionTestUtils.IKE_PARAMS_V4;
import static com.android.modules.utils.build.SdkLevel.isAtLeastT;
+import static com.android.modules.utils.build.SdkLevel.isAtLeastU;
import static com.android.testutils.ParcelUtils.assertParcelSane;
import static org.junit.Assert.assertEquals;
@@ -55,6 +56,9 @@
private static final int ENCODED_INDEX_RESTRICTED_TO_TEST_NETWORKS = 24;
private static final int ENCODED_INDEX_EXCLUDE_LOCAL_ROUTE = 25;
private static final int ENCODED_INDEX_REQUIRE_PLATFORM_VALIDATION = 26;
+ private static final int ENCODED_INDEX_IKE_TUN_CONN_PARAMS = 27;
+ private static final int ENCODED_INDEX_AUTOMATIC_NATT_KEEPALIVE_TIMER_ENABLED = 28;
+ private static final int ENCODED_INDEX_AUTOMATIC_IP_VERSION_SELECTION_ENABLED = 29;
@Test
public void testDefaults() throws Exception {
@@ -85,12 +89,15 @@
assertFalse(p.isRestrictedToTestNetworks);
assertFalse(p.excludeLocalRoutes);
assertFalse(p.requiresInternetValidation);
+ assertFalse(p.automaticNattKeepaliveTimerEnabled);
+ assertFalse(p.automaticIpVersionSelectionEnabled);
}
private VpnProfile getSampleIkev2Profile(String key) {
final VpnProfile p = new VpnProfile(key, true /* isRestrictedToTestNetworks */,
false /* excludesLocalRoutes */, true /* requiresPlatformValidation */,
- null /* ikeTunConnParams */);
+ null /* ikeTunConnParams */, true /* mAutomaticNattKeepaliveTimerEnabled */,
+ true /* automaticIpVersionSelectionEnabled */);
p.name = "foo";
p.type = VpnProfile.TYPE_IKEV2_IPSEC_USER_PASS;
@@ -128,7 +135,9 @@
private VpnProfile getSampleIkev2ProfileWithIkeTunConnParams(String key) {
final VpnProfile p = new VpnProfile(key, true /* isRestrictedToTestNetworks */,
false /* excludesLocalRoutes */, true /* requiresPlatformValidation */,
- new IkeTunnelConnectionParams(IKE_PARAMS_V4, CHILD_PARAMS));
+ new IkeTunnelConnectionParams(IKE_PARAMS_V4, CHILD_PARAMS),
+ true /* mAutomaticNattKeepaliveTimerEnabled */,
+ true /* automaticIpVersionSelectionEnabled */);
p.name = "foo";
p.server = "bar";
@@ -166,7 +175,11 @@
@Test
public void testParcelUnparcel() {
- if (isAtLeastT()) {
+ if (isAtLeastU()) {
+ // automaticNattKeepaliveTimerEnabled, automaticIpVersionSelectionEnabled added in U.
+ assertParcelSane(getSampleIkev2Profile(DUMMY_PROFILE_KEY), 28);
+ assertParcelSane(getSampleIkev2ProfileWithIkeTunConnParams(DUMMY_PROFILE_KEY), 28);
+ } else if (isAtLeastT()) {
// excludeLocalRoutes, requiresPlatformValidation were added in T.
assertParcelSane(getSampleIkev2Profile(DUMMY_PROFILE_KEY), 26);
assertParcelSane(getSampleIkev2ProfileWithIkeTunConnParams(DUMMY_PROFILE_KEY), 26);
@@ -221,16 +234,28 @@
ENCODED_INDEX_AUTH_PARAMS_INLINE,
ENCODED_INDEX_RESTRICTED_TO_TEST_NETWORKS,
ENCODED_INDEX_EXCLUDE_LOCAL_ROUTE,
- ENCODED_INDEX_REQUIRE_PLATFORM_VALIDATION /* missingIndices */);
+ ENCODED_INDEX_REQUIRE_PLATFORM_VALIDATION,
+ ENCODED_INDEX_IKE_TUN_CONN_PARAMS,
+ ENCODED_INDEX_AUTOMATIC_NATT_KEEPALIVE_TIMER_ENABLED,
+ ENCODED_INDEX_AUTOMATIC_IP_VERSION_SELECTION_ENABLED
+ /* missingIndices */);
assertNull(VpnProfile.decode(DUMMY_PROFILE_KEY, tooFewValues.getBytes()));
}
+ private String getEncodedDecodedIkev2ProfileWithtooFewValues() {
+ return getEncodedDecodedIkev2ProfileMissingValues(
+ ENCODED_INDEX_RESTRICTED_TO_TEST_NETWORKS,
+ ENCODED_INDEX_EXCLUDE_LOCAL_ROUTE,
+ ENCODED_INDEX_REQUIRE_PLATFORM_VALIDATION,
+ ENCODED_INDEX_IKE_TUN_CONN_PARAMS,
+ ENCODED_INDEX_AUTOMATIC_NATT_KEEPALIVE_TIMER_ENABLED,
+ ENCODED_INDEX_AUTOMATIC_IP_VERSION_SELECTION_ENABLED /* missingIndices */);
+ }
+
@Test
public void testEncodeDecodeMissingIsRestrictedToTestNetworks() {
- final String tooFewValues =
- getEncodedDecodedIkev2ProfileMissingValues(
- ENCODED_INDEX_RESTRICTED_TO_TEST_NETWORKS /* missingIndices */);
+ final String tooFewValues = getEncodedDecodedIkev2ProfileWithtooFewValues();
// Verify decoding without isRestrictedToTestNetworks defaults to false
final VpnProfile decoded = VpnProfile.decode(DUMMY_PROFILE_KEY, tooFewValues.getBytes());
@@ -239,10 +264,7 @@
@Test
public void testEncodeDecodeMissingExcludeLocalRoutes() {
- final String tooFewValues =
- getEncodedDecodedIkev2ProfileMissingValues(
- ENCODED_INDEX_EXCLUDE_LOCAL_ROUTE,
- ENCODED_INDEX_REQUIRE_PLATFORM_VALIDATION /* missingIndices */);
+ final String tooFewValues = getEncodedDecodedIkev2ProfileWithtooFewValues();
// Verify decoding without excludeLocalRoutes defaults to false
final VpnProfile decoded = VpnProfile.decode(DUMMY_PROFILE_KEY, tooFewValues.getBytes());
@@ -251,9 +273,7 @@
@Test
public void testEncodeDecodeMissingRequiresValidation() {
- final String tooFewValues =
- getEncodedDecodedIkev2ProfileMissingValues(
- ENCODED_INDEX_REQUIRE_PLATFORM_VALIDATION /* missingIndices */);
+ final String tooFewValues = getEncodedDecodedIkev2ProfileWithtooFewValues();
// Verify decoding without requiresValidation defaults to false
final VpnProfile decoded = VpnProfile.decode(DUMMY_PROFILE_KEY, tooFewValues.getBytes());
@@ -261,6 +281,24 @@
}
@Test
+ public void testEncodeDecodeMissingAutomaticNattKeepaliveTimerEnabled() {
+ final String tooFewValues = getEncodedDecodedIkev2ProfileWithtooFewValues();
+
+ // Verify decoding without automaticNattKeepaliveTimerEnabled defaults to false
+ final VpnProfile decoded = VpnProfile.decode(DUMMY_PROFILE_KEY, tooFewValues.getBytes());
+ assertFalse(decoded.automaticNattKeepaliveTimerEnabled);
+ }
+
+ @Test
+ public void testEncodeDecodeMissingAutomaticIpVersionSelectionEnabled() {
+ final String tooFewValues = getEncodedDecodedIkev2ProfileWithtooFewValues();
+
+ // Verify decoding without automaticIpVersionSelectionEnabled defaults to false
+ final VpnProfile decoded = VpnProfile.decode(DUMMY_PROFILE_KEY, tooFewValues.getBytes());
+ assertFalse(decoded.automaticIpVersionSelectionEnabled);
+ }
+
+ @Test
public void testEncodeDecodeLoginsNotSaved() {
final VpnProfile profile = getSampleIkev2Profile(DUMMY_PROFILE_KEY);
profile.saveLogin = false;
diff --git a/tests/unit/java/com/android/server/BpfNetMapsTest.java b/tests/unit/java/com/android/server/BpfNetMapsTest.java
index 0e17cd7..d189848 100644
--- a/tests/unit/java/com/android/server/BpfNetMapsTest.java
+++ b/tests/unit/java/com/android/server/BpfNetMapsTest.java
@@ -690,6 +690,80 @@
mBpfNetMaps.setUidRule(FIREWALL_CHAIN_DOZABLE, TEST_UID, FIREWALL_RULE_ALLOW));
}
+ private void doTestGetUidRule(final List<Integer> enableChains) throws Exception {
+ mUidOwnerMap.updateEntry(new S32(TEST_UID), new UidOwnerValue(0, getMatch(enableChains)));
+
+ for (final int chain: FIREWALL_CHAINS) {
+ final String testCase = "EnabledChains: " + enableChains + " CheckedChain: " + chain;
+ if (enableChains.contains(chain)) {
+ final int expectedRule = mBpfNetMaps.isFirewallAllowList(chain)
+ ? FIREWALL_RULE_ALLOW : FIREWALL_RULE_DENY;
+ assertEquals(testCase, expectedRule, mBpfNetMaps.getUidRule(chain, TEST_UID));
+ } else {
+ final int expectedRule = mBpfNetMaps.isFirewallAllowList(chain)
+ ? FIREWALL_RULE_DENY : FIREWALL_RULE_ALLOW;
+ assertEquals(testCase, expectedRule, mBpfNetMaps.getUidRule(chain, TEST_UID));
+ }
+ }
+ }
+
+ private void doTestGetUidRule(final int enableChain) throws Exception {
+ doTestGetUidRule(List.of(enableChain));
+ }
+
+ @Test
+ @IgnoreUpTo(Build.VERSION_CODES.S_V2)
+ public void testGetUidRule() throws Exception {
+ doTestGetUidRule(FIREWALL_CHAIN_DOZABLE);
+ doTestGetUidRule(FIREWALL_CHAIN_STANDBY);
+ doTestGetUidRule(FIREWALL_CHAIN_POWERSAVE);
+ doTestGetUidRule(FIREWALL_CHAIN_RESTRICTED);
+ doTestGetUidRule(FIREWALL_CHAIN_LOW_POWER_STANDBY);
+ doTestGetUidRule(FIREWALL_CHAIN_OEM_DENY_1);
+ doTestGetUidRule(FIREWALL_CHAIN_OEM_DENY_2);
+ doTestGetUidRule(FIREWALL_CHAIN_OEM_DENY_3);
+ }
+
+ @Test
+ @IgnoreUpTo(Build.VERSION_CODES.S_V2)
+ public void testGetUidRuleMultipleChainEnabled() throws Exception {
+ doTestGetUidRule(List.of(
+ FIREWALL_CHAIN_DOZABLE,
+ FIREWALL_CHAIN_STANDBY));
+ doTestGetUidRule(List.of(
+ FIREWALL_CHAIN_DOZABLE,
+ FIREWALL_CHAIN_STANDBY,
+ FIREWALL_CHAIN_POWERSAVE,
+ FIREWALL_CHAIN_RESTRICTED));
+ doTestGetUidRule(FIREWALL_CHAINS);
+ }
+
+ @Test
+ @IgnoreUpTo(Build.VERSION_CODES.S_V2)
+ public void testGetUidRuleNoEntry() throws Exception {
+ mUidOwnerMap.clear();
+ for (final int chain: FIREWALL_CHAINS) {
+ final int expectedRule = mBpfNetMaps.isFirewallAllowList(chain)
+ ? FIREWALL_RULE_DENY : FIREWALL_RULE_ALLOW;
+ assertEquals(expectedRule, mBpfNetMaps.getUidRule(chain, TEST_UID));
+ }
+ }
+
+ @Test
+ @IgnoreUpTo(Build.VERSION_CODES.S_V2)
+ public void testGetUidRuleInvalidChain() {
+ final Class<ServiceSpecificException> expected = ServiceSpecificException.class;
+ assertThrows(expected, () -> mBpfNetMaps.getUidRule(-1 /* childChain */, TEST_UID));
+ assertThrows(expected, () -> mBpfNetMaps.getUidRule(1000 /* childChain */, TEST_UID));
+ }
+
+ @Test
+ @IgnoreAfter(Build.VERSION_CODES.S_V2)
+ public void testGetUidRuleBeforeT() {
+ assertThrows(UnsupportedOperationException.class,
+ () -> mBpfNetMaps.getUidRule(FIREWALL_CHAIN_DOZABLE, TEST_UID));
+ }
+
@Test
@IgnoreUpTo(Build.VERSION_CODES.S_V2)
public void testReplaceUidChain() throws Exception {
diff --git a/tests/unit/java/com/android/server/ConnectivityServiceTest.java b/tests/unit/java/com/android/server/ConnectivityServiceTest.java
index bd6920a..1a358b2 100755
--- a/tests/unit/java/com/android/server/ConnectivityServiceTest.java
+++ b/tests/unit/java/com/android/server/ConnectivityServiceTest.java
@@ -27,6 +27,7 @@
import static android.Manifest.permission.MANAGE_TEST_NETWORKS;
import static android.Manifest.permission.NETWORK_FACTORY;
import static android.Manifest.permission.NETWORK_SETTINGS;
+import static android.Manifest.permission.NETWORK_SETUP_WIZARD;
import static android.Manifest.permission.NETWORK_STACK;
import static android.Manifest.permission.PACKET_KEEPALIVE_OFFLOAD;
import static android.app.PendingIntent.FLAG_IMMUTABLE;
@@ -172,6 +173,7 @@
import static com.android.testutils.MiscAsserts.assertThrows;
import static com.android.testutils.RecorderCallback.CallbackEntry.AVAILABLE;
import static com.android.testutils.RecorderCallback.CallbackEntry.BLOCKED_STATUS;
+import static com.android.testutils.RecorderCallback.CallbackEntry.BLOCKED_STATUS_INT;
import static com.android.testutils.RecorderCallback.CallbackEntry.LINK_PROPERTIES_CHANGED;
import static com.android.testutils.RecorderCallback.CallbackEntry.LOSING;
import static com.android.testutils.RecorderCallback.CallbackEntry.LOST;
@@ -181,6 +183,8 @@
import static com.android.testutils.RecorderCallback.CallbackEntry.UNAVAILABLE;
import static com.android.testutils.TestPermissionUtil.runAsShell;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.containsString;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotEquals;
@@ -226,6 +230,7 @@
import android.app.PendingIntent;
import android.app.admin.DevicePolicyManager;
import android.app.usage.NetworkStatsManager;
+import android.compat.testing.PlatformCompatChangeRule;
import android.content.BroadcastReceiver;
import android.content.ComponentName;
import android.content.ContentProvider;
@@ -310,6 +315,7 @@
import android.net.Uri;
import android.net.VpnManager;
import android.net.VpnTransportInfo;
+import android.net.connectivity.ConnectivityCompatChanges;
import android.net.metrics.IpConnectivityLog;
import android.net.netd.aidl.NativeUidRangeConfig;
import android.net.networkstack.NetworkStackClientBase;
@@ -377,6 +383,8 @@
import com.android.server.ConnectivityService.ConnectivityDiagnosticsCallbackInfo;
import com.android.server.ConnectivityService.NetworkRequestInfo;
import com.android.server.ConnectivityServiceTest.ConnectivityServiceDependencies.ReportedInterfaces;
+import com.android.server.connectivity.ApplicationSelfCertifiedNetworkCapabilities;
+import com.android.server.connectivity.AutomaticOnOffKeepaliveTracker;
import com.android.server.connectivity.CarrierPrivilegeAuthenticator;
import com.android.server.connectivity.ClatCoordinator;
import com.android.server.connectivity.ConnectivityFlags;
@@ -403,6 +411,9 @@
import com.android.testutils.TestableNetworkCallback;
import com.android.testutils.TestableNetworkOfferCallback;
+import libcore.junit.util.compat.CoreCompatChangeRule.DisableCompatChanges;
+import libcore.junit.util.compat.CoreCompatChangeRule.EnableCompatChanges;
+
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
@@ -472,6 +483,9 @@
@Rule
public final DevSdkIgnoreRule ignoreRule = new DevSdkIgnoreRule();
+ @Rule
+ public final PlatformCompatChangeRule compatChangeRule = new PlatformCompatChangeRule();
+
private static final int TIMEOUT_MS = 2_000;
// Broadcasts can take a long time to be delivered. The test will not wait for that long unless
// there is a failure, so use a long timeout.
@@ -538,6 +552,7 @@
private MockContext mServiceContext;
private HandlerThread mCsHandlerThread;
private ConnectivityServiceDependencies mDeps;
+ private AutomaticOnOffKeepaliveTrackerDependencies mAutoOnOffKeepaliveDependencies;
private ConnectivityService mService;
private WrappedConnectivityManager mCm;
private TestNetworkAgentWrapper mWiFiAgent;
@@ -1838,7 +1853,8 @@
doReturn(mResources).when(mockResContext).getResources();
ConnectivityResources.setResourcesContextForTest(mockResContext);
mDeps = new ConnectivityServiceDependencies(mockResContext);
-
+ mAutoOnOffKeepaliveDependencies =
+ new AutomaticOnOffKeepaliveTrackerDependencies(mServiceContext);
mService = new ConnectivityService(mServiceContext,
mMockDnsResolver,
mock(IpConnectivityLog.class),
@@ -1939,6 +1955,12 @@
}
@Override
+ public AutomaticOnOffKeepaliveTracker makeAutomaticOnOffKeepaliveTracker(final Context c,
+ final Handler h) {
+ return new AutomaticOnOffKeepaliveTracker(c, h, mAutoOnOffKeepaliveDependencies);
+ }
+
+ @Override
public ConnectivityResources getResources(final Context ctx) {
return mConnRes;
}
@@ -2094,6 +2116,51 @@
reset(mBroadcastOptionsShim);
return mBroadcastOptionsShim;
}
+
+ @GuardedBy("this")
+ private boolean mForceDisableCompatChangeCheck = true;
+
+ /**
+ * By default, the {@link #isChangeEnabled(long, String, UserHandle)} will always return
+ * true as the mForceDisableCompatChangeCheck is true and compat change check logic is
+ * never executed. The compat change check logic can be turned on by calling this method.
+ * If this method is called, the
+ * {@link libcore.junit.util.compat.CoreCompatChangeRule.EnableCompatChanges} or
+ * {@link libcore.junit.util.compat.CoreCompatChangeRule.DisableCompatChanges} must be
+ * used to turn on/off the compat change flag.
+ */
+ private void enableCompatChangeCheck() {
+ synchronized (this) {
+ mForceDisableCompatChangeCheck = false;
+ }
+ }
+
+ @Override
+ public boolean isChangeEnabled(long changeId,
+ @NonNull final String packageName,
+ @NonNull final UserHandle user) {
+ synchronized (this) {
+ if (mForceDisableCompatChangeCheck) {
+ return false;
+ } else {
+ return super.isChangeEnabled(changeId, packageName, user);
+ }
+ }
+ }
+ }
+
+ private class AutomaticOnOffKeepaliveTrackerDependencies
+ extends AutomaticOnOffKeepaliveTracker.Dependencies {
+ AutomaticOnOffKeepaliveTrackerDependencies(Context context) {
+ super(context);
+ }
+
+ @Override
+ public boolean isFeatureEnabled(@NonNull final String name, final boolean defaultEnabled) {
+ // Tests for enabling the feature are verified in AutomaticOnOffKeepaliveTrackerTest.
+ // Assuming enabled here to focus on ConnectivityService tests.
+ return true;
+ }
}
private static void initAlarmManager(final AlarmManager am, final Handler alarmHandler) {
@@ -2765,7 +2832,7 @@
if (expectLingering) {
generalCb.expectLosing(net1);
}
- generalCb.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, net2);
+ generalCb.expectCaps(net2, c -> c.hasCapability(NET_CAPABILITY_VALIDATED));
defaultCb.expectAvailableDoubleValidatedCallbacks(net2);
// Make sure cell 1 is unwanted immediately if the radio can't time share, but only
@@ -3181,7 +3248,8 @@
mWiFiAgent.connect(true);
genericNetworkCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
genericNetworkCallback.expectLosing(mCellAgent);
- genericNetworkCallback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiAgent);
+ genericNetworkCallback.expectCaps(mWiFiAgent,
+ c -> c.hasCapability(NET_CAPABILITY_VALIDATED));
wifiNetworkCallback.expectAvailableThenValidatedCallbacks(mWiFiAgent);
cellNetworkCallback.expectLosing(mCellAgent);
assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetwork());
@@ -3222,17 +3290,17 @@
final Uri expectedCapportUrl = sanitized ? null : capportUrl;
newLp.setCaptivePortalApiUrl(capportUrl);
mWiFiAgent.sendLinkProperties(newLp);
- callback.expectLinkPropertiesThat(mWiFiAgent, lp ->
- Objects.equals(expectedCapportUrl, lp.getCaptivePortalApiUrl()));
- defaultCallback.expectLinkPropertiesThat(mWiFiAgent, lp ->
- Objects.equals(expectedCapportUrl, lp.getCaptivePortalApiUrl()));
+ callback.expect(LINK_PROPERTIES_CHANGED, mWiFiAgent, cb ->
+ Objects.equals(expectedCapportUrl, cb.getLp().getCaptivePortalApiUrl()));
+ defaultCallback.expect(LINK_PROPERTIES_CHANGED, mWiFiAgent, cb ->
+ Objects.equals(expectedCapportUrl, cb.getLp().getCaptivePortalApiUrl()));
final CaptivePortalData expectedCapportData = sanitized ? null : capportData;
mWiFiAgent.notifyCapportApiDataChanged(capportData);
- callback.expectLinkPropertiesThat(mWiFiAgent, lp ->
- Objects.equals(expectedCapportData, lp.getCaptivePortalData()));
- defaultCallback.expectLinkPropertiesThat(mWiFiAgent, lp ->
- Objects.equals(expectedCapportData, lp.getCaptivePortalData()));
+ callback.expect(LINK_PROPERTIES_CHANGED, mWiFiAgent, cb ->
+ Objects.equals(expectedCapportData, cb.getLp().getCaptivePortalData()));
+ defaultCallback.expect(LINK_PROPERTIES_CHANGED, mWiFiAgent, cb ->
+ Objects.equals(expectedCapportData, cb.getLp().getCaptivePortalData()));
final LinkProperties lp = mCm.getLinkProperties(mWiFiAgent.getNetwork());
assertEquals(expectedCapportUrl, lp.getCaptivePortalApiUrl());
@@ -3330,7 +3398,7 @@
callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
// TODO: Investigate sending validated before losing.
callback.expectLosing(mCellAgent);
- callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiAgent);
+ callback.expectCaps(mWiFiAgent, c -> c.hasCapability(NET_CAPABILITY_VALIDATED));
defaultCallback.expectAvailableDoubleValidatedCallbacks(mWiFiAgent);
assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetwork());
assertEquals(defaultCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
@@ -3339,7 +3407,7 @@
callback.expectAvailableCallbacksUnvalidated(mEthernetAgent);
// TODO: Investigate sending validated before losing.
callback.expectLosing(mWiFiAgent);
- callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mEthernetAgent);
+ callback.expectCaps(mEthernetAgent, c -> c.hasCapability(NET_CAPABILITY_VALIDATED));
defaultCallback.expectAvailableDoubleValidatedCallbacks(mEthernetAgent);
assertEquals(mEthernetAgent.getNetwork(), mCm.getActiveNetwork());
assertEquals(defaultCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
@@ -3374,7 +3442,7 @@
// if the network is still up.
mWiFiAgent.removeCapability(NET_CAPABILITY_NOT_METERED);
// We expect a notification about the capabilities change, and nothing else.
- defaultCallback.expectCapabilitiesWithout(NET_CAPABILITY_NOT_METERED, mWiFiAgent);
+ defaultCallback.expectCaps(mWiFiAgent, c -> !c.hasCapability(NET_CAPABILITY_NOT_METERED));
defaultCallback.assertNoCallback();
callback.expect(LOST, mWiFiAgent);
assertEquals(defaultCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
@@ -3433,7 +3501,7 @@
callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
// TODO: Investigate sending validated before losing.
callback.expectLosing(mCellAgent);
- callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiAgent);
+ callback.expectCaps(mWiFiAgent, c -> c.hasCapability(NET_CAPABILITY_VALIDATED));
defaultCallback.expectAvailableThenValidatedCallbacks(mWiFiAgent);
assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetwork());
assertEquals(defaultCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
@@ -3460,7 +3528,7 @@
callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
// TODO: Investigate sending validated before losing.
callback.expectLosing(mCellAgent);
- callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiAgent);
+ callback.expectCaps(mWiFiAgent, c -> c.hasCapability(NET_CAPABILITY_VALIDATED));
assertEquals(defaultCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
NetworkRequest cellRequest = new NetworkRequest.Builder()
@@ -3510,7 +3578,7 @@
mEthernetAgent.connect(true);
callback.expectAvailableCallbacksUnvalidated(mEthernetAgent);
callback.expectLosing(mWiFiAgent);
- callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mEthernetAgent);
+ callback.expectCaps(mEthernetAgent, c -> c.hasCapability(NET_CAPABILITY_VALIDATED));
trackDefaultCallback.expectAvailableDoubleValidatedCallbacks(mEthernetAgent);
defaultCallback.expectAvailableDoubleValidatedCallbacks(mEthernetAgent);
assertEquals(defaultCallback.getLastAvailableNetwork(), mCm.getActiveNetwork());
@@ -3570,7 +3638,7 @@
defaultCallback.expectAvailableDoubleValidatedCallbacks(mWiFiAgent);
callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
callback.expectLosing(mCellAgent);
- callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiAgent);
+ callback.expectCaps(mWiFiAgent, c -> c.hasCapability(NET_CAPABILITY_VALIDATED));
// File a request for cellular, then release it.
NetworkRequest cellRequest = new NetworkRequest.Builder()
@@ -3583,7 +3651,8 @@
// Let linger run its course.
callback.assertNoCallback();
final int lingerTimeoutMs = TEST_LINGER_DELAY_MS + TEST_LINGER_DELAY_MS / 4;
- callback.expectCapabilitiesWithout(NET_CAPABILITY_FOREGROUND, mCellAgent, lingerTimeoutMs);
+ callback.expectCaps(mCellAgent, lingerTimeoutMs,
+ c -> !c.hasCapability(NET_CAPABILITY_FOREGROUND));
// Clean up.
mCm.unregisterNetworkCallback(defaultCallback);
@@ -3805,7 +3874,7 @@
mWiFiAgent.connect(true);
callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
callback.expectLosing(mCellAgent);
- callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiAgent);
+ callback.expectCaps(mWiFiAgent, c -> c.hasCapability(NET_CAPABILITY_VALIDATED));
assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetwork());
expectUnvalidationCheckWillNotNotify(mWiFiAgent);
@@ -3813,7 +3882,7 @@
mEthernetAgent.connect(true);
callback.expectAvailableCallbacksUnvalidated(mEthernetAgent);
callback.expectLosing(mWiFiAgent);
- callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mEthernetAgent);
+ callback.expectCaps(mEthernetAgent, c -> c.hasCapability(NET_CAPABILITY_VALIDATED));
assertEquals(mEthernetAgent.getNetwork(), mCm.getActiveNetwork());
callback.assertNoCallback();
@@ -4261,7 +4330,7 @@
mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
mWiFiAgent.connectWithPartialConnectivity();
callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
- callback.expectCapabilitiesWith(NET_CAPABILITY_PARTIAL_CONNECTIVITY, mWiFiAgent);
+ callback.expectCaps(mWiFiAgent, c -> c.hasCapability(NET_CAPABILITY_PARTIAL_CONNECTIVITY));
// Mobile data should be the default network.
assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetwork());
@@ -4289,8 +4358,8 @@
// validated.
mCm.reportNetworkConnectivity(mWiFiAgent.getNetwork(), true);
callback.expectLosing(mCellAgent);
- NetworkCapabilities nc = callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED,
- mWiFiAgent);
+ NetworkCapabilities nc =
+ callback.expectCaps(mWiFiAgent, c -> c.hasCapability(NET_CAPABILITY_VALIDATED));
assertTrue(nc.hasCapability(NET_CAPABILITY_PARTIAL_CONNECTIVITY));
assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetwork());
@@ -4304,7 +4373,7 @@
mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
mWiFiAgent.connectWithPartialConnectivity();
callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
- callback.expectCapabilitiesWith(NET_CAPABILITY_PARTIAL_CONNECTIVITY, mWiFiAgent);
+ callback.expectCaps(mWiFiAgent, c -> c.hasCapability(NET_CAPABILITY_PARTIAL_CONNECTIVITY));
// Mobile data should be the default network.
assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetwork());
@@ -4336,7 +4405,7 @@
callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
verify(mWiFiAgent.mNetworkMonitor, times(1)).setAcceptPartialConnectivity();
callback.expectLosing(mCellAgent);
- nc = callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiAgent);
+ nc = callback.expectCaps(mWiFiAgent, c -> c.hasCapability(NET_CAPABILITY_VALIDATED));
assertFalse(nc.hasCapability(NET_CAPABILITY_PARTIAL_CONNECTIVITY));
// Wifi should be the default network.
@@ -4357,7 +4426,7 @@
verify(mWiFiAgent.mNetworkMonitor, times(1)).setAcceptPartialConnectivity();
callback.expectLosing(mCellAgent);
assertEquals(mWiFiAgent.getNetwork(), mCm.getActiveNetwork());
- callback.expectCapabilitiesWith(NET_CAPABILITY_PARTIAL_CONNECTIVITY, mWiFiAgent);
+ callback.expectCaps(mWiFiAgent, c -> c.hasCapability(NET_CAPABILITY_PARTIAL_CONNECTIVITY));
expectUnvalidationCheckWillNotNotify(mWiFiAgent);
mWiFiAgent.setNetworkValid(false /* privateDnsProbeSent */);
@@ -4365,7 +4434,7 @@
// Need a trigger point to let NetworkMonitor tell ConnectivityService that the network is
// validated.
mCm.reportNetworkConnectivity(mWiFiAgent.getNetwork(), true);
- callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiAgent);
+ callback.expectCaps(mWiFiAgent, c -> c.hasCapability(NET_CAPABILITY_VALIDATED));
mWiFiAgent.disconnect();
callback.expect(LOST, mWiFiAgent);
@@ -4381,8 +4450,8 @@
callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
verify(mWiFiAgent.mNetworkMonitor, times(1)).setAcceptPartialConnectivity();
callback.expectLosing(mCellAgent);
- callback.expectCapabilitiesWith(
- NET_CAPABILITY_PARTIAL_CONNECTIVITY | NET_CAPABILITY_VALIDATED, mWiFiAgent);
+ callback.expectCaps(mWiFiAgent, c -> c.hasCapability(NET_CAPABILITY_PARTIAL_CONNECTIVITY)
+ && c.hasCapability(NET_CAPABILITY_VALIDATED));
expectUnvalidationCheckWillNotNotify(mWiFiAgent);
mWiFiAgent.disconnect();
callback.expect(LOST, mWiFiAgent);
@@ -4413,7 +4482,7 @@
// This is necessary because of b/245893397, the same bug that happens where we use
// expectAvailableDoubleValidatedCallbacks.
// TODO : fix b/245893397 and remove this.
- wifiCallback.expectCapabilitiesWith(NET_CAPABILITY_CAPTIVE_PORTAL, mWiFiAgent);
+ wifiCallback.expectCaps(mWiFiAgent, c -> c.hasCapability(NET_CAPABILITY_CAPTIVE_PORTAL));
// Check that startCaptivePortalApp sends the expected command to NetworkMonitor.
mCm.startCaptivePortalApp(mWiFiAgent.getNetwork());
@@ -4434,9 +4503,10 @@
false /* always */);
waitForIdle();
mCm.reportNetworkConnectivity(mWiFiAgent.getNetwork(), true);
- wifiCallback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiAgent);
+ wifiCallback.expectCaps(mWiFiAgent, c -> c.hasCapability(NET_CAPABILITY_VALIDATED));
validatedCallback.expectAvailableCallbacksValidated(mWiFiAgent);
- validatedCallback.expectCapabilitiesWith(NET_CAPABILITY_PARTIAL_CONNECTIVITY, mWiFiAgent);
+ validatedCallback.expectCaps(mWiFiAgent,
+ c -> c.hasCapability(NET_CAPABILITY_PARTIAL_CONNECTIVITY));
mCm.unregisterNetworkCallback(wifiCallback);
mCm.unregisterNetworkCallback(validatedCallback);
@@ -4638,15 +4708,16 @@
mWiFiAgent.notifyCapportApiDataChanged(testData);
- captivePortalCallback.expectLinkPropertiesThat(mWiFiAgent,
- lp -> testData.equals(lp.getCaptivePortalData()));
+ captivePortalCallback.expect(LINK_PROPERTIES_CHANGED, mWiFiAgent,
+ cb -> testData.equals(cb.getLp().getCaptivePortalData()));
final LinkProperties newLps = new LinkProperties();
newLps.setMtu(1234);
mWiFiAgent.sendLinkProperties(newLps);
// CaptivePortalData is not lost and unchanged when LPs are received from the NetworkAgent
- captivePortalCallback.expectLinkPropertiesThat(mWiFiAgent,
- lp -> testData.equals(lp.getCaptivePortalData()) && lp.getMtu() == 1234);
+ captivePortalCallback.expect(LINK_PROPERTIES_CHANGED, mWiFiAgent,
+ cb -> testData.equals(cb.getLp().getCaptivePortalData())
+ && cb.getLp().getMtu() == 1234);
}
private TestNetworkCallback setupNetworkCallbackAndConnectToWifi() throws Exception {
@@ -4740,8 +4811,8 @@
// Baseline capport data
mWiFiAgent.notifyCapportApiDataChanged(captivePortalTestData.mCapportData);
- captivePortalCallback.expectLinkPropertiesThat(mWiFiAgent,
- lp -> captivePortalTestData.mCapportData.equals(lp.getCaptivePortalData()));
+ captivePortalCallback.expect(LINK_PROPERTIES_CHANGED, mWiFiAgent,
+ cb -> captivePortalTestData.mCapportData.equals(cb.getLp().getCaptivePortalData()));
// Venue URL, T&C URL and friendly name from Network agent with Passpoint source, confirm
// that API data gets precedence on the bytes remaining.
@@ -4750,9 +4821,9 @@
mWiFiAgent.sendLinkProperties(linkProperties);
// Make sure that the capport data is merged
- captivePortalCallback.expectLinkPropertiesThat(mWiFiAgent,
- lp -> captivePortalTestData.mExpectedMergedPasspointData
- .equals(lp.getCaptivePortalData()));
+ captivePortalCallback.expect(LINK_PROPERTIES_CHANGED, mWiFiAgent,
+ cb -> captivePortalTestData.mExpectedMergedPasspointData.equals(
+ cb.getLp().getCaptivePortalData()));
// Now send this information from non-Passpoint source, confirm that Capport data takes
// precedence
@@ -4760,9 +4831,9 @@
mWiFiAgent.sendLinkProperties(linkProperties);
// Make sure that the capport data is merged
- captivePortalCallback.expectLinkPropertiesThat(mWiFiAgent,
- lp -> captivePortalTestData.mExpectedMergedOtherData
- .equals(lp.getCaptivePortalData()));
+ captivePortalCallback.expect(LINK_PROPERTIES_CHANGED, mWiFiAgent,
+ cb -> captivePortalTestData.mExpectedMergedOtherData.equals(
+ cb.getLp().getCaptivePortalData()));
// Create a new LP with no Network agent capport data
final LinkProperties newLps = new LinkProperties();
@@ -4770,21 +4841,22 @@
mWiFiAgent.sendLinkProperties(newLps);
// CaptivePortalData is not lost and has the original values when LPs are received from the
// NetworkAgent
- captivePortalCallback.expectLinkPropertiesThat(mWiFiAgent,
- lp -> captivePortalTestData.mCapportData.equals(lp.getCaptivePortalData())
- && lp.getMtu() == 1234);
+ captivePortalCallback.expect(LINK_PROPERTIES_CHANGED, mWiFiAgent,
+ cb -> captivePortalTestData.mCapportData.equals(cb.getLp().getCaptivePortalData())
+ && cb.getLp().getMtu() == 1234);
// Now send capport data only from the Network agent
mWiFiAgent.notifyCapportApiDataChanged(null);
- captivePortalCallback.expectLinkPropertiesThat(mWiFiAgent,
- lp -> lp.getCaptivePortalData() == null);
+ captivePortalCallback.expect(LINK_PROPERTIES_CHANGED, mWiFiAgent,
+ cb -> cb.getLp().getCaptivePortalData() == null);
newLps.setCaptivePortalData(captivePortalTestData.mNaPasspointData);
mWiFiAgent.sendLinkProperties(newLps);
// Make sure that only the network agent capport data is available
- captivePortalCallback.expectLinkPropertiesThat(mWiFiAgent,
- lp -> captivePortalTestData.mNaPasspointData.equals(lp.getCaptivePortalData()));
+ captivePortalCallback.expect(LINK_PROPERTIES_CHANGED, mWiFiAgent,
+ cb -> captivePortalTestData.mNaPasspointData.equals(
+ cb.getLp().getCaptivePortalData()));
}
@Test
@@ -4799,25 +4871,26 @@
mWiFiAgent.sendLinkProperties(linkProperties);
// Make sure that the data is saved correctly
- captivePortalCallback.expectLinkPropertiesThat(mWiFiAgent,
- lp -> captivePortalTestData.mNaPasspointData.equals(lp.getCaptivePortalData()));
+ captivePortalCallback.expect(LINK_PROPERTIES_CHANGED, mWiFiAgent,
+ cb -> captivePortalTestData.mNaPasspointData.equals(
+ cb.getLp().getCaptivePortalData()));
// Expected merged data: Network agent data is preferred, and values that are not used by
// it are merged from capport data
mWiFiAgent.notifyCapportApiDataChanged(captivePortalTestData.mCapportData);
// Make sure that the Capport data is merged correctly
- captivePortalCallback.expectLinkPropertiesThat(mWiFiAgent,
- lp -> captivePortalTestData.mExpectedMergedPasspointData.equals(
- lp.getCaptivePortalData()));
+ captivePortalCallback.expect(LINK_PROPERTIES_CHANGED, mWiFiAgent,
+ cb -> captivePortalTestData.mExpectedMergedPasspointData.equals(
+ cb.getLp().getCaptivePortalData()));
// Now set the naData to null
linkProperties.setCaptivePortalData(null);
mWiFiAgent.sendLinkProperties(linkProperties);
// Make sure that the Capport data is retained correctly
- captivePortalCallback.expectLinkPropertiesThat(mWiFiAgent,
- lp -> captivePortalTestData.mCapportData.equals(lp.getCaptivePortalData()));
+ captivePortalCallback.expect(LINK_PROPERTIES_CHANGED, mWiFiAgent,
+ cb -> captivePortalTestData.mCapportData.equals(cb.getLp().getCaptivePortalData()));
}
@Test
@@ -4833,17 +4906,17 @@
mWiFiAgent.sendLinkProperties(linkProperties);
// Make sure that the data is saved correctly
- captivePortalCallback.expectLinkPropertiesThat(mWiFiAgent,
- lp -> captivePortalTestData.mNaOtherData.equals(lp.getCaptivePortalData()));
+ captivePortalCallback.expect(LINK_PROPERTIES_CHANGED, mWiFiAgent,
+ cb -> captivePortalTestData.mNaOtherData.equals(cb.getLp().getCaptivePortalData()));
// Expected merged data: Network agent data is preferred, and values that are not used by
// it are merged from capport data
mWiFiAgent.notifyCapportApiDataChanged(captivePortalTestData.mCapportData);
// Make sure that the Capport data is merged correctly
- captivePortalCallback.expectLinkPropertiesThat(mWiFiAgent,
- lp -> captivePortalTestData.mExpectedMergedOtherData.equals(
- lp.getCaptivePortalData()));
+ captivePortalCallback.expect(LINK_PROPERTIES_CHANGED, mWiFiAgent,
+ cb -> captivePortalTestData.mExpectedMergedOtherData.equals(
+ cb.getLp().getCaptivePortalData()));
}
private NetworkRequest.Builder newWifiRequestBuilder() {
@@ -5232,7 +5305,8 @@
// Suspend the network.
mCellAgent.suspend();
- cellNetworkCallback.expectCapabilitiesWithout(NET_CAPABILITY_NOT_SUSPENDED, mCellAgent);
+ cellNetworkCallback.expectCaps(mCellAgent,
+ c -> !c.hasCapability(NET_CAPABILITY_NOT_SUSPENDED));
cellNetworkCallback.expect(SUSPENDED, mCellAgent);
cellNetworkCallback.assertNoCallback();
assertEquals(NetworkInfo.State.SUSPENDED, mCm.getActiveNetworkInfo().getState());
@@ -5247,7 +5321,8 @@
mCm.unregisterNetworkCallback(dfltNetworkCallback);
mCellAgent.resume();
- cellNetworkCallback.expectCapabilitiesWith(NET_CAPABILITY_NOT_SUSPENDED, mCellAgent);
+ cellNetworkCallback.expectCaps(mCellAgent,
+ c -> c.hasCapability(NET_CAPABILITY_NOT_SUSPENDED));
cellNetworkCallback.expect(RESUMED, mCellAgent);
cellNetworkCallback.assertNoCallback();
assertEquals(NetworkInfo.State.CONNECTED, mCm.getActiveNetworkInfo().getState());
@@ -5288,6 +5363,13 @@
callback.expectAvailableCallbacksUnvalidated(mCellAgent);
mCm.unregisterNetworkCallback(callback);
+ mServiceContext.setPermission(NETWORK_SETTINGS, PERMISSION_DENIED);
+ mServiceContext.setPermission(NETWORK_SETUP_WIZARD, PERMISSION_GRANTED);
+ mCm.registerSystemDefaultNetworkCallback(callback, handler);
+ callback.expectAvailableCallbacksUnvalidated(mCellAgent);
+ mCm.unregisterNetworkCallback(callback);
+
+ mServiceContext.setPermission(NETWORK_SETTINGS, PERMISSION_GRANTED);
mCm.registerDefaultNetworkCallbackForUid(APP1_UID, callback, handler);
callback.expectAvailableCallbacksUnvalidated(mCellAgent);
mCm.unregisterNetworkCallback(callback);
@@ -5474,10 +5556,10 @@
// When wifi connects, cell lingers.
callback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
callback.expectLosing(mCellAgent);
- callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiAgent);
+ callback.expectCaps(mWiFiAgent, c -> c.hasCapability(NET_CAPABILITY_VALIDATED));
fgCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
fgCallback.expectLosing(mCellAgent);
- fgCallback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiAgent);
+ fgCallback.expectCaps(mWiFiAgent, c -> c.hasCapability(NET_CAPABILITY_VALIDATED));
assertTrue(isForegroundNetwork(mCellAgent));
assertTrue(isForegroundNetwork(mWiFiAgent));
@@ -5486,7 +5568,7 @@
int timeoutMs = TEST_LINGER_DELAY_MS + TEST_LINGER_DELAY_MS / 4;
fgCallback.expect(LOST, mCellAgent, timeoutMs);
// Expect a network capabilities update sans FOREGROUND.
- callback.expectCapabilitiesWithout(NET_CAPABILITY_FOREGROUND, mCellAgent);
+ callback.expectCaps(mCellAgent, c -> !c.hasCapability(NET_CAPABILITY_FOREGROUND));
assertFalse(isForegroundNetwork(mCellAgent));
assertTrue(isForegroundNetwork(mWiFiAgent));
@@ -5499,8 +5581,8 @@
fgCallback.expectAvailableCallbacksValidated(mCellAgent);
// Expect a network capabilities update with FOREGROUND, because the most recent
// request causes its state to change.
- cellCallback.expectCapabilitiesWith(NET_CAPABILITY_FOREGROUND, mCellAgent);
- callback.expectCapabilitiesWith(NET_CAPABILITY_FOREGROUND, mCellAgent);
+ cellCallback.expectCaps(mCellAgent, c -> c.hasCapability(NET_CAPABILITY_FOREGROUND));
+ callback.expectCaps(mCellAgent, c -> c.hasCapability(NET_CAPABILITY_FOREGROUND));
assertTrue(isForegroundNetwork(mCellAgent));
assertTrue(isForegroundNetwork(mWiFiAgent));
@@ -5509,7 +5591,7 @@
mCm.unregisterNetworkCallback(cellCallback);
fgCallback.expect(LOST, mCellAgent);
// Expect a network capabilities update sans FOREGROUND.
- callback.expectCapabilitiesWithout(NET_CAPABILITY_FOREGROUND, mCellAgent);
+ callback.expectCaps(mCellAgent, c -> !c.hasCapability(NET_CAPABILITY_FOREGROUND));
assertFalse(isForegroundNetwork(mCellAgent));
assertTrue(isForegroundNetwork(mWiFiAgent));
@@ -5661,7 +5743,8 @@
// Need a trigger point to let NetworkMonitor tell ConnectivityService that network is
// validated – see testPartialConnectivity.
mCm.reportNetworkConnectivity(mCellAgent.getNetwork(), true);
- cellNetworkCallback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mCellAgent);
+ cellNetworkCallback.expectCaps(mCellAgent,
+ c -> c.hasCapability(NET_CAPABILITY_VALIDATED));
testFactory.expectRequestRemove();
testFactory.assertRequestCountEquals(0);
// Accordingly, the factory shouldn't be started.
@@ -5862,14 +5945,15 @@
mWiFiAgent.setNetworkValid(true /* privateDnsProbeSent */);
// Have CS reconsider the network (see testPartialConnectivity)
mCm.reportNetworkConnectivity(mWiFiAgent.getNetwork(), true);
- wifiNetworkCallback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiAgent);
+ wifiNetworkCallback.expectCaps(mWiFiAgent, c -> c.hasCapability(NET_CAPABILITY_VALIDATED));
cellCallback.expectOnNetworkUnneeded(defaultCaps);
wifiCallback.assertNoCallback();
// Wifi is no longer validated. Cell is needed again.
mWiFiAgent.setNetworkInvalid(true /* invalidBecauseOfPrivateDns */);
mCm.reportNetworkConnectivity(mWiFiAgent.getNetwork(), false);
- wifiNetworkCallback.expectCapabilitiesWithout(NET_CAPABILITY_VALIDATED, mWiFiAgent);
+ wifiNetworkCallback.expectCaps(mWiFiAgent,
+ c -> !c.hasCapability(NET_CAPABILITY_VALIDATED));
cellCallback.expectOnNetworkNeeded(defaultCaps);
wifiCallback.assertNoCallback();
@@ -5891,7 +5975,8 @@
wifiCallback.assertNoCallback();
mWiFiAgent.setNetworkValid(true /* privateDnsProbeSent */);
mCm.reportNetworkConnectivity(mWiFiAgent.getNetwork(), true);
- wifiNetworkCallback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiAgent);
+ wifiNetworkCallback.expectCaps(mWiFiAgent,
+ c -> c.hasCapability(NET_CAPABILITY_VALIDATED));
cellCallback.expectOnNetworkUnneeded(defaultCaps);
wifiCallback.assertNoCallback();
@@ -5899,7 +5984,8 @@
// not needed.
mWiFiAgent.setNetworkInvalid(true /* invalidBecauseOfPrivateDns */);
mCm.reportNetworkConnectivity(mWiFiAgent.getNetwork(), false);
- wifiNetworkCallback.expectCapabilitiesWithout(NET_CAPABILITY_VALIDATED, mWiFiAgent);
+ wifiNetworkCallback.expectCaps(mWiFiAgent,
+ c -> !c.hasCapability(NET_CAPABILITY_VALIDATED));
cellCallback.assertNoCallback();
wifiCallback.assertNoCallback();
}
@@ -5994,7 +6080,7 @@
// Fail validation on wifi.
mWiFiAgent.setNetworkInvalid(false /* invalidBecauseOfPrivateDns */);
mCm.reportNetworkConnectivity(wifiNetwork, false);
- defaultCallback.expectCapabilitiesWithout(NET_CAPABILITY_VALIDATED, mWiFiAgent);
+ defaultCallback.expectCaps(mWiFiAgent, c -> !c.hasCapability(NET_CAPABILITY_VALIDATED));
validatedWifiCallback.expect(LOST, mWiFiAgent);
expectNotification(mWiFiAgent, NotificationType.LOST_INTERNET);
@@ -6045,7 +6131,7 @@
// Fail validation on wifi and expect the dialog to appear.
mWiFiAgent.setNetworkInvalid(false /* invalidBecauseOfPrivateDns */);
mCm.reportNetworkConnectivity(wifiNetwork, false);
- defaultCallback.expectCapabilitiesWithout(NET_CAPABILITY_VALIDATED, mWiFiAgent);
+ defaultCallback.expectCaps(mWiFiAgent, c -> !c.hasCapability(NET_CAPABILITY_VALIDATED));
validatedWifiCallback.expect(LOST, mWiFiAgent);
expectNotification(mWiFiAgent, NotificationType.LOST_INTERNET);
@@ -6266,6 +6352,142 @@
}
}
+ @Test
+ @IgnoreUpTo(Build.VERSION_CODES.TIRAMISU)
+ @DisableCompatChanges(ConnectivityCompatChanges.ENABLE_SELF_CERTIFIED_CAPABILITIES_DECLARATION)
+ public void testSelfCertifiedCapabilitiesDisabled()
+ throws Exception {
+ mDeps.enableCompatChangeCheck();
+ final NetworkRequest networkRequest = new NetworkRequest.Builder()
+ .addCapability(NetworkCapabilities.NET_CAPABILITY_PRIORITIZE_LATENCY)
+ .addCapability(NetworkCapabilities.NET_CAPABILITY_PRIORITIZE_BANDWIDTH)
+ .build();
+ final TestNetworkCallback cb = new TestNetworkCallback();
+ mCm.requestNetwork(networkRequest, cb);
+ mCm.unregisterNetworkCallback(cb);
+ }
+
+ /** Set the networkSliceResourceId to 0 will result in NameNotFoundException be thrown. */
+ private void setupMockForNetworkCapabilitiesResources(int networkSliceResourceId)
+ throws PackageManager.NameNotFoundException {
+ if (networkSliceResourceId == 0) {
+ doThrow(new PackageManager.NameNotFoundException()).when(mPackageManager).getProperty(
+ ConstantsShim.PROPERTY_SELF_CERTIFIED_NETWORK_CAPABILITIES,
+ mContext.getPackageName());
+ } else {
+ final PackageManager.Property property = new PackageManager.Property(
+ ConstantsShim.PROPERTY_SELF_CERTIFIED_NETWORK_CAPABILITIES,
+ networkSliceResourceId,
+ true /* isResource */,
+ mContext.getPackageName(),
+ "dummyClass"
+ );
+ doReturn(property).when(mPackageManager).getProperty(
+ ConstantsShim.PROPERTY_SELF_CERTIFIED_NETWORK_CAPABILITIES,
+ mContext.getPackageName());
+ doReturn(mContext.getResources()).when(mPackageManager).getResourcesForApplication(
+ mContext.getPackageName());
+ }
+ }
+
+ @Test
+ @IgnoreUpTo(Build.VERSION_CODES.TIRAMISU)
+ @EnableCompatChanges(ConnectivityCompatChanges.ENABLE_SELF_CERTIFIED_CAPABILITIES_DECLARATION)
+ public void requestNetwork_withoutPrioritizeBandwidthDeclaration_shouldThrowException()
+ throws Exception {
+ mDeps.enableCompatChangeCheck();
+ setupMockForNetworkCapabilitiesResources(
+ com.android.frameworks.tests.net.R.xml.self_certified_capabilities_latency);
+ final NetworkRequest networkRequest = new NetworkRequest.Builder()
+ .addCapability(NetworkCapabilities.NET_CAPABILITY_PRIORITIZE_BANDWIDTH)
+ .build();
+ final TestNetworkCallback cb = new TestNetworkCallback();
+ final Exception e = assertThrows(SecurityException.class,
+ () -> mCm.requestNetwork(networkRequest, cb));
+ assertThat(e.getMessage(),
+ containsString(ApplicationSelfCertifiedNetworkCapabilities.PRIORITIZE_BANDWIDTH));
+ }
+
+ @Test
+ @IgnoreUpTo(Build.VERSION_CODES.TIRAMISU)
+ @EnableCompatChanges(ConnectivityCompatChanges.ENABLE_SELF_CERTIFIED_CAPABILITIES_DECLARATION)
+ public void requestNetwork_withoutPrioritizeLatencyDeclaration_shouldThrowException()
+ throws Exception {
+ mDeps.enableCompatChangeCheck();
+ setupMockForNetworkCapabilitiesResources(
+ com.android.frameworks.tests.net.R.xml.self_certified_capabilities_bandwidth);
+ final NetworkRequest networkRequest = new NetworkRequest.Builder()
+ .addCapability(NetworkCapabilities.NET_CAPABILITY_PRIORITIZE_LATENCY)
+ .build();
+ final TestNetworkCallback cb = new TestNetworkCallback();
+ final Exception e = assertThrows(SecurityException.class,
+ () -> mCm.requestNetwork(networkRequest, cb));
+ assertThat(e.getMessage(),
+ containsString(ApplicationSelfCertifiedNetworkCapabilities.PRIORITIZE_LATENCY));
+ }
+
+ @Test
+ @IgnoreUpTo(Build.VERSION_CODES.TIRAMISU)
+ @EnableCompatChanges(ConnectivityCompatChanges.ENABLE_SELF_CERTIFIED_CAPABILITIES_DECLARATION)
+ public void requestNetwork_withoutNetworkSliceProperty_shouldThrowException() throws Exception {
+ mDeps.enableCompatChangeCheck();
+ setupMockForNetworkCapabilitiesResources(0 /* networkSliceResourceId */);
+ final NetworkRequest networkRequest = new NetworkRequest.Builder()
+ .addCapability(NetworkCapabilities.NET_CAPABILITY_PRIORITIZE_LATENCY)
+ .addCapability(NetworkCapabilities.NET_CAPABILITY_PRIORITIZE_BANDWIDTH)
+ .build();
+ final TestNetworkCallback cb = new TestNetworkCallback();
+ final Exception e = assertThrows(SecurityException.class,
+ () -> mCm.requestNetwork(networkRequest, cb));
+ assertThat(e.getMessage(),
+ containsString(ConstantsShim.PROPERTY_SELF_CERTIFIED_NETWORK_CAPABILITIES));
+ }
+
+ @Test
+ @IgnoreUpTo(Build.VERSION_CODES.TIRAMISU)
+ @EnableCompatChanges(ConnectivityCompatChanges.ENABLE_SELF_CERTIFIED_CAPABILITIES_DECLARATION)
+ public void requestNetwork_withNetworkSliceDeclaration_shouldSucceed() throws Exception {
+ mDeps.enableCompatChangeCheck();
+ setupMockForNetworkCapabilitiesResources(
+ com.android.frameworks.tests.net.R.xml.self_certified_capabilities_both);
+
+ final NetworkRequest networkRequest = new NetworkRequest.Builder()
+ .addCapability(NetworkCapabilities.NET_CAPABILITY_PRIORITIZE_LATENCY)
+ .addCapability(NetworkCapabilities.NET_CAPABILITY_PRIORITIZE_BANDWIDTH)
+ .build();
+ final TestNetworkCallback cb = new TestNetworkCallback();
+ mCm.requestNetwork(networkRequest, cb);
+ mCm.unregisterNetworkCallback(cb);
+ }
+
+ @Test
+ @IgnoreUpTo(Build.VERSION_CODES.TIRAMISU)
+ @EnableCompatChanges(ConnectivityCompatChanges.ENABLE_SELF_CERTIFIED_CAPABILITIES_DECLARATION)
+ public void requestNetwork_withNetworkSliceDeclaration_shouldUseCache() throws Exception {
+ mDeps.enableCompatChangeCheck();
+ setupMockForNetworkCapabilitiesResources(
+ com.android.frameworks.tests.net.R.xml.self_certified_capabilities_both);
+
+ final NetworkRequest networkRequest = new NetworkRequest.Builder()
+ .addCapability(NetworkCapabilities.NET_CAPABILITY_PRIORITIZE_LATENCY)
+ .addCapability(NetworkCapabilities.NET_CAPABILITY_PRIORITIZE_BANDWIDTH)
+ .build();
+ final TestNetworkCallback cb = new TestNetworkCallback();
+ mCm.requestNetwork(networkRequest, cb);
+ mCm.unregisterNetworkCallback(cb);
+
+ // Second call should use caches
+ mCm.requestNetwork(networkRequest, cb);
+ mCm.unregisterNetworkCallback(cb);
+
+ // PackageManager's API only called once because the second call is using cache.
+ verify(mPackageManager, times(1)).getProperty(
+ ConstantsShim.PROPERTY_SELF_CERTIFIED_NETWORK_CAPABILITIES,
+ mContext.getPackageName());
+ verify(mPackageManager, times(1)).getResourcesForApplication(
+ mContext.getPackageName());
+ }
+
/**
* Validate the service throws if request with CBS but without carrier privilege.
*/
@@ -7262,7 +7484,7 @@
CallbackEntry.LinkPropertiesChanged cbi =
networkCallback.expect(LINK_PROPERTIES_CHANGED, networkAgent);
networkCallback.expect(BLOCKED_STATUS, networkAgent);
- networkCallback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, networkAgent);
+ networkCallback.expectCaps(networkAgent, c -> c.hasCapability(NET_CAPABILITY_VALIDATED));
networkCallback.assertNoCallback();
checkDirectlyConnectedRoutes(cbi.getLp(), asList(myIpv4Address),
asList(myIpv4DefaultRoute));
@@ -8548,7 +8770,7 @@
mMockVpn.getAgent().mNetworkMonitor.forceReevaluation(Process.myUid());
// Expect to see the validated capability, but no other changes, because the VPN is already
// the default network for the app.
- callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mMockVpn);
+ callback.expectCaps(mMockVpn, c -> c.hasCapability(NET_CAPABILITY_VALIDATED));
callback.assertNoCallback();
mMockVpn.disconnect();
@@ -8851,6 +9073,14 @@
final TestNetworkCallback callback = new TestNetworkCallback();
mCm.registerNetworkCallback(request, callback);
+ // File a VPN request to prevent VPN network being lingered.
+ final NetworkRequest vpnRequest = new NetworkRequest.Builder()
+ .addTransportType(TRANSPORT_VPN)
+ .removeCapability(NET_CAPABILITY_NOT_VPN)
+ .build();
+ final TestNetworkCallback vpnCallback = new TestNetworkCallback();
+ mCm.requestNetwork(vpnRequest, vpnCallback);
+
// Bring up a VPN
mMockVpn.establishForMyUid();
assertUidRangesUpdatedForMyUid(true);
@@ -8909,6 +9139,9 @@
&& c.getUids().contains(singleUidRange)
&& c.hasTransport(TRANSPORT_VPN)
&& !c.hasTransport(TRANSPORT_WIFI));
+
+ mCm.unregisterNetworkCallback(callback);
+ mCm.unregisterNetworkCallback(vpnCallback);
}
@Test
@@ -9156,11 +9389,6 @@
public void expectAvailableThenValidatedCallbacks(HasNetwork n, int blockedStatus) {
super.expectAvailableThenValidatedCallbacks(n.getNetwork(), blockedStatus, TIMEOUT_MS);
}
- public void expectBlockedStatusCallback(HasNetwork n, int blockedStatus) {
- // This doesn't work:
- // super.expectBlockedStatusCallback(blockedStatus, n.getNetwork());
- super.expectBlockedStatusCallback(blockedStatus, n.getNetwork(), TIMEOUT_MS);
- }
public void onBlockedStatusChanged(Network network, int blockedReasons) {
getHistory().add(new CallbackEntry.BlockedStatusInt(network, blockedReasons));
}
@@ -9188,8 +9416,9 @@
assertExtraInfoFromCmPresent(mCellAgent);
setBlockedReasonChanged(BLOCKED_REASON_BATTERY_SAVER);
- cellNetworkCallback.expectBlockedStatusCallback(true, mCellAgent);
- detailedCallback.expectBlockedStatusCallback(mCellAgent, BLOCKED_REASON_BATTERY_SAVER);
+ cellNetworkCallback.expect(BLOCKED_STATUS, mCellAgent, cb -> cb.getBlocked());
+ detailedCallback.expect(BLOCKED_STATUS_INT, mCellAgent,
+ cb -> cb.getReason() == BLOCKED_REASON_BATTERY_SAVER);
assertNull(mCm.getActiveNetwork());
assertActiveNetworkInfo(TYPE_MOBILE, DetailedState.BLOCKED);
assertNetworkInfo(TYPE_MOBILE, DetailedState.BLOCKED);
@@ -9198,21 +9427,23 @@
// If blocked state does not change but blocked reason does, the boolean callback is called.
// TODO: investigate de-duplicating.
setBlockedReasonChanged(BLOCKED_METERED_REASON_USER_RESTRICTED);
- cellNetworkCallback.expectBlockedStatusCallback(true, mCellAgent);
- detailedCallback.expectBlockedStatusCallback(mCellAgent,
- BLOCKED_METERED_REASON_USER_RESTRICTED);
+ cellNetworkCallback.expect(BLOCKED_STATUS, mCellAgent, cb -> cb.getBlocked());
+ detailedCallback.expect(BLOCKED_STATUS_INT, mCellAgent,
+ cb -> cb.getReason() == BLOCKED_METERED_REASON_USER_RESTRICTED);
setBlockedReasonChanged(BLOCKED_REASON_NONE);
- cellNetworkCallback.expectBlockedStatusCallback(false, mCellAgent);
- detailedCallback.expectBlockedStatusCallback(mCellAgent, BLOCKED_REASON_NONE);
+ cellNetworkCallback.expect(BLOCKED_STATUS, mCellAgent, cb -> !cb.getBlocked());
+ detailedCallback.expect(BLOCKED_STATUS_INT, mCellAgent,
+ cb -> cb.getReason() == BLOCKED_REASON_NONE);
assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetwork());
assertActiveNetworkInfo(TYPE_MOBILE, DetailedState.CONNECTED);
assertNetworkInfo(TYPE_MOBILE, DetailedState.CONNECTED);
assertExtraInfoFromCmPresent(mCellAgent);
setBlockedReasonChanged(BLOCKED_METERED_REASON_DATA_SAVER);
- cellNetworkCallback.expectBlockedStatusCallback(true, mCellAgent);
- detailedCallback.expectBlockedStatusCallback(mCellAgent, BLOCKED_METERED_REASON_DATA_SAVER);
+ cellNetworkCallback.expect(BLOCKED_STATUS, mCellAgent, cb -> cb.getBlocked());
+ detailedCallback.expect(BLOCKED_STATUS_INT, mCellAgent,
+ cb -> cb.getReason() == BLOCKED_METERED_REASON_DATA_SAVER);
assertNull(mCm.getActiveNetwork());
assertActiveNetworkInfo(TYPE_MOBILE, DetailedState.BLOCKED);
assertNetworkInfo(TYPE_MOBILE, DetailedState.BLOCKED);
@@ -9220,28 +9451,34 @@
// Restrict the network based on UID rule and NOT_METERED capability change.
mCellAgent.addCapability(NET_CAPABILITY_NOT_METERED);
- cellNetworkCallback.expectCapabilitiesWith(NET_CAPABILITY_NOT_METERED, mCellAgent);
- cellNetworkCallback.expectBlockedStatusCallback(false, mCellAgent);
- detailedCallback.expectCapabilitiesWith(NET_CAPABILITY_NOT_METERED, mCellAgent);
- detailedCallback.expectBlockedStatusCallback(mCellAgent, BLOCKED_REASON_NONE);
+ cellNetworkCallback.expectCaps(mCellAgent,
+ c -> c.hasCapability(NET_CAPABILITY_NOT_METERED));
+ cellNetworkCallback.expect(BLOCKED_STATUS, mCellAgent, cb -> !cb.getBlocked());
+ detailedCallback.expectCaps(mCellAgent, c -> c.hasCapability(NET_CAPABILITY_NOT_METERED));
+ detailedCallback.expect(BLOCKED_STATUS_INT, mCellAgent,
+ cb -> cb.getReason() == BLOCKED_REASON_NONE);
assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetwork());
assertActiveNetworkInfo(TYPE_MOBILE, DetailedState.CONNECTED);
assertNetworkInfo(TYPE_MOBILE, DetailedState.CONNECTED);
assertExtraInfoFromCmPresent(mCellAgent);
mCellAgent.removeCapability(NET_CAPABILITY_NOT_METERED);
- cellNetworkCallback.expectCapabilitiesWithout(NET_CAPABILITY_NOT_METERED, mCellAgent);
- cellNetworkCallback.expectBlockedStatusCallback(true, mCellAgent);
- detailedCallback.expectCapabilitiesWithout(NET_CAPABILITY_NOT_METERED, mCellAgent);
- detailedCallback.expectBlockedStatusCallback(mCellAgent, BLOCKED_METERED_REASON_DATA_SAVER);
+ cellNetworkCallback.expectCaps(mCellAgent,
+ c -> !c.hasCapability(NET_CAPABILITY_NOT_METERED));
+ cellNetworkCallback.expect(BLOCKED_STATUS, mCellAgent, cb -> cb.getBlocked());
+ detailedCallback.expectCaps(mCellAgent,
+ c -> !c.hasCapability(NET_CAPABILITY_NOT_METERED));
+ detailedCallback.expect(BLOCKED_STATUS_INT, mCellAgent,
+ cb -> cb.getReason() == BLOCKED_METERED_REASON_DATA_SAVER);
assertNull(mCm.getActiveNetwork());
assertActiveNetworkInfo(TYPE_MOBILE, DetailedState.BLOCKED);
assertNetworkInfo(TYPE_MOBILE, DetailedState.BLOCKED);
assertExtraInfoFromCmBlocked(mCellAgent);
setBlockedReasonChanged(BLOCKED_REASON_NONE);
- cellNetworkCallback.expectBlockedStatusCallback(false, mCellAgent);
- detailedCallback.expectBlockedStatusCallback(mCellAgent, BLOCKED_REASON_NONE);
+ cellNetworkCallback.expect(BLOCKED_STATUS, mCellAgent, cb -> !cb.getBlocked());
+ detailedCallback.expect(BLOCKED_STATUS_INT, mCellAgent,
+ cb -> cb.getReason() == BLOCKED_REASON_NONE);
assertEquals(mCellAgent.getNetwork(), mCm.getActiveNetwork());
assertActiveNetworkInfo(TYPE_MOBILE, DetailedState.CONNECTED);
assertNetworkInfo(TYPE_MOBILE, DetailedState.CONNECTED);
@@ -9253,8 +9490,9 @@
// Restrict background data. Networking is not blocked because the network is unmetered.
setBlockedReasonChanged(BLOCKED_METERED_REASON_DATA_SAVER);
- cellNetworkCallback.expectBlockedStatusCallback(true, mCellAgent);
- detailedCallback.expectBlockedStatusCallback(mCellAgent, BLOCKED_METERED_REASON_DATA_SAVER);
+ cellNetworkCallback.expect(BLOCKED_STATUS, mCellAgent, cb -> cb.getBlocked());
+ detailedCallback.expect(BLOCKED_STATUS_INT, mCellAgent,
+ cb -> cb.getReason() == BLOCKED_METERED_REASON_DATA_SAVER);
assertNull(mCm.getActiveNetwork());
assertActiveNetworkInfo(TYPE_MOBILE, DetailedState.BLOCKED);
assertNetworkInfo(TYPE_MOBILE, DetailedState.BLOCKED);
@@ -9263,8 +9501,9 @@
cellNetworkCallback.assertNoCallback();
setBlockedReasonChanged(BLOCKED_REASON_NONE);
- cellNetworkCallback.expectBlockedStatusCallback(false, mCellAgent);
- detailedCallback.expectBlockedStatusCallback(mCellAgent, BLOCKED_REASON_NONE);
+ cellNetworkCallback.expect(BLOCKED_STATUS, mCellAgent, cb -> !cb.getBlocked());
+ detailedCallback.expect(BLOCKED_STATUS_INT, mCellAgent,
+ cb -> cb.getReason() == BLOCKED_REASON_NONE);
assertActiveNetworkInfo(TYPE_MOBILE, DetailedState.CONNECTED);
assertNetworkInfo(TYPE_MOBILE, DetailedState.CONNECTED);
assertExtraInfoFromCmPresent(mCellAgent);
@@ -9295,7 +9534,7 @@
mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
mCellAgent.connect(true);
defaultCallback.expectAvailableCallbacksUnvalidatedAndBlocked(mCellAgent);
- defaultCallback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mCellAgent);
+ defaultCallback.expectCaps(mCellAgent, c -> c.hasCapability(NET_CAPABILITY_VALIDATED));
// Allow to use the network after switching to NOT_METERED network.
mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
@@ -9310,8 +9549,8 @@
// Network becomes NOT_METERED.
mCellAgent.addCapability(NET_CAPABILITY_NOT_METERED);
- defaultCallback.expectCapabilitiesWith(NET_CAPABILITY_NOT_METERED, mCellAgent);
- defaultCallback.expectBlockedStatusCallback(false, mCellAgent);
+ defaultCallback.expectCaps(mCellAgent, c -> c.hasCapability(NET_CAPABILITY_NOT_METERED));
+ defaultCallback.expect(BLOCKED_STATUS, mCellAgent, cb -> !cb.getBlocked());
// Verify there's no Networkcallbacks invoked after data saver on/off.
setBlockedReasonChanged(BLOCKED_METERED_REASON_DATA_SAVER);
@@ -9452,8 +9691,8 @@
// Disable lockdown, expect to see the network unblocked.
mMockVpn.setAlwaysOnPackage(null, false /* lockdown */, allowList);
- callback.expectBlockedStatusCallback(false, mWiFiAgent);
- defaultCallback.expectBlockedStatusCallback(false, mWiFiAgent);
+ callback.expect(BLOCKED_STATUS, mWiFiAgent, cb -> !cb.getBlocked());
+ defaultCallback.expect(BLOCKED_STATUS, mWiFiAgent, cb -> !cb.getBlocked());
vpnUidCallback.assertNoCallback();
vpnUidDefaultCallback.assertNoCallback();
vpnDefaultCallbackAsUid.assertNoCallback();
@@ -9511,7 +9750,7 @@
mMockVpn.setAlwaysOnPackage(ALWAYS_ON_PACKAGE, true /* lockdown */, allowList);
waitForIdle();
expectNetworkRejectNonSecureVpn(inOrder, true, uidRangeParcels);
- defaultCallback.expectBlockedStatusCallback(true, mWiFiAgent);
+ defaultCallback.expect(BLOCKED_STATUS, mWiFiAgent, cb -> cb.getBlocked());
assertBlockedCallbackInAnyOrder(callback, true, mWiFiAgent, mCellAgent);
vpnUidCallback.assertNoCallback();
vpnUidDefaultCallback.assertNoCallback();
@@ -9524,7 +9763,7 @@
// Disable lockdown. Everything is unblocked.
mMockVpn.setAlwaysOnPackage(null, false /* lockdown */, allowList);
- defaultCallback.expectBlockedStatusCallback(false, mWiFiAgent);
+ defaultCallback.expect(BLOCKED_STATUS, mWiFiAgent, cb -> !cb.getBlocked());
assertBlockedCallbackInAnyOrder(callback, false, mWiFiAgent, mCellAgent);
vpnUidCallback.assertNoCallback();
vpnUidDefaultCallback.assertNoCallback();
@@ -9565,7 +9804,7 @@
// Enable lockdown and connect a VPN. The VPN is not blocked.
mMockVpn.setAlwaysOnPackage(ALWAYS_ON_PACKAGE, true /* lockdown */, allowList);
- defaultCallback.expectBlockedStatusCallback(true, mWiFiAgent);
+ defaultCallback.expect(BLOCKED_STATUS, mWiFiAgent, cb -> cb.getBlocked());
assertBlockedCallbackInAnyOrder(callback, true, mWiFiAgent, mCellAgent);
vpnUidCallback.assertNoCallback();
vpnUidDefaultCallback.assertNoCallback();
@@ -10049,7 +10288,7 @@
// changes back to cellular.
mWiFiAgent.removeCapability(testCap);
callbackWithCap.expectAvailableCallbacksValidated(mCellAgent);
- callbackWithoutCap.expectCapabilitiesWithout(testCap, mWiFiAgent);
+ callbackWithoutCap.expectCaps(mWiFiAgent, c -> !c.hasCapability(testCap));
verify(mMockNetd).networkSetDefault(eq(mCellAgent.getNetwork().netId));
reset(mMockNetd);
@@ -10319,19 +10558,19 @@
// Expect clatd to be stopped and started with the new prefix.
mService.mResolverUnsolEventCallback.onNat64PrefixEvent(makeNat64PrefixEvent(
cellNetId, PREFIX_OPERATION_ADDED, kOtherNat64PrefixString, 96));
- networkCallback.expectLinkPropertiesThat(mCellAgent,
- (lp) -> lp.getStackedLinks().size() == 0);
+ networkCallback.expect(LINK_PROPERTIES_CHANGED, mCellAgent,
+ cb -> cb.getLp().getStackedLinks().size() == 0);
verifyClatdStop(null /* inOrder */, MOBILE_IFNAME);
assertRoutesRemoved(cellNetId, stackedDefault);
verify(mMockNetd, times(1)).networkRemoveInterface(cellNetId, CLAT_MOBILE_IFNAME);
verifyClatdStart(null /* inOrder */, MOBILE_IFNAME, cellNetId,
kOtherNat64Prefix.toString());
- networkCallback.expectLinkPropertiesThat(mCellAgent,
- (lp) -> lp.getNat64Prefix().equals(kOtherNat64Prefix));
+ networkCallback.expect(LINK_PROPERTIES_CHANGED, mCellAgent,
+ cb -> cb.getLp().getNat64Prefix().equals(kOtherNat64Prefix));
clat.interfaceLinkStateChanged(CLAT_MOBILE_IFNAME, true);
- networkCallback.expectLinkPropertiesThat(mCellAgent,
- (lp) -> lp.getStackedLinks().size() == 1);
+ networkCallback.expect(LINK_PROPERTIES_CHANGED, mCellAgent,
+ cb -> cb.getLp().getStackedLinks().size() == 1);
assertRoutesAdded(cellNetId, stackedDefault);
verify(mMockNetd, times(1)).networkAddInterface(cellNetId, CLAT_MOBILE_IFNAME);
reset(mMockNetd);
@@ -10372,7 +10611,8 @@
// Stopping prefix discovery causes netd to tell us that the NAT64 prefix is gone.
mService.mResolverUnsolEventCallback.onNat64PrefixEvent(makeNat64PrefixEvent(
cellNetId, PREFIX_OPERATION_REMOVED, kOtherNat64PrefixString, 96));
- networkCallback.expectLinkPropertiesThat(mCellAgent, lp -> lp.getNat64Prefix() == null);
+ networkCallback.expect(LINK_PROPERTIES_CHANGED, mCellAgent,
+ cb -> cb.getLp().getNat64Prefix() == null);
// Remove IPv4 address and expect prefix discovery and clatd to be started again.
cellLp.removeLinkAddress(myIpv4);
@@ -10389,22 +10629,24 @@
// Clat iface comes up. Expect stacked link to be added.
clat.interfaceLinkStateChanged(CLAT_MOBILE_IFNAME, true);
- networkCallback.expectLinkPropertiesThat(mCellAgent,
- lp -> lp.getStackedLinks().size() == 1 && lp.getNat64Prefix() != null);
+ networkCallback.expect(LINK_PROPERTIES_CHANGED, mCellAgent,
+ cb -> cb.getLp().getStackedLinks().size() == 1
+ && cb.getLp().getNat64Prefix() != null);
assertRoutesAdded(cellNetId, stackedDefault);
verify(mMockNetd, times(1)).networkAddInterface(cellNetId, CLAT_MOBILE_IFNAME);
// NAT64 prefix is removed. Expect that clat is stopped.
mService.mResolverUnsolEventCallback.onNat64PrefixEvent(makeNat64PrefixEvent(
cellNetId, PREFIX_OPERATION_REMOVED, kNat64PrefixString, 96));
- networkCallback.expectLinkPropertiesThat(mCellAgent,
- lp -> lp.getStackedLinks().size() == 0 && lp.getNat64Prefix() == null);
+ networkCallback.expect(LINK_PROPERTIES_CHANGED, mCellAgent,
+ cb -> cb.getLp().getStackedLinks().size() == 0
+ && cb.getLp().getNat64Prefix() == null);
assertRoutesRemoved(cellNetId, ipv4Subnet, stackedDefault);
// Stop has no effect because clat is already stopped.
verifyClatdStop(null /* inOrder */, MOBILE_IFNAME);
- networkCallback.expectLinkPropertiesThat(mCellAgent,
- lp -> lp.getStackedLinks().size() == 0);
+ networkCallback.expect(LINK_PROPERTIES_CHANGED, mCellAgent,
+ cb -> cb.getLp().getStackedLinks().size() == 0);
verify(mMockNetd, times(1)).networkRemoveInterface(cellNetId, CLAT_MOBILE_IFNAME);
verify(mMockNetd, times(1)).interfaceGetCfg(CLAT_MOBILE_IFNAME);
// Clean up.
@@ -10414,7 +10656,11 @@
verify(mMockNetd, times(1)).idletimerRemoveInterface(eq(MOBILE_IFNAME), anyInt(),
eq(Integer.toString(TRANSPORT_CELLULAR)));
verify(mMockNetd).networkDestroy(cellNetId);
- verify(mMockNetd).setNetworkAllowlist(any());
+ if (SdkLevel.isAtLeastU()) {
+ verify(mMockNetd).setNetworkAllowlist(any());
+ } else {
+ verify(mMockNetd, never()).setNetworkAllowlist(any());
+ }
verifyNoMoreInteractions(mMockNetd);
verifyNoMoreInteractions(mClatCoordinator);
reset(mMockNetd);
@@ -10438,9 +10684,9 @@
verifyClatdStart(null /* inOrder */, MOBILE_IFNAME, cellNetId, kNat64Prefix.toString());
clat = getNat464Xlat(mCellAgent);
clat.interfaceLinkStateChanged(CLAT_MOBILE_IFNAME, true /* up */);
- networkCallback.expectLinkPropertiesThat(mCellAgent,
- lp -> lp.getStackedLinks().size() == 1
- && lp.getNat64Prefix().equals(kNat64Prefix));
+ networkCallback.expect(LINK_PROPERTIES_CHANGED, mCellAgent,
+ cb -> cb.getLp().getStackedLinks().size() == 1
+ && cb.getLp().getNat64Prefix().equals(kNat64Prefix));
verify(mMockNetd).networkAddInterface(cellNetId, CLAT_MOBILE_IFNAME);
// assertRoutesAdded sees all calls since last mMockNetd reset, so expect IPv6 routes again.
assertRoutesAdded(cellNetId, ipv6Subnet, ipv6Default, stackedDefault);
@@ -10455,7 +10701,11 @@
verify(mMockNetd).idletimerRemoveInterface(eq(MOBILE_IFNAME), anyInt(),
eq(Integer.toString(TRANSPORT_CELLULAR)));
verify(mMockNetd).networkDestroy(cellNetId);
- verify(mMockNetd).setNetworkAllowlist(any());
+ if (SdkLevel.isAtLeastU()) {
+ verify(mMockNetd).setNetworkAllowlist(any());
+ } else {
+ verify(mMockNetd, never()).setNetworkAllowlist(any());
+ }
verifyNoMoreInteractions(mMockNetd);
verifyNoMoreInteractions(mClatCoordinator);
@@ -10464,7 +10714,8 @@
private void expectNat64PrefixChange(TestNetworkCallback callback,
TestNetworkAgentWrapper agent, IpPrefix prefix) {
- callback.expectLinkPropertiesThat(agent, x -> Objects.equals(x.getNat64Prefix(), prefix));
+ callback.expect(LINK_PROPERTIES_CHANGED, agent,
+ x -> Objects.equals(x.getLp().getNat64Prefix(), prefix));
}
@Test
@@ -10699,7 +10950,7 @@
mWiFiAgent.connect(true);
networkCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
networkCallback.expectLosing(mCellAgent);
- networkCallback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiAgent);
+ networkCallback.expectCaps(mWiFiAgent, c -> c.hasCapability(NET_CAPABILITY_VALIDATED));
verify(mMockNetd, times(1)).idletimerAddInterface(eq(WIFI_IFNAME), anyInt(),
eq(Integer.toString(TRANSPORT_WIFI)));
verify(mMockNetd, times(1)).idletimerRemoveInterface(eq(MOBILE_IFNAME), anyInt(),
@@ -10723,7 +10974,7 @@
mWiFiAgent.connect(true);
networkCallback.expectAvailableCallbacksUnvalidated(mWiFiAgent);
networkCallback.expectLosing(mCellAgent);
- networkCallback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiAgent);
+ networkCallback.expectCaps(mWiFiAgent, c -> c.hasCapability(NET_CAPABILITY_VALIDATED));
verify(mMockNetd, times(1)).idletimerAddInterface(eq(WIFI_IFNAME), anyInt(),
eq(Integer.toString(TRANSPORT_WIFI)));
verify(mMockNetd, times(1)).idletimerRemoveInterface(eq(MOBILE_IFNAME), anyInt(),
@@ -12103,7 +12354,8 @@
lp.addRoute(rio1);
lp.addRoute(defaultRoute);
mCellAgent.sendLinkProperties(lp);
- networkCallback.expectLinkPropertiesThat(mCellAgent, x -> x.getRoutes().size() == 3);
+ networkCallback.expect(LINK_PROPERTIES_CHANGED, mCellAgent,
+ x -> x.getLp().getRoutes().size() == 3);
assertRoutesAdded(netId, direct, rio1, defaultRoute);
reset(mMockNetd);
@@ -12118,7 +12370,8 @@
assertTrue(lp.getRoutes().contains(defaultWithMtu));
mCellAgent.sendLinkProperties(lp);
- networkCallback.expectLinkPropertiesThat(mCellAgent, x -> x.getRoutes().contains(rio2));
+ networkCallback.expect(LINK_PROPERTIES_CHANGED, mCellAgent,
+ x -> x.getLp().getRoutes().contains(rio2));
assertRoutesRemoved(netId, rio1);
assertRoutesAdded(netId, rio2);
@@ -12397,7 +12650,7 @@
// sees the network come up and validate later
allNetworksCb.expectAvailableCallbacksUnvalidated(mWiFiAgent);
allNetworksCb.expectLosing(mCellAgent);
- allNetworksCb.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiAgent);
+ allNetworksCb.expectCaps(mWiFiAgent, c -> c.hasCapability(NET_CAPABILITY_VALIDATED));
allNetworksCb.expect(LOST, mCellAgent, TEST_LINGER_DELAY_MS * 2);
// The cell network has disconnected (see LOST above) because it was outscored and
@@ -15763,7 +16016,11 @@
mCellAgent.getNetwork().netId,
toUidRangeStableParcels(allowedRanges),
0 /* subPriority */);
- inOrder.verify(mMockNetd).setNetworkAllowlist(new NativeUidRangeConfig[] { config1User });
+ if (SdkLevel.isAtLeastU()) {
+ inOrder.verify(mMockNetd).setNetworkAllowlist(new NativeUidRangeConfig[]{config1User});
+ } else {
+ inOrder.verify(mMockNetd, never()).setNetworkAllowlist(any());
+ }
doReturn(asList(PRIMARY_USER_HANDLE, SECONDARY_USER_HANDLE))
.when(mUserManager).getUserHandles(anyBoolean());
@@ -15777,7 +16034,11 @@
mCellAgent.getNetwork().netId,
toUidRangeStableParcels(allowedRanges),
0 /* subPriority */);
- inOrder.verify(mMockNetd).setNetworkAllowlist(new NativeUidRangeConfig[] { config2Users });
+ if (SdkLevel.isAtLeastU()) {
+ inOrder.verify(mMockNetd).setNetworkAllowlist(new NativeUidRangeConfig[]{config2Users});
+ } else {
+ inOrder.verify(mMockNetd, never()).setNetworkAllowlist(any());
+ }
}
@Test
@@ -15804,8 +16065,12 @@
mCellAgent.getNetwork().netId,
allowAllUidRangesParcel,
0 /* subPriority */);
- inOrder.verify(mMockNetd).setNetworkAllowlist(
- new NativeUidRangeConfig[]{cellAllAllowedConfig});
+ if (SdkLevel.isAtLeastU()) {
+ inOrder.verify(mMockNetd).setNetworkAllowlist(
+ new NativeUidRangeConfig[]{cellAllAllowedConfig});
+ } else {
+ inOrder.verify(mMockNetd, never()).setNetworkAllowlist(any());
+ }
// Verify the same uid ranges are also applied for enterprise network.
final TestNetworkAgentWrapper enterpriseAgent = makeEnterpriseNetworkAgent(
@@ -15819,9 +16084,13 @@
// making the order of the list undeterministic. Thus, verify this in order insensitive way.
final ArgumentCaptor<NativeUidRangeConfig[]> configsCaptor = ArgumentCaptor.forClass(
NativeUidRangeConfig[].class);
- inOrder.verify(mMockNetd).setNetworkAllowlist(configsCaptor.capture());
- assertContainsAll(List.of(configsCaptor.getValue()),
- List.of(cellAllAllowedConfig, enterpriseAllAllowedConfig));
+ if (SdkLevel.isAtLeastU()) {
+ inOrder.verify(mMockNetd).setNetworkAllowlist(configsCaptor.capture());
+ assertContainsAll(List.of(configsCaptor.getValue()),
+ List.of(cellAllAllowedConfig, enterpriseAllAllowedConfig));
+ } else {
+ inOrder.verify(mMockNetd, never()).setNetworkAllowlist(any());
+ }
// Setup profile preference which only applies to test app uid on the managed profile.
ProfileNetworkPreference.Builder prefBuilder = new ProfileNetworkPreference.Builder();
@@ -15849,24 +16118,36 @@
mCellAgent.getNetwork().netId,
excludeAppRangesParcel,
0 /* subPriority */);
- inOrder.verify(mMockNetd).setNetworkAllowlist(configsCaptor.capture());
- assertContainsAll(List.of(configsCaptor.getValue()),
- List.of(cellExcludeAppConfig, enterpriseAllAllowedConfig));
+ if (SdkLevel.isAtLeastU()) {
+ inOrder.verify(mMockNetd).setNetworkAllowlist(configsCaptor.capture());
+ assertContainsAll(List.of(configsCaptor.getValue()),
+ List.of(cellExcludeAppConfig, enterpriseAllAllowedConfig));
+ } else {
+ inOrder.verify(mMockNetd, never()).setNetworkAllowlist(any());
+ }
// Verify unset by giving all allowed set for all users when the preference got removed.
mCm.setProfileNetworkPreference(testHandle, PROFILE_NETWORK_PREFERENCE_ENTERPRISE,
r -> r.run(), listener);
listener.expectOnComplete();
- inOrder.verify(mMockNetd).setNetworkAllowlist(configsCaptor.capture());
- assertContainsAll(List.of(configsCaptor.getValue()),
- List.of(cellAllAllowedConfig, enterpriseAllAllowedConfig));
+ if (SdkLevel.isAtLeastU()) {
+ inOrder.verify(mMockNetd).setNetworkAllowlist(configsCaptor.capture());
+ assertContainsAll(List.of(configsCaptor.getValue()),
+ List.of(cellAllAllowedConfig, enterpriseAllAllowedConfig));
+ } else {
+ inOrder.verify(mMockNetd, never()).setNetworkAllowlist(any());
+ }
// Verify issuing with cellular set only when a network with enterprise capability
// disconnects.
enterpriseAgent.disconnect();
waitForIdle();
- inOrder.verify(mMockNetd).setNetworkAllowlist(
- new NativeUidRangeConfig[]{cellAllAllowedConfig});
+ if (SdkLevel.isAtLeastU()) {
+ inOrder.verify(mMockNetd).setNetworkAllowlist(
+ new NativeUidRangeConfig[]{cellAllAllowedConfig});
+ } else {
+ inOrder.verify(mMockNetd, never()).setNetworkAllowlist(any());
+ }
}
@Test
@@ -15886,7 +16167,11 @@
List.of(prefBuilder.build()),
r -> r.run(), listener);
listener.expectOnComplete();
- inOrder.verify(mMockNetd).setNetworkAllowlist(new NativeUidRangeConfig[]{});
+ if (SdkLevel.isAtLeastU()) {
+ inOrder.verify(mMockNetd).setNetworkAllowlist(new NativeUidRangeConfig[]{});
+ } else {
+ inOrder.verify(mMockNetd, never()).setNetworkAllowlist(any());
+ }
// Start with 1 default network, which should be restricted since the blocking
// preference is already set.
@@ -15910,8 +16195,12 @@
mCellAgent.getNetwork().netId,
excludeAppRangesParcel,
0 /* subPriority */);
- inOrder.verify(mMockNetd).setNetworkAllowlist(
- new NativeUidRangeConfig[]{cellExcludeAppConfig});
+ if (SdkLevel.isAtLeastU()) {
+ inOrder.verify(mMockNetd).setNetworkAllowlist(
+ new NativeUidRangeConfig[]{cellExcludeAppConfig});
+ } else {
+ inOrder.verify(mMockNetd, never()).setNetworkAllowlist(any());
+ }
// Verify enterprise network is not blocked for test app.
final TestNetworkAgentWrapper enterpriseAgent = makeEnterpriseNetworkAgent(
@@ -15930,19 +16219,31 @@
// making the order of the list undeterministic. Thus, verify this in order insensitive way.
final ArgumentCaptor<NativeUidRangeConfig[]> configsCaptor = ArgumentCaptor.forClass(
NativeUidRangeConfig[].class);
- inOrder.verify(mMockNetd).setNetworkAllowlist(configsCaptor.capture());
- assertContainsAll(List.of(configsCaptor.getValue()),
- List.of(enterpriseAllAllowedConfig, cellExcludeAppConfig));
+ if (SdkLevel.isAtLeastU()) {
+ inOrder.verify(mMockNetd).setNetworkAllowlist(configsCaptor.capture());
+ assertContainsAll(List.of(configsCaptor.getValue()),
+ List.of(enterpriseAllAllowedConfig, cellExcludeAppConfig));
+ } else {
+ inOrder.verify(mMockNetd, never()).setNetworkAllowlist(any());
+ }
// Verify issuing with cellular set only when enterprise network disconnects.
enterpriseAgent.disconnect();
waitForIdle();
- inOrder.verify(mMockNetd).setNetworkAllowlist(
- new NativeUidRangeConfig[]{cellExcludeAppConfig});
+ if (SdkLevel.isAtLeastU()) {
+ inOrder.verify(mMockNetd).setNetworkAllowlist(
+ new NativeUidRangeConfig[]{cellExcludeAppConfig});
+ } else {
+ inOrder.verify(mMockNetd, never()).setNetworkAllowlist(any());
+ }
mCellAgent.disconnect();
waitForIdle();
- inOrder.verify(mMockNetd).setNetworkAllowlist(new NativeUidRangeConfig[]{});
+ if (SdkLevel.isAtLeastU()) {
+ inOrder.verify(mMockNetd).setNetworkAllowlist(new NativeUidRangeConfig[]{});
+ } else {
+ inOrder.verify(mMockNetd, never()).setNetworkAllowlist(any());
+ }
}
/**
@@ -17114,15 +17415,17 @@
mCm.reportNetworkConnectivity(mWiFiAgent.getNetwork(), false);
// Wi-Fi is now detected to have a portal : cell should become the default network.
mDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellAgent);
- wifiNetworkCallback.expectCapabilitiesWithout(NET_CAPABILITY_VALIDATED, mWiFiAgent);
- wifiNetworkCallback.expectCapabilitiesWith(NET_CAPABILITY_CAPTIVE_PORTAL, mWiFiAgent);
+ wifiNetworkCallback.expectCaps(mWiFiAgent,
+ c -> !c.hasCapability(NET_CAPABILITY_VALIDATED));
+ wifiNetworkCallback.expectCaps(mWiFiAgent,
+ c -> c.hasCapability(NET_CAPABILITY_CAPTIVE_PORTAL));
// Wi-Fi becomes valid again. The default network goes back to Wi-Fi.
mWiFiAgent.setNetworkValid(false /* privateDnsProbeSent */);
mCm.reportNetworkConnectivity(mWiFiAgent.getNetwork(), true);
mDefaultNetworkCallback.expectAvailableCallbacksValidated(mWiFiAgent);
- wifiNetworkCallback.expectCapabilitiesWithout(NET_CAPABILITY_CAPTIVE_PORTAL,
- mWiFiAgent);
+ wifiNetworkCallback.expectCaps(mWiFiAgent,
+ c -> !c.hasCapability(NET_CAPABILITY_CAPTIVE_PORTAL));
// Wi-Fi roaming from wifiNc2 to wifiNc1, and the network now has partial connectivity.
mWiFiAgent.setNetworkCapabilities(wifiNc1, true);
@@ -17133,15 +17436,15 @@
// Wi-Fi now only offers partial connectivity, so in the absence of accepting partial
// connectivity explicitly for this network, it loses default status to cell.
mDefaultNetworkCallback.expectAvailableCallbacksValidated(mCellAgent);
- wifiNetworkCallback.expectCapabilitiesWith(NET_CAPABILITY_PARTIAL_CONNECTIVITY,
- mWiFiAgent);
+ wifiNetworkCallback.expectCaps(mWiFiAgent,
+ c -> c.hasCapability(NET_CAPABILITY_PARTIAL_CONNECTIVITY));
// Wi-Fi becomes valid again. The default network goes back to Wi-Fi.
mWiFiAgent.setNetworkValid(false /* privateDnsProbeSent */);
mCm.reportNetworkConnectivity(mWiFiAgent.getNetwork(), true);
mDefaultNetworkCallback.expectAvailableCallbacksValidated(mWiFiAgent);
- wifiNetworkCallback.expectCapabilitiesWithout(NET_CAPABILITY_PARTIAL_CONNECTIVITY,
- mWiFiAgent);
+ wifiNetworkCallback.expectCaps(mWiFiAgent,
+ c -> !c.hasCapability(NET_CAPABILITY_PARTIAL_CONNECTIVITY));
}
mCm.unregisterNetworkCallback(wifiNetworkCallback);
diff --git a/tests/unit/java/com/android/server/IpSecServiceTest.java b/tests/unit/java/com/android/server/IpSecServiceTest.java
index 6955620..4b6857c 100644
--- a/tests/unit/java/com/android/server/IpSecServiceTest.java
+++ b/tests/unit/java/com/android/server/IpSecServiceTest.java
@@ -82,7 +82,7 @@
private static final int MAX_NUM_ENCAP_SOCKETS = 100;
private static final int MAX_NUM_SPIS = 100;
private static final int TEST_UDP_ENCAP_INVALID_PORT = 100;
- private static final int TEST_UDP_ENCAP_PORT_OUT_RANGE = 100000;
+ private static final int TEST_UDP_ENCAP_PORT_OUT_RANGE = 200000;
private static final InetAddress INADDR_ANY;
diff --git a/tests/unit/java/com/android/server/NsdServiceTest.java b/tests/unit/java/com/android/server/NsdServiceTest.java
index 5a3bc64..3dc5647 100644
--- a/tests/unit/java/com/android/server/NsdServiceTest.java
+++ b/tests/unit/java/com/android/server/NsdServiceTest.java
@@ -21,6 +21,7 @@
import static android.net.nsd.NsdManager.FAILURE_INTERNAL_ERROR;
import static android.net.nsd.NsdManager.FAILURE_OPERATION_NOT_RUNNING;
+import static com.android.server.NsdService.constructServiceType;
import static com.android.testutils.ContextUtils.mockService;
import static libcore.junit.util.compat.CoreCompatChangeRule.DisableCompatChanges;
@@ -53,6 +54,7 @@
import android.content.Context;
import android.net.INetd;
import android.net.Network;
+import android.net.connectivity.ConnectivityCompatChanges;
import android.net.mdns.aidl.DiscoveryInfo;
import android.net.mdns.aidl.GetAddressInfo;
import android.net.mdns.aidl.IMDnsEventListener;
@@ -187,7 +189,7 @@
}
@Test
- @DisableCompatChanges(NsdManager.RUN_NATIVE_NSD_ONLY_IF_LEGACY_APPS_T_AND_LATER)
+ @DisableCompatChanges(ConnectivityCompatChanges.RUN_NATIVE_NSD_ONLY_IF_LEGACY_APPS_T_AND_LATER)
public void testPreSClients() throws Exception {
// Pre S client connected, the daemon should be started.
connectClient(mService);
@@ -214,7 +216,7 @@
}
@Test
- @EnableCompatChanges(NsdManager.RUN_NATIVE_NSD_ONLY_IF_LEGACY_APPS_T_AND_LATER)
+ @EnableCompatChanges(ConnectivityCompatChanges.RUN_NATIVE_NSD_ONLY_IF_LEGACY_APPS_T_AND_LATER)
public void testNoDaemonStartedWhenClientsConnect() throws Exception {
// Creating an NsdManager will not cause daemon startup.
connectClient(mService);
@@ -248,7 +250,7 @@
}
@Test
- @EnableCompatChanges(NsdManager.RUN_NATIVE_NSD_ONLY_IF_LEGACY_APPS_T_AND_LATER)
+ @EnableCompatChanges(ConnectivityCompatChanges.RUN_NATIVE_NSD_ONLY_IF_LEGACY_APPS_T_AND_LATER)
public void testClientRequestsAreGCedAtDisconnection() throws Exception {
final NsdManager client = connectClient(mService);
final INsdManagerCallback cb1 = getCallback();
@@ -291,7 +293,7 @@
}
@Test
- @EnableCompatChanges(NsdManager.RUN_NATIVE_NSD_ONLY_IF_LEGACY_APPS_T_AND_LATER)
+ @EnableCompatChanges(ConnectivityCompatChanges.RUN_NATIVE_NSD_ONLY_IF_LEGACY_APPS_T_AND_LATER)
public void testCleanupDelayNoRequestActive() throws Exception {
final NsdManager client = connectClient(mService);
@@ -894,8 +896,8 @@
List.of(), /* subtypes */
new String[] {"android", "local"}, /* hostName */
12345, /* port */
- IPV4_ADDRESS,
- IPV6_ADDRESS,
+ List.of(IPV4_ADDRESS),
+ List.of(IPV6_ADDRESS),
List.of(), /* textStrings */
List.of(), /* textEntries */
1234, /* interfaceIndex */
@@ -914,8 +916,8 @@
null, /* subtypes */
null, /* hostName */
0, /* port */
- null, /* ipv4Address */
- null, /* ipv6Address */
+ List.of(), /* ipv4Address */
+ List.of(), /* ipv6Address */
null, /* textStrings */
null, /* textEntries */
1234, /* interfaceIndex */
@@ -931,7 +933,7 @@
waitForIdle();
verify(mDiscoveryManager).unregisterListener(eq(serviceTypeWithLocalDomain), any());
verify(discListener, timeout(TIMEOUT_MS)).onDiscoveryStopped(SERVICE_TYPE);
- verify(mSocketProvider, timeout(CLEANUP_DELAY_MS + TIMEOUT_MS)).stopMonitoringSockets();
+ verify(mSocketProvider, timeout(CLEANUP_DELAY_MS + TIMEOUT_MS)).requestStopWhenInactive();
}
@Test
@@ -980,7 +982,9 @@
waitForIdle();
verify(mSocketProvider).startMonitoringSockets();
verify(mDiscoveryManager).registerListener(eq(constructedServiceType),
- listenerCaptor.capture(), argThat(options -> network.equals(options.getNetwork())));
+ listenerCaptor.capture(), argThat(options ->
+ network.equals(options.getNetwork())
+ && SERVICE_NAME.equals(options.getResolveInstanceName())));
final MdnsServiceBrowserListener listener = listenerCaptor.getValue();
final MdnsServiceInfo mdnsServiceInfo = new MdnsServiceInfo(
@@ -989,8 +993,8 @@
List.of(), /* subtypes */
new String[]{"android", "local"}, /* hostName */
PORT,
- IPV4_ADDRESS,
- IPV6_ADDRESS,
+ List.of(IPV4_ADDRESS),
+ List.of("2001:db8::1", "2001:db8::2"),
List.of() /* textStrings */,
List.of(MdnsServiceInfo.TextEntry.fromBytes(new byte[]{
'k', 'e', 'y', '=', (byte) 0xFF, (byte) 0xFE})) /* textEntries */,
@@ -1010,12 +1014,17 @@
assertEquals(1, info.getAttributes().size());
assertArrayEquals(new byte[]{(byte) 0xFF, (byte) 0xFE}, info.getAttributes().get("key"));
assertEquals(parseNumericAddress(IPV4_ADDRESS), info.getHost());
+ assertEquals(3, info.getHostAddresses().size());
+ assertTrue(info.getHostAddresses().stream().anyMatch(
+ address -> address.equals(parseNumericAddress("2001:db8::1"))));
+ assertTrue(info.getHostAddresses().stream().anyMatch(
+ address -> address.equals(parseNumericAddress("2001:db8::2"))));
assertEquals(network, info.getNetwork());
// Verify the listener has been unregistered.
verify(mDiscoveryManager, timeout(TIMEOUT_MS))
.unregisterListener(eq(constructedServiceType), any());
- verify(mSocketProvider, timeout(CLEANUP_DELAY_MS + TIMEOUT_MS)).stopMonitoringSockets();
+ verify(mSocketProvider, timeout(CLEANUP_DELAY_MS + TIMEOUT_MS)).requestStopWhenInactive();
}
@Test
@@ -1054,6 +1063,54 @@
}
@Test
+ public void testTypeSpecificFeatureFlagging() {
+ doReturn("_type1._tcp:flag1,_type2._tcp:flag2").when(mDeps).getTypeAllowlistFlags();
+ doReturn(true).when(mDeps).isFeatureEnabled(any(),
+ eq("mdns_discovery_manager_allowlist_flag1_version"));
+ doReturn(true).when(mDeps).isFeatureEnabled(any(),
+ eq("mdns_advertiser_allowlist_flag2_version"));
+
+ final NsdManager client = connectClient(mService);
+ final NsdServiceInfo service1 = new NsdServiceInfo(SERVICE_NAME, "_type1._tcp");
+ service1.setHostAddresses(List.of(parseNumericAddress("2001:db8::123")));
+ service1.setPort(1234);
+ final NsdServiceInfo service2 = new NsdServiceInfo(SERVICE_NAME, "_type2._tcp");
+ service2.setHostAddresses(List.of(parseNumericAddress("2001:db8::123")));
+ service2.setPort(1234);
+
+ client.discoverServices(service1.getServiceType(),
+ NsdManager.PROTOCOL_DNS_SD, mock(DiscoveryListener.class));
+ client.discoverServices(service2.getServiceType(),
+ NsdManager.PROTOCOL_DNS_SD, mock(DiscoveryListener.class));
+ waitForIdle();
+
+ // The DiscoveryManager is enabled for _type1 but not _type2
+ verify(mDiscoveryManager).registerListener(eq("_type1._tcp.local"), any(), any());
+ verify(mDiscoveryManager, never()).registerListener(
+ eq("_type2._tcp.local"), any(), any());
+
+ client.resolveService(service1, mock(ResolveListener.class));
+ client.resolveService(service2, mock(ResolveListener.class));
+ waitForIdle();
+
+ // Same behavior for resolve
+ verify(mDiscoveryManager, times(2)).registerListener(
+ eq("_type1._tcp.local"), any(), any());
+ verify(mDiscoveryManager, never()).registerListener(
+ eq("_type2._tcp.local"), any(), any());
+
+ client.registerService(service1, NsdManager.PROTOCOL_DNS_SD,
+ mock(RegistrationListener.class));
+ client.registerService(service2, NsdManager.PROTOCOL_DNS_SD,
+ mock(RegistrationListener.class));
+ waitForIdle();
+
+ // The advertiser is enabled for _type2 but not _type1
+ verify(mAdvertiser, never()).addService(anyInt(), argThat(info -> matches(info, service1)));
+ verify(mAdvertiser).addService(anyInt(), argThat(info -> matches(info, service2)));
+ }
+
+ @Test
public void testAdvertiseWithMdnsAdvertiser() {
setMdnsAdvertiserEnabled();
@@ -1089,7 +1146,7 @@
verify(mAdvertiser).removeService(idCaptor.getValue());
verify(regListener, timeout(TIMEOUT_MS)).onServiceUnregistered(
argThat(info -> matches(info, regInfo)));
- verify(mSocketProvider, timeout(TIMEOUT_MS)).stopMonitoringSockets();
+ verify(mSocketProvider, timeout(TIMEOUT_MS)).requestStopWhenInactive();
}
@Test
@@ -1149,6 +1206,50 @@
argThat(info -> matches(info, new NsdServiceInfo(regInfo.getServiceName(), null))));
}
+ @Test
+ public void testStopServiceResolutionWithMdnsDiscoveryManager() {
+ setMdnsDiscoveryManagerEnabled();
+
+ final NsdManager client = connectClient(mService);
+ final ResolveListener resolveListener = mock(ResolveListener.class);
+ final Network network = new Network(999);
+ final String serviceType = "_nsd._service._tcp";
+ final String constructedServiceType = "_nsd._sub._service._tcp.local";
+ final ArgumentCaptor<MdnsServiceBrowserListener> listenerCaptor =
+ ArgumentCaptor.forClass(MdnsServiceBrowserListener.class);
+ final NsdServiceInfo request = new NsdServiceInfo(SERVICE_NAME, serviceType);
+ request.setNetwork(network);
+ client.resolveService(request, resolveListener);
+ waitForIdle();
+ verify(mSocketProvider).startMonitoringSockets();
+ verify(mDiscoveryManager).registerListener(eq(constructedServiceType),
+ listenerCaptor.capture(), argThat(options -> network.equals(options.getNetwork())));
+
+ client.stopServiceResolution(resolveListener);
+ waitForIdle();
+
+ // Verify the listener has been unregistered.
+ verify(mDiscoveryManager, timeout(TIMEOUT_MS))
+ .unregisterListener(eq(constructedServiceType), eq(listenerCaptor.getValue()));
+ verify(resolveListener, timeout(TIMEOUT_MS)).onResolutionStopped(argThat(ns ->
+ request.getServiceName().equals(ns.getServiceName())
+ && request.getServiceType().equals(ns.getServiceType())));
+ verify(mSocketProvider, timeout(CLEANUP_DELAY_MS + TIMEOUT_MS)).requestStopWhenInactive();
+ }
+
+ @Test
+ public void testConstructServiceType() {
+ final String serviceType1 = "test._tcp";
+ final String serviceType2 = "_test._quic";
+ final String serviceType3 = "_123._udp.";
+ final String serviceType4 = "_TEST._999._tcp.";
+
+ assertEquals(null, constructServiceType(serviceType1));
+ assertEquals(null, constructServiceType(serviceType2));
+ assertEquals("_123._udp", constructServiceType(serviceType3));
+ assertEquals("_TEST._sub._999._tcp", constructServiceType(serviceType4));
+ }
+
private void waitForIdle() {
HandlerUtils.waitForIdle(mHandler, TIMEOUT_MS);
}
diff --git a/tests/unit/java/com/android/server/connectivity/ApplicationSelfCertifiedNetworkCapabilitiesTest.kt b/tests/unit/java/com/android/server/connectivity/ApplicationSelfCertifiedNetworkCapabilitiesTest.kt
new file mode 100644
index 0000000..f2d7aaa
--- /dev/null
+++ b/tests/unit/java/com/android/server/connectivity/ApplicationSelfCertifiedNetworkCapabilitiesTest.kt
@@ -0,0 +1,96 @@
+/*
+ * 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 com.android.server.connectivity
+
+import android.net.NetworkCapabilities
+import android.os.Build
+import androidx.test.InstrumentationRegistry
+import androidx.test.filters.SmallTest
+import com.android.frameworks.tests.net.R
+import com.android.testutils.DevSdkIgnoreRule
+import com.android.testutils.DevSdkIgnoreRunner
+import com.google.common.truth.Truth.assertThat
+import kotlin.test.assertFailsWith
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(DevSdkIgnoreRunner::class)
+@SmallTest
+@DevSdkIgnoreRule.IgnoreUpTo(Build.VERSION_CODES.R)
+class ApplicationSelfCertifiedNetworkCapabilitiesTest {
+ private val mResource = InstrumentationRegistry.getContext().getResources()
+ private val bandwidthCapability = NetworkCapabilities.Builder().apply {
+ addCapability(NetworkCapabilities.NET_CAPABILITY_PRIORITIZE_BANDWIDTH)
+ }.build()
+ private val latencyCapability = NetworkCapabilities.Builder().apply {
+ addCapability(NetworkCapabilities.NET_CAPABILITY_PRIORITIZE_LATENCY)
+ }.build()
+ private val emptyCapability = NetworkCapabilities.Builder().build()
+ private val bothCapabilities = NetworkCapabilities.Builder().apply {
+ addCapability(NetworkCapabilities.NET_CAPABILITY_PRIORITIZE_BANDWIDTH)
+ addCapability(NetworkCapabilities.NET_CAPABILITY_PRIORITIZE_LATENCY)
+ }.build()
+
+ @Test
+ fun parseXmlWithWrongTag_shouldIgnoreWrongTag() {
+ val parser = mResource.getXml(
+ R.xml.self_certified_capabilities_wrong_tag
+ )
+ val selfDeclaredCaps = ApplicationSelfCertifiedNetworkCapabilities.createFromXml(parser)
+ selfDeclaredCaps.enforceSelfCertifiedNetworkCapabilitiesDeclared(latencyCapability)
+ selfDeclaredCaps.enforceSelfCertifiedNetworkCapabilitiesDeclared(bandwidthCapability)
+ }
+
+ @Test
+ fun parseXmlWithWrongDeclaration_shouldThrowException() {
+ val parser = mResource.getXml(
+ R.xml.self_certified_capabilities_wrong_declaration
+ )
+ val exception = assertFailsWith<InvalidTagException> {
+ ApplicationSelfCertifiedNetworkCapabilities.createFromXml(parser)
+ }
+ assertThat(exception.message).contains("network-capabilities-declaration1")
+ }
+
+ @Test
+ fun checkIfSelfCertifiedNetworkCapabilitiesDeclared_shouldThrowExceptionWhenNoDeclaration() {
+ val parser = mResource.getXml(R.xml.self_certified_capabilities_other)
+ val selfDeclaredCaps = ApplicationSelfCertifiedNetworkCapabilities.createFromXml(parser)
+ val exception1 = assertFailsWith<SecurityException> {
+ selfDeclaredCaps.enforceSelfCertifiedNetworkCapabilitiesDeclared(latencyCapability)
+ }
+ assertThat(exception1.message).contains(
+ ApplicationSelfCertifiedNetworkCapabilities.PRIORITIZE_LATENCY
+ )
+ val exception2 = assertFailsWith<SecurityException> {
+ selfDeclaredCaps.enforceSelfCertifiedNetworkCapabilitiesDeclared(bandwidthCapability)
+ }
+ assertThat(exception2.message).contains(
+ ApplicationSelfCertifiedNetworkCapabilities.PRIORITIZE_BANDWIDTH
+ )
+ }
+
+ @Test
+ fun checkIfSelfCertifiedNetworkCapabilitiesDeclared_shouldPassIfDeclarationExist() {
+ val parser = mResource.getXml(R.xml.self_certified_capabilities_both)
+ val selfDeclaredCaps = ApplicationSelfCertifiedNetworkCapabilities.createFromXml(parser)
+ selfDeclaredCaps.enforceSelfCertifiedNetworkCapabilitiesDeclared(latencyCapability)
+ selfDeclaredCaps.enforceSelfCertifiedNetworkCapabilitiesDeclared(bandwidthCapability)
+ selfDeclaredCaps.enforceSelfCertifiedNetworkCapabilitiesDeclared(bothCapabilities)
+ selfDeclaredCaps.enforceSelfCertifiedNetworkCapabilitiesDeclared(emptyCapability)
+ }
+}
diff --git a/tests/unit/java/com/android/server/connectivity/AutomaticOnOffKeepaliveTrackerTest.java b/tests/unit/java/com/android/server/connectivity/AutomaticOnOffKeepaliveTrackerTest.java
index 6c29d6e..4f0b9c4 100644
--- a/tests/unit/java/com/android/server/connectivity/AutomaticOnOffKeepaliveTrackerTest.java
+++ b/tests/unit/java/com/android/server/connectivity/AutomaticOnOffKeepaliveTrackerTest.java
@@ -16,31 +16,70 @@
package com.android.server.connectivity;
+import static android.content.pm.PackageManager.PERMISSION_GRANTED;
+import static android.net.ConnectivityManager.TYPE_MOBILE;
+import static android.net.NetworkCapabilities.TRANSPORT_CELLULAR;
+
+import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertThrows;
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyBoolean;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyLong;
+import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import android.app.AlarmManager;
import android.content.Context;
+import android.content.res.Resources;
+import android.net.ConnectivityResources;
import android.net.INetd;
+import android.net.ISocketKeepaliveCallback;
+import android.net.KeepalivePacketData;
+import android.net.LinkAddress;
+import android.net.LinkProperties;
import android.net.MarkMaskParcel;
+import android.net.NattKeepalivePacketData;
+import android.net.Network;
+import android.net.NetworkAgent;
+import android.net.NetworkCapabilities;
+import android.net.NetworkInfo;
+import android.os.Binder;
import android.os.Build;
+import android.os.Handler;
import android.os.HandlerThread;
+import android.os.IBinder;
+import android.os.Looper;
+import android.os.Message;
import android.test.suitebuilder.annotation.SmallTest;
+import android.util.Log;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.android.server.connectivity.KeepaliveTracker.KeepaliveInfo;
import com.android.testutils.DevSdkIgnoreRule;
import com.android.testutils.DevSdkIgnoreRunner;
+import com.android.testutils.HandlerUtils;
import libcore.util.HexEncoding;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
+import java.io.FileDescriptor;
+import java.net.InetAddress;
+import java.net.Socket;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
@@ -48,17 +87,22 @@
@SmallTest
@DevSdkIgnoreRule.IgnoreUpTo(Build.VERSION_CODES.TIRAMISU)
public class AutomaticOnOffKeepaliveTrackerTest {
+ private static final String TAG = AutomaticOnOffKeepaliveTrackerTest.class.getSimpleName();
private static final int TEST_NETID = 0xA85;
private static final int TEST_NETID_FWMARK = 0x0A85;
private static final int OTHER_NETID = 0x1A85;
private static final int NETID_MASK = 0xffff;
+ private static final int TIMEOUT_MS = 30_000;
+ private static final int MOCK_RESOURCE_ID = 5;
private AutomaticOnOffKeepaliveTracker mAOOKeepaliveTracker;
private HandlerThread mHandlerThread;
@Mock INetd mNetd;
@Mock AutomaticOnOffKeepaliveTracker.Dependencies mDependencies;
@Mock Context mCtx;
- @Mock KeepaliveTracker mKeepaliveTracker;
+ @Mock AlarmManager mAlarmManager;
+ TestKeepaliveTracker mKeepaliveTracker;
+ AOOTestHandler mTestHandler;
// Hexadecimal representation of a SOCK_DIAG response with tcp info.
private static final String SOCK_DIAG_TCP_INET_HEX =
@@ -157,11 +201,46 @@
private static final byte[] TEST_RESPONSE_BYTES =
HexEncoding.decode(TEST_RESPONSE_HEX.toCharArray(), false);
+ private class TestKeepaliveTracker extends KeepaliveTracker {
+ private KeepaliveInfo mKi;
+
+ TestKeepaliveTracker(@NonNull final Context context, @NonNull final Handler handler) {
+ super(context, handler);
+ }
+
+ public void setReturnedKeepaliveInfo(@NonNull final KeepaliveInfo ki) {
+ mKi = ki;
+ }
+
+ @NonNull
+ @Override
+ public KeepaliveInfo makeNattKeepaliveInfo(@Nullable final NetworkAgentInfo nai,
+ @Nullable final FileDescriptor fd, final int intervalSeconds,
+ @NonNull final ISocketKeepaliveCallback cb, @NonNull final String srcAddrString,
+ final int srcPort,
+ @NonNull final String dstAddrString, final int dstPort) {
+ if (null == mKi) {
+ throw new IllegalStateException("Must call setReturnedKeepaliveInfo");
+ }
+ return mKi;
+ }
+ }
+
@Before
public void setup() throws Exception {
MockitoAnnotations.initMocks(this);
+ doReturn(PERMISSION_GRANTED).when(mCtx).checkPermission(any() /* permission */,
+ anyInt() /* pid */, anyInt() /* uid */);
+ ConnectivityResources.setResourcesContextForTest(mCtx);
+ final Resources mockResources = mock(Resources.class);
+ doReturn(MOCK_RESOURCE_ID).when(mockResources).getIdentifier(any() /* name */,
+ any() /* defType */, any() /* defPackage */);
+ doReturn(new String[] { "0,3", "3,3" }).when(mockResources)
+ .getStringArray(MOCK_RESOURCE_ID);
+ doReturn(mockResources).when(mCtx).getResources();
doReturn(mNetd).when(mDependencies).getNetd();
+ doReturn(mAlarmManager).when(mDependencies).getAlarmManager(any());
doReturn(makeMarkMaskParcel(NETID_MASK, TEST_NETID_FWMARK)).when(mNetd)
.getFwmarkForNetwork(TEST_NETID);
@@ -169,11 +248,34 @@
mHandlerThread = new HandlerThread("KeepaliveTrackerTest");
mHandlerThread.start();
- doReturn(mKeepaliveTracker).when(mDependencies).newKeepaliveTracker(
- mCtx, mHandlerThread.getThreadHandler());
- doReturn(true).when(mDependencies).isFeatureEnabled(any());
- mAOOKeepaliveTracker = new AutomaticOnOffKeepaliveTracker(
- mCtx, mHandlerThread.getThreadHandler(), mDependencies);
+ mTestHandler = new AOOTestHandler(mHandlerThread.getLooper());
+ mKeepaliveTracker = new TestKeepaliveTracker(mCtx, mTestHandler);
+ doReturn(mKeepaliveTracker).when(mDependencies).newKeepaliveTracker(mCtx, mTestHandler);
+ doReturn(true).when(mDependencies).isFeatureEnabled(any(), anyBoolean());
+ mAOOKeepaliveTracker =
+ new AutomaticOnOffKeepaliveTracker(mCtx, mTestHandler, mDependencies);
+ }
+
+ private final class AOOTestHandler extends Handler {
+ public AutomaticOnOffKeepaliveTracker.AutomaticOnOffKeepalive mLastAutoKi = null;
+
+ AOOTestHandler(@NonNull final Looper looper) {
+ super(looper);
+ }
+
+ @Override
+ public void handleMessage(@NonNull final Message msg) {
+ switch (msg.what) {
+ case NetworkAgent.CMD_START_SOCKET_KEEPALIVE:
+ Log.d(TAG, "Test handler received CMD_START_SOCKET_KEEPALIVE : " + msg);
+ mAOOKeepaliveTracker.handleStartKeepalive(msg);
+ break;
+ case NetworkAgent.CMD_MONITOR_AUTOMATIC_KEEPALIVE:
+ Log.d(TAG, "Test handler received CMD_MONITOR_AUTOMATIC_KEEPALIVE : " + msg);
+ mLastAutoKi = mAOOKeepaliveTracker.getKeepaliveForBinder((IBinder) msg.obj);
+ break;
+ }
+ }
}
@Test
@@ -186,24 +288,79 @@
@Test
public void testIsAnyTcpSocketConnected_withTargetNetId() throws Exception {
setupResponseWithSocketExisting();
- mHandlerThread.getThreadHandler().post(
+ mTestHandler.post(
() -> assertTrue(mAOOKeepaliveTracker.isAnyTcpSocketConnected(TEST_NETID)));
}
@Test
public void testIsAnyTcpSocketConnected_withIncorrectNetId() throws Exception {
setupResponseWithSocketExisting();
- mHandlerThread.getThreadHandler().post(
+ mTestHandler.post(
() -> assertFalse(mAOOKeepaliveTracker.isAnyTcpSocketConnected(OTHER_NETID)));
}
@Test
public void testIsAnyTcpSocketConnected_noSocketExists() throws Exception {
setupResponseWithoutSocketExisting();
- mHandlerThread.getThreadHandler().post(
+ mTestHandler.post(
() -> assertFalse(mAOOKeepaliveTracker.isAnyTcpSocketConnected(TEST_NETID)));
}
+ @Test
+ public void testAlarm() throws Exception {
+ final InetAddress srcAddress = InetAddress.getByAddress(
+ new byte[] { (byte) 192, 0, 0, (byte) 129 });
+ final int srcPort = 12345;
+ final InetAddress dstAddress = InetAddress.getByAddress(new byte[] { 8, 8, 8, 8});
+ final int dstPort = 12345;
+
+ final NetworkAgentInfo nai = mock(NetworkAgentInfo.class);
+ nai.networkCapabilities = new NetworkCapabilities.Builder()
+ .addTransportType(TRANSPORT_CELLULAR).build();
+ nai.networkInfo = new NetworkInfo(TYPE_MOBILE, 0 /* subtype */, "LTE", "LTE");
+ nai.networkInfo.setDetailedState(NetworkInfo.DetailedState.CONNECTED, "test reason",
+ "test extra info");
+ nai.linkProperties = new LinkProperties();
+ nai.linkProperties.addLinkAddress(new LinkAddress(srcAddress, 24));
+
+ final Socket socket = new Socket();
+ socket.bind(null);
+ final FileDescriptor fd = socket.getFileDescriptor$();
+ final IBinder binder = new Binder();
+ final ISocketKeepaliveCallback cb = mock(ISocketKeepaliveCallback.class);
+ doReturn(binder).when(cb).asBinder();
+ final Network underpinnedNetwork = mock(Network.class);
+
+ final KeepalivePacketData kpd = new NattKeepalivePacketData(srcAddress, srcPort,
+ dstAddress, dstPort, new byte[] {1});
+ final KeepaliveInfo ki = mKeepaliveTracker.new KeepaliveInfo(cb, nai, kpd,
+ 10 /* interval */, KeepaliveInfo.TYPE_NATT, fd);
+ mKeepaliveTracker.setReturnedKeepaliveInfo(ki);
+
+ mAOOKeepaliveTracker.startNattKeepalive(nai, fd, 10 /* intervalSeconds */, cb,
+ srcAddress.toString(), srcPort, dstAddress.toString(), dstPort,
+ true /* automaticOnOffKeepalives */, underpinnedNetwork);
+ HandlerUtils.waitForIdle(mTestHandler, TIMEOUT_MS);
+
+ final ArgumentCaptor<AlarmManager.OnAlarmListener> listenerCaptor =
+ ArgumentCaptor.forClass(AlarmManager.OnAlarmListener.class);
+ verify(mAlarmManager).setExact(eq(AlarmManager.ELAPSED_REALTIME), anyLong(),
+ any(), listenerCaptor.capture(), eq(mTestHandler));
+ final AlarmManager.OnAlarmListener listener = listenerCaptor.getValue();
+
+ // For realism, the listener should be posted on the handler
+ mTestHandler.post(() -> listener.onAlarm());
+ // Wait for the listener to be called. The listener enqueues a message to the handler.
+ HandlerUtils.waitForIdle(mTestHandler, TIMEOUT_MS);
+ // Wait for the message posted by the listener to be processed.
+ HandlerUtils.waitForIdle(mTestHandler, TIMEOUT_MS);
+
+ assertNotNull(mTestHandler.mLastAutoKi);
+ assertEquals(cb, mTestHandler.mLastAutoKi.getCallback());
+ assertEquals(underpinnedNetwork, mTestHandler.mLastAutoKi.getUnderpinnedNetwork());
+ socket.close();
+ }
+
private void setupResponseWithSocketExisting() throws Exception {
final ByteBuffer tcpBufferV6 = getByteBuffer(TEST_RESPONSE_BYTES);
final ByteBuffer tcpBufferV4 = getByteBuffer(TEST_RESPONSE_BYTES);
diff --git a/tests/unit/java/com/android/server/connectivity/IpConnectivityMetricsTest.java b/tests/unit/java/com/android/server/connectivity/IpConnectivityMetricsTest.java
index 719314a..5881a8e 100644
--- a/tests/unit/java/com/android/server/connectivity/IpConnectivityMetricsTest.java
+++ b/tests/unit/java/com/android/server/connectivity/IpConnectivityMetricsTest.java
@@ -80,6 +80,7 @@
private static final byte[] MAC_ADDR =
{(byte)0x84, (byte)0xc9, (byte)0xb2, (byte)0x6a, (byte)0xed, (byte)0x4b};
+ private static final long NET_HANDLE = new Network(4291).getNetworkHandle();
@Mock Context mCtx;
@Mock IIpConnectivityMetrics mMockService;
@@ -607,7 +608,7 @@
void wakeupEvent(String iface, int uid, int ether, int ip, byte[] mac, String srcIp,
String dstIp, int sport, int dport, long now) throws Exception {
- String prefix = NetdEventListenerService.WAKEUP_EVENT_IFACE_PREFIX + iface;
+ String prefix = NET_HANDLE + ":" + iface;
mNetdListener.onWakeupEvent(prefix, uid, ether, ip, mac, srcIp, dstIp, sport, dport, now);
}
diff --git a/tests/unit/java/com/android/server/connectivity/NetdEventListenerServiceTest.java b/tests/unit/java/com/android/server/connectivity/NetdEventListenerServiceTest.java
index 7d6c3ae..f4b6464 100644
--- a/tests/unit/java/com/android/server/connectivity/NetdEventListenerServiceTest.java
+++ b/tests/unit/java/com/android/server/connectivity/NetdEventListenerServiceTest.java
@@ -60,6 +60,8 @@
private static final String EXAMPLE_IPV4 = "192.0.2.1";
private static final String EXAMPLE_IPV6 = "2001:db8:1200::2:1";
+ private static final long NET_HANDLE = new Network(5391).getNetworkHandle();
+
private static final byte[] MAC_ADDR =
{(byte)0x84, (byte)0xc9, (byte)0xb2, (byte)0x6a, (byte)0xed, (byte)0x4b};
@@ -498,7 +500,7 @@
void wakeupEvent(String iface, int uid, int ether, int ip, byte[] mac, String srcIp,
String dstIp, int sport, int dport, long now) throws Exception {
- String prefix = NetdEventListenerService.WAKEUP_EVENT_IFACE_PREFIX + iface;
+ String prefix = NET_HANDLE + ":" + iface;
mService.onWakeupEvent(prefix, uid, ether, ip, mac, srcIp, dstIp, sport, dport, now);
}
diff --git a/tests/unit/java/com/android/server/connectivity/VpnTest.java b/tests/unit/java/com/android/server/connectivity/VpnTest.java
index 3f87ffd..2d87728 100644
--- a/tests/unit/java/com/android/server/connectivity/VpnTest.java
+++ b/tests/unit/java/com/android/server/connectivity/VpnTest.java
@@ -27,11 +27,19 @@
import static android.net.INetd.IF_STATE_UP;
import static android.net.RouteInfo.RTN_UNREACHABLE;
import static android.net.VpnManager.TYPE_VPN_PLATFORM;
+import static android.net.cts.util.IkeSessionTestUtils.CHILD_PARAMS;
+import static android.net.cts.util.IkeSessionTestUtils.TEST_IDENTITY;
+import static android.net.cts.util.IkeSessionTestUtils.TEST_KEEPALIVE_TIMEOUT_UNSET;
+import static android.net.cts.util.IkeSessionTestUtils.getTestIkeSessionParams;
import static android.net.ipsec.ike.IkeSessionConfiguration.EXTENSION_TYPE_MOBIKE;
+import static android.net.ipsec.ike.IkeSessionParams.ESP_ENCAP_TYPE_AUTO;
+import static android.net.ipsec.ike.IkeSessionParams.ESP_IP_VERSION_AUTO;
import static android.os.Build.VERSION_CODES.S_V2;
import static android.os.UserHandle.PER_USER_RANGE;
import static com.android.net.module.util.NetworkStackConstants.IPV6_MIN_MTU;
+import static com.android.server.connectivity.Vpn.AUTOMATIC_KEEPALIVE_DELAY_SECONDS;
+import static com.android.server.connectivity.Vpn.DEFAULT_UDP_PORT_4500_NAT_TIMEOUT_SEC_INT;
import static com.android.testutils.Cleanup.testAndCleanup;
import static com.android.testutils.DevSdkIgnoreRule.IgnoreUpTo;
import static com.android.testutils.MiscAsserts.assertThrows;
@@ -106,10 +114,13 @@
import android.net.VpnTransportInfo;
import android.net.ipsec.ike.ChildSessionCallback;
import android.net.ipsec.ike.ChildSessionConfiguration;
+import android.net.ipsec.ike.IkeFqdnIdentification;
import android.net.ipsec.ike.IkeSessionCallback;
import android.net.ipsec.ike.IkeSessionConfiguration;
import android.net.ipsec.ike.IkeSessionConnectionInfo;
+import android.net.ipsec.ike.IkeSessionParams;
import android.net.ipsec.ike.IkeTrafficSelector;
+import android.net.ipsec.ike.IkeTunnelConnectionParams;
import android.net.ipsec.ike.exceptions.IkeException;
import android.net.ipsec.ike.exceptions.IkeNetworkLostException;
import android.net.ipsec.ike.exceptions.IkeNonProtocolException;
@@ -252,7 +263,8 @@
"VPNAPPEXCLUDED_27_com.testvpn.vpn";
static final String PKGS_BYTES = getPackageByteString(List.of(PKGS));
private static final Range<Integer> PRIMARY_USER_RANGE = uidRangeForUser(PRIMARY_USER.id);
-
+ // Same as IkeSessionParams#IKE_NATT_KEEPALIVE_DELAY_SEC_DEFAULT
+ private static final int IKE_NATT_KEEPALIVE_DELAY_SEC_DEFAULT = 10;
@Mock(answer = Answers.RETURNS_DEEP_STUBS) private Context mContext;
@Mock private UserManager mUserManager;
@Mock private PackageManager mPackageManager;
@@ -1812,6 +1824,11 @@
private PlatformVpnSnapshot verifySetupPlatformVpn(
IkeSessionConfiguration ikeConfig, boolean mtuSupportsIpv6) throws Exception {
+ return verifySetupPlatformVpn(mVpnProfile, ikeConfig, mtuSupportsIpv6);
+ }
+
+ private PlatformVpnSnapshot verifySetupPlatformVpn(VpnProfile vpnProfile,
+ IkeSessionConfiguration ikeConfig, boolean mtuSupportsIpv6) throws Exception {
if (!mtuSupportsIpv6) {
doReturn(IPV6_MIN_MTU - 1).when(mTestDeps).calculateVpnMtu(any(), anyInt(), anyInt(),
anyBoolean());
@@ -1820,10 +1837,11 @@
doReturn(mMockNetworkAgent).when(mTestDeps)
.newNetworkAgent(
any(), any(), anyString(), any(), any(), any(), any(), any(), any());
+ doReturn(TEST_NETWORK).when(mMockNetworkAgent).getNetwork();
final Vpn vpn = createVpnAndSetupUidChecks(AppOpsManager.OPSTR_ACTIVATE_PLATFORM_VPN);
when(mVpnProfileStore.get(vpn.getProfileNameForPackage(TEST_VPN_PKG)))
- .thenReturn(mVpnProfile.encode());
+ .thenReturn(vpnProfile.encode());
vpn.startVpnProfile(TEST_VPN_PKG);
final NetworkCallback nwCb = triggerOnAvailableAndGetCallback();
@@ -1850,7 +1868,7 @@
verify(mTestDeps).newNetworkAgent(
any(), any(), anyString(), ncCaptor.capture(), lpCaptor.capture(),
any(), nacCaptor.capture(), any(), any());
-
+ verify(mIkeSessionWrapper).setUnderpinnedNetwork(TEST_NETWORK);
// Check LinkProperties
final LinkProperties lp = lpCaptor.getValue();
final List<RouteInfo> expectedRoutes =
@@ -1906,6 +1924,109 @@
}
@Test
+ public void testMigrateIkeSessionFromIkeTunnConnParams_AutoTimerNoTimer()
+ throws Exception {
+ doTestMigrateIkeSession_FromIkeTunnConnParams(
+ false /* isAutomaticIpVersionSelectionEnabled */,
+ true /* isAutomaticNattKeepaliveTimerEnabled */,
+ TEST_KEEPALIVE_TIMEOUT_UNSET);
+ }
+
+ @Test
+ public void testMigrateIkeSessionFromIkeTunnConnParams_AutoTimerTimerSet()
+ throws Exception {
+ doTestMigrateIkeSession_FromIkeTunnConnParams(
+ false /* isAutomaticIpVersionSelectionEnabled */,
+ true /* isAutomaticNattKeepaliveTimerEnabled */,
+ 800 /* keepaliveTimeout */);
+ }
+
+ @Test
+ public void testMigrateIkeSessionFromIkeTunnConnParams_AutoIp()
+ throws Exception {
+ doTestMigrateIkeSession_FromIkeTunnConnParams(
+ true /* isAutomaticIpVersionSelectionEnabled */,
+ false /* isAutomaticNattKeepaliveTimerEnabled */,
+ TEST_KEEPALIVE_TIMEOUT_UNSET /* keepaliveTimeout */);
+ }
+
+ @Test
+ public void testMigrateIkeSession_FromNotIkeTunnConnParams_AutoTimer()
+ throws Exception {
+ doTestMigrateIkeSession_FromNotIkeTunnConnParams(
+ false /* isAutomaticIpVersionSelectionEnabled */,
+ true /* isAutomaticNattKeepaliveTimerEnabled */);
+ }
+
+ @Test
+ public void testMigrateIkeSession_FromNotIkeTunnConnParams_AutoIp()
+ throws Exception {
+ doTestMigrateIkeSession_FromNotIkeTunnConnParams(
+ true /* isAutomaticIpVersionSelectionEnabled */,
+ false /* isAutomaticNattKeepaliveTimerEnabled */);
+ }
+
+ private void doTestMigrateIkeSession_FromNotIkeTunnConnParams(
+ boolean isAutomaticIpVersionSelectionEnabled,
+ boolean isAutomaticNattKeepaliveTimerEnabled) throws Exception {
+ final Ikev2VpnProfile ikeProfile =
+ new Ikev2VpnProfile.Builder(TEST_VPN_SERVER, TEST_VPN_IDENTITY)
+ .setAuthPsk(TEST_VPN_PSK)
+ .setBypassable(true /* isBypassable */)
+ .setAutomaticNattKeepaliveTimerEnabled(isAutomaticNattKeepaliveTimerEnabled)
+ .setAutomaticIpVersionSelectionEnabled(isAutomaticIpVersionSelectionEnabled)
+ .build();
+
+ final int expectedKeepalive = isAutomaticNattKeepaliveTimerEnabled
+ ? AUTOMATIC_KEEPALIVE_DELAY_SECONDS
+ : DEFAULT_UDP_PORT_4500_NAT_TIMEOUT_SEC_INT;
+ doTestMigrateIkeSession(ikeProfile.toVpnProfile(), expectedKeepalive,
+ isAutomaticIpVersionSelectionEnabled);
+ }
+
+ private void doTestMigrateIkeSession_FromIkeTunnConnParams(
+ boolean isAutomaticIpVersionSelectionEnabled,
+ boolean isAutomaticNattKeepaliveTimerEnabled,
+ int keepaliveInProfile) throws Exception {
+ final IkeSessionParams ikeSessionParams = getTestIkeSessionParams(true /* testIpv6 */,
+ new IkeFqdnIdentification(TEST_IDENTITY), keepaliveInProfile);
+ final IkeTunnelConnectionParams tunnelParams =
+ new IkeTunnelConnectionParams(ikeSessionParams, CHILD_PARAMS);
+ final Ikev2VpnProfile ikeProfile = new Ikev2VpnProfile.Builder(tunnelParams)
+ .setBypassable(true)
+ .setAutomaticNattKeepaliveTimerEnabled(isAutomaticNattKeepaliveTimerEnabled)
+ .setAutomaticIpVersionSelectionEnabled(isAutomaticIpVersionSelectionEnabled)
+ .build();
+
+ final int expectedKeepalive = isAutomaticNattKeepaliveTimerEnabled
+ ? AUTOMATIC_KEEPALIVE_DELAY_SECONDS
+ : ikeSessionParams.getNattKeepAliveDelaySeconds();
+ doTestMigrateIkeSession(ikeProfile.toVpnProfile(), expectedKeepalive,
+ isAutomaticIpVersionSelectionEnabled);
+ }
+
+ private void doTestMigrateIkeSession(VpnProfile profile, int expectedKeepalive,
+ boolean isAutomaticIpVersionSelectionEnabled) throws Exception {
+ final int expectedIpVersion = isAutomaticIpVersionSelectionEnabled
+ ? ESP_IP_VERSION_AUTO : ESP_IP_VERSION_AUTO;
+ final int expectedEncapType = isAutomaticIpVersionSelectionEnabled
+ ? ESP_ENCAP_TYPE_AUTO : ESP_IP_VERSION_AUTO;
+
+ final PlatformVpnSnapshot vpnSnapShot =
+ verifySetupPlatformVpn(profile,
+ createIkeConfig(createIkeConnectInfo(), true /* isMobikeEnabled */),
+ false /* mtuSupportsIpv6 */);
+ // Mock new network comes up and the cleanup task is cancelled
+ vpnSnapShot.nwCb.onAvailable(TEST_NETWORK_2);
+
+ // Verify MOBIKE is triggered
+ verify(mIkeSessionWrapper).setNetwork(TEST_NETWORK_2,
+ expectedIpVersion, expectedEncapType, expectedKeepalive);
+
+ vpnSnapShot.vpn.mVpnRunner.exitVpnRunner();
+ }
+
+ @Test
public void testStartPlatformVpn_mtuDoesNotSupportIpv6() throws Exception {
final PlatformVpnSnapshot vpnSnapShot =
verifySetupPlatformVpn(
@@ -1932,7 +2053,10 @@
verify(mScheduledFuture).cancel(anyBoolean());
// Verify MOBIKE is triggered
- verify(mIkeSessionWrapper).setNetwork(TEST_NETWORK_2);
+ verify(mIkeSessionWrapper).setNetwork(eq(TEST_NETWORK_2),
+ eq(ESP_IP_VERSION_AUTO) /* ipVersion */,
+ eq(ESP_ENCAP_TYPE_AUTO) /* encapType */,
+ eq(DEFAULT_UDP_PORT_4500_NAT_TIMEOUT_SEC_INT) /* keepaliveDelay */);
// Mock the MOBIKE procedure
vpnSnapShot.ikeCb.onIkeSessionConnectionInfoChanged(createIkeConnectInfo_2());
@@ -2112,7 +2236,8 @@
private void verifyMobikeTriggered(List<Network> expected) {
final ArgumentCaptor<Network> networkCaptor = ArgumentCaptor.forClass(Network.class);
- verify(mIkeSessionWrapper).setNetwork(networkCaptor.capture());
+ verify(mIkeSessionWrapper).setNetwork(networkCaptor.capture(),
+ anyInt() /* ipVersion */, anyInt() /* encapType */, anyInt() /* keepaliveDelay */);
assertEquals(expected, Collections.singletonList(networkCaptor.getValue()));
}
@@ -2128,7 +2253,8 @@
connectivityDiagCallback.onDataStallSuspected(report);
// Should not trigger MOBIKE if MOBIKE is not enabled
- verify(mIkeSessionWrapper, never()).setNetwork(any());
+ verify(mIkeSessionWrapper, never()).setNetwork(any() /* network */,
+ anyInt() /* ipVersion */, anyInt() /* encapType */, anyInt() /* keepaliveDelay */);
}
@Test
@@ -2148,7 +2274,8 @@
// Expect to skip other data stall event if MOBIKE was started.
reset(mIkeSessionWrapper);
connectivityDiagCallback.onDataStallSuspected(report);
- verify(mIkeSessionWrapper, never()).setNetwork(any());
+ verify(mIkeSessionWrapper, never()).setNetwork(any() /* network */,
+ anyInt() /* ipVersion */, anyInt() /* encapType */, anyInt() /* keepaliveDelay */);
reset(mIkev2SessionCreator);
diff --git a/tests/unit/java/com/android/server/connectivity/mdns/MdnsAdvertiserTest.kt b/tests/unit/java/com/android/server/connectivity/mdns/MdnsAdvertiserTest.kt
index 1febe6d..375c150 100644
--- a/tests/unit/java/com/android/server/connectivity/mdns/MdnsAdvertiserTest.kt
+++ b/tests/unit/java/com/android/server/connectivity/mdns/MdnsAdvertiserTest.kt
@@ -42,6 +42,7 @@
import org.mockito.Mockito.doReturn
import org.mockito.Mockito.mock
import org.mockito.Mockito.never
+import org.mockito.Mockito.times
import org.mockito.Mockito.verify
private const val SERVICE_ID_1 = 1
@@ -51,6 +52,7 @@
private val TEST_LINKADDR = LinkAddress(TEST_ADDR, 64 /* prefixLength */)
private val TEST_NETWORK_1 = mock(Network::class.java)
private val TEST_NETWORK_2 = mock(Network::class.java)
+private val TEST_HOSTNAME = arrayOf("Android_test", "local")
private val SERVICE_1 = NsdServiceInfo("TestServiceName", "_advertisertest._tcp").apply {
port = 12345
@@ -81,10 +83,13 @@
@Before
fun setUp() {
thread.start()
+ doReturn(TEST_HOSTNAME).`when`(mockDeps).generateHostname()
doReturn(mockInterfaceAdvertiser1).`when`(mockDeps).makeAdvertiser(eq(mockSocket1),
- any(), any(), any(), any())
+ any(), any(), any(), any(), eq(TEST_HOSTNAME)
+ )
doReturn(mockInterfaceAdvertiser2).`when`(mockDeps).makeAdvertiser(eq(mockSocket2),
- any(), any(), any(), any())
+ any(), any(), any(), any(), eq(TEST_HOSTNAME)
+ )
doReturn(true).`when`(mockInterfaceAdvertiser1).isProbing(anyInt())
doReturn(true).`when`(mockInterfaceAdvertiser2).isProbing(anyInt())
}
@@ -106,8 +111,14 @@
postSync { socketCb.onSocketCreated(TEST_NETWORK_1, mockSocket1, listOf(TEST_LINKADDR)) }
val intAdvCbCaptor = ArgumentCaptor.forClass(MdnsInterfaceAdvertiser.Callback::class.java)
- verify(mockDeps).makeAdvertiser(eq(mockSocket1),
- eq(listOf(TEST_LINKADDR)), eq(thread.looper), any(), intAdvCbCaptor.capture())
+ verify(mockDeps).makeAdvertiser(
+ eq(mockSocket1),
+ eq(listOf(TEST_LINKADDR)),
+ eq(thread.looper),
+ any(),
+ intAdvCbCaptor.capture(),
+ eq(TEST_HOSTNAME)
+ )
doReturn(false).`when`(mockInterfaceAdvertiser1).isProbing(SERVICE_ID_1)
postSync { intAdvCbCaptor.value.onRegisterServiceSucceeded(
@@ -134,9 +145,11 @@
val intAdvCbCaptor1 = ArgumentCaptor.forClass(MdnsInterfaceAdvertiser.Callback::class.java)
val intAdvCbCaptor2 = ArgumentCaptor.forClass(MdnsInterfaceAdvertiser.Callback::class.java)
verify(mockDeps).makeAdvertiser(eq(mockSocket1), eq(listOf(TEST_LINKADDR)),
- eq(thread.looper), any(), intAdvCbCaptor1.capture())
+ eq(thread.looper), any(), intAdvCbCaptor1.capture(), eq(TEST_HOSTNAME)
+ )
verify(mockDeps).makeAdvertiser(eq(mockSocket2), eq(listOf(TEST_LINKADDR)),
- eq(thread.looper), any(), intAdvCbCaptor2.capture())
+ eq(thread.looper), any(), intAdvCbCaptor2.capture(), eq(TEST_HOSTNAME)
+ )
doReturn(false).`when`(mockInterfaceAdvertiser1).isProbing(SERVICE_ID_1)
postSync { intAdvCbCaptor1.value.onRegisterServiceSucceeded(
@@ -192,7 +205,8 @@
val intAdvCbCaptor = ArgumentCaptor.forClass(MdnsInterfaceAdvertiser.Callback::class.java)
verify(mockDeps).makeAdvertiser(eq(mockSocket1), eq(listOf(TEST_LINKADDR)),
- eq(thread.looper), any(), intAdvCbCaptor.capture())
+ eq(thread.looper), any(), intAdvCbCaptor.capture(), eq(TEST_HOSTNAME)
+ )
verify(mockInterfaceAdvertiser1).addService(eq(SERVICE_ID_1),
argThat { it.matches(SERVICE_1) })
verify(mockInterfaceAdvertiser1).addService(eq(SERVICE_ID_2),
@@ -216,6 +230,15 @@
verify(mockInterfaceAdvertiser1, atLeastOnce()).destroyNow()
}
+ @Test
+ fun testRemoveService_whenAllServiceRemoved_thenUpdateHostName() {
+ val advertiser = MdnsAdvertiser(thread.looper, socketProvider, cb, mockDeps)
+ verify(mockDeps, times(1)).generateHostname()
+ postSync { advertiser.addService(SERVICE_ID_1, SERVICE_1) }
+ postSync { advertiser.removeService(SERVICE_ID_1) }
+ verify(mockDeps, times(2)).generateHostname()
+ }
+
private fun postSync(r: () -> Unit) {
handler.post(r)
handler.waitForIdle(TIMEOUT_MS)
diff --git a/tests/unit/java/com/android/server/connectivity/mdns/MdnsDiscoveryManagerTests.java b/tests/unit/java/com/android/server/connectivity/mdns/MdnsDiscoveryManagerTests.java
index 83e7696..e6b8326 100644
--- a/tests/unit/java/com/android/server/connectivity/mdns/MdnsDiscoveryManagerTests.java
+++ b/tests/unit/java/com/android/server/connectivity/mdns/MdnsDiscoveryManagerTests.java
@@ -23,6 +23,7 @@
import static org.mockito.Mockito.when;
import android.annotation.NonNull;
+import android.net.Network;
import android.text.TextUtils;
import com.android.testutils.DevSdkIgnoreRule;
@@ -35,7 +36,10 @@
import org.mockito.MockitoAnnotations;
import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
import java.util.Collections;
+import java.util.List;
/** Tests for {@link MdnsDiscoveryManager}. */
@RunWith(DevSdkIgnoreRunner.class)
@@ -111,25 +115,38 @@
discoveryManager.registerListener(
SERVICE_TYPE_2, mockListenerTwo, MdnsSearchOptions.getDefaultOptions());
- MdnsResponse responseForServiceTypeOne = createMockResponse(SERVICE_TYPE_1);
- discoveryManager.onResponseReceived(responseForServiceTypeOne);
- verify(mockServiceTypeClientOne).processResponse(responseForServiceTypeOne);
+ MdnsPacket responseForServiceTypeOne = createMdnsPacket(SERVICE_TYPE_1);
+ final int ifIndex = 1;
+ final Network network = mock(Network.class);
+ discoveryManager.onResponseReceived(responseForServiceTypeOne, ifIndex, network);
+ verify(mockServiceTypeClientOne).processResponse(responseForServiceTypeOne, ifIndex,
+ network);
- MdnsResponse responseForServiceTypeTwo = createMockResponse(SERVICE_TYPE_2);
- discoveryManager.onResponseReceived(responseForServiceTypeTwo);
- verify(mockServiceTypeClientTwo).processResponse(responseForServiceTypeTwo);
+ MdnsPacket responseForServiceTypeTwo = createMdnsPacket(SERVICE_TYPE_2);
+ discoveryManager.onResponseReceived(responseForServiceTypeTwo, ifIndex, network);
+ verify(mockServiceTypeClientTwo).processResponse(responseForServiceTypeTwo, ifIndex,
+ network);
- MdnsResponse responseForSubtype = createMockResponse("subtype._sub._googlecast._tcp.local");
- discoveryManager.onResponseReceived(responseForSubtype);
- verify(mockServiceTypeClientOne).processResponse(responseForSubtype);
+ MdnsPacket responseForSubtype = createMdnsPacket("subtype._sub._googlecast._tcp.local");
+ discoveryManager.onResponseReceived(responseForSubtype, ifIndex, network);
+ verify(mockServiceTypeClientOne).processResponse(responseForSubtype, ifIndex, network);
}
- private MdnsResponse createMockResponse(String serviceType) {
- MdnsPointerRecord mockPointerRecord = mock(MdnsPointerRecord.class);
- MdnsResponse mockResponse = mock(MdnsResponse.class);
- when(mockResponse.getPointerRecords())
- .thenReturn(Collections.singletonList(mockPointerRecord));
- when(mockPointerRecord.getName()).thenReturn(TextUtils.split(serviceType, "\\."));
- return mockResponse;
+ private MdnsPacket createMdnsPacket(String serviceType) {
+ final String[] type = TextUtils.split(serviceType, "\\.");
+ final ArrayList<String> name = new ArrayList<>(type.length + 1);
+ name.add("TestName");
+ name.addAll(Arrays.asList(type));
+ return new MdnsPacket(0 /* flags */,
+ Collections.emptyList() /* questions */,
+ List.of(new MdnsPointerRecord(
+ type,
+ 0L /* receiptTimeMillis */,
+ false /* cacheFlush */,
+ 120000 /* ttlMillis */,
+ name.toArray(new String[0])
+ )) /* answers */,
+ Collections.emptyList() /* authorityRecords */,
+ Collections.emptyList() /* additionalRecords */);
}
}
\ No newline at end of file
diff --git a/tests/unit/java/com/android/server/connectivity/mdns/MdnsInterfaceAdvertiserTest.kt b/tests/unit/java/com/android/server/connectivity/mdns/MdnsInterfaceAdvertiserTest.kt
index 4a806b1..2d8d8f3 100644
--- a/tests/unit/java/com/android/server/connectivity/mdns/MdnsInterfaceAdvertiserTest.kt
+++ b/tests/unit/java/com/android/server/connectivity/mdns/MdnsInterfaceAdvertiserTest.kt
@@ -55,6 +55,7 @@
private val TEST_ADDRS = listOf(LinkAddress(parseNumericAddress("2001:db8::123"), 64))
private val TEST_BUFFER = ByteArray(1300)
+private val TEST_HOSTNAME = arrayOf("Android_test", "local")
private const val TEST_SERVICE_ID_1 = 42
private val TEST_SERVICE_1 = NsdServiceInfo().apply {
@@ -88,12 +89,23 @@
private val packetHandler get() = packetHandlerCaptor.value
private val advertiser by lazy {
- MdnsInterfaceAdvertiser(LOG_TAG, socket, TEST_ADDRS, thread.looper, TEST_BUFFER, cb, deps)
+ MdnsInterfaceAdvertiser(
+ LOG_TAG,
+ socket,
+ TEST_ADDRS,
+ thread.looper,
+ TEST_BUFFER,
+ cb,
+ deps,
+ TEST_HOSTNAME
+ )
}
@Before
fun setUp() {
- doReturn(repository).`when`(deps).makeRecordRepository(any())
+ doReturn(repository).`when`(deps).makeRecordRepository(any(),
+ eq(TEST_HOSTNAME)
+ )
doReturn(replySender).`when`(deps).makeReplySender(anyString(), any(), any(), any())
doReturn(announcer).`when`(deps).makeMdnsAnnouncer(anyString(), any(), any(), any())
doReturn(prober).`when`(deps).makeMdnsProber(anyString(), any(), any(), any())
diff --git a/tests/unit/java/com/android/server/connectivity/mdns/MdnsMultinetworkSocketClientTest.java b/tests/unit/java/com/android/server/connectivity/mdns/MdnsMultinetworkSocketClientTest.java
index 9d42a65..1e322e4 100644
--- a/tests/unit/java/com/android/server/connectivity/mdns/MdnsMultinetworkSocketClientTest.java
+++ b/tests/unit/java/com/android/server/connectivity/mdns/MdnsMultinetworkSocketClientTest.java
@@ -19,9 +19,9 @@
import static com.android.server.connectivity.mdns.MdnsSocketProvider.SocketCallback;
import static com.android.server.connectivity.mdns.MulticastPacketReader.PacketHandler;
-import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.eq;
import static org.mockito.Mockito.timeout;
@@ -146,16 +146,23 @@
// Send the data and verify the received records.
final PacketHandler handler = handlerCaptor.getValue();
handler.handlePacket(data, data.length, null /* src */);
- final ArgumentCaptor<MdnsResponse> responseCaptor =
- ArgumentCaptor.forClass(MdnsResponse.class);
- verify(mCallback).onResponseReceived(responseCaptor.capture());
- final MdnsResponse response = responseCaptor.getValue();
- assertTrue(response.hasPointerRecords());
- assertArrayEquals("_testtype._tcp.local".split("\\."),
- response.getPointerRecords().get(0).getName());
- assertTrue(response.hasServiceRecord());
- assertEquals("testservice", response.getServiceRecord().getServiceInstanceName());
- assertEquals("Android.local".split("\\."),
- response.getServiceRecord().getServiceHost());
+ final ArgumentCaptor<MdnsPacket> responseCaptor =
+ ArgumentCaptor.forClass(MdnsPacket.class);
+ verify(mCallback).onResponseReceived(responseCaptor.capture(), anyInt(), any());
+ final MdnsPacket response = responseCaptor.getValue();
+ assertEquals(0, response.questions.size());
+ assertEquals(0, response.additionalRecords.size());
+ assertEquals(0, response.authorityRecords.size());
+
+ final String[] serviceName = "testservice._testtype._tcp.local".split("\\.");
+ assertEquals(List.of(
+ new MdnsPointerRecord("_testtype._tcp.local".split("\\."),
+ 0L /* receiptTimeMillis */, false /* cacheFlush */, 4500000 /* ttlMillis */,
+ serviceName),
+ new MdnsServiceRecord(serviceName, 0L /* receiptTimeMillis */,
+ false /* cacheFlush */, 4500000 /* ttlMillis */, 0 /* servicePriority */,
+ 0 /* serviceWeight */, 31234 /* servicePort */,
+ new String[] { "Android", "local" } /* serviceHost */)
+ ), response.answers);
}
}
diff --git a/tests/unit/java/com/android/server/connectivity/mdns/MdnsRecordRepositoryTest.kt b/tests/unit/java/com/android/server/connectivity/mdns/MdnsRecordRepositoryTest.kt
index ecc11ec..5665091 100644
--- a/tests/unit/java/com/android/server/connectivity/mdns/MdnsRecordRepositoryTest.kt
+++ b/tests/unit/java/com/android/server/connectivity/mdns/MdnsRecordRepositoryTest.kt
@@ -67,7 +67,6 @@
class MdnsRecordRepositoryTest {
private val thread = HandlerThread(MdnsRecordRepositoryTest::class.simpleName)
private val deps = object : Dependencies() {
- override fun getHostname() = TEST_HOSTNAME
override fun getInterfaceInetAddresses(iface: NetworkInterface) =
Collections.enumeration(TEST_ADDRESSES.map { it.address })
}
@@ -84,7 +83,7 @@
@Test
fun testAddServiceAndProbe() {
- val repository = MdnsRecordRepository(thread.looper, deps)
+ val repository = MdnsRecordRepository(thread.looper, deps, TEST_HOSTNAME)
assertEquals(0, repository.servicesCount)
assertEquals(-1, repository.addService(TEST_SERVICE_ID_1, TEST_SERVICE_1))
assertEquals(1, repository.servicesCount)
@@ -117,7 +116,7 @@
@Test
fun testAddAndConflicts() {
- val repository = MdnsRecordRepository(thread.looper, deps)
+ val repository = MdnsRecordRepository(thread.looper, deps, TEST_HOSTNAME)
repository.addService(TEST_SERVICE_ID_1, TEST_SERVICE_1)
assertFailsWith(NameConflictException::class) {
repository.addService(TEST_SERVICE_ID_2, TEST_SERVICE_1)
@@ -126,7 +125,7 @@
@Test
fun testInvalidReuseOfServiceId() {
- val repository = MdnsRecordRepository(thread.looper, deps)
+ val repository = MdnsRecordRepository(thread.looper, deps, TEST_HOSTNAME)
repository.addService(TEST_SERVICE_ID_1, TEST_SERVICE_1)
assertFailsWith(IllegalArgumentException::class) {
repository.addService(TEST_SERVICE_ID_1, TEST_SERVICE_2)
@@ -135,7 +134,7 @@
@Test
fun testHasActiveService() {
- val repository = MdnsRecordRepository(thread.looper, deps)
+ val repository = MdnsRecordRepository(thread.looper, deps, TEST_HOSTNAME)
assertFalse(repository.hasActiveService(TEST_SERVICE_ID_1))
repository.addService(TEST_SERVICE_ID_1, TEST_SERVICE_1)
@@ -152,7 +151,7 @@
@Test
fun testExitAnnouncements() {
- val repository = MdnsRecordRepository(thread.looper, deps)
+ val repository = MdnsRecordRepository(thread.looper, deps, TEST_HOSTNAME)
repository.initWithService(TEST_SERVICE_ID_1, TEST_SERVICE_1)
repository.onAdvertisementSent(TEST_SERVICE_ID_1)
@@ -181,7 +180,7 @@
@Test
fun testExitingServiceReAdded() {
- val repository = MdnsRecordRepository(thread.looper, deps)
+ val repository = MdnsRecordRepository(thread.looper, deps, TEST_HOSTNAME)
repository.initWithService(TEST_SERVICE_ID_1, TEST_SERVICE_1)
repository.onAdvertisementSent(TEST_SERVICE_ID_1)
repository.exitService(TEST_SERVICE_ID_1)
@@ -195,7 +194,7 @@
@Test
fun testOnProbingSucceeded() {
- val repository = MdnsRecordRepository(thread.looper, deps)
+ val repository = MdnsRecordRepository(thread.looper, deps, TEST_HOSTNAME)
val announcementInfo = repository.initWithService(TEST_SERVICE_ID_1, TEST_SERVICE_1)
repository.onAdvertisementSent(TEST_SERVICE_ID_1)
val packet = announcementInfo.getPacket(0)
@@ -319,7 +318,7 @@
@Test
fun testGetReply() {
- val repository = MdnsRecordRepository(thread.looper, deps)
+ val repository = MdnsRecordRepository(thread.looper, deps, TEST_HOSTNAME)
repository.initWithService(TEST_SERVICE_ID_1, TEST_SERVICE_1)
val questions = listOf(MdnsPointerRecord(arrayOf("_testservice", "_tcp", "local"),
0L /* receiptTimeMillis */,
@@ -404,7 +403,7 @@
@Test
fun testGetConflictingServices() {
- val repository = MdnsRecordRepository(thread.looper, deps)
+ val repository = MdnsRecordRepository(thread.looper, deps, TEST_HOSTNAME)
repository.addService(TEST_SERVICE_ID_1, TEST_SERVICE_1)
repository.addService(TEST_SERVICE_ID_2, TEST_SERVICE_2)
@@ -432,7 +431,7 @@
@Test
fun testGetConflictingServices_IdenticalService() {
- val repository = MdnsRecordRepository(thread.looper, deps)
+ val repository = MdnsRecordRepository(thread.looper, deps, TEST_HOSTNAME)
repository.addService(TEST_SERVICE_ID_1, TEST_SERVICE_1)
repository.addService(TEST_SERVICE_ID_2, TEST_SERVICE_2)
diff --git a/tests/unit/java/com/android/server/connectivity/mdns/MdnsResponseDecoderTests.java b/tests/unit/java/com/android/server/connectivity/mdns/MdnsResponseDecoderTests.java
index 4cae447..a80c078 100644
--- a/tests/unit/java/com/android/server/connectivity/mdns/MdnsResponseDecoderTests.java
+++ b/tests/unit/java/com/android/server/connectivity/mdns/MdnsResponseDecoderTests.java
@@ -16,20 +16,26 @@
package com.android.server.connectivity.mdns;
+import static android.net.InetAddresses.parseNumericAddress;
+
import static com.android.server.connectivity.mdns.MdnsResponseDecoder.Clock;
import static com.android.testutils.DevSdkIgnoreRuleKt.SC_V2;
+import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
import static org.mockito.Mockito.mock;
-import android.net.InetAddresses;
import android.net.Network;
+import android.util.ArraySet;
import com.android.net.module.util.HexDump;
+import com.android.server.connectivity.mdns.MdnsResponseTests.MdnsInet4AddressRecord;
+import com.android.server.connectivity.mdns.MdnsResponseTests.MdnsInet6AddressRecord;
import com.android.testutils.DevSdkIgnoreRule;
import com.android.testutils.DevSdkIgnoreRunner;
@@ -43,8 +49,11 @@
import java.net.Inet4Address;
import java.net.Inet6Address;
import java.net.InetSocketAddress;
-import java.util.LinkedList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
import java.util.List;
+import java.util.stream.Collectors;
@RunWith(DevSdkIgnoreRunner.class)
@DevSdkIgnoreRule.IgnoreUpTo(SC_V2)
@@ -147,6 +156,44 @@
+ "010001000000780004C0A8018A0000000000000000000000000000"
+ "000000");
+ // MDNS record for name "testhost1" with an IPv4 address of 10.1.2.3
+ private static final byte[] DATAIN_IPV4_1 = HexDump.hexStringToByteArray(
+ "0974657374686f73743100000180010000007800040a010203");
+ // MDNS record for name "testhost1" with an IPv4 address of 10.1.2.4
+ private static final byte[] DATAIN_IPV4_2 = HexDump.hexStringToByteArray(
+ "0974657374686f73743100000180010000007800040a010204");
+ // MDNS record w/name "testhost1" & IPv6 address of aabb:ccdd:1122:3344:a0b0:c0d0:1020:3040
+ private static final byte[] DATAIN_IPV6_1 = HexDump.hexStringToByteArray(
+ "0974657374686f73743100001c8001000000780010aabbccdd11223344a0b0c0d010203040");
+ // MDNS record w/name "testhost1" & IPv6 address of aabb:ccdd:1122:3344:a0b0:c0d0:1020:3030
+ private static final byte[] DATAIN_IPV6_2 = HexDump.hexStringToByteArray(
+ "0974657374686f73743100001c8001000000780010aabbccdd11223344a0b0c0d010203030");
+ // MDNS record w/name "test" & PTR to foo.bar.quxx
+ private static final byte[] DATAIN_PTR_1 = HexDump.hexStringToByteArray(
+ "047465737400000C000100001194000E03666F6F03626172047175787800");
+ // MDNS record w/name "test" & PTR to foo.bar.quxy
+ private static final byte[] DATAIN_PTR_2 = HexDump.hexStringToByteArray(
+ "047465737400000C000100001194000E03666F6F03626172047175787900");
+ // SRV record for: scapy.DNSRRSRV(rrname='foo.bar.quxx', ttl=120, port=1234, target='testhost1')
+ private static final byte[] DATAIN_SERVICE_1 = HexDump.hexStringToByteArray(
+ "03666f6f03626172047175787800002100010000007800110000000004d20974657374686f73743100");
+ // SRV record for: scapy.DNSRRSRV(rrname='foo.bar.quxx', ttl=120, port=1234, target='testhost2')
+ private static final byte[] DATAIN_SERVICE_2 = HexDump.hexStringToByteArray(
+ "03666f6f03626172047175787800002100010000007800110000000004d20974657374686f73743200");
+ // TXT record for: scapy.DNSRR(rrname='foo.bar.quxx', type='TXT', ttl=120,
+ // rdata=[b'a=hello there', b'b=1234567890', b'xyz=!$$$'])
+ private static final byte[] DATAIN_TEXT_1 = HexDump.hexStringToByteArray(
+ "03666f6f03626172047175787800001000010000007800240d613d68656c6c6f2074686572650c623d3132"
+ + "33343536373839300878797a3d21242424");
+
+ // TXT record for: scapy.DNSRR(rrname='foo.bar.quxx', type='TXT', ttl=120,
+ // rdata=[b'a=hello there', b'b=1234567890', b'xyz=!$$$'])
+ private static final byte[] DATAIN_TEXT_2 = HexDump.hexStringToByteArray(
+ "03666f6f03626172047175787800001000010000007800240d613d68656c6c6f2074686572650c623d3132"
+ + "33343536373839300878797a3d21402324");
+
+ private static final String[] DATAIN_SERVICE_NAME_1 = new String[] { "foo", "bar", "quxx" };
+
private static final String CAST_SERVICE_NAME = "_googlecast";
private static final String[] CAST_SERVICE_TYPE =
new String[] {CAST_SERVICE_NAME, "_tcp", "local"};
@@ -154,41 +201,28 @@
private static final String[] MATTER_SERVICE_TYPE =
new String[] {MATTER_SERVICE_NAME, "_tcp", "local"};
- private final List<MdnsResponse> responses = new LinkedList<>();
+ private ArraySet<MdnsResponse> responses;
private final Clock mClock = mock(Clock.class);
@Before
- public void setUp() {
+ public void setUp() throws Exception {
MdnsResponseDecoder decoder = new MdnsResponseDecoder(mClock, CAST_SERVICE_TYPE);
assertNotNull(data);
- DatagramPacket packet = new DatagramPacket(data, data.length);
- packet.setSocketAddress(
- new InetSocketAddress(MdnsConstants.getMdnsIPv4Address(), MdnsConstants.MDNS_PORT));
- responses.clear();
- int errorCode = decoder.decode(
- packet, responses, MdnsSocket.INTERFACE_INDEX_UNSPECIFIED, mock(Network.class));
- assertEquals(MdnsResponseDecoder.SUCCESS, errorCode);
+ responses = decode(decoder, data);
assertEquals(1, responses.size());
}
@Test
- public void testDecodeWithNullServiceType() {
+ public void testDecodeWithNullServiceType() throws Exception {
MdnsResponseDecoder decoder = new MdnsResponseDecoder(mClock, null);
- assertNotNull(data);
- DatagramPacket packet = new DatagramPacket(data, data.length);
- packet.setSocketAddress(
- new InetSocketAddress(MdnsConstants.getMdnsIPv4Address(), MdnsConstants.MDNS_PORT));
- responses.clear();
- int errorCode = decoder.decode(
- packet, responses, MdnsSocket.INTERFACE_INDEX_UNSPECIFIED, mock(Network.class));
- assertEquals(MdnsResponseDecoder.SUCCESS, errorCode);
+ responses = decode(decoder, data);
assertEquals(2, responses.size());
}
@Test
public void testDecodeMultipleAnswerPacket() throws IOException {
- MdnsResponse response = responses.get(0);
+ MdnsResponse response = responses.valueAt(0);
assertTrue(response.isComplete());
MdnsInetAddressRecord inet4AddressRecord = response.getInet4AddressRecord();
@@ -235,16 +269,10 @@
public void testDecodeIPv6AnswerPacket() throws IOException {
MdnsResponseDecoder decoder = new MdnsResponseDecoder(mClock, CAST_SERVICE_TYPE);
assertNotNull(data6);
- DatagramPacket packet = new DatagramPacket(data6, data6.length);
- packet.setSocketAddress(
- new InetSocketAddress(MdnsConstants.getMdnsIPv6Address(), MdnsConstants.MDNS_PORT));
- responses.clear();
- int errorCode = decoder.decode(
- packet, responses, MdnsSocket.INTERFACE_INDEX_UNSPECIFIED, mock(Network.class));
- assertEquals(MdnsResponseDecoder.SUCCESS, errorCode);
-
- MdnsResponse response = responses.get(0);
+ responses = decode(decoder, data6);
+ assertEquals(1, responses.size());
+ MdnsResponse response = responses.valueAt(0);
assertTrue(response.isComplete());
MdnsInetAddressRecord inet6AddressRecord = response.getInet6AddressRecord();
@@ -259,104 +287,297 @@
@Test
public void testIsComplete() {
- MdnsResponse response = responses.get(0);
+ MdnsResponse response = new MdnsResponse(responses.valueAt(0));
assertTrue(response.isComplete());
response.clearPointerRecords();
+ // The service name is still known in MdnsResponse#getServiceName
+ assertTrue(response.isComplete());
+
+ response = new MdnsResponse(responses.valueAt(0));
+ response.clearInet4AddressRecords();
assertFalse(response.isComplete());
- response = responses.get(0);
- response.setInet4AddressRecord(null);
+ response.addInet6AddressRecord(new MdnsInetAddressRecord(new String[] { "testhostname" },
+ 0L /* receiptTimeMillis */, false /* cacheFlush */, 1234L /* ttlMillis */,
+ parseNumericAddress("2008:db1::123")));
+ assertTrue(response.isComplete());
+
+ response.clearInet6AddressRecords();
assertFalse(response.isComplete());
- response = responses.get(0);
- response.setInet6AddressRecord(null);
- assertFalse(response.isComplete());
-
- response = responses.get(0);
+ response = new MdnsResponse(responses.valueAt(0));
response.setServiceRecord(null);
assertFalse(response.isComplete());
- response = responses.get(0);
+ response = new MdnsResponse(responses.valueAt(0));
response.setTextRecord(null);
assertFalse(response.isComplete());
}
@Test
- public void decode_withInterfaceIndex_populatesInterfaceIndex() {
+ public void decode_withInterfaceIndex_populatesInterfaceIndex() throws Exception {
MdnsResponseDecoder decoder = new MdnsResponseDecoder(mClock, CAST_SERVICE_TYPE);
assertNotNull(data6);
DatagramPacket packet = new DatagramPacket(data6, data6.length);
packet.setSocketAddress(
new InetSocketAddress(MdnsConstants.getMdnsIPv6Address(), MdnsConstants.MDNS_PORT));
- responses.clear();
+ final MdnsPacket parsedPacket = MdnsResponseDecoder.parseResponse(data6, data6.length);
+ assertNotNull(parsedPacket);
+
final Network network = mock(Network.class);
- int errorCode = decoder.decode(
- packet, responses, /* interfaceIndex= */ 10, network);
- assertEquals(errorCode, MdnsResponseDecoder.SUCCESS);
+ responses = decoder.augmentResponses(parsedPacket,
+ /* existingResponses= */ Collections.emptyList(),
+ /* interfaceIndex= */ 10, network /* expireOnExit= */);
+
assertEquals(responses.size(), 1);
- assertEquals(responses.get(0).getInterfaceIndex(), 10);
- assertEquals(network, responses.get(0).getNetwork());
+ assertEquals(responses.valueAt(0).getInterfaceIndex(), 10);
+ assertEquals(network, responses.valueAt(0).getNetwork());
}
@Test
- public void decode_singleHostname_multipleSrvRecords_flagEnabled_multipleCompleteResponses() {
+ public void decode_singleHostname_multipleSrvRecords_flagEnabled_multipleCompleteResponses()
+ throws Exception {
//MdnsScannerConfigsFlagsImpl.allowMultipleSrvRecordsPerHost.override(true);
MdnsResponseDecoder decoder = new MdnsResponseDecoder(mClock, MATTER_SERVICE_TYPE);
assertNotNull(matterDuplicateHostname);
- DatagramPacket packet =
- new DatagramPacket(matterDuplicateHostname, matterDuplicateHostname.length);
-
- packet.setSocketAddress(
- new InetSocketAddress(MdnsConstants.getMdnsIPv6Address(), MdnsConstants.MDNS_PORT));
-
- responses.clear();
- int errorCode = decoder.decode(
- packet, responses, /* interfaceIndex= */ 0, mock(Network.class));
- assertEquals(MdnsResponseDecoder.SUCCESS, errorCode);
+ responses = decode(decoder, matterDuplicateHostname);
// This should emit two records:
assertEquals(2, responses.size());
- MdnsResponse response1 = responses.get(0);
- MdnsResponse response2 = responses.get(0);
+ MdnsResponse response1 = responses.valueAt(0);
+ MdnsResponse response2 = responses.valueAt(0);
// Both of which are complete:
assertTrue(response1.isComplete());
assertTrue(response2.isComplete());
// And should both have the same IPv6 address:
- assertEquals(InetAddresses.parseNumericAddress("2605:a601:a846:5700:3e61:5ff:fe0c:89f8"),
- response1.getInet6AddressRecord().getInet6Address());
- assertEquals(InetAddresses.parseNumericAddress("2605:a601:a846:5700:3e61:5ff:fe0c:89f8"),
- response2.getInet6AddressRecord().getInet6Address());
+ assertTrue(response1.getInet6AddressRecords().stream().anyMatch(
+ record -> record.getInet6Address().equals(
+ parseNumericAddress("2605:a601:a846:5700:3e61:5ff:fe0c:89f8"))));
+ assertTrue(response2.getInet6AddressRecords().stream().anyMatch(
+ record -> record.getInet6Address().equals(
+ parseNumericAddress("2605:a601:a846:5700:3e61:5ff:fe0c:89f8"))));
}
@Test
@Ignore("MdnsConfigs is not configurable currently.")
- public void decode_singleHostname_multipleSrvRecords_flagDisabled_singleCompleteResponse() {
+ public void decode_singleHostname_multipleSrvRecords_flagDisabled_singleCompleteResponse()
+ throws Exception {
//MdnsScannerConfigsFlagsImpl.allowMultipleSrvRecordsPerHost.override(false);
MdnsResponseDecoder decoder = new MdnsResponseDecoder(mClock, MATTER_SERVICE_TYPE);
assertNotNull(matterDuplicateHostname);
- DatagramPacket packet =
- new DatagramPacket(matterDuplicateHostname, matterDuplicateHostname.length);
-
- packet.setSocketAddress(
- new InetSocketAddress(MdnsConstants.getMdnsIPv6Address(), MdnsConstants.MDNS_PORT));
-
- responses.clear();
- int errorCode = decoder.decode(
- packet, responses, /* interfaceIndex= */ 0, mock(Network.class));
- assertEquals(MdnsResponseDecoder.SUCCESS, errorCode);
+ responses = decode(decoder, matterDuplicateHostname);
// This should emit only two records:
assertEquals(2, responses.size());
// But only the first is complete:
- assertTrue(responses.get(0).isComplete());
- assertFalse(responses.get(1).isComplete());
+ assertTrue(responses.valueAt(0).isComplete());
+ assertFalse(responses.valueAt(1).isComplete());
+ }
+
+ @Test
+ public void testDecodeWithIpv4AddressChange() throws IOException {
+ MdnsResponse response = makeMdnsResponse(0, DATAIN_SERVICE_NAME_1, List.of(
+ new PacketAndRecordClass(DATAIN_PTR_1,
+ MdnsPointerRecord.class),
+ new PacketAndRecordClass(DATAIN_SERVICE_1,
+ MdnsServiceRecord.class),
+ new PacketAndRecordClass(DATAIN_IPV4_1,
+ MdnsInet4AddressRecord.class)));
+ // Now update the response with another address
+ final MdnsResponseDecoder decoder = new MdnsResponseDecoder(mClock, null);
+ final ArraySet<MdnsResponse> updatedResponses = decode(
+ decoder, makeResponsePacket(DATAIN_IPV4_2), List.of(response));
+ assertEquals(1, updatedResponses.size());
+ assertEquals(parseNumericAddress("10.1.2.4"),
+ updatedResponses.valueAt(0).getInet4AddressRecord().getInet4Address());
+ assertEquals(parseNumericAddress("10.1.2.3"),
+ response.getInet4AddressRecord().getInet4Address());
+ }
+
+ @Test
+ public void testDecodeWithIpv6AddressChange() throws IOException {
+ MdnsResponse response = makeMdnsResponse(0, DATAIN_SERVICE_NAME_1, List.of(
+ new PacketAndRecordClass(DATAIN_PTR_1,
+ MdnsPointerRecord.class),
+ new PacketAndRecordClass(DATAIN_SERVICE_1,
+ MdnsServiceRecord.class),
+ new PacketAndRecordClass(DATAIN_IPV6_1,
+ MdnsInet6AddressRecord.class)));
+ // Now update the response with another address
+ final MdnsResponseDecoder decoder = new MdnsResponseDecoder(mClock, null);
+ final ArraySet<MdnsResponse> updatedResponses = decode(
+ decoder, makeResponsePacket(DATAIN_IPV6_2), List.of(response));
+ assertEquals(1, updatedResponses.size());
+ assertEquals(parseNumericAddress("aabb:ccdd:1122:3344:a0b0:c0d0:1020:3030"),
+ updatedResponses.valueAt(0).getInet6AddressRecord().getInet6Address());
+ assertEquals(parseNumericAddress("aabb:ccdd:1122:3344:a0b0:c0d0:1020:3040"),
+ response.getInet6AddressRecord().getInet6Address());
+ }
+
+ @Test
+ public void testDecodeWithChangeOnText() throws IOException {
+ MdnsResponse response = makeMdnsResponse(0, DATAIN_SERVICE_NAME_1, List.of(
+ new PacketAndRecordClass(DATAIN_PTR_1,
+ MdnsPointerRecord.class),
+ new PacketAndRecordClass(DATAIN_SERVICE_1,
+ MdnsServiceRecord.class),
+ new PacketAndRecordClass(DATAIN_TEXT_1,
+ MdnsTextRecord.class)));
+ // Now update the response with another address
+ final MdnsResponseDecoder decoder = new MdnsResponseDecoder(mClock, null);
+ final ArraySet<MdnsResponse> updatedResponses = decode(
+ decoder, makeResponsePacket(DATAIN_TEXT_2), List.of(response));
+ assertEquals(1, updatedResponses.size());
+ assertEquals(List.of(
+ new MdnsServiceInfo.TextEntry("a", "hello there"),
+ new MdnsServiceInfo.TextEntry("b", "1234567890"),
+ new MdnsServiceInfo.TextEntry("xyz", "!@#$")),
+ updatedResponses.valueAt(0).getTextRecord().getEntries());
+ }
+
+ @Test
+ public void testDecodeWithChangeOnService() throws IOException {
+ MdnsResponse response = makeMdnsResponse(0, DATAIN_SERVICE_NAME_1, List.of(
+ new PacketAndRecordClass(DATAIN_PTR_1,
+ MdnsPointerRecord.class),
+ new PacketAndRecordClass(DATAIN_SERVICE_1,
+ MdnsServiceRecord.class),
+ new PacketAndRecordClass(DATAIN_IPV4_1,
+ MdnsInet4AddressRecord.class)));
+ assertArrayEquals(new String[] { "testhost1" },
+ response.getServiceRecord().getServiceHost());
+ assertNotNull(response.getInet4AddressRecord());
+ // Now update the response with another hostname
+ final MdnsResponseDecoder decoder = new MdnsResponseDecoder(mClock, null);
+ final ArraySet<MdnsResponse> updatedResponses = decode(
+ decoder, makeResponsePacket(DATAIN_SERVICE_2), List.of(response));
+ assertEquals(1, updatedResponses.size());
+ assertArrayEquals(new String[] { "testhost2" },
+ updatedResponses.valueAt(0).getServiceRecord().getServiceHost());
+ // Hostname changed, so address records are dropped
+ assertNull(updatedResponses.valueAt(0).getInet4AddressRecord());
+ }
+
+ @Test
+ public void testDecodeWithChangeOnPtr() throws IOException {
+ MdnsResponse response = makeMdnsResponse(0, DATAIN_SERVICE_NAME_1, List.of(
+ new PacketAndRecordClass(DATAIN_PTR_1,
+ MdnsPointerRecord.class),
+ new PacketAndRecordClass(DATAIN_SERVICE_1,
+ MdnsServiceRecord.class)));
+ // Now update the response with another address
+ final MdnsResponseDecoder decoder = new MdnsResponseDecoder(mClock, null);
+ final ArraySet<MdnsResponse> updatedResponses = decode(
+ decoder, makeResponsePacket(DATAIN_PTR_2), List.of(response));
+ assertEquals(1, updatedResponses.size());
+ assertArrayEquals(new String[] { "foo", "bar", "quxy" },
+ updatedResponses.valueAt(0).getPointerRecords().get(0).getPointer());
+ }
+
+ @Test
+ public void testDecodeWithNoChange() throws IOException {
+ List<PacketAndRecordClass> recordList =
+ Arrays.asList(
+ new PacketAndRecordClass(DATAIN_IPV4_1, MdnsInet4AddressRecord.class),
+ new PacketAndRecordClass(DATAIN_IPV6_1, MdnsInet6AddressRecord.class),
+ new PacketAndRecordClass(DATAIN_PTR_1, MdnsPointerRecord.class),
+ new PacketAndRecordClass(DATAIN_SERVICE_2, MdnsServiceRecord.class),
+ new PacketAndRecordClass(DATAIN_TEXT_1, MdnsTextRecord.class));
+ // Create a two identical responses.
+ MdnsResponse response = makeMdnsResponse(0, DATAIN_SERVICE_NAME_1, recordList);
+
+ final MdnsResponseDecoder decoder = new MdnsResponseDecoder(mClock, null);
+ final byte[] identicalResponse = makeResponsePacket(
+ recordList.stream().map(p -> p.packetData).collect(Collectors.toList()));
+ final ArraySet<MdnsResponse> changes = decode(
+ decoder, identicalResponse, List.of(response));
+
+ // Decoding should not indicate any change.
+ assertEquals(0, changes.size());
+ }
+
+ private static MdnsResponse makeMdnsResponse(long time, String[] serviceName,
+ List<PacketAndRecordClass> responseList) throws IOException {
+ final MdnsResponse response = new MdnsResponse(
+ time, serviceName, 999 /* interfaceIndex */, mock(Network.class));
+ for (PacketAndRecordClass responseData : responseList) {
+ DatagramPacket packet =
+ new DatagramPacket(responseData.packetData, responseData.packetData.length);
+ MdnsPacketReader reader = new MdnsPacketReader(packet);
+ String[] name = reader.readLabels();
+ reader.skip(2); // skip record type indication.
+ // Apply the right kind of record to the response.
+ if (responseData.recordClass == MdnsInet4AddressRecord.class) {
+ response.addInet4AddressRecord(new MdnsInet4AddressRecord(name, reader));
+ } else if (responseData.recordClass == MdnsInet6AddressRecord.class) {
+ response.addInet6AddressRecord(new MdnsInet6AddressRecord(name, reader));
+ } else if (responseData.recordClass == MdnsPointerRecord.class) {
+ response.addPointerRecord(new MdnsPointerRecord(name, reader));
+ } else if (responseData.recordClass == MdnsServiceRecord.class) {
+ response.setServiceRecord(new MdnsServiceRecord(name, reader));
+ } else if (responseData.recordClass == MdnsTextRecord.class) {
+ response.setTextRecord(new MdnsTextRecord(name, reader));
+ } else {
+ fail("Unsupported/unexpected MdnsRecord subtype used in test - invalid test!");
+ }
+ }
+ return response;
+ }
+
+ private static byte[] makeResponsePacket(byte[] responseRecord) throws IOException {
+ return makeResponsePacket(List.of(responseRecord));
+ }
+
+ private static byte[] makeResponsePacket(List<byte[]> responseRecords) throws IOException {
+ final MdnsPacketWriter writer = new MdnsPacketWriter(1500);
+ writer.writeUInt16(0); // Transaction ID (advertisement: 0)
+ writer.writeUInt16(0x8400); // Flags: response, authoritative
+ writer.writeUInt16(0); // questions count
+ writer.writeUInt16(responseRecords.size()); // answers count
+ writer.writeUInt16(0); // authority entries count
+ writer.writeUInt16(0); // additional records count
+
+ for (byte[] record : responseRecords) {
+ writer.writeBytes(record);
+ }
+ final DatagramPacket packet = writer.getPacket(new InetSocketAddress(0 /* port */));
+ return Arrays.copyOf(packet.getData(), packet.getLength());
+ }
+
+
+ // This helper class just wraps the data bytes of a response packet with the contained record
+ // type.
+ // Its only purpose is to make the test code a bit more readable.
+ private static class PacketAndRecordClass {
+ public final byte[] packetData;
+ public final Class<?> recordClass;
+
+ PacketAndRecordClass(byte[] data, Class<?> c) {
+ packetData = data;
+ recordClass = c;
+ }
+ }
+
+ private ArraySet<MdnsResponse> decode(MdnsResponseDecoder decoder, byte[] data)
+ throws MdnsPacket.ParseException {
+ return decode(decoder, data, Collections.emptyList());
+ }
+
+ private ArraySet<MdnsResponse> decode(MdnsResponseDecoder decoder, byte[] data,
+ Collection<MdnsResponse> existingResponses) throws MdnsPacket.ParseException {
+ final MdnsPacket parsedPacket = MdnsResponseDecoder.parseResponse(data, data.length);
+ assertNotNull(parsedPacket);
+
+ return decoder.augmentResponses(parsedPacket,
+ existingResponses,
+ MdnsSocket.INTERFACE_INDEX_UNSPECIFIED, mock(Network.class));
}
}
\ No newline at end of file
diff --git a/tests/unit/java/com/android/server/connectivity/mdns/MdnsResponseTests.java b/tests/unit/java/com/android/server/connectivity/mdns/MdnsResponseTests.java
index ec57dc8..3f5e7a1 100644
--- a/tests/unit/java/com/android/server/connectivity/mdns/MdnsResponseTests.java
+++ b/tests/unit/java/com/android/server/connectivity/mdns/MdnsResponseTests.java
@@ -16,6 +16,8 @@
package com.android.server.connectivity.mdns;
+import static android.net.InetAddresses.parseNumericAddress;
+
import static com.android.testutils.DevSdkIgnoreRuleKt.SC_V2;
import static org.junit.Assert.assertEquals;
@@ -23,22 +25,21 @@
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
import static org.mockito.Mockito.mock;
+import static java.util.Collections.emptyList;
+
import android.net.Network;
import com.android.net.module.util.HexDump;
import com.android.testutils.DevSdkIgnoreRule;
import com.android.testutils.DevSdkIgnoreRunner;
-import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import java.io.IOException;
import java.net.DatagramPacket;
-import java.util.Arrays;
import java.util.List;
// The record test data does not use compressed names (label pointers), since that would require
@@ -48,36 +49,24 @@
public class MdnsResponseTests {
private static final String TAG = "MdnsResponseTests";
// MDNS response packet for name "test" with an IPv4 address of 10.1.2.3
- private static final byte[] dataIn_ipv4_1 = HexDump.hexStringToByteArray(
+ private static final byte[] DATAIN_IPV4 = HexDump.hexStringToByteArray(
"0474657374000001" + "0001000011940004" + "0A010203");
- // MDNS response packet for name "tess" with an IPv4 address of 10.1.2.4
- private static final byte[] dataIn_ipv4_2 = HexDump.hexStringToByteArray(
- "0474657373000001" + "0001000011940004" + "0A010204");
// MDNS response w/name "test" & IPv6 address of aabb:ccdd:1122:3344:a0b0:c0d0:1020:3040
- private static final byte[] dataIn_ipv6_1 = HexDump.hexStringToByteArray(
+ private static final byte[] DATAIN_IPV6 = HexDump.hexStringToByteArray(
"047465737400001C" + "0001000011940010" + "AABBCCDD11223344" + "A0B0C0D010203040");
- // MDNS response w/name "test" & IPv6 address of aabb:ccdd:1122:3344:a0b0:c0d0:1020:3030
- private static final byte[] dataIn_ipv6_2 = HexDump.hexStringToByteArray(
- "047465737400001C" + "0001000011940010" + "AABBCCDD11223344" + "A0B0C0D010203030");
// MDNS response w/name "test" & PTR to foo.bar.quxx
- private static final byte[] dataIn_ptr_1 = HexDump.hexStringToByteArray(
+ private static final byte[] DATAIN_PTR = HexDump.hexStringToByteArray(
"047465737400000C" + "000100001194000E" + "03666F6F03626172" + "047175787800");
- // MDNS response w/name "test" & PTR to foo.bar.quxy
- private static final byte[] dataIn_ptr_2 = HexDump.hexStringToByteArray(
- "047465737400000C" + "000100001194000E" + "03666F6F03626172" + "047175787900");
// MDNS response w/name "test" & Service for host foo.bar.quxx
- private static final byte[] dataIn_service_1 = HexDump.hexStringToByteArray(
+ private static final byte[] DATAIN_SERVICE = HexDump.hexStringToByteArray(
"0474657374000021"
+ "0001000011940014"
+ "000100FF1F480366"
+ "6F6F036261720471"
+ "75787800");
- // MDNS response w/name "test" & Service for host test
- private static final byte[] dataIn_service_2 = HexDump.hexStringToByteArray(
- "0474657374000021" + "000100001194000B" + "000100FF1F480474" + "657374");
// MDNS response w/name "test" & the following text strings:
// "a=hello there", "b=1234567890", and "xyz=!$$$"
- private static final byte[] dataIn_text_1 = HexDump.hexStringToByteArray(
+ private static final byte[] DATAIN_TEXT = HexDump.hexStringToByteArray(
"0474657374000010"
+ "0001000011940024"
+ "0D613D68656C6C6F"
@@ -85,18 +74,11 @@
+ "3D31323334353637"
+ "3839300878797A3D"
+ "21242424");
- // MDNS response w/name "test" & the following text strings:
- // "a=hello there", "b=1234567890", and "xyz=!@#$"
- private static final byte[] dataIn_text_2 = HexDump.hexStringToByteArray(
- "0474657374000010"
- + "0001000011940024"
- + "0D613D68656C6C6F"
- + "2074686572650C62"
- + "3D31323334353637"
- + "3839300878797A3D"
- + "21402324");
+ private static final String[] TEST_SERVICE_NAME =
+ new String[] { "test", "_type", "_tcp", "local" };
private static final int INTERFACE_INDEX = 999;
+ private static final int TEST_TTL_MS = 120_000;
private final Network mNetwork = mock(Network.class);
// The following helper classes act as wrappers so that IPv4 and IPv6 address records can
@@ -113,87 +95,63 @@
}
}
- // This helper class just wraps the data bytes of a response packet with the contained record
- // type.
- // Its only purpose is to make the test code a bit more readable.
- static class PacketAndRecordClass {
- public final byte[] packetData;
- public final Class<?> recordClass;
-
- public PacketAndRecordClass() {
- packetData = null;
- recordClass = null;
- }
-
- public PacketAndRecordClass(byte[] data, Class<?> c) {
- packetData = data;
- recordClass = c;
- }
- }
-
- // Construct an MdnsResponse with the specified data packets applied.
- private MdnsResponse makeMdnsResponse(long time, List<PacketAndRecordClass> responseList)
- throws IOException {
- MdnsResponse response = new MdnsResponse(time, INTERFACE_INDEX, mNetwork);
- for (PacketAndRecordClass responseData : responseList) {
- DatagramPacket packet =
- new DatagramPacket(responseData.packetData, responseData.packetData.length);
- MdnsPacketReader reader = new MdnsPacketReader(packet);
- String[] name = reader.readLabels();
- reader.skip(2); // skip record type indication.
- // Apply the right kind of record to the response.
- if (responseData.recordClass == MdnsInet4AddressRecord.class) {
- response.setInet4AddressRecord(new MdnsInet4AddressRecord(name, reader));
- } else if (responseData.recordClass == MdnsInet6AddressRecord.class) {
- response.setInet6AddressRecord(new MdnsInet6AddressRecord(name, reader));
- } else if (responseData.recordClass == MdnsPointerRecord.class) {
- response.addPointerRecord(new MdnsPointerRecord(name, reader));
- } else if (responseData.recordClass == MdnsServiceRecord.class) {
- response.setServiceRecord(new MdnsServiceRecord(name, reader));
- } else if (responseData.recordClass == MdnsTextRecord.class) {
- response.setTextRecord(new MdnsTextRecord(name, reader));
- } else {
- fail("Unsupported/unexpected MdnsRecord subtype used in test - invalid test!");
- }
- }
+ private MdnsResponse makeCompleteResponse(int recordsTtlMillis) {
+ final String[] hostname = new String[] { "MyHostname" };
+ final String[] serviceName = new String[] { "MyService", "_type", "_tcp", "local" };
+ final String[] serviceType = new String[] { "_type", "_tcp", "local" };
+ final MdnsResponse response = new MdnsResponse(/* now= */ 0, serviceName, INTERFACE_INDEX,
+ mNetwork);
+ response.addPointerRecord(new MdnsPointerRecord(serviceType, 0L /* receiptTimeMillis */,
+ false /* cacheFlush */, recordsTtlMillis, serviceName));
+ response.setServiceRecord(new MdnsServiceRecord(serviceName, 0L /* receiptTimeMillis */,
+ true /* cacheFlush */, recordsTtlMillis, 0 /* servicePriority */,
+ 0 /* serviceWeight */, 0 /* servicePort */, hostname));
+ response.setTextRecord(new MdnsTextRecord(serviceName, 0L /* receiptTimeMillis */,
+ true /* cacheFlush */, recordsTtlMillis, emptyList() /* entries */));
+ response.addInet4AddressRecord(new MdnsInetAddressRecord(
+ hostname, 0L /* receiptTimeMillis */, true /* cacheFlush */,
+ recordsTtlMillis, parseNumericAddress("192.0.2.123")));
+ response.addInet6AddressRecord(new MdnsInetAddressRecord(
+ hostname, 0L /* receiptTimeMillis */, true /* cacheFlush */,
+ recordsTtlMillis, parseNumericAddress("2001:db8::123")));
return response;
}
@Test
public void getInet4AddressRecord_returnsAddedRecord() throws IOException {
- DatagramPacket packet = new DatagramPacket(dataIn_ipv4_1, dataIn_ipv4_1.length);
+ DatagramPacket packet = new DatagramPacket(DATAIN_IPV4, DATAIN_IPV4.length);
MdnsPacketReader reader = new MdnsPacketReader(packet);
String[] name = reader.readLabels();
reader.skip(2); // skip record type indication.
MdnsInetAddressRecord record = new MdnsInetAddressRecord(name, MdnsRecord.TYPE_A, reader);
- MdnsResponse response = new MdnsResponse(0, INTERFACE_INDEX, mNetwork);
+ MdnsResponse response = new MdnsResponse(0, TEST_SERVICE_NAME, INTERFACE_INDEX, mNetwork);
assertFalse(response.hasInet4AddressRecord());
- assertTrue(response.setInet4AddressRecord(record));
+ assertTrue(response.addInet4AddressRecord(record));
assertEquals(response.getInet4AddressRecord(), record);
}
@Test
public void getInet6AddressRecord_returnsAddedRecord() throws IOException {
- DatagramPacket packet = new DatagramPacket(dataIn_ipv6_1, dataIn_ipv6_1.length);
+ DatagramPacket packet = new DatagramPacket(DATAIN_IPV6, DATAIN_IPV6.length);
MdnsPacketReader reader = new MdnsPacketReader(packet);
String[] name = reader.readLabels();
reader.skip(2); // skip record type indication.
MdnsInetAddressRecord record =
new MdnsInetAddressRecord(name, MdnsRecord.TYPE_AAAA, reader);
- MdnsResponse response = new MdnsResponse(0, INTERFACE_INDEX, mNetwork);
+ MdnsResponse response = new MdnsResponse(0, TEST_SERVICE_NAME, INTERFACE_INDEX, mNetwork);
assertFalse(response.hasInet6AddressRecord());
- assertTrue(response.setInet6AddressRecord(record));
+ assertTrue(response.addInet6AddressRecord(record));
assertEquals(response.getInet6AddressRecord(), record);
}
@Test
public void getPointerRecords_returnsAddedRecord() throws IOException {
- DatagramPacket packet = new DatagramPacket(dataIn_ptr_1, dataIn_ptr_1.length);
+ DatagramPacket packet = new DatagramPacket(DATAIN_PTR, DATAIN_PTR.length);
MdnsPacketReader reader = new MdnsPacketReader(packet);
String[] name = reader.readLabels();
reader.skip(2); // skip record type indication.
MdnsPointerRecord record = new MdnsPointerRecord(name, reader);
- MdnsResponse response = new MdnsResponse(0, INTERFACE_INDEX, mNetwork);
+ MdnsResponse response = new MdnsResponse(0, record.getPointer(), INTERFACE_INDEX, mNetwork);
assertFalse(response.hasPointerRecords());
assertTrue(response.addPointerRecord(record));
List<MdnsPointerRecord> recordList = response.getPointerRecords();
@@ -204,12 +162,12 @@
@Test
public void getServiceRecord_returnsAddedRecord() throws IOException {
- DatagramPacket packet = new DatagramPacket(dataIn_service_1, dataIn_service_1.length);
+ DatagramPacket packet = new DatagramPacket(DATAIN_SERVICE, DATAIN_SERVICE.length);
MdnsPacketReader reader = new MdnsPacketReader(packet);
String[] name = reader.readLabels();
reader.skip(2); // skip record type indication.
MdnsServiceRecord record = new MdnsServiceRecord(name, reader);
- MdnsResponse response = new MdnsResponse(0, INTERFACE_INDEX, mNetwork);
+ MdnsResponse response = new MdnsResponse(0, name, INTERFACE_INDEX, mNetwork);
assertFalse(response.hasServiceRecord());
assertTrue(response.setServiceRecord(record));
assertEquals(response.getServiceRecord(), record);
@@ -217,12 +175,12 @@
@Test
public void getTextRecord_returnsAddedRecord() throws IOException {
- DatagramPacket packet = new DatagramPacket(dataIn_text_1, dataIn_text_1.length);
+ DatagramPacket packet = new DatagramPacket(DATAIN_TEXT, DATAIN_TEXT.length);
MdnsPacketReader reader = new MdnsPacketReader(packet);
String[] name = reader.readLabels();
reader.skip(2); // skip record type indication.
MdnsTextRecord record = new MdnsTextRecord(name, reader);
- MdnsResponse response = new MdnsResponse(0, INTERFACE_INDEX, mNetwork);
+ MdnsResponse response = new MdnsResponse(0, name, INTERFACE_INDEX, mNetwork);
assertFalse(response.hasTextRecord());
assertTrue(response.setTextRecord(record));
assertEquals(response.getTextRecord(), record);
@@ -230,104 +188,86 @@
@Test
public void getInterfaceIndex() {
- final MdnsResponse response1 = new MdnsResponse(/* now= */ 0, INTERFACE_INDEX, mNetwork);
+ final MdnsResponse response1 = new MdnsResponse(/* now= */ 0, TEST_SERVICE_NAME,
+ INTERFACE_INDEX, mNetwork);
assertEquals(INTERFACE_INDEX, response1.getInterfaceIndex());
- final MdnsResponse response2 =
- new MdnsResponse(/* now= */ 0, 1234 /* interfaceIndex */, mNetwork);
+ final MdnsResponse response2 = new MdnsResponse(/* now= */ 0, TEST_SERVICE_NAME,
+ 1234 /* interfaceIndex */, mNetwork);
assertEquals(1234, response2.getInterfaceIndex());
}
@Test
public void testGetNetwork() {
- final MdnsResponse response1 =
- new MdnsResponse(/* now= */ 0, INTERFACE_INDEX, null /* network */);
+ final MdnsResponse response1 = new MdnsResponse(/* now= */ 0, TEST_SERVICE_NAME,
+ INTERFACE_INDEX, null /* network */);
assertNull(response1.getNetwork());
- final MdnsResponse response2 =
- new MdnsResponse(/* now= */ 0, 1234 /* interfaceIndex */, mNetwork);
+ final MdnsResponse response2 = new MdnsResponse(/* now= */ 0, TEST_SERVICE_NAME,
+ 1234 /* interfaceIndex */, mNetwork);
assertEquals(mNetwork, response2.getNetwork());
}
@Test
- public void mergeRecordsFrom_indicates_change_on_ipv4_address() throws IOException {
- MdnsResponse response = makeMdnsResponse(
- 0,
- Arrays.asList(
- new PacketAndRecordClass(dataIn_ipv4_1, MdnsInet4AddressRecord.class)));
- // Now create a new response that updates the address.
- MdnsResponse response2 = makeMdnsResponse(
- 100,
- Arrays.asList(
- new PacketAndRecordClass(dataIn_ipv4_2, MdnsInet4AddressRecord.class)));
- assertTrue(response.mergeRecordsFrom(response2));
+ public void copyConstructor() {
+ final MdnsResponse response = makeCompleteResponse(TEST_TTL_MS);
+ final MdnsResponse copy = new MdnsResponse(response);
+
+ assertEquals(response.getInet6AddressRecord(), copy.getInet6AddressRecord());
+ assertEquals(response.getInet4AddressRecord(), copy.getInet4AddressRecord());
+ assertEquals(response.getPointerRecords(), copy.getPointerRecords());
+ assertEquals(response.getServiceRecord(), copy.getServiceRecord());
+ assertEquals(response.getTextRecord(), copy.getTextRecord());
+ assertEquals(response.getRecords(), copy.getRecords());
+ assertEquals(response.getNetwork(), copy.getNetwork());
+ assertEquals(response.getInterfaceIndex(), copy.getInterfaceIndex());
}
@Test
- public void mergeRecordsFrom_indicates_change_on_ipv6_address() throws IOException {
- MdnsResponse response = makeMdnsResponse(
- 0,
- Arrays.asList(
- new PacketAndRecordClass(dataIn_ipv6_1, MdnsInet6AddressRecord.class)));
- // Now create a new response that updates the address.
- MdnsResponse response2 = makeMdnsResponse(
- 100,
- Arrays.asList(
- new PacketAndRecordClass(dataIn_ipv6_2, MdnsInet6AddressRecord.class)));
- assertTrue(response.mergeRecordsFrom(response2));
+ public void addRecords_noChange() {
+ final MdnsResponse response = makeCompleteResponse(TEST_TTL_MS);
+
+ assertFalse(response.addPointerRecord(response.getPointerRecords().get(0)));
+ assertFalse(response.addInet6AddressRecord(response.getInet6AddressRecord()));
+ assertFalse(response.addInet4AddressRecord(response.getInet4AddressRecord()));
+ assertFalse(response.setServiceRecord(response.getServiceRecord()));
+ assertFalse(response.setTextRecord(response.getTextRecord()));
}
@Test
- public void mergeRecordsFrom_indicates_change_on_text() throws IOException {
- MdnsResponse response = makeMdnsResponse(
- 0,
- Arrays.asList(new PacketAndRecordClass(dataIn_text_1, MdnsTextRecord.class)));
- // Now create a new response that updates the address.
- MdnsResponse response2 = makeMdnsResponse(
- 100,
- Arrays.asList(new PacketAndRecordClass(dataIn_text_2, MdnsTextRecord.class)));
- assertTrue(response.mergeRecordsFrom(response2));
- }
+ public void addRecords_ttlChange() {
+ final MdnsResponse response = makeCompleteResponse(TEST_TTL_MS);
+ final MdnsResponse ttlZeroResponse = makeCompleteResponse(0);
- @Test
- public void mergeRecordsFrom_indicates_change_on_service() throws IOException {
- MdnsResponse response = makeMdnsResponse(
- 0,
- Arrays.asList(new PacketAndRecordClass(dataIn_service_1, MdnsServiceRecord.class)));
- // Now create a new response that updates the address.
- MdnsResponse response2 = makeMdnsResponse(
- 100,
- Arrays.asList(new PacketAndRecordClass(dataIn_service_2, MdnsServiceRecord.class)));
- assertTrue(response.mergeRecordsFrom(response2));
- }
+ assertTrue(response.addPointerRecord(ttlZeroResponse.getPointerRecords().get(0)));
+ assertEquals(1, response.getPointerRecords().size());
+ assertEquals(0, response.getPointerRecords().get(0).getTtl());
+ assertTrue(response.getRecords().stream().anyMatch(r ->
+ r == response.getPointerRecords().get(0)));
- @Test
- public void mergeRecordsFrom_indicates_change_on_pointer() throws IOException {
- MdnsResponse response = makeMdnsResponse(
- 0,
- Arrays.asList(new PacketAndRecordClass(dataIn_ptr_1, MdnsPointerRecord.class)));
- // Now create a new response that updates the address.
- MdnsResponse response2 = makeMdnsResponse(
- 100,
- Arrays.asList(new PacketAndRecordClass(dataIn_ptr_2, MdnsPointerRecord.class)));
- assertTrue(response.mergeRecordsFrom(response2));
- }
+ assertTrue(response.addInet6AddressRecord(ttlZeroResponse.getInet6AddressRecord()));
+ assertEquals(1, response.getInet6AddressRecords().size());
+ assertEquals(0, response.getInet6AddressRecord().getTtl());
+ assertTrue(response.getRecords().stream().anyMatch(r ->
+ r == response.getInet6AddressRecord()));
- @Test
- @Ignore("MdnsConfigs is not configurable currently.")
- public void mergeRecordsFrom_indicates_noChange() throws IOException {
- //MdnsConfigsFlagsImpl.useReducedMergeRecordUpdateEvents.override(true);
- List<PacketAndRecordClass> recordList =
- Arrays.asList(
- new PacketAndRecordClass(dataIn_ipv4_1, MdnsInet4AddressRecord.class),
- new PacketAndRecordClass(dataIn_ipv6_1, MdnsInet6AddressRecord.class),
- new PacketAndRecordClass(dataIn_ptr_1, MdnsPointerRecord.class),
- new PacketAndRecordClass(dataIn_service_2, MdnsServiceRecord.class),
- new PacketAndRecordClass(dataIn_text_1, MdnsTextRecord.class));
- // Create a two identical responses.
- MdnsResponse response = makeMdnsResponse(0, recordList);
- MdnsResponse response2 = makeMdnsResponse(100, recordList);
- // Merging should not indicate any change.
- assertFalse(response.mergeRecordsFrom(response2));
+ assertTrue(response.addInet4AddressRecord(ttlZeroResponse.getInet4AddressRecord()));
+ assertEquals(1, response.getInet4AddressRecords().size());
+ assertEquals(0, response.getInet4AddressRecord().getTtl());
+ assertTrue(response.getRecords().stream().anyMatch(r ->
+ r == response.getInet4AddressRecord()));
+
+ assertTrue(response.setServiceRecord(ttlZeroResponse.getServiceRecord()));
+ assertEquals(0, response.getServiceRecord().getTtl());
+ assertTrue(response.getRecords().stream().anyMatch(r ->
+ r == response.getServiceRecord()));
+
+ assertTrue(response.setTextRecord(ttlZeroResponse.getTextRecord()));
+ assertEquals(0, response.getTextRecord().getTtl());
+ assertTrue(response.getRecords().stream().anyMatch(r ->
+ r == response.getTextRecord()));
+
+ // All records were replaced, not added
+ assertEquals(ttlZeroResponse.getRecords().size(), response.getRecords().size());
}
}
\ No newline at end of file
diff --git a/tests/unit/java/com/android/server/connectivity/mdns/MdnsServiceInfoTest.java b/tests/unit/java/com/android/server/connectivity/mdns/MdnsServiceInfoTest.java
index 76728cf..e7d7a98 100644
--- a/tests/unit/java/com/android/server/connectivity/mdns/MdnsServiceInfoTest.java
+++ b/tests/unit/java/com/android/server/connectivity/mdns/MdnsServiceInfoTest.java
@@ -119,6 +119,26 @@
}
@Test
+ public void constructor_createWithUppercaseKeys_correctAttributes() {
+ MdnsServiceInfo info =
+ new MdnsServiceInfo(
+ "my-mdns-service",
+ new String[] {"_testtype", "_tcp"},
+ List.of(),
+ new String[] {"my-host", "local"},
+ 12345,
+ "192.168.1.1",
+ "2001::1",
+ List.of("KEY=Value"),
+ /* textEntries= */ null);
+
+ assertEquals("Value", info.getAttributeByKey("key"));
+ assertEquals("Value", info.getAttributeByKey("KEY"));
+ assertEquals(1, info.getAttributes().size());
+ assertEquals("KEY", info.getAttributes().keySet().iterator().next());
+ }
+
+ @Test
public void getInterfaceIndex_constructorWithDefaultValues_returnsMinusOne() {
MdnsServiceInfo info =
new MdnsServiceInfo(
@@ -177,8 +197,8 @@
List.of(),
new String[] {"my-host", "local"},
12345,
- "192.168.1.1",
- "2001::1",
+ List.of("192.168.1.1"),
+ List.of("2001::1"),
List.of(),
/* textEntries= */ null,
/* interfaceIndex= */ 20,
@@ -197,8 +217,8 @@
List.of(),
new String[] {"my-host", "local"},
12345,
- "192.168.1.1",
- "2001::1",
+ List.of("192.168.1.1", "192.168.1.2"),
+ List.of("2001::1", "2001::2"),
List.of("vn=Alphabet Inc.", "mn=Google Nest Hub Max", "id=12345"),
List.of(
MdnsServiceInfo.TextEntry.fromString("vn=Google Inc."),
@@ -217,7 +237,9 @@
assertArrayEquals(beforeParcel.getHostName(), afterParcel.getHostName());
assertEquals(beforeParcel.getPort(), afterParcel.getPort());
assertEquals(beforeParcel.getIpv4Address(), afterParcel.getIpv4Address());
+ assertEquals(beforeParcel.getIpv4Addresses(), afterParcel.getIpv4Addresses());
assertEquals(beforeParcel.getIpv6Address(), afterParcel.getIpv6Address());
+ assertEquals(beforeParcel.getIpv6Addresses(), afterParcel.getIpv6Addresses());
assertEquals(beforeParcel.getAttributes(), afterParcel.getAttributes());
assertEquals(beforeParcel.getInterfaceIndex(), afterParcel.getInterfaceIndex());
assertEquals(beforeParcel.getNetwork(), afterParcel.getNetwork());
diff --git a/tests/unit/java/com/android/server/connectivity/mdns/MdnsServiceTypeClientTests.java b/tests/unit/java/com/android/server/connectivity/mdns/MdnsServiceTypeClientTests.java
index a45ca68..d9fa10f 100644
--- a/tests/unit/java/com/android/server/connectivity/mdns/MdnsServiceTypeClientTests.java
+++ b/tests/unit/java/com/android/server/connectivity/mdns/MdnsServiceTypeClientTests.java
@@ -24,13 +24,12 @@
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.argThat;
+import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.inOrder;
-import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@@ -60,8 +59,7 @@
import java.io.IOException;
import java.net.DatagramPacket;
-import java.net.Inet4Address;
-import java.net.Inet6Address;
+import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.util.ArrayList;
import java.util.Arrays;
@@ -72,6 +70,7 @@
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
+import java.util.stream.Stream;
/** Tests for {@link MdnsServiceTypeClient}. */
@RunWith(DevSdkIgnoreRunner.class)
@@ -85,6 +84,9 @@
private static final InetSocketAddress IPV6_ADDRESS = new InetSocketAddress(
MdnsConstants.getMdnsIPv6Address(), MdnsConstants.MDNS_PORT);
+ private static final long TEST_TTL = 120000L;
+ private static final long TEST_ELAPSED_REALTIME = 123L;
+
@Mock
private MdnsServiceBrowserListener mockListenerOne;
@Mock
@@ -95,6 +97,8 @@
private MdnsMultinetworkSocketClient mockSocketClient;
@Mock
private Network mockNetwork;
+ @Mock
+ private MdnsResponseDecoder.Clock mockDecoderClock;
@Captor
private ArgumentCaptor<MdnsServiceInfo> serviceInfoCaptor;
@@ -111,6 +115,7 @@
@SuppressWarnings("DoNotMock")
public void setUp() throws IOException {
MockitoAnnotations.initMocks(this);
+ doReturn(TEST_ELAPSED_REALTIME).when(mockDecoderClock).elapsedRealtime();
expectedIPv4Packets = new DatagramPacket[16];
expectedIPv6Packets = new DatagramPacket[16];
@@ -160,7 +165,8 @@
.thenReturn(expectedIPv6Packets[15]);
client =
- new MdnsServiceTypeClient(SERVICE_TYPE, mockSocketClient, currentThreadExecutor) {
+ new MdnsServiceTypeClient(SERVICE_TYPE, mockSocketClient, currentThreadExecutor,
+ mockDecoderClock) {
@Override
MdnsPacketWriter createMdnsPacketWriter() {
return mockPacketWriter;
@@ -414,16 +420,17 @@
}
private static void verifyServiceInfo(MdnsServiceInfo serviceInfo, String serviceName,
- String[] serviceType, String ipv4Address, String ipv6Address, int port,
+ String[] serviceType, List<String> ipv4Addresses, List<String> ipv6Addresses, int port,
List<String> subTypes, Map<String, String> attributes, int interfaceIndex,
Network network) {
assertEquals(serviceName, serviceInfo.getServiceInstanceName());
assertArrayEquals(serviceType, serviceInfo.getServiceType());
- assertEquals(ipv4Address, serviceInfo.getIpv4Address());
- assertEquals(ipv6Address, serviceInfo.getIpv6Address());
+ assertEquals(ipv4Addresses, serviceInfo.getIpv4Addresses());
+ assertEquals(ipv6Addresses, serviceInfo.getIpv6Addresses());
assertEquals(port, serviceInfo.getPort());
assertEquals(subTypes, serviceInfo.getSubtypes());
for (String key : attributes.keySet()) {
+ assertTrue(attributes.containsKey(key));
assertEquals(attributes.get(key), serviceInfo.getAttributeByKey(key));
}
assertEquals(interfaceIndex, serviceInfo.getInterfaceIndex());
@@ -434,22 +441,19 @@
public void processResponse_incompleteResponse() {
client.startSendAndReceive(mockListenerOne, MdnsSearchOptions.getDefaultOptions());
- MdnsResponse response = mock(MdnsResponse.class);
- when(response.getServiceInstanceName()).thenReturn("service-instance-1");
- doReturn(INTERFACE_INDEX).when(response).getInterfaceIndex();
- doReturn(mockNetwork).when(response).getNetwork();
- when(response.isComplete()).thenReturn(false);
-
- client.processResponse(response);
+ client.processResponse(createResponse(
+ "service-instance-1", null /* host */, 0 /* port */,
+ SERVICE_TYPE_LABELS,
+ Collections.emptyMap(), TEST_TTL), INTERFACE_INDEX, mockNetwork);
verify(mockListenerOne).onServiceNameDiscovered(serviceInfoCaptor.capture());
verifyServiceInfo(serviceInfoCaptor.getAllValues().get(0),
"service-instance-1",
SERVICE_TYPE_LABELS,
- null /* ipv4Address */,
- null /* ipv6Address */,
- 0 /* port */,
- List.of() /* subTypes */,
- Collections.singletonMap("key", null) /* attributes */,
+ /* ipv4Address= */ List.of(),
+ /* ipv6Address= */ List.of(),
+ /* port= */ 0,
+ /* subTypes= */ List.of(),
+ Collections.emptyMap(),
INTERFACE_INDEX,
mockNetwork);
@@ -463,36 +467,25 @@
client.startSendAndReceive(mockListenerOne, MdnsSearchOptions.getDefaultOptions());
// Process the initial response.
- MdnsResponse initialResponse =
- createResponse(
- "service-instance-1",
- ipV4Address,
- 5353,
- /* subtype= */ "ABCDE",
- Collections.emptyMap(),
- /* interfaceIndex= */ 20,
- mockNetwork);
- client.processResponse(initialResponse);
+ client.processResponse(createResponse(
+ "service-instance-1", ipV4Address, 5353,
+ /* subtype= */ "ABCDE",
+ Collections.emptyMap(), TEST_TTL), /* interfaceIndex= */ 20, mockNetwork);
// Process a second response with a different port and updated text attributes.
- MdnsResponse secondResponse =
- createResponse(
- "service-instance-1",
- ipV4Address,
- 5354,
- /* subtype= */ "ABCDE",
- Collections.singletonMap("key", "value"),
- /* interfaceIndex= */ 20,
- mockNetwork);
- client.processResponse(secondResponse);
+ client.processResponse(createResponse(
+ "service-instance-1", ipV4Address, 5354,
+ /* subtype= */ "ABCDE",
+ Collections.singletonMap("key", "value"), TEST_TTL),
+ /* interfaceIndex= */ 20, mockNetwork);
// Verify onServiceNameDiscovered was called once for the initial response.
verify(mockListenerOne).onServiceNameDiscovered(serviceInfoCaptor.capture());
verifyServiceInfo(serviceInfoCaptor.getAllValues().get(0),
"service-instance-1",
SERVICE_TYPE_LABELS,
- ipV4Address /* ipv4Address */,
- null /* ipv6Address */,
+ List.of(ipV4Address) /* ipv4Address */,
+ List.of() /* ipv6Address */,
5353 /* port */,
Collections.singletonList("ABCDE") /* subTypes */,
Collections.singletonMap("key", null) /* attributes */,
@@ -529,39 +522,25 @@
client.startSendAndReceive(mockListenerOne, MdnsSearchOptions.getDefaultOptions());
// Process the initial response.
- MdnsResponse initialResponse =
- createResponse(
- "service-instance-1",
- ipV6Address,
- 5353,
- /* subtype= */ "ABCDE",
- Collections.emptyMap(),
- /* interfaceIndex= */ 20,
- mockNetwork);
- client.processResponse(initialResponse);
+ client.processResponse(createResponse(
+ "service-instance-1", ipV6Address, 5353,
+ /* subtype= */ "ABCDE",
+ Collections.emptyMap(), TEST_TTL), /* interfaceIndex= */ 20, mockNetwork);
// Process a second response with a different port and updated text attributes.
- MdnsResponse secondResponse =
- createResponse(
- "service-instance-1",
- ipV6Address,
- 5354,
- /* subtype= */ "ABCDE",
- Collections.singletonMap("key", "value"),
- /* interfaceIndex= */ 20,
- mockNetwork);
- client.processResponse(secondResponse);
-
- System.out.println("secondResponses ip"
- + secondResponse.getInet6AddressRecord().getInet6Address().getHostAddress());
+ client.processResponse(createResponse(
+ "service-instance-1", ipV6Address, 5354,
+ /* subtype= */ "ABCDE",
+ Collections.singletonMap("key", "value"), TEST_TTL),
+ /* interfaceIndex= */ 20, mockNetwork);
// Verify onServiceNameDiscovered was called once for the initial response.
verify(mockListenerOne).onServiceNameDiscovered(serviceInfoCaptor.capture());
verifyServiceInfo(serviceInfoCaptor.getAllValues().get(0),
"service-instance-1",
SERVICE_TYPE_LABELS,
- null /* ipv4Address */,
- ipV6Address /* ipv6Address */,
+ List.of() /* ipv4Address */,
+ List.of(ipV6Address) /* ipv6Address */,
5353 /* port */,
Collections.singletonList("ABCDE") /* subTypes */,
Collections.singletonMap("key", null) /* attributes */,
@@ -619,29 +598,25 @@
final String serviceName = "service-instance-1";
final String ipV6Address = "2000:3333::da6c:63ff:fe7c:7483";
// Process the initial response.
- final MdnsResponse initialResponse =
- createResponse(
- serviceName,
- ipV6Address,
- 5353 /* port */,
- /* subtype= */ "ABCDE",
- Collections.emptyMap(),
- INTERFACE_INDEX,
- mockNetwork);
- client.processResponse(initialResponse);
- MdnsResponse response = mock(MdnsResponse.class);
- doReturn("goodbye-service").when(response).getServiceInstanceName();
- doReturn(INTERFACE_INDEX).when(response).getInterfaceIndex();
- doReturn(mockNetwork).when(response).getNetwork();
- doReturn(true).when(response).isGoodbye();
- client.processResponse(response);
+ client.processResponse(createResponse(
+ serviceName, ipV6Address, 5353,
+ SERVICE_TYPE_LABELS,
+ Collections.emptyMap(), TEST_TTL), INTERFACE_INDEX, mockNetwork);
+
+ client.processResponse(createResponse(
+ "goodbye-service", ipV6Address, 5353,
+ SERVICE_TYPE_LABELS,
+ Collections.emptyMap(), /* ptrTtlMillis= */ 0L), INTERFACE_INDEX, mockNetwork);
+
// Verify removed callback won't be called if the service is not existed.
verifyServiceRemovedNoCallback(mockListenerOne);
verifyServiceRemovedNoCallback(mockListenerTwo);
// Verify removed callback would be called.
- doReturn(serviceName).when(response).getServiceInstanceName();
- client.processResponse(response);
+ client.processResponse(createResponse(
+ serviceName, ipV6Address, 5353,
+ SERVICE_TYPE_LABELS,
+ Collections.emptyMap(), 0L), INTERFACE_INDEX, mockNetwork);
verifyServiceRemovedCallback(
mockListenerOne, serviceName, SERVICE_TYPE_LABELS, INTERFACE_INDEX, mockNetwork);
verifyServiceRemovedCallback(
@@ -651,16 +626,10 @@
@Test
public void reportExistingServiceToNewlyRegisteredListeners() throws Exception {
// Process the initial response.
- MdnsResponse initialResponse =
- createResponse(
- "service-instance-1",
- "192.168.1.1",
- 5353,
- /* subtype= */ "ABCDE",
- Collections.emptyMap(),
- INTERFACE_INDEX,
- mockNetwork);
- client.processResponse(initialResponse);
+ client.processResponse(createResponse(
+ "service-instance-1", "192.168.1.1", 5353,
+ /* subtype= */ "ABCDE",
+ Collections.emptyMap(), TEST_TTL), INTERFACE_INDEX, mockNetwork);
client.startSendAndReceive(mockListenerOne, MdnsSearchOptions.getDefaultOptions());
@@ -669,8 +638,8 @@
verifyServiceInfo(serviceInfoCaptor.getAllValues().get(0),
"service-instance-1",
SERVICE_TYPE_LABELS,
- "192.168.1.1" /* ipv4Address */,
- null /* ipv6Address */,
+ List.of("192.168.1.1") /* ipv4Address */,
+ List.of() /* ipv6Address */,
5353 /* port */,
Collections.singletonList("ABCDE") /* subTypes */,
Collections.singletonMap("key", null) /* attributes */,
@@ -687,10 +656,10 @@
assertNull(existingServiceInfo.getAttributeByKey("key"));
// Process a goodbye message for the existing response.
- MdnsResponse goodByeResponse = mock(MdnsResponse.class);
- when(goodByeResponse.getServiceInstanceName()).thenReturn("service-instance-1");
- when(goodByeResponse.isGoodbye()).thenReturn(true);
- client.processResponse(goodByeResponse);
+ client.processResponse(createResponse(
+ "service-instance-1", "192.168.1.1", 5353,
+ SERVICE_TYPE_LABELS,
+ Collections.emptyMap(), /* ptrTtlMillis= */ 0L), INTERFACE_INDEX, mockNetwork);
client.startSendAndReceive(mockListenerTwo, MdnsSearchOptions.getDefaultOptions());
@@ -709,17 +678,15 @@
Runnable firstMdnsTask = currentThreadExecutor.getAndClearSubmittedRunnable();
// Process the initial response.
- MdnsResponse initialResponse =
- createMockResponse(
- serviceInstanceName, "192.168.1.1", 5353, List.of("ABCDE"),
- Map.of(), INTERFACE_INDEX, mockNetwork);
- client.processResponse(initialResponse);
+ client.processResponse(createResponse(
+ serviceInstanceName, "192.168.1.1", 5353, /* subtype= */ "ABCDE",
+ Collections.emptyMap(), TEST_TTL), INTERFACE_INDEX, mockNetwork);
// Clear the scheduled runnable.
currentThreadExecutor.getAndClearLastScheduledRunnable();
// Simulate the case where the response is after TTL.
- when(initialResponse.getServiceRecord().getRemainingTTL(anyLong())).thenReturn((long) 0);
+ doReturn(TEST_ELAPSED_REALTIME + TEST_TTL + 1L).when(mockDecoderClock).elapsedRealtime();
firstMdnsTask.run();
// Verify removed callback was not called.
@@ -733,7 +700,8 @@
//MdnsConfigsFlagsImpl.allowSearchOptionsToRemoveExpiredService.override(true);
final String serviceInstanceName = "service-instance-1";
client =
- new MdnsServiceTypeClient(SERVICE_TYPE, mockSocketClient, currentThreadExecutor) {
+ new MdnsServiceTypeClient(SERVICE_TYPE, mockSocketClient, currentThreadExecutor,
+ mockDecoderClock) {
@Override
MdnsPacketWriter createMdnsPacketWriter() {
return mockPacketWriter;
@@ -743,24 +711,22 @@
Runnable firstMdnsTask = currentThreadExecutor.getAndClearSubmittedRunnable();
// Process the initial response.
- MdnsResponse initialResponse =
- createMockResponse(
- serviceInstanceName, "192.168.1.1", 5353, List.of("ABCDE"),
- Map.of(), INTERFACE_INDEX, mockNetwork);
- client.processResponse(initialResponse);
+ client.processResponse(createResponse(
+ serviceInstanceName, "192.168.1.1", 5353, /* subtype= */ "ABCDE",
+ Collections.emptyMap(), TEST_TTL), INTERFACE_INDEX, mockNetwork);
// Clear the scheduled runnable.
currentThreadExecutor.getAndClearLastScheduledRunnable();
// Simulate the case where the response is under TTL.
- when(initialResponse.getServiceRecord().getRemainingTTL(anyLong())).thenReturn((long) 1000);
+ doReturn(TEST_ELAPSED_REALTIME + TEST_TTL - 1L).when(mockDecoderClock).elapsedRealtime();
firstMdnsTask.run();
// Verify removed callback was not called.
verifyServiceRemovedNoCallback(mockListenerOne);
// Simulate the case where the response is after TTL.
- when(initialResponse.getServiceRecord().getRemainingTTL(anyLong())).thenReturn((long) 0);
+ doReturn(TEST_ELAPSED_REALTIME + TEST_TTL + 1L).when(mockDecoderClock).elapsedRealtime();
firstMdnsTask.run();
// Verify removed callback was called.
@@ -773,7 +739,8 @@
throws Exception {
final String serviceInstanceName = "service-instance-1";
client =
- new MdnsServiceTypeClient(SERVICE_TYPE, mockSocketClient, currentThreadExecutor) {
+ new MdnsServiceTypeClient(SERVICE_TYPE, mockSocketClient, currentThreadExecutor,
+ mockDecoderClock) {
@Override
MdnsPacketWriter createMdnsPacketWriter() {
return mockPacketWriter;
@@ -783,17 +750,15 @@
Runnable firstMdnsTask = currentThreadExecutor.getAndClearSubmittedRunnable();
// Process the initial response.
- MdnsResponse initialResponse =
- createMockResponse(
- serviceInstanceName, "192.168.1.1", 5353, List.of("ABCDE"),
- Map.of(), INTERFACE_INDEX, mockNetwork);
- client.processResponse(initialResponse);
+ client.processResponse(createResponse(
+ serviceInstanceName, "192.168.1.1", 5353, /* subtype= */ "ABCDE",
+ Collections.emptyMap(), TEST_TTL), INTERFACE_INDEX, mockNetwork);
// Clear the scheduled runnable.
currentThreadExecutor.getAndClearLastScheduledRunnable();
// Simulate the case where the response is after TTL.
- when(initialResponse.getServiceRecord().getRemainingTTL(anyLong())).thenReturn((long) 0);
+ doReturn(TEST_ELAPSED_REALTIME + TEST_TTL + 1L).when(mockDecoderClock).elapsedRealtime();
firstMdnsTask.run();
// Verify removed callback was not called.
@@ -807,7 +772,8 @@
//MdnsConfigsFlagsImpl.removeServiceAfterTtlExpires.override(true);
final String serviceInstanceName = "service-instance-1";
client =
- new MdnsServiceTypeClient(SERVICE_TYPE, mockSocketClient, currentThreadExecutor) {
+ new MdnsServiceTypeClient(SERVICE_TYPE, mockSocketClient, currentThreadExecutor,
+ mockDecoderClock) {
@Override
MdnsPacketWriter createMdnsPacketWriter() {
return mockPacketWriter;
@@ -817,17 +783,15 @@
Runnable firstMdnsTask = currentThreadExecutor.getAndClearSubmittedRunnable();
// Process the initial response.
- MdnsResponse initialResponse =
- createMockResponse(
- serviceInstanceName, "192.168.1.1", 5353, List.of("ABCDE"),
- Map.of(), INTERFACE_INDEX, mockNetwork);
- client.processResponse(initialResponse);
+ client.processResponse(createResponse(
+ serviceInstanceName, "192.168.1.1", 5353, /* subtype= */ "ABCDE",
+ Collections.emptyMap(), TEST_TTL), INTERFACE_INDEX, mockNetwork);
// Clear the scheduled runnable.
currentThreadExecutor.getAndClearLastScheduledRunnable();
// Simulate the case where the response is after TTL.
- when(initialResponse.getServiceRecord().getRemainingTTL(anyLong())).thenReturn((long) 0);
+ doReturn(TEST_ELAPSED_REALTIME + TEST_TTL + 1L).when(mockDecoderClock).elapsedRealtime();
firstMdnsTask.run();
// Verify removed callback was called.
@@ -844,56 +808,36 @@
InOrder inOrder = inOrder(mockListenerOne);
// Process the initial response which is incomplete.
- final MdnsResponse initialResponse =
- createResponse(
- serviceName,
- null,
- 5353,
- "ABCDE" /* subtype */,
- Collections.emptyMap(),
- INTERFACE_INDEX,
- mockNetwork);
- client.processResponse(initialResponse);
+ final String subtype = "ABCDE";
+ client.processResponse(createResponse(
+ serviceName, null, 5353, subtype,
+ Collections.emptyMap(), TEST_TTL), INTERFACE_INDEX, mockNetwork);
// Process a second response which has ip address to make response become complete.
- final MdnsResponse secondResponse =
- createResponse(
- serviceName,
- ipV4Address,
- 5353,
- "ABCDE" /* subtype */,
- Collections.emptyMap(),
- INTERFACE_INDEX,
- mockNetwork);
- client.processResponse(secondResponse);
+ client.processResponse(createResponse(
+ serviceName, ipV4Address, 5353, subtype,
+ Collections.emptyMap(), TEST_TTL), INTERFACE_INDEX, mockNetwork);
// Process a third response with a different ip address, port and updated text attributes.
- final MdnsResponse thirdResponse =
- createResponse(
- serviceName,
- ipV6Address,
- 5354,
- "ABCDE" /* subtype */,
- Collections.singletonMap("key", "value"),
- INTERFACE_INDEX,
- mockNetwork);
- client.processResponse(thirdResponse);
+ client.processResponse(createResponse(
+ serviceName, ipV6Address, 5354, subtype,
+ Collections.singletonMap("key", "value"), TEST_TTL), INTERFACE_INDEX, mockNetwork);
- // Process the last response which is goodbye message.
- final MdnsResponse lastResponse = mock(MdnsResponse.class);
- doReturn(serviceName).when(lastResponse).getServiceInstanceName();
- doReturn(true).when(lastResponse).isGoodbye();
- client.processResponse(lastResponse);
+ // Process the last response which is goodbye message (with the main type, not subtype).
+ client.processResponse(createResponse(
+ serviceName, ipV6Address, 5354, SERVICE_TYPE_LABELS,
+ Collections.singletonMap("key", "value"), /* ptrTtlMillis= */ 0L),
+ INTERFACE_INDEX, mockNetwork);
// Verify onServiceNameDiscovered was first called for the initial response.
inOrder.verify(mockListenerOne).onServiceNameDiscovered(serviceInfoCaptor.capture());
verifyServiceInfo(serviceInfoCaptor.getAllValues().get(0),
serviceName,
SERVICE_TYPE_LABELS,
- null /* ipv4Address */,
- null /* ipv6Address */,
+ List.of() /* ipv4Address */,
+ List.of() /* ipv6Address */,
5353 /* port */,
- Collections.singletonList("ABCDE") /* subTypes */,
+ Collections.singletonList(subtype) /* subTypes */,
Collections.singletonMap("key", null) /* attributes */,
INTERFACE_INDEX,
mockNetwork);
@@ -903,10 +847,10 @@
verifyServiceInfo(serviceInfoCaptor.getAllValues().get(1),
serviceName,
SERVICE_TYPE_LABELS,
- ipV4Address /* ipv4Address */,
- null /* ipv6Address */,
+ List.of(ipV4Address) /* ipv4Address */,
+ List.of() /* ipv6Address */,
5353 /* port */,
- Collections.singletonList("ABCDE") /* subTypes */,
+ Collections.singletonList(subtype) /* subTypes */,
Collections.singletonMap("key", null) /* attributes */,
INTERFACE_INDEX,
mockNetwork);
@@ -916,10 +860,10 @@
verifyServiceInfo(serviceInfoCaptor.getAllValues().get(2),
serviceName,
SERVICE_TYPE_LABELS,
- ipV4Address /* ipv4Address */,
- ipV6Address /* ipv6Address */,
+ List.of(ipV4Address) /* ipv4Address */,
+ List.of(ipV6Address) /* ipv6Address */,
5354 /* port */,
- Collections.singletonList("ABCDE") /* subTypes */,
+ Collections.singletonList(subtype) /* subTypes */,
Collections.singletonMap("key", "value") /* attributes */,
INTERFACE_INDEX,
mockNetwork);
@@ -929,8 +873,8 @@
verifyServiceInfo(serviceInfoCaptor.getAllValues().get(3),
serviceName,
SERVICE_TYPE_LABELS,
- ipV4Address /* ipv4Address */,
- ipV6Address /* ipv6Address */,
+ List.of(ipV4Address) /* ipv4Address */,
+ List.of(ipV6Address) /* ipv6Address */,
5354 /* port */,
Collections.singletonList("ABCDE") /* subTypes */,
Collections.singletonMap("key", "value") /* attributes */,
@@ -942,8 +886,8 @@
verifyServiceInfo(serviceInfoCaptor.getAllValues().get(4),
serviceName,
SERVICE_TYPE_LABELS,
- ipV4Address /* ipv4Address */,
- ipV6Address /* ipv6Address */,
+ List.of(ipV4Address) /* ipv4Address */,
+ List.of(ipV6Address) /* ipv6Address */,
5354 /* port */,
Collections.singletonList("ABCDE") /* subTypes */,
Collections.singletonMap("key", "value") /* attributes */,
@@ -951,6 +895,102 @@
mockNetwork);
}
+ @Test
+ public void testProcessResponse_Resolve() throws Exception {
+ client = new MdnsServiceTypeClient(SERVICE_TYPE, mockSocketClient, currentThreadExecutor);
+
+ final String instanceName = "service-instance";
+ final String[] hostname = new String[] { "testhost "};
+ final String ipV4Address = "192.0.2.0";
+ final String ipV6Address = "2001:db8::";
+
+ final MdnsSearchOptions resolveOptions = MdnsSearchOptions.newBuilder()
+ .setResolveInstanceName(instanceName).build();
+
+ client.startSendAndReceive(mockListenerOne, resolveOptions);
+ InOrder inOrder = inOrder(mockListenerOne, mockSocketClient);
+
+ // Verify a query for SRV/TXT was sent, but no PTR query
+ final ArgumentCaptor<DatagramPacket> srvTxtQueryCaptor =
+ ArgumentCaptor.forClass(DatagramPacket.class);
+ currentThreadExecutor.getAndClearLastScheduledRunnable().run();
+ // Send twice for IPv4 and IPv6
+ inOrder.verify(mockSocketClient, times(2)).sendUnicastPacket(srvTxtQueryCaptor.capture(),
+ eq(null) /* network */);
+
+ final MdnsPacket srvTxtQueryPacket = MdnsPacket.parse(
+ new MdnsPacketReader(srvTxtQueryCaptor.getValue()));
+ final List<MdnsRecord> srvTxtQuestions = srvTxtQueryPacket.questions;
+
+ final String[] serviceName = Stream.concat(Stream.of(instanceName),
+ Arrays.stream(SERVICE_TYPE_LABELS)).toArray(String[]::new);
+ assertFalse(srvTxtQuestions.stream().anyMatch(q -> q.getType() == MdnsRecord.TYPE_PTR));
+ assertTrue(srvTxtQuestions.stream().anyMatch(q ->
+ q.getType() == MdnsRecord.TYPE_SRV && Arrays.equals(q.name, serviceName)));
+ assertTrue(srvTxtQuestions.stream().anyMatch(q ->
+ q.getType() == MdnsRecord.TYPE_TXT && Arrays.equals(q.name, serviceName)));
+
+ // Process a response with SRV+TXT
+ final MdnsPacket srvTxtResponse = new MdnsPacket(
+ 0 /* flags */,
+ Collections.emptyList() /* questions */,
+ List.of(
+ new MdnsServiceRecord(serviceName, 0L /* receiptTimeMillis */,
+ true /* cacheFlush */, TEST_TTL, 0 /* servicePriority */,
+ 0 /* serviceWeight */, 1234 /* servicePort */, hostname),
+ new MdnsTextRecord(serviceName, 0L /* receiptTimeMillis */,
+ true /* cacheFlush */, TEST_TTL,
+ Collections.emptyList() /* entries */)),
+ Collections.emptyList() /* authorityRecords */,
+ Collections.emptyList() /* additionalRecords */);
+
+ client.processResponse(srvTxtResponse, INTERFACE_INDEX, mockNetwork);
+
+ // Expect a query for A/AAAA
+ final ArgumentCaptor<DatagramPacket> addressQueryCaptor =
+ ArgumentCaptor.forClass(DatagramPacket.class);
+ currentThreadExecutor.getAndClearLastScheduledRunnable().run();
+ inOrder.verify(mockSocketClient, times(2)).sendMulticastPacket(addressQueryCaptor.capture(),
+ eq(null) /* network */);
+
+ final MdnsPacket addressQueryPacket = MdnsPacket.parse(
+ new MdnsPacketReader(addressQueryCaptor.getValue()));
+ final List<MdnsRecord> addressQueryQuestions = addressQueryPacket.questions;
+ assertTrue(addressQueryQuestions.stream().anyMatch(q ->
+ q.getType() == MdnsRecord.TYPE_A && Arrays.equals(q.name, hostname)));
+ assertTrue(addressQueryQuestions.stream().anyMatch(q ->
+ q.getType() == MdnsRecord.TYPE_AAAA && Arrays.equals(q.name, hostname)));
+
+ // Process a response with address records
+ final MdnsPacket addressResponse = new MdnsPacket(
+ 0 /* flags */,
+ Collections.emptyList() /* questions */,
+ List.of(
+ new MdnsInetAddressRecord(hostname, 0L /* receiptTimeMillis */,
+ true /* cacheFlush */, TEST_TTL,
+ InetAddresses.parseNumericAddress(ipV4Address)),
+ new MdnsInetAddressRecord(hostname, 0L /* receiptTimeMillis */,
+ true /* cacheFlush */, TEST_TTL,
+ InetAddresses.parseNumericAddress(ipV6Address))),
+ Collections.emptyList() /* authorityRecords */,
+ Collections.emptyList() /* additionalRecords */);
+
+ inOrder.verify(mockListenerOne, never()).onServiceNameDiscovered(any());
+ client.processResponse(addressResponse, INTERFACE_INDEX, mockNetwork);
+
+ inOrder.verify(mockListenerOne).onServiceFound(serviceInfoCaptor.capture());
+ verifyServiceInfo(serviceInfoCaptor.getValue(),
+ instanceName,
+ SERVICE_TYPE_LABELS,
+ List.of(ipV4Address),
+ List.of(ipV6Address),
+ 1234 /* port */,
+ Collections.emptyList() /* subTypes */,
+ Collections.emptyMap() /* attributes */,
+ INTERFACE_INDEX,
+ mockNetwork);
+ }
+
// verifies that the right query was enqueued with the right delay, and send query by executing
// the runnable.
private void verifyAndSendQuery(int index, long timeInMs, boolean expectsUnicastResponse) {
@@ -1029,106 +1069,68 @@
}
}
- // Creates a mock mDNS response.
- private MdnsResponse createMockResponse(
- @NonNull String serviceInstanceName,
- @NonNull String host,
- int port,
- @NonNull List<String> subtypes,
- @NonNull Map<String, String> textAttributes,
- int interfaceIndex,
- Network network)
- throws Exception {
- String[] hostName = new String[]{"hostname"};
- MdnsServiceRecord serviceRecord = mock(MdnsServiceRecord.class);
- when(serviceRecord.getServiceHost()).thenReturn(hostName);
- when(serviceRecord.getServicePort()).thenReturn(port);
-
- MdnsResponse response = spy(new MdnsResponse(0, interfaceIndex, network));
-
- MdnsInetAddressRecord inetAddressRecord = mock(MdnsInetAddressRecord.class);
- if (host.contains(":")) {
- when(inetAddressRecord.getInet6Address())
- .thenReturn((Inet6Address) Inet6Address.getByName(host));
- response.setInet6AddressRecord(inetAddressRecord);
- } else {
- when(inetAddressRecord.getInet4Address())
- .thenReturn((Inet4Address) Inet4Address.getByName(host));
- response.setInet4AddressRecord(inetAddressRecord);
- }
-
- MdnsTextRecord textRecord = mock(MdnsTextRecord.class);
- List<String> textStrings = new ArrayList<>();
- List<TextEntry> textEntries = new ArrayList<>();
- for (Map.Entry<String, String> kv : textAttributes.entrySet()) {
- textStrings.add(kv.getKey() + "=" + kv.getValue());
- textEntries.add(new TextEntry(kv.getKey(), kv.getValue().getBytes(UTF_8)));
- }
- when(textRecord.getStrings()).thenReturn(textStrings);
- when(textRecord.getEntries()).thenReturn(textEntries);
-
- response.setServiceRecord(serviceRecord);
- response.setTextRecord(textRecord);
-
- doReturn(false).when(response).isGoodbye();
- doReturn(true).when(response).isComplete();
- doReturn(serviceInstanceName).when(response).getServiceInstanceName();
- doReturn(new ArrayList<>(subtypes)).when(response).getSubtypes();
- return response;
- }
-
- // Creates a mDNS response.
- private MdnsResponse createResponse(
+ private MdnsPacket createResponse(
@NonNull String serviceInstanceName,
@Nullable String host,
int port,
@NonNull String subtype,
@NonNull Map<String, String> textAttributes,
- int interfaceIndex,
- Network network)
+ long ptrTtlMillis)
throws Exception {
- MdnsResponse response = new MdnsResponse(0, interfaceIndex, network);
+ final ArrayList<String> type = new ArrayList<>();
+ type.add(subtype);
+ type.add(MdnsConstants.SUBTYPE_LABEL);
+ type.addAll(Arrays.asList(SERVICE_TYPE_LABELS));
+ return createResponse(serviceInstanceName, host, port, type.toArray(new String[0]),
+ textAttributes, ptrTtlMillis);
+ }
+
+ // Creates a mDNS response.
+ private MdnsPacket createResponse(
+ @NonNull String serviceInstanceName,
+ @Nullable String host,
+ int port,
+ @NonNull String[] type,
+ @NonNull Map<String, String> textAttributes,
+ long ptrTtlMillis) {
+
+ final ArrayList<MdnsRecord> answerRecords = new ArrayList<>();
// Set PTR record
+ final ArrayList<String> serviceNameList = new ArrayList<>();
+ serviceNameList.add(serviceInstanceName);
+ serviceNameList.addAll(Arrays.asList(type));
+ final String[] serviceName = serviceNameList.toArray(new String[0]);
final MdnsPointerRecord pointerRecord = new MdnsPointerRecord(
- new String[]{subtype, MdnsConstants.SUBTYPE_LABEL, "test"} /* name */,
- 0L /* receiptTimeMillis */,
+ type,
+ TEST_ELAPSED_REALTIME /* receiptTimeMillis */,
false /* cacheFlush */,
- 120000L /* ttlMillis */,
- new String[]{serviceInstanceName});
- response.addPointerRecord(pointerRecord);
+ ptrTtlMillis,
+ serviceName);
+ answerRecords.add(pointerRecord);
// Set SRV record.
final MdnsServiceRecord serviceRecord = new MdnsServiceRecord(
- new String[] {"service"} /* name */,
- 0L /* receiptTimeMillis */,
+ serviceName,
+ TEST_ELAPSED_REALTIME /* receiptTimeMillis */,
false /* cacheFlush */,
- 120000L /* ttlMillis */,
+ TEST_TTL,
0 /* servicePriority */,
0 /* serviceWeight */,
port,
new String[]{"hostname"});
- response.setServiceRecord(serviceRecord);
+ answerRecords.add(serviceRecord);
// Set A/AAAA record.
if (host != null) {
- if (InetAddresses.parseNumericAddress(host) instanceof Inet6Address) {
- final MdnsInetAddressRecord inetAddressRecord = new MdnsInetAddressRecord(
- new String[] {"address"} /* name */,
- 0L /* receiptTimeMillis */,
- false /* cacheFlush */,
- 120000L /* ttlMillis */,
- Inet6Address.getByName(host));
- response.setInet6AddressRecord(inetAddressRecord);
- } else {
- final MdnsInetAddressRecord inetAddressRecord = new MdnsInetAddressRecord(
- new String[] {"address"} /* name */,
- 0L /* receiptTimeMillis */,
- false /* cacheFlush */,
- 120000L /* ttlMillis */,
- Inet4Address.getByName(host));
- response.setInet4AddressRecord(inetAddressRecord);
- }
+ final InetAddress addr = InetAddresses.parseNumericAddress(host);
+ final MdnsInetAddressRecord inetAddressRecord = new MdnsInetAddressRecord(
+ new String[] {"hostname"} /* name */,
+ TEST_ELAPSED_REALTIME /* receiptTimeMillis */,
+ false /* cacheFlush */,
+ TEST_TTL,
+ addr);
+ answerRecords.add(inetAddressRecord);
}
// Set TXT record.
@@ -1137,12 +1139,18 @@
textEntries.add(new TextEntry(kv.getKey(), kv.getValue().getBytes(UTF_8)));
}
final MdnsTextRecord textRecord = new MdnsTextRecord(
- new String[] {"text"} /* name */,
- 0L /* receiptTimeMillis */,
+ serviceName,
+ TEST_ELAPSED_REALTIME /* receiptTimeMillis */,
false /* cacheFlush */,
- 120000L /* ttlMillis */,
+ TEST_TTL,
textEntries);
- response.setTextRecord(textRecord);
- return response;
+ answerRecords.add(textRecord);
+ return new MdnsPacket(
+ 0 /* flags */,
+ Collections.emptyList() /* questions */,
+ answerRecords,
+ Collections.emptyList() /* authorityRecords */,
+ Collections.emptyList() /* additionalRecords */
+ );
}
}
\ No newline at end of file
diff --git a/tests/unit/java/com/android/server/connectivity/mdns/MdnsSocketClientTests.java b/tests/unit/java/com/android/server/connectivity/mdns/MdnsSocketClientTests.java
index 1d61cd3..9048686 100644
--- a/tests/unit/java/com/android/server/connectivity/mdns/MdnsSocketClientTests.java
+++ b/tests/unit/java/com/android/server/connectivity/mdns/MdnsSocketClientTests.java
@@ -18,13 +18,11 @@
import static com.android.testutils.DevSdkIgnoreRuleKt.SC_V2;
-import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyInt;
-import static org.mockito.ArgumentMatchers.argThat;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.never;
@@ -48,7 +46,6 @@
import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
-import org.mockito.ArgumentCaptor;
import org.mockito.ArgumentMatchers;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
@@ -373,7 +370,7 @@
mdnsClient.startDiscovery();
verify(mockCallback, timeout(TIMEOUT).atLeast(1))
- .onResponseReceived(any(MdnsResponse.class));
+ .onResponseReceived(any(MdnsPacket.class), anyInt(), any());
}
@Test
@@ -382,7 +379,7 @@
mdnsClient.startDiscovery();
verify(mockCallback, timeout(TIMEOUT).atLeastOnce())
- .onResponseReceived(any(MdnsResponse.class));
+ .onResponseReceived(any(MdnsPacket.class), anyInt(), any());
mdnsClient.stopDiscovery();
}
@@ -514,7 +511,7 @@
mdnsClient.startDiscovery();
verify(mockCallback, timeout(TIMEOUT).atLeastOnce())
- .onResponseReceived(argThat(response -> response.getInterfaceIndex() == 21));
+ .onResponseReceived(any(), eq(21), any());
}
@Test
@@ -536,11 +533,7 @@
mdnsClient.setCallback(mockCallback);
mdnsClient.startDiscovery();
- ArgumentCaptor<MdnsResponse> mdnsResponseCaptor =
- ArgumentCaptor.forClass(MdnsResponse.class);
verify(mockMulticastSocket, never()).getInterfaceIndex();
- verify(mockCallback, timeout(TIMEOUT).atLeast(1))
- .onResponseReceived(mdnsResponseCaptor.capture());
- assertEquals(-1, mdnsResponseCaptor.getValue().getInterfaceIndex());
+ verify(mockCallback, timeout(TIMEOUT).atLeast(1)).onResponseReceived(any(), eq(-1), any());
}
}
\ No newline at end of file
diff --git a/tests/unit/java/com/android/server/connectivity/mdns/MdnsSocketProviderTest.java b/tests/unit/java/com/android/server/connectivity/mdns/MdnsSocketProviderTest.java
index 635b296..b9cb255 100644
--- a/tests/unit/java/com/android/server/connectivity/mdns/MdnsSocketProviderTest.java
+++ b/tests/unit/java/com/android/server/connectivity/mdns/MdnsSocketProviderTest.java
@@ -27,6 +27,7 @@
import static org.mockito.Mockito.doCallRealMethod;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
@@ -109,12 +110,15 @@
final HandlerThread thread = new HandlerThread("MdnsSocketProviderTest");
thread.start();
mHandler = new Handler(thread.getLooper());
+ mSocketProvider = new MdnsSocketProvider(mContext, thread.getLooper(), mDeps);
+ }
+ private void startMonitoringSockets() {
final ArgumentCaptor<NetworkCallback> nwCallbackCaptor =
ArgumentCaptor.forClass(NetworkCallback.class);
final ArgumentCaptor<TetheringEventCallback> teCallbackCaptor =
ArgumentCaptor.forClass(TetheringEventCallback.class);
- mSocketProvider = new MdnsSocketProvider(mContext, thread.getLooper(), mDeps);
+
mHandler.post(mSocketProvider::startMonitoringSockets);
HandlerUtils.waitForIdle(mHandler, DEFAULT_TIMEOUT);
verify(mCm).registerNetworkCallback(any(), nwCallbackCaptor.capture(), any());
@@ -205,6 +209,8 @@
@Test
public void testSocketRequestAndUnrequestSocket() {
+ startMonitoringSockets();
+
final TestSocketCallback testCallback1 = new TestSocketCallback();
mHandler.post(() -> mSocketProvider.requestSocket(TEST_NETWORK, testCallback1));
HandlerUtils.waitForIdle(mHandler, DEFAULT_TIMEOUT);
@@ -275,6 +281,8 @@
@Test
public void testAddressesChanged() throws Exception {
+ startMonitoringSockets();
+
final TestSocketCallback testCallback = new TestSocketCallback();
mHandler.post(() -> mSocketProvider.requestSocket(TEST_NETWORK, testCallback));
HandlerUtils.waitForIdle(mHandler, DEFAULT_TIMEOUT);
@@ -297,4 +305,53 @@
testCallback.expectedAddressesChangedForNetwork(
TEST_NETWORK, List.of(LINKADDRV4, LINKADDRV6));
}
+
+ @Test
+ public void testStartAndStopMonitoringSockets() {
+ // Stop monitoring sockets before start. Should not unregister any network callback.
+ mHandler.post(mSocketProvider::requestStopWhenInactive);
+ HandlerUtils.waitForIdle(mHandler, DEFAULT_TIMEOUT);
+ verify(mCm, never()).unregisterNetworkCallback(any(NetworkCallback.class));
+ verify(mTm, never()).unregisterTetheringEventCallback(any(TetheringEventCallback.class));
+
+ // Start sockets monitoring.
+ startMonitoringSockets();
+ // Request a socket then unrequest it. Expect no network callback unregistration.
+ final TestSocketCallback testCallback = new TestSocketCallback();
+ mHandler.post(() -> mSocketProvider.requestSocket(TEST_NETWORK, testCallback));
+ HandlerUtils.waitForIdle(mHandler, DEFAULT_TIMEOUT);
+ testCallback.expectedNoCallback();
+ mHandler.post(()-> mSocketProvider.unrequestSocket(testCallback));
+ HandlerUtils.waitForIdle(mHandler, DEFAULT_TIMEOUT);
+ verify(mCm, never()).unregisterNetworkCallback(any(NetworkCallback.class));
+ verify(mTm, never()).unregisterTetheringEventCallback(any(TetheringEventCallback.class));
+ // Request stop and it should unregister network callback immediately because there is no
+ // socket request.
+ mHandler.post(mSocketProvider::requestStopWhenInactive);
+ HandlerUtils.waitForIdle(mHandler, DEFAULT_TIMEOUT);
+ verify(mCm, times(1)).unregisterNetworkCallback(any(NetworkCallback.class));
+ verify(mTm, times(1)).unregisterTetheringEventCallback(any(TetheringEventCallback.class));
+
+ // Start sockets monitoring and request a socket again.
+ mHandler.post(mSocketProvider::startMonitoringSockets);
+ HandlerUtils.waitForIdle(mHandler, DEFAULT_TIMEOUT);
+ verify(mCm, times(2)).registerNetworkCallback(any(), any(NetworkCallback.class), any());
+ verify(mTm, times(2)).registerTetheringEventCallback(
+ any(), any(TetheringEventCallback.class));
+ final TestSocketCallback testCallback2 = new TestSocketCallback();
+ mHandler.post(() -> mSocketProvider.requestSocket(TEST_NETWORK, testCallback2));
+ HandlerUtils.waitForIdle(mHandler, DEFAULT_TIMEOUT);
+ testCallback2.expectedNoCallback();
+ // Try to stop monitoring sockets but should be ignored and wait until all socket are
+ // unrequested.
+ mHandler.post(mSocketProvider::requestStopWhenInactive);
+ HandlerUtils.waitForIdle(mHandler, DEFAULT_TIMEOUT);
+ verify(mCm, times(1)).unregisterNetworkCallback(any(NetworkCallback.class));
+ verify(mTm, times(1)).unregisterTetheringEventCallback(any());
+ // Unrequest the socket then network callbacks should be unregistered.
+ mHandler.post(()-> mSocketProvider.unrequestSocket(testCallback2));
+ HandlerUtils.waitForIdle(mHandler, DEFAULT_TIMEOUT);
+ verify(mCm, times(2)).unregisterNetworkCallback(any(NetworkCallback.class));
+ verify(mTm, times(2)).unregisterTetheringEventCallback(any(TetheringEventCallback.class));
+ }
}
diff --git a/tests/unit/res/xml/self_certified_capabilities_bandwidth.xml b/tests/unit/res/xml/self_certified_capabilities_bandwidth.xml
new file mode 100644
index 0000000..01fdca1
--- /dev/null
+++ b/tests/unit/res/xml/self_certified_capabilities_bandwidth.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+
+<network-capabilities-declaration xmlns:android="http://schemas.android.com/apk/res/android">
+ <uses-network-capability android:name="NET_CAPABILITY_PRIORITIZE_BANDWIDTH"/>
+</network-capabilities-declaration>
diff --git a/tests/unit/res/xml/self_certified_capabilities_both.xml b/tests/unit/res/xml/self_certified_capabilities_both.xml
new file mode 100644
index 0000000..4066be2
--- /dev/null
+++ b/tests/unit/res/xml/self_certified_capabilities_both.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+
+<network-capabilities-declaration xmlns:android="http://schemas.android.com/apk/res/android">
+ <uses-network-capability android:name="NET_CAPABILITY_PRIORITIZE_LATENCY"/>
+ <uses-network-capability android:name="NET_CAPABILITY_PRIORITIZE_BANDWIDTH"/>
+</network-capabilities-declaration>
diff --git a/tests/unit/res/xml/self_certified_capabilities_latency.xml b/tests/unit/res/xml/self_certified_capabilities_latency.xml
new file mode 100644
index 0000000..1c4a0e0
--- /dev/null
+++ b/tests/unit/res/xml/self_certified_capabilities_latency.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+
+<network-capabilities-declaration xmlns:android="http://schemas.android.com/apk/res/android">
+ <uses-network-capability android:name="NET_CAPABILITY_PRIORITIZE_LATENCY"/>
+</network-capabilities-declaration>
diff --git a/tests/unit/res/xml/self_certified_capabilities_other.xml b/tests/unit/res/xml/self_certified_capabilities_other.xml
new file mode 100644
index 0000000..5b6649c
--- /dev/null
+++ b/tests/unit/res/xml/self_certified_capabilities_other.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+
+<network-capabilities-declaration xmlns:android="http://schemas.android.com/apk/res/android">
+ <uses-network-capability android:name="other"/>
+</network-capabilities-declaration>
diff --git a/tests/unit/res/xml/self_certified_capabilities_wrong_declaration.xml b/tests/unit/res/xml/self_certified_capabilities_wrong_declaration.xml
new file mode 100644
index 0000000..6082356
--- /dev/null
+++ b/tests/unit/res/xml/self_certified_capabilities_wrong_declaration.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+
+<network-capabilities-declaration1 xmlns:android="http://schemas.android.com/apk/res/android">
+ <uses-network-capability android:name="NET_CAPABILITY_PRIORITIZE_LATENCY"/>
+</network-capabilities-declaration1>
diff --git a/tests/unit/res/xml/self_certified_capabilities_wrong_tag.xml b/tests/unit/res/xml/self_certified_capabilities_wrong_tag.xml
new file mode 100644
index 0000000..c9ecc0b
--- /dev/null
+++ b/tests/unit/res/xml/self_certified_capabilities_wrong_tag.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+
+<network-capabilities-declaration xmlns:android="http://schemas.android.com/apk/res/android">
+ <uses-network-capability1 android:name="NET_CAPABILITY_PRIORITIZE_LATENCY"/>
+ <uses-network-capability android:name="NET_CAPABILITY_PRIORITIZE_LATENCY"/>
+ <uses-network-capability android:name="NET_CAPABILITY_PRIORITIZE_BANDWIDTH"/>
+</network-capabilities-declaration>
diff --git a/tools/gn2bp/Android.bp.swp b/tools/gn2bp/Android.bp.swp
index 9f34b06..d22a576 100644
--- a/tools/gn2bp/Android.bp.swp
+++ b/tools/gn2bp/Android.bp.swp
@@ -14,6 +14,8 @@
//
// This file is automatically generated by gen_android_bp. Do not edit.
+build = ["Android.extras.bp"]
+
// GN: PACKAGE
package {
default_applicable_licenses: [
@@ -22,19 +24,6 @@
}
// GN: //components/cronet/android:cronet_api_java
-java_library {
- name: "cronet_aml_api_java",
- srcs: [
- ":cronet_aml_api_sources",
- ],
- libs: [
- "androidx.annotation_annotation",
- "framework-annotations-lib",
- ],
- sdk_version: "module_current",
-}
-
-// GN: //components/cronet/android:cronet_api_java
// TODO(danstahr): add the API helpers separately after the main API is checked in and thoroughly reviewed
filegroup {
name: "cronet_aml_api_sources",
@@ -87,6 +76,30 @@
],
}
+// GN: //base/allocator:buildflags__testing
+cc_genrule {
+ name: "cronet_aml_base_allocator_buildflags__testing",
+ cmd: "echo '--flags USE_ALLOCATOR_SHIM=\"true\" USE_PARTITION_ALLOC=\"false\" USE_PARTITION_ALLOC_AS_MALLOC=\"false\" USE_BACKUP_REF_PTR=\"false\" USE_ASAN_BACKUP_REF_PTR=\"false\" USE_PARTITION_ALLOC_AS_GWP_ASAN_STORE=\"false\" USE_MTE_CHECKED_PTR=\"false\" FORCE_ENABLE_RAW_PTR_EXCLUSION=\"false\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//base/allocator:buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin",
+ host_supported: true,
+ out: [
+ "base/allocator/buildflags.h",
+ ],
+ tool_files: [
+ "build/write_buildflag_header.py",
+ ],
+ apex_available: [
+ "com.android.tethering",
+ ],
+}
+
// GN: //base/allocator/partition_allocator:chromecast_buildflags
cc_genrule {
name: "cronet_aml_base_allocator_partition_allocator_chromecast_buildflags",
@@ -110,6 +123,30 @@
],
}
+// GN: //base/allocator/partition_allocator:chromecast_buildflags__testing
+cc_genrule {
+ name: "cronet_aml_base_allocator_partition_allocator_chromecast_buildflags__testing",
+ cmd: "echo '--flags PA_IS_CAST_ANDROID=\"false\" PA_IS_CASTOS=\"false\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//base/allocator/partition_allocator:chromecast_buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin",
+ host_supported: true,
+ out: [
+ "base/allocator/partition_allocator/chromecast_buildflags.h",
+ ],
+ tool_files: [
+ "build/write_buildflag_header.py",
+ ],
+ apex_available: [
+ "com.android.tethering",
+ ],
+}
+
// GN: //base/allocator/partition_allocator:chromeos_buildflags
cc_genrule {
name: "cronet_aml_base_allocator_partition_allocator_chromeos_buildflags",
@@ -133,6 +170,30 @@
],
}
+// GN: //base/allocator/partition_allocator:chromeos_buildflags__testing
+cc_genrule {
+ name: "cronet_aml_base_allocator_partition_allocator_chromeos_buildflags__testing",
+ cmd: "echo '--flags PA_IS_CHROMEOS_ASH=\"false\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//base/allocator/partition_allocator:chromeos_buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin",
+ host_supported: true,
+ out: [
+ "base/allocator/partition_allocator/chromeos_buildflags.h",
+ ],
+ tool_files: [
+ "build/write_buildflag_header.py",
+ ],
+ apex_available: [
+ "com.android.tethering",
+ ],
+}
+
// GN: //base/allocator/partition_allocator:debugging_buildflags
cc_genrule {
name: "cronet_aml_base_allocator_partition_allocator_debugging_buildflags",
@@ -156,6 +217,30 @@
],
}
+// GN: //base/allocator/partition_allocator:debugging_buildflags__testing
+cc_genrule {
+ name: "cronet_aml_base_allocator_partition_allocator_debugging_buildflags__testing",
+ cmd: "echo '--flags PA_DCHECK_IS_ON=\"false\" PA_EXPENSIVE_DCHECKS_ARE_ON=\"false\" PA_DCHECK_IS_CONFIGURABLE=\"false\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//base/allocator/partition_allocator:debugging_buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin",
+ host_supported: true,
+ out: [
+ "base/allocator/partition_allocator/partition_alloc_base/debug/debugging_buildflags.h",
+ ],
+ tool_files: [
+ "build/write_buildflag_header.py",
+ ],
+ apex_available: [
+ "com.android.tethering",
+ ],
+}
+
// GN: //base/allocator/partition_allocator:logging_buildflags
cc_genrule {
name: "cronet_aml_base_allocator_partition_allocator_logging_buildflags",
@@ -179,11 +264,34 @@
],
}
+// GN: //base/allocator/partition_allocator:logging_buildflags__testing
+cc_genrule {
+ name: "cronet_aml_base_allocator_partition_allocator_logging_buildflags__testing",
+ cmd: "echo '--flags PA_ENABLE_LOG_ERROR_NOT_REACHED=\"false\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//base/allocator/partition_allocator:logging_buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin",
+ host_supported: true,
+ out: [
+ "base/allocator/partition_allocator/logging_buildflags.h",
+ ],
+ tool_files: [
+ "build/write_buildflag_header.py",
+ ],
+ apex_available: [
+ "com.android.tethering",
+ ],
+}
+
// GN: //base/allocator/partition_allocator:partition_alloc
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",
@@ -237,6 +345,9 @@
"base/allocator/partition_allocator/tagging.cc",
"base/allocator/partition_allocator/thread_cache.cc",
],
+ static_libs: [
+ "cronet_aml_third_party_android_ndk_cpu_features",
+ ],
generated_headers: [
"cronet_aml_base_allocator_partition_allocator_chromecast_buildflags",
"cronet_aml_base_allocator_partition_allocator_chromeos_buildflags",
@@ -263,6 +374,7 @@
"-DHAVE_SYS_UIO_H",
"-DIS_PARTITION_ALLOC_IMPL",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-DPA_PCSCAN_STACK_SUPPORTED",
@@ -272,6 +384,14 @@
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
"-D__STDC_CONSTANT_MACROS",
"-D__STDC_FORMAT_MACROS",
+ "-O3",
+ "-fdata-sections",
+ "-ffunction-sections",
+ "-fno-asynchronous-unwind-tables",
+ "-fno-unwind-tables",
+ "-fvisibility-inlines-hidden",
+ "-fvisibility=hidden",
+ "-g1",
],
local_include_dirs: [
"./",
@@ -284,18 +404,29 @@
"libgtest_prod_headers",
],
cpp_std: "c++17",
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
target: {
android_arm: {
srcs: [
"base/allocator/partition_allocator/starscan/stack/asm/arm/push_registers_asm.cc",
],
+ cflags: [
+ "-fstack-protector",
+ ],
},
android_arm64: {
srcs: [
"base/allocator/partition_allocator/starscan/stack/asm/arm64/push_registers_asm.cc",
],
cflags: [
+ "-fstack-protector",
"-march=armv8-a+memtag",
+ "-mno-outline",
+ "-mno-outline-atomics",
],
},
android_x86: {
@@ -311,12 +442,229 @@
"base/allocator/partition_allocator/starscan/stack/asm/x64/push_registers_asm.cc",
],
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //base/allocator/partition_allocator:partition_alloc__testing
+cc_library_static {
+ name: "cronet_aml_base_allocator_partition_allocator_partition_alloc__testing",
+ srcs: [
+ "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",
+ "base/allocator/partition_allocator/allocation_guard.cc",
+ "base/allocator/partition_allocator/dangling_raw_ptr_checks.cc",
+ "base/allocator/partition_allocator/gwp_asan_support.cc",
+ "base/allocator/partition_allocator/memory_reclaimer.cc",
+ "base/allocator/partition_allocator/oom.cc",
+ "base/allocator/partition_allocator/oom_callback.cc",
+ "base/allocator/partition_allocator/page_allocator.cc",
+ "base/allocator/partition_allocator/page_allocator_internals_posix.cc",
+ "base/allocator/partition_allocator/partition_address_space.cc",
+ "base/allocator/partition_allocator/partition_alloc.cc",
+ "base/allocator/partition_allocator/partition_alloc_base/check.cc",
+ "base/allocator/partition_allocator/partition_alloc_base/cpu.cc",
+ "base/allocator/partition_allocator/partition_alloc_base/debug/alias.cc",
+ "base/allocator/partition_allocator/partition_alloc_base/files/file_util_posix.cc",
+ "base/allocator/partition_allocator/partition_alloc_base/logging.cc",
+ "base/allocator/partition_allocator/partition_alloc_base/memory/ref_counted.cc",
+ "base/allocator/partition_allocator/partition_alloc_base/posix/safe_strerror.cc",
+ "base/allocator/partition_allocator/partition_alloc_base/rand_util.cc",
+ "base/allocator/partition_allocator/partition_alloc_base/rand_util_posix.cc",
+ "base/allocator/partition_allocator/partition_alloc_base/strings/stringprintf.cc",
+ "base/allocator/partition_allocator/partition_alloc_base/threading/platform_thread.cc",
+ "base/allocator/partition_allocator/partition_alloc_base/threading/platform_thread_posix.cc",
+ "base/allocator/partition_allocator/partition_alloc_base/time/time.cc",
+ "base/allocator/partition_allocator/partition_alloc_base/time/time_conversion_posix.cc",
+ "base/allocator/partition_allocator/partition_alloc_base/time/time_now_posix.cc",
+ "base/allocator/partition_allocator/partition_alloc_base/time/time_override.cc",
+ "base/allocator/partition_allocator/partition_alloc_hooks.cc",
+ "base/allocator/partition_allocator/partition_bucket.cc",
+ "base/allocator/partition_allocator/partition_oom.cc",
+ "base/allocator/partition_allocator/partition_page.cc",
+ "base/allocator/partition_allocator/partition_root.cc",
+ "base/allocator/partition_allocator/partition_stats.cc",
+ "base/allocator/partition_allocator/random.cc",
+ "base/allocator/partition_allocator/reservation_offset_table.cc",
+ "base/allocator/partition_allocator/spinning_mutex.cc",
+ "base/allocator/partition_allocator/starscan/metadata_allocator.cc",
+ "base/allocator/partition_allocator/starscan/pcscan.cc",
+ "base/allocator/partition_allocator/starscan/pcscan_internal.cc",
+ "base/allocator/partition_allocator/starscan/pcscan_scheduling.cc",
+ "base/allocator/partition_allocator/starscan/snapshot.cc",
+ "base/allocator/partition_allocator/starscan/stack/stack.cc",
+ "base/allocator/partition_allocator/starscan/stats_collector.cc",
+ "base/allocator/partition_allocator/starscan/write_protector.cc",
+ "base/allocator/partition_allocator/tagging.cc",
+ "base/allocator/partition_allocator/thread_cache.cc",
+ ],
+ host_supported: true,
+ generated_headers: [
+ "cronet_aml_base_allocator_partition_allocator_chromecast_buildflags__testing",
+ "cronet_aml_base_allocator_partition_allocator_chromeos_buildflags__testing",
+ "cronet_aml_base_allocator_partition_allocator_debugging_buildflags__testing",
+ "cronet_aml_base_allocator_partition_allocator_logging_buildflags__testing",
+ "cronet_aml_base_allocator_partition_allocator_partition_alloc_buildflags__testing",
+ ],
+ export_generated_headers: [
+ "cronet_aml_base_allocator_partition_allocator_chromecast_buildflags__testing",
+ "cronet_aml_base_allocator_partition_allocator_chromeos_buildflags__testing",
+ "cronet_aml_base_allocator_partition_allocator_debugging_buildflags__testing",
+ "cronet_aml_base_allocator_partition_allocator_logging_buildflags__testing",
+ "cronet_aml_base_allocator_partition_allocator_partition_alloc_buildflags__testing",
+ ],
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DIS_PARTITION_ALLOC_IMPL",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-DPA_PCSCAN_STACK_SUPPORTED",
+ "-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",
+ "-O3",
+ "-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",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ android_arm: {
+ srcs: [
+ "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",
+ "-DHAVE_SYS_UIO_H",
+ "-fstack-protector",
+ ],
+ local_include_dirs: [
+ "third_party/android_ndk/sources/android/cpufeatures/",
+ ],
+ },
+ android_arm64: {
+ srcs: [
+ "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",
+ "-DHAVE_SYS_UIO_H",
+ "-fstack-protector",
+ "-march=armv8-a+memtag",
+ "-mno-outline",
+ "-mno-outline-atomics",
+ ],
+ local_include_dirs: [
+ "third_party/android_ndk/sources/android/cpufeatures/",
+ ],
+ },
+ android_x86: {
+ srcs: [
+ "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",
+ "-DHAVE_SYS_UIO_H",
+ "-msse3",
+ ],
+ local_include_dirs: [
+ "third_party/android_ndk/sources/android/cpufeatures/",
+ ],
+ },
+ android_x86_64: {
+ srcs: [
+ "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",
+ "-DHAVE_SYS_UIO_H",
+ "-fstack-protector",
+ "-msse3",
+ ],
+ local_include_dirs: [
+ "third_party/android_ndk/sources/android/cpufeatures/",
+ ],
+ },
+ host: {
+ srcs: [
+ "base/allocator/partition_allocator/starscan/stack/asm/x64/push_registers_asm.cc",
+ ],
+ 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",
+ "-fstack-protector",
+ "-msse3",
+ ],
+ compile_multilib: "64",
+ },
+ },
+}
+
// GN: //base/allocator/partition_allocator:partition_alloc_buildflags
cc_genrule {
name: "cronet_aml_base_allocator_partition_allocator_partition_alloc_buildflags",
@@ -340,6 +688,81 @@
],
}
+// GN: //base/allocator/partition_allocator:partition_alloc_buildflags__testing
+cc_genrule {
+ name: "cronet_aml_base_allocator_partition_allocator_partition_alloc_buildflags__testing",
+ cmd: "if [[ ( $$CC_ARCH == 'x86_64' && $$CC_OS == 'android' ) ]]; " +
+ "then " +
+ "echo '--flags ENABLE_PARTITION_ALLOC_AS_MALLOC_SUPPORT=\"true\" ENABLE_BACKUP_REF_PTR_SUPPORT=\"true\" ENABLE_BACKUP_REF_PTR_SLOW_CHECKS=\"false\" ENABLE_DANGLING_RAW_PTR_CHECKS=\"false\" PUT_REF_COUNT_IN_PREVIOUS_SLOT=\"true\" ENABLE_GWP_ASAN_SUPPORT=\"true\" ENABLE_MTE_CHECKED_PTR_SUPPORT=\"false\" RECORD_ALLOC_INFO=\"false\" USE_FREESLOT_BITMAP=\"false\" ENABLE_SHADOW_METADATA_FOR_64_BITS_POINTERS=\"false\" STARSCAN=\"true\" PA_USE_BASE_TRACING=\"true\" ENABLE_PKEYS=\"false\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//base/allocator/partition_allocator:partition_alloc_buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin; " +
+ "fi; " +
+ "if [[ $$CC_OS != 'android' ]]; " +
+ "then " +
+ "echo '--flags ENABLE_PARTITION_ALLOC_AS_MALLOC_SUPPORT=\"true\" ENABLE_BACKUP_REF_PTR_SUPPORT=\"true\" ENABLE_BACKUP_REF_PTR_SLOW_CHECKS=\"false\" ENABLE_DANGLING_RAW_PTR_CHECKS=\"false\" PUT_REF_COUNT_IN_PREVIOUS_SLOT=\"true\" ENABLE_GWP_ASAN_SUPPORT=\"true\" ENABLE_MTE_CHECKED_PTR_SUPPORT=\"false\" RECORD_ALLOC_INFO=\"false\" USE_FREESLOT_BITMAP=\"false\" ENABLE_SHADOW_METADATA_FOR_64_BITS_POINTERS=\"false\" STARSCAN=\"true\" PA_USE_BASE_TRACING=\"true\" ENABLE_PKEYS=\"true\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//base/allocator/partition_allocator:partition_alloc_buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin; " +
+ "fi; " +
+ "if [[ ( $$CC_ARCH == 'x86' && $$CC_OS == 'android' ) ]]; " +
+ "then " +
+ "echo '--flags ENABLE_PARTITION_ALLOC_AS_MALLOC_SUPPORT=\"true\" ENABLE_BACKUP_REF_PTR_SUPPORT=\"true\" ENABLE_BACKUP_REF_PTR_SLOW_CHECKS=\"false\" ENABLE_DANGLING_RAW_PTR_CHECKS=\"false\" PUT_REF_COUNT_IN_PREVIOUS_SLOT=\"true\" ENABLE_GWP_ASAN_SUPPORT=\"true\" ENABLE_MTE_CHECKED_PTR_SUPPORT=\"false\" RECORD_ALLOC_INFO=\"false\" USE_FREESLOT_BITMAP=\"false\" ENABLE_SHADOW_METADATA_FOR_64_BITS_POINTERS=\"false\" STARSCAN=\"true\" PA_USE_BASE_TRACING=\"true\" ENABLE_PKEYS=\"false\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//base/allocator/partition_allocator:partition_alloc_buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin; " +
+ "fi; " +
+ "if [[ ( $$CC_ARCH == 'arm' && $$CC_OS == 'android' ) ]]; " +
+ "then " +
+ "echo '--flags ENABLE_PARTITION_ALLOC_AS_MALLOC_SUPPORT=\"true\" ENABLE_BACKUP_REF_PTR_SUPPORT=\"true\" ENABLE_BACKUP_REF_PTR_SLOW_CHECKS=\"false\" ENABLE_DANGLING_RAW_PTR_CHECKS=\"false\" PUT_REF_COUNT_IN_PREVIOUS_SLOT=\"true\" ENABLE_GWP_ASAN_SUPPORT=\"true\" ENABLE_MTE_CHECKED_PTR_SUPPORT=\"false\" RECORD_ALLOC_INFO=\"false\" USE_FREESLOT_BITMAP=\"false\" ENABLE_SHADOW_METADATA_FOR_64_BITS_POINTERS=\"false\" STARSCAN=\"true\" PA_USE_BASE_TRACING=\"true\" ENABLE_PKEYS=\"false\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//base/allocator/partition_allocator:partition_alloc_buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin; " +
+ "fi; " +
+ "if [[ ( $$CC_ARCH == 'arm64' && $$CC_OS == 'android' ) ]]; " +
+ "then " +
+ "echo '--flags ENABLE_PARTITION_ALLOC_AS_MALLOC_SUPPORT=\"true\" ENABLE_BACKUP_REF_PTR_SUPPORT=\"true\" ENABLE_BACKUP_REF_PTR_SLOW_CHECKS=\"false\" ENABLE_DANGLING_RAW_PTR_CHECKS=\"false\" PUT_REF_COUNT_IN_PREVIOUS_SLOT=\"true\" ENABLE_GWP_ASAN_SUPPORT=\"true\" ENABLE_MTE_CHECKED_PTR_SUPPORT=\"false\" RECORD_ALLOC_INFO=\"false\" USE_FREESLOT_BITMAP=\"false\" ENABLE_SHADOW_METADATA_FOR_64_BITS_POINTERS=\"false\" STARSCAN=\"true\" PA_USE_BASE_TRACING=\"true\" ENABLE_PKEYS=\"false\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//base/allocator/partition_allocator:partition_alloc_buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin; " +
+ "fi;",
+ host_supported: true,
+ out: [
+ "base/allocator/partition_allocator/partition_alloc_buildflags.h",
+ ],
+ tool_files: [
+ "build/write_buildflag_header.py",
+ ],
+ apex_available: [
+ "com.android.tethering",
+ ],
+}
+
// GN: //base:anchor_functions_buildflags
cc_genrule {
name: "cronet_aml_base_anchor_functions_buildflags",
@@ -363,6 +786,81 @@
],
}
+// GN: //base:anchor_functions_buildflags__testing
+cc_genrule {
+ name: "cronet_aml_base_anchor_functions_buildflags__testing",
+ cmd: "if [[ ( $$CC_ARCH == 'x86_64' && $$CC_OS == 'android' ) ]]; " +
+ "then " +
+ "echo '--flags USE_LLD=\"true\" SUPPORTS_CODE_ORDERING=\"true\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//base:anchor_functions_buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin; " +
+ "fi; " +
+ "if [[ $$CC_OS != 'android' ]]; " +
+ "then " +
+ "echo '--flags USE_LLD=\"true\" SUPPORTS_CODE_ORDERING=\"false\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//base:anchor_functions_buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin; " +
+ "fi; " +
+ "if [[ ( $$CC_ARCH == 'x86' && $$CC_OS == 'android' ) ]]; " +
+ "then " +
+ "echo '--flags USE_LLD=\"true\" SUPPORTS_CODE_ORDERING=\"true\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//base:anchor_functions_buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin; " +
+ "fi; " +
+ "if [[ ( $$CC_ARCH == 'arm' && $$CC_OS == 'android' ) ]]; " +
+ "then " +
+ "echo '--flags USE_LLD=\"true\" SUPPORTS_CODE_ORDERING=\"true\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//base:anchor_functions_buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin; " +
+ "fi; " +
+ "if [[ ( $$CC_ARCH == 'arm64' && $$CC_OS == 'android' ) ]]; " +
+ "then " +
+ "echo '--flags USE_LLD=\"true\" SUPPORTS_CODE_ORDERING=\"true\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//base:anchor_functions_buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin; " +
+ "fi;",
+ host_supported: true,
+ out: [
+ "base/android/library_loader/anchor_functions_buildflags.h",
+ ],
+ tool_files: [
+ "build/write_buildflag_header.py",
+ ],
+ apex_available: [
+ "com.android.tethering",
+ ],
+}
+
// GN: //base:android_runtime_jni_headers
cc_genrule {
name: "cronet_aml_base_android_runtime_jni_headers",
@@ -403,60 +901,48 @@
],
}
+// GN: //base:android_runtime_jni_headers__testing
+cc_genrule {
+ name: "cronet_aml_base_android_runtime_jni_headers__testing",
+ cmd: "$(location base/android/jni_generator/jni_generator.py) --ptr_type " +
+ "long " +
+ "--output_dir " +
+ "$(genDir)/base/android_runtime_jni_headers " +
+ "--includes " +
+ "base/android/jni_generator/jni_generator_helper.h " +
+ "--jar_file " +
+ "$(location :current_android_jar) " +
+ "--output_name " +
+ "Runnable_jni.h " +
+ "--output_name " +
+ "Runtime_jni.h " +
+ "--input_file " +
+ "java/lang/Runnable.class " +
+ "--input_file " +
+ "java/lang/Runtime.class " +
+ "--javap " +
+ "$$(find $${OUT_DIR:-out}/.path -name javap)",
+ out: [
+ "base/android_runtime_jni_headers/Runnable_jni.h",
+ "base/android_runtime_jni_headers/Runtime_jni.h",
+ ],
+ tool_files: [
+ ":current_android_jar",
+ "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: //base:base
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",
@@ -898,9 +1384,60 @@
static_libs: [
"cronet_aml_base_allocator_partition_allocator_partition_alloc",
"cronet_aml_base_base_static",
+ "cronet_aml_base_nodebug_assertion",
"cronet_aml_base_third_party_double_conversion_double_conversion",
"cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations",
+ "cronet_aml_third_party_abseil_cpp_absl_base_base",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+ "cronet_aml_third_party_abseil_cpp_absl_base_strerror",
+ "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+ "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler",
+ "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_city",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_hash",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+ "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
+ "cronet_aml_third_party_abseil_cpp_absl_random_distributions",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material",
+ "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception",
+ "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences",
+ "cronet_aml_third_party_abseil_cpp_absl_status_status",
+ "cronet_aml_third_party_abseil_cpp_absl_status_statusor",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cord",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+ "cronet_aml_third_party_abseil_cpp_absl_time_time",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access",
+ "cronet_aml_third_party_android_ndk_cpu_features",
+ "cronet_aml_third_party_ashmem_ashmem",
"cronet_aml_third_party_boringssl_boringssl",
+ "cronet_aml_third_party_boringssl_boringssl_asm",
"cronet_aml_third_party_icu_icui18n",
"cronet_aml_third_party_icu_icuuc_private",
"cronet_aml_third_party_libevent_libevent",
@@ -972,6 +1509,7 @@
"-DHAVE_SYS_UIO_H",
"-DICU_UTIL_DATA_IMPL=ICU_UTIL_DATA_FILE",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-DUSE_CHROMIUM_ICU=1",
@@ -986,6 +1524,14 @@
"-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",
+ "-fvisibility-inlines-hidden",
+ "-fvisibility=hidden",
+ "-g1",
],
local_include_dirs: [
"./",
@@ -1002,6 +1548,27 @@
"libgtest_prod_headers",
],
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: {
srcs: [
@@ -1011,11 +1578,19 @@
"base/profiler/chrome_unwinder_android_v2.cc",
"base/trace_event/cfi_backtrace_android.cc",
],
+ cflags: [
+ "-fstack-protector",
+ ],
},
android_arm64: {
srcs: [
"base/android/reached_code_profiler.cc",
],
+ cflags: [
+ "-fstack-protector",
+ "-mno-outline",
+ "-mno-outline-atomics",
+ ],
},
android_x86: {
srcs: [
@@ -1030,12 +1605,1031 @@
"base/android/reached_code_profiler_stub.cc",
],
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //base:base__testing
+cc_library_static {
+ name: "cronet_aml_base_base__testing",
+ srcs: [
+ "base/allocator/allocator_check.cc",
+ "base/allocator/allocator_extension.cc",
+ "base/allocator/dispatcher/dispatcher.cc",
+ "base/allocator/dispatcher/internal/dispatch_data.cc",
+ "base/allocator/dispatcher/reentry_guard.cc",
+ "base/allocator/partition_allocator/shim/allocator_shim.cc",
+ "base/at_exit.cc",
+ "base/barrier_closure.cc",
+ "base/base64.cc",
+ "base/base64url.cc",
+ "base/base_paths.cc",
+ "base/big_endian.cc",
+ "base/build_time.cc",
+ "base/callback_list.cc",
+ "base/check.cc",
+ "base/check_is_test.cc",
+ "base/check_op.cc",
+ "base/command_line.cc",
+ "base/containers/flat_tree.cc",
+ "base/containers/intrusive_heap.cc",
+ "base/containers/linked_list.cc",
+ "base/cpu.cc",
+ "base/cpu_reduction_experiment.cc",
+ "base/debug/activity_analyzer.cc",
+ "base/debug/activity_tracker.cc",
+ "base/debug/alias.cc",
+ "base/debug/asan_invalid_access.cc",
+ "base/debug/buffered_dwarf_reader.cc",
+ "base/debug/crash_logging.cc",
+ "base/debug/debugger.cc",
+ "base/debug/debugger_posix.cc",
+ "base/debug/dump_without_crashing.cc",
+ "base/debug/dwarf_line_no.cc",
+ "base/debug/elf_reader.cc",
+ "base/debug/proc_maps_linux.cc",
+ "base/debug/profiler.cc",
+ "base/debug/stack_trace.cc",
+ "base/debug/task_trace.cc",
+ "base/environment.cc",
+ "base/feature_list.cc",
+ "base/features.cc",
+ "base/file_descriptor_posix.cc",
+ "base/file_descriptor_store.cc",
+ "base/files/file.cc",
+ "base/files/file_descriptor_watcher_posix.cc",
+ "base/files/file_enumerator.cc",
+ "base/files/file_enumerator_posix.cc",
+ "base/files/file_path.cc",
+ "base/files/file_path_watcher.cc",
+ "base/files/file_path_watcher_inotify.cc",
+ "base/files/file_posix.cc",
+ "base/files/file_proxy.cc",
+ "base/files/file_tracing.cc",
+ "base/files/file_util.cc",
+ "base/files/file_util_posix.cc",
+ "base/files/important_file_writer.cc",
+ "base/files/important_file_writer_cleaner.cc",
+ "base/files/memory_mapped_file.cc",
+ "base/files/memory_mapped_file_posix.cc",
+ "base/files/safe_base_name.cc",
+ "base/files/scoped_file.cc",
+ "base/files/scoped_temp_dir.cc",
+ "base/functional/callback_helpers.cc",
+ "base/functional/callback_internal.cc",
+ "base/guid.cc",
+ "base/hash/hash.cc",
+ "base/hash/legacy_hash.cc",
+ "base/hash/md5_boringssl.cc",
+ "base/hash/sha1_boringssl.cc",
+ "base/json/json_file_value_serializer.cc",
+ "base/json/json_parser.cc",
+ "base/json/json_reader.cc",
+ "base/json/json_string_value_serializer.cc",
+ "base/json/json_value_converter.cc",
+ "base/json/json_writer.cc",
+ "base/json/string_escape.cc",
+ "base/json/values_util.cc",
+ "base/lazy_instance_helpers.cc",
+ "base/linux_util.cc",
+ "base/location.cc",
+ "base/logging.cc",
+ "base/memory/aligned_memory.cc",
+ "base/memory/discardable_memory.cc",
+ "base/memory/discardable_memory_allocator.cc",
+ "base/memory/discardable_shared_memory.cc",
+ "base/memory/madv_free_discardable_memory_allocator_posix.cc",
+ "base/memory/madv_free_discardable_memory_posix.cc",
+ "base/memory/memory_pressure_listener.cc",
+ "base/memory/memory_pressure_monitor.cc",
+ "base/memory/nonscannable_memory.cc",
+ "base/memory/page_size_posix.cc",
+ "base/memory/platform_shared_memory_handle.cc",
+ "base/memory/platform_shared_memory_region.cc",
+ "base/memory/raw_ptr.cc",
+ "base/memory/raw_ptr_asan_bound_arg_tracker.cc",
+ "base/memory/raw_ptr_asan_service.cc",
+ "base/memory/read_only_shared_memory_region.cc",
+ "base/memory/ref_counted.cc",
+ "base/memory/ref_counted_memory.cc",
+ "base/memory/shared_memory_mapper.cc",
+ "base/memory/shared_memory_mapping.cc",
+ "base/memory/shared_memory_security_policy.cc",
+ "base/memory/shared_memory_tracker.cc",
+ "base/memory/unsafe_shared_memory_pool.cc",
+ "base/memory/unsafe_shared_memory_region.cc",
+ "base/memory/weak_ptr.cc",
+ "base/memory/writable_shared_memory_region.cc",
+ "base/message_loop/message_pump.cc",
+ "base/message_loop/message_pump_default.cc",
+ "base/message_loop/message_pump_epoll.cc",
+ "base/message_loop/message_pump_libevent.cc",
+ "base/message_loop/watchable_io_message_pump_posix.cc",
+ "base/message_loop/work_id_provider.cc",
+ "base/metrics/bucket_ranges.cc",
+ "base/metrics/crc32.cc",
+ "base/metrics/dummy_histogram.cc",
+ "base/metrics/field_trial.cc",
+ "base/metrics/field_trial_param_associator.cc",
+ "base/metrics/field_trial_params.cc",
+ "base/metrics/histogram.cc",
+ "base/metrics/histogram_base.cc",
+ "base/metrics/histogram_delta_serialization.cc",
+ "base/metrics/histogram_functions.cc",
+ "base/metrics/histogram_samples.cc",
+ "base/metrics/histogram_snapshot_manager.cc",
+ "base/metrics/metrics_hashes.cc",
+ "base/metrics/persistent_histogram_allocator.cc",
+ "base/metrics/persistent_histogram_storage.cc",
+ "base/metrics/persistent_memory_allocator.cc",
+ "base/metrics/persistent_sample_map.cc",
+ "base/metrics/ranges_manager.cc",
+ "base/metrics/sample_map.cc",
+ "base/metrics/sample_vector.cc",
+ "base/metrics/single_sample_metrics.cc",
+ "base/metrics/sparse_histogram.cc",
+ "base/metrics/statistics_recorder.cc",
+ "base/metrics/user_metrics.cc",
+ "base/native_library.cc",
+ "base/native_library_posix.cc",
+ "base/observer_list_internal.cc",
+ "base/observer_list_threadsafe.cc",
+ "base/observer_list_types.cc",
+ "base/one_shot_event.cc",
+ "base/path_service.cc",
+ "base/pending_task.cc",
+ "base/pickle.cc",
+ "base/posix/can_lower_nice_to.cc",
+ "base/posix/file_descriptor_shuffle.cc",
+ "base/posix/global_descriptors.cc",
+ "base/posix/safe_strerror.cc",
+ "base/posix/unix_domain_socket.cc",
+ "base/power_monitor/battery_level_provider.cc",
+ "base/power_monitor/battery_state_sampler.cc",
+ "base/power_monitor/moving_average.cc",
+ "base/power_monitor/power_monitor.cc",
+ "base/power_monitor/power_monitor_device_source.cc",
+ "base/power_monitor/power_monitor_features.cc",
+ "base/power_monitor/power_monitor_source.cc",
+ "base/power_monitor/sampling_event_source.cc",
+ "base/power_monitor/timer_sampling_event_source.cc",
+ "base/process/environment_internal.cc",
+ "base/process/internal_linux.cc",
+ "base/process/kill.cc",
+ "base/process/kill_posix.cc",
+ "base/process/launch.cc",
+ "base/process/launch_posix.cc",
+ "base/process/memory.cc",
+ "base/process/memory_linux.cc",
+ "base/process/process_handle.cc",
+ "base/process/process_handle_linux.cc",
+ "base/process/process_handle_posix.cc",
+ "base/process/process_iterator.cc",
+ "base/process/process_iterator_linux.cc",
+ "base/process/process_metrics.cc",
+ "base/process/process_metrics_linux.cc",
+ "base/process/process_metrics_posix.cc",
+ "base/process/process_posix.cc",
+ "base/profiler/arm_cfi_table.cc",
+ "base/profiler/frame.cc",
+ "base/profiler/metadata_recorder.cc",
+ "base/profiler/module_cache.cc",
+ "base/profiler/module_cache_posix.cc",
+ "base/profiler/sample_metadata.cc",
+ "base/profiler/sampling_profiler_thread_token.cc",
+ "base/profiler/stack_base_address_posix.cc",
+ "base/profiler/stack_buffer.cc",
+ "base/profiler/stack_copier.cc",
+ "base/profiler/stack_copier_signal.cc",
+ "base/profiler/stack_copier_suspend.cc",
+ "base/profiler/stack_sampler.cc",
+ "base/profiler/stack_sampler_impl.cc",
+ "base/profiler/stack_sampling_profiler.cc",
+ "base/profiler/thread_delegate_posix.cc",
+ "base/profiler/unwinder.cc",
+ "base/rand_util.cc",
+ "base/rand_util_posix.cc",
+ "base/run_loop.cc",
+ "base/sampling_heap_profiler/lock_free_address_hash_set.cc",
+ "base/sampling_heap_profiler/poisson_allocation_sampler.cc",
+ "base/sampling_heap_profiler/sampling_heap_profiler.cc",
+ "base/scoped_add_feature_flags.cc",
+ "base/scoped_environment_variable_override.cc",
+ "base/scoped_native_library.cc",
+ "base/sequence_checker.cc",
+ "base/sequence_checker_impl.cc",
+ "base/sequence_token.cc",
+ "base/strings/abseil_string_conversions.cc",
+ "base/strings/abseil_string_number_conversions.cc",
+ "base/strings/escape.cc",
+ "base/strings/latin1_string_conversions.cc",
+ "base/strings/pattern.cc",
+ "base/strings/safe_sprintf.cc",
+ "base/strings/strcat.cc",
+ "base/strings/string_number_conversions.cc",
+ "base/strings/string_piece.cc",
+ "base/strings/string_split.cc",
+ "base/strings/string_util.cc",
+ "base/strings/string_util_constants.cc",
+ "base/strings/stringprintf.cc",
+ "base/strings/sys_string_conversions_posix.cc",
+ "base/strings/utf_offset_string_conversions.cc",
+ "base/strings/utf_string_conversion_utils.cc",
+ "base/strings/utf_string_conversions.cc",
+ "base/substring_set_matcher/matcher_string_pattern.cc",
+ "base/substring_set_matcher/substring_set_matcher.cc",
+ "base/supports_user_data.cc",
+ "base/sync_socket.cc",
+ "base/sync_socket_posix.cc",
+ "base/synchronization/atomic_flag.cc",
+ "base/synchronization/condition_variable_posix.cc",
+ "base/synchronization/lock.cc",
+ "base/synchronization/lock_impl_posix.cc",
+ "base/synchronization/waitable_event_posix.cc",
+ "base/synchronization/waitable_event_watcher_posix.cc",
+ "base/syslog_logging.cc",
+ "base/system/sys_info.cc",
+ "base/system/sys_info_linux.cc",
+ "base/system/sys_info_posix.cc",
+ "base/system/system_monitor.cc",
+ "base/task/cancelable_task_tracker.cc",
+ "base/task/common/checked_lock_impl.cc",
+ "base/task/common/lazy_now.cc",
+ "base/task/common/operations_controller.cc",
+ "base/task/common/scoped_defer_task_posting.cc",
+ "base/task/common/task_annotator.cc",
+ "base/task/current_thread.cc",
+ "base/task/default_delayed_task_handle_delegate.cc",
+ "base/task/deferred_sequenced_task_runner.cc",
+ "base/task/delayed_task_handle.cc",
+ "base/task/lazy_thread_pool_task_runner.cc",
+ "base/task/post_job.cc",
+ "base/task/scoped_set_task_priority_for_current_thread.cc",
+ "base/task/sequence_manager/associated_thread_id.cc",
+ "base/task/sequence_manager/atomic_flag_set.cc",
+ "base/task/sequence_manager/delayed_task_handle_delegate.cc",
+ "base/task/sequence_manager/enqueue_order_generator.cc",
+ "base/task/sequence_manager/fence.cc",
+ "base/task/sequence_manager/hierarchical_timing_wheel.cc",
+ "base/task/sequence_manager/sequence_manager.cc",
+ "base/task/sequence_manager/sequence_manager_impl.cc",
+ "base/task/sequence_manager/sequenced_task_source.cc",
+ "base/task/sequence_manager/task_order.cc",
+ "base/task/sequence_manager/task_queue.cc",
+ "base/task/sequence_manager/task_queue_impl.cc",
+ "base/task/sequence_manager/task_queue_selector.cc",
+ "base/task/sequence_manager/tasks.cc",
+ "base/task/sequence_manager/thread_controller.cc",
+ "base/task/sequence_manager/thread_controller_impl.cc",
+ "base/task/sequence_manager/thread_controller_power_monitor.cc",
+ "base/task/sequence_manager/thread_controller_with_message_pump_impl.cc",
+ "base/task/sequence_manager/time_domain.cc",
+ "base/task/sequence_manager/timing_wheel.cc",
+ "base/task/sequence_manager/wake_up_queue.cc",
+ "base/task/sequence_manager/work_deduplicator.cc",
+ "base/task/sequence_manager/work_queue.cc",
+ "base/task/sequence_manager/work_queue_sets.cc",
+ "base/task/sequenced_task_runner.cc",
+ "base/task/simple_task_executor.cc",
+ "base/task/single_thread_task_executor.cc",
+ "base/task/single_thread_task_runner.cc",
+ "base/task/task_executor.cc",
+ "base/task/task_features.cc",
+ "base/task/task_runner.cc",
+ "base/task/task_traits.cc",
+ "base/task/thread_pool.cc",
+ "base/task/thread_pool/delayed_priority_queue.cc",
+ "base/task/thread_pool/delayed_task_manager.cc",
+ "base/task/thread_pool/environment_config.cc",
+ "base/task/thread_pool/initialization_util.cc",
+ "base/task/thread_pool/job_task_source.cc",
+ "base/task/thread_pool/pooled_parallel_task_runner.cc",
+ "base/task/thread_pool/pooled_sequenced_task_runner.cc",
+ "base/task/thread_pool/pooled_single_thread_task_runner_manager.cc",
+ "base/task/thread_pool/pooled_task_runner_delegate.cc",
+ "base/task/thread_pool/priority_queue.cc",
+ "base/task/thread_pool/sequence.cc",
+ "base/task/thread_pool/service_thread.cc",
+ "base/task/thread_pool/task.cc",
+ "base/task/thread_pool/task_source.cc",
+ "base/task/thread_pool/task_source_sort_key.cc",
+ "base/task/thread_pool/task_tracker.cc",
+ "base/task/thread_pool/thread_group.cc",
+ "base/task/thread_pool/thread_group_impl.cc",
+ "base/task/thread_pool/thread_group_native.cc",
+ "base/task/thread_pool/thread_pool_impl.cc",
+ "base/task/thread_pool/thread_pool_instance.cc",
+ "base/task/thread_pool/worker_thread.cc",
+ "base/task/thread_pool/worker_thread_stack.cc",
+ "base/third_party/cityhash/city.cc",
+ "base/third_party/cityhash_v103/src/city_v103.cc",
+ "base/third_party/nspr/prtime.cc",
+ "base/third_party/superfasthash/superfasthash.c",
+ "base/threading/hang_watcher.cc",
+ "base/threading/platform_thread.cc",
+ "base/threading/platform_thread_internal_posix.cc",
+ "base/threading/platform_thread_posix.cc",
+ "base/threading/platform_thread_ref.cc",
+ "base/threading/post_task_and_reply_impl.cc",
+ "base/threading/scoped_blocking_call.cc",
+ "base/threading/scoped_blocking_call_internal.cc",
+ "base/threading/scoped_thread_priority.cc",
+ "base/threading/sequence_local_storage_map.cc",
+ "base/threading/sequence_local_storage_slot.cc",
+ "base/threading/sequenced_task_runner_handle.cc",
+ "base/threading/simple_thread.cc",
+ "base/threading/thread.cc",
+ "base/threading/thread_checker.cc",
+ "base/threading/thread_checker_impl.cc",
+ "base/threading/thread_collision_warner.cc",
+ "base/threading/thread_id_name_manager.cc",
+ "base/threading/thread_local_storage.cc",
+ "base/threading/thread_local_storage_posix.cc",
+ "base/threading/thread_restrictions.cc",
+ "base/threading/thread_task_runner_handle.cc",
+ "base/threading/watchdog.cc",
+ "base/time/clock.cc",
+ "base/time/default_clock.cc",
+ "base/time/default_tick_clock.cc",
+ "base/time/tick_clock.cc",
+ "base/time/time.cc",
+ "base/time/time_conversion_posix.cc",
+ "base/time/time_delta_from_string.cc",
+ "base/time/time_exploded_icu.cc",
+ "base/time/time_exploded_posix.cc",
+ "base/time/time_now_posix.cc",
+ "base/time/time_override.cc",
+ "base/time/time_to_iso8601.cc",
+ "base/timer/elapsed_timer.cc",
+ "base/timer/hi_res_timer_manager_posix.cc",
+ "base/timer/lap_timer.cc",
+ "base/timer/timer.cc",
+ "base/timer/wall_clock_timer.cc",
+ "base/token.cc",
+ "base/trace_event/heap_profiler_allocation_context.cc",
+ "base/trace_event/heap_profiler_allocation_context_tracker.cc",
+ "base/trace_event/memory_allocator_dump_guid.cc",
+ "base/trace_event/trace_event_stub.cc",
+ "base/trace_event/trace_id_helper.cc",
+ "base/unguessable_token.cc",
+ "base/value_iterators.cc",
+ "base/values.cc",
+ "base/version.cc",
+ "base/vlog.cc",
+ ],
+ 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",
+ "cronet_aml_third_party_modp_b64_modp_b64__testing",
+ ],
+ host_supported: true,
+ generated_headers: [
+ "cronet_aml_base_allocator_buildflags__testing",
+ "cronet_aml_base_anchor_functions_buildflags__testing",
+ "cronet_aml_base_build_date__testing",
+ "cronet_aml_base_cfi_buildflags__testing",
+ "cronet_aml_base_clang_profiling_buildflags__testing",
+ "cronet_aml_base_debugging_buildflags__testing",
+ "cronet_aml_base_feature_list_buildflags__testing",
+ "cronet_aml_base_ios_cronet_buildflags__testing",
+ "cronet_aml_base_logging_buildflags__testing",
+ "cronet_aml_base_message_pump_buildflags__testing",
+ "cronet_aml_base_orderfile_buildflags__testing",
+ "cronet_aml_base_parsing_buildflags__testing",
+ "cronet_aml_base_power_monitor_buildflags__testing",
+ "cronet_aml_base_profiler_buildflags__testing",
+ "cronet_aml_base_sanitizer_buildflags__testing",
+ "cronet_aml_base_synchronization_buildflags__testing",
+ "cronet_aml_base_tracing_buildflags__testing",
+ "cronet_aml_build_branding_buildflags__testing",
+ "cronet_aml_build_chromecast_buildflags__testing",
+ "cronet_aml_build_chromeos_buildflags__testing",
+ "cronet_aml_build_config_compiler_compiler_buildflags__testing",
+ ],
+ export_generated_headers: [
+ "cronet_aml_base_allocator_buildflags__testing",
+ "cronet_aml_base_anchor_functions_buildflags__testing",
+ "cronet_aml_base_build_date__testing",
+ "cronet_aml_base_cfi_buildflags__testing",
+ "cronet_aml_base_clang_profiling_buildflags__testing",
+ "cronet_aml_base_debugging_buildflags__testing",
+ "cronet_aml_base_feature_list_buildflags__testing",
+ "cronet_aml_base_ios_cronet_buildflags__testing",
+ "cronet_aml_base_logging_buildflags__testing",
+ "cronet_aml_base_message_pump_buildflags__testing",
+ "cronet_aml_base_orderfile_buildflags__testing",
+ "cronet_aml_base_parsing_buildflags__testing",
+ "cronet_aml_base_power_monitor_buildflags__testing",
+ "cronet_aml_base_profiler_buildflags__testing",
+ "cronet_aml_base_sanitizer_buildflags__testing",
+ "cronet_aml_base_synchronization_buildflags__testing",
+ "cronet_aml_base_tracing_buildflags__testing",
+ "cronet_aml_build_branding_buildflags__testing",
+ "cronet_aml_build_chromecast_buildflags__testing",
+ "cronet_aml_build_chromeos_buildflags__testing",
+ "cronet_aml_build_config_compiler_compiler_buildflags__testing",
+ ],
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DBASE_IMPLEMENTATION",
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DICU_UTIL_DATA_IMPL=ICU_UTIL_DATA_FILE",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-DUSE_CHROMIUM_ICU=1",
+ "-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",
+ "-O2",
+ "-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/",
+ "third_party/icu/source/common/",
+ "third_party/icu/source/i18n/",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ "-Wl,--script,external/cronet/base/android/library_loader/anchor_functions.lds",
+ ],
+ target: {
+ android: {
+ shared_libs: [
+ "libandroid",
+ "liblog",
+ ],
+ },
+ android_arm: {
+ srcs: [
+ "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",
+ "base/android/apk_assets.cc",
+ "base/android/application_status_listener.cc",
+ "base/android/base_feature_list.cc",
+ "base/android/base_features.cc",
+ "base/android/base_jni_onload.cc",
+ "base/android/build_info.cc",
+ "base/android/bundle_utils.cc",
+ "base/android/callback_android.cc",
+ "base/android/child_process_service.cc",
+ "base/android/command_line_android.cc",
+ "base/android/content_uri_utils.cc",
+ "base/android/cpu_features.cc",
+ "base/android/early_trace_event_binding.cc",
+ "base/android/event_log.cc",
+ "base/android/feature_list_jni.cc",
+ "base/android/features_jni.cc",
+ "base/android/field_trial_list.cc",
+ "base/android/important_file_writer_android.cc",
+ "base/android/int_string_callback.cc",
+ "base/android/jank_metric_uma_recorder.cc",
+ "base/android/java_exception_reporter.cc",
+ "base/android/java_handler_thread.cc",
+ "base/android/java_heap_dump_generator.cc",
+ "base/android/java_runtime.cc",
+ "base/android/jni_android.cc",
+ "base/android/jni_array.cc",
+ "base/android/jni_registrar.cc",
+ "base/android/jni_string.cc",
+ "base/android/jni_utils.cc",
+ "base/android/jni_weak_ref.cc",
+ "base/android/library_loader/anchor_functions.cc",
+ "base/android/library_loader/library_loader_hooks.cc",
+ "base/android/library_loader/library_prefetcher.cc",
+ "base/android/library_loader/library_prefetcher_hooks.cc",
+ "base/android/locale_utils.cc",
+ "base/android/memory_pressure_listener_android.cc",
+ "base/android/native_uma_recorder.cc",
+ "base/android/path_service_android.cc",
+ "base/android/path_utils.cc",
+ "base/android/radio_utils.cc",
+ "base/android/reached_addresses_bitset.cc",
+ "base/android/reached_code_profiler.cc",
+ "base/android/remove_stale_data.cc",
+ "base/android/scoped_hardware_buffer_fence_sync.cc",
+ "base/android/scoped_hardware_buffer_handle.cc",
+ "base/android/scoped_java_ref.cc",
+ "base/android/statistics_recorder_android.cc",
+ "base/android/sys_utils.cc",
+ "base/android/task_scheduler/post_task_android.cc",
+ "base/android/task_scheduler/task_runner_android.cc",
+ "base/android/thread_instruction_count.cc",
+ "base/android/timezone_utils.cc",
+ "base/android/trace_event_binding.cc",
+ "base/android/unguessable_token_android.cc",
+ "base/base_paths_android.cc",
+ "base/debug/stack_trace_android.cc",
+ "base/files/file_util_android.cc",
+ "base/files/scoped_file_android.cc",
+ "base/memory/platform_shared_memory_mapper_android.cc",
+ "base/memory/platform_shared_memory_region_android.cc",
+ "base/message_loop/message_pump_android.cc",
+ "base/os_compat_android.cc",
+ "base/power_monitor/power_monitor_device_source_android.cc",
+ "base/process/process_android.cc",
+ "base/profiler/chrome_unwind_info_android.cc",
+ "base/profiler/chrome_unwinder_android.cc",
+ "base/profiler/chrome_unwinder_android_v2.cc",
+ "base/profiler/stack_sampler_android.cc",
+ "base/system/sys_info_android.cc",
+ "base/threading/platform_thread_android.cc",
+ "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",
+ "-DHAVE_SYS_UIO_H",
+ "-fstack-protector",
+ ],
+ local_include_dirs: [
+ "third_party/android_ndk/sources/android/cpufeatures/",
+ ],
+ 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",
+ "-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",
+ ],
+ },
+ android_arm64: {
+ srcs: [
+ "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",
+ "base/android/apk_assets.cc",
+ "base/android/application_status_listener.cc",
+ "base/android/base_feature_list.cc",
+ "base/android/base_features.cc",
+ "base/android/base_jni_onload.cc",
+ "base/android/build_info.cc",
+ "base/android/bundle_utils.cc",
+ "base/android/callback_android.cc",
+ "base/android/child_process_service.cc",
+ "base/android/command_line_android.cc",
+ "base/android/content_uri_utils.cc",
+ "base/android/cpu_features.cc",
+ "base/android/early_trace_event_binding.cc",
+ "base/android/event_log.cc",
+ "base/android/feature_list_jni.cc",
+ "base/android/features_jni.cc",
+ "base/android/field_trial_list.cc",
+ "base/android/important_file_writer_android.cc",
+ "base/android/int_string_callback.cc",
+ "base/android/jank_metric_uma_recorder.cc",
+ "base/android/java_exception_reporter.cc",
+ "base/android/java_handler_thread.cc",
+ "base/android/java_heap_dump_generator.cc",
+ "base/android/java_runtime.cc",
+ "base/android/jni_android.cc",
+ "base/android/jni_array.cc",
+ "base/android/jni_registrar.cc",
+ "base/android/jni_string.cc",
+ "base/android/jni_utils.cc",
+ "base/android/jni_weak_ref.cc",
+ "base/android/library_loader/anchor_functions.cc",
+ "base/android/library_loader/library_loader_hooks.cc",
+ "base/android/library_loader/library_prefetcher.cc",
+ "base/android/library_loader/library_prefetcher_hooks.cc",
+ "base/android/locale_utils.cc",
+ "base/android/memory_pressure_listener_android.cc",
+ "base/android/native_uma_recorder.cc",
+ "base/android/path_service_android.cc",
+ "base/android/path_utils.cc",
+ "base/android/radio_utils.cc",
+ "base/android/reached_addresses_bitset.cc",
+ "base/android/reached_code_profiler.cc",
+ "base/android/remove_stale_data.cc",
+ "base/android/scoped_hardware_buffer_fence_sync.cc",
+ "base/android/scoped_hardware_buffer_handle.cc",
+ "base/android/scoped_java_ref.cc",
+ "base/android/statistics_recorder_android.cc",
+ "base/android/sys_utils.cc",
+ "base/android/task_scheduler/post_task_android.cc",
+ "base/android/task_scheduler/task_runner_android.cc",
+ "base/android/thread_instruction_count.cc",
+ "base/android/timezone_utils.cc",
+ "base/android/trace_event_binding.cc",
+ "base/android/unguessable_token_android.cc",
+ "base/base_paths_android.cc",
+ "base/debug/stack_trace_android.cc",
+ "base/files/file_util_android.cc",
+ "base/files/scoped_file_android.cc",
+ "base/memory/platform_shared_memory_mapper_android.cc",
+ "base/memory/platform_shared_memory_region_android.cc",
+ "base/message_loop/message_pump_android.cc",
+ "base/os_compat_android.cc",
+ "base/power_monitor/power_monitor_device_source_android.cc",
+ "base/process/process_android.cc",
+ "base/profiler/stack_sampler_android.cc",
+ "base/system/sys_info_android.cc",
+ "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",
+ "-DHAVE_SYS_UIO_H",
+ "-fstack-protector",
+ "-mno-outline",
+ "-mno-outline-atomics",
+ ],
+ local_include_dirs: [
+ "third_party/android_ndk/sources/android/cpufeatures/",
+ ],
+ 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",
+ "-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",
+ ],
+ },
+ android_x86: {
+ srcs: [
+ "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",
+ "base/android/apk_assets.cc",
+ "base/android/application_status_listener.cc",
+ "base/android/base_feature_list.cc",
+ "base/android/base_features.cc",
+ "base/android/base_jni_onload.cc",
+ "base/android/build_info.cc",
+ "base/android/bundle_utils.cc",
+ "base/android/callback_android.cc",
+ "base/android/child_process_service.cc",
+ "base/android/command_line_android.cc",
+ "base/android/content_uri_utils.cc",
+ "base/android/cpu_features.cc",
+ "base/android/early_trace_event_binding.cc",
+ "base/android/event_log.cc",
+ "base/android/feature_list_jni.cc",
+ "base/android/features_jni.cc",
+ "base/android/field_trial_list.cc",
+ "base/android/important_file_writer_android.cc",
+ "base/android/int_string_callback.cc",
+ "base/android/jank_metric_uma_recorder.cc",
+ "base/android/java_exception_reporter.cc",
+ "base/android/java_handler_thread.cc",
+ "base/android/java_heap_dump_generator.cc",
+ "base/android/java_runtime.cc",
+ "base/android/jni_android.cc",
+ "base/android/jni_array.cc",
+ "base/android/jni_registrar.cc",
+ "base/android/jni_string.cc",
+ "base/android/jni_utils.cc",
+ "base/android/jni_weak_ref.cc",
+ "base/android/library_loader/anchor_functions.cc",
+ "base/android/library_loader/library_loader_hooks.cc",
+ "base/android/library_loader/library_prefetcher.cc",
+ "base/android/library_loader/library_prefetcher_hooks.cc",
+ "base/android/locale_utils.cc",
+ "base/android/memory_pressure_listener_android.cc",
+ "base/android/native_uma_recorder.cc",
+ "base/android/path_service_android.cc",
+ "base/android/path_utils.cc",
+ "base/android/radio_utils.cc",
+ "base/android/reached_addresses_bitset.cc",
+ "base/android/reached_code_profiler_stub.cc",
+ "base/android/remove_stale_data.cc",
+ "base/android/scoped_hardware_buffer_fence_sync.cc",
+ "base/android/scoped_hardware_buffer_handle.cc",
+ "base/android/scoped_java_ref.cc",
+ "base/android/statistics_recorder_android.cc",
+ "base/android/sys_utils.cc",
+ "base/android/task_scheduler/post_task_android.cc",
+ "base/android/task_scheduler/task_runner_android.cc",
+ "base/android/thread_instruction_count.cc",
+ "base/android/timezone_utils.cc",
+ "base/android/trace_event_binding.cc",
+ "base/android/unguessable_token_android.cc",
+ "base/base_paths_android.cc",
+ "base/debug/stack_trace_android.cc",
+ "base/files/file_util_android.cc",
+ "base/files/scoped_file_android.cc",
+ "base/memory/platform_shared_memory_mapper_android.cc",
+ "base/memory/platform_shared_memory_region_android.cc",
+ "base/message_loop/message_pump_android.cc",
+ "base/os_compat_android.cc",
+ "base/power_monitor/power_monitor_device_source_android.cc",
+ "base/process/process_android.cc",
+ "base/profiler/stack_sampler_android.cc",
+ "base/system/sys_info_android.cc",
+ "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",
+ "-DHAVE_SYS_UIO_H",
+ "-msse3",
+ ],
+ local_include_dirs: [
+ "third_party/android_ndk/sources/android/cpufeatures/",
+ ],
+ 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",
+ "-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",
+ ],
+ },
+ android_x86_64: {
+ srcs: [
+ "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",
+ "base/android/apk_assets.cc",
+ "base/android/application_status_listener.cc",
+ "base/android/base_feature_list.cc",
+ "base/android/base_features.cc",
+ "base/android/base_jni_onload.cc",
+ "base/android/build_info.cc",
+ "base/android/bundle_utils.cc",
+ "base/android/callback_android.cc",
+ "base/android/child_process_service.cc",
+ "base/android/command_line_android.cc",
+ "base/android/content_uri_utils.cc",
+ "base/android/cpu_features.cc",
+ "base/android/early_trace_event_binding.cc",
+ "base/android/event_log.cc",
+ "base/android/feature_list_jni.cc",
+ "base/android/features_jni.cc",
+ "base/android/field_trial_list.cc",
+ "base/android/important_file_writer_android.cc",
+ "base/android/int_string_callback.cc",
+ "base/android/jank_metric_uma_recorder.cc",
+ "base/android/java_exception_reporter.cc",
+ "base/android/java_handler_thread.cc",
+ "base/android/java_heap_dump_generator.cc",
+ "base/android/java_runtime.cc",
+ "base/android/jni_android.cc",
+ "base/android/jni_array.cc",
+ "base/android/jni_registrar.cc",
+ "base/android/jni_string.cc",
+ "base/android/jni_utils.cc",
+ "base/android/jni_weak_ref.cc",
+ "base/android/library_loader/anchor_functions.cc",
+ "base/android/library_loader/library_loader_hooks.cc",
+ "base/android/library_loader/library_prefetcher.cc",
+ "base/android/library_loader/library_prefetcher_hooks.cc",
+ "base/android/locale_utils.cc",
+ "base/android/memory_pressure_listener_android.cc",
+ "base/android/native_uma_recorder.cc",
+ "base/android/path_service_android.cc",
+ "base/android/path_utils.cc",
+ "base/android/radio_utils.cc",
+ "base/android/reached_addresses_bitset.cc",
+ "base/android/reached_code_profiler_stub.cc",
+ "base/android/remove_stale_data.cc",
+ "base/android/scoped_hardware_buffer_fence_sync.cc",
+ "base/android/scoped_hardware_buffer_handle.cc",
+ "base/android/scoped_java_ref.cc",
+ "base/android/statistics_recorder_android.cc",
+ "base/android/sys_utils.cc",
+ "base/android/task_scheduler/post_task_android.cc",
+ "base/android/task_scheduler/task_runner_android.cc",
+ "base/android/thread_instruction_count.cc",
+ "base/android/timezone_utils.cc",
+ "base/android/trace_event_binding.cc",
+ "base/android/unguessable_token_android.cc",
+ "base/base_paths_android.cc",
+ "base/debug/stack_trace_android.cc",
+ "base/files/file_util_android.cc",
+ "base/files/scoped_file_android.cc",
+ "base/memory/platform_shared_memory_mapper_android.cc",
+ "base/memory/platform_shared_memory_region_android.cc",
+ "base/message_loop/message_pump_android.cc",
+ "base/os_compat_android.cc",
+ "base/power_monitor/power_monitor_device_source_android.cc",
+ "base/process/process_android.cc",
+ "base/profiler/stack_sampler_android.cc",
+ "base/system/sys_info_android.cc",
+ "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",
+ "-DHAVE_SYS_UIO_H",
+ "-fstack-protector",
+ "-msse3",
+ ],
+ local_include_dirs: [
+ "third_party/android_ndk/sources/android/cpufeatures/",
+ ],
+ 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",
+ "-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",
+ ],
+ },
+ host: {
+ srcs: [
+ "base/allocator/partition_allocator/shim/allocator_shim_default_dispatch_to_glibc.cc",
+ "base/base_paths_posix.cc",
+ "base/debug/stack_trace_posix.cc",
+ "base/files/file_util_linux.cc",
+ "base/files/scoped_file_linux.cc",
+ "base/memory/platform_shared_memory_mapper_posix.cc",
+ "base/memory/platform_shared_memory_region_posix.cc",
+ "base/power_monitor/power_monitor_device_source_stub.cc",
+ "base/process/process_linux.cc",
+ "base/profiler/stack_sampler_posix.cc",
+ "base/stack_canary_linux.cc",
+ "base/threading/platform_thread_linux.cc",
+ ],
+ 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",
+ "-fstack-protector",
+ "-msse3",
+ ],
+ compile_multilib: "64",
+ },
+ },
+}
+
// GN: //base:base_android_java_enums_srcjar
java_genrule {
name: "cronet_aml_base_base_android_java_enums_srcjar",
@@ -1343,6 +2937,278 @@
],
}
+// GN: //base:base_jni_headers__testing
+cc_genrule {
+ name: "cronet_aml_base_base_jni_headers__testing",
+ srcs: [
+ "base/android/java/src/org/chromium/base/ApkAssets.java",
+ "base/android/java/src/org/chromium/base/ApplicationStatus.java",
+ "base/android/java/src/org/chromium/base/BaseFeatureList.java",
+ "base/android/java/src/org/chromium/base/BuildInfo.java",
+ "base/android/java/src/org/chromium/base/BundleUtils.java",
+ "base/android/java/src/org/chromium/base/Callback.java",
+ "base/android/java/src/org/chromium/base/CommandLine.java",
+ "base/android/java/src/org/chromium/base/ContentUriUtils.java",
+ "base/android/java/src/org/chromium/base/CpuFeatures.java",
+ "base/android/java/src/org/chromium/base/EarlyTraceEvent.java",
+ "base/android/java/src/org/chromium/base/EventLog.java",
+ "base/android/java/src/org/chromium/base/FeatureList.java",
+ "base/android/java/src/org/chromium/base/Features.java",
+ "base/android/java/src/org/chromium/base/FieldTrialList.java",
+ "base/android/java/src/org/chromium/base/FileUtils.java",
+ "base/android/java/src/org/chromium/base/ImportantFileWriterAndroid.java",
+ "base/android/java/src/org/chromium/base/IntStringCallback.java",
+ "base/android/java/src/org/chromium/base/JNIUtils.java",
+ "base/android/java/src/org/chromium/base/JavaExceptionReporter.java",
+ "base/android/java/src/org/chromium/base/JavaHandlerThread.java",
+ "base/android/java/src/org/chromium/base/LocaleUtils.java",
+ "base/android/java/src/org/chromium/base/MemoryPressureListener.java",
+ "base/android/java/src/org/chromium/base/PathService.java",
+ "base/android/java/src/org/chromium/base/PathUtils.java",
+ "base/android/java/src/org/chromium/base/PiiElider.java",
+ "base/android/java/src/org/chromium/base/PowerMonitor.java",
+ "base/android/java/src/org/chromium/base/RadioUtils.java",
+ "base/android/java/src/org/chromium/base/SysUtils.java",
+ "base/android/java/src/org/chromium/base/ThreadUtils.java",
+ "base/android/java/src/org/chromium/base/TimezoneUtils.java",
+ "base/android/java/src/org/chromium/base/TraceEvent.java",
+ "base/android/java/src/org/chromium/base/UnguessableToken.java",
+ "base/android/java/src/org/chromium/base/jank_tracker/JankMetricUMARecorder.java",
+ "base/android/java/src/org/chromium/base/library_loader/LibraryLoader.java",
+ "base/android/java/src/org/chromium/base/library_loader/LibraryPrefetcher.java",
+ "base/android/java/src/org/chromium/base/memory/JavaHeapDumpGenerator.java",
+ "base/android/java/src/org/chromium/base/metrics/NativeUmaRecorder.java",
+ "base/android/java/src/org/chromium/base/metrics/StatisticsRecorderAndroid.java",
+ "base/android/java/src/org/chromium/base/process_launcher/ChildProcessService.java",
+ "base/android/java/src/org/chromium/base/task/PostTask.java",
+ "base/android/java/src/org/chromium/base/task/TaskRunnerImpl.java",
+ ],
+ cmd: "$(location base/android/jni_generator/jni_generator.py) --ptr_type " +
+ "long " +
+ "--output_dir " +
+ "$(genDir)/base/base_jni_headers " +
+ "--includes " +
+ "base/android/jni_generator/jni_generator_helper.h " +
+ "--use_proxy_hash " +
+ "--output_name " +
+ "ApkAssets_jni.h " +
+ "--output_name " +
+ "ApplicationStatus_jni.h " +
+ "--output_name " +
+ "BaseFeatureList_jni.h " +
+ "--output_name " +
+ "BuildInfo_jni.h " +
+ "--output_name " +
+ "BundleUtils_jni.h " +
+ "--output_name " +
+ "Callback_jni.h " +
+ "--output_name " +
+ "CommandLine_jni.h " +
+ "--output_name " +
+ "ContentUriUtils_jni.h " +
+ "--output_name " +
+ "CpuFeatures_jni.h " +
+ "--output_name " +
+ "EarlyTraceEvent_jni.h " +
+ "--output_name " +
+ "EventLog_jni.h " +
+ "--output_name " +
+ "FeatureList_jni.h " +
+ "--output_name " +
+ "Features_jni.h " +
+ "--output_name " +
+ "FieldTrialList_jni.h " +
+ "--output_name " +
+ "FileUtils_jni.h " +
+ "--output_name " +
+ "ImportantFileWriterAndroid_jni.h " +
+ "--output_name " +
+ "IntStringCallback_jni.h " +
+ "--output_name " +
+ "JNIUtils_jni.h " +
+ "--output_name " +
+ "JavaExceptionReporter_jni.h " +
+ "--output_name " +
+ "JavaHandlerThread_jni.h " +
+ "--output_name " +
+ "LocaleUtils_jni.h " +
+ "--output_name " +
+ "MemoryPressureListener_jni.h " +
+ "--output_name " +
+ "PathService_jni.h " +
+ "--output_name " +
+ "PathUtils_jni.h " +
+ "--output_name " +
+ "PiiElider_jni.h " +
+ "--output_name " +
+ "PowerMonitor_jni.h " +
+ "--output_name " +
+ "RadioUtils_jni.h " +
+ "--output_name " +
+ "SysUtils_jni.h " +
+ "--output_name " +
+ "ThreadUtils_jni.h " +
+ "--output_name " +
+ "TimezoneUtils_jni.h " +
+ "--output_name " +
+ "TraceEvent_jni.h " +
+ "--output_name " +
+ "UnguessableToken_jni.h " +
+ "--output_name " +
+ "JankMetricUMARecorder_jni.h " +
+ "--output_name " +
+ "LibraryLoader_jni.h " +
+ "--output_name " +
+ "LibraryPrefetcher_jni.h " +
+ "--output_name " +
+ "JavaHeapDumpGenerator_jni.h " +
+ "--output_name " +
+ "NativeUmaRecorder_jni.h " +
+ "--output_name " +
+ "StatisticsRecorderAndroid_jni.h " +
+ "--output_name " +
+ "ChildProcessService_jni.h " +
+ "--output_name " +
+ "PostTask_jni.h " +
+ "--output_name " +
+ "TaskRunnerImpl_jni.h " +
+ "--input_file " +
+ "$(location base/android/java/src/org/chromium/base/ApkAssets.java) " +
+ "--input_file " +
+ "$(location base/android/java/src/org/chromium/base/ApplicationStatus.java) " +
+ "--input_file " +
+ "$(location base/android/java/src/org/chromium/base/BaseFeatureList.java) " +
+ "--input_file " +
+ "$(location base/android/java/src/org/chromium/base/BuildInfo.java) " +
+ "--input_file " +
+ "$(location base/android/java/src/org/chromium/base/BundleUtils.java) " +
+ "--input_file " +
+ "$(location base/android/java/src/org/chromium/base/Callback.java) " +
+ "--input_file " +
+ "$(location base/android/java/src/org/chromium/base/CommandLine.java) " +
+ "--input_file " +
+ "$(location base/android/java/src/org/chromium/base/ContentUriUtils.java) " +
+ "--input_file " +
+ "$(location base/android/java/src/org/chromium/base/CpuFeatures.java) " +
+ "--input_file " +
+ "$(location base/android/java/src/org/chromium/base/EarlyTraceEvent.java) " +
+ "--input_file " +
+ "$(location base/android/java/src/org/chromium/base/EventLog.java) " +
+ "--input_file " +
+ "$(location base/android/java/src/org/chromium/base/FeatureList.java) " +
+ "--input_file " +
+ "$(location base/android/java/src/org/chromium/base/Features.java) " +
+ "--input_file " +
+ "$(location base/android/java/src/org/chromium/base/FieldTrialList.java) " +
+ "--input_file " +
+ "$(location base/android/java/src/org/chromium/base/FileUtils.java) " +
+ "--input_file " +
+ "$(location base/android/java/src/org/chromium/base/ImportantFileWriterAndroid.java) " +
+ "--input_file " +
+ "$(location base/android/java/src/org/chromium/base/IntStringCallback.java) " +
+ "--input_file " +
+ "$(location base/android/java/src/org/chromium/base/JNIUtils.java) " +
+ "--input_file " +
+ "$(location base/android/java/src/org/chromium/base/JavaExceptionReporter.java) " +
+ "--input_file " +
+ "$(location base/android/java/src/org/chromium/base/JavaHandlerThread.java) " +
+ "--input_file " +
+ "$(location base/android/java/src/org/chromium/base/LocaleUtils.java) " +
+ "--input_file " +
+ "$(location base/android/java/src/org/chromium/base/MemoryPressureListener.java) " +
+ "--input_file " +
+ "$(location base/android/java/src/org/chromium/base/PathService.java) " +
+ "--input_file " +
+ "$(location base/android/java/src/org/chromium/base/PathUtils.java) " +
+ "--input_file " +
+ "$(location base/android/java/src/org/chromium/base/PiiElider.java) " +
+ "--input_file " +
+ "$(location base/android/java/src/org/chromium/base/PowerMonitor.java) " +
+ "--input_file " +
+ "$(location base/android/java/src/org/chromium/base/RadioUtils.java) " +
+ "--input_file " +
+ "$(location base/android/java/src/org/chromium/base/SysUtils.java) " +
+ "--input_file " +
+ "$(location base/android/java/src/org/chromium/base/ThreadUtils.java) " +
+ "--input_file " +
+ "$(location base/android/java/src/org/chromium/base/TimezoneUtils.java) " +
+ "--input_file " +
+ "$(location base/android/java/src/org/chromium/base/TraceEvent.java) " +
+ "--input_file " +
+ "$(location base/android/java/src/org/chromium/base/UnguessableToken.java) " +
+ "--input_file " +
+ "$(location base/android/java/src/org/chromium/base/jank_tracker/JankMetricUMARecorder.java) " +
+ "--input_file " +
+ "$(location base/android/java/src/org/chromium/base/library_loader/LibraryLoader.java) " +
+ "--input_file " +
+ "$(location base/android/java/src/org/chromium/base/library_loader/LibraryPrefetcher.java) " +
+ "--input_file " +
+ "$(location base/android/java/src/org/chromium/base/memory/JavaHeapDumpGenerator.java) " +
+ "--input_file " +
+ "$(location base/android/java/src/org/chromium/base/metrics/NativeUmaRecorder.java) " +
+ "--input_file " +
+ "$(location base/android/java/src/org/chromium/base/metrics/StatisticsRecorderAndroid.java) " +
+ "--input_file " +
+ "$(location base/android/java/src/org/chromium/base/process_launcher/ChildProcessService.java) " +
+ "--input_file " +
+ "$(location base/android/java/src/org/chromium/base/task/PostTask.java) " +
+ "--input_file " +
+ "$(location base/android/java/src/org/chromium/base/task/TaskRunnerImpl.java)",
+ out: [
+ "base/base_jni_headers/ApkAssets_jni.h",
+ "base/base_jni_headers/ApplicationStatus_jni.h",
+ "base/base_jni_headers/BaseFeatureList_jni.h",
+ "base/base_jni_headers/BuildInfo_jni.h",
+ "base/base_jni_headers/BundleUtils_jni.h",
+ "base/base_jni_headers/Callback_jni.h",
+ "base/base_jni_headers/ChildProcessService_jni.h",
+ "base/base_jni_headers/CommandLine_jni.h",
+ "base/base_jni_headers/ContentUriUtils_jni.h",
+ "base/base_jni_headers/CpuFeatures_jni.h",
+ "base/base_jni_headers/EarlyTraceEvent_jni.h",
+ "base/base_jni_headers/EventLog_jni.h",
+ "base/base_jni_headers/FeatureList_jni.h",
+ "base/base_jni_headers/Features_jni.h",
+ "base/base_jni_headers/FieldTrialList_jni.h",
+ "base/base_jni_headers/FileUtils_jni.h",
+ "base/base_jni_headers/ImportantFileWriterAndroid_jni.h",
+ "base/base_jni_headers/IntStringCallback_jni.h",
+ "base/base_jni_headers/JNIUtils_jni.h",
+ "base/base_jni_headers/JankMetricUMARecorder_jni.h",
+ "base/base_jni_headers/JavaExceptionReporter_jni.h",
+ "base/base_jni_headers/JavaHandlerThread_jni.h",
+ "base/base_jni_headers/JavaHeapDumpGenerator_jni.h",
+ "base/base_jni_headers/LibraryLoader_jni.h",
+ "base/base_jni_headers/LibraryPrefetcher_jni.h",
+ "base/base_jni_headers/LocaleUtils_jni.h",
+ "base/base_jni_headers/MemoryPressureListener_jni.h",
+ "base/base_jni_headers/NativeUmaRecorder_jni.h",
+ "base/base_jni_headers/PathService_jni.h",
+ "base/base_jni_headers/PathUtils_jni.h",
+ "base/base_jni_headers/PiiElider_jni.h",
+ "base/base_jni_headers/PostTask_jni.h",
+ "base/base_jni_headers/PowerMonitor_jni.h",
+ "base/base_jni_headers/RadioUtils_jni.h",
+ "base/base_jni_headers/StatisticsRecorderAndroid_jni.h",
+ "base/base_jni_headers/SysUtils_jni.h",
+ "base/base_jni_headers/TaskRunnerImpl_jni.h",
+ "base/base_jni_headers/ThreadUtils_jni.h",
+ "base/base_jni_headers/TimezoneUtils_jni.h",
+ "base/base_jni_headers/TraceEvent_jni.h",
+ "base/base_jni_headers/UnguessableToken_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: //base:base_static
cc_library_static {
name: "cronet_aml_base_base_static",
@@ -1366,6 +3232,7 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-D_FORTIFY_SOURCE=2",
@@ -1374,6 +3241,14 @@
"-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",
+ "-fvisibility-inlines-hidden",
+ "-fvisibility=hidden",
+ "-g1",
],
local_include_dirs: [
"./",
@@ -1382,7 +3257,24 @@
"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",
@@ -1390,17 +3282,138 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //base:base_static__testing
+cc_library_static {
+ name: "cronet_aml_base_base_static__testing",
+ srcs: [
+ "base/base_switches.cc",
+ ],
+ host_supported: true,
+ generated_headers: [
+ "cronet_aml_build_chromeos_buildflags__testing",
+ ],
+ export_generated_headers: [
+ "cronet_aml_build_chromeos_buildflags__testing",
+ ],
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-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",
+ "-O2",
+ "-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",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ android_arm: {
+ cflags: [
+ "-DANDROID",
+ "-DANDROID_NDK_VERSION_ROLL=r23_1",
+ "-DHAVE_SYS_UIO_H",
+ "-fstack-protector",
+ ],
+ },
+ android_arm64: {
+ cflags: [
+ "-DANDROID",
+ "-DANDROID_NDK_VERSION_ROLL=r23_1",
+ "-DHAVE_SYS_UIO_H",
+ "-fstack-protector",
+ "-mno-outline",
+ "-mno-outline-atomics",
+ ],
+ },
+ android_x86: {
+ cflags: [
+ "-DANDROID",
+ "-DANDROID_NDK_VERSION_ROLL=r23_1",
+ "-DHAVE_SYS_UIO_H",
+ "-msse3",
+ ],
+ },
+ android_x86_64: {
+ cflags: [
+ "-DANDROID",
+ "-DANDROID_NDK_VERSION_ROLL=r23_1",
+ "-DHAVE_SYS_UIO_H",
+ "-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",
+ "-fstack-protector",
+ "-msse3",
+ ],
+ compile_multilib: "64",
+ },
+ },
+}
+
// GN: //base:build_date
cc_genrule {
name: "cronet_aml_base_build_date",
cmd: "$(location build/write_build_date_header.py) $(out) " +
- "1674804594",
+ "1674644139",
+ out: [
+ "base/generated_build_date.h",
+ ],
+ tool_files: [
+ "build/write_build_date_header.py",
+ ],
+ apex_available: [
+ "com.android.tethering",
+ ],
+}
+
+// GN: //base:build_date__testing
+cc_genrule {
+ name: "cronet_aml_base_build_date__testing",
+ cmd: "$(location build/write_build_date_header.py) $(out) " +
+ "1674644139",
+ host_supported: true,
out: [
"base/generated_build_date.h",
],
@@ -1435,6 +3448,30 @@
],
}
+// GN: //base:cfi_buildflags__testing
+cc_genrule {
+ name: "cronet_aml_base_cfi_buildflags__testing",
+ cmd: "echo '--flags CFI_CAST_CHECK=\"false && false\" CFI_ICALL_CHECK=\"false && false\" CFI_ENFORCEMENT_TRAP=\"false && !false\" CFI_ENFORCEMENT_DIAGNOSTIC=\"false && false && !false\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//base:cfi_buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin",
+ host_supported: true,
+ out: [
+ "base/cfi_buildflags.h",
+ ],
+ tool_files: [
+ "build/write_buildflag_header.py",
+ ],
+ apex_available: [
+ "com.android.tethering",
+ ],
+}
+
// GN: //base:clang_profiling_buildflags
cc_genrule {
name: "cronet_aml_base_clang_profiling_buildflags",
@@ -1458,12 +3495,36 @@
],
}
+// GN: //base:clang_profiling_buildflags__testing
+cc_genrule {
+ name: "cronet_aml_base_clang_profiling_buildflags__testing",
+ cmd: "echo '--flags CLANG_PROFILING=\"false\" CLANG_PROFILING_INSIDE_SANDBOX=\"false\" USE_CLANG_COVERAGE=\"false\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//base:clang_profiling_buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin",
+ host_supported: true,
+ out: [
+ "base/clang_profiling_buildflags.h",
+ ],
+ tool_files: [
+ "build/write_buildflag_header.py",
+ ],
+ apex_available: [
+ "com.android.tethering",
+ ],
+}
+
// GN: //base:debugging_buildflags
cc_genrule {
name: "cronet_aml_base_debugging_buildflags",
cmd: "if [[ ( $$CC_ARCH == 'x86_64' && $$CC_OS == 'android' ) ]]; " +
"then " +
- "echo '--flags DCHECK_IS_CONFIGURABLE=\"false\" ENABLE_LOCATION_SOURCE=\"true\" FROM_HERE_USES_LOCATION_BUILTINS=\"true\" ENABLE_PROFILING=\"false\" CAN_UNWIND_WITH_FRAME_POINTERS=\"false\" UNSAFE_DEVELOPER_BUILD=\"false\" CAN_UNWIND_WITH_CFI_TABLE=\"false\" EXCLUDE_UNWIND_TABLES=\"false\" ENABLE_GDBINIT_WARNING=\"false\" ENABLE_LLDBINIT_WARNING=\"false\" EXPENSIVE_DCHECKS_ARE_ON=\"false\" ENABLE_STACK_TRACE_LINE_NUMBERS=\"false\"' | " +
+ "echo '--flags DCHECK_IS_CONFIGURABLE=\"false\" ENABLE_LOCATION_SOURCE=\"true\" FROM_HERE_USES_LOCATION_BUILTINS=\"true\" ENABLE_PROFILING=\"false\" CAN_UNWIND_WITH_FRAME_POINTERS=\"false\" UNSAFE_DEVELOPER_BUILD=\"false\" CAN_UNWIND_WITH_CFI_TABLE=\"false\" EXCLUDE_UNWIND_TABLES=\"true\" ENABLE_GDBINIT_WARNING=\"false\" ENABLE_LLDBINIT_WARNING=\"false\" EXPENSIVE_DCHECKS_ARE_ON=\"false\" ENABLE_STACK_TRACE_LINE_NUMBERS=\"false\"' | " +
"$(location build/write_buildflag_header.py) --output " +
"$(out) " +
"--rulename " +
@@ -1475,7 +3536,7 @@
"fi; " +
"if [[ ( $$CC_ARCH == 'x86' && $$CC_OS == 'android' ) ]]; " +
"then " +
- "echo '--flags DCHECK_IS_CONFIGURABLE=\"false\" ENABLE_LOCATION_SOURCE=\"true\" FROM_HERE_USES_LOCATION_BUILTINS=\"true\" ENABLE_PROFILING=\"false\" CAN_UNWIND_WITH_FRAME_POINTERS=\"true\" UNSAFE_DEVELOPER_BUILD=\"false\" CAN_UNWIND_WITH_CFI_TABLE=\"false\" EXCLUDE_UNWIND_TABLES=\"false\" ENABLE_GDBINIT_WARNING=\"false\" ENABLE_LLDBINIT_WARNING=\"false\" EXPENSIVE_DCHECKS_ARE_ON=\"false\" ENABLE_STACK_TRACE_LINE_NUMBERS=\"false\"' | " +
+ "echo '--flags DCHECK_IS_CONFIGURABLE=\"false\" ENABLE_LOCATION_SOURCE=\"true\" FROM_HERE_USES_LOCATION_BUILTINS=\"true\" ENABLE_PROFILING=\"false\" CAN_UNWIND_WITH_FRAME_POINTERS=\"false\" UNSAFE_DEVELOPER_BUILD=\"false\" CAN_UNWIND_WITH_CFI_TABLE=\"false\" EXCLUDE_UNWIND_TABLES=\"true\" ENABLE_GDBINIT_WARNING=\"false\" ENABLE_LLDBINIT_WARNING=\"false\" EXPENSIVE_DCHECKS_ARE_ON=\"false\" ENABLE_STACK_TRACE_LINE_NUMBERS=\"false\"' | " +
"$(location build/write_buildflag_header.py) --output " +
"$(out) " +
"--rulename " +
@@ -1487,7 +3548,7 @@
"fi; " +
"if [[ ( $$CC_ARCH == 'arm' && $$CC_OS == 'android' ) ]]; " +
"then " +
- "echo '--flags DCHECK_IS_CONFIGURABLE=\"false\" ENABLE_LOCATION_SOURCE=\"true\" FROM_HERE_USES_LOCATION_BUILTINS=\"true\" ENABLE_PROFILING=\"false\" CAN_UNWIND_WITH_FRAME_POINTERS=\"false\" UNSAFE_DEVELOPER_BUILD=\"false\" CAN_UNWIND_WITH_CFI_TABLE=\"true\" EXCLUDE_UNWIND_TABLES=\"false\" ENABLE_GDBINIT_WARNING=\"false\" ENABLE_LLDBINIT_WARNING=\"false\" EXPENSIVE_DCHECKS_ARE_ON=\"false\" ENABLE_STACK_TRACE_LINE_NUMBERS=\"false\"' | " +
+ "echo '--flags DCHECK_IS_CONFIGURABLE=\"false\" ENABLE_LOCATION_SOURCE=\"true\" FROM_HERE_USES_LOCATION_BUILTINS=\"true\" ENABLE_PROFILING=\"false\" CAN_UNWIND_WITH_FRAME_POINTERS=\"false\" UNSAFE_DEVELOPER_BUILD=\"false\" CAN_UNWIND_WITH_CFI_TABLE=\"true\" EXCLUDE_UNWIND_TABLES=\"true\" ENABLE_GDBINIT_WARNING=\"false\" ENABLE_LLDBINIT_WARNING=\"false\" EXPENSIVE_DCHECKS_ARE_ON=\"false\" ENABLE_STACK_TRACE_LINE_NUMBERS=\"false\"' | " +
"$(location build/write_buildflag_header.py) --output " +
"$(out) " +
"--rulename " +
@@ -1499,7 +3560,7 @@
"fi; " +
"if [[ ( $$CC_ARCH == 'arm64' && $$CC_OS == 'android' ) ]]; " +
"then " +
- "echo '--flags DCHECK_IS_CONFIGURABLE=\"false\" ENABLE_LOCATION_SOURCE=\"true\" FROM_HERE_USES_LOCATION_BUILTINS=\"true\" ENABLE_PROFILING=\"false\" CAN_UNWIND_WITH_FRAME_POINTERS=\"true\" UNSAFE_DEVELOPER_BUILD=\"false\" CAN_UNWIND_WITH_CFI_TABLE=\"false\" EXCLUDE_UNWIND_TABLES=\"false\" ENABLE_GDBINIT_WARNING=\"false\" ENABLE_LLDBINIT_WARNING=\"false\" EXPENSIVE_DCHECKS_ARE_ON=\"false\" ENABLE_STACK_TRACE_LINE_NUMBERS=\"false\"' | " +
+ "echo '--flags DCHECK_IS_CONFIGURABLE=\"false\" ENABLE_LOCATION_SOURCE=\"true\" FROM_HERE_USES_LOCATION_BUILTINS=\"true\" ENABLE_PROFILING=\"false\" CAN_UNWIND_WITH_FRAME_POINTERS=\"true\" UNSAFE_DEVELOPER_BUILD=\"false\" CAN_UNWIND_WITH_CFI_TABLE=\"false\" EXCLUDE_UNWIND_TABLES=\"true\" ENABLE_GDBINIT_WARNING=\"false\" ENABLE_LLDBINIT_WARNING=\"false\" EXPENSIVE_DCHECKS_ARE_ON=\"false\" ENABLE_STACK_TRACE_LINE_NUMBERS=\"false\"' | " +
"$(location build/write_buildflag_header.py) --output " +
"$(out) " +
"--rulename " +
@@ -1520,6 +3581,81 @@
],
}
+// GN: //base:debugging_buildflags__testing
+cc_genrule {
+ name: "cronet_aml_base_debugging_buildflags__testing",
+ cmd: "if [[ ( $$CC_ARCH == 'x86_64' && $$CC_OS == 'android' ) ]]; " +
+ "then " +
+ "echo '--flags DCHECK_IS_CONFIGURABLE=\"false\" ENABLE_LOCATION_SOURCE=\"true\" FROM_HERE_USES_LOCATION_BUILTINS=\"true\" ENABLE_PROFILING=\"false\" CAN_UNWIND_WITH_FRAME_POINTERS=\"false\" UNSAFE_DEVELOPER_BUILD=\"false\" CAN_UNWIND_WITH_CFI_TABLE=\"false\" EXCLUDE_UNWIND_TABLES=\"true\" ENABLE_GDBINIT_WARNING=\"false\" ENABLE_LLDBINIT_WARNING=\"false\" EXPENSIVE_DCHECKS_ARE_ON=\"false\" ENABLE_STACK_TRACE_LINE_NUMBERS=\"false\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//base:debugging_buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin; " +
+ "fi; " +
+ "if [[ $$CC_OS != 'android' ]]; " +
+ "then " +
+ "echo '--flags DCHECK_IS_CONFIGURABLE=\"false\" ENABLE_LOCATION_SOURCE=\"true\" FROM_HERE_USES_LOCATION_BUILTINS=\"true\" ENABLE_PROFILING=\"false\" CAN_UNWIND_WITH_FRAME_POINTERS=\"true\" UNSAFE_DEVELOPER_BUILD=\"false\" CAN_UNWIND_WITH_CFI_TABLE=\"false\" EXCLUDE_UNWIND_TABLES=\"true\" ENABLE_GDBINIT_WARNING=\"false\" ENABLE_LLDBINIT_WARNING=\"false\" EXPENSIVE_DCHECKS_ARE_ON=\"false\" ENABLE_STACK_TRACE_LINE_NUMBERS=\"false\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//base:debugging_buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin; " +
+ "fi; " +
+ "if [[ ( $$CC_ARCH == 'x86' && $$CC_OS == 'android' ) ]]; " +
+ "then " +
+ "echo '--flags DCHECK_IS_CONFIGURABLE=\"false\" ENABLE_LOCATION_SOURCE=\"true\" FROM_HERE_USES_LOCATION_BUILTINS=\"true\" ENABLE_PROFILING=\"false\" CAN_UNWIND_WITH_FRAME_POINTERS=\"false\" UNSAFE_DEVELOPER_BUILD=\"false\" CAN_UNWIND_WITH_CFI_TABLE=\"false\" EXCLUDE_UNWIND_TABLES=\"true\" ENABLE_GDBINIT_WARNING=\"false\" ENABLE_LLDBINIT_WARNING=\"false\" EXPENSIVE_DCHECKS_ARE_ON=\"false\" ENABLE_STACK_TRACE_LINE_NUMBERS=\"false\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//base:debugging_buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin; " +
+ "fi; " +
+ "if [[ ( $$CC_ARCH == 'arm' && $$CC_OS == 'android' ) ]]; " +
+ "then " +
+ "echo '--flags DCHECK_IS_CONFIGURABLE=\"false\" ENABLE_LOCATION_SOURCE=\"true\" FROM_HERE_USES_LOCATION_BUILTINS=\"true\" ENABLE_PROFILING=\"false\" CAN_UNWIND_WITH_FRAME_POINTERS=\"false\" UNSAFE_DEVELOPER_BUILD=\"false\" CAN_UNWIND_WITH_CFI_TABLE=\"true\" EXCLUDE_UNWIND_TABLES=\"true\" ENABLE_GDBINIT_WARNING=\"false\" ENABLE_LLDBINIT_WARNING=\"false\" EXPENSIVE_DCHECKS_ARE_ON=\"false\" ENABLE_STACK_TRACE_LINE_NUMBERS=\"false\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//base:debugging_buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin; " +
+ "fi; " +
+ "if [[ ( $$CC_ARCH == 'arm64' && $$CC_OS == 'android' ) ]]; " +
+ "then " +
+ "echo '--flags DCHECK_IS_CONFIGURABLE=\"false\" ENABLE_LOCATION_SOURCE=\"true\" FROM_HERE_USES_LOCATION_BUILTINS=\"true\" ENABLE_PROFILING=\"false\" CAN_UNWIND_WITH_FRAME_POINTERS=\"true\" UNSAFE_DEVELOPER_BUILD=\"false\" CAN_UNWIND_WITH_CFI_TABLE=\"false\" EXCLUDE_UNWIND_TABLES=\"true\" ENABLE_GDBINIT_WARNING=\"false\" ENABLE_LLDBINIT_WARNING=\"false\" EXPENSIVE_DCHECKS_ARE_ON=\"false\" ENABLE_STACK_TRACE_LINE_NUMBERS=\"false\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//base:debugging_buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin; " +
+ "fi;",
+ host_supported: true,
+ out: [
+ "base/debug/debugging_buildflags.h",
+ ],
+ tool_files: [
+ "build/write_buildflag_header.py",
+ ],
+ apex_available: [
+ "com.android.tethering",
+ ],
+}
+
// GN: //base:feature_list_buildflags
cc_genrule {
name: "cronet_aml_base_feature_list_buildflags",
@@ -1543,6 +3679,227 @@
],
}
+// GN: //base:feature_list_buildflags__testing
+cc_genrule {
+ name: "cronet_aml_base_feature_list_buildflags__testing",
+ cmd: "echo '--flags ENABLE_BANNED_BASE_FEATURE_PREFIX=\"false\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//base:feature_list_buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin",
+ host_supported: true,
+ out: [
+ "base/feature_list_buildflags.h",
+ ],
+ tool_files: [
+ "build/write_buildflag_header.py",
+ ],
+ apex_available: [
+ "com.android.tethering",
+ ],
+}
+
+// GN: //base:i18n__testing
+cc_library_static {
+ name: "cronet_aml_base_i18n__testing",
+ srcs: [
+ "base/i18n/base_i18n_switches.cc",
+ "base/i18n/break_iterator.cc",
+ "base/i18n/case_conversion.cc",
+ "base/i18n/char_iterator.cc",
+ "base/i18n/character_encoding.cc",
+ "base/i18n/encoding_detection.cc",
+ "base/i18n/file_util_icu.cc",
+ "base/i18n/i18n_constants.cc",
+ "base/i18n/icu_string_conversions.cc",
+ "base/i18n/icu_util.cc",
+ "base/i18n/message_formatter.cc",
+ "base/i18n/number_formatting.cc",
+ "base/i18n/rtl.cc",
+ "base/i18n/streaming_utf8_validator.cc",
+ "base/i18n/string_compare.cc",
+ "base/i18n/string_search.cc",
+ "base/i18n/time_formatting.cc",
+ "base/i18n/timezone.cc",
+ "base/i18n/utf8_validator_tables.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_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",
+ "cronet_aml_third_party_libevent_libevent__testing",
+ "cronet_aml_third_party_modp_b64_modp_b64__testing",
+ ],
+ generated_headers: [
+ "cronet_aml_build_chromecast_buildflags__testing",
+ "cronet_aml_build_chromeos_buildflags__testing",
+ ],
+ export_generated_headers: [
+ "cronet_aml_build_chromecast_buildflags__testing",
+ "cronet_aml_build_chromeos_buildflags__testing",
+ ],
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DANDROID",
+ "-DANDROID_NDK_VERSION_ROLL=r23_1",
+ "-DBASE_I18N_IMPLEMENTATION",
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DHAVE_SYS_UIO_H",
+ "-DICU_UTIL_DATA_IMPL=ICU_UTIL_DATA_FILE",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-DUSE_CHROMIUM_ICU=1",
+ "-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",
+ "-O2",
+ "-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/",
+ "third_party/ced/src/",
+ "third_party/icu/source/common/",
+ "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: [
+ "-fstack-protector",
+ ],
+ },
+ android_arm64: {
+ cflags: [
+ "-fstack-protector",
+ "-mno-outline",
+ "-mno-outline-atomics",
+ ],
+ },
+ android_x86: {
+ cflags: [
+ "-msse3",
+ ],
+ },
+ android_x86_64: {
+ cflags: [
+ "-fstack-protector",
+ "-msse3",
+ ],
+ },
+ },
+}
+
// GN: //base:ios_cronet_buildflags
cc_genrule {
name: "cronet_aml_base_ios_cronet_buildflags",
@@ -1566,6 +3923,30 @@
],
}
+// GN: //base:ios_cronet_buildflags__testing
+cc_genrule {
+ name: "cronet_aml_base_ios_cronet_buildflags__testing",
+ cmd: "echo '--flags CRONET_BUILD=\"true\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//base:ios_cronet_buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin",
+ host_supported: true,
+ out: [
+ "base/message_loop/ios_cronet_buildflags.h",
+ ],
+ tool_files: [
+ "build/write_buildflag_header.py",
+ ],
+ apex_available: [
+ "com.android.tethering",
+ ],
+}
+
// GN: //base:java_features_srcjar
java_genrule {
name: "cronet_aml_base_java_features_srcjar",
@@ -1641,6 +4022,30 @@
],
}
+// GN: //base:logging_buildflags__testing
+cc_genrule {
+ name: "cronet_aml_base_logging_buildflags__testing",
+ cmd: "echo '--flags ENABLE_LOG_ERROR_NOT_REACHED=\"false\" USE_RUNTIME_VLOG=\"true\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//base:logging_buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin",
+ host_supported: true,
+ out: [
+ "base/logging_buildflags.h",
+ ],
+ tool_files: [
+ "build/write_buildflag_header.py",
+ ],
+ apex_available: [
+ "com.android.tethering",
+ ],
+}
+
// GN: //base:message_pump_buildflags
cc_genrule {
name: "cronet_aml_base_message_pump_buildflags",
@@ -1664,8 +4069,32 @@
],
}
+// GN: //base:message_pump_buildflags__testing
+cc_genrule {
+ name: "cronet_aml_base_message_pump_buildflags__testing",
+ cmd: "echo '--flags ENABLE_MESSAGE_PUMP_EPOLL=\"true\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//base:message_pump_buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin",
+ host_supported: true,
+ out: [
+ "base/message_loop/message_pump_buildflags.h",
+ ],
+ tool_files: [
+ "build/write_buildflag_header.py",
+ ],
+ apex_available: [
+ "com.android.tethering",
+ ],
+}
+
// GN: //base:nodebug_assertion
-cc_object {
+cc_library_static {
name: "cronet_aml_base_nodebug_assertion",
srcs: [
"base/nodebug_assertion.cc",
@@ -1685,6 +4114,7 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-D_FORTIFY_SOURCE=2",
@@ -1693,6 +4123,14 @@
"-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: [
"./",
@@ -1701,7 +4139,24 @@
"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",
@@ -1709,12 +4164,118 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //base:nodebug_assertion__testing
+cc_library_static {
+ name: "cronet_aml_base_nodebug_assertion__testing",
+ srcs: [
+ "base/nodebug_assertion.cc",
+ ],
+ static_libs: [
+ "cronet_aml_base_base_static__testing",
+ ],
+ host_supported: true,
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DBASE_IMPLEMENTATION",
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-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",
+ "-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",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ 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: //base:orderfile_buildflags
cc_genrule {
name: "cronet_aml_base_orderfile_buildflags",
@@ -1738,6 +4299,30 @@
],
}
+// GN: //base:orderfile_buildflags__testing
+cc_genrule {
+ name: "cronet_aml_base_orderfile_buildflags__testing",
+ cmd: "echo '--flags DEVTOOLS_INSTRUMENTATION_DUMPING=\"false\" ORDERFILE_INSTRUMENTATION=\"false\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//base:orderfile_buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin",
+ host_supported: true,
+ out: [
+ "base/android/orderfile/orderfile_buildflags.h",
+ ],
+ tool_files: [
+ "build/write_buildflag_header.py",
+ ],
+ apex_available: [
+ "com.android.tethering",
+ ],
+}
+
// GN: //base:parsing_buildflags
cc_genrule {
name: "cronet_aml_base_parsing_buildflags",
@@ -1761,6 +4346,30 @@
],
}
+// GN: //base:parsing_buildflags__testing
+cc_genrule {
+ name: "cronet_aml_base_parsing_buildflags__testing",
+ cmd: "echo '--flags BUILD_RUST_JSON_PARSER=\"false\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//base:parsing_buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin",
+ host_supported: true,
+ out: [
+ "base/parsing_buildflags.h",
+ ],
+ tool_files: [
+ "build/write_buildflag_header.py",
+ ],
+ apex_available: [
+ "com.android.tethering",
+ ],
+}
+
// GN: //base:power_monitor_buildflags
cc_genrule {
name: "cronet_aml_base_power_monitor_buildflags",
@@ -1784,6 +4393,30 @@
],
}
+// GN: //base:power_monitor_buildflags__testing
+cc_genrule {
+ name: "cronet_aml_base_power_monitor_buildflags__testing",
+ cmd: "echo '--flags HAS_BATTERY_LEVEL_PROVIDER_IMPL=\"false\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//base:power_monitor_buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin",
+ host_supported: true,
+ out: [
+ "base/power_monitor/power_monitor_buildflags.h",
+ ],
+ tool_files: [
+ "build/write_buildflag_header.py",
+ ],
+ apex_available: [
+ "com.android.tethering",
+ ],
+}
+
// GN: //base:profiler_buildflags
cc_genrule {
name: "cronet_aml_base_profiler_buildflags",
@@ -1846,6 +4479,81 @@
],
}
+// GN: //base:profiler_buildflags__testing
+cc_genrule {
+ name: "cronet_aml_base_profiler_buildflags__testing",
+ cmd: "if [[ ( $$CC_ARCH == 'x86_64' && $$CC_OS == 'android' ) ]]; " +
+ "then " +
+ "echo '--flags ENABLE_ARM_CFI_TABLE=\"false\" IOS_STACK_PROFILER_ENABLED=\"true\" USE_ANDROID_UNWINDER_V2=\"true\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//base:profiler_buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin; " +
+ "fi; " +
+ "if [[ $$CC_OS != 'android' ]]; " +
+ "then " +
+ "echo '--flags ENABLE_ARM_CFI_TABLE=\"false\" IOS_STACK_PROFILER_ENABLED=\"true\" USE_ANDROID_UNWINDER_V2=\"true\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//base:profiler_buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin; " +
+ "fi; " +
+ "if [[ ( $$CC_ARCH == 'x86' && $$CC_OS == 'android' ) ]]; " +
+ "then " +
+ "echo '--flags ENABLE_ARM_CFI_TABLE=\"false\" IOS_STACK_PROFILER_ENABLED=\"true\" USE_ANDROID_UNWINDER_V2=\"true\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//base:profiler_buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin; " +
+ "fi; " +
+ "if [[ ( $$CC_ARCH == 'arm' && $$CC_OS == 'android' ) ]]; " +
+ "then " +
+ "echo '--flags ENABLE_ARM_CFI_TABLE=\"true\" IOS_STACK_PROFILER_ENABLED=\"true\" USE_ANDROID_UNWINDER_V2=\"true\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//base:profiler_buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin; " +
+ "fi; " +
+ "if [[ ( $$CC_ARCH == 'arm64' && $$CC_OS == 'android' ) ]]; " +
+ "then " +
+ "echo '--flags ENABLE_ARM_CFI_TABLE=\"false\" IOS_STACK_PROFILER_ENABLED=\"true\" USE_ANDROID_UNWINDER_V2=\"true\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//base:profiler_buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin; " +
+ "fi;",
+ host_supported: true,
+ out: [
+ "base/profiler/profiler_buildflags.h",
+ ],
+ tool_files: [
+ "build/write_buildflag_header.py",
+ ],
+ apex_available: [
+ "com.android.tethering",
+ ],
+}
+
// GN: //base:sanitizer_buildflags
cc_genrule {
name: "cronet_aml_base_sanitizer_buildflags",
@@ -1869,6 +4577,30 @@
],
}
+// GN: //base:sanitizer_buildflags__testing
+cc_genrule {
+ name: "cronet_aml_base_sanitizer_buildflags__testing",
+ cmd: "echo '--flags IS_HWASAN=\"false\" USING_SANITIZER=\"false\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//base:sanitizer_buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin",
+ host_supported: true,
+ out: [
+ "base/sanitizer_buildflags.h",
+ ],
+ tool_files: [
+ "build/write_buildflag_header.py",
+ ],
+ apex_available: [
+ "com.android.tethering",
+ ],
+}
+
// GN: //base:synchronization_buildflags
cc_genrule {
name: "cronet_aml_base_synchronization_buildflags",
@@ -1892,6 +4624,561 @@
],
}
+// GN: //base:synchronization_buildflags__testing
+cc_genrule {
+ name: "cronet_aml_base_synchronization_buildflags__testing",
+ cmd: "echo '--flags ENABLE_MUTEX_PRIORITY_INHERITANCE=\"false\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//base:synchronization_buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin",
+ host_supported: true,
+ out: [
+ "base/synchronization/synchronization_buildflags.h",
+ ],
+ tool_files: [
+ "build/write_buildflag_header.py",
+ ],
+ apex_available: [
+ "com.android.tethering",
+ ],
+}
+
+// GN: //base/test:base_unittests_jni_headers__testing
+cc_genrule {
+ name: "cronet_aml_base_test_base_unittests_jni_headers__testing",
+ srcs: [
+ "base/test/android/java/src/org/chromium/base/ContentUriTestUtils.java",
+ "base/test/android/java/src/org/chromium/base/JavaHandlerThreadHelpers.java",
+ ],
+ cmd: "$(location base/android/jni_generator/jni_generator.py) --ptr_type " +
+ "long " +
+ "--output_dir " +
+ "$(genDir)/base/test/base_unittests_jni_headers " +
+ "--includes " +
+ "base/android/jni_generator/jni_generator_helper.h " +
+ "--use_proxy_hash " +
+ "--output_name " +
+ "ContentUriTestUtils_jni.h " +
+ "--output_name " +
+ "JavaHandlerThreadHelpers_jni.h " +
+ "--input_file " +
+ "$(location base/test/android/java/src/org/chromium/base/ContentUriTestUtils.java) " +
+ "--input_file " +
+ "$(location base/test/android/java/src/org/chromium/base/JavaHandlerThreadHelpers.java)",
+ out: [
+ "base/test/base_unittests_jni_headers/ContentUriTestUtils_jni.h",
+ "base/test/base_unittests_jni_headers/JavaHandlerThreadHelpers_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: //base/test:test_config__testing
+cc_library_static {
+ name: "cronet_aml_base_test_test_config__testing",
+ srcs: [
+ "base/test/test_switches.cc",
+ "base/test/test_timeouts.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_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_base_clang_profiling_buildflags__testing",
+ "cronet_aml_build_chromeos_buildflags__testing",
+ ],
+ export_generated_headers: [
+ "cronet_aml_base_clang_profiling_buildflags__testing",
+ "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",
+ "-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: //base/test:test_support__testing
+cc_library_static {
+ name: "cronet_aml_base_test_test_support__testing",
+ srcs: [
+ "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",
+ "base/task/sequence_manager/test/sequence_manager_for_test.cc",
+ "base/task/sequence_manager/test/test_task_queue.cc",
+ "base/test/android/java_handler_thread_helpers.cc",
+ "base/test/android/url_utils.cc",
+ "base/test/bind.cc",
+ "base/test/copy_only_int.cc",
+ "base/test/gtest_links.cc",
+ "base/test/gtest_util.cc",
+ "base/test/gtest_xml_unittest_result_printer.cc",
+ "base/test/gtest_xml_util.cc",
+ "base/test/icu_test_util.cc",
+ "base/test/launcher/test_launcher.cc",
+ "base/test/launcher/test_launcher_test_utils.cc",
+ "base/test/launcher/test_launcher_tracer.cc",
+ "base/test/launcher/test_result.cc",
+ "base/test/launcher/test_results_tracker.cc",
+ "base/test/launcher/unit_test_launcher.cc",
+ "base/test/metrics/histogram_enum_reader.cc",
+ "base/test/metrics/histogram_tester.cc",
+ "base/test/metrics/user_action_tester.cc",
+ "base/test/mock_devices_changed_observer.cc",
+ "base/test/mock_entropy_provider.cc",
+ "base/test/mock_log.cc",
+ "base/test/multiprocess_test.cc",
+ "base/test/multiprocess_test_android.cc",
+ "base/test/null_task_runner.cc",
+ "base/test/perf_log.cc",
+ "base/test/perf_test_suite.cc",
+ "base/test/perf_time_logger.cc",
+ "base/test/power_monitor_test.cc",
+ "base/test/power_monitor_test_utils.cc",
+ "base/test/reached_code_profiler_android.cc",
+ "base/test/scoped_command_line.cc",
+ "base/test/scoped_feature_list.cc",
+ "base/test/scoped_locale.cc",
+ "base/test/scoped_mock_clock_override.cc",
+ "base/test/scoped_mock_time_message_loop_task_runner.cc",
+ "base/test/scoped_path_override.cc",
+ "base/test/scoped_run_loop_timeout.cc",
+ "base/test/sequenced_task_runner_test_template.cc",
+ "base/test/simple_test_clock.cc",
+ "base/test/simple_test_tick_clock.cc",
+ "base/test/task_environment.cc",
+ "base/test/task_runner_test_template.cc",
+ "base/test/test_discardable_memory_allocator.cc",
+ "base/test/test_file_util.cc",
+ "base/test/test_file_util_android.cc",
+ "base/test/test_file_util_linux.cc",
+ "base/test/test_file_util_posix.cc",
+ "base/test/test_io_thread.cc",
+ "base/test/test_message_loop.cc",
+ "base/test/test_mock_time_task_runner.cc",
+ "base/test/test_pending_task.cc",
+ "base/test/test_shared_memory_util.cc",
+ "base/test/test_simple_task_runner.cc",
+ "base/test/test_suite.cc",
+ "base/test/test_support_android.cc",
+ "base/test/test_waitable_event.cc",
+ "base/test/thread_pool_test_helpers_android.cc",
+ "base/test/thread_test_helper.cc",
+ "base/test/values_test_util.cc",
+ "base/test/with_feature_override.cc",
+ "base/timer/mock_timer.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_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",
+ "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",
+ ],
+ generated_headers: [
+ "cronet_aml_base_debugging_buildflags__testing",
+ "cronet_aml_base_logging_buildflags__testing",
+ "cronet_aml_base_test_base_unittests_jni_headers__testing",
+ "cronet_aml_base_test_test_support_jni_headers__testing",
+ "cronet_aml_build_chromeos_buildflags__testing",
+ ],
+ export_generated_headers: [
+ "cronet_aml_base_debugging_buildflags__testing",
+ "cronet_aml_base_logging_buildflags__testing",
+ "cronet_aml_base_test_base_unittests_jni_headers__testing",
+ "cronet_aml_base_test_test_support_jni_headers__testing",
+ "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",
+ "-DGTEST_API_=",
+ "-DGTEST_HAS_ABSL=1",
+ "-DGTEST_HAS_POSIX_RE=0",
+ "-DGTEST_HAS_TR1_TUPLE=0",
+ "-DGTEST_LANG_CXX11=1",
+ "-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",
+ "-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",
+ "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/libxml/linux/include/",
+ "third_party/libxml/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: //base/test:test_support_jni_headers__testing
+cc_genrule {
+ name: "cronet_aml_base_test_test_support_jni_headers__testing",
+ srcs: [
+ "base/test/android/java/src/org/chromium/base/MainReturnCodeResult.java",
+ "base/test/android/java/src/org/chromium/base/MultiprocessTestClientLauncher.java",
+ "base/test/android/javatests/src/org/chromium/base/test/ReachedCodeProfiler.java",
+ "base/test/android/javatests/src/org/chromium/base/test/task/ThreadPoolTestHelpers.java",
+ "base/test/android/javatests/src/org/chromium/base/test/util/UrlUtils.java",
+ ],
+ cmd: "$(location base/android/jni_generator/jni_generator.py) --ptr_type " +
+ "long " +
+ "--output_dir " +
+ "$(genDir)/base/test/test_support_jni_headers " +
+ "--includes " +
+ "base/android/jni_generator/jni_generator_helper.h " +
+ "--use_proxy_hash " +
+ "--output_name " +
+ "MainReturnCodeResult_jni.h " +
+ "--output_name " +
+ "MultiprocessTestClientLauncher_jni.h " +
+ "--output_name " +
+ "ReachedCodeProfiler_jni.h " +
+ "--output_name " +
+ "ThreadPoolTestHelpers_jni.h " +
+ "--output_name " +
+ "UrlUtils_jni.h " +
+ "--input_file " +
+ "$(location base/test/android/java/src/org/chromium/base/MainReturnCodeResult.java) " +
+ "--input_file " +
+ "$(location base/test/android/java/src/org/chromium/base/MultiprocessTestClientLauncher.java) " +
+ "--input_file " +
+ "$(location base/test/android/javatests/src/org/chromium/base/test/ReachedCodeProfiler.java) " +
+ "--input_file " +
+ "$(location base/test/android/javatests/src/org/chromium/base/test/task/ThreadPoolTestHelpers.java) " +
+ "--input_file " +
+ "$(location base/test/android/javatests/src/org/chromium/base/test/util/UrlUtils.java)",
+ out: [
+ "base/test/test_support_jni_headers/MainReturnCodeResult_jni.h",
+ "base/test/test_support_jni_headers/MultiprocessTestClientLauncher_jni.h",
+ "base/test/test_support_jni_headers/ReachedCodeProfiler_jni.h",
+ "base/test/test_support_jni_headers/ThreadPoolTestHelpers_jni.h",
+ "base/test/test_support_jni_headers/UrlUtils_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: //base/third_party/double_conversion:double_conversion
cc_library_static {
name: "cronet_aml_base_third_party_double_conversion_double_conversion",
@@ -1916,6 +5203,7 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-D_FORTIFY_SOURCE=2",
@@ -1924,6 +5212,14 @@
"-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: [
"./",
@@ -1932,7 +5228,24 @@
"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",
@@ -1940,12 +5253,121 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //base/third_party/double_conversion:double_conversion__testing
+cc_library_static {
+ name: "cronet_aml_base_third_party_double_conversion_double_conversion__testing",
+ srcs: [
+ "base/third_party/double_conversion/double-conversion/bignum-dtoa.cc",
+ "base/third_party/double_conversion/double-conversion/bignum.cc",
+ "base/third_party/double_conversion/double-conversion/cached-powers.cc",
+ "base/third_party/double_conversion/double-conversion/double-to-string.cc",
+ "base/third_party/double_conversion/double-conversion/fast-dtoa.cc",
+ "base/third_party/double_conversion/double-conversion/fixed-dtoa.cc",
+ "base/third_party/double_conversion/double-conversion/string-to-double.cc",
+ "base/third_party/double_conversion/double-conversion/strtod.cc",
+ ],
+ host_supported: true,
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-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",
+ "-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",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ 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: //base/third_party/dynamic_annotations:dynamic_annotations
cc_library_static {
name: "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations",
@@ -1963,11 +5385,20 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-O2",
+ "-fdata-sections",
+ "-ffunction-sections",
+ "-fno-asynchronous-unwind-tables",
+ "-fno-unwind-tables",
+ "-fvisibility-inlines-hidden",
+ "-fvisibility=hidden",
+ "-g1",
],
local_include_dirs: [
"./",
@@ -1976,7 +5407,24 @@
"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",
@@ -1984,12 +5432,107 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //base/third_party/dynamic_annotations:dynamic_annotations__testing
+cc_library_static {
+ name: "cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations__testing",
+ srcs: [
+ "base/third_party/dynamic_annotations/dynamic_annotations.c",
+ ],
+ host_supported: true,
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-O2",
+ "-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",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ android_arm: {
+ cflags: [
+ "-DANDROID",
+ "-DANDROID_NDK_VERSION_ROLL=r23_1",
+ "-DHAVE_SYS_UIO_H",
+ "-fstack-protector",
+ ],
+ },
+ android_arm64: {
+ cflags: [
+ "-DANDROID",
+ "-DANDROID_NDK_VERSION_ROLL=r23_1",
+ "-DHAVE_SYS_UIO_H",
+ "-fstack-protector",
+ "-mno-outline",
+ "-mno-outline-atomics",
+ ],
+ },
+ android_x86: {
+ cflags: [
+ "-DANDROID",
+ "-DANDROID_NDK_VERSION_ROLL=r23_1",
+ "-DHAVE_SYS_UIO_H",
+ "-msse3",
+ ],
+ },
+ android_x86_64: {
+ cflags: [
+ "-DANDROID",
+ "-DANDROID_NDK_VERSION_ROLL=r23_1",
+ "-DHAVE_SYS_UIO_H",
+ "-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",
+ "-fstack-protector",
+ "-msse3",
+ ],
+ compile_multilib: "64",
+ },
+ },
+}
+
// GN: //base:tracing_buildflags
cc_genrule {
name: "cronet_aml_base_tracing_buildflags",
@@ -2013,6 +5556,81 @@
],
}
+// GN: //base:tracing_buildflags__testing
+cc_genrule {
+ name: "cronet_aml_base_tracing_buildflags__testing",
+ cmd: "if [[ ( $$CC_ARCH == 'x86_64' && $$CC_OS == 'android' ) ]]; " +
+ "then " +
+ "echo '--flags ENABLE_BASE_TRACING=\"false\" USE_PERFETTO_CLIENT_LIBRARY=\"false\" OPTIONAL_TRACE_EVENTS_ENABLED=\"false\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//base:tracing_buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin; " +
+ "fi; " +
+ "if [[ $$CC_OS != 'android' ]]; " +
+ "then " +
+ "echo '--flags ENABLE_BASE_TRACING=\"false\" USE_PERFETTO_CLIENT_LIBRARY=\"false\" OPTIONAL_TRACE_EVENTS_ENABLED=\"true\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//base:tracing_buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin; " +
+ "fi; " +
+ "if [[ ( $$CC_ARCH == 'x86' && $$CC_OS == 'android' ) ]]; " +
+ "then " +
+ "echo '--flags ENABLE_BASE_TRACING=\"false\" USE_PERFETTO_CLIENT_LIBRARY=\"false\" OPTIONAL_TRACE_EVENTS_ENABLED=\"false\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//base:tracing_buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin; " +
+ "fi; " +
+ "if [[ ( $$CC_ARCH == 'arm' && $$CC_OS == 'android' ) ]]; " +
+ "then " +
+ "echo '--flags ENABLE_BASE_TRACING=\"false\" USE_PERFETTO_CLIENT_LIBRARY=\"false\" OPTIONAL_TRACE_EVENTS_ENABLED=\"false\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//base:tracing_buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin; " +
+ "fi; " +
+ "if [[ ( $$CC_ARCH == 'arm64' && $$CC_OS == 'android' ) ]]; " +
+ "then " +
+ "echo '--flags ENABLE_BASE_TRACING=\"false\" USE_PERFETTO_CLIENT_LIBRARY=\"false\" OPTIONAL_TRACE_EVENTS_ENABLED=\"false\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//base:tracing_buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin; " +
+ "fi;",
+ host_supported: true,
+ out: [
+ "base/tracing_buildflags.h",
+ ],
+ tool_files: [
+ "build/write_buildflag_header.py",
+ ],
+ apex_available: [
+ "com.android.tethering",
+ ],
+}
+
// GN: //build/android:build_config_gen
genrule {
name: "cronet_aml_build_android_build_config_gen",
@@ -2096,6 +5714,30 @@
],
}
+// GN: //build:branding_buildflags__testing
+cc_genrule {
+ name: "cronet_aml_build_branding_buildflags__testing",
+ cmd: "echo '--flags CHROMIUM_BRANDING=\"1\" GOOGLE_CHROME_BRANDING=\"0\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//build:branding_buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin",
+ host_supported: true,
+ out: [
+ "build/branding_buildflags.h",
+ ],
+ tool_files: [
+ "build/write_buildflag_header.py",
+ ],
+ apex_available: [
+ "com.android.tethering",
+ ],
+}
+
// GN: //build:chromecast_buildflags
cc_genrule {
name: "cronet_aml_build_chromecast_buildflags",
@@ -2119,6 +5761,30 @@
],
}
+// GN: //build:chromecast_buildflags__testing
+cc_genrule {
+ name: "cronet_aml_build_chromecast_buildflags__testing",
+ cmd: "echo '--flags IS_CASTOS=\"false\" IS_CAST_ANDROID=\"false\" ENABLE_CAST_RECEIVER=\"false\" IS_CHROMECAST=\"false\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//build:chromecast_buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin",
+ host_supported: true,
+ out: [
+ "build/chromecast_buildflags.h",
+ ],
+ tool_files: [
+ "build/write_buildflag_header.py",
+ ],
+ apex_available: [
+ "com.android.tethering",
+ ],
+}
+
// GN: //build:chromeos_buildflags
cc_genrule {
name: "cronet_aml_build_chromeos_buildflags",
@@ -2142,6 +5808,30 @@
],
}
+// GN: //build:chromeos_buildflags__testing
+cc_genrule {
+ name: "cronet_aml_build_chromeos_buildflags__testing",
+ cmd: "echo '--flags IS_CHROMEOS_DEVICE=\"false\" IS_CHROMEOS_LACROS=\"false\" IS_CHROMEOS_ASH=\"false\" IS_CHROMEOS_WITH_HW_DETAILS=\"false\" IS_REVEN=\"false\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//build:chromeos_buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin",
+ host_supported: true,
+ out: [
+ "build/chromeos_buildflags.h",
+ ],
+ tool_files: [
+ "build/write_buildflag_header.py",
+ ],
+ apex_available: [
+ "com.android.tethering",
+ ],
+}
+
// GN: //build/config/compiler:compiler_buildflags
cc_genrule {
name: "cronet_aml_build_config_compiler_compiler_buildflags",
@@ -2165,8 +5855,83 @@
],
}
+// GN: //build/config/compiler:compiler_buildflags__testing
+cc_genrule {
+ name: "cronet_aml_build_config_compiler_compiler_buildflags__testing",
+ cmd: "if [[ ( $$CC_ARCH == 'x86_64' && $$CC_OS == 'android' ) ]]; " +
+ "then " +
+ "echo '--flags CLANG_PGO=\"0\" SYMBOL_LEVEL=\"1\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//build/config/compiler:compiler_buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin; " +
+ "fi; " +
+ "if [[ $$CC_OS != 'android' ]]; " +
+ "then " +
+ "echo '--flags CLANG_PGO=\"2\" SYMBOL_LEVEL=\"1\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//build/config/compiler:compiler_buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin; " +
+ "fi; " +
+ "if [[ ( $$CC_ARCH == 'x86' && $$CC_OS == 'android' ) ]]; " +
+ "then " +
+ "echo '--flags CLANG_PGO=\"0\" SYMBOL_LEVEL=\"1\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//build/config/compiler:compiler_buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin; " +
+ "fi; " +
+ "if [[ ( $$CC_ARCH == 'arm' && $$CC_OS == 'android' ) ]]; " +
+ "then " +
+ "echo '--flags CLANG_PGO=\"0\" SYMBOL_LEVEL=\"1\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//build/config/compiler:compiler_buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin; " +
+ "fi; " +
+ "if [[ ( $$CC_ARCH == 'arm64' && $$CC_OS == 'android' ) ]]; " +
+ "then " +
+ "echo '--flags CLANG_PGO=\"0\" SYMBOL_LEVEL=\"1\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//build/config/compiler:compiler_buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin; " +
+ "fi;",
+ host_supported: true,
+ out: [
+ "build/config/compiler/compiler_buildflags.h",
+ ],
+ tool_files: [
+ "build/write_buildflag_header.py",
+ ],
+ apex_available: [
+ "com.android.tethering",
+ ],
+}
+
// GN: //buildtools/third_party/libc++:libc++
-cc_object {
+cc_library_static {
name: "cronet_aml_buildtools_third_party_libc___libc__",
srcs: [
"buildtools/third_party/libc++/trunk/src/algorithm.cpp",
@@ -2212,6 +5977,9 @@
"buildtools/third_party/libc++/trunk/src/vector.cpp",
"buildtools/third_party/libc++/trunk/src/verbose_abort.cpp",
],
+ static_libs: [
+ "cronet_aml_buildtools_third_party_libc__abi_libc__abi",
+ ],
host_supported: true,
defaults: [
"cronet_aml_defaults",
@@ -2222,6 +5990,7 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DLIBCXX_BUILDING_LIBCXXABI",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
@@ -2230,6 +5999,13 @@
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCPP_OVERRIDABLE_FUNC_VIS=__attribute__((__visibility__(\"default\")))",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-fdata-sections",
+ "-ffunction-sections",
+ "-fno-asynchronous-unwind-tables",
+ "-fno-unwind-tables",
+ "-fvisibility-inlines-hidden",
+ "-fvisibility=hidden",
+ "-g1",
],
local_include_dirs: [
"./",
@@ -2239,6 +6015,11 @@
"buildtools/third_party/libc++abi/trunk/include",
],
cpp_std: "c++20",
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
cppflags: [
"-fexceptions",
],
@@ -2249,6 +6030,8 @@
"-DANDROID",
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DHAVE_SYS_UIO_H",
+ "-Oz",
+ "-fstack-protector",
],
},
android_arm64: {
@@ -2256,6 +6039,10 @@
"-DANDROID",
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DHAVE_SYS_UIO_H",
+ "-Oz",
+ "-fstack-protector",
+ "-mno-outline",
+ "-mno-outline-atomics",
],
},
android_x86: {
@@ -2263,6 +6050,7 @@
"-DANDROID",
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DHAVE_SYS_UIO_H",
+ "-Oz",
"-msse3",
],
},
@@ -2271,27 +6059,183 @@
"-DANDROID",
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DHAVE_SYS_UIO_H",
+ "-Oz",
+ "-fstack-protector",
"-msse3",
],
},
host: {
cflags: [
"-DCR_SYSROOT_KEY=20220331T153654Z-0",
- "-DNO_UNWIND_TABLES",
"-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: //buildtools/third_party/libc++:libc++__testing
+cc_library_static {
+ name: "cronet_aml_buildtools_third_party_libc___libc____testing",
+ srcs: [
+ "buildtools/third_party/libc++/trunk/src/algorithm.cpp",
+ "buildtools/third_party/libc++/trunk/src/any.cpp",
+ "buildtools/third_party/libc++/trunk/src/atomic.cpp",
+ "buildtools/third_party/libc++/trunk/src/barrier.cpp",
+ "buildtools/third_party/libc++/trunk/src/bind.cpp",
+ "buildtools/third_party/libc++/trunk/src/charconv.cpp",
+ "buildtools/third_party/libc++/trunk/src/chrono.cpp",
+ "buildtools/third_party/libc++/trunk/src/condition_variable.cpp",
+ "buildtools/third_party/libc++/trunk/src/condition_variable_destructor.cpp",
+ "buildtools/third_party/libc++/trunk/src/exception.cpp",
+ "buildtools/third_party/libc++/trunk/src/format.cpp",
+ "buildtools/third_party/libc++/trunk/src/functional.cpp",
+ "buildtools/third_party/libc++/trunk/src/future.cpp",
+ "buildtools/third_party/libc++/trunk/src/hash.cpp",
+ "buildtools/third_party/libc++/trunk/src/ios.cpp",
+ "buildtools/third_party/libc++/trunk/src/ios.instantiations.cpp",
+ "buildtools/third_party/libc++/trunk/src/iostream.cpp",
+ "buildtools/third_party/libc++/trunk/src/legacy_pointer_safety.cpp",
+ "buildtools/third_party/libc++/trunk/src/locale.cpp",
+ "buildtools/third_party/libc++/trunk/src/memory.cpp",
+ "buildtools/third_party/libc++/trunk/src/mutex.cpp",
+ "buildtools/third_party/libc++/trunk/src/mutex_destructor.cpp",
+ "buildtools/third_party/libc++/trunk/src/new.cpp",
+ "buildtools/third_party/libc++/trunk/src/optional.cpp",
+ "buildtools/third_party/libc++/trunk/src/random.cpp",
+ "buildtools/third_party/libc++/trunk/src/random_shuffle.cpp",
+ "buildtools/third_party/libc++/trunk/src/regex.cpp",
+ "buildtools/third_party/libc++/trunk/src/ryu/d2fixed.cpp",
+ "buildtools/third_party/libc++/trunk/src/ryu/d2s.cpp",
+ "buildtools/third_party/libc++/trunk/src/ryu/f2s.cpp",
+ "buildtools/third_party/libc++/trunk/src/shared_mutex.cpp",
+ "buildtools/third_party/libc++/trunk/src/stdexcept.cpp",
+ "buildtools/third_party/libc++/trunk/src/string.cpp",
+ "buildtools/third_party/libc++/trunk/src/strstream.cpp",
+ "buildtools/third_party/libc++/trunk/src/system_error.cpp",
+ "buildtools/third_party/libc++/trunk/src/thread.cpp",
+ "buildtools/third_party/libc++/trunk/src/typeinfo.cpp",
+ "buildtools/third_party/libc++/trunk/src/utility.cpp",
+ "buildtools/third_party/libc++/trunk/src/valarray.cpp",
+ "buildtools/third_party/libc++/trunk/src/variant.cpp",
+ "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",
+ ],
+ cflags: [
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DLIBCXX_BUILDING_LIBCXXABI",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_AVAILABILITY_CUSTOM_VERBOSE_ABORT_PROVIDED=1",
+ "-D_LIBCPP_BUILDING_LIBRARY",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCPP_OVERRIDABLE_FUNC_VIS=__attribute__((__visibility__(\"default\")))",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-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++/trunk/src/",
+ "buildtools/third_party/libc++abi/trunk/include",
+ ],
+ cpp_std: "c++20",
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ cppflags: [
+ "-fexceptions",
+ ],
+ rtti: true,
+ target: {
+ 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: //buildtools/third_party/libc++abi:libc++abi
-cc_object {
+cc_library_static {
name: "cronet_aml_buildtools_third_party_libc__abi_libc__abi",
srcs: [
"buildtools/third_party/libc++abi/trunk/src/abort_message.cpp",
@@ -2321,6 +6265,7 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DLIBCXXABI_SILENT_TERMINATE",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
@@ -2328,6 +6273,13 @@
"-D_LIBCPP_CONSTINIT=constinit",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-fdata-sections",
+ "-ffunction-sections",
+ "-fno-asynchronous-unwind-tables",
+ "-fno-unwind-tables",
+ "-fvisibility-inlines-hidden",
+ "-fvisibility=hidden",
+ "-g1",
],
local_include_dirs: [
"./",
@@ -2337,6 +6289,11 @@
"buildtools/third_party/libc++abi/trunk/include",
],
cpp_std: "c++20",
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
cppflags: [
"-fexceptions",
],
@@ -2350,6 +6307,8 @@
"-DANDROID",
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DHAVE_SYS_UIO_H",
+ "-Oz",
+ "-fstack-protector",
],
},
android_arm64: {
@@ -2360,6 +6319,10 @@
"-DANDROID",
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DHAVE_SYS_UIO_H",
+ "-Oz",
+ "-fstack-protector",
+ "-mno-outline",
+ "-mno-outline-atomics",
],
},
android_x86: {
@@ -2370,6 +6333,7 @@
"-DANDROID",
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DHAVE_SYS_UIO_H",
+ "-Oz",
"-msse3",
],
},
@@ -2381,6 +6345,8 @@
"-DANDROID",
"-DANDROID_NDK_VERSION_ROLL=r23_1",
"-DHAVE_SYS_UIO_H",
+ "-Oz",
+ "-fstack-protector",
"-msse3",
],
},
@@ -2390,15 +6356,154 @@
],
cflags: [
"-DCR_SYSROOT_KEY=20220331T153654Z-0",
- "-DNO_UNWIND_TABLES",
"-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: //buildtools/third_party/libc++abi:libc++abi__testing
+cc_library_static {
+ name: "cronet_aml_buildtools_third_party_libc__abi_libc__abi__testing",
+ srcs: [
+ "buildtools/third_party/libc++abi/trunk/src/abort_message.cpp",
+ "buildtools/third_party/libc++abi/trunk/src/cxa_aux_runtime.cpp",
+ "buildtools/third_party/libc++abi/trunk/src/cxa_default_handlers.cpp",
+ "buildtools/third_party/libc++abi/trunk/src/cxa_exception.cpp",
+ "buildtools/third_party/libc++abi/trunk/src/cxa_exception_storage.cpp",
+ "buildtools/third_party/libc++abi/trunk/src/cxa_guard.cpp",
+ "buildtools/third_party/libc++abi/trunk/src/cxa_handlers.cpp",
+ "buildtools/third_party/libc++abi/trunk/src/cxa_personality.cpp",
+ "buildtools/third_party/libc++abi/trunk/src/cxa_thread_atexit.cpp",
+ "buildtools/third_party/libc++abi/trunk/src/cxa_vector.cpp",
+ "buildtools/third_party/libc++abi/trunk/src/cxa_virtual.cpp",
+ "buildtools/third_party/libc++abi/trunk/src/fallback_malloc.cpp",
+ "buildtools/third_party/libc++abi/trunk/src/private_typeinfo.cpp",
+ "buildtools/third_party/libc++abi/trunk/src/stdlib_exception.cpp",
+ "buildtools/third_party/libc++abi/trunk/src/stdlib_stdexcept.cpp",
+ "buildtools/third_party/libc++abi/trunk/src/stdlib_typeinfo.cpp",
+ ],
+ host_supported: true,
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DLIBCXXABI_SILENT_TERMINATE",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_BUILDING_LIBRARY",
+ "-D_LIBCPP_CONSTINIT=constinit",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-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++/trunk/src/",
+ "buildtools/third_party/libc++abi/trunk/include",
+ ],
+ cpp_std: "c++20",
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ cppflags: [
+ "-fexceptions",
+ ],
+ rtti: true,
+ target: {
+ android_arm: {
+ srcs: [
+ "buildtools/third_party/libc++abi/cxa_demangle_stub.cc",
+ ],
+ cflags: [
+ "-DANDROID",
+ "-DANDROID_NDK_VERSION_ROLL=r23_1",
+ "-DHAVE_SYS_UIO_H",
+ "-Oz",
+ "-fstack-protector",
+ ],
+ },
+ android_arm64: {
+ srcs: [
+ "buildtools/third_party/libc++abi/cxa_demangle_stub.cc",
+ ],
+ cflags: [
+ "-DANDROID",
+ "-DANDROID_NDK_VERSION_ROLL=r23_1",
+ "-DHAVE_SYS_UIO_H",
+ "-Oz",
+ "-fstack-protector",
+ "-mno-outline",
+ "-mno-outline-atomics",
+ ],
+ },
+ android_x86: {
+ srcs: [
+ "buildtools/third_party/libc++abi/cxa_demangle_stub.cc",
+ ],
+ cflags: [
+ "-DANDROID",
+ "-DANDROID_NDK_VERSION_ROLL=r23_1",
+ "-DHAVE_SYS_UIO_H",
+ "-Oz",
+ "-msse3",
+ ],
+ },
+ android_x86_64: {
+ srcs: [
+ "buildtools/third_party/libc++abi/cxa_demangle_stub.cc",
+ ],
+ cflags: [
+ "-DANDROID",
+ "-DANDROID_NDK_VERSION_ROLL=r23_1",
+ "-DHAVE_SYS_UIO_H",
+ "-Oz",
+ "-fstack-protector",
+ "-msse3",
+ ],
+ },
+ host: {
+ srcs: [
+ "buildtools/third_party/libc++abi/trunk/src/cxa_demangle.cpp",
+ ],
+ 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",
},
},
}
@@ -2426,16 +6531,33 @@
],
}
+// GN: //components/cronet/android:buildflags__testing
+cc_genrule {
+ name: "cronet_aml_components_cronet_android_buildflags__testing",
+ cmd: "echo '--flags INTEGRATED_MODE=\"false\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//components/cronet/android:buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin",
+ out: [
+ "components/cronet/android/buildflags.h",
+ ],
+ tool_files: [
+ "build/write_buildflag_header.py",
+ ],
+ apex_available: [
+ "com.android.tethering",
+ ],
+}
+
// GN: //components/cronet/android:cronet
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: [
@@ -2447,15 +6569,79 @@
"cronet_aml_base_allocator_partition_allocator_partition_alloc",
"cronet_aml_base_base",
"cronet_aml_base_base_static",
+ "cronet_aml_base_nodebug_assertion",
"cronet_aml_base_third_party_double_conversion_double_conversion",
"cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations",
+ "cronet_aml_buildtools_third_party_libc___libc__",
+ "cronet_aml_buildtools_third_party_libc__abi_libc__abi",
+ "cronet_aml_components_cronet_android_cronet_static",
+ "cronet_aml_components_cronet_cronet_common",
+ "cronet_aml_components_cronet_cronet_version_header",
+ "cronet_aml_components_cronet_metrics_util",
+ "cronet_aml_components_metrics_library_support",
"cronet_aml_components_prefs_prefs",
"cronet_aml_crypto_crypto",
+ "cronet_aml_net_dns_dns",
+ "cronet_aml_net_dns_public_public",
+ "cronet_aml_net_http_transport_security_state_generated_files",
"cronet_aml_net_net",
+ "cronet_aml_net_net_deps",
+ "cronet_aml_net_net_public_deps",
"cronet_aml_net_preload_decoder",
"cronet_aml_net_third_party_quiche_quiche",
+ "cronet_aml_net_traffic_annotation_traffic_annotation",
"cronet_aml_net_uri_template",
+ "cronet_aml_third_party_abseil_cpp_absl_base_base",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+ "cronet_aml_third_party_abseil_cpp_absl_base_strerror",
+ "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+ "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler",
+ "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_city",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_hash",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+ "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
+ "cronet_aml_third_party_abseil_cpp_absl_random_distributions",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material",
+ "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception",
+ "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences",
+ "cronet_aml_third_party_abseil_cpp_absl_status_status",
+ "cronet_aml_third_party_abseil_cpp_absl_status_statusor",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cord",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+ "cronet_aml_third_party_abseil_cpp_absl_time_time",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access",
+ "cronet_aml_third_party_android_ndk_cpu_features",
+ "cronet_aml_third_party_ashmem_ashmem",
"cronet_aml_third_party_boringssl_boringssl",
+ "cronet_aml_third_party_boringssl_boringssl_asm",
"cronet_aml_third_party_brotli_common",
"cronet_aml_third_party_brotli_dec",
"cronet_aml_third_party_icu_icui18n",
@@ -2465,30 +6651,6 @@
"cronet_aml_third_party_protobuf_protobuf_lite",
"cronet_aml_url_url",
],
- generated_headers: [
- "cronet_aml_base_debugging_buildflags",
- "cronet_aml_base_logging_buildflags",
- "cronet_aml_build_chromeos_buildflags",
- "cronet_aml_components_cronet_android_buildflags",
- "cronet_aml_components_cronet_android_cronet_jni_headers",
- "cronet_aml_components_cronet_android_cronet_jni_registration",
- "cronet_aml_components_cronet_cronet_buildflags",
- "cronet_aml_components_cronet_cronet_version_header_action",
- "cronet_aml_third_party_metrics_proto_metrics_proto_gen_headers",
- "cronet_aml_url_buildflags",
- ],
- export_generated_headers: [
- "cronet_aml_base_debugging_buildflags",
- "cronet_aml_base_logging_buildflags",
- "cronet_aml_build_chromeos_buildflags",
- "cronet_aml_components_cronet_android_buildflags",
- "cronet_aml_components_cronet_android_cronet_jni_headers",
- "cronet_aml_components_cronet_android_cronet_jni_registration",
- "cronet_aml_components_cronet_cronet_buildflags",
- "cronet_aml_components_cronet_cronet_version_header_action",
- "cronet_aml_third_party_metrics_proto_metrics_proto_gen_headers",
- "cronet_aml_url_buildflags",
- ],
defaults: [
"cronet_aml_defaults",
],
@@ -2504,6 +6666,7 @@
"-DHAVE_PTHREAD",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-D_FORTIFY_SOURCE=2",
@@ -2512,6 +6675,14 @@
"-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: [
"./",
@@ -2527,10 +6698,40 @@
],
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",
],
stem: "libcronet.108.0.5359.128",
target: {
+ android_arm: {
+ cflags: [
+ "-fstack-protector",
+ ],
+ },
+ android_arm64: {
+ cflags: [
+ "-fstack-protector",
+ "-mno-outline",
+ "-mno-outline-atomics",
+ ],
+ },
android_x86: {
cflags: [
"-msse3",
@@ -2538,6 +6739,7 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
@@ -2602,6 +6804,62 @@
],
}
+// GN: //components/cronet/android:cronet_jni_headers__testing
+cc_genrule {
+ name: "cronet_aml_components_cronet_android_cronet_jni_headers__testing",
+ srcs: [
+ "components/cronet/android/java/src/org/chromium/net/impl/CronetBidirectionalStream.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/CronetLibraryLoader.java",
+ "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",
+ ],
+ cmd: "$(location base/android/jni_generator/jni_generator.py) --ptr_type " +
+ "long " +
+ "--output_dir " +
+ "$(genDir)/components/cronet/android/cronet_jni_headers " +
+ "--includes " +
+ "base/android/jni_generator/jni_generator_helper.h " +
+ "--use_proxy_hash " +
+ "--output_name " +
+ "CronetBidirectionalStream_jni.h " +
+ "--output_name " +
+ "CronetLibraryLoader_jni.h " +
+ "--output_name " +
+ "CronetUploadDataStream_jni.h " +
+ "--output_name " +
+ "CronetUrlRequest_jni.h " +
+ "--output_name " +
+ "CronetUrlRequestContext_jni.h " +
+ "--input_file " +
+ "$(location components/cronet/android/java/src/org/chromium/net/impl/CronetBidirectionalStream.java) " +
+ "--input_file " +
+ "$(location components/cronet/android/java/src/org/chromium/net/impl/CronetLibraryLoader.java) " +
+ "--input_file " +
+ "$(location components/cronet/android/java/src/org/chromium/net/impl/CronetUploadDataStream.java) " +
+ "--input_file " +
+ "$(location components/cronet/android/java/src/org/chromium/net/impl/CronetUrlRequest.java) " +
+ "--input_file " +
+ "$(location components/cronet/android/java/src/org/chromium/net/impl/CronetUrlRequestContext.java)",
+ out: [
+ "components/cronet/android/cronet_jni_headers/CronetBidirectionalStream_jni.h",
+ "components/cronet/android/cronet_jni_headers/CronetLibraryLoader_jni.h",
+ "components/cronet/android/cronet_jni_headers/CronetUploadDataStream_jni.h",
+ "components/cronet/android/cronet_jni_headers/CronetUrlRequestContext_jni.h",
+ "components/cronet/android/cronet_jni_headers/CronetUrlRequest_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: //components/cronet/android:cronet_jni_registration
cc_genrule {
name: "cronet_aml_components_cronet_android_cronet_jni_registration",
@@ -3104,8 +7362,506 @@
],
}
+// GN: //components/cronet/android:cronet_jni_registration
+java_genrule {
+ name: "cronet_aml_components_cronet_android_cronet_jni_registration__java__testing",
+ srcs: [
+ "base/android/java/src/org/chromium/base/ActivityState.java",
+ "base/android/java/src/org/chromium/base/ApiCompatibilityUtils.java",
+ "base/android/java/src/org/chromium/base/ApkAssets.java",
+ "base/android/java/src/org/chromium/base/ApplicationStatus.java",
+ "base/android/java/src/org/chromium/base/BaseFeatureList.java",
+ "base/android/java/src/org/chromium/base/BuildInfo.java",
+ "base/android/java/src/org/chromium/base/BundleUtils.java",
+ "base/android/java/src/org/chromium/base/ByteArrayGenerator.java",
+ "base/android/java/src/org/chromium/base/Callback.java",
+ "base/android/java/src/org/chromium/base/CallbackController.java",
+ "base/android/java/src/org/chromium/base/CollectionUtil.java",
+ "base/android/java/src/org/chromium/base/CommandLine.java",
+ "base/android/java/src/org/chromium/base/CommandLineInitUtil.java",
+ "base/android/java/src/org/chromium/base/Consumer.java",
+ "base/android/java/src/org/chromium/base/ContentUriUtils.java",
+ "base/android/java/src/org/chromium/base/ContextUtils.java",
+ "base/android/java/src/org/chromium/base/CpuFeatures.java",
+ "base/android/java/src/org/chromium/base/DiscardableReferencePool.java",
+ "base/android/java/src/org/chromium/base/EarlyTraceEvent.java",
+ "base/android/java/src/org/chromium/base/EventLog.java",
+ "base/android/java/src/org/chromium/base/FeatureList.java",
+ "base/android/java/src/org/chromium/base/Features.java",
+ "base/android/java/src/org/chromium/base/FieldTrialList.java",
+ "base/android/java/src/org/chromium/base/FileUtils.java",
+ "base/android/java/src/org/chromium/base/Function.java",
+ "base/android/java/src/org/chromium/base/ImportantFileWriterAndroid.java",
+ "base/android/java/src/org/chromium/base/IntStringCallback.java",
+ "base/android/java/src/org/chromium/base/JNIUtils.java",
+ "base/android/java/src/org/chromium/base/JavaExceptionReporter.java",
+ "base/android/java/src/org/chromium/base/JavaHandlerThread.java",
+ "base/android/java/src/org/chromium/base/JniException.java",
+ "base/android/java/src/org/chromium/base/JniStaticTestMocker.java",
+ "base/android/java/src/org/chromium/base/LifetimeAssert.java",
+ "base/android/java/src/org/chromium/base/LocaleUtils.java",
+ "base/android/java/src/org/chromium/base/Log.java",
+ "base/android/java/src/org/chromium/base/MathUtils.java",
+ "base/android/java/src/org/chromium/base/MemoryPressureListener.java",
+ "base/android/java/src/org/chromium/base/NativeLibraryLoadedStatus.java",
+ "base/android/java/src/org/chromium/base/ObserverList.java",
+ "base/android/java/src/org/chromium/base/PackageManagerUtils.java",
+ "base/android/java/src/org/chromium/base/PackageUtils.java",
+ "base/android/java/src/org/chromium/base/PathService.java",
+ "base/android/java/src/org/chromium/base/PathUtils.java",
+ "base/android/java/src/org/chromium/base/PiiElider.java",
+ "base/android/java/src/org/chromium/base/PowerMonitor.java",
+ "base/android/java/src/org/chromium/base/PowerMonitorForQ.java",
+ "base/android/java/src/org/chromium/base/Predicate.java",
+ "base/android/java/src/org/chromium/base/Promise.java",
+ "base/android/java/src/org/chromium/base/RadioUtils.java",
+ "base/android/java/src/org/chromium/base/StreamUtil.java",
+ "base/android/java/src/org/chromium/base/StrictModeContext.java",
+ "base/android/java/src/org/chromium/base/SysUtils.java",
+ "base/android/java/src/org/chromium/base/ThreadUtils.java",
+ "base/android/java/src/org/chromium/base/TimeUtils.java",
+ "base/android/java/src/org/chromium/base/TimezoneUtils.java",
+ "base/android/java/src/org/chromium/base/TraceEvent.java",
+ "base/android/java/src/org/chromium/base/UnguessableToken.java",
+ "base/android/java/src/org/chromium/base/UnownedUserData.java",
+ "base/android/java/src/org/chromium/base/UnownedUserDataHost.java",
+ "base/android/java/src/org/chromium/base/UnownedUserDataKey.java",
+ "base/android/java/src/org/chromium/base/UserData.java",
+ "base/android/java/src/org/chromium/base/UserDataHost.java",
+ "base/android/java/src/org/chromium/base/WrappedClassLoader.java",
+ "base/android/java/src/org/chromium/base/annotations/AccessedByNative.java",
+ "base/android/java/src/org/chromium/base/annotations/CalledByNative.java",
+ "base/android/java/src/org/chromium/base/annotations/CalledByNativeForTesting.java",
+ "base/android/java/src/org/chromium/base/annotations/CalledByNativeUnchecked.java",
+ "base/android/java/src/org/chromium/base/annotations/JNIAdditionalImport.java",
+ "base/android/java/src/org/chromium/base/annotations/JNINamespace.java",
+ "base/android/java/src/org/chromium/base/annotations/JniIgnoreNatives.java",
+ "base/android/java/src/org/chromium/base/annotations/NativeClassQualifiedName.java",
+ "base/android/java/src/org/chromium/base/annotations/NativeMethods.java",
+ "base/android/java/src/org/chromium/base/compat/ApiHelperForM.java",
+ "base/android/java/src/org/chromium/base/compat/ApiHelperForN.java",
+ "base/android/java/src/org/chromium/base/compat/ApiHelperForO.java",
+ "base/android/java/src/org/chromium/base/compat/ApiHelperForOMR1.java",
+ "base/android/java/src/org/chromium/base/compat/ApiHelperForP.java",
+ "base/android/java/src/org/chromium/base/compat/ApiHelperForQ.java",
+ "base/android/java/src/org/chromium/base/compat/ApiHelperForR.java",
+ "base/android/java/src/org/chromium/base/compat/ApiHelperForS.java",
+ "base/android/java/src/org/chromium/base/jank_tracker/DummyJankTracker.java",
+ "base/android/java/src/org/chromium/base/jank_tracker/FrameMetrics.java",
+ "base/android/java/src/org/chromium/base/jank_tracker/FrameMetricsListener.java",
+ "base/android/java/src/org/chromium/base/jank_tracker/FrameMetricsStore.java",
+ "base/android/java/src/org/chromium/base/jank_tracker/JankActivityTracker.java",
+ "base/android/java/src/org/chromium/base/jank_tracker/JankMetricCalculator.java",
+ "base/android/java/src/org/chromium/base/jank_tracker/JankMetricUMARecorder.java",
+ "base/android/java/src/org/chromium/base/jank_tracker/JankMetrics.java",
+ "base/android/java/src/org/chromium/base/jank_tracker/JankReportingRunnable.java",
+ "base/android/java/src/org/chromium/base/jank_tracker/JankReportingScheduler.java",
+ "base/android/java/src/org/chromium/base/jank_tracker/JankScenario.java",
+ "base/android/java/src/org/chromium/base/jank_tracker/JankTracker.java",
+ "base/android/java/src/org/chromium/base/jank_tracker/JankTrackerImpl.java",
+ "base/android/java/src/org/chromium/base/library_loader/LegacyLinker.java",
+ "base/android/java/src/org/chromium/base/library_loader/LibraryLoader.java",
+ "base/android/java/src/org/chromium/base/library_loader/LibraryPrefetcher.java",
+ "base/android/java/src/org/chromium/base/library_loader/Linker.java",
+ "base/android/java/src/org/chromium/base/library_loader/LinkerJni.java",
+ "base/android/java/src/org/chromium/base/library_loader/LoaderErrors.java",
+ "base/android/java/src/org/chromium/base/library_loader/ModernLinker.java",
+ "base/android/java/src/org/chromium/base/library_loader/ModernLinkerJni.java",
+ "base/android/java/src/org/chromium/base/library_loader/NativeLibraryPreloader.java",
+ "base/android/java/src/org/chromium/base/library_loader/ProcessInitException.java",
+ "base/android/java/src/org/chromium/base/lifetime/DestroyChecker.java",
+ "base/android/java/src/org/chromium/base/lifetime/Destroyable.java",
+ "base/android/java/src/org/chromium/base/memory/JavaHeapDumpGenerator.java",
+ "base/android/java/src/org/chromium/base/memory/MemoryPressureCallback.java",
+ "base/android/java/src/org/chromium/base/memory/MemoryPressureMonitor.java",
+ "base/android/java/src/org/chromium/base/memory/MemoryPressureUma.java",
+ "base/android/java/src/org/chromium/base/memory/MemoryPurgeManager.java",
+ "base/android/java/src/org/chromium/base/metrics/CachingUmaRecorder.java",
+ "base/android/java/src/org/chromium/base/metrics/NativeUmaRecorder.java",
+ "base/android/java/src/org/chromium/base/metrics/NoopUmaRecorder.java",
+ "base/android/java/src/org/chromium/base/metrics/RecordHistogram.java",
+ "base/android/java/src/org/chromium/base/metrics/RecordUserAction.java",
+ "base/android/java/src/org/chromium/base/metrics/ScopedSysTraceEvent.java",
+ "base/android/java/src/org/chromium/base/metrics/StatisticsRecorderAndroid.java",
+ "base/android/java/src/org/chromium/base/metrics/TimingMetric.java",
+ "base/android/java/src/org/chromium/base/metrics/UmaRecorder.java",
+ "base/android/java/src/org/chromium/base/metrics/UmaRecorderHolder.java",
+ "base/android/java/src/org/chromium/base/supplier/BooleanSupplier.java",
+ "base/android/java/src/org/chromium/base/supplier/DestroyableObservableSupplier.java",
+ "base/android/java/src/org/chromium/base/supplier/ObservableSupplier.java",
+ "base/android/java/src/org/chromium/base/supplier/ObservableSupplierImpl.java",
+ "base/android/java/src/org/chromium/base/supplier/OneShotCallback.java",
+ "base/android/java/src/org/chromium/base/supplier/OneshotSupplier.java",
+ "base/android/java/src/org/chromium/base/supplier/OneshotSupplierImpl.java",
+ "base/android/java/src/org/chromium/base/supplier/Supplier.java",
+ "base/android/java/src/org/chromium/base/supplier/UnownedUserDataSupplier.java",
+ "base/android/java/src/org/chromium/base/task/AsyncTask.java",
+ "base/android/java/src/org/chromium/base/task/BackgroundOnlyAsyncTask.java",
+ "base/android/java/src/org/chromium/base/task/ChainedTasks.java",
+ "base/android/java/src/org/chromium/base/task/ChoreographerTaskRunner.java",
+ "base/android/java/src/org/chromium/base/task/ChromeThreadPoolExecutor.java",
+ "base/android/java/src/org/chromium/base/task/DefaultTaskExecutor.java",
+ "base/android/java/src/org/chromium/base/task/PostTask.java",
+ "base/android/java/src/org/chromium/base/task/SequencedTaskRunner.java",
+ "base/android/java/src/org/chromium/base/task/SequencedTaskRunnerImpl.java",
+ "base/android/java/src/org/chromium/base/task/SerialExecutor.java",
+ "base/android/java/src/org/chromium/base/task/SingleThreadTaskRunner.java",
+ "base/android/java/src/org/chromium/base/task/SingleThreadTaskRunnerImpl.java",
+ "base/android/java/src/org/chromium/base/task/TaskExecutor.java",
+ "base/android/java/src/org/chromium/base/task/TaskRunner.java",
+ "base/android/java/src/org/chromium/base/task/TaskRunnerImpl.java",
+ "base/android/java/src/org/chromium/base/task/TaskTraits.java",
+ "base/android/java/src/org/chromium/base/task/TaskTraitsExtensionDescriptor.java",
+ "build/android/java/src/org/chromium/build/annotations/AlwaysInline.java",
+ "build/android/java/src/org/chromium/build/annotations/CheckDiscard.java",
+ "build/android/java/src/org/chromium/build/annotations/DoNotClassMerge.java",
+ "build/android/java/src/org/chromium/build/annotations/DoNotInline.java",
+ "build/android/java/src/org/chromium/build/annotations/IdentifierNameString.java",
+ "build/android/java/src/org/chromium/build/annotations/MainDex.java",
+ "build/android/java/src/org/chromium/build/annotations/MockedInTests.java",
+ "build/android/java/src/org/chromium/build/annotations/UsedByReflection.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/BidirectionalStreamBuilderImpl.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/BidirectionalStreamNetworkException.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/CallbackExceptionImpl.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/CronetBidirectionalStream.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/CronetEngineBase.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/CronetEngineBuilderImpl.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/CronetExceptionImpl.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/CronetLibraryLoader.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/CronetLogger.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/CronetLoggerFactory.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/CronetManifest.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/CronetMetrics.java",
+ "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/NativeCronetEngineBuilderImpl.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/NetworkExceptionImpl.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/NoOpLogger.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/Preconditions.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/QuicExceptionImpl.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/RequestFinishedInfoImpl.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/UrlRequestBase.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/UrlRequestBuilderImpl.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/UrlResponseInfoImpl.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/UserAgent.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/VersionSafeCallbacks.java",
+ "components/cronet/android/java/src/org/chromium/net/urlconnection/CronetBufferedOutputStream.java",
+ "components/cronet/android/java/src/org/chromium/net/urlconnection/CronetChunkedOutputStream.java",
+ "components/cronet/android/java/src/org/chromium/net/urlconnection/CronetFixedModeOutputStream.java",
+ "components/cronet/android/java/src/org/chromium/net/urlconnection/CronetHttpURLConnection.java",
+ "components/cronet/android/java/src/org/chromium/net/urlconnection/CronetHttpURLStreamHandler.java",
+ "components/cronet/android/java/src/org/chromium/net/urlconnection/CronetInputStream.java",
+ "components/cronet/android/java/src/org/chromium/net/urlconnection/CronetOutputStream.java",
+ "components/cronet/android/java/src/org/chromium/net/urlconnection/CronetURLStreamHandlerFactory.java",
+ "components/cronet/android/java/src/org/chromium/net/urlconnection/MessageLoop.java",
+ "net/android/java/src/org/chromium/net/AndroidCertVerifyResult.java",
+ "net/android/java/src/org/chromium/net/AndroidKeyStore.java",
+ "net/android/java/src/org/chromium/net/AndroidNetworkLibrary.java",
+ "net/android/java/src/org/chromium/net/AndroidTrafficStats.java",
+ "net/android/java/src/org/chromium/net/ChromiumNetworkAdapter.java",
+ "net/android/java/src/org/chromium/net/DnsStatus.java",
+ "net/android/java/src/org/chromium/net/GURLUtils.java",
+ "net/android/java/src/org/chromium/net/HttpNegotiateAuthenticator.java",
+ "net/android/java/src/org/chromium/net/HttpNegotiateConstants.java",
+ "net/android/java/src/org/chromium/net/HttpUtil.java",
+ "net/android/java/src/org/chromium/net/MimeTypeFilter.java",
+ "net/android/java/src/org/chromium/net/NetStringUtil.java",
+ "net/android/java/src/org/chromium/net/NetworkActiveNotifier.java",
+ "net/android/java/src/org/chromium/net/NetworkChangeNotifier.java",
+ "net/android/java/src/org/chromium/net/NetworkChangeNotifierAutoDetect.java",
+ "net/android/java/src/org/chromium/net/NetworkTrafficAnnotationTag.java",
+ "net/android/java/src/org/chromium/net/ProxyBroadcastReceiver.java",
+ "net/android/java/src/org/chromium/net/ProxyChangeListener.java",
+ "net/android/java/src/org/chromium/net/RegistrationPolicyAlwaysRegister.java",
+ "net/android/java/src/org/chromium/net/RegistrationPolicyApplicationStatus.java",
+ "net/android/java/src/org/chromium/net/ThreadStatsUid.java",
+ "net/android/java/src/org/chromium/net/X509Util.java",
+ "url/android/java/src/org/chromium/url/IDNStringUtil.java",
+ ],
+ cmd: "current_dir=`basename \\`pwd\\``; " +
+ "for f in $(in); " +
+ "do " +
+ "echo \"../$$current_dir/$$f\" >> $(genDir)/java.sources; " +
+ "done; " +
+ "python3 $(location base/android/jni_generator/jni_registration_generator.py) --srcjar-path " +
+ "$(genDir)/components/cronet/android/cronet_jni_registration.srcjar " +
+ "--depfile " +
+ "$(genDir)/components/cronet/android/cronet_jni_registration.d " +
+ "--sources-files " +
+ "$(genDir)/java.sources " +
+ "--include_test_only " +
+ "--use_proxy_hash " +
+ "--header-path " +
+ "$(genDir)/components/cronet/android/cronet_jni_registration.h " +
+ "--manual_jni_registration " +
+ ";sed -i -e 's/OUT_SOONG_.TEMP_SBOX_.*_OUT/GEN/g' " +
+ "$(genDir)/components/cronet/android/cronet_jni_registration.h",
+ out: [
+ "components/cronet/android/cronet_jni_registration.srcjar",
+ ],
+ tool_files: [
+ "base/android/jni_generator/jni_generator.py",
+ "base/android/jni_generator/jni_registration_generator.py",
+ "build/android/gyp/util/__init__.py",
+ "build/android/gyp/util/build_utils.py",
+ "build/gn_helpers.py",
+ ],
+}
+
+// GN: //components/cronet/android:cronet_jni_registration__testing
+cc_genrule {
+ name: "cronet_aml_components_cronet_android_cronet_jni_registration__testing",
+ srcs: [
+ "base/android/java/src/org/chromium/base/ActivityState.java",
+ "base/android/java/src/org/chromium/base/ApiCompatibilityUtils.java",
+ "base/android/java/src/org/chromium/base/ApkAssets.java",
+ "base/android/java/src/org/chromium/base/ApplicationStatus.java",
+ "base/android/java/src/org/chromium/base/BaseFeatureList.java",
+ "base/android/java/src/org/chromium/base/BuildInfo.java",
+ "base/android/java/src/org/chromium/base/BundleUtils.java",
+ "base/android/java/src/org/chromium/base/ByteArrayGenerator.java",
+ "base/android/java/src/org/chromium/base/Callback.java",
+ "base/android/java/src/org/chromium/base/CallbackController.java",
+ "base/android/java/src/org/chromium/base/CollectionUtil.java",
+ "base/android/java/src/org/chromium/base/CommandLine.java",
+ "base/android/java/src/org/chromium/base/CommandLineInitUtil.java",
+ "base/android/java/src/org/chromium/base/Consumer.java",
+ "base/android/java/src/org/chromium/base/ContentUriUtils.java",
+ "base/android/java/src/org/chromium/base/ContextUtils.java",
+ "base/android/java/src/org/chromium/base/CpuFeatures.java",
+ "base/android/java/src/org/chromium/base/DiscardableReferencePool.java",
+ "base/android/java/src/org/chromium/base/EarlyTraceEvent.java",
+ "base/android/java/src/org/chromium/base/EventLog.java",
+ "base/android/java/src/org/chromium/base/FeatureList.java",
+ "base/android/java/src/org/chromium/base/Features.java",
+ "base/android/java/src/org/chromium/base/FieldTrialList.java",
+ "base/android/java/src/org/chromium/base/FileUtils.java",
+ "base/android/java/src/org/chromium/base/Function.java",
+ "base/android/java/src/org/chromium/base/ImportantFileWriterAndroid.java",
+ "base/android/java/src/org/chromium/base/IntStringCallback.java",
+ "base/android/java/src/org/chromium/base/JNIUtils.java",
+ "base/android/java/src/org/chromium/base/JavaExceptionReporter.java",
+ "base/android/java/src/org/chromium/base/JavaHandlerThread.java",
+ "base/android/java/src/org/chromium/base/JniException.java",
+ "base/android/java/src/org/chromium/base/JniStaticTestMocker.java",
+ "base/android/java/src/org/chromium/base/LifetimeAssert.java",
+ "base/android/java/src/org/chromium/base/LocaleUtils.java",
+ "base/android/java/src/org/chromium/base/Log.java",
+ "base/android/java/src/org/chromium/base/MathUtils.java",
+ "base/android/java/src/org/chromium/base/MemoryPressureListener.java",
+ "base/android/java/src/org/chromium/base/NativeLibraryLoadedStatus.java",
+ "base/android/java/src/org/chromium/base/ObserverList.java",
+ "base/android/java/src/org/chromium/base/PackageManagerUtils.java",
+ "base/android/java/src/org/chromium/base/PackageUtils.java",
+ "base/android/java/src/org/chromium/base/PathService.java",
+ "base/android/java/src/org/chromium/base/PathUtils.java",
+ "base/android/java/src/org/chromium/base/PiiElider.java",
+ "base/android/java/src/org/chromium/base/PowerMonitor.java",
+ "base/android/java/src/org/chromium/base/PowerMonitorForQ.java",
+ "base/android/java/src/org/chromium/base/Predicate.java",
+ "base/android/java/src/org/chromium/base/Promise.java",
+ "base/android/java/src/org/chromium/base/RadioUtils.java",
+ "base/android/java/src/org/chromium/base/StreamUtil.java",
+ "base/android/java/src/org/chromium/base/StrictModeContext.java",
+ "base/android/java/src/org/chromium/base/SysUtils.java",
+ "base/android/java/src/org/chromium/base/ThreadUtils.java",
+ "base/android/java/src/org/chromium/base/TimeUtils.java",
+ "base/android/java/src/org/chromium/base/TimezoneUtils.java",
+ "base/android/java/src/org/chromium/base/TraceEvent.java",
+ "base/android/java/src/org/chromium/base/UnguessableToken.java",
+ "base/android/java/src/org/chromium/base/UnownedUserData.java",
+ "base/android/java/src/org/chromium/base/UnownedUserDataHost.java",
+ "base/android/java/src/org/chromium/base/UnownedUserDataKey.java",
+ "base/android/java/src/org/chromium/base/UserData.java",
+ "base/android/java/src/org/chromium/base/UserDataHost.java",
+ "base/android/java/src/org/chromium/base/WrappedClassLoader.java",
+ "base/android/java/src/org/chromium/base/annotations/AccessedByNative.java",
+ "base/android/java/src/org/chromium/base/annotations/CalledByNative.java",
+ "base/android/java/src/org/chromium/base/annotations/CalledByNativeForTesting.java",
+ "base/android/java/src/org/chromium/base/annotations/CalledByNativeUnchecked.java",
+ "base/android/java/src/org/chromium/base/annotations/JNIAdditionalImport.java",
+ "base/android/java/src/org/chromium/base/annotations/JNINamespace.java",
+ "base/android/java/src/org/chromium/base/annotations/JniIgnoreNatives.java",
+ "base/android/java/src/org/chromium/base/annotations/NativeClassQualifiedName.java",
+ "base/android/java/src/org/chromium/base/annotations/NativeMethods.java",
+ "base/android/java/src/org/chromium/base/compat/ApiHelperForM.java",
+ "base/android/java/src/org/chromium/base/compat/ApiHelperForN.java",
+ "base/android/java/src/org/chromium/base/compat/ApiHelperForO.java",
+ "base/android/java/src/org/chromium/base/compat/ApiHelperForOMR1.java",
+ "base/android/java/src/org/chromium/base/compat/ApiHelperForP.java",
+ "base/android/java/src/org/chromium/base/compat/ApiHelperForQ.java",
+ "base/android/java/src/org/chromium/base/compat/ApiHelperForR.java",
+ "base/android/java/src/org/chromium/base/compat/ApiHelperForS.java",
+ "base/android/java/src/org/chromium/base/jank_tracker/DummyJankTracker.java",
+ "base/android/java/src/org/chromium/base/jank_tracker/FrameMetrics.java",
+ "base/android/java/src/org/chromium/base/jank_tracker/FrameMetricsListener.java",
+ "base/android/java/src/org/chromium/base/jank_tracker/FrameMetricsStore.java",
+ "base/android/java/src/org/chromium/base/jank_tracker/JankActivityTracker.java",
+ "base/android/java/src/org/chromium/base/jank_tracker/JankMetricCalculator.java",
+ "base/android/java/src/org/chromium/base/jank_tracker/JankMetricUMARecorder.java",
+ "base/android/java/src/org/chromium/base/jank_tracker/JankMetrics.java",
+ "base/android/java/src/org/chromium/base/jank_tracker/JankReportingRunnable.java",
+ "base/android/java/src/org/chromium/base/jank_tracker/JankReportingScheduler.java",
+ "base/android/java/src/org/chromium/base/jank_tracker/JankScenario.java",
+ "base/android/java/src/org/chromium/base/jank_tracker/JankTracker.java",
+ "base/android/java/src/org/chromium/base/jank_tracker/JankTrackerImpl.java",
+ "base/android/java/src/org/chromium/base/library_loader/LegacyLinker.java",
+ "base/android/java/src/org/chromium/base/library_loader/LibraryLoader.java",
+ "base/android/java/src/org/chromium/base/library_loader/LibraryPrefetcher.java",
+ "base/android/java/src/org/chromium/base/library_loader/Linker.java",
+ "base/android/java/src/org/chromium/base/library_loader/LinkerJni.java",
+ "base/android/java/src/org/chromium/base/library_loader/LoaderErrors.java",
+ "base/android/java/src/org/chromium/base/library_loader/ModernLinker.java",
+ "base/android/java/src/org/chromium/base/library_loader/ModernLinkerJni.java",
+ "base/android/java/src/org/chromium/base/library_loader/NativeLibraryPreloader.java",
+ "base/android/java/src/org/chromium/base/library_loader/ProcessInitException.java",
+ "base/android/java/src/org/chromium/base/lifetime/DestroyChecker.java",
+ "base/android/java/src/org/chromium/base/lifetime/Destroyable.java",
+ "base/android/java/src/org/chromium/base/memory/JavaHeapDumpGenerator.java",
+ "base/android/java/src/org/chromium/base/memory/MemoryPressureCallback.java",
+ "base/android/java/src/org/chromium/base/memory/MemoryPressureMonitor.java",
+ "base/android/java/src/org/chromium/base/memory/MemoryPressureUma.java",
+ "base/android/java/src/org/chromium/base/memory/MemoryPurgeManager.java",
+ "base/android/java/src/org/chromium/base/metrics/CachingUmaRecorder.java",
+ "base/android/java/src/org/chromium/base/metrics/NativeUmaRecorder.java",
+ "base/android/java/src/org/chromium/base/metrics/NoopUmaRecorder.java",
+ "base/android/java/src/org/chromium/base/metrics/RecordHistogram.java",
+ "base/android/java/src/org/chromium/base/metrics/RecordUserAction.java",
+ "base/android/java/src/org/chromium/base/metrics/ScopedSysTraceEvent.java",
+ "base/android/java/src/org/chromium/base/metrics/StatisticsRecorderAndroid.java",
+ "base/android/java/src/org/chromium/base/metrics/TimingMetric.java",
+ "base/android/java/src/org/chromium/base/metrics/UmaRecorder.java",
+ "base/android/java/src/org/chromium/base/metrics/UmaRecorderHolder.java",
+ "base/android/java/src/org/chromium/base/supplier/BooleanSupplier.java",
+ "base/android/java/src/org/chromium/base/supplier/DestroyableObservableSupplier.java",
+ "base/android/java/src/org/chromium/base/supplier/ObservableSupplier.java",
+ "base/android/java/src/org/chromium/base/supplier/ObservableSupplierImpl.java",
+ "base/android/java/src/org/chromium/base/supplier/OneShotCallback.java",
+ "base/android/java/src/org/chromium/base/supplier/OneshotSupplier.java",
+ "base/android/java/src/org/chromium/base/supplier/OneshotSupplierImpl.java",
+ "base/android/java/src/org/chromium/base/supplier/Supplier.java",
+ "base/android/java/src/org/chromium/base/supplier/UnownedUserDataSupplier.java",
+ "base/android/java/src/org/chromium/base/task/AsyncTask.java",
+ "base/android/java/src/org/chromium/base/task/BackgroundOnlyAsyncTask.java",
+ "base/android/java/src/org/chromium/base/task/ChainedTasks.java",
+ "base/android/java/src/org/chromium/base/task/ChoreographerTaskRunner.java",
+ "base/android/java/src/org/chromium/base/task/ChromeThreadPoolExecutor.java",
+ "base/android/java/src/org/chromium/base/task/DefaultTaskExecutor.java",
+ "base/android/java/src/org/chromium/base/task/PostTask.java",
+ "base/android/java/src/org/chromium/base/task/SequencedTaskRunner.java",
+ "base/android/java/src/org/chromium/base/task/SequencedTaskRunnerImpl.java",
+ "base/android/java/src/org/chromium/base/task/SerialExecutor.java",
+ "base/android/java/src/org/chromium/base/task/SingleThreadTaskRunner.java",
+ "base/android/java/src/org/chromium/base/task/SingleThreadTaskRunnerImpl.java",
+ "base/android/java/src/org/chromium/base/task/TaskExecutor.java",
+ "base/android/java/src/org/chromium/base/task/TaskRunner.java",
+ "base/android/java/src/org/chromium/base/task/TaskRunnerImpl.java",
+ "base/android/java/src/org/chromium/base/task/TaskTraits.java",
+ "base/android/java/src/org/chromium/base/task/TaskTraitsExtensionDescriptor.java",
+ "build/android/java/src/org/chromium/build/annotations/AlwaysInline.java",
+ "build/android/java/src/org/chromium/build/annotations/CheckDiscard.java",
+ "build/android/java/src/org/chromium/build/annotations/DoNotClassMerge.java",
+ "build/android/java/src/org/chromium/build/annotations/DoNotInline.java",
+ "build/android/java/src/org/chromium/build/annotations/IdentifierNameString.java",
+ "build/android/java/src/org/chromium/build/annotations/MainDex.java",
+ "build/android/java/src/org/chromium/build/annotations/MockedInTests.java",
+ "build/android/java/src/org/chromium/build/annotations/UsedByReflection.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/BidirectionalStreamBuilderImpl.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/BidirectionalStreamNetworkException.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/CallbackExceptionImpl.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/CronetBidirectionalStream.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/CronetEngineBase.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/CronetEngineBuilderImpl.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/CronetExceptionImpl.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/CronetLibraryLoader.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/CronetLogger.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/CronetLoggerFactory.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/CronetManifest.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/CronetMetrics.java",
+ "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/NativeCronetEngineBuilderImpl.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/NetworkExceptionImpl.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/NoOpLogger.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/Preconditions.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/QuicExceptionImpl.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/RequestFinishedInfoImpl.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/UrlRequestBase.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/UrlRequestBuilderImpl.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/UrlResponseInfoImpl.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/UserAgent.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/VersionSafeCallbacks.java",
+ "components/cronet/android/java/src/org/chromium/net/urlconnection/CronetBufferedOutputStream.java",
+ "components/cronet/android/java/src/org/chromium/net/urlconnection/CronetChunkedOutputStream.java",
+ "components/cronet/android/java/src/org/chromium/net/urlconnection/CronetFixedModeOutputStream.java",
+ "components/cronet/android/java/src/org/chromium/net/urlconnection/CronetHttpURLConnection.java",
+ "components/cronet/android/java/src/org/chromium/net/urlconnection/CronetHttpURLStreamHandler.java",
+ "components/cronet/android/java/src/org/chromium/net/urlconnection/CronetInputStream.java",
+ "components/cronet/android/java/src/org/chromium/net/urlconnection/CronetOutputStream.java",
+ "components/cronet/android/java/src/org/chromium/net/urlconnection/CronetURLStreamHandlerFactory.java",
+ "components/cronet/android/java/src/org/chromium/net/urlconnection/MessageLoop.java",
+ "net/android/java/src/org/chromium/net/AndroidCertVerifyResult.java",
+ "net/android/java/src/org/chromium/net/AndroidKeyStore.java",
+ "net/android/java/src/org/chromium/net/AndroidNetworkLibrary.java",
+ "net/android/java/src/org/chromium/net/AndroidTrafficStats.java",
+ "net/android/java/src/org/chromium/net/ChromiumNetworkAdapter.java",
+ "net/android/java/src/org/chromium/net/DnsStatus.java",
+ "net/android/java/src/org/chromium/net/GURLUtils.java",
+ "net/android/java/src/org/chromium/net/HttpNegotiateAuthenticator.java",
+ "net/android/java/src/org/chromium/net/HttpNegotiateConstants.java",
+ "net/android/java/src/org/chromium/net/HttpUtil.java",
+ "net/android/java/src/org/chromium/net/MimeTypeFilter.java",
+ "net/android/java/src/org/chromium/net/NetStringUtil.java",
+ "net/android/java/src/org/chromium/net/NetworkActiveNotifier.java",
+ "net/android/java/src/org/chromium/net/NetworkChangeNotifier.java",
+ "net/android/java/src/org/chromium/net/NetworkChangeNotifierAutoDetect.java",
+ "net/android/java/src/org/chromium/net/NetworkTrafficAnnotationTag.java",
+ "net/android/java/src/org/chromium/net/ProxyBroadcastReceiver.java",
+ "net/android/java/src/org/chromium/net/ProxyChangeListener.java",
+ "net/android/java/src/org/chromium/net/RegistrationPolicyAlwaysRegister.java",
+ "net/android/java/src/org/chromium/net/RegistrationPolicyApplicationStatus.java",
+ "net/android/java/src/org/chromium/net/ThreadStatsUid.java",
+ "net/android/java/src/org/chromium/net/X509Util.java",
+ "url/android/java/src/org/chromium/url/IDNStringUtil.java",
+ ],
+ cmd: "current_dir=`basename \\`pwd\\``; " +
+ "for f in $(in); " +
+ "do " +
+ "echo \"../$$current_dir/$$f\" >> $(genDir)/java.sources; " +
+ "done; " +
+ "python3 $(location base/android/jni_generator/jni_registration_generator.py) --srcjar-path " +
+ "$(genDir)/components/cronet/android/cronet_jni_registration.srcjar " +
+ "--depfile " +
+ "$(genDir)/components/cronet/android/cronet_jni_registration.d " +
+ "--sources-files " +
+ "$(genDir)/java.sources " +
+ "--include_test_only " +
+ "--use_proxy_hash " +
+ "--header-path " +
+ "$(genDir)/components/cronet/android/cronet_jni_registration.h " +
+ "--manual_jni_registration " +
+ ";sed -i -e 's/OUT_SOONG_.TEMP_SBOX_.*_OUT/GEN/g' " +
+ "$(genDir)/components/cronet/android/cronet_jni_registration.h",
+ out: [
+ "components/cronet/android/cronet_jni_registration.h",
+ "components/cronet/android/cronet_jni_registration.srcjar",
+ ],
+ tool_files: [
+ "base/android/jni_generator/jni_generator.py",
+ "base/android/jni_generator/jni_registration_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: //components/cronet/android:cronet_static
-cc_object {
+cc_library_static {
name: "cronet_aml_components_cronet_android_cronet_static",
srcs: [
"components/cronet/android/cronet_bidirectional_stream_adapter.cc",
@@ -3125,15 +7881,76 @@
"cronet_aml_base_allocator_partition_allocator_partition_alloc",
"cronet_aml_base_base",
"cronet_aml_base_base_static",
+ "cronet_aml_base_nodebug_assertion",
"cronet_aml_base_third_party_double_conversion_double_conversion",
"cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations",
+ "cronet_aml_components_cronet_cronet_common",
+ "cronet_aml_components_cronet_cronet_version_header",
+ "cronet_aml_components_cronet_metrics_util",
+ "cronet_aml_components_metrics_library_support",
"cronet_aml_components_prefs_prefs",
"cronet_aml_crypto_crypto",
+ "cronet_aml_net_dns_dns",
+ "cronet_aml_net_dns_public_public",
+ "cronet_aml_net_http_transport_security_state_generated_files",
"cronet_aml_net_net",
+ "cronet_aml_net_net_deps",
+ "cronet_aml_net_net_public_deps",
"cronet_aml_net_preload_decoder",
"cronet_aml_net_third_party_quiche_quiche",
+ "cronet_aml_net_traffic_annotation_traffic_annotation",
"cronet_aml_net_uri_template",
+ "cronet_aml_third_party_abseil_cpp_absl_base_base",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+ "cronet_aml_third_party_abseil_cpp_absl_base_strerror",
+ "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+ "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler",
+ "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_city",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_hash",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+ "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
+ "cronet_aml_third_party_abseil_cpp_absl_random_distributions",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material",
+ "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception",
+ "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences",
+ "cronet_aml_third_party_abseil_cpp_absl_status_status",
+ "cronet_aml_third_party_abseil_cpp_absl_status_statusor",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cord",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+ "cronet_aml_third_party_abseil_cpp_absl_time_time",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access",
+ "cronet_aml_third_party_android_ndk_cpu_features",
+ "cronet_aml_third_party_ashmem_ashmem",
"cronet_aml_third_party_boringssl_boringssl",
+ "cronet_aml_third_party_boringssl_boringssl_asm",
"cronet_aml_third_party_brotli_common",
"cronet_aml_third_party_brotli_dec",
"cronet_aml_third_party_icu_icui18n",
@@ -3150,9 +7967,15 @@
"cronet_aml_components_cronet_android_buildflags",
"cronet_aml_components_cronet_android_cronet_jni_headers",
"cronet_aml_components_cronet_android_cronet_jni_registration",
- "cronet_aml_components_cronet_cronet_buildflags",
- "cronet_aml_components_cronet_cronet_version_header_action",
- "cronet_aml_third_party_metrics_proto_metrics_proto_gen_headers",
+ "cronet_aml_url_buildflags",
+ ],
+ export_generated_headers: [
+ "cronet_aml_base_debugging_buildflags",
+ "cronet_aml_base_logging_buildflags",
+ "cronet_aml_build_chromeos_buildflags",
+ "cronet_aml_components_cronet_android_buildflags",
+ "cronet_aml_components_cronet_android_cronet_jni_headers",
+ "cronet_aml_components_cronet_android_cronet_jni_registration",
"cronet_aml_url_buildflags",
],
defaults: [
@@ -3170,6 +7993,7 @@
"-DHAVE_PTHREAD",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-D_FORTIFY_SOURCE=2",
@@ -3178,6 +8002,14 @@
"-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: [
"./",
@@ -3192,7 +8024,40 @@
"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",
@@ -3200,6 +8065,452 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
+ "-msse3",
+ ],
+ },
+ },
+}
+
+// GN: //components/cronet/android:cronet_static__testing
+cc_library_static {
+ name: "cronet_aml_components_cronet_android_cronet_static__testing",
+ srcs: [
+ "components/cronet/android/cronet_bidirectional_stream_adapter.cc",
+ "components/cronet/android/cronet_context_adapter.cc",
+ "components/cronet/android/cronet_library_loader.cc",
+ "components/cronet/android/cronet_upload_data_stream_adapter.cc",
+ "components/cronet/android/cronet_url_request_adapter.cc",
+ "components/cronet/android/io_buffer_with_byte_buffer.cc",
+ "components/cronet/android/url_request_error.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_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",
+ "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_base_debugging_buildflags__testing",
+ "cronet_aml_base_logging_buildflags__testing",
+ "cronet_aml_build_chromeos_buildflags__testing",
+ "cronet_aml_components_cronet_android_buildflags__testing",
+ "cronet_aml_components_cronet_android_cronet_jni_headers__testing",
+ "cronet_aml_components_cronet_android_cronet_jni_registration__testing",
+ "cronet_aml_url_buildflags__testing",
+ ],
+ export_generated_headers: [
+ "cronet_aml_base_debugging_buildflags__testing",
+ "cronet_aml_base_logging_buildflags__testing",
+ "cronet_aml_build_chromeos_buildflags__testing",
+ "cronet_aml_components_cronet_android_buildflags__testing",
+ "cronet_aml_components_cronet_android_cronet_jni_headers__testing",
+ "cronet_aml_components_cronet_android_cronet_jni_registration__testing",
+ "cronet_aml_url_buildflags__testing",
+ ],
+ defaults: [
+ "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",
+ "-DHAVE_PTHREAD",
+ "-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",
+ "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/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/android:cronet_unittests_android__library__testing
+cc_library_shared {
+ name: "cronet_aml_components_cronet_android_cronet_unittests_android__library__testing",
+ srcs: [
+ "components/cronet/run_all_unittests.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_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",
+ "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",
+ ],
+ 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",
+ ],
+ stem: "libcronet_unittests_android__library",
+ 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",
],
},
@@ -3477,8 +8788,31 @@
],
}
+// GN: //components/cronet:cronet_buildflags__testing
+cc_genrule {
+ name: "cronet_aml_components_cronet_cronet_buildflags__testing",
+ cmd: "echo '--flags DISABLE_HISTOGRAM_SUPPORT=\"false\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//components/cronet:cronet_buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin",
+ out: [
+ "components/cronet/cronet_buildflags.h",
+ ],
+ tool_files: [
+ "build/write_buildflag_header.py",
+ ],
+ apex_available: [
+ "com.android.tethering",
+ ],
+}
+
// GN: //components/cronet:cronet_common
-cc_object {
+cc_library_static {
name: "cronet_aml_components_cronet_cronet_common",
srcs: [
"components/cronet/cronet_context.cc",
@@ -3498,15 +8832,74 @@
"cronet_aml_base_allocator_partition_allocator_partition_alloc",
"cronet_aml_base_base",
"cronet_aml_base_base_static",
+ "cronet_aml_base_nodebug_assertion",
"cronet_aml_base_third_party_double_conversion_double_conversion",
"cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations",
+ "cronet_aml_components_cronet_cronet_version_header",
+ "cronet_aml_components_metrics_library_support",
"cronet_aml_components_prefs_prefs",
"cronet_aml_crypto_crypto",
+ "cronet_aml_net_dns_dns",
+ "cronet_aml_net_dns_public_public",
+ "cronet_aml_net_http_transport_security_state_generated_files",
"cronet_aml_net_net",
+ "cronet_aml_net_net_deps",
+ "cronet_aml_net_net_public_deps",
"cronet_aml_net_preload_decoder",
"cronet_aml_net_third_party_quiche_quiche",
+ "cronet_aml_net_traffic_annotation_traffic_annotation",
"cronet_aml_net_uri_template",
+ "cronet_aml_third_party_abseil_cpp_absl_base_base",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+ "cronet_aml_third_party_abseil_cpp_absl_base_strerror",
+ "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+ "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler",
+ "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_city",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_hash",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+ "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
+ "cronet_aml_third_party_abseil_cpp_absl_random_distributions",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material",
+ "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception",
+ "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences",
+ "cronet_aml_third_party_abseil_cpp_absl_status_status",
+ "cronet_aml_third_party_abseil_cpp_absl_status_statusor",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cord",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+ "cronet_aml_third_party_abseil_cpp_absl_time_time",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access",
+ "cronet_aml_third_party_android_ndk_cpu_features",
+ "cronet_aml_third_party_ashmem_ashmem",
"cronet_aml_third_party_boringssl_boringssl",
+ "cronet_aml_third_party_boringssl_boringssl_asm",
"cronet_aml_third_party_brotli_common",
"cronet_aml_third_party_brotli_dec",
"cronet_aml_third_party_icu_icui18n",
@@ -3518,8 +8911,9 @@
],
generated_headers: [
"cronet_aml_components_cronet_cronet_buildflags",
- "cronet_aml_components_cronet_cronet_version_header_action",
- "cronet_aml_third_party_metrics_proto_metrics_proto_gen_headers",
+ ],
+ export_generated_headers: [
+ "cronet_aml_components_cronet_cronet_buildflags",
],
defaults: [
"cronet_aml_defaults",
@@ -3536,6 +8930,7 @@
"-DHAVE_PTHREAD",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-D_FORTIFY_SOURCE=2",
@@ -3544,6 +8939,14 @@
"-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: [
"./",
@@ -3558,7 +8961,40 @@
"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",
@@ -3566,6 +9002,587 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
+ "-msse3",
+ ],
+ },
+ },
+}
+
+// GN: //components/cronet:cronet_common__testing
+cc_library_static {
+ name: "cronet_aml_components_cronet_cronet_common__testing",
+ srcs: [
+ "components/cronet/cronet_context.cc",
+ "components/cronet/cronet_prefs_manager.cc",
+ "components/cronet/cronet_upload_data_stream.cc",
+ "components/cronet/cronet_url_request.cc",
+ "components/cronet/host_cache_persistence_manager.cc",
+ "components/cronet/stale_host_resolver.cc",
+ "components/cronet/url_request_context_config.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_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",
+ "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_components_cronet_cronet_buildflags__testing",
+ ],
+ export_generated_headers: [
+ "cronet_aml_components_cronet_cronet_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",
+ "-DHAVE_PTHREAD",
+ "-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",
+ "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/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_common_unittests__testing
+cc_library_static {
+ name: "cronet_aml_components_cronet_cronet_common_unittests__testing",
+ srcs: [
+ "components/cronet/host_cache_persistence_manager_unittest.cc",
+ "components/cronet/network_tasks_unittest.cc",
+ "components/cronet/stale_host_resolver_unittest.cc",
+ "components/cronet/url_request_context_config_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_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",
+ "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",
+ ],
+ 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: //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: [
+ "-fstack-protector",
+ ],
+ },
+ android_arm64: {
+ cflags: [
+ "-fstack-protector",
+ "-mno-outline",
+ "-mno-outline-atomics",
+ ],
+ },
+ android_x86: {
+ cflags: [
+ "-msse3",
+ ],
+ },
+ android_x86_64: {
+ cflags: [
+ "-fstack-protector",
"-msse3",
],
},
@@ -3598,8 +9615,34 @@
],
}
+// GN: //components/cronet:cronet_version_header_action__testing
+cc_genrule {
+ name: "cronet_aml_components_cronet_cronet_version_header_action__testing",
+ cmd: "$(location build/util/version.py) --official " +
+ "-f " +
+ "$(location chrome/VERSION) " +
+ "-e " +
+ "'VERSION_FULL=\"%s.%s.%s.%s\" % (MAJOR,MINOR,BUILD,PATCH)' " +
+ "-o " +
+ "$(out) " +
+ "$(location components/cronet/version.h.in)",
+ out: [
+ "components/cronet/version.h",
+ ],
+ tool_files: [
+ "build/util/LASTCHANGE",
+ "build/util/android_chrome_version.py",
+ "build/util/version.py",
+ "chrome/VERSION",
+ "components/cronet/version.h.in",
+ ],
+ apex_available: [
+ "com.android.tethering",
+ ],
+}
+
// GN: //components/cronet:metrics_util
-cc_object {
+cc_library_static {
name: "cronet_aml_components_cronet_metrics_util",
srcs: [
"components/cronet/metrics_util.cc",
@@ -3612,9 +9655,60 @@
"cronet_aml_base_allocator_partition_allocator_partition_alloc",
"cronet_aml_base_base",
"cronet_aml_base_base_static",
+ "cronet_aml_base_nodebug_assertion",
"cronet_aml_base_third_party_double_conversion_double_conversion",
"cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations",
+ "cronet_aml_third_party_abseil_cpp_absl_base_base",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+ "cronet_aml_third_party_abseil_cpp_absl_base_strerror",
+ "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+ "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler",
+ "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_city",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_hash",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+ "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
+ "cronet_aml_third_party_abseil_cpp_absl_random_distributions",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material",
+ "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception",
+ "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences",
+ "cronet_aml_third_party_abseil_cpp_absl_status_status",
+ "cronet_aml_third_party_abseil_cpp_absl_status_statusor",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cord",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+ "cronet_aml_third_party_abseil_cpp_absl_time_time",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access",
+ "cronet_aml_third_party_android_ndk_cpu_features",
+ "cronet_aml_third_party_ashmem_ashmem",
"cronet_aml_third_party_boringssl_boringssl",
+ "cronet_aml_third_party_boringssl_boringssl_asm",
"cronet_aml_third_party_icu_icui18n",
"cronet_aml_third_party_icu_icuuc_private",
"cronet_aml_third_party_libevent_libevent",
@@ -3631,6 +9725,7 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-D_FORTIFY_SOURCE=2",
@@ -3639,6 +9734,14 @@
"-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: [
"./",
@@ -3649,7 +9752,40 @@
"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",
@@ -3657,6 +9793,166 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
+ "-msse3",
+ ],
+ },
+ },
+}
+
+// GN: //components/cronet:metrics_util__testing
+cc_library_static {
+ name: "cronet_aml_components_cronet_metrics_util__testing",
+ srcs: [
+ "components/cronet/metrics_util.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_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",
+ ],
+ 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",
],
},
@@ -3664,7 +9960,7 @@
}
// GN: //components/metrics:library_support
-cc_object {
+cc_library_static {
name: "cronet_aml_components_metrics_library_support",
srcs: [
":cronet_aml_third_party_metrics_proto_metrics_proto_gen",
@@ -3680,9 +9976,60 @@
"cronet_aml_base_allocator_partition_allocator_partition_alloc",
"cronet_aml_base_base",
"cronet_aml_base_base_static",
+ "cronet_aml_base_nodebug_assertion",
"cronet_aml_base_third_party_double_conversion_double_conversion",
"cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations",
+ "cronet_aml_third_party_abseil_cpp_absl_base_base",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+ "cronet_aml_third_party_abseil_cpp_absl_base_strerror",
+ "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+ "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler",
+ "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_city",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_hash",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+ "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
+ "cronet_aml_third_party_abseil_cpp_absl_random_distributions",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material",
+ "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception",
+ "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences",
+ "cronet_aml_third_party_abseil_cpp_absl_status_status",
+ "cronet_aml_third_party_abseil_cpp_absl_status_statusor",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cord",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+ "cronet_aml_third_party_abseil_cpp_absl_time_time",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access",
+ "cronet_aml_third_party_android_ndk_cpu_features",
+ "cronet_aml_third_party_ashmem_ashmem",
"cronet_aml_third_party_boringssl_boringssl",
+ "cronet_aml_third_party_boringssl_boringssl_asm",
"cronet_aml_third_party_icu_icui18n",
"cronet_aml_third_party_icu_icuuc_private",
"cronet_aml_third_party_libevent_libevent",
@@ -3692,6 +10039,9 @@
generated_headers: [
"cronet_aml_third_party_metrics_proto_metrics_proto_gen_headers",
],
+ export_generated_headers: [
+ "cronet_aml_third_party_metrics_proto_metrics_proto_gen_headers",
+ ],
defaults: [
"cronet_aml_defaults",
],
@@ -3707,6 +10057,7 @@
"-DHAVE_PTHREAD",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-D_FORTIFY_SOURCE=2",
@@ -3715,6 +10066,14 @@
"-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: [
"./",
@@ -3726,7 +10085,40 @@
"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",
@@ -3734,6 +10126,181 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
+ "-msse3",
+ ],
+ },
+ },
+}
+
+// GN: //components/metrics:library_support__testing
+cc_library_static {
+ name: "cronet_aml_components_metrics_library_support__testing",
+ srcs: [
+ ":cronet_aml_third_party_metrics_proto_metrics_proto__testing_gen",
+ "components/metrics/histogram_encoder.cc",
+ "components/metrics/library_support/histogram_manager.cc",
+ ],
+ shared_libs: [
+ "libandroid",
+ "liblog",
+ "libprotobuf-cpp-lite",
+ ],
+ 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_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",
+ "cronet_aml_third_party_protobuf_protobuf_lite__testing",
+ ],
+ 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",
+ ],
+ 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",
+ "-DHAVE_PTHREAD",
+ "-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/",
+ "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",
],
},
@@ -3774,6 +10341,38 @@
],
}
+// GN: //components/prefs/android:jni_headers__testing
+cc_genrule {
+ name: "cronet_aml_components_prefs_android_jni_headers__testing",
+ srcs: [
+ "components/prefs/android/java/src/org/chromium/components/prefs/PrefService.java",
+ ],
+ cmd: "$(location base/android/jni_generator/jni_generator.py) --ptr_type " +
+ "long " +
+ "--output_dir " +
+ "$(genDir)/components/prefs/android/jni_headers " +
+ "--includes " +
+ "base/android/jni_generator/jni_generator_helper.h " +
+ "--use_proxy_hash " +
+ "--output_name " +
+ "PrefService_jni.h " +
+ "--input_file " +
+ "$(location components/prefs/android/java/src/org/chromium/components/prefs/PrefService.java)",
+ out: [
+ "components/prefs/android/jni_headers/PrefService_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: //components/prefs:prefs
cc_library_static {
name: "cronet_aml_components_prefs_prefs",
@@ -3808,9 +10407,60 @@
"cronet_aml_base_allocator_partition_allocator_partition_alloc",
"cronet_aml_base_base",
"cronet_aml_base_base_static",
+ "cronet_aml_base_nodebug_assertion",
"cronet_aml_base_third_party_double_conversion_double_conversion",
"cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations",
+ "cronet_aml_third_party_abseil_cpp_absl_base_base",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+ "cronet_aml_third_party_abseil_cpp_absl_base_strerror",
+ "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+ "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler",
+ "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_city",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_hash",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+ "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
+ "cronet_aml_third_party_abseil_cpp_absl_random_distributions",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material",
+ "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception",
+ "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences",
+ "cronet_aml_third_party_abseil_cpp_absl_status_status",
+ "cronet_aml_third_party_abseil_cpp_absl_status_statusor",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cord",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+ "cronet_aml_third_party_abseil_cpp_absl_time_time",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access",
+ "cronet_aml_third_party_android_ndk_cpu_features",
+ "cronet_aml_third_party_ashmem_ashmem",
"cronet_aml_third_party_boringssl_boringssl",
+ "cronet_aml_third_party_boringssl_boringssl_asm",
"cronet_aml_third_party_icu_icui18n",
"cronet_aml_third_party_icu_icuuc_private",
"cronet_aml_third_party_libevent_libevent",
@@ -3840,6 +10490,7 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-D_FORTIFY_SOURCE=2",
@@ -3848,6 +10499,14 @@
"-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: [
"./",
@@ -3858,7 +10517,40 @@
"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",
@@ -3866,6 +10558,393 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
+ "-msse3",
+ ],
+ },
+ },
+}
+
+// GN: //components/prefs:prefs__testing
+cc_library_static {
+ name: "cronet_aml_components_prefs_prefs__testing",
+ srcs: [
+ "components/prefs/android/pref_service_android.cc",
+ "components/prefs/command_line_pref_store.cc",
+ "components/prefs/default_pref_store.cc",
+ "components/prefs/in_memory_pref_store.cc",
+ "components/prefs/json_pref_store.cc",
+ "components/prefs/overlay_user_pref_store.cc",
+ "components/prefs/persistent_pref_store.cc",
+ "components/prefs/pref_change_registrar.cc",
+ "components/prefs/pref_member.cc",
+ "components/prefs/pref_notifier_impl.cc",
+ "components/prefs/pref_registry.cc",
+ "components/prefs/pref_registry_simple.cc",
+ "components/prefs/pref_service.cc",
+ "components/prefs/pref_service_factory.cc",
+ "components/prefs/pref_store.cc",
+ "components/prefs/pref_value_map.cc",
+ "components/prefs/pref_value_store.cc",
+ "components/prefs/scoped_user_pref_update.cc",
+ "components/prefs/segregated_pref_store.cc",
+ "components/prefs/value_map_pref_store.cc",
+ "components/prefs/writeable_pref_store.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_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_base_debugging_buildflags__testing",
+ "cronet_aml_base_logging_buildflags__testing",
+ "cronet_aml_build_chromeos_buildflags__testing",
+ "cronet_aml_components_prefs_android_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_components_prefs_android_jni_headers__testing",
+ ],
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DANDROID",
+ "-DANDROID_NDK_VERSION_ROLL=r23_1",
+ "-DCOMPONENTS_PREFS_IMPLEMENTATION",
+ "-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: //components/prefs:test_support__testing
+cc_library_static {
+ name: "cronet_aml_components_prefs_test_support__testing",
+ srcs: [
+ "components/prefs/mock_pref_change_callback.cc",
+ "components/prefs/pref_store_observer_mock.cc",
+ "components/prefs/pref_test_utils.cc",
+ "components/prefs/testing_pref_service.cc",
+ "components/prefs/testing_pref_store.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_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",
+ "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",
+ ],
+ 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",
+ "-DGTEST_API_=",
+ "-DGTEST_HAS_ABSL=1",
+ "-DGTEST_HAS_POSIX_RE=0",
+ "-DGTEST_HAS_TR1_TUPLE=0",
+ "-DGTEST_LANG_CXX11=1",
+ "-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",
+ "-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",
+ "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/",
+ ],
+ 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",
],
},
@@ -3895,6 +10974,30 @@
],
}
+// GN: //crypto:buildflags__testing
+cc_genrule {
+ name: "cronet_aml_crypto_buildflags__testing",
+ cmd: "echo '--flags USE_NSS_CERTS=\"false\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//crypto:buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin",
+ host_supported: true,
+ out: [
+ "crypto/crypto_buildflags.h",
+ ],
+ tool_files: [
+ "build/write_buildflag_header.py",
+ ],
+ apex_available: [
+ "com.android.tethering",
+ ],
+}
+
// GN: //crypto:crypto
cc_library_static {
name: "cronet_aml_crypto_crypto",
@@ -3927,9 +11030,60 @@
"cronet_aml_base_allocator_partition_allocator_partition_alloc",
"cronet_aml_base_base",
"cronet_aml_base_base_static",
+ "cronet_aml_base_nodebug_assertion",
"cronet_aml_base_third_party_double_conversion_double_conversion",
"cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations",
+ "cronet_aml_third_party_abseil_cpp_absl_base_base",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+ "cronet_aml_third_party_abseil_cpp_absl_base_strerror",
+ "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+ "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler",
+ "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_city",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_hash",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+ "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
+ "cronet_aml_third_party_abseil_cpp_absl_random_distributions",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material",
+ "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception",
+ "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences",
+ "cronet_aml_third_party_abseil_cpp_absl_status_status",
+ "cronet_aml_third_party_abseil_cpp_absl_status_statusor",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cord",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+ "cronet_aml_third_party_abseil_cpp_absl_time_time",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access",
+ "cronet_aml_third_party_android_ndk_cpu_features",
+ "cronet_aml_third_party_ashmem_ashmem",
"cronet_aml_third_party_boringssl_boringssl",
+ "cronet_aml_third_party_boringssl_boringssl_asm",
"cronet_aml_third_party_icu_icui18n",
"cronet_aml_third_party_icu_icuuc_private",
"cronet_aml_third_party_libevent_libevent",
@@ -3953,6 +11107,7 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-D_FORTIFY_SOURCE=2",
@@ -3961,6 +11116,14 @@
"-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: [
"./",
@@ -3971,7 +11134,40 @@
"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",
@@ -3979,19 +11175,300 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //crypto:crypto__testing
+cc_library_static {
+ name: "cronet_aml_crypto_crypto__testing",
+ srcs: [
+ "crypto/aead.cc",
+ "crypto/ec_private_key.cc",
+ "crypto/ec_signature_creator.cc",
+ "crypto/ec_signature_creator_impl.cc",
+ "crypto/encryptor.cc",
+ "crypto/hkdf.cc",
+ "crypto/hmac.cc",
+ "crypto/openssl_util.cc",
+ "crypto/p224_spake.cc",
+ "crypto/random.cc",
+ "crypto/rsa_private_key.cc",
+ "crypto/secure_hash.cc",
+ "crypto/secure_util.cc",
+ "crypto/sha2.cc",
+ "crypto/signature_creator.cc",
+ "crypto/signature_verifier.cc",
+ "crypto/symmetric_key.cc",
+ "crypto/unexportable_key.cc",
+ "crypto/unexportable_key_metrics.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_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,
+ generated_headers: [
+ "cronet_aml_crypto_buildflags__testing",
+ ],
+ export_generated_headers: [
+ "cronet_aml_crypto_buildflags__testing",
+ ],
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DCRYPTO_IMPLEMENTATION",
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-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",
+ "-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/",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ "-Wl,--script,external/cronet/base/android/library_loader/anchor_functions.lds",
+ ],
+ target: {
+ android: {
+ shared_libs: [
+ "libandroid",
+ "liblog",
+ ],
+ },
+ 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",
+ "-DHAVE_SYS_UIO_H",
+ "-Oz",
+ "-fstack-protector",
+ ],
+ ldflags: [
+ "-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",
+ ],
+ },
+ 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",
+ "-DHAVE_SYS_UIO_H",
+ "-Oz",
+ "-fstack-protector",
+ "-mno-outline",
+ "-mno-outline-atomics",
+ ],
+ ldflags: [
+ "-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",
+ ],
+ },
+ 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",
+ "-DHAVE_SYS_UIO_H",
+ "-Oz",
+ "-msse3",
+ ],
+ ldflags: [
+ "-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",
+ ],
+ },
+ 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",
+ "-DHAVE_SYS_UIO_H",
+ "-Oz",
+ "-fstack-protector",
+ "-msse3",
+ ],
+ ldflags: [
+ "-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",
+ ],
+ },
+ 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: //gn:default_deps
cc_defaults {
name: "cronet_aml_defaults",
cflags: [
"-DGOOGLE_PROTOBUF_NO_RTTI",
- "-O2",
"-Wno-ambiguous-reversed-operator",
+ "-Wno-c++11-narrowing",
"-Wno-error=return-type",
"-Wno-macro-redefined",
"-Wno-missing-field-initializers",
@@ -4002,9 +11479,9 @@
"-Wno-unreachable-code-loop-increment",
"-Wno-unused-parameter",
"-fPIC",
- "-fvisibility=hidden",
],
stl: "none",
+ cpp_std: "c++17",
apex_available: [
"com.android.tethering",
],
@@ -4022,6 +11499,7 @@
cflags: [
"-UANDROID",
],
+ compile_multilib: "64",
},
},
}
@@ -4169,6 +11647,8 @@
"base/android/java/src/org/chromium/base/metrics/TimingMetric.java",
"base/android/java/src/org/chromium/base/metrics/UmaRecorder.java",
"base/android/java/src/org/chromium/base/metrics/UmaRecorderHolder.java",
+ "base/android/java/src/org/chromium/base/process_launcher/IChildProcessService.aidl",
+ "base/android/java/src/org/chromium/base/process_launcher/IParentProcess.aidl",
"base/android/java/src/org/chromium/base/supplier/BooleanSupplier.java",
"base/android/java/src/org/chromium/base/supplier/DestroyableObservableSupplier.java",
"base/android/java/src/org/chromium/base/supplier/ObservableSupplier.java",
@@ -4195,6 +11675,8 @@
"base/android/java/src/org/chromium/base/task/TaskRunnerImpl.java",
"base/android/java/src/org/chromium/base/task/TaskTraits.java",
"base/android/java/src/org/chromium/base/task/TaskTraitsExtensionDescriptor.java",
+ "base/test/android/java/src/org/chromium/base/ITestCallback.aidl",
+ "base/test/android/java/src/org/chromium/base/ITestController.aidl",
"build/android/java/src/org/chromium/build/annotations/AlwaysInline.java",
"build/android/java/src/org/chromium/build/annotations/CheckDiscard.java",
"build/android/java/src/org/chromium/build/annotations/DoNotClassMerge.java",
@@ -4285,7 +11767,8 @@
"frameworks/base/core/java/",
],
local_include_dirs: [
- "base/android/java/src/",
+ "base/android/java/src",
+ "base/test/android/java/src",
],
},
plugins: [
@@ -4298,6 +11781,282 @@
],
}
+// GN: //gn:java
+java_library {
+ name: "cronet_aml_java__testing",
+ srcs: [
+ ":cronet_aml_base_base_android_java_enums_srcjar",
+ ":cronet_aml_base_java_features_srcjar",
+ ":cronet_aml_base_java_switches_srcjar",
+ ":cronet_aml_build_android_build_config_gen",
+ ":cronet_aml_build_android_native_libraries_gen",
+ ":cronet_aml_components_cronet_android_cronet_jni_registration__java__testing",
+ ":cronet_aml_components_cronet_android_http_cache_type_java",
+ ":cronet_aml_components_cronet_android_implementation_api_version",
+ ":cronet_aml_components_cronet_android_integrated_mode_state",
+ ":cronet_aml_components_cronet_android_interface_api_version",
+ ":cronet_aml_components_cronet_android_load_states_list",
+ ":cronet_aml_components_cronet_android_net_idempotency_java",
+ ":cronet_aml_components_cronet_android_net_request_priority_java",
+ ":cronet_aml_components_cronet_android_network_quality_observation_source_java",
+ ":cronet_aml_components_cronet_android_rtt_throughput_values_java",
+ ":cronet_aml_components_cronet_android_url_request_error_java",
+ ":cronet_aml_net_android_net_android_java_enums_srcjar",
+ ":cronet_aml_net_android_net_errors_java",
+ ":cronet_aml_net_effective_connection_type_java",
+ "base/android/java/src/org/chromium/base/ActivityState.java",
+ "base/android/java/src/org/chromium/base/ApiCompatibilityUtils.java",
+ "base/android/java/src/org/chromium/base/ApkAssets.java",
+ "base/android/java/src/org/chromium/base/ApplicationStatus.java",
+ "base/android/java/src/org/chromium/base/BaseFeatureList.java",
+ "base/android/java/src/org/chromium/base/BuildInfo.java",
+ "base/android/java/src/org/chromium/base/BundleUtils.java",
+ "base/android/java/src/org/chromium/base/ByteArrayGenerator.java",
+ "base/android/java/src/org/chromium/base/Callback.java",
+ "base/android/java/src/org/chromium/base/CallbackController.java",
+ "base/android/java/src/org/chromium/base/CollectionUtil.java",
+ "base/android/java/src/org/chromium/base/CommandLine.java",
+ "base/android/java/src/org/chromium/base/CommandLineInitUtil.java",
+ "base/android/java/src/org/chromium/base/Consumer.java",
+ "base/android/java/src/org/chromium/base/ContentUriUtils.java",
+ "base/android/java/src/org/chromium/base/ContextUtils.java",
+ "base/android/java/src/org/chromium/base/CpuFeatures.java",
+ "base/android/java/src/org/chromium/base/DiscardableReferencePool.java",
+ "base/android/java/src/org/chromium/base/EarlyTraceEvent.java",
+ "base/android/java/src/org/chromium/base/EventLog.java",
+ "base/android/java/src/org/chromium/base/FeatureList.java",
+ "base/android/java/src/org/chromium/base/Features.java",
+ "base/android/java/src/org/chromium/base/FieldTrialList.java",
+ "base/android/java/src/org/chromium/base/FileUtils.java",
+ "base/android/java/src/org/chromium/base/Function.java",
+ "base/android/java/src/org/chromium/base/ImportantFileWriterAndroid.java",
+ "base/android/java/src/org/chromium/base/IntStringCallback.java",
+ "base/android/java/src/org/chromium/base/JNIUtils.java",
+ "base/android/java/src/org/chromium/base/JavaExceptionReporter.java",
+ "base/android/java/src/org/chromium/base/JavaHandlerThread.java",
+ "base/android/java/src/org/chromium/base/JniException.java",
+ "base/android/java/src/org/chromium/base/JniStaticTestMocker.java",
+ "base/android/java/src/org/chromium/base/LifetimeAssert.java",
+ "base/android/java/src/org/chromium/base/LocaleUtils.java",
+ "base/android/java/src/org/chromium/base/Log.java",
+ "base/android/java/src/org/chromium/base/MathUtils.java",
+ "base/android/java/src/org/chromium/base/MemoryPressureListener.java",
+ "base/android/java/src/org/chromium/base/NativeLibraryLoadedStatus.java",
+ "base/android/java/src/org/chromium/base/ObserverList.java",
+ "base/android/java/src/org/chromium/base/PackageManagerUtils.java",
+ "base/android/java/src/org/chromium/base/PackageUtils.java",
+ "base/android/java/src/org/chromium/base/PathService.java",
+ "base/android/java/src/org/chromium/base/PathUtils.java",
+ "base/android/java/src/org/chromium/base/PiiElider.java",
+ "base/android/java/src/org/chromium/base/PowerMonitor.java",
+ "base/android/java/src/org/chromium/base/PowerMonitorForQ.java",
+ "base/android/java/src/org/chromium/base/Predicate.java",
+ "base/android/java/src/org/chromium/base/Promise.java",
+ "base/android/java/src/org/chromium/base/RadioUtils.java",
+ "base/android/java/src/org/chromium/base/StreamUtil.java",
+ "base/android/java/src/org/chromium/base/StrictModeContext.java",
+ "base/android/java/src/org/chromium/base/SysUtils.java",
+ "base/android/java/src/org/chromium/base/ThreadUtils.java",
+ "base/android/java/src/org/chromium/base/TimeUtils.java",
+ "base/android/java/src/org/chromium/base/TimezoneUtils.java",
+ "base/android/java/src/org/chromium/base/TraceEvent.java",
+ "base/android/java/src/org/chromium/base/UnguessableToken.java",
+ "base/android/java/src/org/chromium/base/UnownedUserData.java",
+ "base/android/java/src/org/chromium/base/UnownedUserDataHost.java",
+ "base/android/java/src/org/chromium/base/UnownedUserDataKey.java",
+ "base/android/java/src/org/chromium/base/UserData.java",
+ "base/android/java/src/org/chromium/base/UserDataHost.java",
+ "base/android/java/src/org/chromium/base/WrappedClassLoader.java",
+ "base/android/java/src/org/chromium/base/annotations/AccessedByNative.java",
+ "base/android/java/src/org/chromium/base/annotations/CalledByNative.java",
+ "base/android/java/src/org/chromium/base/annotations/CalledByNativeForTesting.java",
+ "base/android/java/src/org/chromium/base/annotations/CalledByNativeUnchecked.java",
+ "base/android/java/src/org/chromium/base/annotations/JNIAdditionalImport.java",
+ "base/android/java/src/org/chromium/base/annotations/JNINamespace.java",
+ "base/android/java/src/org/chromium/base/annotations/JniIgnoreNatives.java",
+ "base/android/java/src/org/chromium/base/annotations/NativeClassQualifiedName.java",
+ "base/android/java/src/org/chromium/base/annotations/NativeMethods.java",
+ "base/android/java/src/org/chromium/base/compat/ApiHelperForM.java",
+ "base/android/java/src/org/chromium/base/compat/ApiHelperForN.java",
+ "base/android/java/src/org/chromium/base/compat/ApiHelperForO.java",
+ "base/android/java/src/org/chromium/base/compat/ApiHelperForOMR1.java",
+ "base/android/java/src/org/chromium/base/compat/ApiHelperForP.java",
+ "base/android/java/src/org/chromium/base/compat/ApiHelperForQ.java",
+ "base/android/java/src/org/chromium/base/compat/ApiHelperForR.java",
+ "base/android/java/src/org/chromium/base/compat/ApiHelperForS.java",
+ "base/android/java/src/org/chromium/base/jank_tracker/DummyJankTracker.java",
+ "base/android/java/src/org/chromium/base/jank_tracker/FrameMetrics.java",
+ "base/android/java/src/org/chromium/base/jank_tracker/FrameMetricsListener.java",
+ "base/android/java/src/org/chromium/base/jank_tracker/FrameMetricsStore.java",
+ "base/android/java/src/org/chromium/base/jank_tracker/JankActivityTracker.java",
+ "base/android/java/src/org/chromium/base/jank_tracker/JankMetricCalculator.java",
+ "base/android/java/src/org/chromium/base/jank_tracker/JankMetricUMARecorder.java",
+ "base/android/java/src/org/chromium/base/jank_tracker/JankMetrics.java",
+ "base/android/java/src/org/chromium/base/jank_tracker/JankReportingRunnable.java",
+ "base/android/java/src/org/chromium/base/jank_tracker/JankReportingScheduler.java",
+ "base/android/java/src/org/chromium/base/jank_tracker/JankScenario.java",
+ "base/android/java/src/org/chromium/base/jank_tracker/JankTracker.java",
+ "base/android/java/src/org/chromium/base/jank_tracker/JankTrackerImpl.java",
+ "base/android/java/src/org/chromium/base/library_loader/LegacyLinker.java",
+ "base/android/java/src/org/chromium/base/library_loader/LibraryLoader.java",
+ "base/android/java/src/org/chromium/base/library_loader/LibraryPrefetcher.java",
+ "base/android/java/src/org/chromium/base/library_loader/Linker.java",
+ "base/android/java/src/org/chromium/base/library_loader/LinkerJni.java",
+ "base/android/java/src/org/chromium/base/library_loader/LoaderErrors.java",
+ "base/android/java/src/org/chromium/base/library_loader/ModernLinker.java",
+ "base/android/java/src/org/chromium/base/library_loader/ModernLinkerJni.java",
+ "base/android/java/src/org/chromium/base/library_loader/NativeLibraryPreloader.java",
+ "base/android/java/src/org/chromium/base/library_loader/ProcessInitException.java",
+ "base/android/java/src/org/chromium/base/lifetime/DestroyChecker.java",
+ "base/android/java/src/org/chromium/base/lifetime/Destroyable.java",
+ "base/android/java/src/org/chromium/base/memory/JavaHeapDumpGenerator.java",
+ "base/android/java/src/org/chromium/base/memory/MemoryPressureCallback.java",
+ "base/android/java/src/org/chromium/base/memory/MemoryPressureMonitor.java",
+ "base/android/java/src/org/chromium/base/memory/MemoryPressureUma.java",
+ "base/android/java/src/org/chromium/base/memory/MemoryPurgeManager.java",
+ "base/android/java/src/org/chromium/base/metrics/CachingUmaRecorder.java",
+ "base/android/java/src/org/chromium/base/metrics/NativeUmaRecorder.java",
+ "base/android/java/src/org/chromium/base/metrics/NoopUmaRecorder.java",
+ "base/android/java/src/org/chromium/base/metrics/RecordHistogram.java",
+ "base/android/java/src/org/chromium/base/metrics/RecordUserAction.java",
+ "base/android/java/src/org/chromium/base/metrics/ScopedSysTraceEvent.java",
+ "base/android/java/src/org/chromium/base/metrics/StatisticsRecorderAndroid.java",
+ "base/android/java/src/org/chromium/base/metrics/TimingMetric.java",
+ "base/android/java/src/org/chromium/base/metrics/UmaRecorder.java",
+ "base/android/java/src/org/chromium/base/metrics/UmaRecorderHolder.java",
+ "base/android/java/src/org/chromium/base/process_launcher/IChildProcessService.aidl",
+ "base/android/java/src/org/chromium/base/process_launcher/IParentProcess.aidl",
+ "base/android/java/src/org/chromium/base/supplier/BooleanSupplier.java",
+ "base/android/java/src/org/chromium/base/supplier/DestroyableObservableSupplier.java",
+ "base/android/java/src/org/chromium/base/supplier/ObservableSupplier.java",
+ "base/android/java/src/org/chromium/base/supplier/ObservableSupplierImpl.java",
+ "base/android/java/src/org/chromium/base/supplier/OneShotCallback.java",
+ "base/android/java/src/org/chromium/base/supplier/OneshotSupplier.java",
+ "base/android/java/src/org/chromium/base/supplier/OneshotSupplierImpl.java",
+ "base/android/java/src/org/chromium/base/supplier/Supplier.java",
+ "base/android/java/src/org/chromium/base/supplier/UnownedUserDataSupplier.java",
+ "base/android/java/src/org/chromium/base/task/AsyncTask.java",
+ "base/android/java/src/org/chromium/base/task/BackgroundOnlyAsyncTask.java",
+ "base/android/java/src/org/chromium/base/task/ChainedTasks.java",
+ "base/android/java/src/org/chromium/base/task/ChoreographerTaskRunner.java",
+ "base/android/java/src/org/chromium/base/task/ChromeThreadPoolExecutor.java",
+ "base/android/java/src/org/chromium/base/task/DefaultTaskExecutor.java",
+ "base/android/java/src/org/chromium/base/task/PostTask.java",
+ "base/android/java/src/org/chromium/base/task/SequencedTaskRunner.java",
+ "base/android/java/src/org/chromium/base/task/SequencedTaskRunnerImpl.java",
+ "base/android/java/src/org/chromium/base/task/SerialExecutor.java",
+ "base/android/java/src/org/chromium/base/task/SingleThreadTaskRunner.java",
+ "base/android/java/src/org/chromium/base/task/SingleThreadTaskRunnerImpl.java",
+ "base/android/java/src/org/chromium/base/task/TaskExecutor.java",
+ "base/android/java/src/org/chromium/base/task/TaskRunner.java",
+ "base/android/java/src/org/chromium/base/task/TaskRunnerImpl.java",
+ "base/android/java/src/org/chromium/base/task/TaskTraits.java",
+ "base/android/java/src/org/chromium/base/task/TaskTraitsExtensionDescriptor.java",
+ "base/test/android/java/src/org/chromium/base/ITestCallback.aidl",
+ "base/test/android/java/src/org/chromium/base/ITestController.aidl",
+ "build/android/java/src/org/chromium/build/annotations/AlwaysInline.java",
+ "build/android/java/src/org/chromium/build/annotations/CheckDiscard.java",
+ "build/android/java/src/org/chromium/build/annotations/DoNotClassMerge.java",
+ "build/android/java/src/org/chromium/build/annotations/DoNotInline.java",
+ "build/android/java/src/org/chromium/build/annotations/IdentifierNameString.java",
+ "build/android/java/src/org/chromium/build/annotations/MainDex.java",
+ "build/android/java/src/org/chromium/build/annotations/MockedInTests.java",
+ "build/android/java/src/org/chromium/build/annotations/UsedByReflection.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/BidirectionalStreamBuilderImpl.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/BidirectionalStreamNetworkException.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/CallbackExceptionImpl.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/CronetBidirectionalStream.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/CronetEngineBase.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/CronetEngineBuilderImpl.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/CronetExceptionImpl.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/CronetLibraryLoader.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/CronetLogger.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/CronetLoggerFactory.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/CronetManifest.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/CronetMetrics.java",
+ "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/NativeCronetEngineBuilderImpl.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/NetworkExceptionImpl.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/NoOpLogger.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/Preconditions.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/QuicExceptionImpl.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/RequestFinishedInfoImpl.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/UrlRequestBase.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/UrlRequestBuilderImpl.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/UrlResponseInfoImpl.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/UserAgent.java",
+ "components/cronet/android/java/src/org/chromium/net/impl/VersionSafeCallbacks.java",
+ "components/cronet/android/java/src/org/chromium/net/urlconnection/CronetBufferedOutputStream.java",
+ "components/cronet/android/java/src/org/chromium/net/urlconnection/CronetChunkedOutputStream.java",
+ "components/cronet/android/java/src/org/chromium/net/urlconnection/CronetFixedModeOutputStream.java",
+ "components/cronet/android/java/src/org/chromium/net/urlconnection/CronetHttpURLConnection.java",
+ "components/cronet/android/java/src/org/chromium/net/urlconnection/CronetHttpURLStreamHandler.java",
+ "components/cronet/android/java/src/org/chromium/net/urlconnection/CronetInputStream.java",
+ "components/cronet/android/java/src/org/chromium/net/urlconnection/CronetOutputStream.java",
+ "components/cronet/android/java/src/org/chromium/net/urlconnection/CronetURLStreamHandlerFactory.java",
+ "components/cronet/android/java/src/org/chromium/net/urlconnection/MessageLoop.java",
+ "net/android/java/src/org/chromium/net/AndroidCertVerifyResult.java",
+ "net/android/java/src/org/chromium/net/AndroidKeyStore.java",
+ "net/android/java/src/org/chromium/net/AndroidNetworkLibrary.java",
+ "net/android/java/src/org/chromium/net/AndroidTrafficStats.java",
+ "net/android/java/src/org/chromium/net/ChromiumNetworkAdapter.java",
+ "net/android/java/src/org/chromium/net/DnsStatus.java",
+ "net/android/java/src/org/chromium/net/GURLUtils.java",
+ "net/android/java/src/org/chromium/net/HttpNegotiateAuthenticator.java",
+ "net/android/java/src/org/chromium/net/HttpNegotiateConstants.java",
+ "net/android/java/src/org/chromium/net/HttpUtil.java",
+ "net/android/java/src/org/chromium/net/MimeTypeFilter.java",
+ "net/android/java/src/org/chromium/net/NetStringUtil.java",
+ "net/android/java/src/org/chromium/net/NetworkActiveNotifier.java",
+ "net/android/java/src/org/chromium/net/NetworkChangeNotifier.java",
+ "net/android/java/src/org/chromium/net/NetworkChangeNotifierAutoDetect.java",
+ "net/android/java/src/org/chromium/net/NetworkTrafficAnnotationTag.java",
+ "net/android/java/src/org/chromium/net/ProxyBroadcastReceiver.java",
+ "net/android/java/src/org/chromium/net/ProxyChangeListener.java",
+ "net/android/java/src/org/chromium/net/RegistrationPolicyAlwaysRegister.java",
+ "net/android/java/src/org/chromium/net/RegistrationPolicyApplicationStatus.java",
+ "net/android/java/src/org/chromium/net/ThreadStatsUid.java",
+ "net/android/java/src/org/chromium/net/X509Util.java",
+ "url/android/java/src/org/chromium/url/IDNStringUtil.java",
+ ],
+ static_libs: [
+ "modules-utils-build_system",
+ ],
+ apex_available: [
+ "com.android.tethering",
+ ],
+ min_sdk_version: "30",
+ libs: [
+ "androidx.annotation_annotation",
+ "androidx.annotation_annotation-experimental-nodeps",
+ "cronet_aml_api_java",
+ "framework-connectivity-t.stubs.module_lib",
+ "framework-connectivity.stubs.module_lib",
+ "framework-mediaprovider.stubs.module_lib",
+ "framework-tethering.stubs.module_lib",
+ "framework-wifi.stubs.module_lib",
+ "jsr305",
+ ],
+ aidl: {
+ include_dirs: [
+ "frameworks/base/core/java/",
+ ],
+ local_include_dirs: [
+ "base/android/java/src",
+ "base/test/android/java/src",
+ ],
+ },
+ plugins: [
+ "cronet_aml_java_jni_annotation_preprocessor",
+ ],
+ sdk_version: "module_current",
+ javacflags: [
+ "-Aorg.chromium.chrome.skipGenJni",
+ ],
+}
+
// GN: //base/android/jni_generator:jni_processor
java_plugin {
name: "cronet_aml_java_jni_annotation_preprocessor",
@@ -4446,6 +12205,60 @@
],
}
+// GN: //net/base/registry_controlled_domains:registry_controlled_domains__testing
+cc_genrule {
+ name: "cronet_aml_net_base_registry_controlled_domains_registry_controlled_domains__testing",
+ 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) " +
+ "--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) " +
+ "--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) " +
+ "--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) " +
+ "--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) " +
+ "--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) " +
+ "--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)",
+ out: [
+ "net/base/registry_controlled_domains/effective_tld_names-reversed-inc.cc",
+ "net/base/registry_controlled_domains/effective_tld_names_unittest1-reversed-inc.cc",
+ "net/base/registry_controlled_domains/effective_tld_names_unittest2-reversed-inc.cc",
+ "net/base/registry_controlled_domains/effective_tld_names_unittest3-reversed-inc.cc",
+ "net/base/registry_controlled_domains/effective_tld_names_unittest4-reversed-inc.cc",
+ "net/base/registry_controlled_domains/effective_tld_names_unittest5-reversed-inc.cc",
+ "net/base/registry_controlled_domains/effective_tld_names_unittest6-reversed-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:buildflags
cc_genrule {
name: "cronet_aml_net_buildflags",
@@ -4508,8 +12321,70 @@
],
}
+// GN: //net:buildflags__testing
+cc_genrule {
+ name: "cronet_aml_net_buildflags__testing",
+ cmd: "if [[ ( $$CC_ARCH == 'x86_64' && $$CC_OS == 'android' ) ]]; " +
+ "then " +
+ "echo '--flags POSIX_BYPASS_MMAP=\"true\" DISABLE_FILE_SUPPORT=\"true\" ENABLE_MDNS=\"false\" ENABLE_REPORTING=\"true\" ENABLE_WEBSOCKETS=\"false\" INCLUDE_TRANSPORT_SECURITY_STATE_PRELOAD_LIST=\"false\" USE_KERBEROS=\"true\" USE_EXTERNAL_GSSAPI=\"false\" TRIAL_COMPARISON_CERT_VERIFIER_SUPPORTED=\"false\" CHROME_ROOT_STORE_SUPPORTED=\"false\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//net:buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin; " +
+ "fi; " +
+ "if [[ ( $$CC_ARCH == 'x86' && $$CC_OS == 'android' ) ]]; " +
+ "then " +
+ "echo '--flags POSIX_BYPASS_MMAP=\"false\" DISABLE_FILE_SUPPORT=\"true\" ENABLE_MDNS=\"false\" ENABLE_REPORTING=\"true\" ENABLE_WEBSOCKETS=\"false\" INCLUDE_TRANSPORT_SECURITY_STATE_PRELOAD_LIST=\"false\" USE_KERBEROS=\"true\" USE_EXTERNAL_GSSAPI=\"false\" TRIAL_COMPARISON_CERT_VERIFIER_SUPPORTED=\"false\" CHROME_ROOT_STORE_SUPPORTED=\"false\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//net:buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin; " +
+ "fi; " +
+ "if [[ ( $$CC_ARCH == 'arm' && $$CC_OS == 'android' ) ]]; " +
+ "then " +
+ "echo '--flags POSIX_BYPASS_MMAP=\"true\" DISABLE_FILE_SUPPORT=\"true\" ENABLE_MDNS=\"false\" ENABLE_REPORTING=\"true\" ENABLE_WEBSOCKETS=\"false\" INCLUDE_TRANSPORT_SECURITY_STATE_PRELOAD_LIST=\"false\" USE_KERBEROS=\"true\" USE_EXTERNAL_GSSAPI=\"false\" TRIAL_COMPARISON_CERT_VERIFIER_SUPPORTED=\"false\" CHROME_ROOT_STORE_SUPPORTED=\"false\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//net:buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin; " +
+ "fi; " +
+ "if [[ ( $$CC_ARCH == 'arm64' && $$CC_OS == 'android' ) ]]; " +
+ "then " +
+ "echo '--flags POSIX_BYPASS_MMAP=\"true\" DISABLE_FILE_SUPPORT=\"true\" ENABLE_MDNS=\"false\" ENABLE_REPORTING=\"true\" ENABLE_WEBSOCKETS=\"false\" INCLUDE_TRANSPORT_SECURITY_STATE_PRELOAD_LIST=\"false\" USE_KERBEROS=\"true\" USE_EXTERNAL_GSSAPI=\"false\" TRIAL_COMPARISON_CERT_VERIFIER_SUPPORTED=\"false\" CHROME_ROOT_STORE_SUPPORTED=\"false\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//net:buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin; " +
+ "fi;",
+ out: [
+ "net/net_buildflags.h",
+ ],
+ tool_files: [
+ "build/write_buildflag_header.py",
+ ],
+ apex_available: [
+ "com.android.tethering",
+ ],
+}
+
// GN: //net/dns:dns
-cc_object {
+cc_library_static {
name: "cronet_aml_net_dns_dns",
srcs: [
"net/dns/address_info.cc",
@@ -4559,13 +12434,68 @@
"cronet_aml_base_allocator_partition_allocator_partition_alloc",
"cronet_aml_base_base",
"cronet_aml_base_base_static",
+ "cronet_aml_base_nodebug_assertion",
"cronet_aml_base_third_party_double_conversion_double_conversion",
"cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations",
"cronet_aml_crypto_crypto",
+ "cronet_aml_net_dns_public_public",
+ "cronet_aml_net_net_deps",
+ "cronet_aml_net_net_public_deps",
"cronet_aml_net_preload_decoder",
"cronet_aml_net_third_party_quiche_quiche",
+ "cronet_aml_net_traffic_annotation_traffic_annotation",
"cronet_aml_net_uri_template",
+ "cronet_aml_third_party_abseil_cpp_absl_base_base",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+ "cronet_aml_third_party_abseil_cpp_absl_base_strerror",
+ "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+ "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler",
+ "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_city",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_hash",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+ "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
+ "cronet_aml_third_party_abseil_cpp_absl_random_distributions",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material",
+ "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception",
+ "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences",
+ "cronet_aml_third_party_abseil_cpp_absl_status_status",
+ "cronet_aml_third_party_abseil_cpp_absl_status_statusor",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cord",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+ "cronet_aml_third_party_abseil_cpp_absl_time_time",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access",
+ "cronet_aml_third_party_android_ndk_cpu_features",
+ "cronet_aml_third_party_ashmem_ashmem",
"cronet_aml_third_party_boringssl_boringssl",
+ "cronet_aml_third_party_boringssl_boringssl_asm",
"cronet_aml_third_party_brotli_common",
"cronet_aml_third_party_brotli_dec",
"cronet_aml_third_party_icu_icui18n",
@@ -4575,18 +12505,6 @@
"cronet_aml_third_party_protobuf_protobuf_lite",
"cronet_aml_url_url",
],
- generated_headers: [
- "cronet_aml_base_debugging_buildflags",
- "cronet_aml_base_logging_buildflags",
- "cronet_aml_build_chromeos_buildflags",
- "cronet_aml_net_base_registry_controlled_domains_registry_controlled_domains",
- "cronet_aml_net_buildflags",
- "cronet_aml_net_isolation_info_proto_gen_headers",
- "cronet_aml_net_net_jni_headers",
- "cronet_aml_net_net_nqe_proto_gen_headers",
- "cronet_aml_net_third_party_quiche_net_quic_test_tools_proto_gen_headers",
- "cronet_aml_url_buildflags",
- ],
defaults: [
"cronet_aml_defaults",
],
@@ -4604,6 +12522,7 @@
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
"-DNET_IMPLEMENTATION",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-D_FORTIFY_SOURCE=2",
@@ -4612,6 +12531,14 @@
"-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: [
"./",
@@ -4627,7 +12554,40 @@
"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",
@@ -4635,6 +12595,226 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
+ "-msse3",
+ ],
+ },
+ },
+}
+
+// GN: //net/dns:dns__testing
+cc_library_static {
+ name: "cronet_aml_net_dns_dns__testing",
+ srcs: [
+ "net/dns/address_info.cc",
+ "net/dns/address_sorter_posix.cc",
+ "net/dns/context_host_resolver.cc",
+ "net/dns/dns_alias_utility.cc",
+ "net/dns/dns_client.cc",
+ "net/dns/dns_config.cc",
+ "net/dns/dns_config_service.cc",
+ "net/dns/dns_config_service_android.cc",
+ "net/dns/dns_hosts.cc",
+ "net/dns/dns_query.cc",
+ "net/dns/dns_reloader.cc",
+ "net/dns/dns_response.cc",
+ "net/dns/dns_response_result_extractor.cc",
+ "net/dns/dns_server_iterator.cc",
+ "net/dns/dns_session.cc",
+ "net/dns/dns_transaction.cc",
+ "net/dns/dns_udp_tracker.cc",
+ "net/dns/dns_util.cc",
+ "net/dns/host_cache.cc",
+ "net/dns/host_resolver.cc",
+ "net/dns/host_resolver_manager.cc",
+ "net/dns/host_resolver_mdns_listener_impl.cc",
+ "net/dns/host_resolver_mdns_task.cc",
+ "net/dns/host_resolver_nat64_task.cc",
+ "net/dns/host_resolver_proc.cc",
+ "net/dns/host_resolver_system_task.cc",
+ "net/dns/https_record_rdata.cc",
+ "net/dns/httpssvc_metrics.cc",
+ "net/dns/mapped_host_resolver.cc",
+ "net/dns/nsswitch_reader.cc",
+ "net/dns/opt_record_rdata.cc",
+ "net/dns/record_parsed.cc",
+ "net/dns/record_rdata.cc",
+ "net/dns/resolve_context.cc",
+ "net/dns/serial_worker.cc",
+ "net/dns/system_dns_config_change_notifier.cc",
+ "net/dns/test_dns_config_service.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_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",
+ "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",
+ ],
+ 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",
+ "-DENABLE_BUILT_IN_DNS",
+ "-DGOOGLE_PROTOBUF_INTERNAL_DONATE_STEAL_INLINE=0",
+ "-DGOOGLE_PROTOBUF_NO_RTTI",
+ "-DGOOGLE_PROTOBUF_NO_STATIC_INITIALIZER",
+ "-DHAVE_PTHREAD",
+ "-DHAVE_SYS_UIO_H",
+ "-DNDEBUG",
+ "-DNET_IMPLEMENTATION",
+ "-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",
+ "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/brotli/include/",
+ "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",
],
},
@@ -4642,7 +12822,7 @@
}
// GN: //net/dns/public:public
-cc_object {
+cc_library_static {
name: "cronet_aml_net_dns_public_public",
srcs: [
"net/dns/public/dns_config_overrides.cc",
@@ -4663,13 +12843,67 @@
"cronet_aml_base_allocator_partition_allocator_partition_alloc",
"cronet_aml_base_base",
"cronet_aml_base_base_static",
+ "cronet_aml_base_nodebug_assertion",
"cronet_aml_base_third_party_double_conversion_double_conversion",
"cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations",
"cronet_aml_crypto_crypto",
+ "cronet_aml_net_net_deps",
+ "cronet_aml_net_net_public_deps",
"cronet_aml_net_preload_decoder",
"cronet_aml_net_third_party_quiche_quiche",
+ "cronet_aml_net_traffic_annotation_traffic_annotation",
"cronet_aml_net_uri_template",
+ "cronet_aml_third_party_abseil_cpp_absl_base_base",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+ "cronet_aml_third_party_abseil_cpp_absl_base_strerror",
+ "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+ "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler",
+ "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_city",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_hash",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+ "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
+ "cronet_aml_third_party_abseil_cpp_absl_random_distributions",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material",
+ "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception",
+ "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences",
+ "cronet_aml_third_party_abseil_cpp_absl_status_status",
+ "cronet_aml_third_party_abseil_cpp_absl_status_statusor",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cord",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+ "cronet_aml_third_party_abseil_cpp_absl_time_time",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access",
+ "cronet_aml_third_party_android_ndk_cpu_features",
+ "cronet_aml_third_party_ashmem_ashmem",
"cronet_aml_third_party_boringssl_boringssl",
+ "cronet_aml_third_party_boringssl_boringssl_asm",
"cronet_aml_third_party_brotli_common",
"cronet_aml_third_party_brotli_dec",
"cronet_aml_third_party_icu_icui18n",
@@ -4679,18 +12913,6 @@
"cronet_aml_third_party_protobuf_protobuf_lite",
"cronet_aml_url_url",
],
- generated_headers: [
- "cronet_aml_base_debugging_buildflags",
- "cronet_aml_base_logging_buildflags",
- "cronet_aml_build_chromeos_buildflags",
- "cronet_aml_net_base_registry_controlled_domains_registry_controlled_domains",
- "cronet_aml_net_buildflags",
- "cronet_aml_net_isolation_info_proto_gen_headers",
- "cronet_aml_net_net_jni_headers",
- "cronet_aml_net_net_nqe_proto_gen_headers",
- "cronet_aml_net_third_party_quiche_net_quic_test_tools_proto_gen_headers",
- "cronet_aml_url_buildflags",
- ],
defaults: [
"cronet_aml_defaults",
],
@@ -4708,6 +12930,7 @@
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
"-DNET_IMPLEMENTATION",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-D_FORTIFY_SOURCE=2",
@@ -4716,6 +12939,14 @@
"-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: [
"./",
@@ -4731,7 +12962,40 @@
"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",
@@ -4739,6 +13003,393 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
+ "-msse3",
+ ],
+ },
+ },
+}
+
+// GN: //net/dns/public:public__testing
+cc_library_static {
+ name: "cronet_aml_net_dns_public_public__testing",
+ srcs: [
+ "net/dns/public/dns_config_overrides.cc",
+ "net/dns/public/dns_over_https_config.cc",
+ "net/dns/public/dns_over_https_server_config.cc",
+ "net/dns/public/dns_query_type.cc",
+ "net/dns/public/doh_provider_entry.cc",
+ "net/dns/public/host_resolver_results.cc",
+ "net/dns/public/resolve_error_info.cc",
+ "net/dns/public/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_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",
+ "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",
+ ],
+ 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",
+ "-DENABLE_BUILT_IN_DNS",
+ "-DGOOGLE_PROTOBUF_INTERNAL_DONATE_STEAL_INLINE=0",
+ "-DGOOGLE_PROTOBUF_NO_RTTI",
+ "-DGOOGLE_PROTOBUF_NO_STATIC_INITIALIZER",
+ "-DHAVE_PTHREAD",
+ "-DHAVE_SYS_UIO_H",
+ "-DNDEBUG",
+ "-DNET_IMPLEMENTATION",
+ "-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",
+ "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/brotli/include/",
+ "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_library_static {
+ 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_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",
+ "cronet_aml_third_party_modp_b64_modp_b64__testing",
+ "cronet_aml_third_party_protobuf_protobuf_lite__testing",
+ "cronet_aml_url_url__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",
+ 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",
],
},
@@ -4764,8 +13415,220 @@
],
}
+// GN: //net:gtest_util__testing
+cc_library_static {
+ name: "cronet_aml_net_gtest_util__testing",
+ srcs: [
+ "net/test/scoped_disable_exit_on_dfatal.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_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",
+ "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",
+ ],
+ 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",
+ "-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/http:transport_security_state_generated_files
-cc_object {
+cc_library_static {
name: "cronet_aml_net_http_transport_security_state_generated_files",
srcs: [
"net/http/transport_security_state.cc",
@@ -4779,13 +13642,69 @@
"cronet_aml_base_allocator_partition_allocator_partition_alloc",
"cronet_aml_base_base",
"cronet_aml_base_base_static",
+ "cronet_aml_base_nodebug_assertion",
"cronet_aml_base_third_party_double_conversion_double_conversion",
"cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations",
"cronet_aml_crypto_crypto",
+ "cronet_aml_net_dns_dns",
+ "cronet_aml_net_dns_public_public",
+ "cronet_aml_net_net_deps",
+ "cronet_aml_net_net_public_deps",
"cronet_aml_net_preload_decoder",
"cronet_aml_net_third_party_quiche_quiche",
+ "cronet_aml_net_traffic_annotation_traffic_annotation",
"cronet_aml_net_uri_template",
+ "cronet_aml_third_party_abseil_cpp_absl_base_base",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+ "cronet_aml_third_party_abseil_cpp_absl_base_strerror",
+ "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+ "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler",
+ "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_city",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_hash",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+ "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
+ "cronet_aml_third_party_abseil_cpp_absl_random_distributions",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material",
+ "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception",
+ "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences",
+ "cronet_aml_third_party_abseil_cpp_absl_status_status",
+ "cronet_aml_third_party_abseil_cpp_absl_status_statusor",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cord",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+ "cronet_aml_third_party_abseil_cpp_absl_time_time",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access",
+ "cronet_aml_third_party_android_ndk_cpu_features",
+ "cronet_aml_third_party_ashmem_ashmem",
"cronet_aml_third_party_boringssl_boringssl",
+ "cronet_aml_third_party_boringssl_boringssl_asm",
"cronet_aml_third_party_brotli_common",
"cronet_aml_third_party_brotli_dec",
"cronet_aml_third_party_icu_icui18n",
@@ -4796,17 +13715,10 @@
"cronet_aml_url_url",
],
generated_headers: [
- "cronet_aml_base_debugging_buildflags",
- "cronet_aml_base_logging_buildflags",
"cronet_aml_build_branding_buildflags",
- "cronet_aml_build_chromeos_buildflags",
- "cronet_aml_net_base_registry_controlled_domains_registry_controlled_domains",
- "cronet_aml_net_buildflags",
- "cronet_aml_net_isolation_info_proto_gen_headers",
- "cronet_aml_net_net_jni_headers",
- "cronet_aml_net_net_nqe_proto_gen_headers",
- "cronet_aml_net_third_party_quiche_net_quic_test_tools_proto_gen_headers",
- "cronet_aml_url_buildflags",
+ ],
+ export_generated_headers: [
+ "cronet_aml_build_branding_buildflags",
],
defaults: [
"cronet_aml_defaults",
@@ -4825,6 +13737,7 @@
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
"-DNET_IMPLEMENTATION",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-D_FORTIFY_SOURCE=2",
@@ -4833,6 +13746,14 @@
"-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: [
"./",
@@ -4848,7 +13769,40 @@
"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",
@@ -4856,12 +13810,228 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //net/http:transport_security_state_generated_files__testing
+cc_library_static {
+ name: "cronet_aml_net_http_transport_security_state_generated_files__testing",
+ srcs: [
+ "net/http/transport_security_state.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_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",
+ "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_branding_buildflags__testing",
+ ],
+ export_generated_headers: [
+ "cronet_aml_build_branding_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",
+ "-DENABLE_BUILT_IN_DNS",
+ "-DGOOGLE_PROTOBUF_INTERNAL_DONATE_STEAL_INLINE=0",
+ "-DGOOGLE_PROTOBUF_NO_RTTI",
+ "-DGOOGLE_PROTOBUF_NO_STATIC_INITIALIZER",
+ "-DHAVE_PTHREAD",
+ "-DHAVE_SYS_UIO_H",
+ "-DNDEBUG",
+ "-DNET_IMPLEMENTATION",
+ "-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",
+ "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/brotli/include/",
+ "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/http:transport_security_state_unittest_data_default__testing
+cc_genrule {
+ name: "cronet_aml_net_http_transport_security_state_unittest_data_default__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_unittest_default.json) " +
+ "$(location net/http/transport_security_state_static_unittest_default.pins) " +
+ "$(location net/http/transport_security_state_static_unittest.template) " +
+ "$(location net/http/transport_security_state_static_unittest_default.h)",
+ out: [
+ "net/http/transport_security_state_static_unittest_default.h",
+ ],
+ tool_files: [
+ "build/gn_run_binary.py",
+ "net/http/transport_security_state_static_unittest.template",
+ "net/http/transport_security_state_static_unittest_default.json",
+ "net/http/transport_security_state_static_unittest_default.pins",
+ ],
+ apex_available: [
+ "com.android.tethering",
+ ],
+}
+
// GN: //net:ios_cronet_buildflags
cc_genrule {
name: "cronet_aml_net_ios_cronet_buildflags",
@@ -4885,6 +14055,70 @@
],
}
+// 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",
+ srcs: [
+ "net/base/isolation_info.proto",
+ ],
+ tools: [
+ "cronet_aml_third_party_protobuf_protoc",
+ ],
+ cmd: "$(location cronet_aml_third_party_protobuf_protoc) --proto_path=external/cronet/net/base --cpp_out=lite=true:$(genDir)/external/cronet/net/base/ $(in)",
+ out: [
+ "external/cronet/net/base/isolation_info.pb.cc",
+ ],
+ apex_available: [
+ "com.android.tethering",
+ ],
+}
+
+// GN: //net:isolation_info_proto__testing
+cc_genrule {
+ name: "cronet_aml_net_isolation_info_proto__testing_gen_headers",
+ srcs: [
+ "net/base/isolation_info.proto",
+ ],
+ tools: [
+ "cronet_aml_third_party_protobuf_protoc",
+ ],
+ cmd: "$(location cronet_aml_third_party_protobuf_protoc) --proto_path=external/cronet/net/base --cpp_out=lite=true:$(genDir)/external/cronet/net/base/ $(in)",
+ out: [
+ "external/cronet/net/base/isolation_info.pb.h",
+ ],
+ export_include_dirs: [
+ ".",
+ "net/base",
+ "protos",
+ ],
+ apex_available: [
+ "com.android.tethering",
+ ],
+}
+
// GN: //net:isolation_info_proto
cc_genrule {
name: "cronet_aml_net_isolation_info_proto_gen",
@@ -4930,12 +14164,6 @@
cc_library_static {
name: "cronet_aml_net_net",
srcs: [
- ":cronet_aml_net_dns_dns",
- ":cronet_aml_net_dns_public_public",
- ":cronet_aml_net_http_transport_security_state_generated_files",
- ":cronet_aml_net_net_deps",
- ":cronet_aml_net_net_public_deps",
- ":cronet_aml_net_traffic_annotation_traffic_annotation",
"net/android/android_http_util.cc",
"net/android/cert_verify_result_android.cc",
"net/android/gurl_utils.cc",
@@ -5428,13 +14656,70 @@
"cronet_aml_base_allocator_partition_allocator_partition_alloc",
"cronet_aml_base_base",
"cronet_aml_base_base_static",
+ "cronet_aml_base_nodebug_assertion",
"cronet_aml_base_third_party_double_conversion_double_conversion",
"cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations",
"cronet_aml_crypto_crypto",
+ "cronet_aml_net_dns_dns",
+ "cronet_aml_net_dns_public_public",
+ "cronet_aml_net_http_transport_security_state_generated_files",
+ "cronet_aml_net_net_deps",
+ "cronet_aml_net_net_public_deps",
"cronet_aml_net_preload_decoder",
"cronet_aml_net_third_party_quiche_quiche",
+ "cronet_aml_net_traffic_annotation_traffic_annotation",
"cronet_aml_net_uri_template",
+ "cronet_aml_third_party_abseil_cpp_absl_base_base",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+ "cronet_aml_third_party_abseil_cpp_absl_base_strerror",
+ "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+ "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler",
+ "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_city",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_hash",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+ "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
+ "cronet_aml_third_party_abseil_cpp_absl_random_distributions",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material",
+ "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception",
+ "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences",
+ "cronet_aml_third_party_abseil_cpp_absl_status_status",
+ "cronet_aml_third_party_abseil_cpp_absl_status_statusor",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cord",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+ "cronet_aml_third_party_abseil_cpp_absl_time_time",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access",
+ "cronet_aml_third_party_android_ndk_cpu_features",
+ "cronet_aml_third_party_ashmem_ashmem",
"cronet_aml_third_party_boringssl_boringssl",
+ "cronet_aml_third_party_boringssl_boringssl_asm",
"cronet_aml_third_party_brotli_common",
"cronet_aml_third_party_brotli_dec",
"cronet_aml_third_party_icu_icui18n",
@@ -5445,32 +14730,12 @@
"cronet_aml_url_url",
],
generated_headers: [
- "cronet_aml_base_debugging_buildflags",
- "cronet_aml_base_logging_buildflags",
- "cronet_aml_build_branding_buildflags",
"cronet_aml_build_chromeos_buildflags",
- "cronet_aml_net_base_registry_controlled_domains_registry_controlled_domains",
- "cronet_aml_net_buildflags",
"cronet_aml_net_ios_cronet_buildflags",
- "cronet_aml_net_isolation_info_proto_gen_headers",
- "cronet_aml_net_net_jni_headers",
- "cronet_aml_net_net_nqe_proto_gen_headers",
- "cronet_aml_net_third_party_quiche_net_quic_test_tools_proto_gen_headers",
- "cronet_aml_url_buildflags",
],
export_generated_headers: [
- "cronet_aml_base_debugging_buildflags",
- "cronet_aml_base_logging_buildflags",
- "cronet_aml_build_branding_buildflags",
"cronet_aml_build_chromeos_buildflags",
- "cronet_aml_net_base_registry_controlled_domains_registry_controlled_domains",
- "cronet_aml_net_buildflags",
"cronet_aml_net_ios_cronet_buildflags",
- "cronet_aml_net_isolation_info_proto_gen_headers",
- "cronet_aml_net_net_jni_headers",
- "cronet_aml_net_net_nqe_proto_gen_headers",
- "cronet_aml_net_third_party_quiche_net_quic_test_tools_proto_gen_headers",
- "cronet_aml_url_buildflags",
],
export_static_lib_headers: [
"cronet_aml_crypto_crypto",
@@ -5493,6 +14758,7 @@
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
"-DNET_IMPLEMENTATION",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-D_FORTIFY_SOURCE=2",
@@ -5501,6 +14767,14 @@
"-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: [
"./",
@@ -5516,16 +14790,45 @@
"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: {
srcs: [
"net/disk_cache/blockfile/mapped_file_bypass_mmap_posix.cc",
],
+ cflags: [
+ "-fstack-protector",
+ ],
},
android_arm64: {
srcs: [
"net/disk_cache/blockfile/mapped_file_bypass_mmap_posix.cc",
],
+ cflags: [
+ "-fstack-protector",
+ "-mno-outline",
+ "-mno-outline-atomics",
+ ],
},
android_x86: {
srcs: [
@@ -5540,6 +14843,693 @@
"net/disk_cache/blockfile/mapped_file_bypass_mmap_posix.cc",
],
cflags: [
+ "-fstack-protector",
+ "-msse3",
+ ],
+ },
+ },
+}
+
+// GN: //net:net__testing
+cc_library_static {
+ name: "cronet_aml_net_net__testing",
+ srcs: [
+ "net/android/android_http_util.cc",
+ "net/android/cert_verify_result_android.cc",
+ "net/android/gurl_utils.cc",
+ "net/android/http_auth_negotiate_android.cc",
+ "net/android/keystore.cc",
+ "net/android/network_change_notifier_android.cc",
+ "net/android/network_change_notifier_delegate_android.cc",
+ "net/android/network_change_notifier_factory_android.cc",
+ "net/android/network_library.cc",
+ "net/android/radio_activity_tracker.cc",
+ "net/android/traffic_stats.cc",
+ "net/base/address_family.cc",
+ "net/base/address_list.cc",
+ "net/base/address_tracker_linux.cc",
+ "net/base/auth.cc",
+ "net/base/backoff_entry.cc",
+ "net/base/backoff_entry_serializer.cc",
+ "net/base/cache_metrics.cc",
+ "net/base/chunked_upload_data_stream.cc",
+ "net/base/connection_endpoint_metadata.cc",
+ "net/base/data_url.cc",
+ "net/base/datagram_buffer.cc",
+ "net/base/elements_upload_data_stream.cc",
+ "net/base/features.cc",
+ "net/base/file_stream.cc",
+ "net/base/file_stream_context.cc",
+ "net/base/file_stream_context_posix.cc",
+ "net/base/filename_util.cc",
+ "net/base/filename_util_internal.cc",
+ "net/base/hash_value.cc",
+ "net/base/hex_utils.cc",
+ "net/base/host_mapping_rules.cc",
+ "net/base/host_port_pair.cc",
+ "net/base/io_buffer.cc",
+ "net/base/ip_address.cc",
+ "net/base/ip_endpoint.cc",
+ "net/base/isolation_info.cc",
+ "net/base/load_timing_info.cc",
+ "net/base/logging_network_change_observer.cc",
+ "net/base/lookup_string_in_fixed_set.cc",
+ "net/base/mime_sniffer.cc",
+ "net/base/mime_util.cc",
+ "net/base/net_errors.cc",
+ "net/base/net_errors_posix.cc",
+ "net/base/net_module.cc",
+ "net/base/net_string_util_icu_alternatives_android.cc",
+ "net/base/network_activity_monitor.cc",
+ "net/base/network_anonymization_key.cc",
+ "net/base/network_change_notifier.cc",
+ "net/base/network_change_notifier_posix.cc",
+ "net/base/network_delegate.cc",
+ "net/base/network_delegate_impl.cc",
+ "net/base/network_interfaces.cc",
+ "net/base/network_interfaces_getifaddrs.cc",
+ "net/base/network_interfaces_getifaddrs_android.cc",
+ "net/base/network_interfaces_linux.cc",
+ "net/base/network_interfaces_posix.cc",
+ "net/base/network_isolation_key.cc",
+ "net/base/parse_number.cc",
+ "net/base/platform_mime_util_linux.cc",
+ "net/base/port_util.cc",
+ "net/base/prioritized_dispatcher.cc",
+ "net/base/prioritized_task_runner.cc",
+ "net/base/privacy_mode.cc",
+ "net/base/proxy_server.cc",
+ "net/base/proxy_string_util.cc",
+ "net/base/registry_controlled_domains/registry_controlled_domain.cc",
+ "net/base/request_priority.cc",
+ "net/base/scheme_host_port_matcher.cc",
+ "net/base/scheme_host_port_matcher_rule.cc",
+ "net/base/schemeful_site.cc",
+ "net/base/sockaddr_storage.cc",
+ "net/base/sockaddr_util_posix.cc",
+ "net/base/transport_info.cc",
+ "net/base/upload_bytes_element_reader.cc",
+ "net/base/upload_data_stream.cc",
+ "net/base/upload_element_reader.cc",
+ "net/base/upload_file_element_reader.cc",
+ "net/base/url_util.cc",
+ "net/cert/asn1_util.cc",
+ "net/cert/caching_cert_verifier.cc",
+ "net/cert/cert_and_ct_verifier.cc",
+ "net/cert/cert_database.cc",
+ "net/cert/cert_status_flags.cc",
+ "net/cert/cert_verifier.cc",
+ "net/cert/cert_verify_proc.cc",
+ "net/cert/cert_verify_proc_android.cc",
+ "net/cert/cert_verify_proc_builtin.cc",
+ "net/cert/cert_verify_result.cc",
+ "net/cert/coalescing_cert_verifier.cc",
+ "net/cert/crl_set.cc",
+ "net/cert/ct_log_response_parser.cc",
+ "net/cert/ct_log_verifier.cc",
+ "net/cert/ct_log_verifier_util.cc",
+ "net/cert/ct_objects_extractor.cc",
+ "net/cert/ct_policy_enforcer.cc",
+ "net/cert/ct_sct_to_string.cc",
+ "net/cert/ct_serialization.cc",
+ "net/cert/ct_signed_certificate_timestamp_log_param.cc",
+ "net/cert/do_nothing_ct_verifier.cc",
+ "net/cert/ev_root_ca_metadata.cc",
+ "net/cert/internal/cert_issuer_source_aia.cc",
+ "net/cert/internal/revocation_checker.cc",
+ "net/cert/internal/system_trust_store.cc",
+ "net/cert/known_roots.cc",
+ "net/cert/merkle_audit_proof.cc",
+ "net/cert/merkle_consistency_proof.cc",
+ "net/cert/merkle_tree_leaf.cc",
+ "net/cert/multi_log_ct_verifier.cc",
+ "net/cert/multi_threaded_cert_verifier.cc",
+ "net/cert/ocsp_verify_result.cc",
+ "net/cert/pem.cc",
+ "net/cert/pki/cert_error_id.cc",
+ "net/cert/pki/cert_error_params.cc",
+ "net/cert/pki/cert_errors.cc",
+ "net/cert/pki/cert_issuer_source_static.cc",
+ "net/cert/pki/certificate_policies.cc",
+ "net/cert/pki/common_cert_errors.cc",
+ "net/cert/pki/crl.cc",
+ "net/cert/pki/extended_key_usage.cc",
+ "net/cert/pki/general_names.cc",
+ "net/cert/pki/name_constraints.cc",
+ "net/cert/pki/ocsp.cc",
+ "net/cert/pki/parse_certificate.cc",
+ "net/cert/pki/parse_name.cc",
+ "net/cert/pki/parsed_certificate.cc",
+ "net/cert/pki/path_builder.cc",
+ "net/cert/pki/revocation_util.cc",
+ "net/cert/pki/signature_algorithm.cc",
+ "net/cert/pki/simple_path_builder_delegate.cc",
+ "net/cert/pki/string_util.cc",
+ "net/cert/pki/trust_store.cc",
+ "net/cert/pki/trust_store_collection.cc",
+ "net/cert/pki/trust_store_in_memory.cc",
+ "net/cert/pki/verify_certificate_chain.cc",
+ "net/cert/pki/verify_name_match.cc",
+ "net/cert/pki/verify_signed_data.cc",
+ "net/cert/sct_status_flags.cc",
+ "net/cert/signed_certificate_timestamp.cc",
+ "net/cert/signed_certificate_timestamp_and_status.cc",
+ "net/cert/signed_tree_head.cc",
+ "net/cert/symantec_certs.cc",
+ "net/cert/test_root_certs.cc",
+ "net/cert/test_root_certs_android.cc",
+ "net/cert/trial_comparison_cert_verifier_util.cc",
+ "net/cert/x509_cert_types.cc",
+ "net/cert/x509_certificate.cc",
+ "net/cert/x509_certificate_net_log_param.cc",
+ "net/cert/x509_util.cc",
+ "net/cert/x509_util_android.cc",
+ "net/cert_net/cert_net_fetcher_url_request.cc",
+ "net/cookies/canonical_cookie.cc",
+ "net/cookies/cookie_access_delegate.cc",
+ "net/cookies/cookie_access_result.cc",
+ "net/cookies/cookie_change_dispatcher.cc",
+ "net/cookies/cookie_constants.cc",
+ "net/cookies/cookie_deletion_info.cc",
+ "net/cookies/cookie_inclusion_status.cc",
+ "net/cookies/cookie_monster.cc",
+ "net/cookies/cookie_monster_change_dispatcher.cc",
+ "net/cookies/cookie_monster_netlog_params.cc",
+ "net/cookies/cookie_options.cc",
+ "net/cookies/cookie_partition_key.cc",
+ "net/cookies/cookie_partition_key_collection.cc",
+ "net/cookies/cookie_store.cc",
+ "net/cookies/cookie_util.cc",
+ "net/cookies/parsed_cookie.cc",
+ "net/cookies/site_for_cookies.cc",
+ "net/cookies/static_cookie_policy.cc",
+ "net/der/encode_values.cc",
+ "net/der/input.cc",
+ "net/der/parse_values.cc",
+ "net/der/parser.cc",
+ "net/der/tag.cc",
+ "net/disk_cache/backend_cleanup_tracker.cc",
+ "net/disk_cache/blockfile/addr.cc",
+ "net/disk_cache/blockfile/backend_impl.cc",
+ "net/disk_cache/blockfile/bitmap.cc",
+ "net/disk_cache/blockfile/block_files.cc",
+ "net/disk_cache/blockfile/disk_format.cc",
+ "net/disk_cache/blockfile/entry_impl.cc",
+ "net/disk_cache/blockfile/eviction.cc",
+ "net/disk_cache/blockfile/file.cc",
+ "net/disk_cache/blockfile/file_lock.cc",
+ "net/disk_cache/blockfile/file_posix.cc",
+ "net/disk_cache/blockfile/in_flight_backend_io.cc",
+ "net/disk_cache/blockfile/in_flight_io.cc",
+ "net/disk_cache/blockfile/mapped_file.cc",
+ "net/disk_cache/blockfile/rankings.cc",
+ "net/disk_cache/blockfile/sparse_control.cc",
+ "net/disk_cache/blockfile/stats.cc",
+ "net/disk_cache/cache_util.cc",
+ "net/disk_cache/cache_util_posix.cc",
+ "net/disk_cache/disk_cache.cc",
+ "net/disk_cache/memory/mem_backend_impl.cc",
+ "net/disk_cache/memory/mem_entry_impl.cc",
+ "net/disk_cache/net_log_parameters.cc",
+ "net/disk_cache/simple/post_doom_waiter.cc",
+ "net/disk_cache/simple/simple_backend_impl.cc",
+ "net/disk_cache/simple/simple_entry_format.cc",
+ "net/disk_cache/simple/simple_entry_impl.cc",
+ "net/disk_cache/simple/simple_entry_operation.cc",
+ "net/disk_cache/simple/simple_file_enumerator.cc",
+ "net/disk_cache/simple/simple_file_tracker.cc",
+ "net/disk_cache/simple/simple_index.cc",
+ "net/disk_cache/simple/simple_index_file.cc",
+ "net/disk_cache/simple/simple_net_log_parameters.cc",
+ "net/disk_cache/simple/simple_synchronous_entry.cc",
+ "net/disk_cache/simple/simple_util.cc",
+ "net/disk_cache/simple/simple_util_posix.cc",
+ "net/disk_cache/simple/simple_version_upgrade.cc",
+ "net/filter/brotli_source_stream.cc",
+ "net/filter/filter_source_stream.cc",
+ "net/filter/gzip_header.cc",
+ "net/filter/gzip_source_stream.cc",
+ "net/filter/source_stream.cc",
+ "net/first_party_sets/addition_overlaps_union_find.cc",
+ "net/first_party_sets/first_party_set_entry.cc",
+ "net/first_party_sets/first_party_set_metadata.cc",
+ "net/first_party_sets/first_party_sets_cache_filter.cc",
+ "net/first_party_sets/first_party_sets_context_config.cc",
+ "net/first_party_sets/global_first_party_sets.cc",
+ "net/first_party_sets/same_party_context.cc",
+ "net/http/alternative_service.cc",
+ "net/http/bidirectional_stream.cc",
+ "net/http/bidirectional_stream_impl.cc",
+ "net/http/bidirectional_stream_request_info.cc",
+ "net/http/broken_alternative_services.cc",
+ "net/http/http_auth.cc",
+ "net/http/http_auth_cache.cc",
+ "net/http/http_auth_challenge_tokenizer.cc",
+ "net/http/http_auth_controller.cc",
+ "net/http/http_auth_filter.cc",
+ "net/http/http_auth_handler.cc",
+ "net/http/http_auth_handler_basic.cc",
+ "net/http/http_auth_handler_digest.cc",
+ "net/http/http_auth_handler_factory.cc",
+ "net/http/http_auth_handler_negotiate.cc",
+ "net/http/http_auth_handler_ntlm.cc",
+ "net/http/http_auth_handler_ntlm_portable.cc",
+ "net/http/http_auth_multi_round_parse.cc",
+ "net/http/http_auth_ntlm_mechanism.cc",
+ "net/http/http_auth_preferences.cc",
+ "net/http/http_auth_scheme.cc",
+ "net/http/http_basic_state.cc",
+ "net/http/http_basic_stream.cc",
+ "net/http/http_byte_range.cc",
+ "net/http/http_cache.cc",
+ "net/http/http_cache_lookup_manager.cc",
+ "net/http/http_cache_transaction.cc",
+ "net/http/http_cache_writers.cc",
+ "net/http/http_chunked_decoder.cc",
+ "net/http/http_content_disposition.cc",
+ "net/http/http_log_util.cc",
+ "net/http/http_network_layer.cc",
+ "net/http/http_network_session.cc",
+ "net/http/http_network_session_peer.cc",
+ "net/http/http_network_transaction.cc",
+ "net/http/http_proxy_client_socket.cc",
+ "net/http/http_proxy_connect_job.cc",
+ "net/http/http_raw_request_headers.cc",
+ "net/http/http_request_headers.cc",
+ "net/http/http_request_info.cc",
+ "net/http/http_response_body_drainer.cc",
+ "net/http/http_response_headers.cc",
+ "net/http/http_response_info.cc",
+ "net/http/http_security_headers.cc",
+ "net/http/http_server_properties.cc",
+ "net/http/http_server_properties_manager.cc",
+ "net/http/http_status_code.cc",
+ "net/http/http_stream_factory.cc",
+ "net/http/http_stream_factory_job.cc",
+ "net/http/http_stream_factory_job_controller.cc",
+ "net/http/http_stream_parser.cc",
+ "net/http/http_stream_request.cc",
+ "net/http/http_util.cc",
+ "net/http/http_vary_data.cc",
+ "net/http/partial_data.cc",
+ "net/http/proxy_client_socket.cc",
+ "net/http/proxy_fallback.cc",
+ "net/http/transport_security_persister.cc",
+ "net/http/transport_security_state_source.cc",
+ "net/http/url_security_manager.cc",
+ "net/http/url_security_manager_posix.cc",
+ "net/http/webfonts_histogram.cc",
+ "net/log/file_net_log_observer.cc",
+ "net/log/net_log.cc",
+ "net/log/net_log_capture_mode.cc",
+ "net/log/net_log_entry.cc",
+ "net/log/net_log_event_type.cc",
+ "net/log/net_log_source.cc",
+ "net/log/net_log_util.cc",
+ "net/log/net_log_values.cc",
+ "net/log/net_log_with_source.cc",
+ "net/log/trace_net_log_observer.cc",
+ "net/network_error_logging/network_error_logging_service.cc",
+ "net/nqe/cached_network_quality.cc",
+ "net/nqe/effective_connection_type.cc",
+ "net/nqe/event_creator.cc",
+ "net/nqe/network_id.cc",
+ "net/nqe/network_qualities_prefs_manager.cc",
+ "net/nqe/network_quality.cc",
+ "net/nqe/network_quality_estimator.cc",
+ "net/nqe/network_quality_estimator_params.cc",
+ "net/nqe/network_quality_estimator_util.cc",
+ "net/nqe/network_quality_observation.cc",
+ "net/nqe/network_quality_store.cc",
+ "net/nqe/observation_buffer.cc",
+ "net/nqe/pref_names.cc",
+ "net/nqe/socket_watcher.cc",
+ "net/nqe/socket_watcher_factory.cc",
+ "net/nqe/throughput_analyzer.cc",
+ "net/ntlm/ntlm.cc",
+ "net/ntlm/ntlm_buffer_reader.cc",
+ "net/ntlm/ntlm_buffer_writer.cc",
+ "net/ntlm/ntlm_client.cc",
+ "net/ntlm/ntlm_constants.cc",
+ "net/proxy_resolution/configured_proxy_resolution_request.cc",
+ "net/proxy_resolution/configured_proxy_resolution_service.cc",
+ "net/proxy_resolution/dhcp_pac_file_fetcher.cc",
+ "net/proxy_resolution/multi_threaded_proxy_resolver.cc",
+ "net/proxy_resolution/network_delegate_error_observer.cc",
+ "net/proxy_resolution/pac_file_data.cc",
+ "net/proxy_resolution/pac_file_decider.cc",
+ "net/proxy_resolution/pac_file_fetcher.cc",
+ "net/proxy_resolution/pac_file_fetcher_impl.cc",
+ "net/proxy_resolution/polling_proxy_config_service.cc",
+ "net/proxy_resolution/proxy_bypass_rules.cc",
+ "net/proxy_resolution/proxy_config.cc",
+ "net/proxy_resolution/proxy_config_service.cc",
+ "net/proxy_resolution/proxy_config_service_android.cc",
+ "net/proxy_resolution/proxy_config_service_fixed.cc",
+ "net/proxy_resolution/proxy_config_with_annotation.cc",
+ "net/proxy_resolution/proxy_info.cc",
+ "net/proxy_resolution/proxy_list.cc",
+ "net/proxy_resolution/proxy_resolver_factory.cc",
+ "net/quic/bidirectional_stream_quic_impl.cc",
+ "net/quic/crypto/proof_source_chromium.cc",
+ "net/quic/crypto/proof_verifier_chromium.cc",
+ "net/quic/dedicated_web_transport_http3_client.cc",
+ "net/quic/network_connection.cc",
+ "net/quic/platform/impl/quic_chromium_clock.cc",
+ "net/quic/properties_based_quic_server_info.cc",
+ "net/quic/quic_address_mismatch.cc",
+ "net/quic/quic_chromium_alarm_factory.cc",
+ "net/quic/quic_chromium_client_session.cc",
+ "net/quic/quic_chromium_client_stream.cc",
+ "net/quic/quic_chromium_connection_helper.cc",
+ "net/quic/quic_chromium_packet_reader.cc",
+ "net/quic/quic_chromium_packet_writer.cc",
+ "net/quic/quic_clock_skew_detector.cc",
+ "net/quic/quic_connection_logger.cc",
+ "net/quic/quic_connectivity_monitor.cc",
+ "net/quic/quic_context.cc",
+ "net/quic/quic_crypto_client_config_handle.cc",
+ "net/quic/quic_crypto_client_stream_factory.cc",
+ "net/quic/quic_event_logger.cc",
+ "net/quic/quic_http3_logger.cc",
+ "net/quic/quic_http_stream.cc",
+ "net/quic/quic_http_utils.cc",
+ "net/quic/quic_proxy_client_socket.cc",
+ "net/quic/quic_server_info.cc",
+ "net/quic/quic_session_key.cc",
+ "net/quic/quic_stream_factory.cc",
+ "net/quic/set_quic_flag.cc",
+ "net/quic/web_transport_client.cc",
+ "net/quic/web_transport_error.cc",
+ "net/reporting/reporting_browsing_data_remover.cc",
+ "net/reporting/reporting_cache.cc",
+ "net/reporting/reporting_cache_impl.cc",
+ "net/reporting/reporting_cache_observer.cc",
+ "net/reporting/reporting_context.cc",
+ "net/reporting/reporting_delegate.cc",
+ "net/reporting/reporting_delivery_agent.cc",
+ "net/reporting/reporting_endpoint.cc",
+ "net/reporting/reporting_endpoint_manager.cc",
+ "net/reporting/reporting_garbage_collector.cc",
+ "net/reporting/reporting_header_parser.cc",
+ "net/reporting/reporting_network_change_observer.cc",
+ "net/reporting/reporting_policy.cc",
+ "net/reporting/reporting_report.cc",
+ "net/reporting/reporting_service.cc",
+ "net/reporting/reporting_uploader.cc",
+ "net/socket/client_socket_factory.cc",
+ "net/socket/client_socket_handle.cc",
+ "net/socket/client_socket_pool.cc",
+ "net/socket/client_socket_pool_manager.cc",
+ "net/socket/client_socket_pool_manager_impl.cc",
+ "net/socket/connect_job.cc",
+ "net/socket/connect_job_factory.cc",
+ "net/socket/network_binding_client_socket_factory.cc",
+ "net/socket/next_proto.cc",
+ "net/socket/server_socket.cc",
+ "net/socket/socket.cc",
+ "net/socket/socket_bio_adapter.cc",
+ "net/socket/socket_descriptor.cc",
+ "net/socket/socket_net_log_params.cc",
+ "net/socket/socket_options.cc",
+ "net/socket/socket_posix.cc",
+ "net/socket/socket_tag.cc",
+ "net/socket/socks5_client_socket.cc",
+ "net/socket/socks_client_socket.cc",
+ "net/socket/socks_connect_job.cc",
+ "net/socket/ssl_client_socket.cc",
+ "net/socket/ssl_client_socket_impl.cc",
+ "net/socket/ssl_connect_job.cc",
+ "net/socket/ssl_server_socket_impl.cc",
+ "net/socket/stream_socket.cc",
+ "net/socket/tcp_client_socket.cc",
+ "net/socket/tcp_server_socket.cc",
+ "net/socket/tcp_socket_posix.cc",
+ "net/socket/transport_client_socket.cc",
+ "net/socket/transport_client_socket_pool.cc",
+ "net/socket/transport_connect_job.cc",
+ "net/socket/transport_connect_sub_job.cc",
+ "net/socket/udp_client_socket.cc",
+ "net/socket/udp_net_log_parameters.cc",
+ "net/socket/udp_server_socket.cc",
+ "net/socket/udp_socket_global_limits.cc",
+ "net/socket/udp_socket_posix.cc",
+ "net/socket/unix_domain_client_socket_posix.cc",
+ "net/socket/unix_domain_server_socket_posix.cc",
+ "net/socket/websocket_endpoint_lock_manager.cc",
+ "net/socket/websocket_transport_client_socket_pool.cc",
+ "net/spdy/alps_decoder.cc",
+ "net/spdy/bidirectional_stream_spdy_impl.cc",
+ "net/spdy/buffered_spdy_framer.cc",
+ "net/spdy/header_coalescer.cc",
+ "net/spdy/http2_priority_dependencies.cc",
+ "net/spdy/http2_push_promise_index.cc",
+ "net/spdy/multiplexed_http_stream.cc",
+ "net/spdy/multiplexed_session.cc",
+ "net/spdy/spdy_buffer.cc",
+ "net/spdy/spdy_buffer_producer.cc",
+ "net/spdy/spdy_http_stream.cc",
+ "net/spdy/spdy_http_utils.cc",
+ "net/spdy/spdy_log_util.cc",
+ "net/spdy/spdy_proxy_client_socket.cc",
+ "net/spdy/spdy_read_queue.cc",
+ "net/spdy/spdy_session.cc",
+ "net/spdy/spdy_session_key.cc",
+ "net/spdy/spdy_session_pool.cc",
+ "net/spdy/spdy_stream.cc",
+ "net/spdy/spdy_write_queue.cc",
+ "net/ssl/cert_compression.cc",
+ "net/ssl/client_cert_identity.cc",
+ "net/ssl/openssl_ssl_util.cc",
+ "net/ssl/ssl_cert_request_info.cc",
+ "net/ssl/ssl_cipher_suite_names.cc",
+ "net/ssl/ssl_client_auth_cache.cc",
+ "net/ssl/ssl_client_session_cache.cc",
+ "net/ssl/ssl_config.cc",
+ "net/ssl/ssl_config_service.cc",
+ "net/ssl/ssl_config_service_defaults.cc",
+ "net/ssl/ssl_info.cc",
+ "net/ssl/ssl_key_logger.cc",
+ "net/ssl/ssl_key_logger_impl.cc",
+ "net/ssl/ssl_platform_key_android.cc",
+ "net/ssl/ssl_platform_key_util.cc",
+ "net/ssl/ssl_private_key.cc",
+ "net/ssl/ssl_server_config.cc",
+ "net/ssl/threaded_ssl_private_key.cc",
+ "net/url_request/redirect_info.cc",
+ "net/url_request/redirect_util.cc",
+ "net/url_request/report_sender.cc",
+ "net/url_request/static_http_user_agent_settings.cc",
+ "net/url_request/url_request.cc",
+ "net/url_request/url_request_context.cc",
+ "net/url_request/url_request_context_builder.cc",
+ "net/url_request/url_request_context_getter.cc",
+ "net/url_request/url_request_error_job.cc",
+ "net/url_request/url_request_filter.cc",
+ "net/url_request/url_request_http_job.cc",
+ "net/url_request/url_request_interceptor.cc",
+ "net/url_request/url_request_job.cc",
+ "net/url_request/url_request_job_factory.cc",
+ "net/url_request/url_request_netlog_params.cc",
+ "net/url_request/url_request_redirect_job.cc",
+ "net/url_request/url_request_throttler_entry.cc",
+ "net/url_request/url_request_throttler_manager.cc",
+ "net/url_request/view_cache_helper.cc",
+ "net/url_request/websocket_handshake_userdata_key.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_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",
+ "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",
+ "cronet_aml_net_ios_cronet_buildflags__testing",
+ ],
+ export_generated_headers: [
+ "cronet_aml_build_chromeos_buildflags__testing",
+ "cronet_aml_net_ios_cronet_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",
+ "-DENABLE_BUILT_IN_DNS",
+ "-DGOOGLE_PROTOBUF_INTERNAL_DONATE_STEAL_INLINE=0",
+ "-DGOOGLE_PROTOBUF_NO_RTTI",
+ "-DGOOGLE_PROTOBUF_NO_STATIC_INITIALIZER",
+ "-DHAVE_PTHREAD",
+ "-DHAVE_SYS_UIO_H",
+ "-DNDEBUG",
+ "-DNET_IMPLEMENTATION",
+ "-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",
+ "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/brotli/include/",
+ "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: {
+ srcs: [
+ "net/disk_cache/blockfile/mapped_file_bypass_mmap_posix.cc",
+ ],
+ cflags: [
+ "-fstack-protector",
+ ],
+ },
+ android_arm64: {
+ srcs: [
+ "net/disk_cache/blockfile/mapped_file_bypass_mmap_posix.cc",
+ ],
+ cflags: [
+ "-fstack-protector",
+ "-mno-outline",
+ "-mno-outline-atomics",
+ ],
+ },
+ android_x86: {
+ srcs: [
+ "net/disk_cache/blockfile/mapped_file_posix.cc",
+ ],
+ cflags: [
+ "-msse3",
+ ],
+ },
+ android_x86_64: {
+ srcs: [
+ "net/disk_cache/blockfile/mapped_file_bypass_mmap_posix.cc",
+ ],
+ cflags: [
+ "-fstack-protector",
"-msse3",
],
},
@@ -5547,7 +15537,7 @@
}
// GN: //net:net_deps
-cc_object {
+cc_library_static {
name: "cronet_aml_net_net_deps",
srcs: [
":cronet_aml_net_isolation_info_proto_gen",
@@ -5562,10 +15552,61 @@
"cronet_aml_base_allocator_partition_allocator_partition_alloc",
"cronet_aml_base_base",
"cronet_aml_base_base_static",
+ "cronet_aml_base_nodebug_assertion",
"cronet_aml_base_third_party_double_conversion_double_conversion",
"cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations",
"cronet_aml_net_preload_decoder",
+ "cronet_aml_third_party_abseil_cpp_absl_base_base",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+ "cronet_aml_third_party_abseil_cpp_absl_base_strerror",
+ "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+ "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler",
+ "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_city",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_hash",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+ "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
+ "cronet_aml_third_party_abseil_cpp_absl_random_distributions",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material",
+ "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception",
+ "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences",
+ "cronet_aml_third_party_abseil_cpp_absl_status_status",
+ "cronet_aml_third_party_abseil_cpp_absl_status_statusor",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cord",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+ "cronet_aml_third_party_abseil_cpp_absl_time_time",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access",
+ "cronet_aml_third_party_android_ndk_cpu_features",
+ "cronet_aml_third_party_ashmem_ashmem",
"cronet_aml_third_party_boringssl_boringssl",
+ "cronet_aml_third_party_boringssl_boringssl_asm",
"cronet_aml_third_party_brotli_common",
"cronet_aml_third_party_brotli_dec",
"cronet_aml_third_party_icu_icui18n",
@@ -5583,6 +15624,15 @@
"cronet_aml_net_net_jni_headers",
"cronet_aml_url_buildflags",
],
+ export_generated_headers: [
+ "cronet_aml_base_debugging_buildflags",
+ "cronet_aml_base_logging_buildflags",
+ "cronet_aml_build_chromeos_buildflags",
+ "cronet_aml_net_base_registry_controlled_domains_registry_controlled_domains",
+ "cronet_aml_net_isolation_info_proto_gen_headers",
+ "cronet_aml_net_net_jni_headers",
+ "cronet_aml_url_buildflags",
+ ],
defaults: [
"cronet_aml_defaults",
],
@@ -5600,6 +15650,7 @@
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
"-DNET_IMPLEMENTATION",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-D_FORTIFY_SOURCE=2",
@@ -5608,6 +15659,14 @@
"-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: [
"./",
@@ -5620,7 +15679,40 @@
"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",
@@ -5628,6 +15720,198 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
+ "-msse3",
+ ],
+ },
+ },
+}
+
+// GN: //net:net_deps__testing
+cc_library_static {
+ name: "cronet_aml_net_net_deps__testing",
+ srcs: [
+ ":cronet_aml_net_isolation_info_proto__testing_gen",
+ ],
+ 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_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",
+ "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",
+ ],
+ 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",
+ ],
+ 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",
+ ],
+ 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",
+ "-DENABLE_BUILT_IN_DNS",
+ "-DGOOGLE_PROTOBUF_INTERNAL_DONATE_STEAL_INLINE=0",
+ "-DGOOGLE_PROTOBUF_NO_RTTI",
+ "-DGOOGLE_PROTOBUF_NO_STATIC_INITIALIZER",
+ "-DHAVE_PTHREAD",
+ "-DHAVE_SYS_UIO_H",
+ "-DNDEBUG",
+ "-DNET_IMPLEMENTATION",
+ "-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/",
+ "third_party/brotli/include/",
+ "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",
],
},
@@ -5740,6 +16024,151 @@
],
}
+// GN: //net:net_jni_headers__testing
+cc_genrule {
+ name: "cronet_aml_net_net_jni_headers__testing",
+ srcs: [
+ "net/android/java/src/org/chromium/net/AndroidCertVerifyResult.java",
+ "net/android/java/src/org/chromium/net/AndroidKeyStore.java",
+ "net/android/java/src/org/chromium/net/AndroidNetworkLibrary.java",
+ "net/android/java/src/org/chromium/net/AndroidTrafficStats.java",
+ "net/android/java/src/org/chromium/net/DnsStatus.java",
+ "net/android/java/src/org/chromium/net/GURLUtils.java",
+ "net/android/java/src/org/chromium/net/HttpNegotiateAuthenticator.java",
+ "net/android/java/src/org/chromium/net/HttpUtil.java",
+ "net/android/java/src/org/chromium/net/NetStringUtil.java",
+ "net/android/java/src/org/chromium/net/NetworkActiveNotifier.java",
+ "net/android/java/src/org/chromium/net/NetworkChangeNotifier.java",
+ "net/android/java/src/org/chromium/net/ProxyChangeListener.java",
+ "net/android/java/src/org/chromium/net/X509Util.java",
+ ],
+ cmd: "$(location base/android/jni_generator/jni_generator.py) --ptr_type " +
+ "long " +
+ "--output_dir " +
+ "$(genDir)/net/net_jni_headers " +
+ "--includes " +
+ "base/android/jni_generator/jni_generator_helper.h " +
+ "--use_proxy_hash " +
+ "--output_name " +
+ "AndroidCertVerifyResult_jni.h " +
+ "--output_name " +
+ "AndroidKeyStore_jni.h " +
+ "--output_name " +
+ "AndroidNetworkLibrary_jni.h " +
+ "--output_name " +
+ "AndroidTrafficStats_jni.h " +
+ "--output_name " +
+ "DnsStatus_jni.h " +
+ "--output_name " +
+ "GURLUtils_jni.h " +
+ "--output_name " +
+ "HttpNegotiateAuthenticator_jni.h " +
+ "--output_name " +
+ "HttpUtil_jni.h " +
+ "--output_name " +
+ "NetStringUtil_jni.h " +
+ "--output_name " +
+ "NetworkActiveNotifier_jni.h " +
+ "--output_name " +
+ "NetworkChangeNotifier_jni.h " +
+ "--output_name " +
+ "ProxyChangeListener_jni.h " +
+ "--output_name " +
+ "X509Util_jni.h " +
+ "--input_file " +
+ "$(location net/android/java/src/org/chromium/net/AndroidCertVerifyResult.java) " +
+ "--input_file " +
+ "$(location net/android/java/src/org/chromium/net/AndroidKeyStore.java) " +
+ "--input_file " +
+ "$(location net/android/java/src/org/chromium/net/AndroidNetworkLibrary.java) " +
+ "--input_file " +
+ "$(location net/android/java/src/org/chromium/net/AndroidTrafficStats.java) " +
+ "--input_file " +
+ "$(location net/android/java/src/org/chromium/net/DnsStatus.java) " +
+ "--input_file " +
+ "$(location net/android/java/src/org/chromium/net/GURLUtils.java) " +
+ "--input_file " +
+ "$(location net/android/java/src/org/chromium/net/HttpNegotiateAuthenticator.java) " +
+ "--input_file " +
+ "$(location net/android/java/src/org/chromium/net/HttpUtil.java) " +
+ "--input_file " +
+ "$(location net/android/java/src/org/chromium/net/NetStringUtil.java) " +
+ "--input_file " +
+ "$(location net/android/java/src/org/chromium/net/NetworkActiveNotifier.java) " +
+ "--input_file " +
+ "$(location net/android/java/src/org/chromium/net/NetworkChangeNotifier.java) " +
+ "--input_file " +
+ "$(location net/android/java/src/org/chromium/net/ProxyChangeListener.java) " +
+ "--input_file " +
+ "$(location net/android/java/src/org/chromium/net/X509Util.java)",
+ out: [
+ "net/net_jni_headers/AndroidCertVerifyResult_jni.h",
+ "net/net_jni_headers/AndroidKeyStore_jni.h",
+ "net/net_jni_headers/AndroidNetworkLibrary_jni.h",
+ "net/net_jni_headers/AndroidTrafficStats_jni.h",
+ "net/net_jni_headers/DnsStatus_jni.h",
+ "net/net_jni_headers/GURLUtils_jni.h",
+ "net/net_jni_headers/HttpNegotiateAuthenticator_jni.h",
+ "net/net_jni_headers/HttpUtil_jni.h",
+ "net/net_jni_headers/NetStringUtil_jni.h",
+ "net/net_jni_headers/NetworkActiveNotifier_jni.h",
+ "net/net_jni_headers/NetworkChangeNotifier_jni.h",
+ "net/net_jni_headers/ProxyChangeListener_jni.h",
+ "net/net_jni_headers/X509Util_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_nqe_proto__testing
+cc_genrule {
+ name: "cronet_aml_net_net_nqe_proto__testing_gen",
+ srcs: [
+ "net/nqe/proto/network_id_proto.proto",
+ ],
+ tools: [
+ "cronet_aml_third_party_protobuf_protoc",
+ ],
+ cmd: "$(location cronet_aml_third_party_protobuf_protoc) --proto_path=external/cronet/net/nqe/proto --cpp_out=lite=true:$(genDir)/external/cronet/net/nqe/proto/ $(in)",
+ out: [
+ "external/cronet/net/nqe/proto/network_id_proto.pb.cc",
+ ],
+ apex_available: [
+ "com.android.tethering",
+ ],
+}
+
+// GN: //net:net_nqe_proto__testing
+cc_genrule {
+ name: "cronet_aml_net_net_nqe_proto__testing_gen_headers",
+ srcs: [
+ "net/nqe/proto/network_id_proto.proto",
+ ],
+ tools: [
+ "cronet_aml_third_party_protobuf_protoc",
+ ],
+ cmd: "$(location cronet_aml_third_party_protobuf_protoc) --proto_path=external/cronet/net/nqe/proto --cpp_out=lite=true:$(genDir)/external/cronet/net/nqe/proto/ $(in)",
+ out: [
+ "external/cronet/net/nqe/proto/network_id_proto.pb.h",
+ ],
+ export_include_dirs: [
+ ".",
+ "net/nqe/proto",
+ "protos",
+ ],
+ apex_available: [
+ "com.android.tethering",
+ ],
+}
+
// GN: //net:net_nqe_proto
cc_genrule {
name: "cronet_aml_net_net_nqe_proto_gen",
@@ -5782,7 +16211,7 @@
}
// GN: //net:net_public_deps
-cc_object {
+cc_library_static {
name: "cronet_aml_net_net_public_deps",
srcs: [
":cronet_aml_net_net_nqe_proto_gen",
@@ -5798,12 +16227,64 @@
"cronet_aml_base_allocator_partition_allocator_partition_alloc",
"cronet_aml_base_base",
"cronet_aml_base_base_static",
+ "cronet_aml_base_nodebug_assertion",
"cronet_aml_base_third_party_double_conversion_double_conversion",
"cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations",
"cronet_aml_crypto_crypto",
"cronet_aml_net_third_party_quiche_quiche",
+ "cronet_aml_net_traffic_annotation_traffic_annotation",
"cronet_aml_net_uri_template",
+ "cronet_aml_third_party_abseil_cpp_absl_base_base",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+ "cronet_aml_third_party_abseil_cpp_absl_base_strerror",
+ "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+ "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler",
+ "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_city",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_hash",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+ "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
+ "cronet_aml_third_party_abseil_cpp_absl_random_distributions",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material",
+ "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception",
+ "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences",
+ "cronet_aml_third_party_abseil_cpp_absl_status_status",
+ "cronet_aml_third_party_abseil_cpp_absl_status_statusor",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cord",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+ "cronet_aml_third_party_abseil_cpp_absl_time_time",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access",
+ "cronet_aml_third_party_android_ndk_cpu_features",
+ "cronet_aml_third_party_ashmem_ashmem",
"cronet_aml_third_party_boringssl_boringssl",
+ "cronet_aml_third_party_boringssl_boringssl_asm",
"cronet_aml_third_party_icu_icui18n",
"cronet_aml_third_party_icu_icuuc_private",
"cronet_aml_third_party_libevent_libevent",
@@ -5812,7 +16293,11 @@
"cronet_aml_url_url",
],
generated_headers: [
- "cronet_aml_build_chromeos_buildflags",
+ "cronet_aml_net_buildflags",
+ "cronet_aml_net_net_nqe_proto_gen_headers",
+ "cronet_aml_net_third_party_quiche_net_quic_test_tools_proto_gen_headers",
+ ],
+ export_generated_headers: [
"cronet_aml_net_buildflags",
"cronet_aml_net_net_nqe_proto_gen_headers",
"cronet_aml_net_third_party_quiche_net_quic_test_tools_proto_gen_headers",
@@ -5832,6 +16317,7 @@
"-DHAVE_PTHREAD",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-D_FORTIFY_SOURCE=2",
@@ -5840,6 +16326,14 @@
"-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: [
"./",
@@ -5854,7 +16348,40 @@
"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",
@@ -5862,6 +16389,193 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
+ "-msse3",
+ ],
+ },
+ },
+}
+
+// GN: //net:net_public_deps__testing
+cc_library_static {
+ name: "cronet_aml_net_net_public_deps__testing",
+ srcs: [
+ ":cronet_aml_net_net_nqe_proto__testing_gen",
+ ":cronet_aml_net_third_party_quiche_net_quic_test_tools_proto__testing_gen",
+ ],
+ 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_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",
+ "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_net_buildflags__testing",
+ "cronet_aml_net_net_nqe_proto__testing_gen_headers",
+ "cronet_aml_net_third_party_quiche_net_quic_test_tools_proto__testing_gen_headers",
+ ],
+ export_generated_headers: [
+ "cronet_aml_net_buildflags__testing",
+ "cronet_aml_net_net_nqe_proto__testing_gen_headers",
+ "cronet_aml_net_third_party_quiche_net_quic_test_tools_proto__testing_gen_headers",
+ ],
+ 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",
+ "-DHAVE_PTHREAD",
+ "-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",
+ "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/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",
],
},
@@ -5882,9 +16596,60 @@
"cronet_aml_base_allocator_partition_allocator_partition_alloc",
"cronet_aml_base_base",
"cronet_aml_base_base_static",
+ "cronet_aml_base_nodebug_assertion",
"cronet_aml_base_third_party_double_conversion_double_conversion",
"cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations",
+ "cronet_aml_third_party_abseil_cpp_absl_base_base",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+ "cronet_aml_third_party_abseil_cpp_absl_base_strerror",
+ "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+ "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler",
+ "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_city",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_hash",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+ "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
+ "cronet_aml_third_party_abseil_cpp_absl_random_distributions",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material",
+ "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception",
+ "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences",
+ "cronet_aml_third_party_abseil_cpp_absl_status_status",
+ "cronet_aml_third_party_abseil_cpp_absl_status_statusor",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cord",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+ "cronet_aml_third_party_abseil_cpp_absl_time_time",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access",
+ "cronet_aml_third_party_android_ndk_cpu_features",
+ "cronet_aml_third_party_ashmem_ashmem",
"cronet_aml_third_party_boringssl_boringssl",
+ "cronet_aml_third_party_boringssl_boringssl_asm",
"cronet_aml_third_party_icu_icui18n",
"cronet_aml_third_party_icu_icuuc_private",
"cronet_aml_third_party_libevent_libevent",
@@ -5901,6 +16666,7 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-D_FORTIFY_SOURCE=2",
@@ -5909,6 +16675,14 @@
"-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: [
"./",
@@ -5919,7 +16693,40 @@
"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",
@@ -5927,12 +16734,893 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //net:preload_decoder__testing
+cc_library_static {
+ name: "cronet_aml_net_preload_decoder__testing",
+ srcs: [
+ "net/extras/preload_data/decoder.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_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",
+ ],
+ 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: //net:quic_test_flags_utils__testing
+cc_library_static {
+ name: "cronet_aml_net_quic_test_flags_utils__testing",
+ srcs: [
+ "net/quic/platform/impl/quic_test_flags_utils.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_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",
+ "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",
+ ],
+ 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",
+ "-DHAVE_PTHREAD",
+ "-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",
+ "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/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:simple_quic_tools__testing
+cc_library_static {
+ name: "cronet_aml_net_simple_quic_tools__testing",
+ srcs: [
+ "net/tools/quic/quic_client_message_loop_network_helper.cc",
+ "net/tools/quic/quic_simple_client.cc",
+ "net/tools/quic/quic_simple_server.cc",
+ "net/tools/quic/quic_simple_server_packet_writer.cc",
+ "net/tools/quic/quic_simple_server_session_helper.cc",
+ "net/tools/quic/quic_simple_server_socket.cc",
+ "net/tools/quic/synchronous_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_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",
+ "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",
+ ],
+ 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",
+ "-DHAVE_PTHREAD",
+ "-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",
+ "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/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:test_support__testing
+cc_library_static {
+ name: "cronet_aml_net_test_support__testing",
+ srcs: [
+ "net/base/connection_endpoint_metadata_test_util.cc",
+ "net/base/load_timing_info_test_util.cc",
+ "net/base/mock_file_stream.cc",
+ "net/base/mock_network_change_notifier.cc",
+ "net/base/test_completion_callback.cc",
+ "net/base/test_data_stream.cc",
+ "net/cert/mock_cert_net_fetcher.cc",
+ "net/cert/mock_cert_verifier.cc",
+ "net/cert/mock_client_cert_verifier.cc",
+ "net/cookies/cookie_change_dispatcher_test_helpers.cc",
+ "net/cookies/cookie_monster_store_test.cc",
+ "net/cookies/cookie_store_test_callbacks.cc",
+ "net/cookies/cookie_store_test_helpers.cc",
+ "net/cookies/test_cookie_access_delegate.cc",
+ "net/disk_cache/disk_cache_test_base.cc",
+ "net/disk_cache/disk_cache_test_util.cc",
+ "net/disk_cache/mock/mock_backend_impl.cc",
+ "net/disk_cache/mock/mock_entry_impl.cc",
+ "net/filter/filter_source_stream_test_util.cc",
+ "net/filter/mock_source_stream.cc",
+ "net/http/http_stream_factory_test_util.cc",
+ "net/http/http_transaction_test_util.cc",
+ "net/http/mock_http_cache.cc",
+ "net/http/transport_security_state_test_util.cc",
+ "net/log/test_net_log.cc",
+ "net/log/test_net_log_util.cc",
+ "net/network_error_logging/mock_persistent_nel_store.cc",
+ "net/network_error_logging/network_error_logging_test_util.cc",
+ "net/nqe/network_quality_estimator_test_util.cc",
+ "net/proxy_resolution/mock_pac_file_fetcher.cc",
+ "net/proxy_resolution/mock_proxy_resolver.cc",
+ "net/proxy_resolution/proxy_config_service_common_unittest.cc",
+ "net/quic/quic_test_packet_printer.cc",
+ "net/reporting/mock_persistent_reporting_store.cc",
+ "net/reporting/reporting_test_util.cc",
+ "net/socket/read_buffering_stream_socket.cc",
+ "net/socket/socket_test_util.cc",
+ "net/socket/transport_client_socket_test_util.cc",
+ "net/spdy/spdy_test_util_common.cc",
+ "net/ssl/client_cert_identity_test_util.cc",
+ "net/ssl/ssl_private_key_test_util.cc",
+ "net/ssl/test_ssl_config_service.cc",
+ "net/ssl/test_ssl_private_key.cc",
+ "net/test/cert_builder.cc",
+ "net/test/cert_test_util.cc",
+ "net/test/ct_test_util.cc",
+ "net/test/embedded_test_server/connection_tracker.cc",
+ "net/test/embedded_test_server/controllable_http_response.cc",
+ "net/test/embedded_test_server/default_handlers.cc",
+ "net/test/embedded_test_server/embedded_test_server.cc",
+ "net/test/embedded_test_server/embedded_test_server_connection_listener.cc",
+ "net/test/embedded_test_server/http1_connection.cc",
+ "net/test/embedded_test_server/http2_connection.cc",
+ "net/test/embedded_test_server/http_connection.cc",
+ "net/test/embedded_test_server/http_request.cc",
+ "net/test/embedded_test_server/http_response.cc",
+ "net/test/embedded_test_server/request_handler_util.cc",
+ "net/test/embedded_test_server/simple_connection_listener.cc",
+ "net/test/key_util.cc",
+ "net/test/net_test_suite.cc",
+ "net/test/quic_simple_test_server.cc",
+ "net/test/revocation_builder.cc",
+ "net/test/spawned_test_server/base_test_server.cc",
+ "net/test/spawned_test_server/remote_test_server.cc",
+ "net/test/spawned_test_server/remote_test_server_spawner_request.cc",
+ "net/test/ssl_test_util.cc",
+ "net/test/test_connection_cost_observer.cc",
+ "net/test/test_data_directory.cc",
+ "net/test/test_doh_server.cc",
+ "net/test/url_request/ssl_certificate_error_job.cc",
+ "net/test/url_request/url_request_failed_job.cc",
+ "net/test/url_request/url_request_hanging_read_job.cc",
+ "net/test/url_request/url_request_mock_data_job.cc",
+ "net/url_request/url_request_test_job.cc",
+ "net/url_request/url_request_test_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_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",
+ "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_net_http_transport_security_state_unittest_data_default__testing",
+ ],
+ export_generated_headers: [
+ "cronet_aml_net_http_transport_security_state_unittest_data_default__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",
+ "-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:net_quic_proto__testing
+cc_genrule {
+ name: "cronet_aml_net_third_party_quiche_net_quic_proto__testing_gen",
+ srcs: [
+ "net/third_party/quiche/src/quiche/quic/core/proto/cached_network_parameters.proto",
+ "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",
+ ],
+ tools: [
+ "cronet_aml_third_party_protobuf_protoc",
+ ],
+ cmd: "$(location cronet_aml_third_party_protobuf_protoc) --proto_path=external/cronet/net/third_party/quiche/src --cpp_out=lite=true:$(genDir)/external/cronet/net/third_party/quiche/src/ $(in)",
+ out: [
+ "external/cronet/net/third_party/quiche/src/quiche/quic/core/proto/cached_network_parameters.pb.cc",
+ "external/cronet/net/third_party/quiche/src/quiche/quic/core/proto/crypto_server_config.pb.cc",
+ "external/cronet/net/third_party/quiche/src/quiche/quic/core/proto/source_address_token.pb.cc",
+ ],
+ apex_available: [
+ "com.android.tethering",
+ ],
+}
+
+// GN: //net/third_party/quiche:net_quic_proto__testing
+cc_genrule {
+ name: "cronet_aml_net_third_party_quiche_net_quic_proto__testing_gen_headers",
+ srcs: [
+ "net/third_party/quiche/src/quiche/quic/core/proto/cached_network_parameters.proto",
+ "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",
+ ],
+ tools: [
+ "cronet_aml_third_party_protobuf_protoc",
+ ],
+ cmd: "$(location cronet_aml_third_party_protobuf_protoc) --proto_path=external/cronet/net/third_party/quiche/src --cpp_out=lite=true:$(genDir)/external/cronet/net/third_party/quiche/src/ $(in)",
+ out: [
+ "external/cronet/net/third_party/quiche/src/quiche/quic/core/proto/cached_network_parameters.pb.h",
+ "external/cronet/net/third_party/quiche/src/quiche/quic/core/proto/crypto_server_config.pb.h",
+ "external/cronet/net/third_party/quiche/src/quiche/quic/core/proto/source_address_token.pb.h",
+ ],
+ export_include_dirs: [
+ ".",
+ "net/third_party/quiche/src",
+ "protos",
+ ],
+ apex_available: [
+ "com.android.tethering",
+ ],
+}
+
// GN: //net/third_party/quiche:net_quic_proto
cc_genrule {
name: "cronet_aml_net_third_party_quiche_net_quic_proto_gen",
@@ -5982,6 +17670,47 @@
],
}
+// GN: //net/third_party/quiche:net_quic_test_tools_proto__testing
+cc_genrule {
+ name: "cronet_aml_net_third_party_quiche_net_quic_test_tools_proto__testing_gen",
+ srcs: [
+ "net/third_party/quiche/src/quiche/quic/test_tools/send_algorithm_test_result.proto",
+ ],
+ tools: [
+ "cronet_aml_third_party_protobuf_protoc",
+ ],
+ cmd: "$(location cronet_aml_third_party_protobuf_protoc) --proto_path=external/cronet/net/third_party/quiche/src/quiche/quic/test_tools --cpp_out=lite=true:$(genDir)/external/cronet/net/third_party/quiche/src/quiche/quic/test_tools/ $(in)",
+ out: [
+ "external/cronet/net/third_party/quiche/src/quiche/quic/test_tools/send_algorithm_test_result.pb.cc",
+ ],
+ apex_available: [
+ "com.android.tethering",
+ ],
+}
+
+// GN: //net/third_party/quiche:net_quic_test_tools_proto__testing
+cc_genrule {
+ name: "cronet_aml_net_third_party_quiche_net_quic_test_tools_proto__testing_gen_headers",
+ srcs: [
+ "net/third_party/quiche/src/quiche/quic/test_tools/send_algorithm_test_result.proto",
+ ],
+ tools: [
+ "cronet_aml_third_party_protobuf_protoc",
+ ],
+ cmd: "$(location cronet_aml_third_party_protobuf_protoc) --proto_path=external/cronet/net/third_party/quiche/src/quiche/quic/test_tools --cpp_out=lite=true:$(genDir)/external/cronet/net/third_party/quiche/src/quiche/quic/test_tools/ $(in)",
+ out: [
+ "external/cronet/net/third_party/quiche/src/quiche/quic/test_tools/send_algorithm_test_result.pb.h",
+ ],
+ export_include_dirs: [
+ ".",
+ "net/third_party/quiche/src/quiche/quic/test_tools",
+ "protos",
+ ],
+ apex_available: [
+ "com.android.tethering",
+ ],
+}
+
// GN: //net/third_party/quiche:net_quic_test_tools_proto
cc_genrule {
name: "cronet_aml_net_third_party_quiche_net_quic_test_tools_proto_gen",
@@ -6028,53 +17757,6 @@
name: "cronet_aml_net_third_party_quiche_quiche",
srcs: [
":cronet_aml_net_third_party_quiche_net_quic_proto_gen",
- ":cronet_aml_third_party_abseil_cpp_absl_base_base",
- ":cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
- ":cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
- ":cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
- ":cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
- ":cronet_aml_third_party_abseil_cpp_absl_base_strerror",
- ":cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
- ":cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler",
- ":cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set",
- ":cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
- ":cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
- ":cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack",
- ":cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler",
- ":cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
- ":cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
- ":cronet_aml_third_party_abseil_cpp_absl_hash_city",
- ":cronet_aml_third_party_abseil_cpp_absl_hash_hash",
- ":cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash",
- ":cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
- ":cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
- ":cronet_aml_third_party_abseil_cpp_absl_random_distributions",
- ":cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
- ":cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg",
- ":cronet_aml_third_party_abseil_cpp_absl_random_internal_randen",
- ":cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes",
- ":cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl",
- ":cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow",
- ":cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material",
- ":cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception",
- ":cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences",
- ":cronet_aml_third_party_abseil_cpp_absl_status_status",
- ":cronet_aml_third_party_abseil_cpp_absl_status_statusor",
- ":cronet_aml_third_party_abseil_cpp_absl_strings_cord",
- ":cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal",
- ":cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions",
- ":cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle",
- ":cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info",
- ":cronet_aml_third_party_abseil_cpp_absl_strings_internal",
- ":cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal",
- ":cronet_aml_third_party_abseil_cpp_absl_strings_strings",
- ":cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
- ":cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
- ":cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
- ":cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
- ":cronet_aml_third_party_abseil_cpp_absl_time_time",
- ":cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
- ":cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access",
"net/third_party/quiche/overrides/quiche_platform_impl/quiche_mutex_impl.cc",
"net/third_party/quiche/overrides/quiche_platform_impl/quiche_time_utils_impl.cc",
"net/third_party/quiche/overrides/quiche_platform_impl/quiche_url_utils_impl.cc",
@@ -6366,10 +18048,61 @@
"cronet_aml_base_allocator_partition_allocator_partition_alloc",
"cronet_aml_base_base",
"cronet_aml_base_base_static",
+ "cronet_aml_base_nodebug_assertion",
"cronet_aml_base_third_party_double_conversion_double_conversion",
"cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations",
"cronet_aml_net_uri_template",
+ "cronet_aml_third_party_abseil_cpp_absl_base_base",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+ "cronet_aml_third_party_abseil_cpp_absl_base_strerror",
+ "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+ "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler",
+ "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_city",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_hash",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+ "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
+ "cronet_aml_third_party_abseil_cpp_absl_random_distributions",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material",
+ "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception",
+ "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences",
+ "cronet_aml_third_party_abseil_cpp_absl_status_status",
+ "cronet_aml_third_party_abseil_cpp_absl_status_statusor",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cord",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+ "cronet_aml_third_party_abseil_cpp_absl_time_time",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access",
+ "cronet_aml_third_party_android_ndk_cpu_features",
+ "cronet_aml_third_party_ashmem_ashmem",
"cronet_aml_third_party_boringssl_boringssl",
+ "cronet_aml_third_party_boringssl_boringssl_asm",
"cronet_aml_third_party_icu_icui18n",
"cronet_aml_third_party_icu_icuuc_private",
"cronet_aml_third_party_libevent_libevent",
@@ -6378,11 +18111,9 @@
"cronet_aml_url_url",
],
generated_headers: [
- "cronet_aml_build_chromeos_buildflags",
"cronet_aml_net_third_party_quiche_net_quic_proto_gen_headers",
],
export_generated_headers: [
- "cronet_aml_build_chromeos_buildflags",
"cronet_aml_net_third_party_quiche_net_quic_proto_gen_headers",
],
defaults: [
@@ -6401,6 +18132,7 @@
"-DHAVE_SYS_UIO_H",
"-DIS_QUICHE_IMPL",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-D_FORTIFY_SOURCE=2",
@@ -6409,6 +18141,14 @@
"-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: [
"./",
@@ -6423,7 +18163,40 @@
"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",
@@ -6431,14 +18204,1216 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //net/third_party/quiche:quiche__testing
+cc_library_static {
+ name: "cronet_aml_net_third_party_quiche_quiche__testing",
+ srcs: [
+ ":cronet_aml_net_third_party_quiche_net_quic_proto__testing_gen",
+ "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",
+ "net/third_party/quiche/src/quiche/common/platform/api/quiche_hostname_utils.cc",
+ "net/third_party/quiche/src/quiche/common/platform/api/quiche_mutex.cc",
+ "net/third_party/quiche/src/quiche/common/platform/default/quiche_platform_impl/quiche_flags_impl.cc",
+ "net/third_party/quiche/src/quiche/common/quiche_buffer_allocator.cc",
+ "net/third_party/quiche/src/quiche/common/quiche_crypto_logging.cc",
+ "net/third_party/quiche/src/quiche/common/quiche_data_reader.cc",
+ "net/third_party/quiche/src/quiche/common/quiche_data_writer.cc",
+ "net/third_party/quiche/src/quiche/common/quiche_ip_address.cc",
+ "net/third_party/quiche/src/quiche/common/quiche_ip_address_family.cc",
+ "net/third_party/quiche/src/quiche/common/quiche_mem_slice_storage.cc",
+ "net/third_party/quiche/src/quiche/common/quiche_random.cc",
+ "net/third_party/quiche/src/quiche/common/quiche_text_utils.cc",
+ "net/third_party/quiche/src/quiche/common/simple_buffer_allocator.cc",
+ "net/third_party/quiche/src/quiche/common/structured_headers.cc",
+ "net/third_party/quiche/src/quiche/http2/adapter/event_forwarder.cc",
+ "net/third_party/quiche/src/quiche/http2/adapter/header_validator.cc",
+ "net/third_party/quiche/src/quiche/http2/adapter/http2_protocol.cc",
+ "net/third_party/quiche/src/quiche/http2/adapter/http2_util.cc",
+ "net/third_party/quiche/src/quiche/http2/adapter/noop_header_validator.cc",
+ "net/third_party/quiche/src/quiche/http2/adapter/oghttp2_adapter.cc",
+ "net/third_party/quiche/src/quiche/http2/adapter/oghttp2_session.cc",
+ "net/third_party/quiche/src/quiche/http2/adapter/oghttp2_util.cc",
+ "net/third_party/quiche/src/quiche/http2/adapter/window_manager.cc",
+ "net/third_party/quiche/src/quiche/http2/core/http2_trace_logging.cc",
+ "net/third_party/quiche/src/quiche/http2/decoder/decode_buffer.cc",
+ "net/third_party/quiche/src/quiche/http2/decoder/decode_http2_structures.cc",
+ "net/third_party/quiche/src/quiche/http2/decoder/decode_status.cc",
+ "net/third_party/quiche/src/quiche/http2/decoder/frame_decoder_state.cc",
+ "net/third_party/quiche/src/quiche/http2/decoder/http2_frame_decoder.cc",
+ "net/third_party/quiche/src/quiche/http2/decoder/http2_frame_decoder_listener.cc",
+ "net/third_party/quiche/src/quiche/http2/decoder/http2_structure_decoder.cc",
+ "net/third_party/quiche/src/quiche/http2/decoder/payload_decoders/altsvc_payload_decoder.cc",
+ "net/third_party/quiche/src/quiche/http2/decoder/payload_decoders/continuation_payload_decoder.cc",
+ "net/third_party/quiche/src/quiche/http2/decoder/payload_decoders/data_payload_decoder.cc",
+ "net/third_party/quiche/src/quiche/http2/decoder/payload_decoders/goaway_payload_decoder.cc",
+ "net/third_party/quiche/src/quiche/http2/decoder/payload_decoders/headers_payload_decoder.cc",
+ "net/third_party/quiche/src/quiche/http2/decoder/payload_decoders/ping_payload_decoder.cc",
+ "net/third_party/quiche/src/quiche/http2/decoder/payload_decoders/priority_payload_decoder.cc",
+ "net/third_party/quiche/src/quiche/http2/decoder/payload_decoders/priority_update_payload_decoder.cc",
+ "net/third_party/quiche/src/quiche/http2/decoder/payload_decoders/push_promise_payload_decoder.cc",
+ "net/third_party/quiche/src/quiche/http2/decoder/payload_decoders/rst_stream_payload_decoder.cc",
+ "net/third_party/quiche/src/quiche/http2/decoder/payload_decoders/settings_payload_decoder.cc",
+ "net/third_party/quiche/src/quiche/http2/decoder/payload_decoders/unknown_payload_decoder.cc",
+ "net/third_party/quiche/src/quiche/http2/decoder/payload_decoders/window_update_payload_decoder.cc",
+ "net/third_party/quiche/src/quiche/http2/hpack/decoder/hpack_block_decoder.cc",
+ "net/third_party/quiche/src/quiche/http2/hpack/decoder/hpack_decoder.cc",
+ "net/third_party/quiche/src/quiche/http2/hpack/decoder/hpack_decoder_listener.cc",
+ "net/third_party/quiche/src/quiche/http2/hpack/decoder/hpack_decoder_state.cc",
+ "net/third_party/quiche/src/quiche/http2/hpack/decoder/hpack_decoder_string_buffer.cc",
+ "net/third_party/quiche/src/quiche/http2/hpack/decoder/hpack_decoder_tables.cc",
+ "net/third_party/quiche/src/quiche/http2/hpack/decoder/hpack_decoding_error.cc",
+ "net/third_party/quiche/src/quiche/http2/hpack/decoder/hpack_entry_decoder.cc",
+ "net/third_party/quiche/src/quiche/http2/hpack/decoder/hpack_entry_decoder_listener.cc",
+ "net/third_party/quiche/src/quiche/http2/hpack/decoder/hpack_entry_type_decoder.cc",
+ "net/third_party/quiche/src/quiche/http2/hpack/decoder/hpack_string_decoder.cc",
+ "net/third_party/quiche/src/quiche/http2/hpack/decoder/hpack_string_decoder_listener.cc",
+ "net/third_party/quiche/src/quiche/http2/hpack/decoder/hpack_whole_entry_buffer.cc",
+ "net/third_party/quiche/src/quiche/http2/hpack/decoder/hpack_whole_entry_listener.cc",
+ "net/third_party/quiche/src/quiche/http2/hpack/http2_hpack_constants.cc",
+ "net/third_party/quiche/src/quiche/http2/hpack/huffman/hpack_huffman_decoder.cc",
+ "net/third_party/quiche/src/quiche/http2/hpack/huffman/hpack_huffman_encoder.cc",
+ "net/third_party/quiche/src/quiche/http2/hpack/huffman/huffman_spec_tables.cc",
+ "net/third_party/quiche/src/quiche/http2/hpack/varint/hpack_varint_decoder.cc",
+ "net/third_party/quiche/src/quiche/http2/hpack/varint/hpack_varint_encoder.cc",
+ "net/third_party/quiche/src/quiche/http2/http2_constants.cc",
+ "net/third_party/quiche/src/quiche/http2/http2_structures.cc",
+ "net/third_party/quiche/src/quiche/quic/core/congestion_control/bandwidth_sampler.cc",
+ "net/third_party/quiche/src/quiche/quic/core/congestion_control/bbr2_drain.cc",
+ "net/third_party/quiche/src/quiche/quic/core/congestion_control/bbr2_misc.cc",
+ "net/third_party/quiche/src/quiche/quic/core/congestion_control/bbr2_probe_bw.cc",
+ "net/third_party/quiche/src/quiche/quic/core/congestion_control/bbr2_probe_rtt.cc",
+ "net/third_party/quiche/src/quiche/quic/core/congestion_control/bbr2_sender.cc",
+ "net/third_party/quiche/src/quiche/quic/core/congestion_control/bbr2_startup.cc",
+ "net/third_party/quiche/src/quiche/quic/core/congestion_control/bbr_sender.cc",
+ "net/third_party/quiche/src/quiche/quic/core/congestion_control/cubic_bytes.cc",
+ "net/third_party/quiche/src/quiche/quic/core/congestion_control/general_loss_algorithm.cc",
+ "net/third_party/quiche/src/quiche/quic/core/congestion_control/hybrid_slow_start.cc",
+ "net/third_party/quiche/src/quiche/quic/core/congestion_control/pacing_sender.cc",
+ "net/third_party/quiche/src/quiche/quic/core/congestion_control/prr_sender.cc",
+ "net/third_party/quiche/src/quiche/quic/core/congestion_control/rtt_stats.cc",
+ "net/third_party/quiche/src/quiche/quic/core/congestion_control/send_algorithm_interface.cc",
+ "net/third_party/quiche/src/quiche/quic/core/congestion_control/tcp_cubic_sender_bytes.cc",
+ "net/third_party/quiche/src/quiche/quic/core/congestion_control/uber_loss_algorithm.cc",
+ "net/third_party/quiche/src/quiche/quic/core/crypto/aead_base_decrypter.cc",
+ "net/third_party/quiche/src/quiche/quic/core/crypto/aead_base_encrypter.cc",
+ "net/third_party/quiche/src/quiche/quic/core/crypto/aes_128_gcm_12_decrypter.cc",
+ "net/third_party/quiche/src/quiche/quic/core/crypto/aes_128_gcm_12_encrypter.cc",
+ "net/third_party/quiche/src/quiche/quic/core/crypto/aes_128_gcm_decrypter.cc",
+ "net/third_party/quiche/src/quiche/quic/core/crypto/aes_128_gcm_encrypter.cc",
+ "net/third_party/quiche/src/quiche/quic/core/crypto/aes_256_gcm_decrypter.cc",
+ "net/third_party/quiche/src/quiche/quic/core/crypto/aes_256_gcm_encrypter.cc",
+ "net/third_party/quiche/src/quiche/quic/core/crypto/aes_base_decrypter.cc",
+ "net/third_party/quiche/src/quiche/quic/core/crypto/aes_base_encrypter.cc",
+ "net/third_party/quiche/src/quiche/quic/core/crypto/cert_compressor.cc",
+ "net/third_party/quiche/src/quiche/quic/core/crypto/certificate_util.cc",
+ "net/third_party/quiche/src/quiche/quic/core/crypto/certificate_view.cc",
+ "net/third_party/quiche/src/quiche/quic/core/crypto/chacha20_poly1305_decrypter.cc",
+ "net/third_party/quiche/src/quiche/quic/core/crypto/chacha20_poly1305_encrypter.cc",
+ "net/third_party/quiche/src/quiche/quic/core/crypto/chacha20_poly1305_tls_decrypter.cc",
+ "net/third_party/quiche/src/quiche/quic/core/crypto/chacha20_poly1305_tls_encrypter.cc",
+ "net/third_party/quiche/src/quiche/quic/core/crypto/chacha_base_decrypter.cc",
+ "net/third_party/quiche/src/quiche/quic/core/crypto/chacha_base_encrypter.cc",
+ "net/third_party/quiche/src/quiche/quic/core/crypto/channel_id.cc",
+ "net/third_party/quiche/src/quiche/quic/core/crypto/client_proof_source.cc",
+ "net/third_party/quiche/src/quiche/quic/core/crypto/crypto_framer.cc",
+ "net/third_party/quiche/src/quiche/quic/core/crypto/crypto_handshake.cc",
+ "net/third_party/quiche/src/quiche/quic/core/crypto/crypto_handshake_message.cc",
+ "net/third_party/quiche/src/quiche/quic/core/crypto/crypto_secret_boxer.cc",
+ "net/third_party/quiche/src/quiche/quic/core/crypto/crypto_utils.cc",
+ "net/third_party/quiche/src/quiche/quic/core/crypto/curve25519_key_exchange.cc",
+ "net/third_party/quiche/src/quiche/quic/core/crypto/key_exchange.cc",
+ "net/third_party/quiche/src/quiche/quic/core/crypto/null_decrypter.cc",
+ "net/third_party/quiche/src/quiche/quic/core/crypto/null_encrypter.cc",
+ "net/third_party/quiche/src/quiche/quic/core/crypto/p256_key_exchange.cc",
+ "net/third_party/quiche/src/quiche/quic/core/crypto/proof_source.cc",
+ "net/third_party/quiche/src/quiche/quic/core/crypto/proof_source_x509.cc",
+ "net/third_party/quiche/src/quiche/quic/core/crypto/quic_client_session_cache.cc",
+ "net/third_party/quiche/src/quiche/quic/core/crypto/quic_compressed_certs_cache.cc",
+ "net/third_party/quiche/src/quiche/quic/core/crypto/quic_crypter.cc",
+ "net/third_party/quiche/src/quiche/quic/core/crypto/quic_crypto_client_config.cc",
+ "net/third_party/quiche/src/quiche/quic/core/crypto/quic_crypto_proof.cc",
+ "net/third_party/quiche/src/quiche/quic/core/crypto/quic_crypto_server_config.cc",
+ "net/third_party/quiche/src/quiche/quic/core/crypto/quic_decrypter.cc",
+ "net/third_party/quiche/src/quiche/quic/core/crypto/quic_encrypter.cc",
+ "net/third_party/quiche/src/quiche/quic/core/crypto/quic_hkdf.cc",
+ "net/third_party/quiche/src/quiche/quic/core/crypto/tls_client_connection.cc",
+ "net/third_party/quiche/src/quiche/quic/core/crypto/tls_connection.cc",
+ "net/third_party/quiche/src/quiche/quic/core/crypto/tls_server_connection.cc",
+ "net/third_party/quiche/src/quiche/quic/core/crypto/transport_parameters.cc",
+ "net/third_party/quiche/src/quiche/quic/core/crypto/web_transport_fingerprint_proof_verifier.cc",
+ "net/third_party/quiche/src/quiche/quic/core/deterministic_connection_id_generator.cc",
+ "net/third_party/quiche/src/quiche/quic/core/frames/quic_ack_frame.cc",
+ "net/third_party/quiche/src/quiche/quic/core/frames/quic_ack_frequency_frame.cc",
+ "net/third_party/quiche/src/quiche/quic/core/frames/quic_blocked_frame.cc",
+ "net/third_party/quiche/src/quiche/quic/core/frames/quic_connection_close_frame.cc",
+ "net/third_party/quiche/src/quiche/quic/core/frames/quic_crypto_frame.cc",
+ "net/third_party/quiche/src/quiche/quic/core/frames/quic_frame.cc",
+ "net/third_party/quiche/src/quiche/quic/core/frames/quic_goaway_frame.cc",
+ "net/third_party/quiche/src/quiche/quic/core/frames/quic_handshake_done_frame.cc",
+ "net/third_party/quiche/src/quiche/quic/core/frames/quic_max_streams_frame.cc",
+ "net/third_party/quiche/src/quiche/quic/core/frames/quic_message_frame.cc",
+ "net/third_party/quiche/src/quiche/quic/core/frames/quic_new_connection_id_frame.cc",
+ "net/third_party/quiche/src/quiche/quic/core/frames/quic_new_token_frame.cc",
+ "net/third_party/quiche/src/quiche/quic/core/frames/quic_padding_frame.cc",
+ "net/third_party/quiche/src/quiche/quic/core/frames/quic_path_challenge_frame.cc",
+ "net/third_party/quiche/src/quiche/quic/core/frames/quic_path_response_frame.cc",
+ "net/third_party/quiche/src/quiche/quic/core/frames/quic_ping_frame.cc",
+ "net/third_party/quiche/src/quiche/quic/core/frames/quic_retire_connection_id_frame.cc",
+ "net/third_party/quiche/src/quiche/quic/core/frames/quic_rst_stream_frame.cc",
+ "net/third_party/quiche/src/quiche/quic/core/frames/quic_stop_sending_frame.cc",
+ "net/third_party/quiche/src/quiche/quic/core/frames/quic_stop_waiting_frame.cc",
+ "net/third_party/quiche/src/quiche/quic/core/frames/quic_stream_frame.cc",
+ "net/third_party/quiche/src/quiche/quic/core/frames/quic_streams_blocked_frame.cc",
+ "net/third_party/quiche/src/quiche/quic/core/frames/quic_window_update_frame.cc",
+ "net/third_party/quiche/src/quiche/quic/core/http/capsule.cc",
+ "net/third_party/quiche/src/quiche/quic/core/http/http_constants.cc",
+ "net/third_party/quiche/src/quiche/quic/core/http/http_decoder.cc",
+ "net/third_party/quiche/src/quiche/quic/core/http/http_encoder.cc",
+ "net/third_party/quiche/src/quiche/quic/core/http/quic_client_promised_info.cc",
+ "net/third_party/quiche/src/quiche/quic/core/http/quic_client_push_promise_index.cc",
+ "net/third_party/quiche/src/quiche/quic/core/http/quic_header_list.cc",
+ "net/third_party/quiche/src/quiche/quic/core/http/quic_headers_stream.cc",
+ "net/third_party/quiche/src/quiche/quic/core/http/quic_receive_control_stream.cc",
+ "net/third_party/quiche/src/quiche/quic/core/http/quic_send_control_stream.cc",
+ "net/third_party/quiche/src/quiche/quic/core/http/quic_server_initiated_spdy_stream.cc",
+ "net/third_party/quiche/src/quiche/quic/core/http/quic_server_session_base.cc",
+ "net/third_party/quiche/src/quiche/quic/core/http/quic_spdy_client_session.cc",
+ "net/third_party/quiche/src/quiche/quic/core/http/quic_spdy_client_session_base.cc",
+ "net/third_party/quiche/src/quiche/quic/core/http/quic_spdy_client_stream.cc",
+ "net/third_party/quiche/src/quiche/quic/core/http/quic_spdy_session.cc",
+ "net/third_party/quiche/src/quiche/quic/core/http/quic_spdy_stream.cc",
+ "net/third_party/quiche/src/quiche/quic/core/http/quic_spdy_stream_body_manager.cc",
+ "net/third_party/quiche/src/quiche/quic/core/http/spdy_server_push_utils.cc",
+ "net/third_party/quiche/src/quiche/quic/core/http/spdy_utils.cc",
+ "net/third_party/quiche/src/quiche/quic/core/http/web_transport_http3.cc",
+ "net/third_party/quiche/src/quiche/quic/core/http/web_transport_stream_adapter.cc",
+ "net/third_party/quiche/src/quiche/quic/core/legacy_quic_stream_id_manager.cc",
+ "net/third_party/quiche/src/quiche/quic/core/qpack/qpack_blocking_manager.cc",
+ "net/third_party/quiche/src/quiche/quic/core/qpack/qpack_decoded_headers_accumulator.cc",
+ "net/third_party/quiche/src/quiche/quic/core/qpack/qpack_decoder.cc",
+ "net/third_party/quiche/src/quiche/quic/core/qpack/qpack_decoder_stream_receiver.cc",
+ "net/third_party/quiche/src/quiche/quic/core/qpack/qpack_decoder_stream_sender.cc",
+ "net/third_party/quiche/src/quiche/quic/core/qpack/qpack_encoder.cc",
+ "net/third_party/quiche/src/quiche/quic/core/qpack/qpack_encoder_stream_receiver.cc",
+ "net/third_party/quiche/src/quiche/quic/core/qpack/qpack_encoder_stream_sender.cc",
+ "net/third_party/quiche/src/quiche/quic/core/qpack/qpack_header_table.cc",
+ "net/third_party/quiche/src/quiche/quic/core/qpack/qpack_index_conversions.cc",
+ "net/third_party/quiche/src/quiche/quic/core/qpack/qpack_instruction_decoder.cc",
+ "net/third_party/quiche/src/quiche/quic/core/qpack/qpack_instruction_encoder.cc",
+ "net/third_party/quiche/src/quiche/quic/core/qpack/qpack_instructions.cc",
+ "net/third_party/quiche/src/quiche/quic/core/qpack/qpack_progressive_decoder.cc",
+ "net/third_party/quiche/src/quiche/quic/core/qpack/qpack_receive_stream.cc",
+ "net/third_party/quiche/src/quiche/quic/core/qpack/qpack_required_insert_count.cc",
+ "net/third_party/quiche/src/quiche/quic/core/qpack/qpack_send_stream.cc",
+ "net/third_party/quiche/src/quiche/quic/core/qpack/qpack_static_table.cc",
+ "net/third_party/quiche/src/quiche/quic/core/qpack/value_splitting_header_list.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_ack_listener_interface.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_alarm.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_bandwidth.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_chaos_protector.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_clock.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_coalesced_packet.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_config.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_connection.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_connection_context.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_connection_id.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_connection_id_manager.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_connection_stats.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_constants.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_control_frame_manager.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_crypto_client_handshaker.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_crypto_client_stream.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_crypto_handshaker.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_crypto_server_stream.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_crypto_server_stream_base.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_crypto_stream.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_data_reader.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_data_writer.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_datagram_queue.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_error_codes.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_flow_controller.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_framer.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_idle_network_detector.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_legacy_version_encapsulator.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_mtu_discovery.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_network_blackhole_detector.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_packet_creator.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_packet_number.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_packets.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_path_validator.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_ping_manager.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_received_packet_manager.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_sent_packet_manager.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_server_id.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_session.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_socket_address_coder.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_stream.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_stream_id_manager.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_stream_send_buffer.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_stream_sequencer.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_stream_sequencer_buffer.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_sustained_bandwidth_recorder.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_tag.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_time.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_transmission_info.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_types.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_unacked_packet_map.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_utils.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_version_manager.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_versions.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_write_blocked_list.cc",
+ "net/third_party/quiche/src/quiche/quic/core/tls_client_handshaker.cc",
+ "net/third_party/quiche/src/quiche/quic/core/tls_handshaker.cc",
+ "net/third_party/quiche/src/quiche/quic/core/tls_server_handshaker.cc",
+ "net/third_party/quiche/src/quiche/quic/core/uber_quic_stream_id_manager.cc",
+ "net/third_party/quiche/src/quiche/quic/core/uber_received_packet_manager.cc",
+ "net/third_party/quiche/src/quiche/quic/platform/api/quic_socket_address.cc",
+ "net/third_party/quiche/src/quiche/spdy/core/array_output_buffer.cc",
+ "net/third_party/quiche/src/quiche/spdy/core/hpack/hpack_constants.cc",
+ "net/third_party/quiche/src/quiche/spdy/core/hpack/hpack_decoder_adapter.cc",
+ "net/third_party/quiche/src/quiche/spdy/core/hpack/hpack_encoder.cc",
+ "net/third_party/quiche/src/quiche/spdy/core/hpack/hpack_entry.cc",
+ "net/third_party/quiche/src/quiche/spdy/core/hpack/hpack_header_table.cc",
+ "net/third_party/quiche/src/quiche/spdy/core/hpack/hpack_output_stream.cc",
+ "net/third_party/quiche/src/quiche/spdy/core/hpack/hpack_static_table.cc",
+ "net/third_party/quiche/src/quiche/spdy/core/http2_frame_decoder_adapter.cc",
+ "net/third_party/quiche/src/quiche/spdy/core/http2_header_block.cc",
+ "net/third_party/quiche/src/quiche/spdy/core/http2_header_storage.cc",
+ "net/third_party/quiche/src/quiche/spdy/core/recording_headers_handler.cc",
+ "net/third_party/quiche/src/quiche/spdy/core/spdy_alt_svc_wire_format.cc",
+ "net/third_party/quiche/src/quiche/spdy/core/spdy_frame_builder.cc",
+ "net/third_party/quiche/src/quiche/spdy/core/spdy_framer.cc",
+ "net/third_party/quiche/src/quiche/spdy/core/spdy_no_op_visitor.cc",
+ "net/third_party/quiche/src/quiche/spdy/core/spdy_pinnable_buffer_piece.cc",
+ "net/third_party/quiche/src/quiche/spdy/core/spdy_prefixed_buffer_reader.cc",
+ "net/third_party/quiche/src/quiche/spdy/core/spdy_protocol.cc",
+ "net/third_party/quiche/src/quiche/spdy/core/spdy_simple_arena.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_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",
+ "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_net_third_party_quiche_net_quic_proto__testing_gen_headers",
+ ],
+ export_generated_headers: [
+ "cronet_aml_net_third_party_quiche_net_quic_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",
+ "-DHAVE_PTHREAD",
+ "-DHAVE_SYS_UIO_H",
+ "-DIS_QUICHE_IMPL",
+ "-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",
+ "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/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_tool_support__testing
+cc_library_static {
+ name: "cronet_aml_net_third_party_quiche_quiche_tool_support__testing",
+ srcs: [
+ "net/third_party/quiche/overrides/quiche_platform_impl/quiche_command_line_flags_impl.cc",
+ "net/third_party/quiche/overrides/quiche_platform_impl/quiche_default_proof_providers_impl.cc",
+ "net/third_party/quiche/src/quiche/common/platform/api/quiche_file_utils.cc",
+ "net/third_party/quiche/src/quiche/common/platform/default/quiche_platform_impl/quiche_file_utils_impl.cc",
+ "net/third_party/quiche/src/quiche/quic/core/chlo_extractor.cc",
+ "net/third_party/quiche/src/quiche/quic/core/http/quic_spdy_server_stream_base.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_buffered_packet_store.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_dispatcher.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_packet_writer_wrapper.cc",
+ "net/third_party/quiche/src/quiche/quic/core/quic_time_wait_list_manager.cc",
+ "net/third_party/quiche/src/quiche/quic/core/tls_chlo_extractor.cc",
+ "net/third_party/quiche/src/quiche/quic/tools/quic_backend_response.cc",
+ "net/third_party/quiche/src/quiche/quic/tools/quic_client_base.cc",
+ "net/third_party/quiche/src/quiche/quic/tools/quic_memory_cache_backend.cc",
+ "net/third_party/quiche/src/quiche/quic/tools/quic_simple_client_session.cc",
+ "net/third_party/quiche/src/quiche/quic/tools/quic_simple_client_stream.cc",
+ "net/third_party/quiche/src/quiche/quic/tools/quic_simple_crypto_server_stream_helper.cc",
+ "net/third_party/quiche/src/quiche/quic/tools/quic_simple_dispatcher.cc",
+ "net/third_party/quiche/src/quiche/quic/tools/quic_simple_server_session.cc",
+ "net/third_party/quiche/src/quiche/quic/tools/quic_simple_server_stream.cc",
+ "net/third_party/quiche/src/quiche/quic/tools/quic_spdy_client_base.cc",
+ "net/third_party/quiche/src/quiche/quic/tools/quic_tcp_like_trace_converter.cc",
+ "net/third_party/quiche/src/quiche/quic/tools/quic_url.cc",
+ "net/third_party/quiche/src/quiche/quic/tools/simple_ticket_crypter.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_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",
+ "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",
+ ],
+ 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",
+ "-DHAVE_PTHREAD",
+ "-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",
+ "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/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/tools/huffman_trie:huffman_trie_generator_sources__testing
+cc_library_static {
+ name: "cronet_aml_net_tools_huffman_trie_huffman_trie_generator_sources__testing",
+ srcs: [
+ "net/tools/huffman_trie/bit_writer.cc",
+ "net/tools/huffman_trie/huffman/huffman_builder.cc",
+ "net/tools/huffman_trie/trie/trie_bit_buffer.cc",
+ "net/tools/huffman_trie/trie/trie_writer.cc",
+ "net/tools/huffman_trie/trie_entry.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_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: [
+ "./",
+ "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++20",
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+}
+
+// GN: //net/tools/tld_cleanup:tld_cleanup__testing
+cc_library_static {
+ name: "cronet_aml_net_tools_tld_cleanup_tld_cleanup__testing",
+ srcs: [
+ "net/tools/tld_cleanup/tld_cleanup_util.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_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",
+ "cronet_aml_url_url__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: //net/tools/transport_security_state_generator:transport_security_state_generator__testing
+cc_binary {
+ name: "cronet_aml_net_tools_transport_security_state_generator_transport_security_state_generator__testing",
+ srcs: [
+ "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",
+ "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: [
+ "./",
+ "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++20",
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+}
+
+// GN: //net/tools/transport_security_state_generator:transport_security_state_generator_sources__testing
+cc_library_static {
+ name: "cronet_aml_net_tools_transport_security_state_generator_transport_security_state_generator_sources__testing",
+ srcs: [
+ "net/tools/transport_security_state_generator/cert_util.cc",
+ "net/tools/transport_security_state_generator/input_file_parsers.cc",
+ "net/tools/transport_security_state_generator/pinset.cc",
+ "net/tools/transport_security_state_generator/pinsets.cc",
+ "net/tools/transport_security_state_generator/preloaded_state_generator.cc",
+ "net/tools/transport_security_state_generator/spki_hash.cc",
+ "net/tools/transport_security_state_generator/transport_security_state_entry.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_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",
+ "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: [
+ "./",
+ "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++20",
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+}
+
// GN: //net/traffic_annotation:traffic_annotation
-cc_object {
+cc_library_static {
name: "cronet_aml_net_traffic_annotation_traffic_annotation",
srcs: [
"net/traffic_annotation/network_traffic_annotation_android.cc",
@@ -6451,9 +19426,60 @@
"cronet_aml_base_allocator_partition_allocator_partition_alloc",
"cronet_aml_base_base",
"cronet_aml_base_base_static",
+ "cronet_aml_base_nodebug_assertion",
"cronet_aml_base_third_party_double_conversion_double_conversion",
"cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations",
+ "cronet_aml_third_party_abseil_cpp_absl_base_base",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+ "cronet_aml_third_party_abseil_cpp_absl_base_strerror",
+ "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+ "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler",
+ "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_city",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_hash",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+ "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
+ "cronet_aml_third_party_abseil_cpp_absl_random_distributions",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material",
+ "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception",
+ "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences",
+ "cronet_aml_third_party_abseil_cpp_absl_status_status",
+ "cronet_aml_third_party_abseil_cpp_absl_status_statusor",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cord",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+ "cronet_aml_third_party_abseil_cpp_absl_time_time",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access",
+ "cronet_aml_third_party_android_ndk_cpu_features",
+ "cronet_aml_third_party_ashmem_ashmem",
"cronet_aml_third_party_boringssl_boringssl",
+ "cronet_aml_third_party_boringssl_boringssl_asm",
"cronet_aml_third_party_icu_icui18n",
"cronet_aml_third_party_icu_icuuc_private",
"cronet_aml_third_party_libevent_libevent",
@@ -6462,6 +19488,9 @@
generated_headers: [
"cronet_aml_build_chromeos_buildflags",
],
+ export_generated_headers: [
+ "cronet_aml_build_chromeos_buildflags",
+ ],
defaults: [
"cronet_aml_defaults",
],
@@ -6473,6 +19502,7 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-D_FORTIFY_SOURCE=2",
@@ -6481,6 +19511,14 @@
"-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: [
"./",
@@ -6491,7 +19529,40 @@
"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",
@@ -6499,6 +19570,172 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
+ "-msse3",
+ ],
+ },
+ },
+}
+
+// GN: //net/traffic_annotation:traffic_annotation__testing
+cc_library_static {
+ name: "cronet_aml_net_traffic_annotation_traffic_annotation__testing",
+ srcs: [
+ "net/traffic_annotation/network_traffic_annotation_android.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_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",
+ ],
+ export_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",
+ "-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",
],
},
@@ -6519,9 +19756,60 @@
"cronet_aml_base_allocator_partition_allocator_partition_alloc",
"cronet_aml_base_base",
"cronet_aml_base_base_static",
+ "cronet_aml_base_nodebug_assertion",
"cronet_aml_base_third_party_double_conversion_double_conversion",
"cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations",
+ "cronet_aml_third_party_abseil_cpp_absl_base_base",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+ "cronet_aml_third_party_abseil_cpp_absl_base_strerror",
+ "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+ "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler",
+ "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_city",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_hash",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+ "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
+ "cronet_aml_third_party_abseil_cpp_absl_random_distributions",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material",
+ "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception",
+ "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences",
+ "cronet_aml_third_party_abseil_cpp_absl_status_status",
+ "cronet_aml_third_party_abseil_cpp_absl_status_statusor",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cord",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+ "cronet_aml_third_party_abseil_cpp_absl_time_time",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access",
+ "cronet_aml_third_party_android_ndk_cpu_features",
+ "cronet_aml_third_party_ashmem_ashmem",
"cronet_aml_third_party_boringssl_boringssl",
+ "cronet_aml_third_party_boringssl_boringssl_asm",
"cronet_aml_third_party_icu_icui18n",
"cronet_aml_third_party_icu_icuuc_private",
"cronet_aml_third_party_libevent_libevent",
@@ -6539,6 +19827,7 @@
"-DHAVE_SYS_UIO_H",
"-DIS_URI_TEMPLATE_IMPL",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-D_FORTIFY_SOURCE=2",
@@ -6547,6 +19836,14 @@
"-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: [
"./",
@@ -6557,7 +19854,40 @@
"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",
@@ -6565,6 +19895,747 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
+ "-msse3",
+ ],
+ },
+ },
+}
+
+// GN: //net:uri_template__testing
+cc_library_static {
+ name: "cronet_aml_net_uri_template__testing",
+ srcs: [
+ "net/third_party/uri_template/uri_template.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_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",
+ ],
+ 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",
+ "-DIS_URI_TEMPLATE_IMPL",
+ "-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: //testing/android/native_test:native_test_jni_headers__testing
+cc_genrule {
+ name: "cronet_aml_testing_android_native_test_native_test_jni_headers__testing",
+ srcs: [
+ "testing/android/native_test/java/src/org/chromium/native_test/MainRunner.java",
+ "testing/android/native_test/java/src/org/chromium/native_test/NativeTest.java",
+ ],
+ cmd: "$(location base/android/jni_generator/jni_generator.py) --ptr_type " +
+ "long " +
+ "--output_dir " +
+ "$(genDir)/testing/android/native_test/native_test_jni_headers " +
+ "--includes " +
+ "base/android/jni_generator/jni_generator_helper.h " +
+ "--use_proxy_hash " +
+ "--output_name " +
+ "MainRunner_jni.h " +
+ "--output_name " +
+ "NativeTest_jni.h " +
+ "--input_file " +
+ "$(location testing/android/native_test/java/src/org/chromium/native_test/MainRunner.java) " +
+ "--input_file " +
+ "$(location testing/android/native_test/java/src/org/chromium/native_test/NativeTest.java)",
+ out: [
+ "testing/android/native_test/native_test_jni_headers/MainRunner_jni.h",
+ "testing/android/native_test/native_test_jni_headers/NativeTest_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: //testing/android/native_test:native_test_native_code__testing
+cc_library_static {
+ name: "cronet_aml_testing_android_native_test_native_test_native_code__testing",
+ srcs: [
+ "testing/android/native_test/native_test_jni_onload.cc",
+ ],
+ 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_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",
+ "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",
+ ],
+ 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: //testing/android/native_test:native_test_support__testing
+cc_library_static {
+ name: "cronet_aml_testing_android_native_test_native_test_support__testing",
+ srcs: [
+ "testing/android/native_test/main_runner.cc",
+ "testing/android/native_test/native_test_launcher.cc",
+ "testing/android/native_test/native_test_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_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",
+ "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",
+ ],
+ 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",
+ ],
+ 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",
+ ],
+ 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",
+ "-DGTEST_API_=",
+ "-DGTEST_HAS_ABSL=1",
+ "-DGTEST_HAS_POSIX_RE=0",
+ "-DGTEST_HAS_TR1_TUPLE=0",
+ "-DGTEST_LANG_CXX11=1",
+ "-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",
+ "-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",
+ "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/",
+ ],
+ 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: //testing/gtest:gtest__testing
+cc_library_static {
+ name: "cronet_aml_testing_gtest_gtest__testing",
+ srcs: [
+ "testing/gtest/empty.cc",
+ "testing/multiprocess_func_list.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_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",
+ ],
+ 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",
+ "-DGTEST_API_=",
+ "-DGTEST_HAS_ABSL=1",
+ "-DGTEST_HAS_POSIX_RE=0",
+ "-DGTEST_HAS_TR1_TUPLE=0",
+ "-DGTEST_LANG_CXX11=1",
+ "-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",
+ "third_party/abseil-cpp/",
+ "third_party/googletest/custom/",
+ "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: [
+ "-fstack-protector",
+ ],
+ },
+ android_arm64: {
+ cflags: [
+ "-fstack-protector",
+ "-mno-outline",
+ "-mno-outline-atomics",
+ ],
+ },
+ android_x86: {
+ cflags: [
+ "-msse3",
+ ],
+ },
+ android_x86_64: {
+ cflags: [
+ "-fstack-protector",
"-msse3",
],
},
@@ -6572,7 +20643,7 @@
}
// GN: //third_party/abseil-cpp/absl/base:base
-cc_object {
+cc_library_static {
name: "cronet_aml_third_party_abseil_cpp_absl_base_base",
srcs: [
"third_party/abseil-cpp/absl/base/internal/cycleclock.cc",
@@ -6581,6 +20652,11 @@
"third_party/abseil-cpp/absl/base/internal/thread_identity.cc",
"third_party/abseil-cpp/absl/base/internal/unscaledcycleclock.cc",
],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+ ],
defaults: [
"cronet_aml_defaults",
],
@@ -6593,11 +20669,20 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-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: [
"./",
@@ -6607,7 +20692,24 @@
"third_party/abseil-cpp/",
],
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",
@@ -6615,14 +20717,124 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //third_party/abseil-cpp/absl/base:base__testing
+cc_library_static {
+ name: "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+ srcs: [
+ "third_party/abseil-cpp/absl/base/internal/cycleclock.cc",
+ "third_party/abseil-cpp/absl/base/internal/spinlock.cc",
+ "third_party/abseil-cpp/absl/base/internal/sysinfo.cc",
+ "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",
+ ],
+ cflags: [
+ "-DABSL_ALLOCATOR_NOTHROW=1",
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-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/",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ 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: //third_party/abseil-cpp/absl/base:log_severity
-cc_object {
+cc_library_static {
name: "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
srcs: [
"third_party/abseil-cpp/absl/base/log_severity.cc",
@@ -6639,11 +20851,20 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-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: [
"./",
@@ -6653,7 +20874,24 @@
"third_party/abseil-cpp/",
],
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",
@@ -6661,18 +20899,125 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //third_party/abseil-cpp/absl/base:log_severity__testing
+cc_library_static {
+ name: "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+ srcs: [
+ "third_party/abseil-cpp/absl/base/log_severity.cc",
+ ],
+ host_supported: true,
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DABSL_ALLOCATOR_NOTHROW=1",
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-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/",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ 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: //third_party/abseil-cpp/absl/base:malloc_internal
-cc_object {
+cc_library_static {
name: "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
srcs: [
"third_party/abseil-cpp/absl/base/internal/low_level_alloc.cc",
],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_base",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+ ],
defaults: [
"cronet_aml_defaults",
],
@@ -6685,11 +21030,20 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-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: [
"./",
@@ -6699,7 +21053,24 @@
"third_party/abseil-cpp/",
],
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",
@@ -6707,18 +21078,128 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //third_party/abseil-cpp/absl/base:malloc_internal__testing
+cc_library_static {
+ name: "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+ srcs: [
+ "third_party/abseil-cpp/absl/base/internal/low_level_alloc.cc",
+ ],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+ ],
+ host_supported: true,
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DABSL_ALLOCATOR_NOTHROW=1",
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-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/",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ 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: //third_party/abseil-cpp/absl/base:raw_logging_internal
-cc_object {
+cc_library_static {
name: "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
srcs: [
"third_party/abseil-cpp/absl/base/internal/raw_logging.cc",
],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ ],
defaults: [
"cronet_aml_defaults",
],
@@ -6731,11 +21212,20 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-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: [
"./",
@@ -6745,7 +21235,24 @@
"third_party/abseil-cpp/",
],
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",
@@ -6753,14 +21260,118 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //third_party/abseil-cpp/absl/base:raw_logging_internal__testing
+cc_library_static {
+ name: "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+ srcs: [
+ "third_party/abseil-cpp/absl/base/internal/raw_logging.cc",
+ ],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+ ],
+ host_supported: true,
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DABSL_ALLOCATOR_NOTHROW=1",
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-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/",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ 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: //third_party/abseil-cpp/absl/base:spinlock_wait
-cc_object {
+cc_library_static {
name: "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
srcs: [
"third_party/abseil-cpp/absl/base/internal/spinlock_wait.cc",
@@ -6777,11 +21388,20 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-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: [
"./",
@@ -6791,7 +21411,24 @@
"third_party/abseil-cpp/",
],
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",
@@ -6799,14 +21436,115 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //third_party/abseil-cpp/absl/base:spinlock_wait__testing
+cc_library_static {
+ name: "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+ srcs: [
+ "third_party/abseil-cpp/absl/base/internal/spinlock_wait.cc",
+ ],
+ host_supported: true,
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DABSL_ALLOCATOR_NOTHROW=1",
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-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/",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ 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: //third_party/abseil-cpp/absl/base:strerror
-cc_object {
+cc_library_static {
name: "cronet_aml_third_party_abseil_cpp_absl_base_strerror",
srcs: [
"third_party/abseil-cpp/absl/base/internal/strerror.cc",
@@ -6823,11 +21561,20 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-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: [
"./",
@@ -6837,7 +21584,24 @@
"third_party/abseil-cpp/",
],
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",
@@ -6845,18 +21609,123 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //third_party/abseil-cpp/absl/base:strerror__testing
+cc_library_static {
+ name: "cronet_aml_third_party_abseil_cpp_absl_base_strerror__testing",
+ srcs: [
+ "third_party/abseil-cpp/absl/base/internal/strerror.cc",
+ ],
+ host_supported: true,
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DABSL_ALLOCATOR_NOTHROW=1",
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-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/",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ 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: //third_party/abseil-cpp/absl/base:throw_delegate
-cc_object {
+cc_library_static {
name: "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
srcs: [
"third_party/abseil-cpp/absl/base/internal/throw_delegate.cc",
],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+ ],
defaults: [
"cronet_aml_defaults",
],
@@ -6869,11 +21738,20 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-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: [
"./",
@@ -6883,7 +21761,24 @@
"third_party/abseil-cpp/",
],
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",
@@ -6891,19 +21786,145 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //third_party/abseil-cpp/absl/base:throw_delegate__testing
+cc_library_static {
+ name: "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+ srcs: [
+ "third_party/abseil-cpp/absl/base/internal/throw_delegate.cc",
+ ],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+ ],
+ host_supported: true,
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DABSL_ALLOCATOR_NOTHROW=1",
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-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/",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ 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: //third_party/abseil-cpp/absl/container:hashtablez_sampler
-cc_object {
+cc_library_static {
name: "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler",
srcs: [
"third_party/abseil-cpp/absl/container/internal/hashtablez_sampler.cc",
"third_party/abseil-cpp/absl/container/internal/hashtablez_sampler_force_weak_definition.cc",
],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_base",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+ "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+ "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+ "cronet_aml_third_party_abseil_cpp_absl_time_time",
+ ],
defaults: [
"cronet_aml_defaults",
],
@@ -6916,11 +21937,20 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-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: [
"./",
@@ -6930,7 +21960,24 @@
"third_party/abseil-cpp/",
],
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",
@@ -6938,18 +21985,164 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //third_party/abseil-cpp/absl/container:hashtablez_sampler__testing
+cc_library_static {
+ name: "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler__testing",
+ srcs: [
+ "third_party/abseil-cpp/absl/container/internal/hashtablez_sampler.cc",
+ "third_party/abseil-cpp/absl/container/internal/hashtablez_sampler_force_weak_definition.cc",
+ ],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+ ],
+ host_supported: true,
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DABSL_ALLOCATOR_NOTHROW=1",
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-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/",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ 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: //third_party/abseil-cpp/absl/container:raw_hash_set
-cc_object {
+cc_library_static {
name: "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set",
srcs: [
"third_party/abseil-cpp/absl/container/internal/raw_hash_set.cc",
],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_base",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+ "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+ "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+ "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+ "cronet_aml_third_party_abseil_cpp_absl_time_time",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
+ ],
defaults: [
"cronet_aml_defaults",
],
@@ -6962,11 +22155,20 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-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: [
"./",
@@ -6976,7 +22178,24 @@
"third_party/abseil-cpp/",
],
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",
@@ -6984,20 +22203,148 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //third_party/abseil-cpp/absl/container:raw_hash_set__testing
+cc_library_static {
+ name: "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set__testing",
+ srcs: [
+ "third_party/abseil-cpp/absl/container/internal/raw_hash_set.cc",
+ ],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+ ],
+ host_supported: true,
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DABSL_ALLOCATOR_NOTHROW=1",
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-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/",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ 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: //third_party/abseil-cpp/absl/debugging:debugging_internal
-cc_object {
+cc_library_static {
name: "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
srcs: [
"third_party/abseil-cpp/absl/debugging/internal/address_is_readable.cc",
"third_party/abseil-cpp/absl/debugging/internal/elf_mem_image.cc",
"third_party/abseil-cpp/absl/debugging/internal/vdso_support.cc",
],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+ ],
defaults: [
"cronet_aml_defaults",
],
@@ -7010,11 +22357,20 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-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: [
"./",
@@ -7024,7 +22380,24 @@
"third_party/abseil-cpp/",
],
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",
@@ -7032,18 +22405,131 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //third_party/abseil-cpp/absl/debugging:debugging_internal__testing
+cc_library_static {
+ name: "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+ srcs: [
+ "third_party/abseil-cpp/absl/debugging/internal/address_is_readable.cc",
+ "third_party/abseil-cpp/absl/debugging/internal/elf_mem_image.cc",
+ "third_party/abseil-cpp/absl/debugging/internal/vdso_support.cc",
+ ],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+ ],
+ host_supported: true,
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DABSL_ALLOCATOR_NOTHROW=1",
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-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/",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ 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: //third_party/abseil-cpp/absl/debugging:demangle_internal
-cc_object {
+cc_library_static {
name: "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
srcs: [
"third_party/abseil-cpp/absl/debugging/internal/demangle.cc",
],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_base",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+ ],
defaults: [
"cronet_aml_defaults",
],
@@ -7056,11 +22542,20 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-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: [
"./",
@@ -7070,7 +22565,24 @@
"third_party/abseil-cpp/",
],
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",
@@ -7078,18 +22590,140 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //third_party/abseil-cpp/absl/debugging:demangle_internal__testing
+cc_library_static {
+ name: "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+ srcs: [
+ "third_party/abseil-cpp/absl/debugging/internal/demangle.cc",
+ ],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+ ],
+ host_supported: true,
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DABSL_ALLOCATOR_NOTHROW=1",
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-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/",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ 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: //third_party/abseil-cpp/absl/debugging:examine_stack
-cc_object {
+cc_library_static {
name: "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack",
srcs: [
"third_party/abseil-cpp/absl/debugging/internal/examine_stack.cc",
],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_base",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+ "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+ ],
defaults: [
"cronet_aml_defaults",
],
@@ -7102,11 +22736,20 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-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: [
"./",
@@ -7116,7 +22759,24 @@
"third_party/abseil-cpp/",
],
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",
@@ -7124,18 +22784,150 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //third_party/abseil-cpp/absl/debugging:examine_stack__testing
+cc_library_static {
+ name: "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack__testing",
+ srcs: [
+ "third_party/abseil-cpp/absl/debugging/internal/examine_stack.cc",
+ ],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+ ],
+ host_supported: true,
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DABSL_ALLOCATOR_NOTHROW=1",
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-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/",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ 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: //third_party/abseil-cpp/absl/debugging:failure_signal_handler
-cc_object {
+cc_library_static {
name: "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler",
srcs: [
"third_party/abseil-cpp/absl/debugging/failure_signal_handler.cc",
],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_base",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+ "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+ ],
defaults: [
"cronet_aml_defaults",
],
@@ -7148,11 +22940,20 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-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: [
"./",
@@ -7162,7 +22963,24 @@
"third_party/abseil-cpp/",
],
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",
@@ -7170,18 +22988,140 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //third_party/abseil-cpp/absl/debugging:failure_signal_handler__testing
+cc_library_static {
+ name: "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler__testing",
+ srcs: [
+ "third_party/abseil-cpp/absl/debugging/failure_signal_handler.cc",
+ ],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+ ],
+ host_supported: true,
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DABSL_ALLOCATOR_NOTHROW=1",
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-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/",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ 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: //third_party/abseil-cpp/absl/debugging:stacktrace
-cc_object {
+cc_library_static {
name: "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
srcs: [
"third_party/abseil-cpp/absl/debugging/stacktrace.cc",
],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+ ],
defaults: [
"cronet_aml_defaults",
],
@@ -7194,11 +23134,20 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-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: [
"./",
@@ -7208,7 +23157,24 @@
"third_party/abseil-cpp/",
],
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",
@@ -7216,18 +23182,137 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //third_party/abseil-cpp/absl/debugging:stacktrace__testing
+cc_library_static {
+ name: "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+ srcs: [
+ "third_party/abseil-cpp/absl/debugging/stacktrace.cc",
+ ],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+ ],
+ host_supported: true,
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DABSL_ALLOCATOR_NOTHROW=1",
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-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/",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ 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: //third_party/abseil-cpp/absl/debugging:symbolize
-cc_object {
+cc_library_static {
name: "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
srcs: [
"third_party/abseil-cpp/absl/debugging/symbolize.cc",
],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_base",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+ "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+ ],
defaults: [
"cronet_aml_defaults",
],
@@ -7240,11 +23325,20 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-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: [
"./",
@@ -7254,7 +23348,24 @@
"third_party/abseil-cpp/",
],
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",
@@ -7262,18 +23373,138 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //third_party/abseil-cpp/absl/debugging:symbolize__testing
+cc_library_static {
+ name: "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+ srcs: [
+ "third_party/abseil-cpp/absl/debugging/symbolize.cc",
+ ],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+ ],
+ host_supported: true,
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DABSL_ALLOCATOR_NOTHROW=1",
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-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/",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ 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: //third_party/abseil-cpp/absl/hash:city
-cc_object {
+cc_library_static {
name: "cronet_aml_third_party_abseil_cpp_absl_hash_city",
srcs: [
"third_party/abseil-cpp/absl/hash/internal/city.cc",
],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_base",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+ ],
defaults: [
"cronet_aml_defaults",
],
@@ -7286,11 +23517,20 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-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: [
"./",
@@ -7300,7 +23540,24 @@
"third_party/abseil-cpp/",
],
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",
@@ -7308,18 +23565,139 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //third_party/abseil-cpp/absl/hash:city__testing
+cc_library_static {
+ name: "cronet_aml_third_party_abseil_cpp_absl_hash_city__testing",
+ srcs: [
+ "third_party/abseil-cpp/absl/hash/internal/city.cc",
+ ],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+ ],
+ host_supported: true,
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DABSL_ALLOCATOR_NOTHROW=1",
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-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/",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ 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: //third_party/abseil-cpp/absl/hash:hash
-cc_object {
+cc_library_static {
name: "cronet_aml_third_party_abseil_cpp_absl_hash_hash",
srcs: [
"third_party/abseil-cpp/absl/hash/internal/hash.cc",
],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_base",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+ "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_city",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access",
+ ],
defaults: [
"cronet_aml_defaults",
],
@@ -7332,11 +23710,20 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-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: [
"./",
@@ -7346,7 +23733,24 @@
"third_party/abseil-cpp/",
],
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",
@@ -7354,18 +23758,140 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //third_party/abseil-cpp/absl/hash:hash__testing
+cc_library_static {
+ name: "cronet_aml_third_party_abseil_cpp_absl_hash_hash__testing",
+ srcs: [
+ "third_party/abseil-cpp/absl/hash/internal/hash.cc",
+ ],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_city__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access__testing",
+ ],
+ host_supported: true,
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DABSL_ALLOCATOR_NOTHROW=1",
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-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/",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ 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: //third_party/abseil-cpp/absl/hash:low_level_hash
-cc_object {
+cc_library_static {
name: "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash",
srcs: [
"third_party/abseil-cpp/absl/hash/internal/low_level_hash.cc",
],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_base",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+ ],
defaults: [
"cronet_aml_defaults",
],
@@ -7378,11 +23904,20 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-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: [
"./",
@@ -7392,7 +23927,24 @@
"third_party/abseil-cpp/",
],
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",
@@ -7400,14 +23952,122 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //third_party/abseil-cpp/absl/hash:low_level_hash__testing
+cc_library_static {
+ name: "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash__testing",
+ srcs: [
+ "third_party/abseil-cpp/absl/hash/internal/low_level_hash.cc",
+ ],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+ ],
+ host_supported: true,
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DABSL_ALLOCATOR_NOTHROW=1",
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-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/",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ 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: //third_party/abseil-cpp/absl/numeric:int128
-cc_object {
+cc_library_static {
name: "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
srcs: [
"third_party/abseil-cpp/absl/numeric/int128.cc",
@@ -7424,11 +24084,20 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-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: [
"./",
@@ -7438,7 +24107,24 @@
"third_party/abseil-cpp/",
],
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",
@@ -7446,14 +24132,115 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //third_party/abseil-cpp/absl/numeric:int128__testing
+cc_library_static {
+ name: "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+ srcs: [
+ "third_party/abseil-cpp/absl/numeric/int128.cc",
+ ],
+ host_supported: true,
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DABSL_ALLOCATOR_NOTHROW=1",
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-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/",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ 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: //third_party/abseil-cpp/absl/profiling:exponential_biased
-cc_object {
+cc_library_static {
name: "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
srcs: [
"third_party/abseil-cpp/absl/profiling/internal/exponential_biased.cc",
@@ -7470,11 +24257,20 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-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: [
"./",
@@ -7484,7 +24280,24 @@
"third_party/abseil-cpp/",
],
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",
@@ -7492,19 +24305,130 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //third_party/abseil-cpp/absl/profiling:exponential_biased__testing
+cc_library_static {
+ name: "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
+ srcs: [
+ "third_party/abseil-cpp/absl/profiling/internal/exponential_biased.cc",
+ ],
+ host_supported: true,
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DABSL_ALLOCATOR_NOTHROW=1",
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-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/",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ 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: //third_party/abseil-cpp/absl/random:distributions
-cc_object {
+cc_library_static {
name: "cronet_aml_third_party_abseil_cpp_absl_random_distributions",
srcs: [
"third_party/abseil-cpp/absl/random/discrete_distribution.cc",
"third_party/abseil-cpp/absl/random/gaussian_distribution.cc",
],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_base",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+ "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+ ],
defaults: [
"cronet_aml_defaults",
],
@@ -7517,11 +24441,20 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-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: [
"./",
@@ -7531,7 +24464,24 @@
"third_party/abseil-cpp/",
],
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",
@@ -7539,14 +24489,126 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //third_party/abseil-cpp/absl/random:distributions__testing
+cc_library_static {
+ name: "cronet_aml_third_party_abseil_cpp_absl_random_distributions__testing",
+ srcs: [
+ "third_party/abseil-cpp/absl/random/discrete_distribution.cc",
+ "third_party/abseil-cpp/absl/random/gaussian_distribution.cc",
+ ],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+ ],
+ host_supported: true,
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DABSL_ALLOCATOR_NOTHROW=1",
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-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/",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ 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: //third_party/abseil-cpp/absl/random/internal:platform
-cc_object {
+cc_library_static {
name: "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
srcs: [
"third_party/abseil-cpp/absl/random/internal/randen_round_keys.cc",
@@ -7554,6 +24616,9 @@
generated_headers: [
"cronet_aml_build_chromeos_buildflags",
],
+ export_generated_headers: [
+ "cronet_aml_build_chromeos_buildflags",
+ ],
defaults: [
"cronet_aml_defaults",
],
@@ -7566,11 +24631,20 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-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: [
"./",
@@ -7580,7 +24654,24 @@
"third_party/abseil-cpp/",
],
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",
@@ -7588,20 +24679,142 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //third_party/abseil-cpp/absl/random/internal:platform__testing
+cc_library_static {
+ name: "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
+ srcs: [
+ "third_party/abseil-cpp/absl/random/internal/randen_round_keys.cc",
+ ],
+ host_supported: true,
+ generated_headers: [
+ "cronet_aml_build_chromeos_buildflags__testing",
+ ],
+ export_generated_headers: [
+ "cronet_aml_build_chromeos_buildflags__testing",
+ ],
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DABSL_ALLOCATOR_NOTHROW=1",
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-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/",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ 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: //third_party/abseil-cpp/absl/random/internal:pool_urbg
-cc_object {
+cc_library_static {
name: "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg",
srcs: [
"third_party/abseil-cpp/absl/random/internal/pool_urbg.cc",
],
- generated_headers: [
- "cronet_aml_build_chromeos_buildflags",
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_base",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+ "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material",
+ "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
],
defaults: [
"cronet_aml_defaults",
@@ -7615,11 +24828,20 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-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: [
"./",
@@ -7629,7 +24851,24 @@
"third_party/abseil-cpp/",
],
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",
@@ -7637,20 +24876,147 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //third_party/abseil-cpp/absl/random/internal:pool_urbg__testing
+cc_library_static {
+ name: "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg__testing",
+ srcs: [
+ "third_party/abseil-cpp/absl/random/internal/pool_urbg.cc",
+ ],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+ ],
+ host_supported: true,
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DABSL_ALLOCATOR_NOTHROW=1",
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-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/",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ 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: //third_party/abseil-cpp/absl/random/internal:randen
-cc_object {
+cc_library_static {
name: "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen",
srcs: [
"third_party/abseil-cpp/absl/random/internal/randen.cc",
],
- generated_headers: [
- "cronet_aml_build_chromeos_buildflags",
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_base",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow",
],
defaults: [
"cronet_aml_defaults",
@@ -7664,11 +25030,20 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-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: [
"./",
@@ -7678,7 +25053,24 @@
"third_party/abseil-cpp/",
],
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",
@@ -7686,20 +25078,134 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //third_party/abseil-cpp/absl/random/internal:randen__testing
+cc_library_static {
+ name: "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen__testing",
+ srcs: [
+ "third_party/abseil-cpp/absl/random/internal/randen.cc",
+ ],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
+ ],
+ host_supported: true,
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DABSL_ALLOCATOR_NOTHROW=1",
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-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/",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ 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: //third_party/abseil-cpp/absl/random/internal:randen_hwaes
-cc_object {
+cc_library_static {
name: "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes",
srcs: [
"third_party/abseil-cpp/absl/random/internal/randen_detect.cc",
],
- generated_headers: [
- "cronet_aml_build_chromeos_buildflags",
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl",
],
defaults: [
"cronet_aml_defaults",
@@ -7713,11 +25219,20 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-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: [
"./",
@@ -7727,7 +25242,24 @@
"third_party/abseil-cpp/",
],
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",
@@ -7735,20 +25267,127 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //third_party/abseil-cpp/absl/random/internal:randen_hwaes__testing
+cc_library_static {
+ name: "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
+ srcs: [
+ "third_party/abseil-cpp/absl/random/internal/randen_detect.cc",
+ ],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
+ ],
+ host_supported: true,
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DABSL_ALLOCATOR_NOTHROW=1",
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-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/",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ 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: //third_party/abseil-cpp/absl/random/internal:randen_hwaes_impl
-cc_object {
+cc_library_static {
name: "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl",
srcs: [
"third_party/abseil-cpp/absl/random/internal/randen_hwaes.cc",
],
- generated_headers: [
- "cronet_aml_build_chromeos_buildflags",
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
],
defaults: [
"cronet_aml_defaults",
@@ -7762,11 +25401,20 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-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: [
"./",
@@ -7776,7 +25424,24 @@
"third_party/abseil-cpp/",
],
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",
@@ -7784,20 +25449,130 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //third_party/abseil-cpp/absl/random/internal:randen_hwaes_impl__testing
+cc_library_static {
+ name: "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
+ srcs: [
+ "third_party/abseil-cpp/absl/random/internal/randen_hwaes.cc",
+ ],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
+ ],
+ host_supported: true,
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DABSL_ALLOCATOR_NOTHROW=1",
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-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/",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ 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: //third_party/abseil-cpp/absl/random/internal:randen_slow
-cc_object {
+cc_library_static {
name: "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow",
srcs: [
"third_party/abseil-cpp/absl/random/internal/randen_slow.cc",
],
- generated_headers: [
- "cronet_aml_build_chromeos_buildflags",
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_base",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
],
defaults: [
"cronet_aml_defaults",
@@ -7811,11 +25586,20 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-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: [
"./",
@@ -7825,7 +25609,24 @@
"third_party/abseil-cpp/",
],
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",
@@ -7833,18 +25634,138 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //third_party/abseil-cpp/absl/random/internal:randen_slow__testing
+cc_library_static {
+ name: "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
+ srcs: [
+ "third_party/abseil-cpp/absl/random/internal/randen_slow.cc",
+ ],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
+ ],
+ host_supported: true,
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DABSL_ALLOCATOR_NOTHROW=1",
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-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/",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ 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: //third_party/abseil-cpp/absl/random/internal:seed_material
-cc_object {
+cc_library_static {
name: "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material",
srcs: [
"third_party/abseil-cpp/absl/random/internal/seed_material.cc",
],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_base",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+ "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
+ ],
defaults: [
"cronet_aml_defaults",
],
@@ -7857,11 +25778,20 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-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: [
"./",
@@ -7871,7 +25801,24 @@
"third_party/abseil-cpp/",
],
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",
@@ -7879,14 +25826,126 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //third_party/abseil-cpp/absl/random/internal:seed_material__testing
+cc_library_static {
+ name: "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material__testing",
+ srcs: [
+ "third_party/abseil-cpp/absl/random/internal/seed_material.cc",
+ ],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+ ],
+ host_supported: true,
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DABSL_ALLOCATOR_NOTHROW=1",
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-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/",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ 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: //third_party/abseil-cpp/absl/random:seed_gen_exception
-cc_object {
+cc_library_static {
name: "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception",
srcs: [
"third_party/abseil-cpp/absl/random/seed_gen_exception.cc",
@@ -7903,11 +25962,20 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-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: [
"./",
@@ -7917,7 +25985,24 @@
"third_party/abseil-cpp/",
],
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",
@@ -7925,20 +26010,137 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //third_party/abseil-cpp/absl/random:seed_gen_exception__testing
+cc_library_static {
+ name: "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception__testing",
+ srcs: [
+ "third_party/abseil-cpp/absl/random/seed_gen_exception.cc",
+ ],
+ host_supported: true,
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DABSL_ALLOCATOR_NOTHROW=1",
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-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/",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ 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: //third_party/abseil-cpp/absl/random:seed_sequences
-cc_object {
+cc_library_static {
name: "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences",
srcs: [
"third_party/abseil-cpp/absl/random/seed_sequences.cc",
],
- generated_headers: [
- "cronet_aml_build_chromeos_buildflags",
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_base",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+ "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material",
+ "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
],
defaults: [
"cronet_aml_defaults",
@@ -7952,11 +26154,20 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-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: [
"./",
@@ -7966,7 +26177,24 @@
"third_party/abseil-cpp/",
],
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",
@@ -7974,19 +26202,168 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //third_party/abseil-cpp/absl/random:seed_sequences__testing
+cc_library_static {
+ name: "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences__testing",
+ srcs: [
+ "third_party/abseil-cpp/absl/random/seed_sequences.cc",
+ ],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+ ],
+ host_supported: true,
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DABSL_ALLOCATOR_NOTHROW=1",
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-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/",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ 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: //third_party/abseil-cpp/absl/status:status
-cc_object {
+cc_library_static {
name: "cronet_aml_third_party_abseil_cpp_absl_status_status",
srcs: [
"third_party/abseil-cpp/absl/status/status.cc",
"third_party/abseil-cpp/absl/status/status_payload_printer.cc",
],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_base",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+ "cronet_aml_third_party_abseil_cpp_absl_base_strerror",
+ "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+ "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cord",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+ "cronet_aml_third_party_abseil_cpp_absl_time_time",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
+ ],
defaults: [
"cronet_aml_defaults",
],
@@ -7999,11 +26376,20 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-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: [
"./",
@@ -8013,7 +26399,24 @@
"third_party/abseil-cpp/",
],
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",
@@ -8021,18 +26424,180 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //third_party/abseil-cpp/absl/status:status__testing
+cc_library_static {
+ name: "cronet_aml_third_party_abseil_cpp_absl_status_status__testing",
+ srcs: [
+ "third_party/abseil-cpp/absl/status/status.cc",
+ "third_party/abseil-cpp/absl/status/status_payload_printer.cc",
+ ],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_strerror__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cord__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+ ],
+ host_supported: true,
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DABSL_ALLOCATOR_NOTHROW=1",
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-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/",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ 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: //third_party/abseil-cpp/absl/status:statusor
-cc_object {
+cc_library_static {
name: "cronet_aml_third_party_abseil_cpp_absl_status_statusor",
srcs: [
"third_party/abseil-cpp/absl/status/statusor.cc",
],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_base",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+ "cronet_aml_third_party_abseil_cpp_absl_base_strerror",
+ "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+ "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
+ "cronet_aml_third_party_abseil_cpp_absl_status_status",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cord",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+ "cronet_aml_third_party_abseil_cpp_absl_time_time",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access",
+ ],
defaults: [
"cronet_aml_defaults",
],
@@ -8045,11 +26610,20 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-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: [
"./",
@@ -8059,7 +26633,24 @@
"third_party/abseil-cpp/",
],
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",
@@ -8067,20 +26658,179 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //third_party/abseil-cpp/absl/status:statusor__testing
+cc_library_static {
+ name: "cronet_aml_third_party_abseil_cpp_absl_status_statusor__testing",
+ srcs: [
+ "third_party/abseil-cpp/absl/status/statusor.cc",
+ ],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_strerror__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_status_status__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cord__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access__testing",
+ ],
+ host_supported: true,
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DABSL_ALLOCATOR_NOTHROW=1",
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-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/",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ 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: //third_party/abseil-cpp/absl/strings:cord
-cc_object {
+cc_library_static {
name: "cronet_aml_third_party_abseil_cpp_absl_strings_cord",
srcs: [
"third_party/abseil-cpp/absl/strings/cord.cc",
"third_party/abseil-cpp/absl/strings/cord_analysis.cc",
"third_party/abseil-cpp/absl/strings/cord_buffer.cc",
],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_base",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+ "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+ "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+ "cronet_aml_third_party_abseil_cpp_absl_time_time",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
+ ],
defaults: [
"cronet_aml_defaults",
],
@@ -8093,11 +26843,20 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-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: [
"./",
@@ -8107,7 +26866,24 @@
"third_party/abseil-cpp/",
],
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",
@@ -8115,14 +26891,144 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //third_party/abseil-cpp/absl/strings:cord__testing
+cc_library_static {
+ name: "cronet_aml_third_party_abseil_cpp_absl_strings_cord__testing",
+ srcs: [
+ "third_party/abseil-cpp/absl/strings/cord.cc",
+ "third_party/abseil-cpp/absl/strings/cord_analysis.cc",
+ "third_party/abseil-cpp/absl/strings/cord_buffer.cc",
+ ],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+ ],
+ host_supported: true,
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DABSL_ALLOCATOR_NOTHROW=1",
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-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/",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ 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: //third_party/abseil-cpp/absl/strings:cord_internal
-cc_object {
+cc_library_static {
name: "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal",
srcs: [
"third_party/abseil-cpp/absl/strings/internal/cord_internal.cc",
@@ -8133,6 +27039,16 @@
"third_party/abseil-cpp/absl/strings/internal/cord_rep_crc.cc",
"third_party/abseil-cpp/absl/strings/internal/cord_rep_ring.cc",
],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_base",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+ "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+ ],
defaults: [
"cronet_aml_defaults",
],
@@ -8145,11 +27061,20 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-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: [
"./",
@@ -8159,7 +27084,24 @@
"third_party/abseil-cpp/",
],
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",
@@ -8167,18 +27109,140 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //third_party/abseil-cpp/absl/strings:cord_internal__testing
+cc_library_static {
+ name: "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
+ srcs: [
+ "third_party/abseil-cpp/absl/strings/internal/cord_internal.cc",
+ "third_party/abseil-cpp/absl/strings/internal/cord_rep_btree.cc",
+ "third_party/abseil-cpp/absl/strings/internal/cord_rep_btree_navigator.cc",
+ "third_party/abseil-cpp/absl/strings/internal/cord_rep_btree_reader.cc",
+ "third_party/abseil-cpp/absl/strings/internal/cord_rep_consume.cc",
+ "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",
+ ],
+ cflags: [
+ "-DABSL_ALLOCATOR_NOTHROW=1",
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-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/",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ 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: //third_party/abseil-cpp/absl/strings:cordz_functions
-cc_object {
+cc_library_static {
name: "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions",
srcs: [
"third_party/abseil-cpp/absl/strings/internal/cordz_functions.cc",
],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
+ ],
defaults: [
"cronet_aml_defaults",
],
@@ -8191,11 +27255,20 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-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: [
"./",
@@ -8205,7 +27278,24 @@
"third_party/abseil-cpp/",
],
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",
@@ -8213,18 +27303,144 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //third_party/abseil-cpp/absl/strings:cordz_functions__testing
+cc_library_static {
+ name: "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
+ srcs: [
+ "third_party/abseil-cpp/absl/strings/internal/cordz_functions.cc",
+ ],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
+ ],
+ host_supported: true,
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DABSL_ALLOCATOR_NOTHROW=1",
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-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/",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ 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: //third_party/abseil-cpp/absl/strings:cordz_handle
-cc_object {
+cc_library_static {
name: "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle",
srcs: [
"third_party/abseil-cpp/absl/strings/internal/cordz_handle.cc",
],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_base",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+ "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+ "cronet_aml_third_party_abseil_cpp_absl_time_time",
+ ],
defaults: [
"cronet_aml_defaults",
],
@@ -8237,11 +27453,20 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-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: [
"./",
@@ -8251,7 +27476,24 @@
"third_party/abseil-cpp/",
],
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",
@@ -8259,18 +27501,163 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //third_party/abseil-cpp/absl/strings:cordz_handle__testing
+cc_library_static {
+ name: "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
+ srcs: [
+ "third_party/abseil-cpp/absl/strings/internal/cordz_handle.cc",
+ ],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+ ],
+ host_supported: true,
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DABSL_ALLOCATOR_NOTHROW=1",
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-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/",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ 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: //third_party/abseil-cpp/absl/strings:cordz_info
-cc_object {
+cc_library_static {
name: "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info",
srcs: [
"third_party/abseil-cpp/absl/strings/internal/cordz_info.cc",
],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_base",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+ "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+ "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+ "cronet_aml_third_party_abseil_cpp_absl_time_time",
+ ],
defaults: [
"cronet_aml_defaults",
],
@@ -8283,11 +27670,20 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-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: [
"./",
@@ -8297,7 +27693,24 @@
"third_party/abseil-cpp/",
],
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",
@@ -8305,20 +27718,151 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //third_party/abseil-cpp/absl/strings:cordz_info__testing
+cc_library_static {
+ name: "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info__testing",
+ srcs: [
+ "third_party/abseil-cpp/absl/strings/internal/cordz_info.cc",
+ ],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+ ],
+ host_supported: true,
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DABSL_ALLOCATOR_NOTHROW=1",
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-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/",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ 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: //third_party/abseil-cpp/absl/strings:internal
-cc_object {
+cc_library_static {
name: "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
srcs: [
"third_party/abseil-cpp/absl/strings/internal/escaping.cc",
"third_party/abseil-cpp/absl/strings/internal/ostringstream.cc",
"third_party/abseil-cpp/absl/strings/internal/utf8.cc",
],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_base",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+ ],
defaults: [
"cronet_aml_defaults",
],
@@ -8331,11 +27875,20 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-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: [
"./",
@@ -8345,7 +27898,24 @@
"third_party/abseil-cpp/",
],
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",
@@ -8353,14 +27923,123 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //third_party/abseil-cpp/absl/strings:internal__testing
+cc_library_static {
+ name: "cronet_aml_third_party_abseil_cpp_absl_strings_internal__testing",
+ srcs: [
+ "third_party/abseil-cpp/absl/strings/internal/escaping.cc",
+ "third_party/abseil-cpp/absl/strings/internal/ostringstream.cc",
+ "third_party/abseil-cpp/absl/strings/internal/utf8.cc",
+ ],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+ ],
+ host_supported: true,
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DABSL_ALLOCATOR_NOTHROW=1",
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-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/",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ 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: //third_party/abseil-cpp/absl/strings:str_format_internal
-cc_object {
+cc_library_static {
name: "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal",
srcs: [
"third_party/abseil-cpp/absl/strings/internal/str_format/arg.cc",
@@ -8370,6 +28049,17 @@
"third_party/abseil-cpp/absl/strings/internal/str_format/output.cc",
"third_party/abseil-cpp/absl/strings/internal/str_format/parser.cc",
],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_base",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+ "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
+ ],
defaults: [
"cronet_aml_defaults",
],
@@ -8382,11 +28072,20 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-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: [
"./",
@@ -8396,7 +28095,24 @@
"third_party/abseil-cpp/",
],
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",
@@ -8404,14 +28120,131 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //third_party/abseil-cpp/absl/strings:str_format_internal__testing
+cc_library_static {
+ name: "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal__testing",
+ srcs: [
+ "third_party/abseil-cpp/absl/strings/internal/str_format/arg.cc",
+ "third_party/abseil-cpp/absl/strings/internal/str_format/bind.cc",
+ "third_party/abseil-cpp/absl/strings/internal/str_format/extension.cc",
+ "third_party/abseil-cpp/absl/strings/internal/str_format/float_conversion.cc",
+ "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",
+ ],
+ cflags: [
+ "-DABSL_ALLOCATOR_NOTHROW=1",
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-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/",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ 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: //third_party/abseil-cpp/absl/strings:strings
-cc_object {
+cc_library_static {
name: "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
srcs: [
"third_party/abseil-cpp/absl/strings/ascii.cc",
@@ -8428,6 +28261,15 @@
"third_party/abseil-cpp/absl/strings/string_view.cc",
"third_party/abseil-cpp/absl/strings/substitute.cc",
],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_base",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+ "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+ ],
defaults: [
"cronet_aml_defaults",
],
@@ -8440,11 +28282,20 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-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: [
"./",
@@ -8454,7 +28305,24 @@
"third_party/abseil-cpp/",
],
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",
@@ -8462,18 +28330,147 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //third_party/abseil-cpp/absl/strings:strings__testing
+cc_library_static {
+ name: "cronet_aml_third_party_abseil_cpp_absl_strings_strings__testing",
+ srcs: [
+ "third_party/abseil-cpp/absl/strings/ascii.cc",
+ "third_party/abseil-cpp/absl/strings/charconv.cc",
+ "third_party/abseil-cpp/absl/strings/escaping.cc",
+ "third_party/abseil-cpp/absl/strings/internal/charconv_bigint.cc",
+ "third_party/abseil-cpp/absl/strings/internal/charconv_parse.cc",
+ "third_party/abseil-cpp/absl/strings/internal/memutil.cc",
+ "third_party/abseil-cpp/absl/strings/match.cc",
+ "third_party/abseil-cpp/absl/strings/numbers.cc",
+ "third_party/abseil-cpp/absl/strings/str_cat.cc",
+ "third_party/abseil-cpp/absl/strings/str_replace.cc",
+ "third_party/abseil-cpp/absl/strings/str_split.cc",
+ "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",
+ ],
+ cflags: [
+ "-DABSL_ALLOCATOR_NOTHROW=1",
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-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/",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ 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: //third_party/abseil-cpp/absl/synchronization:graphcycles_internal
-cc_object {
+cc_library_static {
name: "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
srcs: [
"third_party/abseil-cpp/absl/synchronization/internal/graphcycles.cc",
],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_base",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+ ],
defaults: [
"cronet_aml_defaults",
],
@@ -8486,11 +28483,20 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-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: [
"./",
@@ -8500,7 +28506,24 @@
"third_party/abseil-cpp/",
],
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",
@@ -8508,14 +28531,122 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //third_party/abseil-cpp/absl/synchronization:graphcycles_internal__testing
+cc_library_static {
+ name: "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal__testing",
+ srcs: [
+ "third_party/abseil-cpp/absl/synchronization/internal/graphcycles.cc",
+ ],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_base__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait__testing",
+ ],
+ host_supported: true,
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DABSL_ALLOCATOR_NOTHROW=1",
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-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/",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ 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: //third_party/abseil-cpp/absl/synchronization:synchronization
-cc_object {
+cc_library_static {
name: "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
srcs: [
"third_party/abseil-cpp/absl/synchronization/barrier.cc",
@@ -8526,6 +28657,25 @@
"third_party/abseil-cpp/absl/synchronization/mutex.cc",
"third_party/abseil-cpp/absl/synchronization/notification.cc",
],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_base",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+ "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+ "cronet_aml_third_party_abseil_cpp_absl_time_time",
+ ],
defaults: [
"cronet_aml_defaults",
],
@@ -8538,11 +28688,20 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-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: [
"./",
@@ -8552,7 +28711,24 @@
"third_party/abseil-cpp/",
],
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",
@@ -8560,14 +28736,140 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //third_party/abseil-cpp/absl/synchronization:synchronization__testing
+cc_library_static {
+ name: "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization__testing",
+ srcs: [
+ "third_party/abseil-cpp/absl/synchronization/barrier.cc",
+ "third_party/abseil-cpp/absl/synchronization/blocking_counter.cc",
+ "third_party/abseil-cpp/absl/synchronization/internal/create_thread_identity.cc",
+ "third_party/abseil-cpp/absl/synchronization/internal/per_thread_sem.cc",
+ "third_party/abseil-cpp/absl/synchronization/internal/waiter.cc",
+ "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",
+ ],
+ cflags: [
+ "-DABSL_ALLOCATOR_NOTHROW=1",
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-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/",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ 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: //third_party/abseil-cpp/absl/time/internal/cctz:civil_time
-cc_object {
+cc_library_static {
name: "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
srcs: [
"third_party/abseil-cpp/absl/time/internal/cctz/src/civil_time_detail.cc",
@@ -8584,11 +28886,20 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-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: [
"./",
@@ -8598,7 +28909,24 @@
"third_party/abseil-cpp/",
],
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",
@@ -8606,14 +28934,115 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //third_party/abseil-cpp/absl/time/internal/cctz:civil_time__testing
+cc_library_static {
+ name: "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time__testing",
+ srcs: [
+ "third_party/abseil-cpp/absl/time/internal/cctz/src/civil_time_detail.cc",
+ ],
+ host_supported: true,
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DABSL_ALLOCATOR_NOTHROW=1",
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-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/",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ 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: //third_party/abseil-cpp/absl/time/internal/cctz:time_zone
-cc_object {
+cc_library_static {
name: "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
srcs: [
"third_party/abseil-cpp/absl/time/internal/cctz/src/time_zone_fixed.cc",
@@ -8626,6 +29055,9 @@
"third_party/abseil-cpp/absl/time/internal/cctz/src/time_zone_posix.cc",
"third_party/abseil-cpp/absl/time/internal/cctz/src/zone_info_source.cc",
],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+ ],
defaults: [
"cronet_aml_defaults",
],
@@ -8638,11 +29070,20 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-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: [
"./",
@@ -8652,7 +29093,24 @@
"third_party/abseil-cpp/",
],
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",
@@ -8660,14 +29118,126 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //third_party/abseil-cpp/absl/time/internal/cctz:time_zone__testing
+cc_library_static {
+ name: "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone__testing",
+ srcs: [
+ "third_party/abseil-cpp/absl/time/internal/cctz/src/time_zone_fixed.cc",
+ "third_party/abseil-cpp/absl/time/internal/cctz/src/time_zone_format.cc",
+ "third_party/abseil-cpp/absl/time/internal/cctz/src/time_zone_if.cc",
+ "third_party/abseil-cpp/absl/time/internal/cctz/src/time_zone_impl.cc",
+ "third_party/abseil-cpp/absl/time/internal/cctz/src/time_zone_info.cc",
+ "third_party/abseil-cpp/absl/time/internal/cctz/src/time_zone_libc.cc",
+ "third_party/abseil-cpp/absl/time/internal/cctz/src/time_zone_lookup.cc",
+ "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",
+ ],
+ cflags: [
+ "-DABSL_ALLOCATOR_NOTHROW=1",
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-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/",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ 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: //third_party/abseil-cpp/absl/time:time
-cc_object {
+cc_library_static {
name: "cronet_aml_third_party_abseil_cpp_absl_time_time",
srcs: [
"third_party/abseil-cpp/absl/time/civil_time.cc",
@@ -8676,6 +29246,18 @@
"third_party/abseil-cpp/absl/time/format.cc",
"third_party/abseil-cpp/absl/time/time.cc",
],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_base",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+ "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+ ],
defaults: [
"cronet_aml_defaults",
],
@@ -8688,11 +29270,20 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-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: [
"./",
@@ -8702,7 +29293,24 @@
"third_party/abseil-cpp/",
],
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",
@@ -8710,18 +29318,139 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //third_party/abseil-cpp/absl/time:time__testing
+cc_library_static {
+ name: "cronet_aml_third_party_abseil_cpp_absl_time_time__testing",
+ srcs: [
+ "third_party/abseil-cpp/absl/time/civil_time.cc",
+ "third_party/abseil-cpp/absl/time/clock.cc",
+ "third_party/abseil-cpp/absl/time/duration.cc",
+ "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",
+ ],
+ cflags: [
+ "-DABSL_ALLOCATOR_NOTHROW=1",
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-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/",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ 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: //third_party/abseil-cpp/absl/types:bad_optional_access
-cc_object {
+cc_library_static {
name: "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
srcs: [
"third_party/abseil-cpp/absl/types/bad_optional_access.cc",
],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+ ],
defaults: [
"cronet_aml_defaults",
],
@@ -8734,11 +29463,20 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-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: [
"./",
@@ -8748,7 +29486,24 @@
"third_party/abseil-cpp/",
],
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",
@@ -8756,18 +29511,127 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //third_party/abseil-cpp/absl/types:bad_optional_access__testing
+cc_library_static {
+ name: "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access__testing",
+ srcs: [
+ "third_party/abseil-cpp/absl/types/bad_optional_access.cc",
+ ],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+ ],
+ host_supported: true,
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DABSL_ALLOCATOR_NOTHROW=1",
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-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/",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ 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: //third_party/abseil-cpp/absl/types:bad_variant_access
-cc_object {
+cc_library_static {
name: "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access",
srcs: [
"third_party/abseil-cpp/absl/types/bad_variant_access.cc",
],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+ ],
defaults: [
"cronet_aml_defaults",
],
@@ -8780,11 +29644,20 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-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: [
"./",
@@ -8794,7 +29667,24 @@
"third_party/abseil-cpp/",
],
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",
@@ -8802,14 +29692,119 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //third_party/abseil-cpp/absl/types:bad_variant_access__testing
+cc_library_static {
+ name: "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access__testing",
+ srcs: [
+ "third_party/abseil-cpp/absl/types/bad_variant_access.cc",
+ ],
+ static_libs: [
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity__testing",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal__testing",
+ ],
+ host_supported: true,
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DABSL_ALLOCATOR_NOTHROW=1",
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-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/",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ 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: //third_party/android_ndk:cpu_features
-cc_object {
+cc_library_static {
name: "cronet_aml_third_party_android_ndk_cpu_features",
srcs: [
"third_party/android_ndk/sources/android/cpufeatures/cpu-features.c",
@@ -8825,11 +29820,20 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-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: [
"./",
@@ -8839,7 +29843,24 @@
"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: [
+ "-fstack-protector",
+ ],
+ },
+ android_arm64: {
+ cflags: [
+ "-fstack-protector",
+ "-mno-outline",
+ "-mno-outline-atomics",
+ ],
+ },
android_x86: {
cflags: [
"-msse3",
@@ -8847,6 +29868,79 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
+ "-msse3",
+ ],
+ },
+ },
+}
+
+// GN: //third_party/android_ndk:cpu_features__testing
+cc_library_static {
+ name: "cronet_aml_third_party_android_ndk_cpu_features__testing",
+ srcs: [
+ "third_party/android_ndk/sources/android/cpufeatures/cpu-features.c",
+ ],
+ 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_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/android_ndk/sources/android/cpufeatures/",
+ ],
+ 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",
],
},
@@ -8854,7 +29948,7 @@
}
// GN: //third_party/ashmem:ashmem
-cc_object {
+cc_library_static {
name: "cronet_aml_third_party_ashmem_ashmem",
srcs: [
"third_party/ashmem/ashmem-dev.c",
@@ -8870,6 +29964,7 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-D_FORTIFY_SOURCE=2",
@@ -8878,6 +29973,14 @@
"-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: [
"./",
@@ -8886,7 +29989,24 @@
"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",
@@ -8894,6 +30014,81 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
+ "-msse3",
+ ],
+ },
+ },
+}
+
+// GN: //third_party/ashmem:ashmem__testing
+cc_library_static {
+ name: "cronet_aml_third_party_ashmem_ashmem__testing",
+ srcs: [
+ "third_party/ashmem/ashmem-dev.c",
+ ],
+ 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",
],
},
@@ -8904,7 +30099,6 @@
cc_library_static {
name: "cronet_aml_third_party_boringssl_boringssl",
srcs: [
- ":cronet_aml_third_party_boringssl_boringssl_asm",
"third_party/boringssl/err_data.c",
"third_party/boringssl/src/crypto/asn1/a_bitstr.c",
"third_party/boringssl/src/crypto/asn1/a_bool.c",
@@ -9172,6 +30366,9 @@
"third_party/boringssl/src/ssl/tls_method.cc",
"third_party/boringssl/src/ssl/tls_record.cc",
],
+ static_libs: [
+ "cronet_aml_third_party_boringssl_boringssl_asm",
+ ],
defaults: [
"cronet_aml_defaults",
],
@@ -9186,12 +30383,21 @@
"-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: [
"./",
@@ -9201,7 +30407,24 @@
"third_party/boringssl/src/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",
@@ -9209,14 +30432,386 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //third_party/boringssl:boringssl__testing
+cc_library_static {
+ name: "cronet_aml_third_party_boringssl_boringssl__testing",
+ 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__testing",
+ ],
+ host_supported: true,
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-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",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-DOPENSSL_SMALL",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-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/",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ 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: //third_party/boringssl:boringssl_asm
-cc_object {
+cc_library_static {
name: "cronet_aml_third_party_boringssl_boringssl_asm",
defaults: [
"cronet_aml_defaults",
@@ -9229,6 +30824,7 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-D_FORTIFY_SOURCE=2",
@@ -9237,6 +30833,14 @@
"-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: [
"./",
@@ -9246,6 +30850,11 @@
"third_party/boringssl/src/include/",
],
cpp_std: "c++17",
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
target: {
android_arm: {
srcs: [
@@ -9263,6 +30872,9 @@
"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: [
@@ -9280,6 +30892,11 @@
"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: [
@@ -9325,12 +30942,201 @@
"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 {
+ name: "cronet_aml_third_party_boringssl_boringssl_asm__testing",
+ host_supported: true,
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-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",
+ "-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/",
+ ],
+ 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: [
+ "-DANDROID",
+ "-DANDROID_NDK_VERSION_ROLL=r23_1",
+ "-DHAVE_SYS_UIO_H",
+ "-Oz",
+ "-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: [
+ "-DANDROID",
+ "-DANDROID_NDK_VERSION_ROLL=r23_1",
+ "-DHAVE_SYS_UIO_H",
+ "-Oz",
+ "-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: [
+ "-DANDROID",
+ "-DANDROID_NDK_VERSION_ROLL=r23_1",
+ "-DHAVE_SYS_UIO_H",
+ "-Oz",
+ "-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: [
+ "-DANDROID",
+ "-DANDROID_NDK_VERSION_ROLL=r23_1",
+ "-DHAVE_SYS_UIO_H",
+ "-Oz",
+ "-fstack-protector",
+ "-msse3",
+ ],
+ },
+ host: {
+ 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: [
+ "-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: //third_party/brotli:common
cc_library_static {
name: "cronet_aml_third_party_brotli_common",
@@ -9353,6 +31159,7 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-D_FORTIFY_SOURCE=2",
@@ -9361,6 +31168,14 @@
"-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: [
"./",
@@ -9370,7 +31185,24 @@
"third_party/brotli/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",
@@ -9378,6 +31210,87 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
+ "-msse3",
+ ],
+ },
+ },
+}
+
+// GN: //third_party/brotli:common__testing
+cc_library_static {
+ name: "cronet_aml_third_party_brotli_common__testing",
+ srcs: [
+ "third_party/brotli/common/constants.c",
+ "third_party/brotli/common/context.c",
+ "third_party/brotli/common/dictionary.c",
+ "third_party/brotli/common/platform.c",
+ "third_party/brotli/common/shared_dictionary.c",
+ "third_party/brotli/common/transform.c",
+ ],
+ 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/brotli/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",
],
},
@@ -9407,11 +31320,20 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-O2",
+ "-fdata-sections",
+ "-ffunction-sections",
+ "-fno-asynchronous-unwind-tables",
+ "-fno-unwind-tables",
+ "-fvisibility-inlines-hidden",
+ "-fvisibility=hidden",
+ "-g1",
],
local_include_dirs: [
"./",
@@ -9421,7 +31343,24 @@
"third_party/brotli/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",
@@ -9429,6 +31368,507 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
+ "-msse3",
+ ],
+ },
+ },
+}
+
+// GN: //third_party/brotli:dec__testing
+cc_library_static {
+ name: "cronet_aml_third_party_brotli_dec__testing",
+ srcs: [
+ "third_party/brotli/dec/bit_reader.c",
+ "third_party/brotli/dec/decode.c",
+ "third_party/brotli/dec/huffman.c",
+ "third_party/brotli/dec/state.c",
+ ],
+ static_libs: [
+ "cronet_aml_third_party_brotli_common__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_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-O2",
+ "-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/brotli/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/ced:ced__testing
+cc_library_static {
+ name: "cronet_aml_third_party_ced_ced__testing",
+ srcs: [
+ "third_party/ced/src/compact_enc_det/compact_enc_det.cc",
+ "third_party/ced/src/compact_enc_det/compact_enc_det_hint_code.cc",
+ "third_party/ced/src/util/encodings/encodings.cc",
+ "third_party/ced/src/util/languages/languages.cc",
+ ],
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DANDROID",
+ "-DANDROID_NDK_VERSION_ROLL=r23_1",
+ "-DCOMPILER_GCC",
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DHAVE_SYS_UIO_H",
+ "-DHTML5_MODE",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-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/ced/src/",
+ ],
+ 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/googletest:gmock__testing
+cc_library_static {
+ name: "cronet_aml_third_party_googletest_gmock__testing",
+ srcs: [
+ "third_party/googletest/src/googlemock/src/gmock-cardinalities.cc",
+ "third_party/googletest/src/googlemock/src/gmock-internal-utils.cc",
+ "third_party/googletest/src/googlemock/src/gmock-matchers.cc",
+ "third_party/googletest/src/googlemock/src/gmock-spec-builders.cc",
+ "third_party/googletest/src/googlemock/src/gmock.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_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",
+ ],
+ 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",
+ "-DGTEST_API_=",
+ "-DGTEST_HAS_ABSL=1",
+ "-DGTEST_HAS_POSIX_RE=0",
+ "-DGTEST_HAS_TR1_TUPLE=0",
+ "-DGTEST_LANG_CXX11=1",
+ "-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/googletest/custom/",
+ "third_party/googletest/src/googlemock/include/",
+ "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: [
+ "-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/googletest:gtest__testing
+cc_library_static {
+ name: "cronet_aml_third_party_googletest_gtest__testing",
+ srcs: [
+ "third_party/googletest/custom/gtest/internal/custom/chrome_custom_temp_dir.cc",
+ "third_party/googletest/custom/gtest/internal/custom/gtest_port_wrapper.cc",
+ "third_party/googletest/custom/gtest/internal/custom/stack_trace_getter.cc",
+ "third_party/googletest/src/googletest/src/gtest-assertion-result.cc",
+ "third_party/googletest/src/googletest/src/gtest-death-test.cc",
+ "third_party/googletest/src/googletest/src/gtest-filepath.cc",
+ "third_party/googletest/src/googletest/src/gtest-matchers.cc",
+ "third_party/googletest/src/googletest/src/gtest-printers.cc",
+ "third_party/googletest/src/googletest/src/gtest-test-part.cc",
+ "third_party/googletest/src/googletest/src/gtest-typed-test.cc",
+ "third_party/googletest/src/googletest/src/gtest.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_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",
+ ],
+ 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",
+ "-DGTEST_API_=",
+ "-DGTEST_HAS_ABSL=1",
+ "-DGTEST_HAS_POSIX_RE=0",
+ "-DGTEST_HAS_TR1_TUPLE=0",
+ "-DGTEST_LANG_CXX11=1",
+ "-DHAVE_SYS_UIO_H",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-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/abseil-cpp/",
+ "third_party/boringssl/src/include/",
+ "third_party/googletest/custom/",
+ "third_party/googletest/src/googletest/",
+ "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: [
+ "-fstack-protector",
+ ],
+ },
+ android_arm64: {
+ cflags: [
+ "-fstack-protector",
+ "-mno-outline",
+ "-mno-outline-atomics",
+ ],
+ },
+ android_x86: {
+ cflags: [
+ "-msse3",
+ ],
+ },
+ android_x86_64: {
+ cflags: [
+ "-fstack-protector",
"-msse3",
],
},
@@ -9696,6 +32136,7 @@
"-DHAVE_SYS_UIO_H",
"-DICU_UTIL_DATA_IMPL=ICU_UTIL_DATA_FILE",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-DUCONFIG_ONLY_HTML_CONVERSION=1",
@@ -9711,6 +32152,14 @@
"-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: [
"./",
@@ -9721,8 +32170,25 @@
"third_party/icu/source/i18n/",
],
cpp_std: "c++17",
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
rtti: true,
target: {
+ android_arm: {
+ cflags: [
+ "-fstack-protector",
+ ],
+ },
+ android_arm64: {
+ cflags: [
+ "-fstack-protector",
+ "-mno-outline",
+ "-mno-outline-atomics",
+ ],
+ },
android_x86: {
cflags: [
"-msse3",
@@ -9730,12 +32196,368 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //third_party/icu:icui18n__testing
+cc_library_static {
+ name: "cronet_aml_third_party_icu_icui18n__testing",
+ srcs: [
+ "third_party/icu/source/i18n/alphaindex.cpp",
+ "third_party/icu/source/i18n/anytrans.cpp",
+ "third_party/icu/source/i18n/astro.cpp",
+ "third_party/icu/source/i18n/basictz.cpp",
+ "third_party/icu/source/i18n/bocsu.cpp",
+ "third_party/icu/source/i18n/brktrans.cpp",
+ "third_party/icu/source/i18n/buddhcal.cpp",
+ "third_party/icu/source/i18n/calendar.cpp",
+ "third_party/icu/source/i18n/casetrn.cpp",
+ "third_party/icu/source/i18n/cecal.cpp",
+ "third_party/icu/source/i18n/chnsecal.cpp",
+ "third_party/icu/source/i18n/choicfmt.cpp",
+ "third_party/icu/source/i18n/coleitr.cpp",
+ "third_party/icu/source/i18n/coll.cpp",
+ "third_party/icu/source/i18n/collation.cpp",
+ "third_party/icu/source/i18n/collationbuilder.cpp",
+ "third_party/icu/source/i18n/collationcompare.cpp",
+ "third_party/icu/source/i18n/collationdata.cpp",
+ "third_party/icu/source/i18n/collationdatabuilder.cpp",
+ "third_party/icu/source/i18n/collationdatareader.cpp",
+ "third_party/icu/source/i18n/collationdatawriter.cpp",
+ "third_party/icu/source/i18n/collationfastlatin.cpp",
+ "third_party/icu/source/i18n/collationfastlatinbuilder.cpp",
+ "third_party/icu/source/i18n/collationfcd.cpp",
+ "third_party/icu/source/i18n/collationiterator.cpp",
+ "third_party/icu/source/i18n/collationkeys.cpp",
+ "third_party/icu/source/i18n/collationroot.cpp",
+ "third_party/icu/source/i18n/collationrootelements.cpp",
+ "third_party/icu/source/i18n/collationruleparser.cpp",
+ "third_party/icu/source/i18n/collationsets.cpp",
+ "third_party/icu/source/i18n/collationsettings.cpp",
+ "third_party/icu/source/i18n/collationtailoring.cpp",
+ "third_party/icu/source/i18n/collationweights.cpp",
+ "third_party/icu/source/i18n/compactdecimalformat.cpp",
+ "third_party/icu/source/i18n/coptccal.cpp",
+ "third_party/icu/source/i18n/cpdtrans.cpp",
+ "third_party/icu/source/i18n/csdetect.cpp",
+ "third_party/icu/source/i18n/csmatch.cpp",
+ "third_party/icu/source/i18n/csr2022.cpp",
+ "third_party/icu/source/i18n/csrecog.cpp",
+ "third_party/icu/source/i18n/csrmbcs.cpp",
+ "third_party/icu/source/i18n/csrsbcs.cpp",
+ "third_party/icu/source/i18n/csrucode.cpp",
+ "third_party/icu/source/i18n/csrutf8.cpp",
+ "third_party/icu/source/i18n/curramt.cpp",
+ "third_party/icu/source/i18n/currfmt.cpp",
+ "third_party/icu/source/i18n/currpinf.cpp",
+ "third_party/icu/source/i18n/currunit.cpp",
+ "third_party/icu/source/i18n/dangical.cpp",
+ "third_party/icu/source/i18n/datefmt.cpp",
+ "third_party/icu/source/i18n/dayperiodrules.cpp",
+ "third_party/icu/source/i18n/dcfmtsym.cpp",
+ "third_party/icu/source/i18n/decContext.cpp",
+ "third_party/icu/source/i18n/decNumber.cpp",
+ "third_party/icu/source/i18n/decimfmt.cpp",
+ "third_party/icu/source/i18n/double-conversion-bignum-dtoa.cpp",
+ "third_party/icu/source/i18n/double-conversion-bignum.cpp",
+ "third_party/icu/source/i18n/double-conversion-cached-powers.cpp",
+ "third_party/icu/source/i18n/double-conversion-double-to-string.cpp",
+ "third_party/icu/source/i18n/double-conversion-fast-dtoa.cpp",
+ "third_party/icu/source/i18n/double-conversion-string-to-double.cpp",
+ "third_party/icu/source/i18n/double-conversion-strtod.cpp",
+ "third_party/icu/source/i18n/dtfmtsym.cpp",
+ "third_party/icu/source/i18n/dtitvfmt.cpp",
+ "third_party/icu/source/i18n/dtitvinf.cpp",
+ "third_party/icu/source/i18n/dtptngen.cpp",
+ "third_party/icu/source/i18n/dtrule.cpp",
+ "third_party/icu/source/i18n/erarules.cpp",
+ "third_party/icu/source/i18n/esctrn.cpp",
+ "third_party/icu/source/i18n/ethpccal.cpp",
+ "third_party/icu/source/i18n/fmtable.cpp",
+ "third_party/icu/source/i18n/fmtable_cnv.cpp",
+ "third_party/icu/source/i18n/format.cpp",
+ "third_party/icu/source/i18n/formatted_string_builder.cpp",
+ "third_party/icu/source/i18n/formattedval_iterimpl.cpp",
+ "third_party/icu/source/i18n/formattedval_sbimpl.cpp",
+ "third_party/icu/source/i18n/formattedvalue.cpp",
+ "third_party/icu/source/i18n/fphdlimp.cpp",
+ "third_party/icu/source/i18n/fpositer.cpp",
+ "third_party/icu/source/i18n/funcrepl.cpp",
+ "third_party/icu/source/i18n/gender.cpp",
+ "third_party/icu/source/i18n/gregocal.cpp",
+ "third_party/icu/source/i18n/gregoimp.cpp",
+ "third_party/icu/source/i18n/hebrwcal.cpp",
+ "third_party/icu/source/i18n/indiancal.cpp",
+ "third_party/icu/source/i18n/inputext.cpp",
+ "third_party/icu/source/i18n/islamcal.cpp",
+ "third_party/icu/source/i18n/japancal.cpp",
+ "third_party/icu/source/i18n/listformatter.cpp",
+ "third_party/icu/source/i18n/measfmt.cpp",
+ "third_party/icu/source/i18n/measunit.cpp",
+ "third_party/icu/source/i18n/measunit_extra.cpp",
+ "third_party/icu/source/i18n/measure.cpp",
+ "third_party/icu/source/i18n/msgfmt.cpp",
+ "third_party/icu/source/i18n/name2uni.cpp",
+ "third_party/icu/source/i18n/nfrs.cpp",
+ "third_party/icu/source/i18n/nfrule.cpp",
+ "third_party/icu/source/i18n/nfsubs.cpp",
+ "third_party/icu/source/i18n/nortrans.cpp",
+ "third_party/icu/source/i18n/nultrans.cpp",
+ "third_party/icu/source/i18n/number_affixutils.cpp",
+ "third_party/icu/source/i18n/number_asformat.cpp",
+ "third_party/icu/source/i18n/number_capi.cpp",
+ "third_party/icu/source/i18n/number_compact.cpp",
+ "third_party/icu/source/i18n/number_currencysymbols.cpp",
+ "third_party/icu/source/i18n/number_decimalquantity.cpp",
+ "third_party/icu/source/i18n/number_decimfmtprops.cpp",
+ "third_party/icu/source/i18n/number_fluent.cpp",
+ "third_party/icu/source/i18n/number_formatimpl.cpp",
+ "third_party/icu/source/i18n/number_grouping.cpp",
+ "third_party/icu/source/i18n/number_integerwidth.cpp",
+ "third_party/icu/source/i18n/number_longnames.cpp",
+ "third_party/icu/source/i18n/number_mapper.cpp",
+ "third_party/icu/source/i18n/number_modifiers.cpp",
+ "third_party/icu/source/i18n/number_multiplier.cpp",
+ "third_party/icu/source/i18n/number_notation.cpp",
+ "third_party/icu/source/i18n/number_output.cpp",
+ "third_party/icu/source/i18n/number_padding.cpp",
+ "third_party/icu/source/i18n/number_patternmodifier.cpp",
+ "third_party/icu/source/i18n/number_patternstring.cpp",
+ "third_party/icu/source/i18n/number_rounding.cpp",
+ "third_party/icu/source/i18n/number_scientific.cpp",
+ "third_party/icu/source/i18n/number_skeletons.cpp",
+ "third_party/icu/source/i18n/number_symbolswrapper.cpp",
+ "third_party/icu/source/i18n/number_usageprefs.cpp",
+ "third_party/icu/source/i18n/number_utils.cpp",
+ "third_party/icu/source/i18n/numfmt.cpp",
+ "third_party/icu/source/i18n/numparse_affixes.cpp",
+ "third_party/icu/source/i18n/numparse_compositions.cpp",
+ "third_party/icu/source/i18n/numparse_currency.cpp",
+ "third_party/icu/source/i18n/numparse_decimal.cpp",
+ "third_party/icu/source/i18n/numparse_impl.cpp",
+ "third_party/icu/source/i18n/numparse_parsednumber.cpp",
+ "third_party/icu/source/i18n/numparse_scientific.cpp",
+ "third_party/icu/source/i18n/numparse_symbols.cpp",
+ "third_party/icu/source/i18n/numparse_validators.cpp",
+ "third_party/icu/source/i18n/numrange_capi.cpp",
+ "third_party/icu/source/i18n/numrange_fluent.cpp",
+ "third_party/icu/source/i18n/numrange_impl.cpp",
+ "third_party/icu/source/i18n/numsys.cpp",
+ "third_party/icu/source/i18n/olsontz.cpp",
+ "third_party/icu/source/i18n/persncal.cpp",
+ "third_party/icu/source/i18n/pluralranges.cpp",
+ "third_party/icu/source/i18n/plurfmt.cpp",
+ "third_party/icu/source/i18n/plurrule.cpp",
+ "third_party/icu/source/i18n/quant.cpp",
+ "third_party/icu/source/i18n/quantityformatter.cpp",
+ "third_party/icu/source/i18n/rbnf.cpp",
+ "third_party/icu/source/i18n/rbt.cpp",
+ "third_party/icu/source/i18n/rbt_data.cpp",
+ "third_party/icu/source/i18n/rbt_pars.cpp",
+ "third_party/icu/source/i18n/rbt_rule.cpp",
+ "third_party/icu/source/i18n/rbt_set.cpp",
+ "third_party/icu/source/i18n/rbtz.cpp",
+ "third_party/icu/source/i18n/regexcmp.cpp",
+ "third_party/icu/source/i18n/regeximp.cpp",
+ "third_party/icu/source/i18n/regexst.cpp",
+ "third_party/icu/source/i18n/regextxt.cpp",
+ "third_party/icu/source/i18n/region.cpp",
+ "third_party/icu/source/i18n/reldatefmt.cpp",
+ "third_party/icu/source/i18n/reldtfmt.cpp",
+ "third_party/icu/source/i18n/rematch.cpp",
+ "third_party/icu/source/i18n/remtrans.cpp",
+ "third_party/icu/source/i18n/repattrn.cpp",
+ "third_party/icu/source/i18n/rulebasedcollator.cpp",
+ "third_party/icu/source/i18n/scientificnumberformatter.cpp",
+ "third_party/icu/source/i18n/scriptset.cpp",
+ "third_party/icu/source/i18n/search.cpp",
+ "third_party/icu/source/i18n/selfmt.cpp",
+ "third_party/icu/source/i18n/sharedbreakiterator.cpp",
+ "third_party/icu/source/i18n/simpletz.cpp",
+ "third_party/icu/source/i18n/smpdtfmt.cpp",
+ "third_party/icu/source/i18n/smpdtfst.cpp",
+ "third_party/icu/source/i18n/sortkey.cpp",
+ "third_party/icu/source/i18n/standardplural.cpp",
+ "third_party/icu/source/i18n/string_segment.cpp",
+ "third_party/icu/source/i18n/strmatch.cpp",
+ "third_party/icu/source/i18n/strrepl.cpp",
+ "third_party/icu/source/i18n/stsearch.cpp",
+ "third_party/icu/source/i18n/taiwncal.cpp",
+ "third_party/icu/source/i18n/timezone.cpp",
+ "third_party/icu/source/i18n/titletrn.cpp",
+ "third_party/icu/source/i18n/tmunit.cpp",
+ "third_party/icu/source/i18n/tmutamt.cpp",
+ "third_party/icu/source/i18n/tmutfmt.cpp",
+ "third_party/icu/source/i18n/tolowtrn.cpp",
+ "third_party/icu/source/i18n/toupptrn.cpp",
+ "third_party/icu/source/i18n/translit.cpp",
+ "third_party/icu/source/i18n/transreg.cpp",
+ "third_party/icu/source/i18n/tridpars.cpp",
+ "third_party/icu/source/i18n/tzfmt.cpp",
+ "third_party/icu/source/i18n/tzgnames.cpp",
+ "third_party/icu/source/i18n/tznames.cpp",
+ "third_party/icu/source/i18n/tznames_impl.cpp",
+ "third_party/icu/source/i18n/tzrule.cpp",
+ "third_party/icu/source/i18n/tztrans.cpp",
+ "third_party/icu/source/i18n/ucal.cpp",
+ "third_party/icu/source/i18n/ucln_in.cpp",
+ "third_party/icu/source/i18n/ucol.cpp",
+ "third_party/icu/source/i18n/ucol_res.cpp",
+ "third_party/icu/source/i18n/ucol_sit.cpp",
+ "third_party/icu/source/i18n/ucoleitr.cpp",
+ "third_party/icu/source/i18n/ucsdet.cpp",
+ "third_party/icu/source/i18n/udat.cpp",
+ "third_party/icu/source/i18n/udateintervalformat.cpp",
+ "third_party/icu/source/i18n/udatpg.cpp",
+ "third_party/icu/source/i18n/ufieldpositer.cpp",
+ "third_party/icu/source/i18n/uitercollationiterator.cpp",
+ "third_party/icu/source/i18n/ulistformatter.cpp",
+ "third_party/icu/source/i18n/ulocdata.cpp",
+ "third_party/icu/source/i18n/umsg.cpp",
+ "third_party/icu/source/i18n/unesctrn.cpp",
+ "third_party/icu/source/i18n/uni2name.cpp",
+ "third_party/icu/source/i18n/units_complexconverter.cpp",
+ "third_party/icu/source/i18n/units_converter.cpp",
+ "third_party/icu/source/i18n/units_data.cpp",
+ "third_party/icu/source/i18n/units_router.cpp",
+ "third_party/icu/source/i18n/unum.cpp",
+ "third_party/icu/source/i18n/unumsys.cpp",
+ "third_party/icu/source/i18n/upluralrules.cpp",
+ "third_party/icu/source/i18n/uregex.cpp",
+ "third_party/icu/source/i18n/uregexc.cpp",
+ "third_party/icu/source/i18n/uregion.cpp",
+ "third_party/icu/source/i18n/usearch.cpp",
+ "third_party/icu/source/i18n/uspoof.cpp",
+ "third_party/icu/source/i18n/uspoof_build.cpp",
+ "third_party/icu/source/i18n/uspoof_conf.cpp",
+ "third_party/icu/source/i18n/uspoof_impl.cpp",
+ "third_party/icu/source/i18n/utf16collationiterator.cpp",
+ "third_party/icu/source/i18n/utf8collationiterator.cpp",
+ "third_party/icu/source/i18n/utmscale.cpp",
+ "third_party/icu/source/i18n/utrans.cpp",
+ "third_party/icu/source/i18n/vtzone.cpp",
+ "third_party/icu/source/i18n/vzone.cpp",
+ "third_party/icu/source/i18n/windtfmt.cpp",
+ "third_party/icu/source/i18n/winnmfmt.cpp",
+ "third_party/icu/source/i18n/wintzimpl.cpp",
+ "third_party/icu/source/i18n/zonemeta.cpp",
+ "third_party/icu/source/i18n/zrule.cpp",
+ "third_party/icu/source/i18n/ztrans.cpp",
+ ],
+ static_libs: [
+ "cronet_aml_third_party_icu_icuuc_private__testing",
+ ],
+ host_supported: true,
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DHAVE_DLOPEN=0",
+ "-DICU_UTIL_DATA_IMPL=ICU_UTIL_DATA_FILE",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-DUCONFIG_ONLY_HTML_CONVERSION=1",
+ "-DUCONFIG_USE_WINDOWS_LCID_MAPPING_API=0",
+ "-DUSE_CHROMIUM_ICU=1",
+ "-DU_CHARSET_IS_UTF8=1",
+ "-DU_ENABLE_DYLOAD=0",
+ "-DU_ENABLE_RESOURCE_TRACING=0",
+ "-DU_ENABLE_TRACING=1",
+ "-DU_I18N_IMPLEMENTATION",
+ "-DU_STATIC_IMPLEMENTATION",
+ "-DU_USING_ICU_NAMESPACE=0",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-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/icu/source/common/",
+ "third_party/icu/source/i18n/",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ rtti: true,
+ target: {
+ 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: //third_party/icu:icuuc_private
cc_library_static {
name: "cronet_aml_third_party_icu_icuuc_private",
@@ -9953,6 +32775,7 @@
"-DHAVE_SYS_UIO_H",
"-DICU_UTIL_DATA_IMPL=ICU_UTIL_DATA_FILE",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-DUCONFIG_ONLY_HTML_CONVERSION=1",
@@ -9969,6 +32792,14 @@
"-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: [
"./",
@@ -9979,8 +32810,25 @@
"third_party/icu/source/i18n/",
],
cpp_std: "c++17",
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
rtti: true,
target: {
+ android_arm: {
+ cflags: [
+ "-fstack-protector",
+ ],
+ },
+ android_arm64: {
+ cflags: [
+ "-fstack-protector",
+ "-mno-outline",
+ "-mno-outline-atomics",
+ ],
+ },
android_x86: {
cflags: [
"-msse3",
@@ -9988,12 +32836,325 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //third_party/icu:icuuc_private__testing
+cc_library_static {
+ name: "cronet_aml_third_party_icu_icuuc_private__testing",
+ srcs: [
+ "third_party/icu/source/common/appendable.cpp",
+ "third_party/icu/source/common/bmpset.cpp",
+ "third_party/icu/source/common/brkeng.cpp",
+ "third_party/icu/source/common/brkiter.cpp",
+ "third_party/icu/source/common/bytesinkutil.cpp",
+ "third_party/icu/source/common/bytestream.cpp",
+ "third_party/icu/source/common/bytestrie.cpp",
+ "third_party/icu/source/common/bytestriebuilder.cpp",
+ "third_party/icu/source/common/bytestrieiterator.cpp",
+ "third_party/icu/source/common/caniter.cpp",
+ "third_party/icu/source/common/characterproperties.cpp",
+ "third_party/icu/source/common/chariter.cpp",
+ "third_party/icu/source/common/charstr.cpp",
+ "third_party/icu/source/common/cmemory.cpp",
+ "third_party/icu/source/common/cstr.cpp",
+ "third_party/icu/source/common/cstring.cpp",
+ "third_party/icu/source/common/cwchar.cpp",
+ "third_party/icu/source/common/dictbe.cpp",
+ "third_party/icu/source/common/dictionarydata.cpp",
+ "third_party/icu/source/common/dtintrv.cpp",
+ "third_party/icu/source/common/edits.cpp",
+ "third_party/icu/source/common/emojiprops.cpp",
+ "third_party/icu/source/common/errorcode.cpp",
+ "third_party/icu/source/common/filteredbrk.cpp",
+ "third_party/icu/source/common/filterednormalizer2.cpp",
+ "third_party/icu/source/common/icudataver.cpp",
+ "third_party/icu/source/common/icuplug.cpp",
+ "third_party/icu/source/common/loadednormalizer2impl.cpp",
+ "third_party/icu/source/common/localebuilder.cpp",
+ "third_party/icu/source/common/localematcher.cpp",
+ "third_party/icu/source/common/localeprioritylist.cpp",
+ "third_party/icu/source/common/locavailable.cpp",
+ "third_party/icu/source/common/locbased.cpp",
+ "third_party/icu/source/common/locdispnames.cpp",
+ "third_party/icu/source/common/locdistance.cpp",
+ "third_party/icu/source/common/locdspnm.cpp",
+ "third_party/icu/source/common/locid.cpp",
+ "third_party/icu/source/common/loclikely.cpp",
+ "third_party/icu/source/common/loclikelysubtags.cpp",
+ "third_party/icu/source/common/locmap.cpp",
+ "third_party/icu/source/common/locresdata.cpp",
+ "third_party/icu/source/common/locutil.cpp",
+ "third_party/icu/source/common/lsr.cpp",
+ "third_party/icu/source/common/lstmbe.cpp",
+ "third_party/icu/source/common/messagepattern.cpp",
+ "third_party/icu/source/common/normalizer2.cpp",
+ "third_party/icu/source/common/normalizer2impl.cpp",
+ "third_party/icu/source/common/normlzr.cpp",
+ "third_party/icu/source/common/parsepos.cpp",
+ "third_party/icu/source/common/patternprops.cpp",
+ "third_party/icu/source/common/pluralmap.cpp",
+ "third_party/icu/source/common/propname.cpp",
+ "third_party/icu/source/common/propsvec.cpp",
+ "third_party/icu/source/common/punycode.cpp",
+ "third_party/icu/source/common/putil.cpp",
+ "third_party/icu/source/common/rbbi.cpp",
+ "third_party/icu/source/common/rbbi_cache.cpp",
+ "third_party/icu/source/common/rbbidata.cpp",
+ "third_party/icu/source/common/rbbinode.cpp",
+ "third_party/icu/source/common/rbbirb.cpp",
+ "third_party/icu/source/common/rbbiscan.cpp",
+ "third_party/icu/source/common/rbbisetb.cpp",
+ "third_party/icu/source/common/rbbistbl.cpp",
+ "third_party/icu/source/common/rbbitblb.cpp",
+ "third_party/icu/source/common/resbund.cpp",
+ "third_party/icu/source/common/resbund_cnv.cpp",
+ "third_party/icu/source/common/resource.cpp",
+ "third_party/icu/source/common/restrace.cpp",
+ "third_party/icu/source/common/ruleiter.cpp",
+ "third_party/icu/source/common/schriter.cpp",
+ "third_party/icu/source/common/serv.cpp",
+ "third_party/icu/source/common/servlk.cpp",
+ "third_party/icu/source/common/servlkf.cpp",
+ "third_party/icu/source/common/servls.cpp",
+ "third_party/icu/source/common/servnotf.cpp",
+ "third_party/icu/source/common/servrbf.cpp",
+ "third_party/icu/source/common/servslkf.cpp",
+ "third_party/icu/source/common/sharedobject.cpp",
+ "third_party/icu/source/common/simpleformatter.cpp",
+ "third_party/icu/source/common/static_unicode_sets.cpp",
+ "third_party/icu/source/common/stringpiece.cpp",
+ "third_party/icu/source/common/stringtriebuilder.cpp",
+ "third_party/icu/source/common/uarrsort.cpp",
+ "third_party/icu/source/common/ubidi.cpp",
+ "third_party/icu/source/common/ubidi_props.cpp",
+ "third_party/icu/source/common/ubidiln.cpp",
+ "third_party/icu/source/common/ubiditransform.cpp",
+ "third_party/icu/source/common/ubidiwrt.cpp",
+ "third_party/icu/source/common/ubrk.cpp",
+ "third_party/icu/source/common/ucase.cpp",
+ "third_party/icu/source/common/ucasemap.cpp",
+ "third_party/icu/source/common/ucasemap_titlecase_brkiter.cpp",
+ "third_party/icu/source/common/ucat.cpp",
+ "third_party/icu/source/common/uchar.cpp",
+ "third_party/icu/source/common/ucharstrie.cpp",
+ "third_party/icu/source/common/ucharstriebuilder.cpp",
+ "third_party/icu/source/common/ucharstrieiterator.cpp",
+ "third_party/icu/source/common/uchriter.cpp",
+ "third_party/icu/source/common/ucln_cmn.cpp",
+ "third_party/icu/source/common/ucmndata.cpp",
+ "third_party/icu/source/common/ucnv.cpp",
+ "third_party/icu/source/common/ucnv2022.cpp",
+ "third_party/icu/source/common/ucnv_bld.cpp",
+ "third_party/icu/source/common/ucnv_cb.cpp",
+ "third_party/icu/source/common/ucnv_cnv.cpp",
+ "third_party/icu/source/common/ucnv_ct.cpp",
+ "third_party/icu/source/common/ucnv_err.cpp",
+ "third_party/icu/source/common/ucnv_ext.cpp",
+ "third_party/icu/source/common/ucnv_io.cpp",
+ "third_party/icu/source/common/ucnv_lmb.cpp",
+ "third_party/icu/source/common/ucnv_set.cpp",
+ "third_party/icu/source/common/ucnv_u16.cpp",
+ "third_party/icu/source/common/ucnv_u32.cpp",
+ "third_party/icu/source/common/ucnv_u7.cpp",
+ "third_party/icu/source/common/ucnv_u8.cpp",
+ "third_party/icu/source/common/ucnvbocu.cpp",
+ "third_party/icu/source/common/ucnvdisp.cpp",
+ "third_party/icu/source/common/ucnvhz.cpp",
+ "third_party/icu/source/common/ucnvisci.cpp",
+ "third_party/icu/source/common/ucnvlat1.cpp",
+ "third_party/icu/source/common/ucnvmbcs.cpp",
+ "third_party/icu/source/common/ucnvscsu.cpp",
+ "third_party/icu/source/common/ucnvsel.cpp",
+ "third_party/icu/source/common/ucol_swp.cpp",
+ "third_party/icu/source/common/ucptrie.cpp",
+ "third_party/icu/source/common/ucurr.cpp",
+ "third_party/icu/source/common/udata.cpp",
+ "third_party/icu/source/common/udatamem.cpp",
+ "third_party/icu/source/common/udataswp.cpp",
+ "third_party/icu/source/common/uenum.cpp",
+ "third_party/icu/source/common/uhash.cpp",
+ "third_party/icu/source/common/uhash_us.cpp",
+ "third_party/icu/source/common/uidna.cpp",
+ "third_party/icu/source/common/uinit.cpp",
+ "third_party/icu/source/common/uinvchar.cpp",
+ "third_party/icu/source/common/uiter.cpp",
+ "third_party/icu/source/common/ulist.cpp",
+ "third_party/icu/source/common/uloc.cpp",
+ "third_party/icu/source/common/uloc_keytype.cpp",
+ "third_party/icu/source/common/uloc_tag.cpp",
+ "third_party/icu/source/common/umapfile.cpp",
+ "third_party/icu/source/common/umath.cpp",
+ "third_party/icu/source/common/umutablecptrie.cpp",
+ "third_party/icu/source/common/umutex.cpp",
+ "third_party/icu/source/common/unames.cpp",
+ "third_party/icu/source/common/unifiedcache.cpp",
+ "third_party/icu/source/common/unifilt.cpp",
+ "third_party/icu/source/common/unifunct.cpp",
+ "third_party/icu/source/common/uniset.cpp",
+ "third_party/icu/source/common/uniset_closure.cpp",
+ "third_party/icu/source/common/uniset_props.cpp",
+ "third_party/icu/source/common/unisetspan.cpp",
+ "third_party/icu/source/common/unistr.cpp",
+ "third_party/icu/source/common/unistr_case.cpp",
+ "third_party/icu/source/common/unistr_case_locale.cpp",
+ "third_party/icu/source/common/unistr_cnv.cpp",
+ "third_party/icu/source/common/unistr_props.cpp",
+ "third_party/icu/source/common/unistr_titlecase_brkiter.cpp",
+ "third_party/icu/source/common/unorm.cpp",
+ "third_party/icu/source/common/unormcmp.cpp",
+ "third_party/icu/source/common/uobject.cpp",
+ "third_party/icu/source/common/uprops.cpp",
+ "third_party/icu/source/common/ures_cnv.cpp",
+ "third_party/icu/source/common/uresbund.cpp",
+ "third_party/icu/source/common/uresdata.cpp",
+ "third_party/icu/source/common/usc_impl.cpp",
+ "third_party/icu/source/common/uscript.cpp",
+ "third_party/icu/source/common/uscript_props.cpp",
+ "third_party/icu/source/common/uset.cpp",
+ "third_party/icu/source/common/uset_props.cpp",
+ "third_party/icu/source/common/usetiter.cpp",
+ "third_party/icu/source/common/ushape.cpp",
+ "third_party/icu/source/common/usprep.cpp",
+ "third_party/icu/source/common/ustack.cpp",
+ "third_party/icu/source/common/ustr_cnv.cpp",
+ "third_party/icu/source/common/ustr_titlecase_brkiter.cpp",
+ "third_party/icu/source/common/ustr_wcs.cpp",
+ "third_party/icu/source/common/ustrcase.cpp",
+ "third_party/icu/source/common/ustrcase_locale.cpp",
+ "third_party/icu/source/common/ustrenum.cpp",
+ "third_party/icu/source/common/ustrfmt.cpp",
+ "third_party/icu/source/common/ustring.cpp",
+ "third_party/icu/source/common/ustrtrns.cpp",
+ "third_party/icu/source/common/utext.cpp",
+ "third_party/icu/source/common/utf_impl.cpp",
+ "third_party/icu/source/common/util.cpp",
+ "third_party/icu/source/common/util_props.cpp",
+ "third_party/icu/source/common/utrace.cpp",
+ "third_party/icu/source/common/utrie.cpp",
+ "third_party/icu/source/common/utrie2.cpp",
+ "third_party/icu/source/common/utrie2_builder.cpp",
+ "third_party/icu/source/common/utrie_swap.cpp",
+ "third_party/icu/source/common/uts46.cpp",
+ "third_party/icu/source/common/utypes.cpp",
+ "third_party/icu/source/common/uvector.cpp",
+ "third_party/icu/source/common/uvectr32.cpp",
+ "third_party/icu/source/common/uvectr64.cpp",
+ "third_party/icu/source/common/wintz.cpp",
+ "third_party/icu/source/stubdata/stubdata.cpp",
+ ],
+ host_supported: true,
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DHAVE_DLOPEN=0",
+ "-DICU_UTIL_DATA_IMPL=ICU_UTIL_DATA_FILE",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-DUCONFIG_ONLY_HTML_CONVERSION=1",
+ "-DUCONFIG_USE_WINDOWS_LCID_MAPPING_API=0",
+ "-DUSE_CHROMIUM_ICU=1",
+ "-DU_CHARSET_IS_UTF8=1",
+ "-DU_COMMON_IMPLEMENTATION",
+ "-DU_ENABLE_DYLOAD=0",
+ "-DU_ENABLE_RESOURCE_TRACING=0",
+ "-DU_ENABLE_TRACING=1",
+ "-DU_ICUDATAENTRY_IN_COMMON",
+ "-DU_STATIC_IMPLEMENTATION",
+ "-DU_USING_ICU_NAMESPACE=0",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-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/icu/source/common/",
+ "third_party/icu/source/i18n/",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ rtti: true,
+ target: {
+ 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: //third_party/libevent:libevent
cc_library_static {
name: "cronet_aml_third_party_libevent_libevent",
@@ -10025,11 +33186,20 @@
"-DHAVE_CONFIG_H",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-O2",
+ "-fdata-sections",
+ "-ffunction-sections",
+ "-fno-asynchronous-unwind-tables",
+ "-fno-unwind-tables",
+ "-fvisibility-inlines-hidden",
+ "-fvisibility=hidden",
+ "-g1",
],
local_include_dirs: [
"./",
@@ -10039,7 +33209,24 @@
"third_party/libevent/android/",
],
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",
@@ -10047,12 +33234,582 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //third_party/libevent:libevent__testing
+cc_library_static {
+ name: "cronet_aml_third_party_libevent_libevent__testing",
+ srcs: [
+ "third_party/libevent/buffer.c",
+ "third_party/libevent/epoll.c",
+ "third_party/libevent/evbuffer.c",
+ "third_party/libevent/evdns.c",
+ "third_party/libevent/event.c",
+ "third_party/libevent/event_tagging.c",
+ "third_party/libevent/evrpc.c",
+ "third_party/libevent/evutil.c",
+ "third_party/libevent/http.c",
+ "third_party/libevent/log.c",
+ "third_party/libevent/poll.c",
+ "third_party/libevent/select.c",
+ "third_party/libevent/signal.c",
+ "third_party/libevent/strlcpy.c",
+ ],
+ host_supported: true,
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-DHAVE_CONFIG_H",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-O2",
+ "-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",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ android_arm: {
+ cflags: [
+ "-DANDROID",
+ "-DANDROID_NDK_VERSION_ROLL=r23_1",
+ "-DHAVE_SYS_UIO_H",
+ "-fstack-protector",
+ ],
+ local_include_dirs: [
+ "third_party/libevent/android/",
+ ],
+ },
+ android_arm64: {
+ cflags: [
+ "-DANDROID",
+ "-DANDROID_NDK_VERSION_ROLL=r23_1",
+ "-DHAVE_SYS_UIO_H",
+ "-fstack-protector",
+ "-mno-outline",
+ "-mno-outline-atomics",
+ ],
+ local_include_dirs: [
+ "third_party/libevent/android/",
+ ],
+ },
+ android_x86: {
+ cflags: [
+ "-DANDROID",
+ "-DANDROID_NDK_VERSION_ROLL=r23_1",
+ "-DHAVE_SYS_UIO_H",
+ "-msse3",
+ ],
+ local_include_dirs: [
+ "third_party/libevent/android/",
+ ],
+ },
+ android_x86_64: {
+ cflags: [
+ "-DANDROID",
+ "-DANDROID_NDK_VERSION_ROLL=r23_1",
+ "-DHAVE_SYS_UIO_H",
+ "-fstack-protector",
+ "-msse3",
+ ],
+ local_include_dirs: [
+ "third_party/libevent/android/",
+ ],
+ },
+ 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",
+ "-fstack-protector",
+ "-msse3",
+ ],
+ local_include_dirs: [
+ "third_party/libevent/linux/",
+ ],
+ compile_multilib: "64",
+ },
+ },
+}
+
+// GN: //third_party/libxml:libxml__testing
+cc_library_static {
+ name: "cronet_aml_third_party_libxml_libxml__testing",
+ srcs: [
+ "third_party/libxml/src/HTMLparser.c",
+ "third_party/libxml/src/HTMLtree.c",
+ "third_party/libxml/src/SAX2.c",
+ "third_party/libxml/src/buf.c",
+ "third_party/libxml/src/chvalid.c",
+ "third_party/libxml/src/dict.c",
+ "third_party/libxml/src/encoding.c",
+ "third_party/libxml/src/entities.c",
+ "third_party/libxml/src/error.c",
+ "third_party/libxml/src/globals.c",
+ "third_party/libxml/src/hash.c",
+ "third_party/libxml/src/list.c",
+ "third_party/libxml/src/parser.c",
+ "third_party/libxml/src/parserInternals.c",
+ "third_party/libxml/src/pattern.c",
+ "third_party/libxml/src/threads.c",
+ "third_party/libxml/src/tree.c",
+ "third_party/libxml/src/uri.c",
+ "third_party/libxml/src/valid.c",
+ "third_party/libxml/src/xmlIO.c",
+ "third_party/libxml/src/xmlmemory.c",
+ "third_party/libxml/src/xmlreader.c",
+ "third_party/libxml/src/xmlsave.c",
+ "third_party/libxml/src/xmlstring.c",
+ "third_party/libxml/src/xmlunicode.c",
+ "third_party/libxml/src/xmlwriter.c",
+ "third_party/libxml/src/xpath.c",
+ ],
+ shared_libs: [
+ "libz",
+ ],
+ static_libs: [
+ "cronet_aml_third_party_icu_icuuc_private__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",
+ "-DICU_UTIL_DATA_IMPL=ICU_UTIL_DATA_FILE",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-DUSE_CHROMIUM_ICU=1",
+ "-DU_ENABLE_DYLOAD=0",
+ "-DU_ENABLE_RESOURCE_TRACING=0",
+ "-DU_ENABLE_TRACING=1",
+ "-DU_STATIC_IMPLEMENTATION",
+ "-DU_USING_ICU_NAMESPACE=0",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_REENTRANT",
+ "-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/icu/source/common/",
+ "third_party/icu/source/i18n/",
+ "third_party/libxml/linux/",
+ "third_party/libxml/linux/include/",
+ "third_party/libxml/src/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/libxml:libxml_utils__testing
+cc_library_static {
+ name: "cronet_aml_third_party_libxml_libxml_utils__testing",
+ srcs: [
+ "third_party/libxml/chromium/libxml_utils.cc",
+ ],
+ shared_libs: [
+ "libz",
+ ],
+ static_libs: [
+ "cronet_aml_third_party_icu_icuuc_private__testing",
+ "cronet_aml_third_party_libxml_libxml__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",
+ "-DICU_UTIL_DATA_IMPL=ICU_UTIL_DATA_FILE",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-DUSE_CHROMIUM_ICU=1",
+ "-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",
+ "third_party/icu/source/common/",
+ "third_party/icu/source/i18n/",
+ "third_party/libxml/linux/include/",
+ "third_party/libxml/src/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/libxml:xml_reader__testing
+cc_library_static {
+ name: "cronet_aml_third_party_libxml_xml_reader__testing",
+ srcs: [
+ "third_party/libxml/chromium/xml_reader.cc",
+ ],
+ shared_libs: [
+ "libz",
+ ],
+ static_libs: [
+ "cronet_aml_third_party_icu_icuuc_private__testing",
+ "cronet_aml_third_party_libxml_libxml__testing",
+ "cronet_aml_third_party_libxml_libxml_utils__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",
+ "-DICU_UTIL_DATA_IMPL=ICU_UTIL_DATA_FILE",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-DUSE_CHROMIUM_ICU=1",
+ "-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",
+ "third_party/icu/source/common/",
+ "third_party/icu/source/i18n/",
+ "third_party/libxml/linux/include/",
+ "third_party/libxml/src/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/metrics_proto:metrics_proto__testing
+cc_genrule {
+ name: "cronet_aml_third_party_metrics_proto_metrics_proto__testing_gen",
+ srcs: [
+ "third_party/metrics_proto/call_stack_profile.proto",
+ "third_party/metrics_proto/cast_logs.proto",
+ "third_party/metrics_proto/chrome_os_app_list_launch_event.proto",
+ "third_party/metrics_proto/chrome_searchbox_stats.proto",
+ "third_party/metrics_proto/chrome_user_metrics_extension.proto",
+ "third_party/metrics_proto/custom_tab_session.proto",
+ "third_party/metrics_proto/execution_context.proto",
+ "third_party/metrics_proto/extension_install.proto",
+ "third_party/metrics_proto/histogram_event.proto",
+ "third_party/metrics_proto/omnibox_event.proto",
+ "third_party/metrics_proto/omnibox_focus_type.proto",
+ "third_party/metrics_proto/omnibox_input_type.proto",
+ "third_party/metrics_proto/perf_data.proto",
+ "third_party/metrics_proto/perf_stat.proto",
+ "third_party/metrics_proto/printer_event.proto",
+ "third_party/metrics_proto/reporting_info.proto",
+ "third_party/metrics_proto/sampled_profile.proto",
+ "third_party/metrics_proto/structured_data.proto",
+ "third_party/metrics_proto/system_profile.proto",
+ "third_party/metrics_proto/trace_log.proto",
+ "third_party/metrics_proto/translate_event.proto",
+ "third_party/metrics_proto/ukm/aggregate.proto",
+ "third_party/metrics_proto/ukm/entry.proto",
+ "third_party/metrics_proto/ukm/report.proto",
+ "third_party/metrics_proto/ukm/source.proto",
+ "third_party/metrics_proto/user_action_event.proto",
+ "third_party/metrics_proto/user_demographics.proto",
+ ],
+ tools: [
+ "cronet_aml_third_party_protobuf_protoc",
+ ],
+ cmd: "$(location cronet_aml_third_party_protobuf_protoc) --proto_path=external/cronet/third_party/metrics_proto --cpp_out=lite=true:$(genDir)/external/cronet/third_party/metrics_proto/ $(in)",
+ out: [
+ "external/cronet/third_party/metrics_proto/call_stack_profile.pb.cc",
+ "external/cronet/third_party/metrics_proto/cast_logs.pb.cc",
+ "external/cronet/third_party/metrics_proto/chrome_os_app_list_launch_event.pb.cc",
+ "external/cronet/third_party/metrics_proto/chrome_searchbox_stats.pb.cc",
+ "external/cronet/third_party/metrics_proto/chrome_user_metrics_extension.pb.cc",
+ "external/cronet/third_party/metrics_proto/custom_tab_session.pb.cc",
+ "external/cronet/third_party/metrics_proto/execution_context.pb.cc",
+ "external/cronet/third_party/metrics_proto/extension_install.pb.cc",
+ "external/cronet/third_party/metrics_proto/histogram_event.pb.cc",
+ "external/cronet/third_party/metrics_proto/omnibox_event.pb.cc",
+ "external/cronet/third_party/metrics_proto/omnibox_focus_type.pb.cc",
+ "external/cronet/third_party/metrics_proto/omnibox_input_type.pb.cc",
+ "external/cronet/third_party/metrics_proto/perf_data.pb.cc",
+ "external/cronet/third_party/metrics_proto/perf_stat.pb.cc",
+ "external/cronet/third_party/metrics_proto/printer_event.pb.cc",
+ "external/cronet/third_party/metrics_proto/reporting_info.pb.cc",
+ "external/cronet/third_party/metrics_proto/sampled_profile.pb.cc",
+ "external/cronet/third_party/metrics_proto/structured_data.pb.cc",
+ "external/cronet/third_party/metrics_proto/system_profile.pb.cc",
+ "external/cronet/third_party/metrics_proto/trace_log.pb.cc",
+ "external/cronet/third_party/metrics_proto/translate_event.pb.cc",
+ "external/cronet/third_party/metrics_proto/ukm/aggregate.pb.cc",
+ "external/cronet/third_party/metrics_proto/ukm/entry.pb.cc",
+ "external/cronet/third_party/metrics_proto/ukm/report.pb.cc",
+ "external/cronet/third_party/metrics_proto/ukm/source.pb.cc",
+ "external/cronet/third_party/metrics_proto/user_action_event.pb.cc",
+ "external/cronet/third_party/metrics_proto/user_demographics.pb.cc",
+ ],
+ apex_available: [
+ "com.android.tethering",
+ ],
+}
+
+// GN: //third_party/metrics_proto:metrics_proto__testing
+cc_genrule {
+ name: "cronet_aml_third_party_metrics_proto_metrics_proto__testing_gen_headers",
+ srcs: [
+ "third_party/metrics_proto/call_stack_profile.proto",
+ "third_party/metrics_proto/cast_logs.proto",
+ "third_party/metrics_proto/chrome_os_app_list_launch_event.proto",
+ "third_party/metrics_proto/chrome_searchbox_stats.proto",
+ "third_party/metrics_proto/chrome_user_metrics_extension.proto",
+ "third_party/metrics_proto/custom_tab_session.proto",
+ "third_party/metrics_proto/execution_context.proto",
+ "third_party/metrics_proto/extension_install.proto",
+ "third_party/metrics_proto/histogram_event.proto",
+ "third_party/metrics_proto/omnibox_event.proto",
+ "third_party/metrics_proto/omnibox_focus_type.proto",
+ "third_party/metrics_proto/omnibox_input_type.proto",
+ "third_party/metrics_proto/perf_data.proto",
+ "third_party/metrics_proto/perf_stat.proto",
+ "third_party/metrics_proto/printer_event.proto",
+ "third_party/metrics_proto/reporting_info.proto",
+ "third_party/metrics_proto/sampled_profile.proto",
+ "third_party/metrics_proto/structured_data.proto",
+ "third_party/metrics_proto/system_profile.proto",
+ "third_party/metrics_proto/trace_log.proto",
+ "third_party/metrics_proto/translate_event.proto",
+ "third_party/metrics_proto/ukm/aggregate.proto",
+ "third_party/metrics_proto/ukm/entry.proto",
+ "third_party/metrics_proto/ukm/report.proto",
+ "third_party/metrics_proto/ukm/source.proto",
+ "third_party/metrics_proto/user_action_event.proto",
+ "third_party/metrics_proto/user_demographics.proto",
+ ],
+ tools: [
+ "cronet_aml_third_party_protobuf_protoc",
+ ],
+ cmd: "$(location cronet_aml_third_party_protobuf_protoc) --proto_path=external/cronet/third_party/metrics_proto --cpp_out=lite=true:$(genDir)/external/cronet/third_party/metrics_proto/ $(in)",
+ out: [
+ "external/cronet/third_party/metrics_proto/call_stack_profile.pb.h",
+ "external/cronet/third_party/metrics_proto/cast_logs.pb.h",
+ "external/cronet/third_party/metrics_proto/chrome_os_app_list_launch_event.pb.h",
+ "external/cronet/third_party/metrics_proto/chrome_searchbox_stats.pb.h",
+ "external/cronet/third_party/metrics_proto/chrome_user_metrics_extension.pb.h",
+ "external/cronet/third_party/metrics_proto/custom_tab_session.pb.h",
+ "external/cronet/third_party/metrics_proto/execution_context.pb.h",
+ "external/cronet/third_party/metrics_proto/extension_install.pb.h",
+ "external/cronet/third_party/metrics_proto/histogram_event.pb.h",
+ "external/cronet/third_party/metrics_proto/omnibox_event.pb.h",
+ "external/cronet/third_party/metrics_proto/omnibox_focus_type.pb.h",
+ "external/cronet/third_party/metrics_proto/omnibox_input_type.pb.h",
+ "external/cronet/third_party/metrics_proto/perf_data.pb.h",
+ "external/cronet/third_party/metrics_proto/perf_stat.pb.h",
+ "external/cronet/third_party/metrics_proto/printer_event.pb.h",
+ "external/cronet/third_party/metrics_proto/reporting_info.pb.h",
+ "external/cronet/third_party/metrics_proto/sampled_profile.pb.h",
+ "external/cronet/third_party/metrics_proto/structured_data.pb.h",
+ "external/cronet/third_party/metrics_proto/system_profile.pb.h",
+ "external/cronet/third_party/metrics_proto/trace_log.pb.h",
+ "external/cronet/third_party/metrics_proto/translate_event.pb.h",
+ "external/cronet/third_party/metrics_proto/ukm/aggregate.pb.h",
+ "external/cronet/third_party/metrics_proto/ukm/entry.pb.h",
+ "external/cronet/third_party/metrics_proto/ukm/report.pb.h",
+ "external/cronet/third_party/metrics_proto/ukm/source.pb.h",
+ "external/cronet/third_party/metrics_proto/user_action_event.pb.h",
+ "external/cronet/third_party/metrics_proto/user_demographics.pb.h",
+ ],
+ export_include_dirs: [
+ ".",
+ "protos",
+ "third_party/metrics_proto",
+ ],
+ apex_available: [
+ "com.android.tethering",
+ ],
+}
+
// GN: //third_party/metrics_proto:metrics_proto
cc_genrule {
name: "cronet_aml_third_party_metrics_proto_metrics_proto_gen",
@@ -10215,6 +33972,7 @@
"-DDYNAMIC_ANNOTATIONS_ENABLED=0",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-D_FORTIFY_SOURCE=2",
@@ -10223,6 +33981,14 @@
"-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: [
"./",
@@ -10231,7 +33997,24 @@
"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",
@@ -10239,12 +34022,114 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
"-msse3",
],
},
},
}
+// GN: //third_party/modp_b64:modp_b64__testing
+cc_library_static {
+ name: "cronet_aml_third_party_modp_b64_modp_b64__testing",
+ srcs: [
+ "third_party/modp_b64/modp_b64.cc",
+ ],
+ host_supported: true,
+ defaults: [
+ "cronet_aml_defaults",
+ ],
+ cflags: [
+ "-DCR_CLANG_REVISION=\"llvmorg-16-init-6578-g0d30e92f-2\"",
+ "-DCR_LIBCXX_REVISION=64d36e572d3f9719c5d75011a718f33f11126851",
+ "-DDYNAMIC_ANNOTATIONS_ENABLED=0",
+ "-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",
+ "-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",
+ ],
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
+ target: {
+ 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: //third_party/protobuf:protobuf_full
cc_library_static {
name: "cronet_aml_third_party_protobuf_protobuf_full",
@@ -10365,6 +34250,15 @@
"-D_LARGEFILE_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-O2",
+ "-fdata-sections",
+ "-ffunction-sections",
+ "-fno-asynchronous-unwind-tables",
+ "-fno-unwind-tables",
+ "-fstack-protector",
+ "-fvisibility-inlines-hidden",
+ "-fvisibility=hidden",
+ "-g1",
"-msse3",
],
local_include_dirs: [
@@ -10375,6 +34269,11 @@
"third_party/protobuf/src/",
],
cpp_std: "c++20",
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
}
// GN: //third_party/protobuf:protobuf_lite
@@ -10432,11 +34331,20 @@
"-DHAVE_PTHREAD",
"-DHAVE_SYS_UIO_H",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-D_GNU_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-O2",
+ "-fdata-sections",
+ "-ffunction-sections",
+ "-fno-asynchronous-unwind-tables",
+ "-fno-unwind-tables",
+ "-fvisibility-inlines-hidden",
+ "-fvisibility=hidden",
+ "-g1",
],
local_include_dirs: [
"./",
@@ -10446,7 +34354,24 @@
"third_party/protobuf/src/",
],
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",
@@ -10454,6 +34379,117 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
+ "-msse3",
+ ],
+ },
+ },
+}
+
+// GN: //third_party/protobuf:protobuf_lite__testing
+cc_library_static {
+ name: "cronet_aml_third_party_protobuf_protobuf_lite__testing",
+ srcs: [
+ "third_party/protobuf/src/google/protobuf/any_lite.cc",
+ "third_party/protobuf/src/google/protobuf/arena.cc",
+ "third_party/protobuf/src/google/protobuf/arenastring.cc",
+ "third_party/protobuf/src/google/protobuf/arenaz_sampler.cc",
+ "third_party/protobuf/src/google/protobuf/extension_set.cc",
+ "third_party/protobuf/src/google/protobuf/generated_enum_util.cc",
+ "third_party/protobuf/src/google/protobuf/generated_message_tctable_lite.cc",
+ "third_party/protobuf/src/google/protobuf/generated_message_util.cc",
+ "third_party/protobuf/src/google/protobuf/implicit_weak_message.cc",
+ "third_party/protobuf/src/google/protobuf/inlined_string_field.cc",
+ "third_party/protobuf/src/google/protobuf/io/coded_stream.cc",
+ "third_party/protobuf/src/google/protobuf/io/io_win32.cc",
+ "third_party/protobuf/src/google/protobuf/io/strtod.cc",
+ "third_party/protobuf/src/google/protobuf/io/zero_copy_stream.cc",
+ "third_party/protobuf/src/google/protobuf/io/zero_copy_stream_impl.cc",
+ "third_party/protobuf/src/google/protobuf/io/zero_copy_stream_impl_lite.cc",
+ "third_party/protobuf/src/google/protobuf/map.cc",
+ "third_party/protobuf/src/google/protobuf/message_lite.cc",
+ "third_party/protobuf/src/google/protobuf/parse_context.cc",
+ "third_party/protobuf/src/google/protobuf/repeated_field.cc",
+ "third_party/protobuf/src/google/protobuf/repeated_ptr_field.cc",
+ "third_party/protobuf/src/google/protobuf/stubs/bytestream.cc",
+ "third_party/protobuf/src/google/protobuf/stubs/common.cc",
+ "third_party/protobuf/src/google/protobuf/stubs/int128.cc",
+ "third_party/protobuf/src/google/protobuf/stubs/status.cc",
+ "third_party/protobuf/src/google/protobuf/stubs/statusor.cc",
+ "third_party/protobuf/src/google/protobuf/stubs/stringpiece.cc",
+ "third_party/protobuf/src/google/protobuf/stubs/stringprintf.cc",
+ "third_party/protobuf/src/google/protobuf/stubs/structurally_valid.cc",
+ "third_party/protobuf/src/google/protobuf/stubs/strutil.cc",
+ "third_party/protobuf/src/google/protobuf/stubs/time.cc",
+ "third_party/protobuf/src/google/protobuf/wire_format_lite.cc",
+ ],
+ shared_libs: [
+ "liblog",
+ ],
+ 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",
+ "-DHAVE_PTHREAD",
+ "-DHAVE_SYS_UIO_H",
+ "-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
+ "-DNVALGRIND",
+ "-DOFFICIAL_BUILD",
+ "-D_GNU_SOURCE",
+ "-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-O2",
+ "-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/protobuf/src/",
+ ],
+ 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",
],
},
@@ -10464,14 +34500,14 @@
cc_binary {
name: "cronet_aml_third_party_protobuf_protoc",
srcs: [
- ":cronet_aml_buildtools_third_party_libc___libc__",
- ":cronet_aml_buildtools_third_party_libc__abi_libc__abi",
"third_party/protobuf/src/google/protobuf/compiler/main.cc",
],
shared_libs: [
"libz",
],
static_libs: [
+ "cronet_aml_buildtools_third_party_libc___libc__",
+ "cronet_aml_buildtools_third_party_libc__abi_libc__abi",
"cronet_aml_third_party_protobuf_protobuf_full",
"cronet_aml_third_party_protobuf_protoc_lib",
],
@@ -10502,6 +34538,15 @@
"-D_LARGEFILE_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-O2",
+ "-fdata-sections",
+ "-ffunction-sections",
+ "-fno-asynchronous-unwind-tables",
+ "-fno-unwind-tables",
+ "-fstack-protector",
+ "-fvisibility-inlines-hidden",
+ "-fvisibility=hidden",
+ "-g1",
"-msse3",
],
local_include_dirs: [
@@ -10512,6 +34557,11 @@
"third_party/protobuf/src/",
],
cpp_std: "c++20",
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
}
// GN: //third_party/protobuf:protoc_lib
@@ -10637,6 +34687,15 @@
"-D_LARGEFILE_SOURCE",
"-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS",
"-D_LIBCXXABI_DISABLE_VISIBILITY_ANNOTATIONS",
+ "-O2",
+ "-fdata-sections",
+ "-ffunction-sections",
+ "-fno-asynchronous-unwind-tables",
+ "-fno-unwind-tables",
+ "-fstack-protector",
+ "-fvisibility-inlines-hidden",
+ "-fvisibility=hidden",
+ "-g1",
"-msse3",
],
local_include_dirs: [
@@ -10647,6 +34706,11 @@
"third_party/protobuf/src/",
],
cpp_std: "c++20",
+ ldflags: [
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
+ ],
}
// GN: //url:buildflags
@@ -10672,6 +34736,29 @@
],
}
+// GN: //url:buildflags__testing
+cc_genrule {
+ name: "cronet_aml_url_buildflags__testing",
+ cmd: "echo '--flags USE_PLATFORM_ICU_ALTERNATIVES=\"true\"' | " +
+ "$(location build/write_buildflag_header.py) --output " +
+ "$(out) " +
+ "--rulename " +
+ "//url:buildflags " +
+ "--gen-dir " +
+ ". " +
+ "--definitions " +
+ "/dev/stdin",
+ out: [
+ "url/buildflags.h",
+ ],
+ tool_files: [
+ "build/write_buildflag_header.py",
+ ],
+ apex_available: [
+ "com.android.tethering",
+ ],
+}
+
// GN: //url:url
cc_library_static {
name: "cronet_aml_url_url",
@@ -10707,9 +34794,60 @@
"cronet_aml_base_allocator_partition_allocator_partition_alloc",
"cronet_aml_base_base",
"cronet_aml_base_base_static",
+ "cronet_aml_base_nodebug_assertion",
"cronet_aml_base_third_party_double_conversion_double_conversion",
"cronet_aml_base_third_party_dynamic_annotations_dynamic_annotations",
+ "cronet_aml_third_party_abseil_cpp_absl_base_base",
+ "cronet_aml_third_party_abseil_cpp_absl_base_log_severity",
+ "cronet_aml_third_party_abseil_cpp_absl_base_malloc_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_raw_logging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_base_spinlock_wait",
+ "cronet_aml_third_party_abseil_cpp_absl_base_strerror",
+ "cronet_aml_third_party_abseil_cpp_absl_base_throw_delegate",
+ "cronet_aml_third_party_abseil_cpp_absl_container_hashtablez_sampler",
+ "cronet_aml_third_party_abseil_cpp_absl_container_raw_hash_set",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_debugging_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_demangle_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_examine_stack",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_failure_signal_handler",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_stacktrace",
+ "cronet_aml_third_party_abseil_cpp_absl_debugging_symbolize",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_city",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_hash",
+ "cronet_aml_third_party_abseil_cpp_absl_hash_low_level_hash",
+ "cronet_aml_third_party_abseil_cpp_absl_numeric_int128",
+ "cronet_aml_third_party_abseil_cpp_absl_profiling_exponential_biased",
+ "cronet_aml_third_party_abseil_cpp_absl_random_distributions",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_platform",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_pool_urbg",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_hwaes_impl",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_randen_slow",
+ "cronet_aml_third_party_abseil_cpp_absl_random_internal_seed_material",
+ "cronet_aml_third_party_abseil_cpp_absl_random_seed_gen_exception",
+ "cronet_aml_third_party_abseil_cpp_absl_random_seed_sequences",
+ "cronet_aml_third_party_abseil_cpp_absl_status_status",
+ "cronet_aml_third_party_abseil_cpp_absl_status_statusor",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cord",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cord_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_functions",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_handle",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_cordz_info",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_str_format_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_strings_strings",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_graphcycles_internal",
+ "cronet_aml_third_party_abseil_cpp_absl_synchronization_synchronization",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_civil_time",
+ "cronet_aml_third_party_abseil_cpp_absl_time_internal_cctz_time_zone",
+ "cronet_aml_third_party_abseil_cpp_absl_time_time",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_optional_access",
+ "cronet_aml_third_party_abseil_cpp_absl_types_bad_variant_access",
+ "cronet_aml_third_party_android_ndk_cpu_features",
+ "cronet_aml_third_party_ashmem_ashmem",
"cronet_aml_third_party_boringssl_boringssl",
+ "cronet_aml_third_party_boringssl_boringssl_asm",
"cronet_aml_third_party_icu_icui18n",
"cronet_aml_third_party_icu_icuuc_private",
"cronet_aml_third_party_libevent_libevent",
@@ -10741,6 +34879,7 @@
"-DHAVE_SYS_UIO_H",
"-DIS_URL_IMPL",
"-DNDEBUG",
+ "-DNO_UNWIND_TABLES",
"-DNVALGRIND",
"-DOFFICIAL_BUILD",
"-D_FORTIFY_SOURCE=2",
@@ -10749,6 +34888,14 @@
"-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: [
"./",
@@ -10759,7 +34906,40 @@
"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",
@@ -10767,6 +34947,202 @@
},
android_x86_64: {
cflags: [
+ "-fstack-protector",
+ "-msse3",
+ ],
+ },
+ },
+}
+
+// GN: //url:url__testing
+cc_library_static {
+ name: "cronet_aml_url_url__testing",
+ srcs: [
+ "url/gurl.cc",
+ "url/origin.cc",
+ "url/scheme_host_port.cc",
+ "url/third_party/mozilla/url_parse.cc",
+ "url/url_canon.cc",
+ "url/url_canon_etc.cc",
+ "url/url_canon_filesystemurl.cc",
+ "url/url_canon_fileurl.cc",
+ "url/url_canon_host.cc",
+ "url/url_canon_internal.cc",
+ "url/url_canon_ip.cc",
+ "url/url_canon_mailtourl.cc",
+ "url/url_canon_path.cc",
+ "url/url_canon_pathurl.cc",
+ "url/url_canon_query.cc",
+ "url/url_canon_relative.cc",
+ "url/url_canon_stdstring.cc",
+ "url/url_canon_stdurl.cc",
+ "url/url_constants.cc",
+ "url/url_idna_icu_alternatives_android.cc",
+ "url/url_parse_file.cc",
+ "url/url_util.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_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_base_debugging_buildflags__testing",
+ "cronet_aml_base_logging_buildflags__testing",
+ "cronet_aml_build_chromeos_buildflags__testing",
+ "cronet_aml_url_buildflags__testing",
+ "cronet_aml_url_url_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_url_buildflags__testing",
+ "cronet_aml_url_url_jni_headers__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",
+ "-DIS_URL_IMPL",
+ "-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",
],
},
@@ -10813,6 +35189,44 @@
],
}
+// GN: //url:url_jni_headers__testing
+cc_genrule {
+ name: "cronet_aml_url_url_jni_headers__testing",
+ srcs: [
+ "url/android/java/src/org/chromium/url/IDNStringUtil.java",
+ "url/android/java/src/org/chromium/url/Origin.java",
+ ],
+ cmd: "$(location base/android/jni_generator/jni_generator.py) --ptr_type " +
+ "long " +
+ "--output_dir " +
+ "$(genDir)/url/url_jni_headers " +
+ "--includes " +
+ "base/android/jni_generator/jni_generator_helper.h " +
+ "--use_proxy_hash " +
+ "--output_name " +
+ "IDNStringUtil_jni.h " +
+ "--output_name " +
+ "Origin_jni.h " +
+ "--input_file " +
+ "$(location url/android/java/src/org/chromium/url/IDNStringUtil.java) " +
+ "--input_file " +
+ "$(location url/android/java/src/org/chromium/url/Origin.java)",
+ out: [
+ "url/url_jni_headers/IDNStringUtil_jni.h",
+ "url/url_jni_headers/Origin_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: LICENSE
license {
name: "external_cronet_license",
@@ -10821,15 +35235,11 @@
"SPDX-license-identifier-Apache-2.0",
"SPDX-license-identifier-BSD",
"SPDX-license-identifier-BSL-1.0",
- "SPDX-license-identifier-GPL",
- "SPDX-license-identifier-GPL-2.0",
- "SPDX-license-identifier-GPL-3.0",
"SPDX-license-identifier-ICU",
"SPDX-license-identifier-ISC",
- "SPDX-license-identifier-LGPL",
- "SPDX-license-identifier-LGPL-2.1",
"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",
diff --git a/tools/gn2bp/desc_arm.json b/tools/gn2bp/desc_arm.json
index ff1a7e2..87b86e3 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 20c942f..7b8bfe3 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 b25932b..df8635a 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 b4bc6e9..707b9c7 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 9d2d858..d714a90 100755
--- a/tools/gn2bp/gen_android_bp
+++ b/tools/gn2bp/gen_android_bp
@@ -40,11 +40,18 @@
ROOT_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
# Default targets to translate to the blueprint file.
-default_targets = [
+DEFAULT_TARGETS = [
'//components/cronet/android:cronet',
'//components/cronet/android:cronet_android_mainline',
]
+DEFAULT_TESTS = [
+ '//components/cronet/android:cronet_unittests_android__library',
+]
+
+EXTRAS_ANDROID_BP_FILE = "Android.extras.bp"
+
+CRONET_API_MODULE_NAME = "cronet_aml_api_java"
# Defines a custom init_rc argument to be applied to the corresponding output
# blueprint target.
target_initrc = {
@@ -126,6 +133,30 @@
"-msse3",
# needed for zlib:zlib
"-msse4.2",
+ # flags to reduce binary size
+ "-O1",
+ "-O2",
+ "-O3",
+ "-Oz",
+ "-g1",
+ "-g2",
+ "-fdata-sections",
+ "-ffunction-sections",
+ "-fvisibility=hidden",
+ "-fvisibility-inlines-hidden",
+ "-fstack-protector",
+ "-mno-outline",
+ "-mno-outline-atomics",
+ "-fno-asynchronous-unwind-tables",
+ "-fno-unwind-tables",
+]
+
+# Linker flags which are passed through to the blueprint.
+ldflag_allowlist = [
+ # flags to reduce binary size
+ "-Wl,--as-needed",
+ "-Wl,--gc-sections",
+ "-Wl,--icf=all",
]
def get_linker_script_ldflag(script_path):
@@ -133,14 +164,6 @@
# Additional arguments to apply to Android.bp rules.
additional_args = {
- # TODO: remove if not needed.
- 'cronet_aml_components_cronet_android_cronet': [
- # linker_scripts property is not available in tm-mainline-prod.
- # So use ldflags to specify linker script.
- ('ldflags',{
- get_linker_script_ldflag('base/android/library_loader/anchor_functions.lds'),
- }),
- ],
'cronet_aml_net_net': [
('export_static_lib_headers', {
'cronet_aml_net_third_party_quiche_quiche',
@@ -195,12 +218,20 @@
builtin_deps = {
'//buildtools/third_party/libunwind:libunwind':
lambda m, a: None, # disable libunwind
+ '//buildtools/third_party/libunwind:libunwind__testing':
+ lambda m, a: None, # disable libunwind
'//net/data/ssl/chrome_root_store:gen_root_store_inc':
lambda m, a: None,
+ '//net/data/ssl/chrome_root_store:gen_root_store_inc__testing':
+ lambda m, a: None,
'//net/tools/root_store_tool:root_store_tool':
lambda m, a: None,
+ '//net/tools/root_store_tool:root_store_tool__testing':
+ lambda m, a: None,
'//third_party/zlib:zlib':
enable_zlib,
+ '//third_party/zlib:zlib__testing':
+ enable_zlib,
}
experimental_android_deps = {
@@ -296,6 +327,10 @@
self.export_system_include_dirs = set()
self.generated_headers = set()
self.export_generated_headers = set()
+ self.ldflags = set()
+ self.compile_multilib = None
+ if name == 'host':
+ self.compile_multilib = '64'
def to_string(self, output):
nested_out = []
@@ -313,8 +348,12 @@
self._output_field(nested_out, 'export_system_include_dirs')
self._output_field(nested_out, 'generated_headers')
self._output_field(nested_out, 'export_generated_headers')
+ self._output_field(nested_out, 'ldflags')
if nested_out:
+ # This is added here to make sure it doesn't add a `host` arch-specific module just for
+ # `compile_multilib` flag.
+ self._output_field(nested_out, 'compile_multilib')
output.append(' %s: {' % self.name)
for line in nested_out:
output.append(' %s' % line)
@@ -493,6 +532,12 @@
else:
self.shared_libs.add(lib)
+ def is_test(self):
+ if gn_utils.TESTING_SUFFIX in self.name:
+ name_without_prefix = self.name[:self.name.find(gn_utils.TESTING_SUFFIX)]
+ return any([name_without_prefix == label_to_module_name(target) for target in DEFAULT_TESTS])
+ return False
+
def _output_field(self, output, name, sort=True):
value = getattr(self, name)
return write_blueprint_key_value(output, name, value, sort)
@@ -504,7 +549,13 @@
return self.type == "cc_genrule"
def has_input_files(self):
- return len(self.srcs) > 0 or any([len(target.srcs) > 0 for target in self.target.values()])
+ if len(self.srcs) > 0:
+ return True
+ if any([len(target.srcs) > 0 for target in self.target.values()]):
+ return True
+ # Allow cc_static_library with export_generated_headers as those are crucial for
+ # the depending modules
+ return len(self.export_generated_headers) > 0
def merge_attribute(self, key, source_module, allowed_archs, source_key = None):
"""
@@ -546,8 +597,8 @@
def to_string(self, output):
for m in sorted(self.modules.values(), key=lambda m: m.name):
- if m.type != "cc_object" or m.has_input_files():
- # Don't print cc_object with empty srcs. These attributes are already
+ if m.type != "cc_library_static" or m.has_input_files():
+ # Don't print cc_library_static with empty srcs. These attributes are already
# propagated up the tree. Printing them messes the presubmits because
# every module is compiled while those targets are not reachable in
# a normal compilation path.
@@ -912,6 +963,9 @@
files = self.target.sources.union(self.target.inputs)
return {gn_utils.label_to_path(file) for file in files if is_supported_source_file(file)}
+ def get_tools(self):
+ return set()
+
def get_tool_files(self):
# gn treats inputs and sources for actions equally.
# soong only supports source files inside srcs, non-source files are added as
@@ -958,7 +1012,40 @@
self._set_value_arg('--output', '$(out)')
super()._sanitize_args()
+class GnRunBinary(BaseActionSanitizer):
+ def __init__(self, target, arch):
+ super().__init__(target, arch)
+ self.binary_to_target = {
+ "clang_x64/transport_security_state_generator":
+ "cronet_aml_net_tools_transport_security_state_generator_transport_security_state_generator__testing",
+ }
+ self.binary = self.binary_to_target[self.target.args[0]]
+
+ def _replace_gen_with_location_tag(self, arg):
+ if arg.startswith("gen/"):
+ return "$(location %s)" % arg.replace("gen/", "")
+ return 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)
+ super()._sanitize_args()
+
+ def get_tools(self):
+ tools = super().get_tools()
+ tools.add(self.binary)
+ return tools
+
+ def get_cmd(self):
+ # Remove the script and use the binary right away
+ return NEWLINE.join(self.target.args)
+
class JniGeneratorSanitizer(BaseActionSanitizer):
+ def __init__(self, target, arch, is_test_target):
+ self.is_test_target = is_test_target
+ super().__init__(target, arch)
+
def _add_location_tag_to_filepath(self, arg):
if not arg.endswith('.class'):
# --input_file supports both .class specifiers or source files as arguments.
@@ -975,7 +1062,9 @@
self._delete_value_arg('--prev_output_dir', False)
self._update_list_arg('--input_file', self._sanitize_filepath)
self._update_list_arg('--input_file', self._add_location_tag_to_filepath)
- self._append_arg('--package_prefix', 'android.net.http.internal')
+ if not self.is_test_target:
+ # Only jarjar platform code
+ self._append_arg('--package_prefix', 'android.net.http.internal')
super()._sanitize_args()
def _sanitize_outputs(self):
@@ -995,6 +1084,10 @@
return tool_files
class JniRegistrationGeneratorSanitizer(BaseActionSanitizer):
+ def __init__(self, target, arch, is_test_target):
+ self.is_test_target = is_test_target
+ super().__init__(target, arch)
+
def _sanitize_inputs(self):
self.target.inputs = [file for file in self.target.inputs if not file.startswith('//out/')]
@@ -1006,7 +1099,9 @@
# update_jni_registration_module removes them from the srcs of the module
# It might be better to remove sources by '--sources-exclusions'
self._delete_value_arg('--sources-exclusions')
- self._append_arg('--package_prefix', 'android.net.http.internal')
+ if not self.is_test_target:
+ # Only jarjar platform code
+ self._append_arg('--package_prefix', 'android.net.http.internal')
super()._sanitize_args()
def get_cmd(self):
@@ -1031,7 +1126,10 @@
class JavaJniRegistrationGeneratorSanitizer(JniRegistrationGeneratorSanitizer):
def get_name(self):
- return label_to_module_name(self.target.name) + "__java"
+ name = super().get_name() + "__java"
+ if self.is_test_target:
+ name += gn_utils.TESTING_SUFFIX
+ return name
def _sanitize_outputs(self):
self.target.outputs = [out for out in self.target.outputs if
@@ -1082,18 +1180,18 @@
self._set_value_arg('--output', '$(out)')
super()._sanitize_args()
-def get_action_sanitizer(target, type, arch):
+def get_action_sanitizer(target, type, arch, is_test_target):
if target.script == "//build/write_buildflag_header.py":
return WriteBuildFlagHeaderSanitizer(target, arch)
elif target.script == "//build/write_build_date_header.py":
return WriteBuildDateHeaderSanitizer(target, arch)
elif target.script == '//base/android/jni_generator/jni_generator.py':
- return JniGeneratorSanitizer(target, arch)
+ return JniGeneratorSanitizer(target, arch, is_test_target)
elif target.script == '//base/android/jni_generator/jni_registration_generator.py':
if type == 'java_genrule':
- return JavaJniRegistrationGeneratorSanitizer(target, arch)
+ return JavaJniRegistrationGeneratorSanitizer(target, arch, is_test_target)
else:
- return JniRegistrationGeneratorSanitizer(target, arch)
+ return JniRegistrationGeneratorSanitizer(target, arch, is_test_target)
elif target.script == "//build/util/version.py":
return VersionSanitizer(target, arch)
elif target.script == "//build/android/gyp/java_cpp_enum.py":
@@ -1106,11 +1204,13 @@
return JavaCppStringSanitizer(target, arch)
elif target.script == '//build/android/gyp/write_native_libraries_java.py':
return WriteNativeLibrariesJavaSanitizer(target, arch)
+ elif target.script == '//build/gn_run_binary.py':
+ return GnRunBinary(target, arch)
else:
# TODO: throw exception here once all script hacks have been converted.
return BaseActionSanitizer(target, arch)
-def create_action_foreach_modules(blueprint, target):
+def create_action_foreach_modules(blueprint, target, is_test_target):
""" The following assumes that rebase_path exists in the args.
The args of an action_foreach contains hints about which output files are generated
by which source files.
@@ -1141,10 +1241,10 @@
new_args.append(arg)
target.args = new_args
- return create_action_module(blueprint, target, 'cc_genrule')
+ return create_action_module(blueprint, target, 'cc_genrule', is_test_target)
-def create_action_module_internal(target, type, arch=None):
- sanitizer = get_action_sanitizer(target, type, arch)
+def create_action_module_internal(target, type, is_test_target, arch=None):
+ sanitizer = get_action_sanitizer(target, type, arch, is_test_target)
sanitizer.sanitize()
module = Module(type, sanitizer.get_name(), target.name)
@@ -1154,6 +1254,7 @@
module.genrule_headers.add(module.name)
module.srcs = sanitizer.get_srcs()
module.tool_files = sanitizer.get_tool_files()
+ module.tools = sanitizer.get_tools()
return module
@@ -1213,7 +1314,7 @@
merged_module.cmd = merge_cmd(modules, genrule_type)
return merged_module
-def create_action_module(blueprint, target, genrule_type):
+def create_action_module(blueprint, target, genrule_type, is_test_target):
'''
Create module for action target and add to the blueprint. If target has arch specific attributes
this function merge them and create a single module.
@@ -1224,12 +1325,13 @@
'''
# TODO: Handle this target correctly, this target generates java_genrule but this target has
# different value for cpu-family arg between archs
- if target.name == '//build/android:native_libraries_gen':
- module = create_action_module_internal(target, genrule_type, target.arch['android_arm'])
+ if target.name in ['//build/android:native_libraries_gen',
+ '//build/android:native_libraries_gen__testing']:
+ module = create_action_module_internal(target, genrule_type, is_test_target, target.arch['android_arm'])
blueprint.add_module(module)
return module
- modules = {arch_name: create_action_module_internal(target, genrule_type, arch)
+ modules = {arch_name: create_action_module_internal(target, genrule_type, is_test_target, arch)
for arch_name, arch in target.arch.items()}
module = merge_modules(modules, genrule_type)
blueprint.add_module(module)
@@ -1242,8 +1344,16 @@
cflags |= set("-D%s" % define.replace("\"", "\\\"") for define in defines)
return cflags
-def set_module_flags(module, cflags, defines):
+def _set_linker_script(module, libs):
+ for lib in libs:
+ if lib.endswith(".lds"):
+ module.ldflags.add(get_linker_script_ldflag(gn_utils.label_to_path(lib)))
+
+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)
# TODO: implement proper cflag parsing.
for flag in cflags:
if '-std=' in flag:
@@ -1268,7 +1378,7 @@
if d not in local_include_dirs_denylist]
-def create_modules_from_target(blueprint, gn, gn_target_name):
+def create_modules_from_target(blueprint, gn, gn_target_name, is_test_target):
"""Generate module(s) for a given GN target.
Given a GN target name, generate one or more corresponding modules into a
@@ -1292,12 +1402,10 @@
# Can be used for both host and device targets.
module_type = 'cc_binary'
module = Module(module_type, bp_module_name, gn_target_name)
- elif target.type == 'static_library':
+ elif target.type in ['static_library', 'source_set']:
module = Module('cc_library_static', bp_module_name, gn_target_name)
elif target.type == 'shared_library':
module = Module('cc_library_shared', bp_module_name, gn_target_name)
- elif target.type == 'source_set':
- module = Module('cc_object', bp_module_name, gn_target_name)
elif target.type == 'group':
# "group" targets are resolved recursively by gn_utils.get_target().
# There's nothing we need to do at this level for them.
@@ -1307,9 +1415,9 @@
if module is None:
return None
elif target.type == 'action':
- module = create_action_module(blueprint, target, 'cc_genrule')
+ module = create_action_module(blueprint, target, 'cc_genrule', is_test_target)
elif target.type == 'action_foreach':
- module = create_action_foreach_modules(blueprint, target)
+ module = create_action_foreach_modules(blueprint, target, is_test_target)
elif target.type == 'copy':
# TODO: careful now! copy targets are not supported yet, but this will stop
# traversing the dependency tree. For //base:base, this is not a big
@@ -1335,11 +1443,13 @@
module.rtti = target.rtti
if target.type in gn_utils.LINKER_UNIT_TYPES:
- set_module_flags(module, target.cflags, target.defines)
+ set_module_flags(module, module.type, target.cflags, target.defines, target.ldflags, target.libs)
set_module_include_dirs(module, target.cflags, target.include_dirs)
# TODO: set_module_xxx is confusing, apply similar function to module and target in better way.
for arch_name, arch in target.arch.items():
- set_module_flags(module.target[arch_name], arch.cflags, arch.defines)
+ # TODO(aymanm): Make libs arch-specific.
+ set_module_flags(module.target[arch_name], module.type,
+ arch.cflags, arch.defines, arch.ldflags, [])
# -Xclang -target-feature -Xclang +mte are used to enable MTE (Memory Tagging Extensions).
# Flags which does not start with '-' could not be in the cflags so enabling MTE by
# -march and -mcpu Feature Modifiers. MTE is only available on arm64. This is needed for
@@ -1380,6 +1490,11 @@
# So setting the output name based on the output_name from the desc.json
module.stem = 'lib' + target.output_name
+ if module.is_test():
+ # Tests output should be a shared library in the format of 'lib[module_name]'
+ module.stem = 'lib' + target.get_target_name()[
+ :target.get_target_name().find(gn_utils.TESTING_SUFFIX)]
+
# dep_name is an unmangled GN target name (e.g. //foo:bar(toolchain)).
# Currently, only one module is generated from target even target has multiple toolchains.
# And module is generated based on the first visited target.
@@ -1392,7 +1507,7 @@
builtin_deps[dep_name](module, None)
continue
- dep_module = create_modules_from_target(blueprint, gn, dep_name)
+ dep_module = create_modules_from_target(blueprint, gn, dep_name, is_test_target)
if dep_module is None:
continue
@@ -1413,27 +1528,21 @@
if not module.is_compiled() or module.is_genrule():
continue
+ # Drop compiled modules that doesn't provide any benefit. This is mostly
+ # applicable to source_sets when converted to cc_static_library, sometimes
+ # the source set only has header files which are dropped so the module becomes empty.
+ if dep_module.is_compiled() and not dep_module.has_input_files():
+ continue
+
if dep_module.type == 'cc_library_shared':
module.shared_libs.add(dep_module.name)
elif dep_module.type == 'cc_library_static':
module.static_libs.add(dep_module.name)
- elif dep_module.type == 'cc_object':
- module.merge_attribute('generated_headers', dep_module, target.arch.keys())
- if module.type != 'cc_object':
- if dep_module.has_input_files():
- # Only add it as part of srcs if the dep_module has input files otherwise
- # this would throw an error.
- module.srcs.add(":" + dep_module.name)
- module.merge_attribute('export_generated_headers', dep_module,
- target.arch.keys(), 'generated_headers')
elif dep_module.type == 'cc_genrule':
module.merge_attribute('generated_headers', dep_module, [], 'genrule_headers')
module.merge_attribute('srcs', dep_module, [], 'genrule_srcs')
module.merge_attribute('shared_libs', dep_module, [], 'genrule_shared_libs')
module.merge_attribute('header_libs', dep_module, [], 'genrule_header_libs')
- if module.type not in ["cc_object"]:
- module.merge_attribute('export_generated_headers', dep_module, [],
- 'genrule_headers')
elif dep_module.type == 'cc_binary':
continue # Ignore executables deps (used by cmdline integration tests).
else:
@@ -1447,25 +1556,17 @@
if dep_name in builtin_deps:
builtin_deps[dep_name](module, arch_name)
continue
- dep_module = create_modules_from_target(blueprint, gn, dep_name)
+ dep_module = create_modules_from_target(blueprint, gn, dep_name, is_test_target)
# Arch-specific dependencies currently only include cc_library_static.
# Revisit this approach once we need to support more target types.
if dep_module.type == 'cc_library_static':
- module.target[arch_name].static_libs.add(dep_module.name)
- elif dep_module.type == 'cc_genrule':
- if dep_module.name.endswith(arch_name):
- 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)
+ 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)
else:
raise Error('Unsupported arch-specific dependency %s of target %s with type %s' %
(dep_module.name, target.name, dep_module.type))
@@ -1522,8 +1623,10 @@
def get_api_java_actions(gn):
return get_java_actions(gn, lambda name: name == java_api_target_name)
-def create_java_module(blueprint, gn):
+def create_java_module(blueprint, gn, is_test_target):
bp_module_name = module_prefix + 'java'
+ if is_test_target:
+ bp_module_name += gn_utils.TESTING_SUFFIX
module = Module('java_library', bp_module_name, '//gn:java')
module.srcs.update([gn_utils.label_to_path(source) for source in get_non_api_java_sources(gn)])
module.libs = {
@@ -1540,7 +1643,7 @@
"modules-utils-build_system",
}
module.aidl["include_dirs"] = {"frameworks/base/core/java/"}
- module.aidl["local_include_dirs"] = {"base/android/java/src/"}
+ module.aidl["local_include_dirs"] = gn.aidl_local_include_dirs
module.sdk_version = "module_current"
module.min_sdk_version = 30
module.apex_available.add(tethering_apex)
@@ -1550,13 +1653,14 @@
# would be less likely to conflict with upstream changes if the revert is not
# accepted.
module.javacflags.add("-Aorg.chromium.chrome.skipGenJni")
- module.javacflags.add("-Apackage_prefix=android.net.http.internal")
+ if not is_test_target:
+ module.javacflags.add("-Apackage_prefix=android.net.http.internal")
for dep in get_non_api_java_actions(gn):
target = gn.get_target(dep)
if target.script == '//build/android/gyp/gcc_preprocess.py':
module.srcs.add(':' + create_gcc_preprocess_modules(blueprint, target).name)
else:
- module.srcs.add(':' + create_action_module(blueprint, target, 'java_genrule').name)
+ module.srcs.add(':' + create_action_module(blueprint, target, 'java_genrule', is_test_target).name)
preprocessor_module = create_java_jni_preprocessor(blueprint)
module.plugins.add(preprocessor_module.name)
blueprint.add_module(module)
@@ -1571,19 +1675,10 @@
source_module.comment += "\n// TODO(danstahr): add the API helpers separately after the main" \
" API is checked in and thoroughly reviewed"
source_module.srcs.update([
- ':' + create_action_module(blueprint, gn.get_target(dep), 'java_genrule').name
+ ':' + create_action_module(blueprint, gn.get_target(dep), 'java_genrule', False).name
for dep in get_api_java_actions(gn)])
blueprint.add_module(source_module)
-
- java_module = Module('java_library', module_prefix + 'api_java', java_api_target_name)
- java_module.srcs.add(":" + source_module.name)
- java_module.sdk_version = "module_current"
- java_module.libs = {
- "androidx.annotation_annotation",
- "framework-annotations-lib",
- }
- blueprint.add_module(java_module)
- return java_module
+ return source_module
def update_jni_registration_module(module, gn):
# TODO: java_sources might not contain all the required java files
@@ -1591,7 +1686,7 @@
for source in get_non_api_java_sources(gn)
if source.endswith('.java')])
-def create_blueprint_for_targets(gn, targets):
+def create_blueprint_for_targets(gn, targets, test_targets):
"""Generate a blueprint for a list of GN targets."""
blueprint = Blueprint()
@@ -1607,11 +1702,10 @@
'-Wno-sign-promo',
'-Wno-unused-parameter',
'-Wno-null-pointer-subtraction', # Needed to libevent
- '-fvisibility=hidden',
'-Wno-ambiguous-reversed-operator', # needed for icui18n
'-Wno-unreachable-code-loop-increment', # needed for icui18n
- '-O2',
'-fPIC',
+ '-Wno-c++11-narrowing',
]
# Chromium builds do not add a dependency for headers found inside the
# sysroot, so they are added globally via defaults.
@@ -1630,16 +1724,22 @@
'-UANDROID',
]
defaults.stl = 'none'
+ defaults.cpp_std = 'c++17'
defaults.min_sdk_version = 29
defaults.apex_available.add(tethering_apex)
blueprint.add_module(defaults)
for target in targets:
- create_modules_from_target(blueprint, gn, target)
+ create_modules_from_target(blueprint, gn, target, is_test_target=False)
- java_api_module = create_java_api_module(blueprint, gn)
- java_module = create_java_module(blueprint, gn)
- java_module.libs.add(java_api_module.name)
+ for test_target in test_targets:
+ create_modules_from_target(blueprint, gn, test_target + gn_utils.TESTING_SUFFIX, is_test_target=True)
+
+ create_java_api_module(blueprint, gn)
+ java_module = create_java_module(blueprint, gn, is_test_target=False)
+ java_module.libs.add(CRONET_API_MODULE_NAME)
+ java_module_testing = create_java_module(blueprint, gn, is_test_target=True)
+ java_module_testing.libs.add(CRONET_API_MODULE_NAME)
for module in blueprint.modules.values():
if 'cronet_jni_registration' in module.name:
update_jni_registration_module(module, gn)
@@ -1667,24 +1767,20 @@
def create_license_module(blueprint):
module = Module("license", "external_cronet_license", "LICENSE")
module.license_kinds.update({
- 'SPDX-license-identifier-LGPL-2.1',
- 'SPDX-license-identifier-GPL-2.0',
'SPDX-license-identifier-MPL',
+ 'SPDX-license-identifier-MPL-1.1',
'SPDX-license-identifier-ISC',
- 'SPDX-license-identifier-GPL',
'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-LGPL',
- 'SPDX-license-identifier-GPL-3.0',
'SPDX-license-identifier-Unicode-DFS',
'SPDX-license-identifier-NCSA',
'SPDX-license-identifier-OpenSSL',
'SPDX-license-identifier-MIT',
"SPDX-license-identifier-ICU",
- 'legacy_unencumbered', # public domain
+ 'legacy_unencumbered',
})
module.license_text.update({
"LICENSE",
@@ -1754,14 +1850,16 @@
if args.verbose:
log.basicConfig(format='%(levelname)s:%(funcName)s:%(message)s', level=log.DEBUG)
- targets = args.targets or default_targets
+ targets = args.targets or DEFAULT_TARGETS
gn = gn_utils.GnParser(builtin_deps)
for desc_file in args.desc:
with open(desc_file) as f:
desc = json.load(f)
for target in targets:
gn.parse_gn_desc(desc, target)
- blueprint = create_blueprint_for_targets(gn, targets)
+ for test_target in DEFAULT_TESTS:
+ gn.parse_gn_desc(desc, test_target, is_test_target=True)
+ blueprint = create_blueprint_for_targets(gn, targets, DEFAULT_TESTS)
project_root = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))
tool_name = os.path.relpath(os.path.abspath(__file__), project_root)
@@ -1785,6 +1883,8 @@
// limitations under the License.
//
// This file is automatically generated by %s. Do not edit.
+
+build = ["Android.extras.bp"]
""" % (tool_name)
]
blueprint.to_string(output)
diff --git a/tools/gn2bp/gen_desc_json.sh b/tools/gn2bp/gen_desc_json.sh
index 1f60eb9..bf9b21d 100755
--- a/tools/gn2bp/gen_desc_json.sh
+++ b/tools/gn2bp/gen_desc_json.sh
@@ -41,27 +41,32 @@
"target_os = \"android\""
"enable_websockets = false"
"disable_file_support = true"
- "disable_brotli_filter = false"
"is_component_build = false"
"use_crash_key_stubs = true"
"use_partition_alloc = false"
"include_transport_security_state_preload_list = false"
"use_platform_icu_alternatives = true"
"default_min_sdk_version = 19"
- "use_errorprone_java_compiler = true"
"enable_reporting = true"
"use_hashed_jni_names = true"
- "treat_warnings_as_errors = false"
"enable_base_tracing = false"
"is_cronet_build = true"
"is_debug = false"
"is_official_build = true"
+ "use_nss_certs = false"
+ "clang_use_default_sample_profile = false"
+ "media_use_ffmpeg=false"
+ "use_thin_lto=false"
+ "enable_resource_allowlist_generation=false"
+ "enable_jdk_library_desugaring=false"
+ "exclude_unwind_tables=true"
+ "symbol_level=1"
)
gn_args+=("target_cpu = \"${1}\"")
# Only set arm_use_neon on arm architectures to prevent warning from being
# written to json output.
- if [[ "$1" =~ ^arm ]]; then
+ if [[ "$1" = "arm" ]]; then
gn_args+=("arm_use_neon = false")
fi
diff --git a/tools/gn2bp/gn_utils.py b/tools/gn2bp/gn_utils.py
index 3d709e5..4066673 100644
--- a/tools/gn2bp/gn_utils.py
+++ b/tools/gn2bp/gn_utils.py
@@ -46,6 +46,8 @@
}
ARCH_REGEX = r'(android_x86_64|android_x86|android_arm|android_arm64|host)'
RESPONSE_FILE = '{{response_file_name}}'
+TESTING_SUFFIX = "__testing"
+AIDL_INCLUDE_DIRS_REGEX = r'--includes=\[(.*)\]'
def repo_root():
"""Returns an absolute path to the repository root."""
@@ -53,6 +55,18 @@
os.path.realpath(os.path.dirname(__file__)), os.path.pardir)
+def _clean_string(str):
+ return str.replace('\\', '').replace('../../', '').replace('"', '').strip()
+
+
+def _extract_includes_from_aidl_args(args):
+ for arg in args:
+ is_match = re.match(AIDL_INCLUDE_DIRS_REGEX, arg)
+ if is_match:
+ local_includes = is_match.group(1).split(",")
+ return [_clean_string(local_include) for local_include in local_includes]
+ return []
+
def label_to_path(label):
"""Turn a GN output label (e.g., //some_dir/file.cc) into a path."""
assert label.startswith('//')
@@ -119,6 +133,7 @@
self.deps = set()
self.transitive_static_libs_deps = set()
self.source_set_deps = set()
+ self.ldflags = set()
# These are valid only for type == 'action'
self.inputs = set()
@@ -207,7 +222,7 @@
'libs', 'proto_paths'):
self.__dict__[key].update(other.__dict__.get(key, []))
- for key_in_arch in ('cflags', 'defines', 'include_dirs', 'source_set_deps'):
+ for key_in_arch in ('cflags', 'defines', 'include_dirs', 'source_set_deps', 'ldflags'):
self.arch[arch].__dict__[key_in_arch].update(
other.arch[arch].__dict__.get(key_in_arch, []))
@@ -250,9 +265,12 @@
return
for key in ('sources', 'cflags', 'defines', 'include_dirs', 'deps', 'source_set_deps',
- 'inputs', 'outputs', 'args', 'script', 'response_file_contents'):
+ 'inputs', 'outputs', 'args', 'script', 'response_file_contents', 'ldflags'):
self._finalize_attribute(key)
+ def get_target_name(self):
+ return self.name[self.name.find(":") + 1:]
+
def __init__(self, builtin_deps):
self.builtin_deps = builtin_deps
@@ -262,6 +280,7 @@
self.actions = {}
self.proto_libs = {}
self.java_sources = collections.defaultdict(set)
+ self.aidl_local_include_dirs = set()
self.java_actions = collections.defaultdict(set)
def _get_response_file_contents(self, action_desc):
@@ -308,7 +327,7 @@
return self.all_targets[label_without_toolchain(gn_target_name)]
- def parse_gn_desc(self, gn_desc, gn_target_name, java_group_name=None):
+ def parse_gn_desc(self, gn_desc, gn_target_name, java_group_name=None, is_test_target=False):
"""Parses a gn desc tree and resolves all target dependencies.
It bubbles up variables from source_set dependencies as described in the
@@ -324,6 +343,9 @@
if self._is_java_group(type_, target_name):
java_group_name = target_name
+ if is_test_target:
+ target_name += TESTING_SUFFIX
+
target = self.all_targets.get(target_name)
if target is None:
target = GnParser.Target(target_name, type_)
@@ -392,7 +414,7 @@
target.arch[arch].cflags.update(desc.get('cflags', []) + desc.get('cflags_cc', []))
target.libs.update(desc.get('libs', []))
- target.ldflags.update(desc.get('ldflags', []))
+ target.arch[arch].ldflags.update(desc.get('ldflags', []))
target.arch[arch].defines.update(desc.get('defines', []))
target.arch[arch].include_dirs.update(desc.get('include_dirs', []))
target.output_name = desc.get('output_name', None)
@@ -401,20 +423,12 @@
# Recurse in dependencies.
for gn_dep_name in desc.get('deps', []):
- dep = self.parse_gn_desc(gn_desc, gn_dep_name, java_group_name)
+ dep = self.parse_gn_desc(gn_desc, gn_dep_name, java_group_name, is_test_target)
if dep.type == 'proto_library':
target.proto_deps.add(dep.name)
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']:
@@ -428,12 +442,11 @@
# java_library.
pass
- # Source set bubble up transitive source sets but can't be combined with this
- # if they are combined then source sets will bubble up static libraries
- # while we only want to have source sets bubble up only source sets.
- if dep.type == 'static_library':
- # Bubble up static_libs. Necessary, since soong does not propagate
+ if dep.type in ['static_library', 'source_set']:
+ # Bubble up static_libs and source_set. Necessary, since soong does not propagate
# static_libs up the build tree.
+ # Source sets are later translated to static_libraries, so it makes sense
+ # to reuse transitive_static_libs_deps.
target.arch[arch].transitive_static_libs_deps.add(dep.name)
if arch in dep.arch:
@@ -451,15 +464,23 @@
if dep.name.endswith('__compile_java'):
log.debug('Adding java sources for %s', dep.name)
java_srcs = [src for src in dep.inputs if _is_java_source(src)]
- self.java_sources[java_group_name].update(java_srcs)
+ if not is_test_target:
+ # TODO(aymanm): Fix collecting sources for testing modules for java.
+ # Don't collect java source files for test targets.
+ # We only need a specific set of java sources which are hardcoded in gen_android_bp
+ self.java_sources[java_group_name].update(java_srcs)
if dep.type in ["action"] and target.type == "java_group":
- # //base:base_java_aidl generates srcjar from .aidl files. But java_library in soong can
- # directly have .aidl files in srcs. So adding .aidl files to the java_sources.
+ # GN uses an action to compile aidl files. However, this is not needed in soong
+ # as soong can directly have .aidl files in srcs. So adding .aidl files to the java_sources.
# TODO: Find a better way/place to do this.
- if dep.name == '//base:base_java_aidl':
+ if '_aidl' in dep.name:
self.java_sources[java_group_name].update(dep.arch[arch].sources)
+ self.aidl_local_include_dirs.update(_extract_includes_from_aidl_args(dep.arch[arch].args))
else:
- self.java_actions[java_group_name].add(dep.name)
+ if not is_test_target:
+ # TODO(aymanm): Fix collecting actions for testing modules for java.
+ # Don't collect java actions for test targets.
+ self.java_actions[java_group_name].add(dep.name)
return target
def get_proto_exports(self, proto_desc):