Update MB for the new way to run 'analyze'.

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 755 matching lines @@
       env['GYP_CROSSCOMPILE'] = '1'
     return cmd, env
 
   def RunGNAnalyze(self, vals):
     # analyze runs before 'gn gen' now, so we need to run gn gen
     # in order to ensure that we have a build directory.
     ret = self.RunGNGen(vals)
     if ret:
       return ret
 
-    inp = self.ReadInputJSON(['files', 'targets'])
+    # TODO(dpranke): add 'test_targets' and 'additional_compile_targets'
+    # as required keys once the recipe has been converted over.
+    # See crbug.com/552146.
+    inp = self.ReadInputJSON(['files'])
     if self.args.verbose:
       self.Print()
       self.Print('analyze input:')
       self.PrintJSON(inp)
       self.Print()
 
+    use_new_logic = ('test_targets' in inp and
+                     'additional_compile_targets' in inp)
+    if use_new_logic:
+      # TODO(crbug.com/555273) - currently GN treats targets and
+      # additional_compile_targets identically since we can't tell the
+      # difference between a target that is a group in GN and one that isn't.
+      # We should eventually fix this and treat the two types differently.
+      targets = (set(inp['test_targets']) |
+                 set(inp['additional_compile_targets']))
+    else:
+      targets = set(inp['targets'])
+
     output_path = self.args.output_path[0]
 
     # Bail out early if a GN file was modified, since 'gn refs' won't know
-    # what to do about it.
-    if any(f.endswith('.gn') or f.endswith('.gni') for f in inp['files']):
-      self.WriteJSON({'status': 'Found dependency (all)'}, output_path)
-      return 0
-
-    # Bail out early if 'all' was asked for, since 'gn refs' won't recognize it.
-    if 'all' in inp['targets']:
-      self.WriteJSON({'status': 'Found dependency (all)'}, output_path)
+    # what to do about it. Also, bail out early if 'all' was asked for,
+    # since we can't deal with it yet.
+    if (any(f.endswith('.gn') or f.endswith('.gni') for f in inp['files']) or
+        'all' in targets):
+      if use_new_logic:
+        self.WriteJSON({
+              'status': 'Found dependency (all)',
+              'compile_targets': sorted(targets),
+              'test_targets': sorted(targets & set(inp['test_targets'])),
+            }, output_path)
+      else:
+        self.WriteJSON({'status': 'Found dependency (all)'}, output_path)
       return 0
 
     # This shouldn't normally happen, but could due to unusual race conditions,
     # like a try job that gets scheduled before a patch lands but runs after
     # the patch has landed.
     if not inp['files']:
       self.Print('Warning: No files modified in patch, bailing out early.')
-      self.WriteJSON({'targets': [],
-                      'build_targets': [],
-                      'status': 'No dependency'}, output_path)
+      if use_new_logic:
+        self.WriteJSON({
+              'status': 'No dependency',
+              'compile_targets': [],
+              'test_targets': [],
+            }, output_path)
+      else:
+        self.WriteJSON({
+              'status': 'No dependency',
+              'targets': [],
+              'build_targets': [],
+            }, output_path)
       return 0
 
     ret = 0
     response_file = self.TempFile()
     response_file.write('\n'.join(inp['files']) + '\n')
     response_file.close()
 
-    matching_targets = []
+    matching_targets = set()
     try:
       cmd = self.GNCmd('refs', self.args.path[0]) + [
           '@%s' % response_file.name, '--all', '--as=output']
       ret, out, _ = self.Run(cmd, force_verbose=False)
       if ret and not 'The input matches no targets' in out:
         self.WriteFailureAndRaise('gn refs returned %d: %s' % (ret, out),
                                   output_path)
       build_dir = self.ToSrcRelPath(self.args.path[0]) + self.sep
       for output in out.splitlines():
         build_output = output.replace(build_dir, '')
-        if build_output in inp['targets']:
-          matching_targets.append(build_output)
+        if build_output in targets:
+          matching_targets.add(build_output)
 
       cmd = self.GNCmd('refs', self.args.path[0]) + [
           '@%s' % response_file.name, '--all']
       ret, out, _ = self.Run(cmd, force_verbose=False)
       if ret and not 'The input matches no targets' in out:
         self.WriteFailureAndRaise('gn refs returned %d: %s' % (ret, out),
                                   output_path)
       for label in out.splitlines():
         build_target = label[2:]
         # We want to accept 'chrome/android:chrome_public_apk' and
         # just 'chrome_public_apk'. This may result in too many targets
         # getting built, but we can adjust that later if need be.
-        for input_target in inp['targets']:
+        for input_target in targets:
           if (input_target == build_target or
               build_target.endswith(':' + input_target)):
-            matching_targets.append(input_target)
+            matching_targets.add(input_target)
     finally:
       self.RemoveFile(response_file.name)
 
     if matching_targets:
-      # TODO: it could be that a target X might depend on a target Y
-      # and both would be listed in the input, but we would only need
-      # to specify target X as a build_target (whereas both X and Y are
-      # targets). I'm not sure if that optimization is generally worth it.
-      self.WriteJSON({'targets': sorted(set(matching_targets)),
-                      'build_targets': sorted(set(matching_targets)),
-                      'status': 'Found dependency'}, output_path)
+      if use_new_logic:
+        self.WriteJSON({
+              'status': 'Found dependency',
+              'compile_targets': sorted(matching_targets),
+              'test_targets': sorted(matching_targets &
+                                     set(inp['test_targets'])),
+            }, output_path)
+      else:
+        self.WriteJSON({
+            'status': 'Found dependency',
+            'targets': sorted(matching_targets),
+            'build_targets': sorted(matching_targets),
+        }, output_path)
     else:
-      self.WriteJSON({'targets': [],
-                      'build_targets': [],
-                      'status': 'No dependency'}, output_path)
+      if use_new_logic:
+        self.WriteJSON({
+            'status': 'No dependency',
+            'compile_targets': [],
+            'test_targets': [],
+        }, output_path)
+      else:
+        self.WriteJSON({
+            'status': 'No dependency',
+            'targets': [],
+            'build_targets': [],
+        }, output_path)
 
     if self.args.verbose:
       outp = json.loads(self.ReadFile(output_path))
       self.Print()
       self.Print('analyze output:')
       self.PrintJSON(outp)
       self.Print()
 
     return 0
 
@@ skipping 182 matching lines @@
 
 if __name__ == '__main__':
   try:
     sys.exit(main(sys.argv[1:]))
   except MBErr as e:
     print(e)
     sys.exit(1)
   except KeyboardInterrupt:
     print("interrupted, exiting", stream=sys.stderr)
     sys.exit(130)