Add Windows ASAN bots.

scripts/slave/zip_build.py

 #!/usr/bin/env python
 # 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.
 
 """ Creates a zip file in the staging dir with the result of a compile.
     It can be sent to other machines for testing.
 """
 
 import csv
 import glob
 import optparse
 import os
 import re
 import shutil
 import stat
 import sys
 import tempfile
 
 from common import chromium_utils
 from slave import slave_utils
 
 class StagingError(Exception): pass
 
 
+def ASANFilter(path):
+  """Takes a path to a file and returns the path to its asan'd counterpart.
+
+  Returns None if path is already an asan'd file.
+  Returns the original path otherwise.
+  """
+  head, tail = os.path.split(path)
+  parts = tail.split('.', 1)
+  if len(parts) == 1:
+    return path
+  if parts[-1].startswith('asan'):  # skip 'foo.asan.exe' entirely
+    return None
+  parts.insert(1, 'asan')
+  asan_path = os.path.join(head, '.'.join(parts))
+  if os.path.exists(asan_path):
+    return asan_path
+  return path
+
+
+FILTERS = {
+    'asan': ASANFilter,
+}
+
+
 def CopyDebugCRT(build_dir):
   # Copy the relevant CRT DLLs to |build_dir|. We copy DLLs from all versions
   # of VS installed to make sure we have the correct CRT version, unused DLLs
   # should not conflict with the others anyways.
   crt_dlls = glob.glob(
       'C:\\Program Files (x86)\\Microsoft Visual Studio *\\VC\\redist\\'
       'Debug_NonRedist\\x86\\Microsoft.*.DebugCRT\\*.dll')
   for dll in crt_dlls:
     shutil.copy(dll, build_dir)
 
@@ skipping 151 matching lines @@
     tmp_revision_file.close()
     chromium_utils.MakeWorldReadable(tmp_revision_file.name)
     dest_path = os.path.join(dirname,
                              chromium_utils.FULL_BUILD_REVISION_FILENAME)
     shutil.move(tmp_revision_file.name, dest_path)
   except IOError:
     print 'Writing to revision file in %s failed.' % dirname
 
 
 def MakeUnversionedArchive(build_dir, staging_dir, zip_file_list,
-                           zip_file_name):
+                           zip_file_name, filters):
   """Creates an unversioned full build archive.
   Returns the path of the created archive."""
   (zip_dir, zip_file) = chromium_utils.MakeZip(staging_dir,
                                                zip_file_name,
                                                zip_file_list,
                                                build_dir,
-                                               raise_error=True)
+                                               raise_error=True,
+                                               replacements=filters)
   chromium_utils.RemoveDirectory(zip_dir)
   if not os.path.exists(zip_file):
     raise StagingError('Failed to make zip package %s' % zip_file)
   chromium_utils.MakeWorldReadable(zip_file)
 
   # Report the size of the zip file to help catch when it gets too big and
   # can cause bot failures from timeouts during downloads to testers.
   zip_size = os.stat(zip_file)[stat.ST_SIZE]
   print 'Zip file is %ld bytes' % zip_size
 
@@ skipping 97 matching lines @@
 
   # Build the list of files to archive.
   root_files = os.listdir(build_dir)
   path_filter = PathMatcher(options)
   print path_filter
   print ('\nActually excluded: %s' %
          [f for f in root_files if not path_filter.Match(f)])
 
   zip_file_list = [f for f in root_files if path_filter.Match(f)]
   zip_file = MakeUnversionedArchive(build_dir, staging_dir, zip_file_list,
-                                    unversioned_base_name)
+                                    unversioned_base_name, options.filters)
 
   zip_base, zip_ext = MakeVersionedArchive(zip_file, version_suffix, options)
   PruneOldArchives(staging_dir, zip_base, zip_ext)
 
   # Update the latest revision file in the staging directory
   # to allow testers to figure out the latest packaged revision
   # without downloading tarballs.
   WriteRevisionFile(staging_dir, build_revision)
 
   return 0
 
 
 def main(argv):
   option_parser = optparse.OptionParser()
   option_parser.add_option('--target',
                            help='build target to archive (Debug or Release)')
   option_parser.add_option('--src-dir', default='src',
                            help='path to the top-level sources directory')
   option_parser.add_option('--build-dir', default='chrome',
                            help=('path to main build directory (the parent of '
                                  'the Release or Debug directory)'))
   option_parser.add_option('--exclude-files', default='',
                            help=('Comma separated list of files that should '
                                  'always be excluded from the zip.'))
   option_parser.add_option('--include-files', default='',
                            help=('Comma separated list of files that should '
                                  'always be included in the zip.'))
   option_parser.add_option('--webkit-dir',
                            help='webkit directory path, relative to --src-dir')
+  option_parser.add_option('--filters', action='append', default=[],
+                           help='Filters to apply to build zip '
+                                '(avail: %r).' % list(FILTERS.keys()))
   chromium_utils.AddPropertiesOptions(option_parser)
 
   options, args = option_parser.parse_args(argv)
 
   if not options.target:
     options.target = options.factory_properties.get('target', 'Release')
   if not options.webkit_dir:
     options.webkit_dir = options.factory_properties.get('webkit_dir')
 
   # When option_parser is passed argv as a list, it can return the caller as
   # first unknown arg.  So throw a warning if we have two or more unknown
   # arguments.
   if args[1:]:
     print 'Warning -- unknown arguments' % args[1:]
 
+  if options.factory_properties.get('asan'):
+    options.filters.append('asan')
+  options.filters = [FILTERS[item] for item in set(options.filters)]
+
   return Archive(options)
 
+
 if '__main__' == __name__:
   sys.exit(main(sys.argv))