🎅 Use GN's dependency info for native libraries in write_build_config.py

build/config/android/rules.gni

 # Copyright 2014 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("//build/config/android/config.gni")
 import("//build/config/android/internal_rules.gni")
 import("//build/toolchain/toolchain.gni")
 
 assert(is_android)
 
@@ skipping 1371 matching lines @@
   #     they are depended on through android_library or android_resources targets
   #     (and so not through builtin targets like 'action', 'group', etc).
   #   install_script_name: Name of wrapper script (default=target_name).
   #   java_files: List of .java files to include in the apk.
   #   srcjar_deps: List of srcjar dependencies. The .java files in the srcjars
   #      will be added to java_files and be included in this apk.
   #   apk_name: Name for final apk.
   #   final_apk_path: Path to final built apk. Default is
   #     $root_out_dir/apks/$apk_name.apk. Setting this will override apk_name.
   #   loadable_modules: List of paths to native libraries to include. Different
-  #     from |native_libs| in that:
+  #     from |shared_libraries| in that:
   #       * dependencies of this .so are not automatically included
   #       * ".cr.so" is never added
   #       * they are not side-loaded for _incremental targets.
   #       * load_library_from_apk, use_chromium_linker,
   #         and enable_relocation_packing do not apply
-  #     Use this instead of native_libs when you are going to load the library
-  #     conditionally, and only when native_libs doesn't work for you.
-  #   native_libs: List paths of native libraries to include in this apk. If these
+  #     Use this instead of shared_libraries when you are going to load the library
+  #     conditionally, and only when shared_libraries doesn't work for you.
+  #   shared_libraries: List shared_library targets to bundle. If these
   #     libraries depend on other shared_library targets, those dependencies will
-  #     also be included in the apk. When building with is_component_build,
-  #     The extension is automatically changed to ".cr.so".

[jbudorick, 2016/06/22 14:20:48]

Is this no longer true?

[agrieve, 2016/06/22 14:33:59]

We're now specifying target labels rather than file names, so the comment isn't
really relevant anymore (but it does still output the correct names when in
component mode)

+  #     also be included in the apk (e.g. for is_component_build).
   #   native_lib_placeholders: List of placeholder filenames to add to the apk
   #     (optional).
   #   apk_under_test: For an instrumentation test apk, this is the target of the
   #     tested apk.
   #   include_all_resources - If true include all resource IDs in all generated
   #     R.java files.
   #   testonly: Marks this target as "test-only".
   #   write_asset_list: Adds an extra file to the assets, which contains a list of
   #     all other asset files.
   #   alternative_locale_resource_dep: The locale resource target which overrides
@@ skipping 14 matching lines @@
   #       "android/org/chromium/foo/FooApplication.java",
   #       "android/org/chromium/foo/FooActivity.java",
   #     ]
   #     deps = [
   #       ":foo_support_java"
   #       ":foo_resources"
   #     ]
   #     srcjar_deps = [
   #       ":foo_generated_enum"
   #     ]
-  #     native_libs = [
-  #       native_lib_path
+  #     shared_libraries = [
+  #       ":my_shared_lib",
   #     ]
   #   }
   template("android_apk") {
     set_sources_assignment_filter([])
     forward_variables_from(invoker, [ "testonly" ])
 
     assert(defined(invoker.final_apk_path) || defined(invoker.apk_name))
     assert(defined(invoker.android_manifest))
     gen_dir = "$target_gen_dir/$target_name"
     base_path = "$gen_dir/$target_name"
@@ skipping 26 matching lines @@
     _final_apk_path_no_ext = _final_apk_path_no_ext_list[0]
     assert(_final_apk_path_no_ext != "")  # Mark as used.
 
     _install_script_name = "install_$_template_name"
     if (defined(invoker.install_script_name)) {
       _install_script_name = invoker.install_script_name
     }
     _incremental_install_script_path =
         "${root_out_dir}/bin/${_install_script_name}_incremental"
 
-    _native_libs = []
-
     _version_code = android_default_version_code
     if (defined(invoker.version_code)) {
       _version_code = invoker.version_code
     }
 
     _version_name = android_default_version_name
     if (defined(invoker.version_name)) {
       _version_name = invoker.version_name
     }
     _keystore_path = android_keystore_path
@@ skipping 29 matching lines @@
     }
     if (_load_library_from_apk) {
       assert(_use_chromium_linker || _requires_sdk_api_level_23,
              "load_library_from_apk requires use_chromium_linker " +
                  "or requires_sdk_api_level_23")
     }
 
     # The dependency that makes the chromium linker, if any is needed.
     _native_libs_deps = []
 
