🎣 Reland of Make Android .build_configs aware of prebuilts and java sources

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 113 matching lines @@
 
   def AllConfigPaths(self):
     return self.all_deps_config_paths
 
   def RemoveNonDirectDep(self, path):
     if path in self.direct_deps_config_paths:
       raise Exception('Cannot remove direct dep.')
     self.all_deps_config_paths.remove(path)
     self.all_deps_configs.remove(GetDepConfig(path))
 
+  def PrebuiltJarPaths(self):
+    ret = []
+    for config in self.Direct('java_library'):
+      if config['is_prebuilt']:
+        ret.append(config['jar_path'])
+        ret.extend(Deps(config['deps_configs']).PrebuiltJarPaths())
+    return ret
+
+
 def _MergeAssets(all_assets):
   """Merges all assets from the given deps.
 
   Returns:
     A tuple of lists: (compressed, uncompressed)
     Each tuple entry is a list of "srcPath:zipPath". srcPath is the path of the
     asset to add, and zipPath is the location within the zip (excluding assets/
     prefix)
   """
   compressed = {}
@@ skipping 75 matching lines @@
   parser.add_option('--asset-sources', help='List of asset sources.')
   parser.add_option('--asset-renaming-sources',
                     help='List of asset sources with custom destinations.')
   parser.add_option('--asset-renaming-destinations',
                     help='List of asset custom destinations.')
   parser.add_option('--disable-asset-compression', action='store_true',
                     help='Whether to disable asset compression.')
 
   # java library options
   parser.add_option('--jar-path', help='Path to target\'s jar output.')
+  parser.add_option('--java-sources-file', help='Path to .sources file')
   parser.add_option('--supports-android', action='store_true',
       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.')
 
@@ skipping 21 matching lines @@
       help='Whether there is alternative-locale-resource in direct deps')
 
   options, args = parser.parse_args(argv)
 
   if args:
     parser.error('No positional arguments should be given.')
 
   required_options_map = {
       'java_binary': ['build_config', 'jar_path'],
       'java_library': ['build_config', 'jar_path'],
+      'java_prebuilt': ['build_config', 'jar_path'],
       'android_assets': ['build_config'],
       '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)
 
   build_utils.CheckOptions(options, parser, required_options)
 
+  # Java prebuilts are the same as libraries except for in gradle files.
+  is_java_prebuilt = options.type == 'java_prebuilt'
+  if is_java_prebuilt:
+    options.type = 'java_library'
+
   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')
 
   direct_deps_config_paths = build_utils.ParseGypList(options.deps_configs)
   direct_deps_config_paths = _FilterUnwantedDepsPaths(direct_deps_config_paths,
@@ skipping 25 matching lines @@
   # overrides are done correctly.
   all_resources_deps.reverse()
 
   if options.type == 'android_apk' and options.tested_apk_config:
     tested_apk_deps = Deps([options.tested_apk_config])
     tested_apk_resources_deps = tested_apk_deps.All('android_resources')
     all_resources_deps = [
         d for d in all_resources_deps if not d in tested_apk_resources_deps]
 
   # Initialize some common config.
+  # Any value that needs to be queryable by dependents must go within deps_info.
   config = {
     'deps_info': {
       'name': os.path.basename(options.build_config),
       'path': options.build_config,
       'type': options.type,
       'deps_configs': direct_deps_config_paths
-    }
+    },
+    # Info needed only by generate_gradle.py.
+    'gradle': {}
   }
   deps_info = config['deps_info']
+  gradle = config['gradle']
+
+  # Required for generating gradle files.
+  if options.type == 'java_library':
+    deps_info['is_prebuilt'] = is_java_prebuilt
+
+  if options.android_manifest:
+    gradle['android_manifest'] = options.android_manifest
+  if options.type in ('java_binary', 'java_library', 'android_apk'):
+    if options.java_sources_file:
+      gradle['java_sources_file'] = options.java_sources_file
+    gradle['dependent_prebuilt_jars'] = deps.PrebuiltJarPaths()
+    gradle['dependent_projects'] = (
+        [c['path'] for c in direct_library_deps if not c['is_prebuilt']])
+
 
   if (options.type in ('java_binary', 'java_library') and
       not options.bypass_platform_checks):
     deps_info['requires_android'] = options.requires_android
     deps_info['supports_android'] = options.supports_android
 
     deps_require_android = (all_resources_deps +
         [d['name'] for d in all_library_deps if d['requires_android']])
     deps_not_support_android = (
         [d['name'] for d in all_library_deps if not d['supports_android']])
@@ skipping 13 matching lines @@
       deps_info['dex_path'] = options.dex_path
     if options.type == 'android_apk':
       deps_info['apk_path'] = options.apk_path
       deps_info['incremental_apk_path'] = options.incremental_apk_path
       deps_info['incremental_install_script_path'] = (
           options.incremental_install_script_path)
 
     # Classpath values filled in below (after applying tested_apk_config).
     config['javac'] = {}
 
+
   if options.type in ('java_binary', 'java_library'):
     # Only resources might have srcjars (normal srcjar targets are listed in
     # srcjar_deps). A resource's srcjar contains the R.java file for those
     # resources, and (like Android's default build system) we allow a library to
     # refer to the resources in any of its dependents.
     config['javac']['srcjars'] = [
         c['srcjar'] for c in all_resources_deps if 'srcjar' in c]
 
     # Used to strip out R.class for android_prebuilt()s.
     if options.type == 'java_library':
@@ skipping 162 matching lines @@
         _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:]))