👔 Make instrumentation tests declare their runtime_deps

tools/mb/mb.py

 #!/usr/bin/env python
 # Copyright 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.
 
 """MB - the Meta-Build wrapper around GYP and GN
 
 MB is a wrapper script for GYP and GN that can be used to generate build files
 for sets of canned configurations and analyze them.
 """
@@ skipping 244 matching lines @@
       self.ParseArgs([self.args.subcommand, '--help'])
     else:
       self.ParseArgs(['--help'])
 
   def CmdIsolate(self):
     vals = self.GetConfig()
     if not vals:
       return 1
 
     if vals['type'] == 'gn':
-      return self.RunGNIsolate(vals)
+      gn_isolate_map = self.ReadGnIsolateMap()
+      return self.RunGNIsolate(vals, gn_isolate_map)
     else:
       return self.Build('%s_run' % self.args.target[0])
 
   def CmdLookup(self):
     vals = self.Lookup()
     if vals['type'] == 'gn':
       cmd = self.GNCmd('gen', '_path_')
       gn_args = self.GNArgs(vals)
       self.Print('\nWriting """\\\n%s""" to _path_/args.gn.\n' % gn_args)
       env = None
     else:
       cmd, env = self.GYPCmd('_path_', vals)
 
     self.PrintCmd(cmd, env)
     return 0
 
   def CmdRun(self):
     vals = self.GetConfig()
     if not vals:
       return 1
 
     build_dir = self.args.path[0]
     target = self.args.target[0]
 
     if vals['type'] == 'gn':
+      gn_isolate_map = self.ReadGnIsolateMap()
+      build_target = target
+      if gn_isolate_map[target]['type'] == 'android_instrumentation':
+        build_target = target + '_apk'

[jbudorick, 2016/04/28 03:11:57]

:(

       if self.args.build:
-        ret = self.Build(target)
+        ret = self.Build(build_target)
         if ret:
           return ret
-      ret = self.RunGNIsolate(vals)
+      ret = self.RunGNIsolate(vals, gn_isolate_map)
       if ret:
         return ret
     else:
       ret = self.Build('%s_run' % target)
       if ret:
         return ret
 
     cmd = [
         self.executable,
         self.PathJoin('tools', 'swarming_client', 'isolate.py'),
@@ skipping 441 matching lines @@
       # We need GN to generate the list of runtime dependencies for
       # the compile targets listed (one per line) in the file so
       # we can run them via swarming. We use ninja_to_gn.pyl to convert
       # the compile targets to the matching GN labels.
       path = self.args.swarming_targets_file
       if not self.Exists(path):
         self.WriteFailureAndRaise('"%s" does not exist' % path,
                                   output_path=None)
       contents = self.ReadFile(path)
       swarming_targets = set(contents.splitlines())
-      gn_isolate_map = ast.literal_eval(self.ReadFile(self.PathJoin(
-          self.chromium_src_dir, 'testing', 'buildbot', 'gn_isolate_map.pyl')))
+      gn_isolate_map = self.ReadGnIsolateMap()
       gn_labels = []
       err = ''
       for target in swarming_targets:
         target_name = self.GNTargetName(target)
         if not target_name in gn_isolate_map:
           err += ('test target "%s" not found\n' % target_name)
         elif gn_isolate_map[target_name]['type'] == 'unknown':
           err += ('test target "%s" type is unknown\n' % target_name)
         else:
           gn_labels.append(gn_isolate_map[target_name]['label'])
@@ skipping 52 matching lines @@
       command, extra_files = self.GetIsolateCommand(target, vals,
                                                     gn_isolate_map)
 
       runtime_deps = self.ReadFile(runtime_deps_path).splitlines()
 
       self.WriteIsolateFiles(build_dir, command, target, runtime_deps,
                              extra_files)
 
     return 0
 
-  def RunGNIsolate(self, vals):
-    gn_isolate_map = ast.literal_eval(self.ReadFile(self.PathJoin(
+  def ReadGnIsolateMap(self):
+    return ast.literal_eval(self.ReadFile(self.PathJoin(
         self.chromium_src_dir, 'testing', 'buildbot', 'gn_isolate_map.pyl')))
 
+  def RunGNIsolate(self, vals, gn_isolate_map):
     build_dir = self.args.path[0]
     target = self.args.target[0]
     target_name = self.GNTargetName(target)
     command, extra_files = self.GetIsolateCommand(target, vals, gn_isolate_map)
 
     label = gn_isolate_map[target_name]['label']
     cmd = self.GNCmd('desc', build_dir, label, 'runtime_deps')
     ret, out, _ = self.Call(cmd)
     if ret:
       if out:
@@ skipping 138 matching lines @@
     executable = gn_isolate_map[target_name].get('executable', target_name)
     executable_suffix = '.exe' if self.platform == 'win32' else ''
 
     cmdline = []
     extra_files = []
 
     if android:
       # TODO(jbudorick): This won't work with instrumentation test targets.
       # Revisit this logic when those are added to gn_isolate_map.pyl.
       cmdline = [self.PathJoin('bin', 'run_%s' % target_name)]
+      if gn_isolate_map[target]['type'] == 'android_instrumentation':
+        cmdline[0] += '_apk'
     elif use_x11 and test_type == 'windowed_test_launcher':
       extra_files = [
           'xdisplaycheck',
           '../../testing/test_env.py',
           '../../testing/xvfb.py',
       ]
       cmdline = [
         '../../testing/xvfb.py',
         '.',
         './' + str(executable) + executable_suffix,
@@ skipping 460 matching lines @@
   # Then check to see if the arg contains any metacharacters other than
   # double quotes; if it does, quote everything (including the double
   # quotes) for safety.
   if any(a in UNSAFE_FOR_CMD for a in arg):
     arg = ''.join('^' + a if a in ALL_META_CHARS else a for a in arg)
   return arg
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv[1:]))