Implement multi-phase build support in MB.

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 60 matching lines @@
       return 1
 
   def ParseArgs(self, argv):
     def AddCommonOptions(subp):
       subp.add_argument('-b', '--builder',
                         help='builder name to look up config from')
       subp.add_argument('-m', '--master',
                         help='master name to look up config from')
       subp.add_argument('-c', '--config',
                         help='configuration to analyze')
+      subp.add_argument('--phase', type=int,
+                        help=('build phase for a given build '
+                              '(int in [1, 2, ...))'))
       subp.add_argument('-f', '--config-file', metavar='PATH',
                         default=self.default_config,
                         help='path to config file '
                             '(default is //tools/mb/mb_config.pyl)')
       subp.add_argument('-g', '--goma-dir',
                         help='path to goma directory')
       subp.add_argument('--gyp-script', metavar='PATH',
                         default=self.PathJoin('build', 'gyp_chromium'),
                         help='path to gyp script relative to project root '
                              '(default is %(default)s)')
@@ skipping 230 matching lines @@
   def CmdValidate(self, print_ok=True):
     errs = []
 
     # Read the file to make sure it parses.
     self.ReadConfigFile()
 
     # Build a list of all of the configs referenced by builders.
     all_configs = {}
     for master in self.masters:
       for config in self.masters[master].values():
-        all_configs[config] = master
+        if isinstance(config, list):
+          for c in config:
+            all_configs[c] = master
+        else:
+          all_configs[config] = master
 
     # Check that every referenced args file or config actually exists.
     for config, loc in all_configs.items():
       if config.startswith('//'):
         if not self.Exists(self.ToAbsPath(config)):
           errs.append('Unknown args file "%s" referenced from "%s".' %
                       (config, loc))
       elif not config in self.configs:
         errs.append('Unknown config "%s" referenced from "%s".' %
                     (config, loc))
@@ skipping 126 matching lines @@
       config_only = config_builders - master_builders
       tbd = set()
       gyp = set()
       done = set()
       notes = {builder: '' for builder in config_builders | master_builders}
 
       for builder in both:
         config = self.masters[master][builder]
         if config == 'tbd':
           tbd.add(builder)
+        elif isinstance(config, list):
+          vals = self.FlattenConfig(config[0])
+          if vals['type'] == 'gyp':
+            gyp.add(builder)
+          else:
+            done.add(builder)
         elif config.startswith('//'):
           done.add(builder)
         else:
-          # TODO(dpranke): Check if MB is actually running?
           vals = self.FlattenConfig(config)
           if vals['type'] == 'gyp':
             gyp.add(builder)
           else:
             done.add(builder)
 
       if self.args.check_compile and (tbd or master_only):
         either = tbd | master_only
         for builder in either:
           notes[builder] = ' (' + self.CheckCompile(master, builder) +')'
@@ skipping 23 matching lines @@
 
     vals = {}
     if self.args.builder or self.args.master or self.args.config:
       vals = self.Lookup()
       if vals['type'] == 'gn':
         # Re-run gn gen in order to ensure the config is consistent with the
         # build dir.
         self.RunGNGen(vals)
       return vals
 
-    # TODO: We can only get the config for GN build dirs, not GYP build dirs.
-    # GN stores the args that were used in args.gn in the build dir,
-    # but GYP doesn't store them anywhere. We should consider modifying
-    # gyp_chromium to record the arguments it runs with in a similar
-    # manner.
-
     mb_type_path = self.PathJoin(self.ToAbsPath(build_dir), 'mb_type')
     if not self.Exists(mb_type_path):
       toolchain_path = self.PathJoin(self.ToAbsPath(build_dir),
                                      'toolchain.ninja')
       if not self.Exists(toolchain_path):
         self.Print('Must either specify a path to an existing GN build dir '
                    'or pass in a -m/-b pair or a -c flag to specify the '
                    'configuration')
         return {}
       else:
@@ skipping 108 matching lines @@
                   '(-m/--master and -b/--builder)')
 
     if not self.args.master in self.masters:
       raise MBErr('Master name "%s" not found in "%s"' %
                   (self.args.master, self.args.config_file))
 
     if not self.args.builder in self.masters[self.args.master]:
       raise MBErr('Builder name "%s"  not found under masters[%s] in "%s"' %
                   (self.args.builder, self.args.master, self.args.config_file))
 
-    return self.masters[self.args.master][self.args.builder]
+    config = self.masters[self.args.master][self.args.builder]
+    if isinstance(config, list):
+      if self.args.phase is None:
+        raise MBErr('Must specify a build --phase for %s on %s' %
+                    (self.args.builder, self.args.master))
+      phase = int(self.args.phase)
+      if phase < 1 or phase > len(config):
+        raise MBErr('Phase %d out of bounds for %s on %s' %
+                    (phase, self.args.builder, self.args.master))
+      return config[phase-1]
+
+    if self.args.phase is not None:
+      raise MBErr('Must not specify a build --phase for %s on %s' %
+                  (self.args.builder, self.args.master))
+    return config
 
   def FlattenConfig(self, config):
     mixins = self.configs[config]
-    # TODO(dpranke): We really should provide a constructor for the
-    # default set of values.
     vals = {
       'args_file': '',
       'cros_passthrough': False,
       'gn_args': [],
       'gyp_defines': '',
       'gyp_crosscompile': False,
       'type': None,
     }
 
     visited = []
     self.FlattenMixins(mixins, vals, visited)
     return vals
 
   def FlattenMixins(self, mixins, vals, visited):
     for m in mixins:
       if m not in self.mixins:
         raise MBErr('Unknown mixin "%s"' % m)
 
-      # TODO: check for cycles in mixins.
-
       visited.append(m)
 
       mixin_vals = self.mixins[m]
 
       if 'cros_passthrough' in mixin_vals:
         vals['cros_passthrough'] = mixin_vals['cros_passthrough']
       if 'gn_args' in mixin_vals:
         if vals['gn_args']:
           vals['gn_args'] += ' ' + mixin_vals['gn_args']
         else:
@@ skipping 274 matching lines @@
       self.PrintJSON(outp)
       self.Print()
 
     return ret
 
   def GetIsolateCommand(self, target, vals, gn_isolate_map):
     android = 'target_os="android"' in vals['gn_args']
 
     # This needs to mirror the settings in //build/config/ui.gni:
     # use_x11 = is_linux && !use_ozone.
-    # TODO(dpranke): Figure out how to keep this in sync better.
     use_x11 = (self.platform == 'linux2' and
                not android and
                not 'use_ozone=true' in vals['gn_args'])
 
     asan = 'is_asan=true' in vals['gn_args']
     msan = 'is_msan=true' in vals['gn_args']
     tsan = 'is_tsan=true' in vals['gn_args']
 
     target_name = self.GNTargetName(target)
     test_type = gn_isolate_map[target_name]['type']
@@ skipping 496 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:]))