Instrumented libraries: refactor build scripts.

third_party/instrumented_libraries/download_build_install.py

 #!/usr/bin/python
 # Copyright 2013 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.
 
 """Downloads, builds (with instrumentation) and installs shared libraries."""
 
 import argparse
 import os
 import platform
@@ skipping 95 matching lines @@
     raise Exception('Failed to run: %s' % command)
 
 
 def run_shell_commands(commands, verbose=False, environment=None):
   for command in commands:
     shell_call(command, verbose, environment)
 
 
 def destdir_configure_make_install(parsed_arguments, environment,
                                    install_prefix):
-  configure_command = './configure %s' % parsed_arguments.custom_configure_flags
+  configure_command = './configure %s' % parsed_arguments.extra_configure_flags
   configure_command += ' --libdir=/lib/'
   # Installing to a temporary directory allows us to safely clean up the .la
   # files below.
   destdir = '%s/debian/instrumented_build' % os.getcwd()
   # Some makefiles use BUILDROOT instead of DESTDIR.
   make_command = 'make -j%s DESTDIR=%s BUILDROOT=%s' % (
       parsed_arguments.jobs, destdir, destdir),
   run_shell_commands([
       configure_command,
       make_command,
       '%s install' % make_command,
       # Kill the .la files. They contain absolute paths, and will cause build
       # errors in dependent libraries.
       'rm %s/lib/*.la -f' % destdir,
       # Now move the contents of the temporary destdir to their final place.
       'cp %s/* %s/ -rdf' % (destdir, install_prefix)],
                      parsed_arguments.verbose, environment)
 
 
 def prefix_configure_make_install(parsed_arguments, environment,
                                   install_prefix):
   configure_command = './configure %s --prefix=%s' % (
-      parsed_arguments.custom_configure_flags, install_prefix)
+      parsed_arguments.extra_configure_flags, install_prefix)
   shell_call(configure_command, parsed_arguments.verbose, environment)
   shell_call('make -j%s' % parsed_arguments.jobs,
              parsed_arguments.verbose, environment)
   shell_call('make -j%s install' % parsed_arguments.jobs,
              parsed_arguments.verbose, environment)
 
 
 def nss_make_and_copy(parsed_arguments, environment, install_prefix):
   # NSS uses a build system that's different from configure/make/install. All
   # flags must be passed as arguments to make.
@@ skipping 86 matching lines @@
   if parsed_arguments.build_method == 'destdir':
     destdir_configure_make_install(
         parsed_arguments, environment, install_prefix)
   elif parsed_arguments.build_method == 'prefix':
     prefix_configure_make_install(parsed_arguments, environment, install_prefix)
   elif parsed_arguments.build_method == 'custom_nss':
     nss_make_and_copy(parsed_arguments, environment, install_prefix)
   elif parsed_arguments.build_method == 'custom_libcap':
     libcap2_make_install(parsed_arguments, environment, install_prefix)
   elif parsed_arguments.build_method == 'custom_pango':
-    parsed_arguments.custom_configure_flags += \
+    parsed_arguments.extra_configure_flags += \
       ' --x-libraries=%s/lib' % install_prefix
-    parsed_arguments.custom_configure_flags += \
+    parsed_arguments.extra_configure_flags += \
       ' --x-includes=%s/include' % install_prefix
     prefix_configure_make_install(parsed_arguments, environment, install_prefix)
   elif parsed_arguments.build_method == 'custom_libpci3':
     libpci3_make_install(parsed_arguments, environment, install_prefix)
   else:
     raise Exception('Unrecognized build method: %s' %
                     parsed_arguments.build_method)
 
 
 def download_build_install(parsed_arguments):
   sanitizer_params = SUPPORTED_SANITIZERS[parsed_arguments.sanitizer_type]
 
   environment = os.environ.copy()
   # Usage of environment variables CC and CXX prefers usage flags --c-compiler
   # and --cxx-compiler
