Instrumented libraries: bundle the full source code with each build.

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 40 matching lines @@
         real_path(args.run_before_build) if args.run_before_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(
+        product_dir, 'instrumented_libraries', 'sources', self._package)
 
     self._cflags = unescape_flags(args.cflags)
     if args.sanitizer_blacklist:
       blacklist_file = real_path(args.sanitizer_blacklist)
       self._cflags += ' -fsanitize-blacklist=%s' % blacklist_file
 
     self._ldflags = unescape_flags(args.ldflags)
 
     self.init_build_env()
 
     # Initialized later.
     self._source_dir = None
+    self._source_archives = None
 
   def init_build_env(self):
     self._build_env = os.environ.copy()
 
     self._build_env['CC'] = self._cc
     self._build_env['CXX'] = self._cxx
 
     self._build_env['CFLAGS'] = self._cflags
     self._build_env['CXXFLAGS'] = self._cflags
     self._build_env['LDFLAGS'] = self._ldflags
@@ skipping 15 matching lines @@
     child = subprocess.Popen(
         command, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
         env=env, shell=True, cwd=cwd)
     stdout, stderr = child.communicate()
     if self._verbose or child.returncode:
       print stdout
     if child.returncode:
       raise Exception('Failed to run: %s' % command)
 
   def maybe_download_source(self):
-    """Checks out the source code (if needed) and sets self._source_dir."""
+    """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)
       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.'
+      raise Exception(
+          '`apt-get source %s\' must create exactly one subdirectory.'
+              % self._package)
+    self._source_dir = os.path.join(dirpath, dirnames[0], '')
+
+    if len(filenames) == 0:
+      raise Exception('Can\'t find source archives after `apt-get source %s\'.'
          % self._package)
-    self._source_dir = os.path.join(dirpath, dirnames[0], '')
+    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)
 
+  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?' % \
             self._package
       print
@@ skipping 243 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()