Let gyp_chromium set GYP_CROSSCOMPILE for android and ios.

build/gyp_chromium

 #!/usr/bin/env python
 
 # Copyright (c) 2012 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.
 
 # This script is wrapper for Chromium that adds some support for how GYP
 # is invoked by Chromium beyond what can be done in the gclient hooks.
 
 import glob
@@ skipping 81 matching lines @@
     key = FormatKeyForGN(tokens[0])
     if len(tokens) == 2:
       result += [(key, tokens[1])]
     else:
       # No value supplied, treat it as a boolean and set it. Note that we
       # use the string '1' here so we have a consistent definition whether
       # you do 'foo=1' or 'foo'.
       result += [(key, '1')]
   return result
 
+
 def GetGypVarsForGN(supplemental_files):
   """Returns a dictionary of all GYP vars that we will be passing to GN."""
+  # Find the .gyp directory in the user's home directory.
+  home_dot_gyp = os.environ.get('GYP_CONFIG_DIR', None)
+  if home_dot_gyp:
+    home_dot_gyp = os.path.expanduser(home_dot_gyp)
+  if not home_dot_gyp:
+    home_vars = ['HOME']
+    if sys.platform in ('cygwin', 'win32'):
+      home_vars.append('USERPROFILE')
+    for home_var in home_vars:
+      home = os.getenv(home_var)
+      if home != None:
+        home_dot_gyp = os.path.join(home, '.gyp')
+        if not os.path.exists(home_dot_gyp):
+          home_dot_gyp = None
+        else:
+          break
+
+  if home_dot_gyp:
+    include_gypi = os.path.join(home_dot_gyp, "include.gypi")
+    if os.path.exists(include_gypi):
+      supplemental_files += [include_gypi]
 
   # GYP defines from the supplemental.gypi files.
   supp_items = []
   for supplement in supplemental_files:
     with open(supplement, 'r') as f:
       try:
         file_data = eval(f.read(), {'__builtins__': None}, None)
       except SyntaxError, e:
         e.filename = os.path.abspath(supplement)
         raise
       variables = file_data.get('variables', [])
       for v in variables:
         supp_items += [(FormatKeyForGN(v), str(variables[v]))]
 
   # GYP defines from the environment.
   env_items = ProcessGypDefinesItems(
       shlex.split(os.environ.get('GYP_DEFINES', '')))
 
   # GYP defines from the command line. We can't use optparse since we want
   # to ignore all arguments other than "-D".
   cmdline_input_items = []
   for i in range(len(sys.argv))[1:]:
     if sys.argv[i].startswith('-D'):
       if sys.argv[i] == '-D' and i + 1 < len(sys.argv):
         cmdline_input_items += [sys.argv[i + 1]]
       elif len(sys.argv[i]) > 2:
         cmdline_input_items += [sys.argv[i][2:]]
   cmdline_items = ProcessGypDefinesItems(cmdline_input_items)
 
-  return dict(supp_items + env_items + cmdline_items)
+  vars_dict = dict(supp_items + env_items + cmdline_items)
+  # It's not possible to set a default value for cpu_arch in GN, so do it here
+  # for now (http://crbug.com/344767).
+  if vars_dict.get('OS') == 'android' and not 'target_arch' in vars_dict:
+    vars_dict['target_arch'] = 'arm'
+  return vars_dict
+
 
 def GetOutputDirectory():
   """Returns the output directory that GYP will use."""
   # GYP generator flags from the command line. We can't use optparse since we
   # want to ignore all arguments other than "-G".
   needle = '-Goutput_dir='
   cmdline_input_items = []
   for item in sys.argv[1:]:
     if item.startswith(needle):
       return item[len(needle):]
 
   env_items = shlex.split(os.environ.get('GYP_GENERATOR_FLAGS', ''))
   needle = 'output_dir='
   for item in env_items:
     if item.startswith(needle):
       return item[len(needle):]
 
   return "out"
 
-def GetArgsStringForGN(supplemental_files):
+
+def GetArgsStringForGN(vars_dict):
   """Returns the args to pass to GN.
   Based on a subset of the GYP variables that have been rewritten a bit."""