-  if 'CC' not in environment and parsed_arguments.c_compiler:
-    environment['CC'] = parsed_arguments.c_compiler
-  if 'CXX' not in environment and parsed_arguments.cxx_compiler:
-    environment['CXX'] = parsed_arguments.cxx_compiler
+  if 'CC' not in environment and parsed_arguments.cc:
+    environment['CC'] = parsed_arguments.cc
+  if 'CXX' not in environment and parsed_arguments.cxx:
+    environment['CXX'] = parsed_arguments.cxx
 
   product_directory = os.path.normpath('%s/%s' % (
       get_script_absolute_path(),
       parsed_arguments.product_directory))
 
   compiler_flags = sanitizer_params['compiler_flags']
   if parsed_arguments.sanitizer_blacklist:
     compiler_flags += ' -fsanitize-blacklist=%s/%s' % (
         product_directory,
         parsed_arguments.sanitizer_blacklist)
   environment['CFLAGS'] = '%s %s' % (compiler_flags,
-                                     parsed_arguments.custom_c_compiler_flags)
+                                     parsed_arguments.extra_cflags)
   environment['CXXFLAGS'] = '%s %s' % (
       compiler_flags,
-      parsed_arguments.custom_cxx_compiler_flags)
+      parsed_arguments.extra_cxxflags)
 
   install_prefix = '%s/instrumented_libraries/%s' % (
       product_directory,
       parsed_arguments.sanitizer_type)
 
   # Make sure the linker searches the instrumented libraries dir for
   # library dependencies.
   environment['LDFLAGS'] = '%s -L%s/lib %s' % (
       sanitizer_params['linker_flags'],
-      install_prefix, parsed_arguments.custom_linker_flags)
+      install_prefix, parsed_arguments.extra_ldflags)
 
   library_directory = '%s/%s' % (parsed_arguments.intermediate_directory,
                                  parsed_arguments.library)
 
   # A failed build might have left a dirty source tree behind.
   if os.path.exists(library_directory):
     shutil.rmtree(library_directory)
   os.makedirs(library_directory)
 
   with ScopedChangeDirectory(library_directory) as cd_library:
@@ skipping 35 matching lines @@
       description='Download, build and install instrumented library')
 
   argument_parser.add_argument('-j', '--jobs', type=int, default=1)
   argument_parser.add_argument('-l', '--library', required=True)
   argument_parser.add_argument(
       '-i', '--product-directory', default='.',
       help='Relative path to the directory with chrome binaries')
   argument_parser.add_argument(
       '-m', '--intermediate-directory', default='.',
       help='Relative path to the directory for temporary build files')
-  argument_parser.add_argument('--custom-configure-flags', default='')
-  argument_parser.add_argument('--custom-c-compiler-flags', default='')
-  argument_parser.add_argument('--custom-cxx-compiler-flags', default='')
-  argument_parser.add_argument('--custom-linker-flags', default='')
+  argument_parser.add_argument('--extra-configure-flags', default='')
+  argument_parser.add_argument('--extra-cflags', default='')
+  argument_parser.add_argument('--extra-cxxflags', default='')
+  argument_parser.add_argument('--extra-ldflags', default='')
   argument_parser.add_argument('-s', '--sanitizer-type', required=True,
                                choices=SUPPORTED_SANITIZERS.keys())
   argument_parser.add_argument('-v', '--verbose', action='store_true')
   argument_parser.add_argument('--check-build-deps', action='store_true')
-  argument_parser.add_argument('--c-compiler')
-  argument_parser.add_argument('--cxx-compiler')
+  argument_parser.add_argument('--cc')
+  argument_parser.add_argument('--cxx')
   # This should be a shell script to run before building specific libraries
   # e.g. extracting archives with sources, patching makefiles, etc.
   argument_parser.add_argument('--run-before-build', default='')
   argument_parser.add_argument('--build-method', default='destdir')
   argument_parser.add_argument('--sanitizer-blacklist', default='')
 
   # Ignore all empty arguments because in several cases gyp passes them to the
   # script, but ArgumentParser treats them as positional arguments instead of
   # ignoring (and doesn't have such options).
   parsed_arguments = argument_parser.parse_args(
       [arg for arg in sys.argv[1:] if len(arg) != 0])
   # Ensure current working directory is this script directory.
   os.chdir(get_script_absolute_path())
   # Ensure all build dependencies are installed.
   if parsed_arguments.check_build_deps:
     check_library_build_dependencies(parsed_arguments.library)
 
   download_build_install(parsed_arguments)
 
 
 if __name__ == '__main__':
   main()