Add support for the GYP_CROSSCOMPILE env var 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 129 matching lines @@
     if vals['type'] == 'gyp':
       return self.RunGYPGen(vals)
 
     raise MBErr('Unknown meta-build type "%s"' % vals['type'])
 
   def CmdLookup(self):
     vals = self.GetConfig()
     if vals['type'] == 'gn':
       cmd = self.GNCmd('gen', '<path>', vals['gn_args'])
     elif vals['type'] == 'gyp':
+      if vals['gyp_crosscompile']:
+        self.Print('GYP_CROSSCOMPILE=1')
       cmd = self.GYPCmd('<path>', vals['gyp_defines'], vals['gyp_config'])
     else:
       raise MBErr('Unknown meta-build type "%s"' % vals['type'])
 
     self.PrintCmd(cmd)
     return 0
 
   def CmdHelp(self):
     if self.args.subcommand:
       self.ParseArgs([self.args.subcommand, '--help'])
@@ skipping 122 matching lines @@
 
     return self.masters[self.args.master][self.args.builder]
 
   def FlattenConfig(self, config):
     mixins = self.configs[config]
     vals = {
       'type': None,
       'gn_args': [],
       'gyp_config': [],
       'gyp_defines': [],
+      'gyp_crosscompile': False,
     }
 
     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 '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_config' in mixin_vals:
         vals['gyp_config'] = mixin_vals['gyp_config']
+      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 'mixins' in mixin_vals:
         self.FlattenMixins(mixin_vals['mixins'], vals, visited)
     return vals
 
   def RunGNGen(self, vals):
@@ skipping 92 matching lines @@
 
   def RunGYPGen(self, vals):
     path = self.args.path[0]
 
     output_dir, gyp_config = self.ParseGYPConfigPath(path)
     if gyp_config != vals['gyp_config']:
       raise MBErr('The last component of the path (%s) must match the '
                   'GYP configuration specified in the config (%s), and '
                   'it does not.' % (gyp_config, vals['gyp_config']))
     cmd = self.GYPCmd(output_dir, vals['gyp_defines'], config=gyp_config)
-    ret, _, _ = self.Run(cmd)
+    env = None
+    if vals['gyp_crosscompile']:
+      if self.args.verbose:
+        self.Print('Setting GYP_CROSSCOMPILE=1 in the environment')
+      env = os.environ.copy()
+      env['GYP_CROSSCOMPILE'] = '1'
+    ret, _, _ = self.Run(cmd, env=env)
     return ret
 
   def RunGYPAnalyze(self, vals):
     output_dir, gyp_config = self.ParseGYPConfigPath(self.args.path[0])
     if gyp_config != vals['gyp_config']:
       raise MBErr('The last component of the path (%s) must match the '
                   'GYP configuration specified in the config (%s), and '
                   'it does not.' % (gyp_config, vals['gyp_config']))
     if self.args.verbose:
       inp = self.ReadInputJSON(['files', 'targets'])
@@ skipping 305 matching lines @@
       cmd = ['python'] + cmd[1:]
     self.Print(*[pipes.quote(c) for c in cmd])
 
   def PrintJSON(self, obj):
     self.Print(json.dumps(obj, indent=2, sort_keys=True))
 
   def Print(self, *args, **kwargs):
     # This function largely exists so it can be overridden for testing.
     print(*args, **kwargs)
 
-  def Run(self, cmd):
+  def Run(self, cmd, env=None):
     # This function largely exists so it can be overridden for testing.
     if self.args.dryrun or self.args.verbose:
       self.PrintCmd(cmd)
     if self.args.dryrun:
       return 0, '', ''
-    ret, out, err = self.Call(cmd)
+    ret, out, err = self.Call(cmd, env=env)
     if self.args.verbose:
       if out:
         self.Print(out, end='')
       if err:
         self.Print(err, end='', file=sys.stderr)
     return ret, out, err
 
-  def Call(self, cmd):
+  def Call(self, cmd, env=None):
     p = subprocess.Popen(cmd, shell=False, cwd=self.chromium_src_dir,
-                         stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+                         stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+                         env=env)
     out, err = p.communicate()
     return p.returncode, out, err
 
   def ExpandUser(self, path):
     # This function largely exists so it can be overridden for testing.
     return os.path.expanduser(path)
 
   def Exists(self, path):
     # This function largely exists so it can be overridden for testing.
     return os.path.exists(path)
@@ skipping 32 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)