Reland of iOS: Use JSON for GN configuration instead of MB + remove symbols

tools-webrtc/mb/mb.py

 #!/usr/bin/env python
 # Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
 #
 # Use of this source code is governed by a BSD-style license
 # that can be found in the LICENSE file in the root of the source
 # tree. An additional intellectual property rights grant can be found
 # in the file PATENTS.  All contributing project authors may
 # be found in the AUTHORS file in the root of the source tree.
 
 """MB - the Meta-Build wrapper around GYP and GN
@@ skipping 15 matching lines @@
 import shutil
 import sys
 import subprocess
 import tempfile
 import traceback
 import urllib2
 
 from collections import OrderedDict
 
 SCRIPT_DIR = os.path.dirname(os.path.realpath(__file__))
-CHROMIUM_SRC_DIR = os.path.dirname(os.path.dirname(SCRIPT_DIR))
-sys.path = [os.path.join(CHROMIUM_SRC_DIR, 'build')] + sys.path
+SRC_DIR = os.path.dirname(os.path.dirname(SCRIPT_DIR))
+sys.path = [os.path.join(SRC_DIR, 'build')] + sys.path
 
 import gn_helpers
 
 
 def main(args):
   mbw = MetaBuildWrapper()
   return mbw.Main(args)
 
 
 class MetaBuildWrapper(object):
   def __init__(self):
-    self.chromium_src_dir = CHROMIUM_SRC_DIR
+    self.src_dir = SRC_DIR
     self.default_config = os.path.join(SCRIPT_DIR, 'mb_config.pyl')
     self.default_isolate_map = os.path.join(SCRIPT_DIR, 'gn_isolate_map.pyl')
     self.executable = sys.executable
     self.platform = sys.platform
     self.sep = os.sep
     self.args = argparse.Namespace()
     self.configs = {}
     self.masters = {}
     self.mixins = {}
 
@@ skipping 552 matching lines @@
     if 'type' not in vals:
         vals['type'] = 'gn'
     assert vals['type'] in ('gn', 'gyp'), (
         'Unknown meta-build type "%s"' % vals['gn_args'])
 
     return vals
 
   def ReadIOSBotConfig(self):
     if not self.args.master or not self.args.builder:
       return {}
-    path = self.PathJoin(self.chromium_src_dir, 'ios', 'build', 'bots',
-                         self.args.master, self.args.builder + '.json')
+    path = self.PathJoin(self.src_dir, 'tools-webrtc', 'ios',
+                         self.args.master,
+                         self.args.builder.replace(' ', '_') + '.json')
     if not self.Exists(path):
       return {}
 
     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', []))
@@ skipping 280 matching lines @@
       }) + '\n')
 
     self.WriteJSON(
       {
         'args': [
           '--isolated',
           self.ToSrcRelPath('%s/%s.isolated' % (build_dir, target)),
           '--isolate',
           self.ToSrcRelPath('%s/%s.isolate' % (build_dir, target)),
         ],
-        'dir': self.chromium_src_dir,
+        'dir': self.src_dir,
         'version': 1,
       },
       isolate_path + 'd.gen.json',
     )
 
   def MapTargetsToLabels(self, isolate_map, targets):
     labels = []
     err = ''
 
     def StripTestSuffixes(target):
@@ skipping 24 matching lines @@
     return err, labels
 
   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)
+    gn_path = self.PathJoin(self.src_dir, 'buildtools', subdir, exe)
     return [gn_path, subcommand, path] + list(args)
 
 
   def GNArgs(self, vals):
     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 re.search('target_os.*=.*"chromeos"', gn_args):
         raise MBErr('GN_ARGS is missing target_os = "chromeos": (GN_ARGS=%s)' %
@@ skipping 150 matching lines @@
           executable,
           '--',
           '--asan=%d' % asan,
           '--msan=%d' % msan,
           '--tsan=%d' % tsan,
       ]
 
     return cmdline, extra_files
 
   def ToAbsPath(self, build_path, *comps):
-    return self.PathJoin(self.chromium_src_dir,
+    return self.PathJoin(self.src_dir,
                          self.ToSrcRelPath(build_path),
                          *comps)
 
   def ToSrcRelPath(self, path):
     """Returns a relative path from the top of the repo."""
     if path.startswith('//'):
       return path[2:].replace('/', self.sep)
-    return self.RelPath(path, self.chromium_src_dir)
+    return self.RelPath(path, self.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):
     if vals['cros_passthrough']:
       if not 'GYP_DEFINES' in os.environ:
         raise MBErr('MB is expecting GYP_DEFINES to be in the environment')
@@ skipping 267 matching lines @@
       if ret:
         self.Print('  -> returned %d' % ret)
       if out:
         self.Print(out, end='')
       if err:
         self.Print(err, end='', file=sys.stderr)
     return ret, out, err
 
   def Call(self, cmd, env=None, buffer_output=True):
     if buffer_output:
-      p = subprocess.Popen(cmd, shell=False, cwd=self.chromium_src_dir,
+      p = subprocess.Popen(cmd, shell=False, cwd=self.src_dir,
                            stdout=subprocess.PIPE, stderr=subprocess.PIPE,
                            env=env)
       out, err = p.communicate()
     else:
-      p = subprocess.Popen(cmd, shell=False, cwd=self.chromium_src_dir,
+      p = subprocess.Popen(cmd, shell=False, cwd=self.src_dir,
                            env=env)
       p.wait()
       out = err = ''
     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):
@@ skipping 88 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:]))