GN: asset_location -> android_assets() for mojo_runner

build/android/gyp/apkbuilder.py

 #!/usr/bin/env python
 #
 # Copyright (c) 2015 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.
 
 """Adds the code parts to a resource APK."""
 
 import argparse
 import itertools
@@ skipping 67 matching lines @@
   """Returns (src, dest) given an asset path in the form src[:dest]."""
   path_parts = path.split(':')
   src_path = path_parts[0]
   if len(path_parts) > 1:
     dest_path = path_parts[1]
   else:
     dest_path = os.path.basename(src_path)
   return src_path, dest_path
 
 
-def _AddAssets(apk, paths, disable_compression=False):
+def _ExpandPaths(paths):
+  """Converts src:dst into tuples and enumerates files within directories.
+
+  Args:
+    paths: Paths in the form "src_path:dest_path"
+
+  Returns:
+    A list of (src_path, dest_path) tuples sorted by dest_path (for stable
+    ordering within output .apk).
+  """
+  ret = []
+  for path in paths:
+    src_path, dest_path = _SplitAssetPath(path)
+    if os.path.isdir(src_path):
+      for f in build_utils.FindInDirectory(src_path, '*'):
+        ret.append((f, os.path.join(dest_path, f[len(src_path) + 1:])))
+    else:
+      ret.append((src_path, dest_path))
+  ret.sort(key=lambda t:t[1])
+  return ret
+
+
+def _AddAssets(apk, path_tuples, disable_compression=False):
   """Adds the given paths to the apk.
 
   Args:
     apk: ZipFile to write to.
     paths: List of paths (with optional :zipPath suffix) to add.
     disable_compression: Whether to disable compression.
   """
   # Group all uncompressed assets together in the hope that it will increase
   # locality of mmap'ed files.
   for target_compress in (False, True):
-    for path in paths:
-      src_path, dest_path = _SplitAssetPath(path)
+    for src_path, dest_path in path_tuples:
 
       compress = not disable_compression and (
           os.path.splitext(src_path)[1] not in _NO_COMPRESS_EXTENSIONS)
       if target_compress == compress:
         apk_path = 'assets/' + dest_path
         try:
           apk.getinfo(apk_path)
           # Should never happen since write_build_config.py handles merging.
           raise Exception('Multiple targets specified the asset path: %s' %
                           apk_path)
         except KeyError:
           build_utils.AddToZipHermetic(apk, apk_path, src_path=src_path,
                                        compress=compress)
 
 
-def _CreateAssetsList(paths):
+def _CreateAssetsList(path_tuples):
   """Returns a newline-separated list of asset paths for the given paths."""
-  return '\n'.join(_SplitAssetPath(p)[1] for p in sorted(paths)) + '\n'
+  dests = sorted(t[1] for t in path_tuples)
+  return '\n'.join(dests) + '\n'
 
 
 def main(args):
   args = build_utils.ExpandFileArgs(args)
   options = _ParseArgs(args)
 
   native_libs = sorted(options.native_libs)
 
   input_paths = [options.resource_apk, __file__] + native_libs
   if options.dex_file:
     input_paths.append(options.dex_file)
 
   if options.emma_device_jar:
     input_paths.append(options.emma_device_jar)
 
   input_strings = [options.android_abi, options.native_lib_placeholders]
 
-  for path in itertools.chain(options.assets, options.uncompressed_assets):
-    src_path, dest_path = _SplitAssetPath(path)
+  _assets = _ExpandPaths(options.assets)
+  _uncompressed_assets = _ExpandPaths(options.uncompressed_assets)
+
+  for src_path, dest_path in itertools.chain(_assets, _uncompressed_assets):
     input_paths.append(src_path)
     input_strings.append(dest_path)
 
   def on_stale_md5():
     tmp_apk = options.output_apk + '.tmp'
     try:
       # TODO(agrieve): It would be more efficient to combine this step
       # with finalize_apk(), which sometimes aligns and uncompresses the
       # native libraries.
       with zipfile.ZipFile(options.resource_apk) as resource_apk, \
            zipfile.ZipFile(tmp_apk, 'w', zipfile.ZIP_DEFLATED) as out_apk:
         def copy_resource(zipinfo):
           compress = zipinfo.compress_type != zipfile.ZIP_STORED
           build_utils.AddToZipHermetic(out_apk, zipinfo.filename,
                                        data=resource_apk.read(zipinfo.filename),
                                        compress=compress)
 
         # Make assets come before resources in order to maintain the same file
         # ordering as GYP / aapt. http://crbug.com/561862
         resource_infos = resource_apk.infolist()
 
         # 1. AndroidManifest.xml
         assert resource_infos[0].filename == 'AndroidManifest.xml'
         copy_resource(resource_infos[0])
 
         # 2. Assets
         if options.write_asset_list:
           data = _CreateAssetsList(
-              itertools.chain(options.assets, options.uncompressed_assets))
+              itertools.chain(_assets, _uncompressed_assets))
           build_utils.AddToZipHermetic(out_apk, 'assets/assets_list', data=data)
 
-        _AddAssets(out_apk, options.assets, disable_compression=False)
-        _AddAssets(out_apk, options.uncompressed_assets,
-                   disable_compression=True)
+        _AddAssets(out_apk, _assets, disable_compression=False)
+        _AddAssets(out_apk, _uncompressed_assets, disable_compression=True)
 
         # 3. Resources
         for info in resource_infos[1:]:
           copy_resource(info)
 
         # 4. Dex files
         if options.dex_file and options.dex_file.endswith('.zip'):
           with zipfile.ZipFile(options.dex_file, 'r') as dex_zip:
             for dex in (d for d in dex_zip.namelist() if d.endswith('.dex')):
               build_utils.AddToZipHermetic(out_apk, dex, data=dex_zip.read(dex))
@@ skipping 40 matching lines @@
   build_utils.CallAndWriteDepfileIfStale(
       on_stale_md5,
       options,
       input_paths=input_paths,
       input_strings=input_strings,
       output_paths=[options.output_apk])
 
 
 if __name__ == '__main__':
   main(sys.argv[1:])