Add GN template for android_assets(). Use it in content_shell_apk.

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
 things like: the javac classpath, the list of android resources dependencies,
 etc. It also includes the information needed to create the build_config for
 other targets that depend on that one.
 
 Android build scripts should not refer to the build_config directly, and the
 build specification should instead pass information in using the special
 file-arg syntax (see build_utils.py:ExpandFileArgs). That syntax allows passing
 of values in a json dict in a file and looks like this:
   --python-arg=@FileArg(build_config_path:javac:classpath)
 
 Note: If paths to input files are passed in this way, it is important that:
   1. inputs/deps of the action ensure that the files are available the first
   time the action runs.
   2. Either (a) or (b)
     a. inputs/deps ensure that the action runs whenever one of the files changes
     b. the files are added to the action's depfile
 """
 
+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
 
@@ skipping 62 matching lines @@
 
   def Direct(self, wanted_type=None):
     if wanted_type is None:
       return self.direct_deps_configs
     return DepsOfType(wanted_type, self.direct_deps_configs)
 
   def AllConfigPaths(self):
     return self.all_deps_config_paths
 
 
+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 = {}
+  uncompressed = {}
+  for asset_dep in all_assets:
+    entry = asset_dep['assets']
+    disable_compression = entry.get('disable_compression', False)
+    dest_map = uncompressed if disable_compression else compressed
+    other_map = compressed if disable_compression else uncompressed
+    outputs = entry.get('outputs', [])
+    for src, dest in itertools.izip_longest(entry['sources'], outputs):
+      if not dest:
+        dest = os.path.basename(src)
+      # Merge so that each path shows up in only one of the lists, and that
+      # deps of the same target override previous ones.
+      other_map.pop(dest, 0)
+      dest_map[dest] = src
+
+  def create_list(asset_map):
+    ret = ['%s:%s' % (src, dest) for dest, src in asset_map.iteritems()]
+    # Sort to ensure deterministic ordering.
+    ret.sort()
+    return ret
+
+  return create_list(compressed), create_list(uncompressed)
+
+
 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 '
       'dependencies may not write build_config files. Missing build_config '
       'files are handled differently based on the type of this target.')
 
   # android_resources options
   parser.add_option('--srcjar', help='Path to target\'s resources srcjar.')
   parser.add_option('--resources-zip', help='Path to target\'s resources zip.')
   parser.add_option('--r-text', help='Path to target\'s R.txt file.')
   parser.add_option('--package-name',
       help='Java package name for these resources.')
   parser.add_option('--android-manifest', help='Path to android manifest.')
 
+  # android_assets options
+  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('--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.')
 
   # 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('--tested-apk-config',
       help='Path to the build config of the tested apk (for an instrumentation '
       'test apk).')
 
   options, args = parser.parse_args(argv)
 
   if args:
     parser.error('No positional arguments should be given.')
 
-
-  if not options.type in [
-      'java_library', 'android_resources', 'android_apk', 'deps_dex']:
+  required_options_map = {
+      'java_library': ['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']
+  }
+  required_options = required_options_map.get(options.type)
+  if not required_options:
     raise Exception('Unknown type: <%s>' % options.type)
 
-  required_options = ['build_config'] + {
-      'java_library': ['jar_path'],
-      'android_resources': ['resources_zip'],
-      'android_apk': ['jar_path', 'dex_path', 'resources_zip'],
-      'deps_dex': ['dex_path']
-    }[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')
 
   possible_deps_config_paths = build_utils.ParseGypList(
       options.possible_deps_configs)
 
-  allow_unknown_deps = (options.type == 'android_apk' or
-                        options.type == 'android_resources')
+  allow_unknown_deps = (options.type in
+                        ('android_apk', 'android_assets', 'android_resources'))
   unknown_deps = [
       c for c in possible_deps_config_paths if not os.path.exists(c)]
   if unknown_deps and not allow_unknown_deps:
     raise Exception('Unknown deps: ' + str(unknown_deps))
 
   direct_deps_config_paths = [
       c for c in possible_deps_config_paths if not c in unknown_deps]
 
   deps = Deps(direct_deps_config_paths)
   direct_library_deps = deps.Direct('java_library')
@@ skipping 58 matching lines @@
     # 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 direct_resources_deps if 'srcjar' in c]
 
   if options.type == 'android_apk':
     # Apks will get their resources srcjar explicitly passed to the java step.
     config['javac']['srcjars'] = []
 
+  if options.type == 'android_assets':
+    all_asset_sources = []
+    if options.asset_renaming_sources:
+      all_asset_sources.extend(
+          build_utils.ParseGypList(options.asset_renaming_sources))
+    if options.asset_sources:
+      all_asset_sources.extend(build_utils.ParseGypList(options.asset_sources))
+
+    deps_info['assets'] = {
+        'sources': all_asset_sources
+    }
+    if options.asset_renaming_destinations:
+      deps_info['assets']['outputs'] = (
+          build_utils.ParseGypList(options.asset_renaming_destinations))
+    if options.disable_asset_compression:
+      deps_info['assets']['disable_compression'] = True
+
   if options.type == 'android_resources':
     deps_info['resources_zip'] = options.resources_zip
     if options.srcjar:
       deps_info['srcjar'] = options.srcjar
     if options.android_manifest:
       manifest = AndroidManifest(options.android_manifest)
       deps_info['package_name'] = manifest.GetPackageName()
     if options.package_name:
       deps_info['package_name'] = options.package_name
     if options.r_text:
@@ skipping 76 matching lines @@
       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'])
 
     config['native'] = {
       'libraries': library_paths,
       'java_libraries_list': java_libraries_list_holder[0],
     }
+    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,
         deps.AllConfigPaths() + build_utils.GetPythonDependencies())
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv[1:]))