-
-  # Find the .gyp directory in the user's home directory.
-  home_dot_gyp = os.environ.get('GYP_CONFIG_DIR', None)
-  if home_dot_gyp:
-    home_dot_gyp = os.path.expanduser(home_dot_gyp)
-  if not home_dot_gyp:
-    home_vars = ['HOME']
-    if sys.platform in ('cygwin', 'win32'):
-      home_vars.append('USERPROFILE')
-    for home_var in home_vars:
-      home = os.getenv(home_var)
-      if home != None:
-        home_dot_gyp = os.path.join(home, '.gyp')
-        if not os.path.exists(home_dot_gyp):
-          home_dot_gyp = None
-        else:
-          break
-
-  if home_dot_gyp:
-    include_gypi = os.path.join(home_dot_gyp, "include.gypi")
-    if os.path.exists(include_gypi):
-      supplemental_files += [include_gypi]
-
-  vars_dict = GetGypVarsForGN(supplemental_files)
-  # It's not possible to let set a default value for cpu_arch in GN, so do it
-  # here for now (http://crbug.com/344767).
-  if vars_dict.get('OS') == 'android' and not 'target_arch' in vars_dict:
-    vars_dict['target_arch'] = 'arm'
-
   gn_args = ''
 
   # Note: These are the additional flags passed to various builds by builders
   # on the main waterfall. We'll probably need to add these at some point:
   #   mac_strip_release=1         http://crbug.com/330301
   #   linux_dump_symbols=0        http://crbug.com/330300
   #   host_os=linux  Probably can skip, GN knows the host OS.
   #   order_text_section=<path>   http://crbug.com/330299
   #   chromium_win_pch=0          http://crbug.com/297678
   #   chromium_ios_signing=0      http://crbug.com/330302
@@ skipping 98 matching lines @@
   # Always include common.gypi.
   AddInclude(os.path.join(script_dir, 'common.gypi'))
 
   # Optionally add supplemental .gypi files if present.
   for supplement in supplemental_files:
     AddInclude(supplement)
 
   return result
 
 
-def RunGN(supplemental_includes):
+def RunGN(vars_dict):
   """Runs GN, returning True if it succeeded, printing an error and returning
   false if not."""
 
   # The binaries in platform-specific subdirectories in src/tools/gn/bin.
   gnpath = SRC_DIR + '/tools/gn/bin/'
   if sys.platform in ('cygwin', 'win32'):
     gnpath += 'win/gn.exe'
   elif sys.platform.startswith('linux'):
     # On Linux we have 32-bit and 64-bit versions.
     if subprocess.check_output(["getconf", "LONG_BIT"]).find("64") >= 0:
       gnpath += 'linux/gn'
     else:
       gnpath += 'linux/gn32'
   elif sys.platform == 'darwin':
     gnpath += 'mac/gn'
   else:
     print 'Unknown platform for GN: ', sys.platform
     return False
 
   print 'Generating gyp files from GN...'
 
   # Need to pass both the source root (the bots don't run this command from
   # within the source tree) as well as set the is_gyp value so the BUILD files
   # to know they're being run under GYP.
   args = [gnpath, 'gyp', '-q',
           '--root=' + chrome_src,
-          '--args=' + GetArgsStringForGN(supplemental_includes),
+          '--args=' + GetArgsStringForGN(vars_dict),
           '--output=//' + GetOutputDirectory() + '/gn_build/']
   return subprocess.call(args) == 0
 
 
 def CopyVsRuntimeDlls(output_dir, runtime_dirs):
   """Copies the VS runtime DLLs from the given |runtime_dirs| to the output
   directory so that even if not system-installed, built binaries are likely to
   be able to run.
 
   This needs to be run after gyp has been run so that the expected target
@@ skipping 131 matching lines @@
       print('Using automatic toolchain in %s (%s edition).' % (
                 toolchain, 'Pro' if version_is_pro else 'Express'))
 
   # If CHROMIUM_GYP_SYNTAX_CHECK is set to 1, it will invoke gyp with --check
   # to enfore syntax checking.
   syntax_check = os.environ.get('CHROMIUM_GYP_SYNTAX_CHECK')
   if syntax_check and int(syntax_check):
     args.append('--check')
 
   supplemental_includes = GetSupplementalFiles()
-  if not RunGN(supplemental_includes):
+  gn_vars_dict = GetGypVarsForGN(supplemental_includes)
+
+  # Automatically turn on crosscompile support for platforms that need it.
+  # (The Chrome OS build sets CC_host / CC_target which implicitly enables
+  # this mode.)
+  if all(('ninja' in os.environ.get('GYP_GENERATORS', ''),
+          gn_vars_dict.get('OS') in ['android', 'ios'],
+          'GYP_CROSSCOMPILE' not in os.environ)):
+    os.environ['GYP_CROSSCOMPILE'] = '1'
+
+  if not RunGN(gn_vars_dict):
     sys.exit(1)
   args.extend(
       ['-I' + i for i in additional_include_files(supplemental_includes, args)])
 
   args.extend(['-D', 'gyp_output_dir=' + GetOutputDirectory()])
 
   print 'Updating projects from gyp files...'
   sys.stdout.flush()
 
   # Off we go...
   gyp_rc = gyp.main(args)
 
   # Check for landmines (reasons to clobber the build). This must be run here,
   # rather than a separate runhooks step so that any environment modifications
   # from above are picked up.
   print 'Running build/landmines.py...'
   subprocess.check_call(
       [sys.executable, os.path.join(script_dir, 'landmines.py')])
 
   if vs2013_runtime_dll_dirs:
     CopyVsRuntimeDlls(GetOutputDirectory(), vs2013_runtime_dll_dirs)
 
   sys.exit(gyp_rc)