Add support for cros chrome_sdk (simplechrome) to 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 551 matching lines @@
 
   def Lookup(self):
     vals = self.ReadBotConfig()
     if not vals:
       self.ReadConfigFile()
       config = self.ConfigFromArgs()
       if config.startswith('//'):
         if not self.Exists(self.ToAbsPath(config)):
           raise MBErr('args file "%s" not found' % config)
         vals = {
+          'args_file': config,
+          'cros_passthrough': False,
+          'gn_args': '',
+          'gyp_crosscompile': False,
+          'gyp_defines': '',
           'type': 'gn',
-          'args_file': config,
-          'gn_args': '',
         }
       else:
         if not config in self.configs:
           raise MBErr('Config "%s" not found in %s' %
                       (config, self.args.config_file))
         vals = self.FlattenConfig(config)
 
     # Do some basic sanity checking on the config so that we
     # don't have to do this in every caller.
     assert 'type' in vals, 'No meta-build type specified in the config'
@@ skipping 12 matching lines @@
 
     contents = json.loads(self.ReadFile(path))
     gyp_vals = contents.get('GYP_DEFINES', {})
     if isinstance(gyp_vals, dict):
       gyp_defines = ' '.join('%s=%s' % (k, v) for k, v in gyp_vals.items())
     else:
       gyp_defines = ' '.join(gyp_vals)
     gn_args = ' '.join(contents.get('gn_args', []))
 
     return {
+        'args_file': '',
+        'cros_passthrough': False,
+        'gn_args': gn_args,
+        'gyp_crosscompile': False,
+        'gyp_defines': gyp_defines,
         'type': contents.get('mb_type', ''),
-        'gn_args': gn_args,
-        'gyp_defines': gyp_defines,
-        'gyp_crosscompile': False,
     }
 
   def ReadConfigFile(self):
     if not self.Exists(self.args.config_file):
       raise MBErr('config file not found at %s' % self.args.config_file)
 
     try:
       contents = ast.literal_eval(self.ReadFile(self.args.config_file))
     except SyntaxError as e:
       raise MBErr('Failed to parse config file "%s": %s' %
@@ skipping 20 matching lines @@
                   (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]
 
   def FlattenConfig(self, config):
     mixins = self.configs[config]
+    # TODO(dpranke): We really should provide a constructor for the
+    # default set of values.
     vals = {
-      'type': None,
+      '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 'type' in mixin_vals:
-        vals['type'] = mixin_vals['type']
+
+      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:
           vals['gn_args'] = mixin_vals['gn_args']
       if 'gyp_crosscompile' in mixin_vals:
         vals['gyp_crosscompile'] = mixin_vals['gyp_crosscompile']
       if 'gyp_defines' in mixin_vals:
         if vals['gyp_defines']:
           vals['gyp_defines'] += ' ' + mixin_vals['gyp_defines']
         else:
           vals['gyp_defines'] = mixin_vals['gyp_defines']
+      if 'type' in mixin_vals:
+        vals['type'] = mixin_vals['type']
+
       if 'mixins' in mixin_vals:
         self.FlattenMixins(mixin_vals['mixins'], vals, visited)
     return vals
 
   def ClobberIfNeeded(self, vals):
     path = self.args.path[0]
     build_dir = self.ToAbsPath(path)
     mb_type_path = self.PathJoin(build_dir, 'mb_type')
     needs_clobber = False
     new_mb_type = vals['type']
@@ skipping 184 matching lines @@
     elif self.platform == 'darwin':
       subdir, exe = 'mac', 'gn'
     else:
       subdir, exe = 'win', 'gn.exe'
 
     gn_path = self.PathJoin(self.chromium_src_dir, 'buildtools', subdir, exe)
 
     return [gn_path, subcommand, path] + list(args)
 
   def GNArgs(self, vals):
-    gn_args = vals['gn_args']
+    if vals['cros_passthrough']:
+      if not 'GN_ARGS' in os.environ:
+        raise MBErr('MB is expecting GN_ARGS to be in the environment')
+      gn_args = os.environ['GN_ARGS']
+      if not 'target_os="chromeos"' in gn_args:
+        raise MBErr('GN_ARGS is missing target_os="chromeos": (GN_ARGS=%s)' %
+                    gn_args)
+    else:
+      gn_args = vals['gn_args']
+
     if self.args.goma_dir:
       gn_args += ' goma_dir="%s"' % self.args.goma_dir
 
     android_version_code = self.args.android_version_code
     if android_version_code:
       gn_args += ' android_default_version_code="%s"' % android_version_code
 
     android_version_name = self.args.android_version_name
     if android_version_name:
       gn_args += ' android_default_version_name="%s"' % android_version_name
@@ skipping 141 matching lines @@
     if path.startswith('//'):
       return path[2:].replace('/', self.sep)
     return self.RelPath(path, self.chromium_src_dir)
 
   def ParseGYPConfigPath(self, path):
     rpath = self.ToSrcRelPath(path)
     output_dir, _, _ = rpath.rpartition(self.sep)
     return output_dir
 
   def GYPCmd(self, output_dir, vals):
-    gyp_defines = vals['gyp_defines']
+    if vals['cros_passthrough']:
+      if not 'GYP_DEFINES' in os.environ:
+        raise MBErr('MB is expecting GYP_DEFINES to be in the environment')
+      gyp_defines = os.environ['GYP_DEFINES']
+      if not 'chromeos=1' in gyp_defines:
+        raise MBErr('GYP_DEFINES is missing chromeos=1: (GYP_DEFINES=%s)' %
+                    gyp_defines)
+    else:
+      gyp_defines = vals['gyp_defines']
+
     goma_dir = self.args.goma_dir
 
     # GYP uses shlex.split() to split the gyp defines into separate arguments,
     # so we can support backslashes and and spaces in arguments by quoting
     # them, even on Windows, where this normally wouldn't work.
     if goma_dir and ('\\' in goma_dir or ' ' in goma_dir):
       goma_dir = "'%s'" % goma_dir
 
     if goma_dir:
       gyp_defines += ' gomadir=%s' % goma_dir
@@ skipping 354 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:]))