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

build/android/gyp/write_build_config.py

 #!/usr/bin/env python
 #
 # 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.
 
 """Writes a build_config file.
 
 The build_config file for a target is a json file containing information about
 how to build that target based on the target's dependencies. This includes
@@ skipping 17 matching lines @@
 
 import itertools
 import optparse
 import os
 import sys
 import xml.dom.minidom
 
 from util import build_utils
 from util import md5_check
 
 import write_ordered_libraries

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

nit: get rid of this

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

Done.

 
 
 # Types that should never be used as a dependency of another build config.
 _ROOT_TYPES = ('android_apk', 'deps_dex', 'java_binary', 'resource_rewriter')
 # Types that should not allow code deps to pass through.
 _RESOURCE_TYPES = ('android_assets', 'android_resources')
 
 
 class AndroidManifest(object):
   def __init__(self, path):
@@ skipping 125 matching lines @@
   # Don't allow java libraries to cross through assets/resources.
   if target_type in _RESOURCE_TYPES:
     ret = [p for p in ret if GetDepConfig(p)['type'] in _RESOURCE_TYPES]
   return ret
 
 
 def _AsInterfaceJar(jar_path):
   return jar_path[:-3] + 'interface.jar'
 
 
+def _ExtractSharedLibsFromRuntimeDeps(runtime_deps_files):
+  ret = []
+  for path in runtime_deps_files:
+    with open(path) as f:
+      for line in f:
+        line = line.rstrip()
+        if not line.endswith('.so'):
+          continue
+        ret.append(os.path.normpath(line))
+  ret.reverse()
+  return ret
+
+
 def main(argv):
   parser = optparse.OptionParser()
   build_utils.AddDepfileOption(parser)
   parser.add_option('--build-config', help='Path to build_config output.')
   parser.add_option(
       '--type',
       help='Type of this target (e.g. android_library).')
   parser.add_option(
       '--possible-deps-configs',
       help='List of paths for dependency\'s build_config files. Some '
@@ skipping 27 matching lines @@
       help='Whether this library supports running on the Android platform.')
   parser.add_option('--requires-android', action='store_true',
       help='Whether this library requires running on the Android platform.')
   parser.add_option('--bypass-platform-checks', action='store_true',
       help='Bypass checks for support/require Android platform.')
 
   # android library options
   parser.add_option('--dex-path', help='Path to target\'s dex output.')
 
   # native library options
-  parser.add_option('--native-libs', help='List of top-level native libs.')
-  parser.add_option('--readelf-path', help='Path to toolchain\'s readelf.')
+  parser.add_option('--shared-libraries-runtime-deps',
+                    help='Path to file containing runtime deps for shared '
+                         'libraries.')
 
   # apk options
   parser.add_option('--apk-path', help='Path to the target\'s apk output.')
   parser.add_option('--incremental-apk-path',
                     help="Path to the target's incremental apk output.")
   parser.add_option('--incremental-install-script-path',
                     help="Path to the target's generated incremental install "
                     "script.")
 
   parser.add_option('--tested-apk-config',
@@ skipping 18 matching lines @@
       'android_resources': ['build_config', 'resources_zip'],
       'android_apk': ['build_config', 'jar_path', 'dex_path', 'resources_zip'],
       'deps_dex': ['build_config', 'dex_path'],
       'resource_rewriter': ['build_config'],
       'group': ['build_config'],
   }
   required_options = required_options_map.get(options.type)
   if not required_options:
     raise Exception('Unknown type: <%s>' % options.type)
 
-  if options.native_libs:
-    required_options.append('readelf_path')
-
   build_utils.CheckOptions(options, parser, required_options)
 
   if options.type == 'java_library':
     if options.supports_android and not options.dex_path:
       raise Exception('java_library that supports Android requires a dex path.')
 
     if options.requires_android and not options.supports_android:
       raise Exception(
           '--supports-android is required when using --requires-android')
 
@@ skipping 241 matching lines @@
       'dependency_jars': dependency_jars,
       'all_interface_jars': all_interface_jars,
     }
     manifest = AndroidManifest(options.android_manifest)
     deps_info['package_name'] = manifest.GetPackageName()
     if not options.tested_apk_config and manifest.GetInstrumentation():
       # This must then have instrumentation only for itself.
       manifest.CheckInstrumentation(manifest.GetPackageName())
 
     library_paths = []
-    java_libraries_list_holder = [None]
-    libraries = build_utils.ParseGypList(options.native_libs or '[]')
-    if libraries:
-      def recompute_ordered_libraries():
-        libraries_dir = os.path.dirname(libraries[0])
-        write_ordered_libraries.SetReadelfPath(options.readelf_path)

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

Do we no longer need to do the library ordering logic here? If not, can we
either remove that code entirely or at least nix the import here?

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

It seems GN is consistent in ordering the files in dependency order.

GYP doesn't use write_build_config, but it does still use
write_ordered_libraries. I think we can't delete the code until GYP is gone.

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

sgtm

-        write_ordered_libraries.SetLibraryDirs([libraries_dir])
-        all_deps = (
-            write_ordered_libraries.GetSortedTransitiveDependenciesForBinaries(
-                libraries))
-        # Create a java literal array with the "base" library names:
-        # e.g. libfoo.so -> foo
-        java_libraries_list_holder[0] = ('{%s}' % ','.join(
-            ['"%s"' % s[3:-3] for s in all_deps]))
-        library_paths.extend(
-            write_ordered_libraries.FullLibraryPath(x) for x in all_deps)
+    java_libraries_list = None
+    runtime_deps_files = build_utils.ParseGypList(
+        options.shared_libraries_runtime_deps or '[]')
+    if runtime_deps_files:
+      library_paths = _ExtractSharedLibsFromRuntimeDeps(runtime_deps_files)
+      # Create a java literal array with the "base" library names:
+      # e.g. libfoo.so -> foo
+      java_libraries_list = ('{%s}' % ','.join(
+          ['"%s"' % s[3:-3] for s in library_paths]))
 
-      # This step takes about 600ms on a z620 for chrome_apk, so it's worth
-      # caching.
-      md5_check.CallAndRecordIfStale(
-          recompute_ordered_libraries,
-          record_path=options.build_config + '.nativelibs.md5.stamp',
-          input_paths=libraries,
-          output_paths=[options.build_config])
-      if not library_paths:
-        prev_config = build_utils.ReadJson(options.build_config)
-        java_libraries_list_holder[0] = (
-            prev_config['native']['java_libraries_list'])
-        library_paths.extend(prev_config['native']['libraries'])
-
-    all_inputs.extend(library_paths)
+    all_inputs.extend(runtime_deps_files)
     config['native'] = {
       'libraries': library_paths,
-      'java_libraries_list': java_libraries_list_holder[0],
+      'java_libraries_list': java_libraries_list,
     }
     config['assets'], config['uncompressed_assets'] = (
         _MergeAssets(deps.All('android_assets')))
 
   build_utils.WriteJson(config, options.build_config, only_if_changed=True)
 
   if options.depfile:
     build_utils.WriteDepfile(options.depfile, all_inputs)
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv[1:]))