-    if (defined(invoker.native_libs) && invoker.native_libs != []) {
+    if (defined(invoker.shared_libraries) && invoker.shared_libraries != []) {
+      _native_libs_deps += invoker.shared_libraries
+
       if (is_component_build || is_asan) {
-        _native_libs += [ "$root_shlib_dir/libc++_shared.so" ]
         _native_libs_deps += [ "//build/android:cpplib_stripped" ]
       }
 
-      # Allow native_libs to be in the form "foo.so" or "foo.cr.so"
-      _first_ext_removed =
-          process_file_template(invoker.native_libs, "{{source_name_part}}")
-      _native_libs += process_file_template(
-              _first_ext_removed,
-              "$root_shlib_dir/{{source_name_part}}$shlib_extension")
+      # To determine the filenames of all dependent shared libraries, write the
+      # runtime deps of |shared_libraries| to a file during "gn gen".
+      # write_build_config.py will then grep this file for *.so to obtain the
+      # complete list.
+      _runtime_deps_file =
+          "$target_gen_dir/${_template_name}.native.runtimedeps"
+      group("${_template_name}__runtime_deps") {
+        deps = _native_libs_deps

[jbudorick, 2016/06/22 14:20:48]

Does this need to be a build-time dependency? Could it instead be data_deps,
allowing the build_config target to depend on the runtime_deps target w/o
requiring the native libs to be built beforehand?

[agrieve, 2016/06/22 14:33:59]

My goal is to write a script that will directly build all __build_config
targets, and not have to wait for all of the native code to build. This could
use data_deps, but then ninja wouldn't return until all of them have built.

[jbudorick, 2016/06/22 14:52:52]

Ah, ok. So it wants to depend on the names but not the actual objects?

[agrieve, 2016/06/22 15:39:23]

Exactly. It just needs the output paths, but they don't need to exist yet.

[jbudorick, 2016/06/22 15:44:22]

sgtm

+        write_runtime_deps = _runtime_deps_file
+      }
 
       _native_lib_version_rule = ""
       if (defined(invoker.native_lib_version_rule)) {
         _native_lib_version_rule = invoker.native_lib_version_rule
       }
       _native_lib_version_arg = "\"\""
       if (defined(invoker.native_lib_version_arg)) {
         _native_lib_version_arg = invoker.native_lib_version_arg
       }
     }
@@ skipping 29 matching lines @@
       type = "android_apk"
       jar_path = _jar_path
       dex_path = final_dex_path
       apk_path = _final_apk_path
       incremental_apk_path = "${_final_apk_path_no_ext}_incremental.apk"
       incremental_install_script_path = _incremental_install_script_path
       resources_zip = resources_zip_path
       build_config = _build_config
       android_manifest = _android_manifest
 
-      deps = _native_libs_deps + _android_manifest_deps
+      deps = _android_manifest_deps
       if (defined(invoker.deps)) {
         deps += invoker.deps
       }
 
       if (defined(invoker.alternative_locale_resource_dep)) {
         deps += [ invoker.alternative_locale_resource_dep ]
         has_alternative_locale_resource = true
       }
 
       # Added emma to the target's classpath via its .build_config.
       if (emma_coverage && !_emma_never_instrument) {
         deps += [ "//third_party/android_tools:emma_device" ]
       }
 
       proguard_enabled = _proguard_enabled
       if (_proguard_enabled) {
         proguard_info = "$_proguard_output_jar_path.info"
       }
 
-      native_libs = _native_libs
+      # Don't depend on the runtime_deps target in order to avoid having to
+      # build the native libraries just to create the .build_config file.
+      # The dep is unnecessary since the runtime_deps file is created by gn gen
+      # and the runtime_deps file is added to write_build_config.py's depfile.
+      if (_native_libs_deps != []) {
+        shared_libraries_runtime_deps_file = _runtime_deps_file
+      }
     }
 
     _final_deps = []
 
     _generated_proguard_config = "$base_path.resources.proguard.txt"
     process_resources_target = "${_template_name}__process_resources"
     process_resources(process_resources_target) {
       forward_variables_from(invoker,
                              [
                                "alternative_android_sdk_jar",
@@ skipping 12 matching lines @@
       proguard_file = _generated_proguard_config
 
       build_config = _build_config
       deps = _android_manifest_deps + [ ":$build_config_target" ]
       if (defined(invoker.deps)) {
         deps += invoker.deps
       }
     }
     _srcjar_deps += [ ":$process_resources_target" ]
 
-    if (_native_libs != []) {
+    if (_native_libs_deps != []) {
       _enable_chromium_linker_tests = false
       if (defined(invoker.enable_chromium_linker_tests)) {
         _enable_chromium_linker_tests = invoker.enable_chromium_linker_tests
       }
 
       java_cpp_template("${_template_name}__native_libraries_java") {
         package_name = "org/chromium/base/library_loader"
         sources = [
           "//base/android/java/templates/NativeLibraries.template",
         ]
@@ skipping 172 matching lines @@
           _dex_arg_key =
               "${_rebased_build_config}:final_dex:dependency_dex_files"
         }
         args = [ "--inputs=@FileArg($_dex_arg_key)" ]
       }
     }
 
     _native_libs_file_arg_dep = ":$build_config_target"
     _native_libs_file_arg = "@FileArg($_rebased_build_config:native:libraries)"
 
-    if (_native_libs != [] && _enable_relocation_packing) {
+    if (_native_libs_deps != [] && _enable_relocation_packing) {
       _prepare_native_target_name = "${_template_name}__prepare_native"
       _native_libs_dir = "$gen_dir/packed-libs"
       _native_libs_json = "$gen_dir/packed-libs/filelist.json"
       _rebased_native_libs_json = rebase_path(_native_libs_json, root_build_dir)
 
       _native_libs_file_arg_dep = ":$_prepare_native_target_name"
       _native_libs_file_arg = "@FileArg($_rebased_native_libs_json:files)"
 
       action(_prepare_native_target_name) {
         forward_variables_from(invoker,
                                [
                                  "deps",
                                  "public_deps",
                                ])
         script = "//build/android/gyp/pack_relocations.py"
         depfile = "$target_gen_dir/$target_name.d"
         outputs = [
           depfile,
           _native_libs_json,
         ]
 
-        inputs = _native_libs + [ _build_config ]
+        inputs = [
+          _build_config,
+        ]
 
         deps += _native_libs_deps
         deps += [
           ":$build_config_target",
           relocation_packer_target,
         ]
 
         args = [
           "--depfile",
           rebase_path(depfile, root_build_dir),
           "--enable-packing=1",
           "--android-pack-relocations",
           rebase_path(relocation_packer_exe, root_build_dir),
           "--stripped-libraries-dir",
           rebase_path(root_build_dir, root_build_dir),
           "--packed-libraries-dir",
           rebase_path(_native_libs_dir, root_build_dir),
           "--libraries=@FileArg(${_rebased_build_config}:native:libraries)",
           "--filelistjson=$_rebased_native_libs_json",
         ]
       }
     }
 
     _extra_native_libs = []
     _extra_native_libs_deps = []
     _extra_native_libs_even_when_incremental = []
     _extra_native_libs_even_when_incremental_deps = []
     assert(_extra_native_libs_even_when_incremental_deps == [])  # Mark as used.
-    if (_native_libs != []) {
+    if (_native_libs_deps != []) {
       if (is_debug) {
         _extra_native_libs_even_when_incremental = [ android_gdbserver ]
       }
 
       if (_use_chromium_linker) {
         _extra_native_libs =
             [ "$root_shlib_dir/libchromium_android_linker$shlib_extension" ]
         _extra_native_libs_deps +=
             [ "//base/android/linker:chromium_android_linker" ]
       }
@@ skipping 51 matching lines @@
                            ":$process_resources_target",
                          ]
 
       # This target generates the input file _all_resources_zip_path.
       deps += _android_manifest_deps + [
                 ":$build_config_target",
                 ":$process_resources_target",
                 ":$final_dex_target_name",
               ]
 
-      if ((_native_libs != [] ||
+      if ((_native_libs_deps != [] ||
            _extra_native_libs_even_when_incremental != []) &&
           !_create_abi_split) {
         deps += _native_libs_deps + _extra_native_libs_deps +
                 _extra_native_libs_even_when_incremental_deps +
                 [ _native_libs_file_arg_dep ]
         native_libs_filearg = _native_libs_file_arg
         native_libs = _extra_native_libs
         native_libs_even_when_incremental =
             _extra_native_libs_even_when_incremental
       }
 
       # Placeholders necessary for some older devices.
       # http://crbug.com/395038
       forward_variables_from(invoker, [ "native_lib_placeholders" ])
     }
 
-    if ((_native_libs != [] || _extra_native_libs_even_when_incremental != []) && _create_abi_split) {
+    if ((_native_libs_deps != [] ||
+         _extra_native_libs_even_when_incremental != []) && _create_abi_split) {
       _manifest_rule =
           "${_template_name}__split_manifest_abi_${android_app_abi}"
       generate_split_manifest(_manifest_rule) {
         main_manifest = _android_manifest
         out_manifest =
             "$gen_dir/split-manifests/${android_app_abi}/AndroidManifest.xml"
         split_name = "abi_${android_app_abi}"
         deps = _android_manifest_deps
       }
 
@@ skipping 137 matching lines @@
   #     "transitive closure" of these dependencies will be included in the apk.
   #     Note: this "transitive closure" actually only includes such targets if
   #     they are depended on through android_library or android_resources targets
   #     (and so not through builtin targets like 'action', 'group', etc).
   #   java_files: List of .java files to include in the apk.
   #   srcjar_deps: List of srcjar dependencies. The .java files in the srcjars
   #      will be added to java_files and be included in this apk.
   #   apk_name: Name for final apk.
   #   final_apk_path: Path to final built apk. Default is
   #     $root_out_dir/apks/$apk_name.apk. Setting this will override apk_name.
-  #   native_libs: List paths of native libraries to include in this apk. If these
+  #   shared_libraries: List shared_library targets to bundle. If these
   #     libraries depend on other shared_library targets, those dependencies will
-  #     also be included in the apk.
+  #     also be included in the apk (e.g. for is_component_build).
   #   apk_under_test: The apk being tested.
   #   isolate_file: Isolate file containing the list of test data dependencies.
   #
   # Example
   #   instrumentation_test_apk("foo_test_apk") {
   #     android_manifest = "AndroidManifest.xml"
   #     apk_name = "FooTest"
   #     apk_under_test = "Foo"
   #     java_files = [
   #       "android/org/chromium/foo/FooTestCase.java",
@@ skipping 100 matching lines @@
   }
 
   # Declare an Android gtest apk
   #
   # This target creates an Android apk for running gtest-based unittests.
   #
   # Variables
   #   deps: Specifies the dependencies of this target. These will be passed to
   #     the underlying android_apk invocation and should include the java and
   #     resource dependencies of the apk.
-  #   unittests_dep: This should be the label of the gtest native target. This
-  #     target must be defined previously in the same file.
-  #   unittests_binary: The basename of the library produced by the unittests_dep
-  #     target. If unspecified, it assumes the name of the unittests_dep target
-  #     (which will be correct unless that target specifies an "output_name".
-  #     TODO(brettw) make this automatic by allowing get_target_outputs to
-  #     support executables.
+  #   shared_library: shared_library target that contains the unit tests.
   #   apk_name: The name of the produced apk. If unspecified, it uses the name
-  #             of the unittests_dep target postfixed with "_apk"
+  #             of the shared_library target suffixed with "_apk"
   #   use_default_launcher: Whether the default activity (NativeUnitTestActivity)
   #     should be used for launching tests.
   #   use_native_activity: Test implements ANativeActivity_onCreate().
   #
   # Example
   #   unittest_apk("foo_unittests_apk") {
   #     deps = [ ":foo_java", ":foo_resources" ]
-  #     unittests_dep = ":foo_unittests"
+  #     shared_library = ":foo_unittests"
   #   }
   template("unittest_apk") {
-    assert(defined(invoker.unittests_dep),
-           "Need unittests_dep for $target_name")
-
-    test_suite_name = get_label_info(invoker.unittests_dep, "name")
-
-    # This trivial assert is needed in case both unittests_binary and apk_name
-    # are defined, as otherwise test_suite_name would not be used.
-    assert(test_suite_name != "")
-
     _use_native_activity =
         defined(invoker.use_native_activity) && invoker.use_native_activity
     _android_manifest = "$target_gen_dir/$target_name/AndroidManifest.xml"
+    assert(invoker.shared_library != "")
 
     # This trivial assert is needed in case android_manifest is defined,
     # as otherwise _use_native_activity and _android_manifest would not be used.
     assert(_use_native_activity != "" && _android_manifest != "")
 
     if (!defined(invoker.android_manifest)) {
       jinja_template("${target_name}_manifest") {
-        if (!defined(invoker.unittests_binary)) {
-          native_library_name = test_suite_name
-        } else {
-          native_library_name = invoker.unittests_binary
-        }
+        _native_library_name = get_label_info(invoker.shared_library, "name")
         input = "//testing/android/native_test/java/AndroidManifest.xml.jinja2"
         output = _android_manifest
         variables = [
           "is_component_build=${is_component_build}",
-          "native_library_name=${native_library_name}",
+          "native_library_name=${_native_library_name}",
           "use_native_activity=${_use_native_activity}",
         ]
       }
     }
 
     android_apk(target_name) {
       set_sources_assignment_filter([])
       data_deps = []
       deps = []
       forward_variables_from(invoker, "*")
       testonly = true
 
       if (defined(invoker.proguard_enabled) && invoker.proguard_enabled) {
         assert(invoker.proguard_configs != [])
         proguard_enabled = true
         proguard_configs = invoker.proguard_configs
       }
 
       if (!defined(apk_name)) {
-        apk_name = test_suite_name
+        apk_name = get_label_info(invoker.shared_library, "name")
       }
 
       if (!defined(android_manifest)) {
         deps += [ ":${target_name}_manifest" ]
         android_manifest = _android_manifest
       }
 
-      if (!defined(unittests_binary)) {
-        unittests_binary = "lib${test_suite_name}${shlib_extension}"
-      }
-
       final_apk_path = "$root_build_dir/${apk_name}_apk/${apk_name}-debug.apk"
 
       if (!defined(use_default_launcher) || use_default_launcher) {
         deps += [ "//testing/android/native_test:native_test_java" ]
       }
-      native_libs = [ unittests_binary ]
+      shared_libraries = [ invoker.shared_library ]
       deps += [
         "//base:base_java",
         "//testing/android/appurify_support:appurify_support_java",
         "//testing/android/reporter:reporter_java",
       ]
       data_deps += [
         "//build/android/pylib/remote/device/dummy:remote_device_dummy_apk",
         "//tools/android/md5sum",
       ]
       if (host_os == "linux") {
@@ skipping 132 matching lines @@
     android_library(target_name) {
       chromium_code = false
       java_files = []
       srcjar_deps = [ ":${_template_name}__protoc_java" ]
       deps = [
         "//third_party/android_protobuf:protobuf_nano_javalib",
       ]
     }
   }
 }