Update from https://crrev.com/329939

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 61 matching lines @@
   if not path in dep_config_cache:
     dep_config_cache[path] = build_utils.ReadJson(path)['deps_info']
   return dep_config_cache[path]
 
 
 def DepsOfType(wanted_type, configs):
   return [c for c in configs if c['type'] == wanted_type]
 
 
 def GetAllDepsConfigsInOrder(deps_config_paths):
-  def Deps(path):
+  def GetDeps(path):
     return set(GetDepConfig(path)['deps_configs'])
-  return build_utils.GetSortedTransitiveDependencies(deps_config_paths, Deps)
+  return build_utils.GetSortedTransitiveDependencies(deps_config_paths, GetDeps)
+
+
+class Deps(object):
+  def __init__(self, direct_deps_config_paths):
+    self.all_deps_config_paths = GetAllDepsConfigsInOrder(
+        direct_deps_config_paths)
+    self.direct_deps_configs = [
+        GetDepConfig(p) for p in direct_deps_config_paths]
+    self.all_deps_configs = [
+        GetDepConfig(p) for p in self.all_deps_config_paths]
+
+  def All(self, wanted_type=None):
+    if type is None:
+      return self.all_deps_configs
+    return DepsOfType(wanted_type, self.all_deps_configs)
+
+  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 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.')
 
   # 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.')
@@ skipping 45 matching lines @@
       options.possible_deps_configs)
 
   allow_unknown_deps = options.type == 'android_apk'
   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]
-  all_deps_config_paths = GetAllDepsConfigsInOrder(direct_deps_config_paths)
 
-  direct_deps_configs = [GetDepConfig(p) for p in direct_deps_config_paths]
-  all_deps_configs = [GetDepConfig(p) for p in all_deps_config_paths]
+  deps = Deps(direct_deps_config_paths)
+  direct_library_deps = deps.Direct('java_library')
+  all_library_deps = deps.All('java_library')
 
-  direct_library_deps = DepsOfType('java_library', direct_deps_configs)
-  all_library_deps = DepsOfType('java_library', all_deps_configs)
-
-  direct_resources_deps = DepsOfType('android_resources', direct_deps_configs)
-  all_resources_deps = DepsOfType('android_resources', all_deps_configs)
+  direct_resources_deps = deps.Direct('android_resources')
+  all_resources_deps = deps.All('android_resources')
   # Resources should be ordered with the highest-level dependency first so that
   # 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.
   config = {
     'deps_info': {
       'name': os.path.basename(options.build_config),
       'path': options.build_config,
       'type': options.type,
       'deps_configs': direct_deps_config_paths,
     }
   }
   deps_info = config['deps_info']
@@ skipping 38 matching lines @@
         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_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.type == 'android_resources' or options.type == 'android_apk':
     config['resources'] = {}
     config['resources']['dependency_zips'] = [
         c['resources_zip'] for c in all_resources_deps]
     config['resources']['extra_package_names'] = []
+    config['resources']['extra_r_text_files'] = []
 
   if options.type == 'android_apk':
     config['resources']['extra_package_names'] = [
         c['package_name'] for c in all_resources_deps if 'package_name' in c]
+    config['resources']['extra_r_text_files'] = [
+        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]
 
   # An instrumentation test apk should exclude the dex files that are in the apk
   # under test.
   if options.type == 'android_apk' and options.tested_apk_config:
-    tested_apk_config_paths = GetAllDepsConfigsInOrder(
-        [options.tested_apk_config])
-    tested_apk_configs = [GetDepConfig(p) for p in tested_apk_config_paths]
-    tested_apk_library_deps = DepsOfType('java_library', tested_apk_configs)
+    tested_apk_deps = Deps([options.tested_apk_config])
+    tested_apk_library_deps = tested_apk_deps.All('java_library')
     tested_apk_deps_dex_files = [c['dex_path'] for c in tested_apk_library_deps]
     deps_dex_files = [
         p for p in deps_dex_files if not p in tested_apk_deps_dex_files]
 
     tested_apk_config = GetDepConfig(options.tested_apk_config)
     expected_tested_package = tested_apk_config['package_name']
     AndroidManifest(options.android_manifest).CheckInstrumentation(
         expected_tested_package)
 
   # Dependencies for the final dex file of an apk or a 'deps_dex'.
@@ skipping 36 matching lines @@
       config['native'] = {
         'libraries': library_paths,
         'java_libraries_list': java_libraries_list
       }
 
   build_utils.WriteJson(config, options.build_config, only_if_changed=True)
 
   if options.depfile:
     build_utils.WriteDepfile(
         options.depfile,
-        all_deps_config_paths + build_utils.GetPythonDependencies())
+        deps.AllConfigPaths() + build_utils.GetPythonDependencies())
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv[1:]))