Add a 'filter' option to zip_build to allow for build post-processing.

scripts/common/chromium_utils.py

 # 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.
 
 """ Set of basic operations/utilities that are used by the build. """
 
 import copy
 import errno
 import fnmatch
 import glob
@@ skipping 457 matching lines @@
   if not os.path.isdir(dest_dir):
     raise PathNotFound('Unable to find dir %s' % dest_dir)
   src_file = os.path.basename(src_path)
   if dest_fn:
     shutil.copy(src_path, os.path.join(dest_dir, dest_fn))
   else:
     shutil.copy(src_path, os.path.join(dest_dir, src_file))
 
 
 def MakeZip(output_dir, archive_name, file_list, file_relative_dir,
-            raise_error=True, remove_archive_directory=True):
+            raise_error=True, remove_archive_directory=True, path_filter=None):
   """Packs files into a new zip archive.
 
   Files are first copied into a directory within the output_dir named for
   the archive_name, which will be created if necessary and emptied if it
   already exists.  The files are then then packed using archive names
   relative to the output_dir.  That is, if the zipfile is unpacked in place,
   it will create a directory identical to the new archiev_name directory, in
   the output_dir.  The zip file will be named as the archive_name, plus
   '.zip'.
 
   Args:
     output_dir: Absolute path to the directory in which the archive is to
       be created.
     archive_dir: Subdirectory of output_dir holding files to be added to
       the new zipfile.
     file_list: List of paths to files or subdirectories, relative to the
       file_relative_dir.
     file_relative_dir: Absolute path to the directory containing the files
       and subdirectories in the file_list.
     raise_error: Whether to raise a PathNotFound error if one of the files in
       the list is not found.
     remove_archive_directory: Whether to remove the archive staging directory
       before copying files over to it.
+    path_filter: A function f(path) -> path. For each file to add, transform
+      the path with the path_filter function, and read data from the resulting
+      file instead. i.e. foo.exe could actually contain data from foo.asan.exe.
 
   Returns:
     A tuple consisting of (archive_dir, zip_file_path), where archive_dir
     is the full path to the newly created archive_name subdirectory.
 
   Raises:
     PathNotFound if any of the files in the list is not found, unless
     raise_error is False, in which case the error will be ignored.
   """
 
   # Collect files into the archive directory.
   archive_dir = os.path.join(output_dir, archive_name)
   if remove_archive_directory and os.path.exists(archive_dir):
     # Move it even if it's not a directory as expected. This can happen with
     # FILES.cfg archive creation where we create an archive staging directory
     # that is the same name as the ultimate archive name.
     if not os.path.isdir(archive_dir):
       print 'Moving old "%s" file to create same name directory.' % archive_dir
       previous_archive_file = '%s.old' % archive_dir
       MoveFile(archive_dir, previous_archive_file)
     else:
       RemoveDirectory(archive_dir)
   MaybeMakeDirectory(archive_dir)
   for needed_file in file_list:
     needed_file = needed_file.rstrip()
     # These paths are relative to the file_relative_dir.  We need to copy
     # them over maintaining the relative directories, where applicable.
     src_path = os.path.join(file_relative_dir, needed_file)
+    if path_filter:
+      new_src_path = path_filter(src_path)
+      if new_src_path is None:
+        print 'Skipping %s' % src_path
+        continue
+      if new_src_path != src_path:
+        print 'Replacing contents of %s with %s' % (src_path, new_src_path)
+      src_path = new_src_path
     dirname, basename = os.path.split(needed_file)
     try:
       if os.path.isdir(src_path):
         shutil.copytree(src_path, os.path.join(archive_dir, needed_file),
                         symlinks=True)
       elif dirname != '' and basename != '':
         dest_dir = os.path.join(archive_dir, dirname)
         MaybeMakeDirectory(dest_dir)
-        CopyFileToDir(src_path, dest_dir)
+        CopyFileToDir(src_path, dest_dir, basename)
       else:
-        CopyFileToDir(src_path, archive_dir)
+        CopyFileToDir(src_path, archive_dir, basename)
     except PathNotFound:
       if raise_error:
         raise
 
   # Pack the zip file.
   output_file = '%s.zip' % archive_dir
   previous_file = '%s_old.zip' % archive_dir
   MoveFile(output_file, previous_file)
   # On Windows we use the python zip module; on Linux and Mac, we use the zip
   # command as it will handle links and file bits (executable).  Which is much
@@ skipping 566 matching lines @@
     conn.close()
 
   return rev, 'ok'
 
 
 def AbsoluteCanonicalPath(*path):
   """Return the most canonical path Python can provide."""
 
   file_path = os.path.join(*path)
   return os.path.realpath(os.path.abspath(os.path.expanduser(file_path)))