| // Copyright 2018 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| import groovy.json.JsonOutput |
| import org.gradle.api.DefaultTask |
| import org.gradle.api.tasks.TaskAction |
| |
| import java.util.regex.Pattern |
| |
| /** |
| * Task to download dependencies specified in {@link ChromiumPlugin} and configure the |
| * Chromium build to integrate them. Used by declaring a new task in a {@code build.gradle} |
| * file: |
| * <pre> |
| * task myTaskName(type: BuildConfigGenerator) { |
| * repositoryPath 'build_files_and_repository_location/' |
| * } |
| * </pre> |
| */ |
| class BuildConfigGenerator extends DefaultTask { |
| private static final BUILD_GN_TOKEN_START = "# === Generated Code Start ===" |
| private static final BUILD_GN_TOKEN_END = "# === Generated Code End ===" |
| private static final BUILD_GN_GEN_PATTERN = Pattern.compile( |
| "${BUILD_GN_TOKEN_START}(.*)${BUILD_GN_TOKEN_END}", |
| Pattern.DOTALL) |
| private static final BUILD_GN_GEN_REMINDER = "# This is generated, do not edit. Update BuildConfigGenerator.groovy instead.\n" |
| private static final DEPS_TOKEN_START = "# === ANDROID_DEPS Generated Code Start ===" |
| private static final DEPS_TOKEN_END = "# === ANDROID_DEPS Generated Code End ===" |
| private static final DEPS_GEN_PATTERN = Pattern.compile( |
| "${DEPS_TOKEN_START}(.*)${DEPS_TOKEN_END}", |
| Pattern.DOTALL) |
| private static final DOWNLOAD_DIRECTORY_NAME = "libs" |
| |
| // Some libraries are hosted in Chromium's //third_party directory. This is a mapping between |
| // them so they can be used instead of android_deps pulling in its own copy. |
| private static final def EXISTING_LIBS = [ |
| 'junit_junit': '//third_party/junit:junit', |
| 'org_hamcrest_hamcrest_core': '//third_party/hamcrest:hamcrest_core_java', |
| ] |
| |
| |
| /** |
| * Directory where the artifacts will be downloaded and where files will be generated. |
| * Note: this path is specified as relative to the chromium source root, and must be normalised |
| * to an absolute path before being used, as Groovy would base relative path where the script |
| * is being executed. |
| */ |
| String repositoryPath |
| |
| /** |
| * Relative path to the DEPS file where the cipd packages are specified. |
| */ |
| String depsPath |
| |
| /** |
| * Relative path to the Chromium source root from the build.gradle file. |
| */ |
| String chromiumSourceRoot |
| |
| /** |
| * Name of the cipd root package. |
| */ |
| String cipdBucket |
| |
| /** |
| * Prefix of path to strip before uploading to CIPD. |
| */ |
| String stripFromCipdPath |
| |
| /** |
| * Skips license file import. |
| */ |
| boolean skipLicenses |
| |
| /** |
| * Only pull play services targets into BUILD.gn file. |
| * If the play services target depends on a non-play services target, it will use the target in |
| * //third_party/android_deps/BUILD.gn. |
| */ |
| boolean onlyPlayServices |
| |
| @TaskAction |
| void main() { |
| def graph = new ChromiumDepGraph(project: project, skipLicenses: skipLicenses) |
| def normalisedRepoPath = normalisePath(repositoryPath) |
| def rootDirPath = normalisePath(".") |
| |
| // 1. Parse the dependency data |
| graph.collectDependencies() |
| |
| // 2. Import artifacts into the local repository |
| def dependencyDirectories = [] |
| graph.dependencies.values().each { dependency -> |
| if (excludeDependency(dependency, onlyPlayServices)) { |
| return |
| } |
| logger.debug "Processing ${dependency.name}: \n${jsonDump(dependency)}" |
| def depDir = "${DOWNLOAD_DIRECTORY_NAME}/${dependency.id}" |
| def absoluteDepDir = "${normalisedRepoPath}/${depDir}" |
| |
| dependencyDirectories.add(depDir) |
| |
| if (new File("${absoluteDepDir}/${dependency.fileName}").exists()) { |
| getLogger().quiet("${dependency.id} exists, skipping.") |
| return |
| } |
| |
| project.copy { |
| from dependency.artifact.file |
| into absoluteDepDir |
| } |
| |
| new File("${absoluteDepDir}/README.chromium").write(makeReadme(dependency)) |
| new File("${absoluteDepDir}/cipd.yaml").write(makeCipdYaml(dependency, cipdBucket, |
| stripFromCipdPath, |
| repositoryPath)) |
| new File("${absoluteDepDir}/OWNERS").write(makeOwners()) |
| if (!skipLicenses) { |
| if (!dependency.licensePath?.trim()?.isEmpty()) { |
| new File("${absoluteDepDir}/LICENSE").write( |
| new File("${normalisedRepoPath}/${dependency.licensePath}").text) |
| } else if (!dependency.licenseUrl?.trim()?.isEmpty()) { |
| File destFile = new File("${absoluteDepDir}/LICENSE") |
| downloadFile(dependency.id, dependency.licenseUrl, destFile) |
| if (destFile.text.contains("<html")) { |
| throw new RuntimeException("Found HTML in LICENSE file. Please add an " |
| + "override to ChromiumDepGraph.groovy for ${dependency.name}.") |
| } |
| } |
| } |
| } |
| |
| // 3. Generate the root level build files |
| updateBuildTargetDeclaration(graph, "${normalisedRepoPath}/BUILD.gn", onlyPlayServices) |
| updateDepsDeclaration(graph, cipdBucket, stripFromCipdPath, repositoryPath, |
| "${rootDirPath}/${depsPath}", onlyPlayServices) |
| dependencyDirectories.sort { path1, path2 -> return path1.compareTo(path2) } |
| updateReadmeReferenceFile(dependencyDirectories, |
| "${normalisedRepoPath}/additional_readme_paths.json") |
| } |
| |
| private static void updateBuildTargetDeclaration(ChromiumDepGraph depGraph, String path, |
| boolean onlyPlayServices) { |
| File buildFile = new File(path) |
| def sb = new StringBuilder() |
| |
| // Comparator to sort the dependency in alphabetical order, with the visible ones coming |
| // before all the internal ones. |
| def dependencyComparator = { dependency1, dependency2 -> |
| def visibilityResult = Boolean.compare(dependency1.visible, dependency2.visible) |
| if (visibilityResult != 0) return -visibilityResult |
| |
| return dependency1.id.compareTo(dependency2.id) |
| } |
| |
| depGraph.dependencies.values().sort(dependencyComparator).each { dependency -> |
| if (excludeDependency(dependency, onlyPlayServices)) { |
| return |
| } |
| def depsStr = "" |
| if (!dependency.children.isEmpty()) { |
| dependency.children.each { childDep -> |
| def dep = depGraph.dependencies[childDep] |
| if (dep.exclude) { |
| return |
| } |
| // Special case: If a child dependency is an existing lib, rather than skipping |
| // it, replace the child dependency with the existing lib. |
| def existingLib = EXISTING_LIBS.get(dep.id) |
| def targetName = translateTargetName(dep.id) + "_java" |
| if (existingLib != null) { |
| depsStr += "\"${existingLib}\"," |
| } else if (onlyPlayServices && !isPlayServicesTarget(dep.id)) { |
| depsStr += "\"//third_party/android_deps:${targetName}\"," |
| } else { |
| depsStr += "\":${targetName}\"," |
| } |
| } |
| } |
| |
| def libPath = "${DOWNLOAD_DIRECTORY_NAME}/${dependency.id}" |
| def targetName = translateTargetName(dependency.id) + "_java" |
| sb.append(BUILD_GN_GEN_REMINDER) |
| if (dependency.extension == 'jar') { |
| sb.append("""\ |
| java_prebuilt("${targetName}") { |
| jar_path = "${libPath}/${dependency.fileName}" |
| output_name = "${dependency.id}" |
| """.stripIndent()) |
| if (dependency.supportsAndroid) { |
| sb.append(" supports_android = true\n") |
| } else { |
| // No point in enabling asserts third-party prebuilts. |
| // Also required to break a dependency cycle for errorprone. |
| sb.append(" enable_bytecode_rewriter = false\n") |
| } |
| } else if (dependency.extension == 'aar') { |
| sb.append("""\ |
| android_aar_prebuilt("${targetName}") { |
| aar_path = "${libPath}/${dependency.fileName}" |
| info_path = "${libPath}/${dependency.id}.info" |
| """.stripIndent()) |
| } else { |
| throw new IllegalStateException("Dependency type should be JAR or AAR") |
| } |
| |
| if (!dependency.visible) { |
| sb.append(" # To remove visibility constraint, add this dependency to\n") |
| sb.append(" # //tools/android/roll/android_deps/build.gradle.\n") |
| sb.append(" visibility = [ \":*\" ]\n") |
| } |
| if (dependency.testOnly) sb.append(" testonly = true\n") |
| if (!depsStr.empty) sb.append(" deps = [${depsStr}]\n") |
| addSpecialTreatment(sb, dependency.id) |
| |
| sb.append("}\n\n") |
| } |
| |
| def matcher = BUILD_GN_GEN_PATTERN.matcher(buildFile.getText()) |
| if (!matcher.find()) throw new IllegalStateException("BUILD.gn insertion point not found.") |
| buildFile.write(matcher.replaceFirst( |
| "${BUILD_GN_TOKEN_START}\n${sb.toString()}\n${BUILD_GN_TOKEN_END}")) |
| } |
| |
| public static String translateTargetName(String targetName) { |
| if (isPlayServicesTarget(targetName)) { |
| return targetName.replaceFirst("com_", "").replaceFirst("android_gms_", "") |
| } |
| return targetName |
| } |
| |
| public static boolean isPlayServicesTarget(String dependencyId) { |
| // Firebase has historically been treated as a part of play services, so it counts here for |
| // backwards compatibility. |
| return Pattern.matches(".*google.*(play_services|firebase).*", dependencyId) |
| } |
| |
| private static void addSpecialTreatment(StringBuilder sb, String dependencyId) { |
| if (isPlayServicesTarget(dependencyId)) { |
| if (Pattern.matches(".*cast_framework.*", dependencyId)) { |
| sb.append(' # Removing all resources from cast framework as they are unused bloat.\n') |
| sb.append(' # Can only safely remove them when R8 will strip the path that accesses them.\n') |
| sb.append(' strip_resources = !is_java_debug\n') |
| } else { |
| sb.append(' # Removing drawables from GMS .aars as they are unused bloat.\n') |
| sb.append(' strip_drawables = true\n') |
| } |
| } |
| switch(dependencyId) { |
| case 'androidx_annotation_annotation': |
| sb.append(' # https://crbug.com/989505\n') |
| sb.append(' jar_excluded_patterns = ["META-INF/proguard/*"]\n') |
| break |
| case 'androidx_core_core': |
| case 'androidx_media_media': |
| case 'androidx_versionedparcelable_versionedparcelable': |
| case 'com_android_support_support_compat': |
| case 'com_android_support_support_media_compat': |
| case 'com_android_support_versionedparcelable': |
| // Target has AIDL, but we don't support it yet: http://crbug.com/644439 |
| sb.append(' ignore_aidl = true\n') |
| break |
| case 'androidx_test_uiautomator_uiautomator': |
| sb.append(' deps = [":androidx_test_runner_java"]\n') |
| break |
| case 'com_android_support_mediarouter_v7': |
| sb.append(' # https://crbug.com/1000382\n') |
| sb.append(' proguard_configs = ["support_mediarouter.flags"]\n') |
| break |
| case 'androidx_mediarouter_mediarouter': |
| sb.append(' # https://crbug.com/1000382\n') |
| sb.append(' proguard_configs = ["androidx_mediarouter.flags"]\n') |
| break |
| case 'androidx_transition_transition': |
| // Not specified in the POM, compileOnly dependency not supposed to be used unless |
| // the library is present: b/70887421 |
| sb.append(' deps += [":androidx_fragment_fragment_java"]\n') |
| break |
| case 'androidx_vectordrawable_vectordrawable': |
| case 'com_android_support_support_vector_drawable': |
| // Target has AIDL, but we don't support it yet: http://crbug.com/644439 |
| sb.append(' create_srcjar = false\n') |
| break |
| case 'android_arch_lifecycle_runtime': |
| case 'android_arch_lifecycle_viewmodel': |
| sb.append(' # https://crbug.com/887942#c1\n') |
| sb.append(' ignore_proguard_configs = true\n') |
| break |
| case 'com_android_support_coordinatorlayout': |
| sb.append(' # https:crbug.com/954584\n') |
| sb.append(' ignore_proguard_configs = true\n') |
| break |
| case 'com_android_support_design': |
| // Reduce binary size. https:crbug.com/954584 |
| sb.append(' ignore_proguard_configs = true\n') |
| break |
| case 'com_android_support_support_annotations': |
| sb.append(' # https://crbug.com/989505\n') |
| sb.append(' jar_excluded_patterns = ["META-INF/proguard/*"]\n') |
| break |
| case 'com_android_support_transition': |
| // Not specified in the POM, compileOnly dependency not supposed to be used unless |
| // the library is present: b/70887421 |
| sb.append(' deps += [":com_android_support_support_fragment_java"]\n') |
| break |
| case 'com_google_android_gms_play_services_basement': |
| // Deprecated deps jar but still needed by play services basement. |
| sb.append(' input_jars_paths=["\\$android_sdk/optional/org.apache.http.legacy.jar"]\n') |
| break |
| case 'com_google_ar_core': |
| // Target .aar file contains .so libraries that need to be extracted, |
| // and android_aar_prebuilt template will fail if it's not set explictly. |
| sb.append(' extract_native_libraries = true\n') |
| break |
| case 'com_google_guava_guava': |
| // Need to exclude class and replace it with class library as |
| // com_google_guava_listenablefuture has support_androids=true. |
| sb.append(' deps += [":com_google_guava_listenablefuture_java"]\n') |
| sb.append(' jar_excluded_patterns = ["*/ListenableFuture.class"]\n') |
| break |
| case 'com_google_guava_listenablefuture_java': |
| // Needed to break dependency cycle for errorprone_plugin_java. |
| sb.append(' no_build_hooks = true\n') |
| break |
| case 'androidx_test_rules': |
| // Target needs Android SDK deps which exist in third_party/android_sdk. |
| sb.append("""\ |
| | deps += [ |
| | "//third_party/android_sdk:android_test_base_java", |
| | "//third_party/android_sdk:android_test_mock_java", |
| | "//third_party/android_sdk:android_test_runner_java", |
| | ] |
| | |
| |""".stripMargin()) |
| break |
| case 'net_sf_kxml_kxml2': |
| sb.append(' # Target needs to exclude *xmlpull* files as already included in Android SDK.\n') |
| sb.append(' jar_excluded_patterns = [ "*xmlpull*" ]\n') |
| break |
| case 'com_android_support_preference_v7': |
| // Replace broad library -keep rules with a more limited set in |
| // chrome/android/java/proguard.flags instead. |
| sb.append(' ignore_proguard_configs = true\n') |
| break |
| } |
| } |
| |
| private static void updateDepsDeclaration(ChromiumDepGraph depGraph, String cipdBucket, |
| String stripFromCipdPath, String repoPath, |
| String depsFilePath, boolean onlyPlayServices) { |
| File depsFile = new File(depsFilePath) |
| def sb = new StringBuilder() |
| // Note: The string we're inserting is nested 1 level, hence the 2 leading spaces. Same |
| // applies to the multiline package declaration string below. |
| sb.append(" # Generated by //tools/android/roll/android_deps/fetch_all.py") |
| |
| // Comparator to sort the dependencies in alphabetical order. |
| def dependencyComparator = { dependency1, dependency2 -> |
| return dependency1.id.compareTo(dependency2.id) |
| } |
| |
| depGraph.dependencies.values().sort(dependencyComparator).each { dependency -> |
| if (excludeDependency(dependency, onlyPlayServices)) { |
| return |
| } |
| def depPath = "${DOWNLOAD_DIRECTORY_NAME}/${dependency.id}" |
| def cipdPath = "${cipdBucket}/" |
| if (stripFromCipdPath) { |
| assert repoPath.startsWith(stripFromCipdPath) |
| cipdPath += repoPath.substring(stripFromCipdPath.length() + 1) |
| } else { |
| cipdPath += repoPath |
| } |
| // CIPD does not allow uppercase in names. |
| cipdPath += "/${depPath}".toLowerCase() |
| sb.append("""\ |
| | |
| | 'src/${repoPath}/${depPath}': { |
| | 'packages': [ |
| | { |
| | 'package': '${cipdPath}', |
| | 'version': 'version:${dependency.version}-${dependency.cipdSuffix}', |
| | }, |
| | ], |
| | 'condition': 'checkout_android', |
| | 'dep_type': 'cipd', |
| | }, |
| |""".stripMargin()) |
| } |
| |
| def matcher = DEPS_GEN_PATTERN.matcher(depsFile.getText()) |
| if (!matcher.find()) throw new IllegalStateException("DEPS insertion point not found.") |
| depsFile.write(matcher.replaceFirst("${DEPS_TOKEN_START}\n${sb}\n ${DEPS_TOKEN_END}")) |
| } |
| |
| private static void updateReadmeReferenceFile(List<String> directories, String readmePath) { |
| File refFile = new File(readmePath) |
| refFile.write(JsonOutput.prettyPrint(JsonOutput.toJson(directories)) + "\n") |
| } |
| |
| public static boolean excludeDependency(ChromiumDepGraph.DependencyDescription dependency, |
| boolean onlyPlayServices) { |
| return dependency.exclude || EXISTING_LIBS.get(dependency.id) != null || |
| (onlyPlayServices && !isPlayServicesTarget(dependency.id)) |
| } |
| |
| private String normalisePath(String pathRelativeToChromiumRoot) { |
| return project.file("${chromiumSourceRoot}/${pathRelativeToChromiumRoot}").absolutePath |
| } |
| |
| static String makeOwners() { |
| // Make it easier to upgrade existing dependencies without full third_party review. |
| return "file://third_party/android_deps/OWNERS" |
| } |
| |
| static String makeReadme(ChromiumDepGraph.DependencyDescription dependency) { |
| def licenseString |
| // Replace license names with ones that are whitelisted, see third_party/PRESUBMIT.py |
| switch (dependency.licenseName) { |
| case "The Apache Software License, Version 2.0": |
| licenseString = "Apache Version 2.0" |
| break |
| default: |
| licenseString = dependency.licenseName |
| } |
| |
| def securityCritical = dependency.supportsAndroid && dependency.isShipped |
| def licenseFile = dependency.isShipped? "LICENSE" : "NOT_SHIPPED" |
| |
| return """\ |
| Name: ${dependency.displayName} |
| Short Name: ${dependency.name} |
| URL: ${dependency.url} |
| Version: ${dependency.version} |
| License: ${licenseString} |
| License File: ${licenseFile} |
| Security Critical: ${securityCritical? "yes" : "no"} |
| ${dependency.licenseAndroidCompatible? "License Android Compatible: yes" : ""} |
| Description: |
| ${dependency.description} |
| |
| Local Modifications: |
| No modifications. |
| """.stripIndent() |
| } |
| |
| static String makeCipdYaml(ChromiumDepGraph.DependencyDescription dependency, String cipdBucket, |
| String stripFromCipdPath, String repoPath) { |
| if (!stripFromCipdPath) { |
| stripFromCipdPath = '' |
| } |
| def cipdVersion = "${dependency.version}-${dependency.cipdSuffix}" |
| def cipdPath = "${cipdBucket}/" |
| if (stripFromCipdPath) { |
| assert repoPath.startsWith(stripFromCipdPath) |
| cipdPath += repoPath.substring(stripFromCipdPath.length() + 1) |
| } else { |
| cipdPath += repoPath |
| } |
| // CIPD does not allow uppercase in names. |
| cipdPath += "/${DOWNLOAD_DIRECTORY_NAME}/" + dependency.id.toLowerCase() |
| |
| // NOTE: the fetch_all.py script relies on the format of this file! |
| // See fetch_all.py:GetCipdPackageInfo(). |
| // NOTE: keep the copyright year 2018 until this generated code is |
| // updated, avoiding annual churn of all cipd.yaml files. |
| def str = """\ |
| # Copyright 2018 The Chromium Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| # To create CIPD package run the following command. |
| # cipd create --pkg-def cipd.yaml -tag version:${cipdVersion} |
| package: ${cipdPath} |
| description: "${dependency.displayName}" |
| data: |
| - file: ${dependency.fileName} |
| """.stripIndent() |
| |
| return str |
| } |
| |
| static String jsonDump(obj) { |
| return JsonOutput.prettyPrint(JsonOutput.toJson(obj)) |
| } |
| |
| static void printDump(obj) { |
| getLogger().warn(jsonDump(obj)) |
| } |
| |
| static HttpURLConnection connectAndFollowRedirects(String id, String sourceUrl) { |
| URL urlObj = new URL(sourceUrl) |
| HttpURLConnection connection |
| for (int i = 0; i < 10; ++i) { |
| // Several deps use this URL for their license, but it just points to license |
| // *template*. Generally the actual license can be found in the source code. |
| if (sourceUrl.contains("://opensource.org/licenses")) { |
| throw new RuntimeException("Found templated license URL for dependency " |
| + id + ": " + sourceUrl |
| + ". You will need to edit FALLBACK_PROPERTIES for this dep.") |
| } |
| connection = urlObj.openConnection() |
| switch (connection.getResponseCode()) { |
| case HttpURLConnection.HTTP_MOVED_PERM: |
| case HttpURLConnection.HTTP_MOVED_TEMP: |
| String location = connection.getHeaderField("Location"); |
| urlObj = new URL(urlObj, location); |
| continue |
| case HttpURLConnection.HTTP_OK: |
| return connection |
| default: |
| throw new RuntimeException( |
| "Url had statusCode=" + connection.getResponseCode() + ": " + sourceUrl) |
| } |
| } |
| throw new RuntimeException("Url in redirect loop: " + sourceUrl) |
| } |
| |
| static void downloadFile(String id, String sourceUrl, File destinationFile) { |
| destinationFile.withOutputStream { out -> |
| out << connectAndFollowRedirects(id, sourceUrl).getInputStream() |
| } |
| } |
| |
| } |
