Add GN rules for building instrumented libraries.

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 ast
 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))
+  if not s:
+    return ''
+  try:
+    return ' '.join(ast.literal_eval(s))
+  except (SyntaxError, ValueError):
+    return ' '.join(shlex.split(s))
 
 
 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 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_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._extra_configure_flags = unescape_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._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(
@@ skipping 52 matching lines @@
       raise Exception('Failed to run: %s' % command)
 
   def maybe_download_source(self):
     """Checks out the source code (if needed).
 
     Checks out the source code for the package, if required (i.e. unless running
     in no-clobber mode). Initializes self._source_dir and self._source_archives.
     """
     get_fresh_source = self._clobber or not os.path.exists(self._working_dir)
     if get_fresh_source:
-      self.shell_call('rm -rf %s' % self._working_dir)
+      shutil.rmtree(self._working_dir, ignore_errors=True)
       os.makedirs(self._working_dir)
       self.shell_call('apt-get source %s' % self._package,
                       cwd=self._working_dir)
 
     (dirpath, dirnames, filenames) = os.walk(self._working_dir).next()
 
     if len(dirnames) != 1:
       raise Exception(
           '`apt-get source %s\' must create exactly one subdirectory.'
               % self._package)
@@ skipping 12 matching lines @@
       self.shell_call('patch -p1 -i %s' % self._patch, 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)
+    shutil.rmtree(self._source_archives_dir, ignore_errors=True)
     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())
+    if not os.path.exists(self.dest_libdir()):
+      os.makedirs(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/scripts/' \
             'install-build-deps.sh?' % \
             self._package
       print
       raise
@@ skipping 184 matching lines @@
     # Make sure we don't override the default flags in the makefile.
     for variable in ['CFLAGS', 'CXXFLAGS', 'LDFLAGS']:
       del self._build_env[variable]
 
     # Hardcoded paths.
     temp_dir = os.path.join(self._source_dir, 'nss')
     temp_libdir = os.path.join(temp_dir, 'lib')
 
     # Parallel build is not supported. Also, the build happens in
     # <source_dir>/nss.
-    self.make(make_args, jobs=1, cwd=temp_dir)
+    try:
+      self.make(make_args, jobs=1, cwd=temp_dir)
+    except Exception:
+      # Building fails after all the required DSOs have been built, so ignore
+      # the error.
+      pass
 
     self.fix_rpaths(temp_libdir)
 
     # 'make install' is not supported. Copy the DSOs manually.
     for (dirpath, dirnames, filenames) in os.walk(temp_libdir):
       for filename in filenames:
         if filename.endswith('.so'):
           full_path = os.path.join(dirpath, filename)
           if self._verbose:
             print 'download_build_install.py: installing %s' % full_path
           shutil.copy(full_path, self.dest_libdir())
 
 
+class StubBuilder(InstrumentedPackageBuilder):
+  def download_build_install(self):
+    self._touch(os.path.join(self._destdir, '%s.txt' % self._package))
+    self._touch(os.path.join(self.dest_libdir(), '%s.so.0' % self._package))
+
+  def _touch(self, path):
+    with open(path, 'w'):
+      pass
+
+
 def main():
   parser = argparse.ArgumentParser(
       description='Download, build and install an instrumented package.')
 
   parser.add_argument('-j', '--jobs', type=int, default=1)
   parser.add_argument('-p', '--package', required=True)
   parser.add_argument(
       '-i', '--product-dir', default='.',
       help='Relative path to the directory with chrome binaries')
   parser.add_argument(
@@ skipping 27 matching lines @@
         (os.environ.get('INSTRUMENTED_LIBRARIES_NO_CLOBBER', '') != '1')
 
   if args.build_method == 'destdir':
     builder = InstrumentedPackageBuilder(args, clobber)
   elif args.build_method == 'custom_nss':
     builder = NSSBuilder(args, clobber)
   elif args.build_method == 'custom_libcap':
     builder = LibcapBuilder(args, clobber)
   elif args.build_method == 'custom_libpci3':
     builder = Libpci3Builder(args, clobber)
+  elif args.build_method == 'stub':
+    builder = StubBuilder(args, clobber)
   else:
     raise Exception('Unrecognized build method: %s' % args.build_method)
 
   builder.download_build_install()
 
 if __name__ == '__main__':
   main()