Roll //build, //native_client, and a few more targets of opportunity.

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 11 matching lines @@
   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 optparse
 import os
 import sys
+import xml.dom.minidom
 
 from util import build_utils
 
 import write_ordered_libraries
 
+class AndroidManifest(object):
+  def __init__(self, path):
+    self.path = path
+    dom = xml.dom.minidom.parse(path)
+    manifests = dom.getElementsByTagName('manifest')
+    assert len(manifests) == 1
+    self.manifest = manifests[0]
+
+  def GetInstrumentation(self):
+    instrumentation_els = self.manifest.getElementsByTagName('instrumentation')
+    if len(instrumentation_els) == 0:
+      return None
+    if len(instrumentation_els) != 1:
+      raise Exception(
+          'More than one <instrumentation> element found in %s' % self.path)
+    return instrumentation_els[0]
+
+  def CheckInstrumentation(self, expected_package):
+    instr = self.GetInstrumentation()
+    if not instr:
+      raise Exception('No <instrumentation> elements found in %s' % self.path)
+    instrumented_package = instr.getAttributeNS(
+        'http://schemas.android.com/apk/res/android', 'targetPackage')
+    if instrumented_package != expected_package:
+      raise Exception(
+          'Wrong instrumented package. Expected %s, got %s'
+          % (expected_package, instrumented_package))
+
+  def GetPackageName(self):
+    return self.manifest.getAttribute('package')
+
 
 dep_config_cache = {}
 def GetDepConfig(path):
   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]
@@ skipping 34 matching lines @@
   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']:
     raise Exception('Unknown type: <%s>' % options.type)
 
@@ skipping 46 matching lines @@
   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']
 
-
   if options.type == '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']])
 
     if deps_require_android and not options.requires_android:
       raise Exception('Some deps require building for the Android platform: ' +
           str(deps_require_android))
 
     if deps_not_support_android and options.supports_android:
       raise Exception('Not all deps support the Android platform: ' +
           str(deps_not_support_android))
 
-
   if options.type in ['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]
     deps_info['resources_deps'] = [c['path'] for c in all_resources_deps]
     deps_info['jar_path'] = options.jar_path
     if options.type == 'android_apk' or options.supports_android:
       deps_info['dex_path'] = options.dex_path
     config['javac'] = {
       'classpath': javac_classpath,
     }
@@ skipping 23 matching lines @@
   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'] = []
 
   if options.type == 'android_apk':
     config['resources']['extra_package_names'] = [
         c['package_name'] for c in all_resources_deps if 'package_name' 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_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'.
   if options.type in ['android_apk', 'deps_dex']:
     config['final_dex'] = {}
     dex_config = config['final_dex']
     # TODO(cjhopman): proguard version
-    dex_deps_files = [c['dex_path'] for c in all_library_deps]
-    dex_config['dependency_dex_files'] = dex_deps_files
+    dex_config['dependency_dex_files'] = deps_dex_files
 
   if options.type == 'android_apk':
     config['dist_jar'] = {
       'dependency_jars': [
         c['jar_path'] for c in all_library_deps
       ]
     }
+    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 = []
     if options.native_libs:
       libraries = build_utils.ParseGypList(options.native_libs)
       if libraries:
         libraries_dir = os.path.dirname(libraries[0])
         write_ordered_libraries.SetReadelfPath(options.readelf_path)
         write_ordered_libraries.SetLibraryDirs([libraries_dir])
         all_native_library_deps = (
@@ skipping 14 matching lines @@
   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())
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv[1:]))