Remove dead code from compile.py.

scripts/slave/compile.py

 #!/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.
 
 """A tool to build chrome, executed by buildbot.
 
   When this is run, the current directory (cwd) should be the outer build
   directory (e.g., chrome-release/build/).
 
@@ skipping 58 matching lines @@
         fh.write('  %s=%s\n' % (k, self[k]))
       else:
         fh.write('  %s (removed)\n' % k)
     fh.write('\n')
 
 
 # TODO(tikuta): move to goma_utils.py
 def goma_setup(options, env):
   """Sets up goma if necessary.
 
-  If using the Goma compiler, first call goma_ctl  to ensure the proxy is
+  If using the Goma compiler, first call goma_ctl to ensure the proxy is
   available, and returns (True, instance of cloudtail subprocess).
-  If it failed to start up compiler_proxy, modify options.compiler and
-  options.goma_dir and returns (False, None)
-
+  If it failed to start up compiler_proxy, modify options.compiler
+  and options.goma_dir, modify env to GOMA_DISABLED=true,
+  and returns (False, None).
   """
   if options.compiler not in ('goma', 'goma-clang'):
     # Unset goma_dir to make sure we'll not use goma.
     options.goma_dir = None
     return False, None
 
-  hostname = goma_utils.GetShortHostname()
-  # HACK(shinyak, yyanagisawa, goma): Windows NO_NACL_GOMA (crbug.com/390764)
-  # Building NaCl untrusted code using goma brings large performance
-  # improvement but it sometimes cause build failure by race condition.
-  # Let me enable goma build on goma canary buildslaves to confirm the issue
-  # has been fixed by a workaround.
-  # vm*-m4 are trybots. build*-m1 and vm*-m1 are all goma canary bots.
-  if hostname in ['build28-m1', 'build58-m1', 'vm191-m1', 'vm480-m1',
-                  'vm820-m1', 'vm821-m1', 'vm848-m1']:
-    env['NO_NACL_GOMA'] = 'false'
-
   if options.goma_fail_fast:
     # startup fails when initial ping failed.
     env['GOMA_FAIL_FAST'] = 'true'
   else:
     # If a network error continues 30 minutes, compiler_proxy make the compile
     # failed.  When people use goma, they expect using goma is faster than
     # compile locally. If goma cannot guarantee that, let it make compile
     # as error.
     env['GOMA_ALLOWED_NETWORK_ERROR_DURATION'] = '1800'
 
-  # HACK(yyanagisawa): reduce GOMA_BURST_MAX_PROCS crbug.com/592306
-  # Recently, I sometimes see buildbot slave time out, one possibility I come
-  # up with is burst mode use up resource.
-  # Let me temporary set small values to GOMA_BURST_MAX_PROCS to confirm
-  # the possibility is true or false.
-  max_subprocs = '3'
-  max_heavy_subprocs = '1'
-  number_of_processors = 0
-  try:
-    number_of_processors = multiprocessing.cpu_count()
-  except NotImplementedError:
-    print 'cpu_count() is not implemented, using default value.'
-    number_of_processors = 1
-  if number_of_processors > 3:
-    max_subprocs = str(number_of_processors - 1)
-    max_heavy_subprocs = str(number_of_processors / 2)
-  env['GOMA_BURST_MAX_SUBPROCS'] = max_subprocs
-  env['GOMA_BURST_MAX_SUBPROCS_LOW'] = max_subprocs
-  env['GOMA_BURST_MAX_SUBPROCS_HEAVY'] = max_heavy_subprocs
-
   # Caches CRLs in GOMA_CACHE_DIR.
   # Since downloading CRLs is usually slow, caching them may improves
   # compiler_proxy start time.
   if not os.path.exists(options.goma_cache_dir):
     os.mkdir(options.goma_cache_dir, 0700)
   env['GOMA_CACHE_DIR'] = options.goma_cache_dir
 
   # Enable DepsCache. DepsCache caches the list of files to send goma server.
   # This will greatly improve build speed when cache is warmed.
   # The cache file is stored in the target output directory.
   env['GOMA_DEPS_CACHE_DIR'] = (
       options.goma_deps_cache_dir or options.target_output_dir)
 
-  if not env.get('GOMA_HERMETIC'):
+  if options.goma_hermetic:
     env['GOMA_HERMETIC'] = options.goma_hermetic
   if options.goma_enable_remote_link:
     env['GOMA_ENABLE_REMOTE_LINK'] = options.goma_enable_remote_link
   if options.goma_store_local_run_output:
     env['GOMA_STORE_LOCAL_RUN_OUTPUT'] = options.goma_store_local_run_output
   if options.goma_enable_compiler_info_cache:
     # Will be stored in GOMA_CACHE_DIR.
     env['GOMA_COMPILER_INFO_CACHE_FILE'] = 'goma-compiler-info.cache'
 
   if options.build_data_dir:
     env['GOMA_DUMP_STATS_FILE'] = os.path.join(options.build_data_dir,
                                                'goma_stats_proto')
 
-  # goma is requested.
-  goma_key = os.path.join(options.goma_dir, 'goma.key')
-  if os.path.exists(goma_key):
-    env['GOMA_API_KEY_FILE'] = goma_key
   if options.goma_service_account_json_file:
     env['GOMA_SERVICE_ACCOUNT_JSON_FILE'] = \
         options.goma_service_account_json_file
-  if chromium_utils.IsWindows():
-    env['GOMA_RPC_EXTRA_PARAMS'] = '?win'
   goma_start_command = ['restart']
   goma_ctl_cmd = [sys.executable,
                   os.path.join(options.goma_dir, 'goma_ctl.py')]
   result = chromium_utils.RunCommand(goma_ctl_cmd + goma_start_command, env=env)
   if not result:
     # goma started sucessfully.
     # Making cloudtail to upload the latest log.
     # TODO(yyanagisawa): install cloudtail from CIPD.
     cloudtail_path = '/opt/infra-tools/cloudtail'
     if chromium_utils.IsWindows():
@@ skipping 43 matching lines @@
     options.compiler = None
   # Reset options.goma_dir.
   options.goma_dir = None
   env['GOMA_DISABLED'] = '1'
   return False, None
 
 
 # TODO(tikuta): move to goma_utils.py
 def goma_teardown(options, env, exit_status, cloudtail_proc):
   """Tears down goma if necessary. """
-  if (options.compiler in ('goma', 'goma-clang') and
-      options.goma_dir):
+  if options.goma_dir:
     override_gsutil = None
     if options.gsutil_py_path:
       override_gsutil = [sys.executable, options.gsutil_py_path]
 
     # If goma compiler_proxy crashes during the build, there could be crash
     # dump.
     if options.build_data_dir:
       env['GOMACTL_CRASH_REPORT_ID_FILE'] = os.path.join(options.build_data_dir,
                                                          'crash_report_id_file')
     goma_ctl_cmd = [sys.executable,
                     os.path.join(options.goma_dir, 'goma_ctl.py')]
     if options.goma_jsonstatus:
       chromium_utils.RunCommand(
           goma_ctl_cmd + ['jsonstatus', options.goma_jsonstatus], env=env)
       goma_utils.SendGomaTsMon(options.goma_jsonstatus, exit_status)
-    # Always stop the proxy for now to allow in-place update.
+    # Always stop the proxy to dump GomaStats.
     chromium_utils.RunCommand(goma_ctl_cmd + ['stop'], env=env)
     goma_utils.UploadGomaCompilerProxyInfo(override_gsutil=override_gsutil)
     if env.get('GOMA_DUMP_STATS_FILE'):
       goma_utils.SendGomaStats(env['GOMA_DUMP_STATS_FILE'],
                                env.get('GOMACTL_CRASH_REPORT_ID_FILE'),
                                options.build_data_dir)
   if cloudtail_proc:
     cloudtail_proc.terminate()
     cloudtail_proc.wait()
 
@@ skipping 203 matching lines @@
   finally:
     override_gsutil = None
     if options.gsutil_py_path:
       override_gsutil = [sys.executable, options.gsutil_py_path]
 
     goma_utils.UploadNinjaLog(
         options.target_output_dir, options.compiler, command, exit_status,
         override_gsutil=override_gsutil)
 
 
-def get_target_build_dir(args, options):
+def get_target_build_dir(options):
   """Keep this function in sync with src/build/landmines.py"""
   if chromium_utils.IsLinux() and options.cros_board:
     # When building ChromeOS's Simple Chrome workflow, the output directory
     # has a CROS board name suffix.
     outdir = 'out_%s' % (options.cros_board,)
   elif options.out_dir:
     outdir = options.out_dir
   else:
     outdir = 'out'
   return os.path.abspath(os.path.join(options.src_dir, outdir, options.target))
@@ skipping 58 matching lines @@
                            help='Checks the output of the ninja builder to '
                                 'confirm that a second compile immediately '
                                 'the first is a no-op.')
 
   options, args = option_parser.parse_args()
 
   if not options.src_dir:
     options.src_dir = 'src'
   options.src_dir = os.path.abspath(options.src_dir)
 
-  options.target_output_dir = get_target_build_dir(args, options)
+  options.target_output_dir = get_target_build_dir(options)
 
   assert options.build_tool in (None, 'ninja')
   return options, args
 
 
 def real_main():
   options, args = get_parsed_options()
 
   # Prepare environment.
   env = EchoDict(os.environ)
@@ skipping 11 matching lines @@
   exit_status = main_ninja(options, args, env)
 
   # stop goma
   goma_teardown(options, env, exit_status, goma_cloudtail)
 
   return exit_status
 
 
 if '__main__' == __name__:
   sys.exit(real_main())