Switch MB to write the GN args to args.gn.

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.
 """
 
 from __future__ import print_function
 
 import argparse
 import ast
 import errno
 import json
 import os
 import pipes
 import pprint
 import re
 import shutil
 import sys
 import subprocess
 import tempfile
 import urllib2
 
 from collections import OrderedDict
 
+CHROMIUM_SRC_DIR = os.path.dirname(os.path.dirname(os.path.dirname(
+    os.path.abspath(__file__))))
+sys.path = [os.path.join(CHROMIUM_SRC_DIR, 'build')] + sys.path
+
+import gn_helpers
+
+
 def main(args):
   mbw = MetaBuildWrapper()
   return mbw.Main(args)
 
 
 class MetaBuildWrapper(object):
   def __init__(self):
-    p = os.path
-    d = os.path.dirname
-    self.chromium_src_dir = p.normpath(d(d(d(p.abspath(__file__)))))
-    self.default_config = p.join(self.chromium_src_dir, 'tools', 'mb',
-                                 'mb_config.pyl')
+    self.chromium_src_dir = CHROMIUM_SRC_DIR
+    self.default_config = os.path.join(self.chromium_src_dir, 'tools', 'mb',
+                                       'mb_config.pyl')
     self.executable = sys.executable
     self.platform = sys.platform
     self.sep = os.sep
     self.args = argparse.Namespace()
     self.configs = {}
     self.masters = {}
     self.mixins = {}
 
   def Main(self, args):
     self.ParseArgs(args)
@@ skipping 196 matching lines @@
       return 1
 
     if vals['type'] == 'gn':
       return self.RunGNIsolate(vals)
     else:
       return self.Build('%s_run' % self.args.target[0])
 
   def CmdLookup(self):
     vals = self.Lookup()
     if vals['type'] == 'gn':
-      cmd = self.GNCmd('gen', '_path_', vals['gn_args'])
+      cmd = self.GNCmd('gen', '_path_')
+      gn_args = self.GNArgs(vals)
+      self.Print('\nWriting """\\\n%s""" to _path_/args.gn.\n' % gn_args)
       env = None
     else:
       cmd, env = self.GYPCmd('_path_', vals)
 
     self.PrintCmd(cmd, env)
     return 0
 
   def CmdRun(self):
     vals = self.GetConfig()
     if not vals:
@@ skipping 414 matching lines @@
 
     if needs_clobber:
       self.RemoveDirectory(build_dir)
 
     self.MaybeMakeDirectory(build_dir)
     self.WriteFile(mb_type_path, new_mb_type)
 
   def RunGNGen(self, vals):
     build_dir = self.args.path[0]
 
-    cmd = self.GNCmd('gen', build_dir, vals['gn_args'], extra_args=['--check'])
+    cmd = self.GNCmd('gen', build_dir, '--check')
+    gn_args = self.GNArgs(vals)
+
+    # Since GN hasn't run yet, the build directory may not even exist.
+    self.MaybeMakeDirectory(self.ToAbsPath(build_dir))
+
+    gn_args_path = self.ToAbsPath(build_dir, 'args.gn')
+    self.WriteFile(gn_args_path, gn_args)
 
     swarming_targets = []
     if getattr(self.args, 'swarming_targets_file', None):
       # We need GN to generate the list of runtime dependencies for
       # the compile targets listed (one per line) in the file so
       # we can run them via swarming. We use ninja_to_gn.pyl to convert
       # the compile targets to the matching GN labels.
       path = self.args.swarming_targets_file
       if not self.Exists(path):
         self.WriteFailureAndRaise('"%s" does not exist' % path,
@@ skipping 11 matching lines @@
         elif gn_isolate_map[target_name]['type'] == 'unknown':
           err += ('test target "%s" type is unknown\n' % target_name)
         else:
           gn_labels.append(gn_isolate_map[target_name]['label'])
 
       if err:
           raise MBErr('Error: Failed to match swarming targets to %s:\n%s' %
                       ('//testing/buildbot/gn_isolate_map.pyl', err))
 
       gn_runtime_deps_path = self.ToAbsPath(build_dir, 'runtime_deps')
-
-      # Since GN hasn't run yet, the build directory may not even exist.
-      self.MaybeMakeDirectory(self.ToAbsPath(build_dir))
-
       self.WriteFile(gn_runtime_deps_path, '\n'.join(gn_labels) + '\n')
       cmd.append('--runtime-deps-list-file=%s' % gn_runtime_deps_path)
 
     ret, _, _ = self.Run(cmd)
     if ret:
         # If `gn gen` failed, we should exit early rather than trying to
         # generate isolates. Run() will have already logged any error output.
         self.Print('GN gen failed: %d' % ret)
         return ret
 
@@ skipping 46 matching lines @@
   def RunGNIsolate(self, vals):
     gn_isolate_map = ast.literal_eval(self.ReadFile(self.PathJoin(
         self.chromium_src_dir, 'testing', 'buildbot', 'gn_isolate_map.pyl')))
 
     build_dir = self.args.path[0]
     target = self.args.target[0]
     target_name = self.GNTargetName(target)
     command, extra_files = self.GetIsolateCommand(target, vals, gn_isolate_map)
 
     label = gn_isolate_map[target_name]['label']
-    cmd = self.GNCmd('desc', build_dir, extra_args=[label, 'runtime_deps'])
+    cmd = self.GNCmd('desc', build_dir, label, 'runtime_deps')
     ret, out, _ = self.Call(cmd)
     if ret:
       if out:
         self.Print(out)
       return ret
 
     runtime_deps = out.splitlines()
 
     self.WriteIsolateFiles(build_dir, command, target, runtime_deps,
                            extra_files)
@@ skipping 28 matching lines @@
           self.ToSrcRelPath('%s/%s.isolated' % (build_dir, target)),
           '--isolate',
           self.ToSrcRelPath('%s/%s.isolate' % (build_dir, target)),
         ],
         'dir': self.chromium_src_dir,
         'version': 1,
       },
       isolate_path + 'd.gen.json',
     )
 
-  def GNCmd(self, subcommand, path, gn_args='', extra_args=None):
+  def GNCmd(self, subcommand, path, *args):
     if self.platform == 'linux2':
       subdir, exe = 'linux64', 'gn'
     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)
 
-    cmd = [gn_path, subcommand, path]
+    return [gn_path, subcommand, path] + list(args)
+
+  def GNArgs(self, vals):
+    gn_args = vals['gn_args']
     if self.args.goma_dir:
       gn_args += ' goma_dir="%s"' % self.args.goma_dir
-    if gn_args:
-      cmd.append('--args=%s' % gn_args)
-    if extra_args:
-      cmd.extend(extra_args)
-    return cmd
+
+    # Canonicalize the arg string into a sorted, newline-separated list
+    # of key-value pairs, and de-dup the keys if need be so that only
+    # the last instance of each arg is listed.
+    gn_args = gn_helpers.ToGNString(gn_helpers.FromGNArgs(gn_args))
+
+    return gn_args
 
   def RunGYPGen(self, vals):
     path = self.args.path[0]
 
     output_dir = self.ParseGYPConfigPath(path)
     cmd, env = self.GYPCmd(output_dir, vals)
     ret, _, _ = self.Run(cmd, env=env)
     return ret
 
   def RunGYPAnalyze(self, vals):
@@ skipping 208 matching lines @@
           }, output_path)
       return 0
 
     ret = 0
     response_file = self.TempFile()
     response_file.write('\n'.join(inp['files']) + '\n')
     response_file.close()
 
     matching_targets = set()
     try:
-      cmd = self.GNCmd('refs', self.args.path[0]) + [
-          '@%s' % response_file.name, '--all', '--as=output']
+      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 targets:
           matching_targets.add(build_output)
 
-      cmd = self.GNCmd('refs', self.args.path[0]) + [
-          '@%s' % response_file.name, '--all']
+      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 targets:
@@ skipping 241 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:]))