Use gn_helpers to [se]serialize GN lists.

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 272 matching lines @@
   parser.add_option('--has-alternative-locale-resource', action='store_true',
       help='Whether there is alternative-locale-resource in direct deps')
   parser.add_option('--fail',
       help='GYP-list of error message lines to fail with.')
 
   options, args = parser.parse_args(argv)
 
   if args:
     parser.error('No positional arguments should be given.')
   if options.fail:
-    parser.error('\n'.join(build_utils.ParseGypList(options.fail)))
+    parser.error('\n'.join(build_utils.ParseGnList(options.fail)))
 
   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'],
@@ skipping 11 matching lines @@
     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 = build_utils.ParseGnList(options.deps_configs)
   direct_deps_config_paths = _FilterDepsPaths(direct_deps_config_paths,
                                               options.type)
 
   deps = Deps(direct_deps_config_paths)
   all_inputs = deps.AllConfigPaths() + build_utils.GetPythonDependencies()
 
   # Remove other locale resources if there is alternative_locale_resource in
   # direct deps.
   if options.has_alternative_locale_resource:
     alternative = [r['path'] for r in deps.Direct('android_resources')
@@ skipping 41 matching lines @@
   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
     if options.bundled_srcjars:
       gradle['bundled_srcjars'] = (
-          build_utils.ParseGypList(options.bundled_srcjars))
+          build_utils.ParseGnList(options.bundled_srcjars))
 
     gradle['dependent_prebuilt_jars'] = deps.PrebuiltJarPaths()
 
     gradle['dependent_android_projects'] = []
     gradle['dependent_java_projects'] = []
     for c in direct_library_deps:
       if not c['is_prebuilt']:
         if c['requires_android']:
           gradle['dependent_android_projects'].append(c['path'])
         else:
@@ skipping 46 matching lines @@
           c['package_name'] for c in all_resources_deps if 'package_name' 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))
+          build_utils.ParseGnList(options.asset_renaming_sources))
     if options.asset_sources:
-      all_asset_sources.extend(build_utils.ParseGypList(options.asset_sources))
+      all_asset_sources.extend(build_utils.ParseGnList(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))
+          build_utils.ParseGnList(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:
       deps_info['r_text'] = options.r_text
     if options.is_locale_resource:
       deps_info['is_locale_resource'] = True
 
     deps_info['resources_dirs'] = []
     if options.resource_dirs:
       for gyp_list in options.resource_dirs:
-        deps_info['resources_dirs'].extend(build_utils.ParseGypList(gyp_list))
+        deps_info['resources_dirs'].extend(build_utils.ParseGnList(gyp_list))
 
   if options.supports_android and options.type in ('android_apk',
                                                    'java_library'):
     # Lint all resources that are not already linted by a dependent library.
     owned_resource_dirs = set()
     owned_resource_zips = set()
     for c in all_resources_deps:
       # Always use resources_dirs in favour of resources_zips so that lint error
       # messages have paths that are closer to reality (and to avoid needing to
       # extract during lint).
@@ skipping 23 matching lines @@
         c['r_text'] for c in all_resources_deps if 'r_text' in c]
 
   if options.type in ['android_apk', 'deps_dex']:
     deps_dex_files = [c['dex_path'] for c in all_library_deps]
 
   if options.type in ('java_binary', 'java_library', 'android_apk'):
     javac_classpath = [c['jar_path'] for c in direct_library_deps]
     java_full_classpath = [c['jar_path'] for c in all_library_deps]
 
     if options.extra_classpath_jars:
-      extra_jars = build_utils.ParseGypList(options.extra_classpath_jars)
+      extra_jars = build_utils.ParseGnList(options.extra_classpath_jars)
       deps_info['extra_classpath_jars'] = extra_jars
       javac_classpath += extra_jars
 
   # The java code for an instrumentation test apk is assembled differently for
   # ProGuard vs. non-ProGuard.
   #
   # Without ProGuard: Each library's jar is dexed separately and then combined
   # into a single classes.dex. A test apk will include all dex files not already
   # present in the apk-under-test. At runtime all test code lives in the test
   # apk, and the program code lives in the apk-under-test.
@@ skipping 69 matching lines @@
       '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 = None
-    runtime_deps_files = build_utils.ParseGypList(
+    runtime_deps_files = build_utils.ParseGnList(
         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]))
 
     all_inputs.extend(runtime_deps_files)
     config['native'] = {
       'libraries': library_paths,
       '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:]))