Revert of untrusted.gyp to fix goma_status=ok error.

build/build_nexe.py

 #!/usr/bin/python
 # Copyright (c) 2012 The Native Client Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """NEXE building script
 
 This module will take a set of source files, include paths, library paths, and
 additional arguments, and use them to build.
 """
@@ skipping 80 matching lines @@
   if not out_ts or not src_ts:
     return True
 
   # If just rebuilt timestamps may be equal due to time granularity.
   if rebuilt:
     return out_ts < src_ts
   # If about to build, be conservative and rebuilt just in case.
   return out_ts <= src_ts
 
 
-def GetGomaConfig(gomadir, osname, arch, toolname):
+def GetGomaPath(osname, arch, toolname):
   """Returns full-path of gomacc if goma is available or None."""
   # Start goma support from os/arch/toolname that have been tested.
   # Set NO_NACL_GOMA=true to force to avoid using goma.
   if (osname != 'linux' or arch not in ['x86-32', 'x86-64']
       or toolname not in ['newlib', 'glibc']
-      or os.environ.get('NO_NACL_GOMA')):
-    return {}
+      or os.environ.get('NO_NACL_GOMA', None)):
+    return None
 
-  goma_config = {}
   try:
     gomacc_base = 'gomacc.exe' if os.name == 'nt' else 'gomacc'
-    # Search order of gomacc:
-    # --gomadir command argument -> GOMA_DIR env. -> PATH env.
-    search_path = []
-    # 1. --gomadir in the command argument.
-    if gomadir:
-      search_path.append(gomadir)
-    # 2. Use GOMA_DIR environmental variable if exist.
-    goma_dir_env = os.environ.get('GOMA_DIR')
-    if goma_dir_env:
-      search_path.append(gomadir_env)
-    # 3. Append PATH env.
-    path_env = os.environ.get('PATH')
-    if path_env:
-      search_path.extend(path_env.split(os.path.pathsep))
-
-    for directory in search_path:
+    for directory in os.environ.get('PATH', '').split(os.path.pathsep):
       gomacc = os.path.join(directory, gomacc_base)
       if os.path.isfile(gomacc):
         port = subprocess.Popen(
             [gomacc, 'port'], stdout=subprocess.PIPE).communicate()[0].strip()
         if port:
           status = urllib2.urlopen(
               'http://127.0.0.1:%s/healthz' % port).read().strip()
           if status == 'ok':
-            goma_config['gomacc'] = gomacc
-            break
+            return gomacc
   except Exception:
     # Anyway, fallbacks to non-goma mode.
     pass
-
-  if goma_config:
-    goma_config['burst'] = False
-    if osname == 'linux' and not os.environ.get('NO_NACL_GOMA_BURST', None):
-      goma_config['burst'] = True
-  return goma_config
+  return None
 
 
 class Builder(object):
   """Builder object maintains options and generates build command-lines.
 
   The Builder object takes a set of script command-line options, and generates
   a set of paths, and command-line options for the NaCl toolchain.
   """
   def __init__(self, options):
     arch = options.arch
@@ skipping 80 matching lines @@
     self.BuildCompileOptions(options.compile_flags, self.define_list)
     self.BuildLinkOptions(options.link_flags)
     self.BuildArchiveOptions()
     self.verbose = options.verbose
     self.suffix = options.suffix
     self.strip = options.strip
     self.empty = options.empty
     self.strip_all = options.strip_all
     self.strip_debug = options.strip_debug
     self.finalize_pexe = options.finalize_pexe and arch == 'pnacl'
-    goma_config = GetGomaConfig(options.gomadir, self.osname, arch, toolname)
-    self.gomacc = goma_config.get('gomacc', '')
-    self.goma_burst = goma_config.get('burst', False)
+    self.gomacc = GetGomaPath(self.osname, arch, toolname)
 
     # Use unoptimized native objects for debug IRT builds for faster compiles.
     if (self.is_pnacl_toolchain
         and (self.outtype == 'nlib'
              or self.outtype == 'nexe')
         and self.arch != 'pnacl'):
       if (options.build_config is not None
           and options.build_config == 'Debug'):
         self.compile_options.extend(['--pnacl-allow-translate',
                                      '--pnacl-allow-native',
@@ skipping 453 matching lines @@
   parser.add_option('--defines', dest='defines',
                     help='Set defines')
   parser.add_option('--link_flags', dest='link_flags',
                     help='Set link flags.')
   parser.add_option('-v', '--verbose', dest='verbose', default=False,
                     help='Enable verbosity', action='store_true')
   parser.add_option('-t', '--toolpath', dest='toolpath',
                     help='Set the path for of the toolchains.')
   parser.add_option('--config-name', dest='build_config',
                     help='GYP build configuration name (Release/Debug)')
-  parser.add_option('--gomadir', dest='gomadir',
-                    help='Path of the goma directory.')
   options, files = parser.parse_args(argv[1:])
 
   if not argv:
     parser.print_help()
     return 1
 
   try:
     if options.source_list:
       source_list_handle = open(options.source_list, 'r')
       source_list = source_list_handle.read().splitlines()
@@ skipping 14 matching lines @@
     build = Builder(options)
     objs = []
 
     if build.outtype == 'translate':
       # Just translate a pexe to a nexe
       if len(files) != 1:
         parser.error('Pexe translation requires exactly one input file.')
       build.Translate(list(files)[0])
       return 0
 
-    if build.gomacc and build.goma_burst:  # execute gomacc as many as possible.
+    if build.gomacc:  # use goma build.
       returns = Queue.Queue()
       def CompileThread(filename, queue):
         try:
           queue.put(build.Compile(filename))
         except Exception:
           # Put current exception info to the queue.
           queue.put(sys.exc_info())
       build_threads = []
       # Start parallel build.
       for filename in files:
@@ skipping 24 matching lines @@
       shutil.copy(objs[0], options.name)
     else:
       build.Generate(objs)
     return 0
   except Error as e:
     sys.stderr.write('%s\n' % e)
     return 1
 
 if __name__ == '__main__':
   sys.exit(Main(sys.argv))