Instrumented libraries: move all scripts to scripts/.

third_party/instrumented_libraries/scripts/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
 import re
 import shlex
 import shutil
 import subprocess
 import sys
 
 SCRIPT_ABSOLUTE_PATH = os.path.dirname(os.path.abspath(__file__))
 
 def unescape_flags(s):
   """Un-escapes build flags received from GYP.
 
   GYP escapes build flags as if they are to be inserted directly into a command
   line, wrapping each flag in double quotes. When flags are passed via
   CFLAGS/LDFLAGS instead, double quotes must be dropped.
   """
   return ' '.join(shlex.split(s))
 
 
-def real_path(path_relative_to_script):
+def real_path(path_relative_to_gyp):
   """Returns the absolute path to a file.
 
-  GYP generates paths relative to the location of the .gyp file, which coincides
-  with the location of this script. This function converts them to absolute
-  paths.
+  GYP generates paths relative to the location of the .gyp file, which is one
+  level above the location of this script. This function converts them to
+  absolute paths.
   """
-  return os.path.realpath(os.path.join(SCRIPT_ABSOLUTE_PATH,
-                                       path_relative_to_script))
+  return os.path.realpath(os.path.join(SCRIPT_ABSOLUTE_PATH, '..',
+                                       path_relative_to_gyp))
 
 
 class InstrumentedPackageBuilder(object):
   """Checks out and builds a single instrumented package."""
   def __init__(self, args, clobber):
     self._cc = args.cc
     self._cxx = args.cxx
     self._extra_configure_flags = args.extra_configure_flags
     self._jobs = args.jobs
     self._libdir = args.libdir
     self._package = args.package
     self._patch = real_path(args.patch) if args.patch else None
-    self._run_before_build = \
-        real_path(args.run_before_build) if args.run_before_build else None
+    self._pre_build = \
+        real_path(args.pre_build) if args.pre_build else None
     self._sanitizer = args.sanitizer
     self._verbose = args.verbose
     self._clobber = clobber
     self._working_dir = os.path.join(
         real_path(args.intermediate_dir), self._package, '')
 
     product_dir = real_path(args.product_dir)
     self._destdir = os.path.join(
         product_dir, 'instrumented_libraries', self._sanitizer)
     self._source_archives_dir = os.path.join(
@@ skipping 70 matching lines @@
       raise Exception('Can\'t find source archives after `apt-get source %s\'.'
          % self._package)
     self._source_archives = \
         [os.path.join(dirpath, filename) for filename in filenames]
 
     return get_fresh_source
 
   def patch_source(self):
     if self._patch:
       self.shell_call('patch -p1 -i %s' % self._patch, cwd=self._source_dir)
-    if self._run_before_build:
-      self.shell_call(self._run_before_build, cwd=self._source_dir)
+    if self._pre_build:
+      self.shell_call(self._pre_build, cwd=self._source_dir)
 
   def copy_source_archives(self):
     """Copies the downloaded source archives to the output dir.
 
     For license compliance purposes, every Chromium build that includes
     instrumented libraries must include their full source code.
     """
     self.shell_call('rm -rf %s' % self._source_archives_dir)
     os.makedirs(self._source_archives_dir)
     for filename in self._source_archives:
       shutil.copy(filename, self._source_archives_dir)
     if self._patch:
       shutil.copy(self._patch, self._source_archives_dir)
 
   def download_build_install(self):
     got_fresh_source = self.maybe_download_source()
     if got_fresh_source:
       self.patch_source()
       self.copy_source_archives()
 
     self.shell_call('mkdir -p %s' % self.dest_libdir())
 
     try:
       self.build_and_install()
     except Exception as exception:
       print 'ERROR: Failed to build package %s. Have you run ' \
-            'src/third_party/instrumented_libraries/install-build-deps.sh?' % \
+            'src/third_party/instrumented_libraries/scripts/' \
+            'install-build-deps.sh?' % \
             self._package
       print
       raise
 
     # Touch a text file to indicate package is installed.
     stamp_file = os.path.join(self._destdir, '%s.txt' % self._package)
     open(stamp_file, 'w').close()
 
     # Remove downloaded package and generated temporary build files. Failed
     # builds intentionally skip this step to help debug build failures.
     if self._clobber:
       self.shell_call('rm -rf %s' % self._working_dir)
 
   def fix_rpaths(self, directory):
     # TODO(earthdok): reimplement fix_rpaths.sh in Python.
-    script = real_path('fix_rpaths.sh')
+    script = real_path('scripts/fix_rpaths.sh')
     self.shell_call("%s %s" % (script, directory))
 
   def temp_dir(self):
     """Returns the directory which will be passed to `make install'."""
     return os.path.join(self._source_dir, 'debian', 'instrumented_build')
 
   def temp_libdir(self):
     """Returns the directory under temp_dir() containing the DSOs."""
     return os.path.join(self.temp_dir(), self._libdir)
 
@@ skipping 188 matching lines @@
   parser.add_argument('--cflags', default='')
   parser.add_argument('--ldflags', default='')
   parser.add_argument('-s', '--sanitizer', required=True,
                                choices=['asan', 'msan', 'tsan'])
   parser.add_argument('-v', '--verbose', action='store_true')
   parser.add_argument('--cc')
   parser.add_argument('--cxx')
   parser.add_argument('--patch', default='')
   # This should be a shell script to run before building specific libraries.
   # This will be run after applying the patch above.
-  parser.add_argument('--run-before-build', default='')
+  parser.add_argument('--pre-build', default='')
   parser.add_argument('--build-method', default='destdir')
   parser.add_argument('--sanitizer-blacklist', default='')
   # The LIBDIR argument to configure/make.
   parser.add_argument('--libdir', default='lib')
 
   # 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).
   args = parser.parse_args([arg for arg in sys.argv[1:] if len(arg) != 0])
 
@@ skipping 10 matching lines @@
     builder = LibcapBuilder(args, clobber)
   elif args.build_method == 'custom_libpci3':
     builder = Libpci3Builder(args, clobber)
   else:
     raise Exception('Unrecognized build method: %s' % args.build_method)
 
   builder.download_build_install()
 
 if __name__ == '__main__':
   main()