Enables goma from GYP.

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 GetGomaPath(osname, arch, toolname):
+def GetGomaPath(gomadir, 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', None)):
+      or os.environ.get('NO_NACL_GOMA'):
     return None
 
   try:
     gomacc_base = 'gomacc.exe' if os.name == 'nt' else 'gomacc'
-    for directory in os.environ.get('PATH', '').split(os.path.pathsep):
+    # 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 environment 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:
       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':
             return gomacc
   except Exception:
@@ skipping 93 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'
-    self.gomacc = GetGomaPath(self.osname, arch, toolname)
+    self.gomacc = GetGomaPath(options.gomadir, 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:  # use goma build.
+    if build.gomacc:  # execute gomacc as many as possible.
       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))