Merge "Use absolute paths in classpaths.proto." into sc-dev
diff --git a/apex/platform_bootclasspath_test.go b/apex/platform_bootclasspath_test.go
index 52b1689..ce12f46 100644
--- a/apex/platform_bootclasspath_test.go
+++ b/apex/platform_bootclasspath_test.go
@@ -20,6 +20,7 @@
"android/soong/android"
"android/soong/java"
"github.com/google/blueprint"
+ "github.com/google/blueprint/proptools"
)
// Contains tests for platform_bootclasspath logic from java/platform_bootclasspath.go that requires
@@ -174,6 +175,141 @@
})
}
+// TestPlatformBootclasspath_AlwaysUsePrebuiltSdks verifies that the build does not fail when
+// AlwaysUsePrebuiltSdk() returns true. The structure of the modules in this test matches what
+// currently exists in some places in the Android build but it is not the intended structure. It is
+// in fact an invalid structure that should cause build failures. However, fixing that structure
+// will take too long so in the meantime this tests the workarounds to avoid build breakages.
+//
+// The main issues with this structure are:
+// 1. There is no prebuilt_bootclasspath_fragment referencing the "foo" java_sdk_library_import.
+// 2. There is no prebuilt_apex/apex_set which makes the dex implementation jar available to the
+// prebuilt_bootclasspath_fragment and the "foo" java_sdk_library_import.
+//
+// Together these cause the following symptoms:
+// 1. The "foo" java_sdk_library_import does not have a dex implementation jar.
+// 2. The "foo" java_sdk_library_import does not have a myapex variant.
+//
+// TODO(b/179354495): Fix the structure in this test once the main Android build has been fixed.
+func TestPlatformBootclasspath_AlwaysUsePrebuiltSdks(t *testing.T) {
+ result := android.GroupFixturePreparers(
+ prepareForTestWithPlatformBootclasspath,
+ prepareForTestWithMyapex,
+ // Configure two libraries, the first is a java_sdk_library whose prebuilt will be used because
+ // of AlwaysUsePrebuiltsSdk() but does not have an appropriate apex variant and does not provide
+ // a boot dex jar. The second is a normal library that is unaffected. The order matters because
+ // if the dependency on myapex:foo is filtered out because of either of those conditions then
+ // the dependencies resolved by the platform_bootclasspath will not match the configured list
+ // and so will fail the test.
+ java.FixtureConfigureUpdatableBootJars("myapex:foo", "myapex:bar"),
+ java.PrepareForTestWithJavaSdkLibraryFiles,
+ android.FixtureModifyProductVariables(func(variables android.FixtureProductVariables) {
+ variables.Always_use_prebuilt_sdks = proptools.BoolPtr(true)
+ }),
+ java.FixtureWithPrebuiltApis(map[string][]string{
+ "current": {},
+ "30": {"foo"},
+ }),
+ ).RunTestWithBp(t, `
+ apex {
+ name: "myapex",
+ key: "myapex.key",
+ bootclasspath_fragments: [
+ "mybootclasspath-fragment",
+ ],
+ updatable: false,
+ }
+
+ apex_key {
+ name: "myapex.key",
+ public_key: "testkey.avbpubkey",
+ private_key: "testkey.pem",
+ }
+
+ java_library {
+ name: "bar",
+ srcs: ["b.java"],
+ installable: true,
+ apex_available: ["myapex"],
+ permitted_packages: ["bar"],
+ }
+
+ java_sdk_library {
+ name: "foo",
+ srcs: ["b.java"],
+ shared_library: false,
+ public: {
+ enabled: true,
+ },
+ apex_available: ["myapex"],
+ permitted_packages: ["foo"],
+ }
+
+ // A prebuilt java_sdk_library_import that is not preferred by default but will be preferred
+ // because AlwaysUsePrebuiltSdks() is true.
+ java_sdk_library_import {
+ name: "foo",
+ prefer: false,
+ shared_library: false,
+ public: {
+ jars: ["sdk_library/public/foo-stubs.jar"],
+ stub_srcs: ["sdk_library/public/foo_stub_sources"],
+ current_api: "sdk_library/public/foo.txt",
+ removed_api: "sdk_library/public/foo-removed.txt",
+ sdk_version: "current",
+ },
+ apex_available: ["myapex"],
+ }
+
+ // This always depends on the source foo module, its dependencies are not affected by the
+ // AlwaysUsePrebuiltSdks().
+ bootclasspath_fragment {
+ name: "mybootclasspath-fragment",
+ apex_available: [
+ "myapex",
+ ],
+ contents: [
+ "foo", "bar",
+ ],
+ }
+
+ platform_bootclasspath {
+ name: "myplatform-bootclasspath",
+ }
+`,
+ )
+
+ java.CheckPlatformBootclasspathModules(t, result, "myplatform-bootclasspath", []string{
+ // The configured contents of BootJars.
+ "platform:prebuilt_foo", // Note: This is the platform not myapex variant.
+ "myapex:bar",
+ })
+
+ // Make sure that the myplatform-bootclasspath has the correct dependencies.
+ CheckModuleDependencies(t, result.TestContext, "myplatform-bootclasspath", "android_common", []string{
+ // The following are stubs.
+ "platform:prebuilt_sdk_public_current_android",
+ "platform:prebuilt_sdk_system_current_android",
+ "platform:prebuilt_sdk_test_current_android",
+
+ // Not a prebuilt as no prebuilt existed when it was added.
+ "platform:legacy.core.platform.api.stubs",
+
+ // Needed for generating the boot image.
+ `platform:dex2oatd`,
+
+ // The platform_bootclasspath intentionally adds dependencies on both source and prebuilt
+ // modules when available as it does not know which one will be preferred.
+ //
+ // The source module has an APEX variant but the prebuilt does not.
+ "myapex:foo",
+ "platform:prebuilt_foo",
+
+ // Only a source module exists.
+ "myapex:bar",
+ })
+}
+
// CheckModuleDependencies checks the dependencies of the selected module against the expected list.
//
// The expected list must be a list of strings of the form "<apex>:<module>", where <apex> is the
diff --git a/dexpreopt/config.go b/dexpreopt/config.go
index 1844bce..7e73bf7 100644
--- a/dexpreopt/config.go
+++ b/dexpreopt/config.go
@@ -130,9 +130,11 @@
ProvidesUsesLibrary string // library name (usually the same as module name)
ClassLoaderContexts ClassLoaderContextMap
- Archs []android.ArchType
- DexPreoptImagesDeps []android.OutputPaths
- DexPreoptImageLocationsOnHost []string // boot image location on host (file path without the arch subdirectory)
+ Archs []android.ArchType
+ DexPreoptImagesDeps []android.OutputPaths
+
+ DexPreoptImageLocationsOnHost []string // boot image location on host (file path without the arch subdirectory)
+ DexPreoptImageLocationsOnDevice []string // boot image location on device (file path without the arch subdirectory)
PreoptBootClassPathDexFiles android.Paths // file paths of boot class path files
PreoptBootClassPathDexLocations []string // virtual locations of boot class path files
diff --git a/dexpreopt/dexpreopt.go b/dexpreopt/dexpreopt.go
index 9d9234f..da015a3 100644
--- a/dexpreopt/dexpreopt.go
+++ b/dexpreopt/dexpreopt.go
@@ -499,11 +499,16 @@
// PathToLocation converts .../system/framework/arm64/boot.art to .../system/framework/boot.art
func PathToLocation(path android.Path, arch android.ArchType) string {
- pathArch := filepath.Base(filepath.Dir(path.String()))
+ return PathStringToLocation(path.String(), arch)
+}
+
+// PathStringToLocation converts .../system/framework/arm64/boot.art to .../system/framework/boot.art
+func PathStringToLocation(path string, arch android.ArchType) string {
+ pathArch := filepath.Base(filepath.Dir(path))
if pathArch != arch.String() {
panic(fmt.Errorf("last directory in %q must be %q", path, arch.String()))
}
- return filepath.Join(filepath.Dir(filepath.Dir(path.String())), filepath.Base(path.String()))
+ return filepath.Join(filepath.Dir(filepath.Dir(path)), filepath.Base(path))
}
func makefileMatch(pattern, s string) bool {
diff --git a/dexpreopt/dexpreopt_gen/dexpreopt_gen.go b/dexpreopt/dexpreopt_gen/dexpreopt_gen.go
index 32c4f84..7dbe74c 100644
--- a/dexpreopt/dexpreopt_gen/dexpreopt_gen.go
+++ b/dexpreopt/dexpreopt_gen/dexpreopt_gen.go
@@ -37,6 +37,12 @@
globalConfigPath = flag.String("global", "", "path to global configuration file")
moduleConfigPath = flag.String("module", "", "path to module configuration file")
outDir = flag.String("out_dir", "", "path to output directory")
+ // If uses_target_files is true, dexpreopt_gen will be running on extracted target_files.zip files.
+ // In this case, the tool replace output file path with $(basePath)/$(on-device file path).
+ // The flag is useful when running dex2oat on system image and vendor image which are built separately.
+ usesTargetFiles = flag.Bool("uses_target_files", false, "whether or not dexpreopt is running on target_files")
+ // basePath indicates the path where target_files.zip is extracted.
+ basePath = flag.String("base_path", ".", "base path where images and tools are extracted")
)
type builderContext struct {
@@ -134,32 +140,28 @@
}
}
}()
-
+ if *usesTargetFiles {
+ moduleConfig.ManifestPath = android.OptionalPath{}
+ prefix := "dex2oat_result"
+ moduleConfig.BuildPath = android.PathForOutput(ctx, filepath.Join(prefix, moduleConfig.DexLocation))
+ for i, location := range moduleConfig.PreoptBootClassPathDexLocations {
+ moduleConfig.PreoptBootClassPathDexFiles[i] = android.PathForSource(ctx, *basePath+location)
+ }
+ for i := range moduleConfig.ClassLoaderContexts {
+ for _, v := range moduleConfig.ClassLoaderContexts[i] {
+ v.Host = android.PathForSource(ctx, *basePath+v.Device)
+ }
+ }
+ moduleConfig.EnforceUsesLibraries = false
+ for i, location := range moduleConfig.DexPreoptImageLocationsOnDevice {
+ moduleConfig.DexPreoptImageLocationsOnHost[i] = *basePath + location
+ }
+ }
writeScripts(ctx, globalSoongConfig, globalConfig, moduleConfig, *dexpreoptScriptPath)
}
func writeScripts(ctx android.BuilderContext, globalSoong *dexpreopt.GlobalSoongConfig,
global *dexpreopt.GlobalConfig, module *dexpreopt.ModuleConfig, dexpreoptScriptPath string) {
- dexpreoptRule, err := dexpreopt.GenerateDexpreoptRule(ctx, globalSoong, global, module)
- if err != nil {
- panic(err)
- }
-
- installDir := module.BuildPath.InSameDir(ctx, "dexpreopt_install")
-
- dexpreoptRule.Command().FlagWithArg("rm -rf ", installDir.String())
- dexpreoptRule.Command().FlagWithArg("mkdir -p ", installDir.String())
-
- for _, install := range dexpreoptRule.Installs() {
- installPath := installDir.Join(ctx, strings.TrimPrefix(install.To, "/"))
- dexpreoptRule.Command().Text("mkdir -p").Flag(filepath.Dir(installPath.String()))
- dexpreoptRule.Command().Text("cp -f").Input(install.From).Output(installPath)
- }
- dexpreoptRule.Command().Tool(globalSoong.SoongZip).
- FlagWithArg("-o ", "$2").
- FlagWithArg("-C ", installDir.String()).
- FlagWithArg("-D ", installDir.String())
-
write := func(rule *android.RuleBuilder, file string) {
script := &bytes.Buffer{}
script.WriteString(scriptHeader)
@@ -195,6 +197,30 @@
panic(err)
}
}
+ dexpreoptRule, err := dexpreopt.GenerateDexpreoptRule(ctx, globalSoong, global, module)
+ if err != nil {
+ panic(err)
+ }
+ // When usesTargetFiles is true, only odex/vdex files are necessary.
+ // So skip redunant processes(such as copying the result to the artifact path, and zipping, and so on.)
+ if *usesTargetFiles {
+ write(dexpreoptRule, dexpreoptScriptPath)
+ return
+ }
+ installDir := module.BuildPath.InSameDir(ctx, "dexpreopt_install")
+
+ dexpreoptRule.Command().FlagWithArg("rm -rf ", installDir.String())
+ dexpreoptRule.Command().FlagWithArg("mkdir -p ", installDir.String())
+
+ for _, install := range dexpreoptRule.Installs() {
+ installPath := installDir.Join(ctx, strings.TrimPrefix(install.To, "/"))
+ dexpreoptRule.Command().Text("mkdir -p").Flag(filepath.Dir(installPath.String()))
+ dexpreoptRule.Command().Text("cp -f").Input(install.From).Output(installPath)
+ }
+ dexpreoptRule.Command().Tool(globalSoong.SoongZip).
+ FlagWithArg("-o ", "$2").
+ FlagWithArg("-C ", installDir.String()).
+ FlagWithArg("-D ", installDir.String())
// The written scripts will assume the input is $1 and the output is $2
if module.DexPath.String() != "$1" {
diff --git a/java/bootclasspath.go b/java/bootclasspath.go
index 02833ab..634959a 100644
--- a/java/bootclasspath.go
+++ b/java/bootclasspath.go
@@ -29,7 +29,7 @@
func registerBootclasspathBuildComponents(ctx android.RegistrationContext) {
ctx.FinalDepsMutators(func(ctx android.RegisterMutatorsContext) {
- ctx.BottomUp("bootclasspath_deps", bootclasspathDepsMutator)
+ ctx.BottomUp("bootclasspath_deps", bootclasspathDepsMutator).Parallel()
})
}
@@ -95,6 +95,15 @@
if ctx.OtherModuleDependencyVariantExists(variations, prebuiltName) {
ctx.AddVariationDependencies(variations, tag, prebuiltName)
addedDep = true
+ } else if ctx.Config().AlwaysUsePrebuiltSdks() && len(variations) > 0 {
+ // TODO(b/179354495): Remove this code path once the Android build has been fully migrated to
+ // use bootclasspath_fragment properly.
+ // Some prebuilt java_sdk_library modules do not yet have an APEX variations so try and add a
+ // dependency on the non-APEX variant.
+ if ctx.OtherModuleDependencyVariantExists(nil, prebuiltName) {
+ ctx.AddVariationDependencies(nil, tag, prebuiltName)
+ addedDep = true
+ }
}
// If no appropriate variant existing for this, so no dependency could be added, then it is an
diff --git a/java/dexpreopt.go b/java/dexpreopt.go
index 8d23ad6..2e46d74 100644
--- a/java/dexpreopt.go
+++ b/java/dexpreopt.go
@@ -184,7 +184,7 @@
imagesDeps = append(imagesDeps, variant.imagesDeps)
}
// The image locations for all Android variants are identical.
- hostImageLocations := bootImage.getAnyAndroidVariant().imageLocations()
+ hostImageLocations, deviceImageLocations := bootImage.getAnyAndroidVariant().imageLocations()
var profileClassListing android.OptionalPath
var profileBootListing android.OptionalPath
@@ -224,9 +224,10 @@
ProvidesUsesLibrary: providesUsesLib,
ClassLoaderContexts: d.classLoaderContexts,
- Archs: archs,
- DexPreoptImagesDeps: imagesDeps,
- DexPreoptImageLocationsOnHost: hostImageLocations,
+ Archs: archs,
+ DexPreoptImagesDeps: imagesDeps,
+ DexPreoptImageLocationsOnHost: hostImageLocations,
+ DexPreoptImageLocationsOnDevice: deviceImageLocations,
PreoptBootClassPathDexFiles: dexFiles.Paths(),
PreoptBootClassPathDexLocations: dexLocations,
diff --git a/java/dexpreopt_bootjars.go b/java/dexpreopt_bootjars.go
index 07715ab..c1068da 100644
--- a/java/dexpreopt_bootjars.go
+++ b/java/dexpreopt_bootjars.go
@@ -244,6 +244,9 @@
// Subdirectory where the image files are installed.
installDirOnHost string
+ // Subdirectory where the image files on device are installed.
+ installDirOnDevice string
+
// A list of (location, jar) pairs for the Java modules in this image.
modules android.ConfiguredJarList
@@ -273,8 +276,9 @@
dexLocationsDeps []string // for the dependency images and in this image
// Paths to image files.
- imagePathOnHost android.OutputPath // first image file
- imagesDeps android.OutputPaths // all files
+ imagePathOnHost android.OutputPath // first image file path on host
+ imagePathOnDevice string // first image file path on device
+ imagesDeps android.OutputPaths // all files
// Only for extensions, paths to the primary boot images.
primaryImages android.OutputPath
@@ -361,11 +365,12 @@
// The location is passed as an argument to the ART tools like dex2oat instead of the real path.
// ART tools will then reconstruct the architecture-specific real path.
//
-func (image *bootImageVariant) imageLocations() (imageLocations []string) {
+func (image *bootImageVariant) imageLocations() (imageLocationsOnHost []string, imageLocationsOnDevice []string) {
if image.extends != nil {
- imageLocations = image.extends.getVariant(image.target).imageLocations()
+ imageLocationsOnHost, imageLocationsOnDevice = image.extends.getVariant(image.target).imageLocations()
}
- return append(imageLocations, dexpreopt.PathToLocation(image.imagePathOnHost, image.target.Arch.ArchType))
+ return append(imageLocationsOnHost, dexpreopt.PathToLocation(image.imagePathOnHost, image.target.Arch.ArchType)),
+ append(imageLocationsOnDevice, dexpreopt.PathStringToLocation(image.imagePathOnDevice, image.target.Arch.ArchType))
}
func dexpreoptBootJarsFactory() android.SingletonModule {
@@ -761,7 +766,7 @@
if len(pp) > 0 {
updatablePackages = append(updatablePackages, pp...)
} else {
- ctx.ModuleErrorf("Missing permitted_packages")
+ ctx.OtherModuleErrorf(module, "Missing permitted_packages")
}
}
}
@@ -796,12 +801,13 @@
// Create a rule to call oatdump.
output := android.PathForOutput(ctx, "boot."+suffix+".oatdump.txt")
rule := android.NewRuleBuilder(pctx, ctx)
+ imageLocationsOnHost, _ := image.imageLocations()
rule.Command().
// TODO: for now, use the debug version for better error reporting
BuiltTool("oatdumpd").
FlagWithInputList("--runtime-arg -Xbootclasspath:", image.dexPathsDeps.Paths(), ":").
FlagWithList("--runtime-arg -Xbootclasspath-locations:", image.dexLocationsDeps, ":").
- FlagWithArg("--image=", strings.Join(image.imageLocations(), ":")).Implicits(image.imagesDeps.Paths()).
+ FlagWithArg("--image=", strings.Join(imageLocationsOnHost, ":")).Implicits(image.imagesDeps.Paths()).
FlagWithOutput("--output=", output).
FlagWithArg("--instruction-set=", arch.String())
rule.Build("dump-oat-boot-"+suffix, "dump oat boot "+arch.String())
@@ -871,8 +877,8 @@
ctx.Strict("DEXPREOPT_IMAGE_BUILT_INSTALLED_"+sfx, variant.installs.String())
ctx.Strict("DEXPREOPT_IMAGE_UNSTRIPPED_BUILT_INSTALLED_"+sfx, variant.unstrippedInstalls.String())
}
- imageLocations := current.getAnyAndroidVariant().imageLocations()
- ctx.Strict("DEXPREOPT_IMAGE_LOCATIONS_"+current.name, strings.Join(imageLocations, ":"))
+ imageLocationsOnHost, _ := current.getAnyAndroidVariant().imageLocations()
+ ctx.Strict("DEXPREOPT_IMAGE_LOCATIONS_"+current.name, strings.Join(imageLocationsOnHost, ":"))
ctx.Strict("DEXPREOPT_IMAGE_ZIP_"+current.name, current.zip.String())
}
ctx.Strict("DEXPREOPT_IMAGE_NAMES", strings.Join(imageNames, " "))
diff --git a/java/dexpreopt_config.go b/java/dexpreopt_config.go
index 7fb0444..3724860 100644
--- a/java/dexpreopt_config.go
+++ b/java/dexpreopt_config.go
@@ -84,25 +84,28 @@
frameworkModules := global.BootJars.RemoveList(artModules)
artDirOnHost := "apex/art_boot_images/javalib"
+ artDirOnDevice := "apex/com.android.art/javalib"
frameworkSubdir := "system/framework"
// ART config for the primary boot image in the ART apex.
// It includes the Core Libraries.
artCfg := bootImageConfig{
- name: artBootImageName,
- stem: "boot",
- installDirOnHost: artDirOnHost,
- modules: artModules,
+ name: artBootImageName,
+ stem: "boot",
+ installDirOnHost: artDirOnHost,
+ installDirOnDevice: artDirOnDevice,
+ modules: artModules,
}
// Framework config for the boot image extension.
// It includes framework libraries and depends on the ART config.
frameworkCfg := bootImageConfig{
- extends: &artCfg,
- name: frameworkBootImageName,
- stem: "boot",
- installDirOnHost: frameworkSubdir,
- modules: frameworkModules,
+ extends: &artCfg,
+ name: frameworkBootImageName,
+ stem: "boot",
+ installDirOnHost: frameworkSubdir,
+ installDirOnDevice: frameworkSubdir,
+ modules: frameworkModules,
}
configs := map[string]*bootImageConfig{
@@ -131,11 +134,12 @@
arch := target.Arch.ArchType
imageDir := c.dir.Join(ctx, target.Os.String(), c.installDirOnHost, arch.String())
variant := &bootImageVariant{
- bootImageConfig: c,
- target: target,
- imagePathOnHost: imageDir.Join(ctx, imageName),
- imagesDeps: c.moduleFiles(ctx, imageDir, ".art", ".oat", ".vdex"),
- dexLocations: c.modules.DevicePaths(ctx.Config(), target.Os),
+ bootImageConfig: c,
+ target: target,
+ imagePathOnHost: imageDir.Join(ctx, imageName),
+ imagePathOnDevice: filepath.Join("/", c.installDirOnDevice, arch.String(), imageName),
+ imagesDeps: c.moduleFiles(ctx, imageDir, ".art", ".oat", ".vdex"),
+ dexLocations: c.modules.DevicePaths(ctx.Config(), target.Os),
}
variant.dexLocationsDeps = variant.dexLocations
c.variants = append(c.variants, variant)
diff --git a/java/hiddenapi_modular.go b/java/hiddenapi_modular.go
index 2dceb65..f5afe5d 100644
--- a/java/hiddenapi_modular.go
+++ b/java/hiddenapi_modular.go
@@ -15,6 +15,7 @@
package java
import (
+ "fmt"
"strings"
"android/soong/android"
@@ -560,7 +561,25 @@
for _, module := range contents {
bootDexJar := module.bootDexJar()
if bootDexJar == nil {
- ctx.ModuleErrorf("module %s does not provide a dex jar", module)
+ if ctx.Config().AlwaysUsePrebuiltSdks() {
+ // TODO(b/179354495): Remove this work around when it is unnecessary.
+ // Prebuilt modules like framework-wifi do not yet provide dex implementation jars. So,
+ // create a fake one that will cause a build error only if it is used.
+ fake := android.PathForModuleOut(ctx, "fake/boot-dex/%s.jar", module.Name())
+
+ // Create an error rule that pretends to create the output file but will actually fail if it
+ // is run.
+ ctx.Build(pctx, android.BuildParams{
+ Rule: android.ErrorRule,
+ Output: fake,
+ Args: map[string]string{
+ "error": fmt.Sprintf("missing dependencies: boot dex jar for %s", module),
+ },
+ })
+ bootDexJars = append(bootDexJars, fake)
+ } else {
+ ctx.ModuleErrorf("module %s does not provide a dex jar", module)
+ }
} else {
bootDexJars = append(bootDexJars, bootDexJar)
}
diff --git a/java/platform_bootclasspath.go b/java/platform_bootclasspath.go
index c8fafed..6ebeb6b 100644
--- a/java/platform_bootclasspath.go
+++ b/java/platform_bootclasspath.go
@@ -242,8 +242,15 @@
} else {
name := ctx.OtherModuleName(m)
if apexInfo.IsForPlatform() {
- // error: this jar is part of the platform
- ctx.ModuleErrorf("module %q from platform is not allowed in the updatable boot jars list", name)
+ // If AlwaysUsePrebuiltSdks() returns true then it is possible that the updatable list will
+ // include platform variants of a prebuilt module due to workarounds elsewhere. In that case
+ // do not treat this as an error.
+ // TODO(b/179354495): Always treat this as an error when migration to bootclasspath_fragment
+ // modules is complete.
+ if !ctx.Config().AlwaysUsePrebuiltSdks() {
+ // error: this jar is part of the platform
+ ctx.ModuleErrorf("module %q from platform is not allowed in the updatable boot jars list", name)
+ }
} else {
// TODO(b/177892522): Treat this as an error.
// Cannot do that at the moment because framework-wifi and framework-tethering are in the