Build a Syzygy-reordered mini_installer.exe.

chrome/tools/build/win/create_installer_archive.py

 #!/usr/bin/python
 # Copyright (c) 2011 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.
 
 """Script to create Chrome Installer archive.
 
   This script is used to create an archive of all the files required for a
   Chrome install in appropriate directory structure. It reads chrome.release
   file as input, creates chrome.7z archive, compresses setup.exe and
@@ skipping 97 matching lines @@
   specified to staging dir.
   """
   for option in config.options(section):
     if option.endswith('dir'):
       continue
 
     dst = os.path.join(staging_dir, config.get(section, option))
     if not os.path.exists(dst):
       os.makedirs(dst)
     for file in glob.glob(os.path.join(build_dir, option)):
-      shutil.copy(file, dst)
+      dst_file = os.path.join(dst, os.path.basename(file))
+      if not os.path.exists(dst_file):
+        shutil.copy(file, dst)
 
 def GenerateDiffPatch(options, orig_file, new_file, patch_file):
   if (options.diff_algorithm == "COURGETTE"):
     exe_file = os.path.join(options.last_chrome_installer, COURGETTE_EXEC)
     cmd = '%s -gen "%s" "%s" "%s"' % (exe_file, orig_file, new_file, patch_file)
   else:
     exe_file = os.path.join(options.build_dir, BSDIFF_EXEC)
     cmd = [exe_file, orig_file, new_file, patch_file,]
   RunSystemCommand(cmd)
 
@@ skipping 50 matching lines @@
   exit_code = subprocess.call(cmd)
   if (exit_code != 0):
     raise Exception("Error while running cmd: %s, exit_code: %s" %
                     (cmd, exit_code))
 
 def CreateArchiveFile(options, staging_dir, current_version, prev_version):
   """Creates a new installer archive file after deleting any existing old file.
   """
   # First create an uncompressed archive file for the current build (chrome.7z)
   lzma_exec = GetLZMAExec(options.build_dir)
-  archive_file = os.path.join(options.build_dir,
+  archive_file = os.path.join(options.output_dir,
                               options.output_name + ARCHIVE_SUFFIX)
   cmd = [lzma_exec,
          'a',
          '-t7z',
          archive_file,
          os.path.join(staging_dir, CHROME_DIR),
          '-mx0',]
   # There doesnt seem to be any way in 7za.exe to override existing file so
   # we always delete before creating a new one.
   if not os.path.exists(archive_file):
@@ skipping 13 matching lines @@
                                                   PATCH_FILE_EXT)
     GenerateDiffPatch(options, prev_archive_file, archive_file, patch_file)
     compressed_archive_file = patch_name_prefix + '_' + \
                               current_version + '_from_' + prev_version + \
                               COMPRESSED_FILE_EXT
     orig_file = patch_file
   else:
     compressed_archive_file = options.output_name + COMPRESSED_ARCHIVE_SUFFIX
     orig_file = archive_file
 
-  compressed_archive_file_path = os.path.join(options.build_dir,
+  compressed_archive_file_path = os.path.join(options.output_dir,
                                               compressed_archive_file)
   CompressUsingLZMA(options.build_dir, compressed_archive_file_path, orig_file)
 
   return compressed_archive_file
 
 
 def PrepareSetupExec(options, staging_dir, current_version, prev_version):
   """Prepares setup.exe for bundling in mini_installer based on options."""
   if options.setup_exe_format == "FULL":
     setup_file = SETUP_EXEC
   elif options.setup_exe_format == "DIFF":
     if not options.last_chrome_installer:
       raise Exception(
           "To use DIFF for setup.exe, --last_chrome_installer is needed.")
     prev_setup_file = os.path.join(options.last_chrome_installer, SETUP_EXEC)
     new_setup_file = os.path.join(options.build_dir, SETUP_EXEC)
     patch_file = os.path.join(options.build_dir, SETUP_PATCH_FILE_PREFIX +
                                                   PATCH_FILE_EXT)
     GenerateDiffPatch(options, prev_setup_file, new_setup_file, patch_file)
     setup_file = SETUP_PATCH_FILE_PREFIX + '_' + current_version + \
                  '_from_' + prev_version + COMPRESSED_FILE_EXT
     setup_file_path = os.path.join(options.build_dir, setup_file)
     CompressUsingLZMA(options.build_dir, setup_file_path, patch_file)
   else:
     cmd = ['makecab.exe',
            '/D', 'CompressionType=LZX',
            '/V1',
-           '/L', options.build_dir,
+           '/L', options.output_dir,
            os.path.join(options.build_dir, SETUP_EXEC),]
     RunSystemCommand(cmd)
     setup_file = SETUP_EXEC[:-1] + "_"
   return setup_file
 
 
 _RESOURCE_FILE_TEMPLATE = """\
 // This file is automatically generated by create_installer_archive.py.
 // It contains the resource entries that are going to be linked inside
 // mini_installer.exe. For each file to be linked there should be two
@@ skipping 47 matching lines @@
   """
   current_version = BuildVersion(options.build_dir)
 
   config = Readconfig(options.build_dir, options.input_file, current_version)
 
   (staging_dir, temp_dir) = MakeStagingDirectories(options.staging_dir)
 
   prev_version = GetPrevVersion(options.build_dir, temp_dir,
                                 options.last_chrome_installer)
 
+  # Preferentially copy the files we can find from the output_dir, as
+  # this is where we'll find the Syzygy-optimized executables when
+  # building the optimized mini_installer.
+  if options.build_dir != options.output_dir:
+    CopyAllFilesToStagingDir(config, options.distribution,
+                             staging_dir, options.output_dir)
+
+  # Now copy the remainder of the files from the build dir.
   CopyAllFilesToStagingDir(config, options.distribution,
                            staging_dir, options.build_dir)
 
   version_numbers = current_version.split('.')
   current_build_number = version_numbers[2] + '.' + version_numbers[3]
   prev_build_number = ''
   if prev_version:
     version_numbers = prev_version.split('.')
     prev_build_number = version_numbers[2] + '.' + version_numbers[3]
 
   # Name of the archive file built (for example - chrome.7z or
   # patch-<old_version>-<new_version>.7z or patch-<new_version>.7z
   archive_file = CreateArchiveFile(options, staging_dir,
                                    current_build_number, prev_build_number)
 
   setup_file = PrepareSetupExec(options, staging_dir,
                                 current_build_number, prev_build_number)
 
   CreateResourceInputFile(options.build_dir, options.setup_exe_format,
                           archive_file, setup_file, options.resource_file_path)
 
 def _ParseOptions():
   parser = optparse.OptionParser()
   parser.add_option('-i', '--input_file',
       help='Input file describing which files to archive.')
-  parser.add_option('-o', '--build_dir',
+  parser.add_option('-b', '--build_dir',
       help='Build directory. The paths in input_file are relative to this.')
   parser.add_option('--staging_dir',
       help='Staging directory where intermediate files and directories '
            'will be created'),
+  parser.add_option('-o', '--output_dir',
+      help='The output directory where the archives will be written. '
+            'Defaults to the build_dir.')
   parser.add_option('--resource_file_path',
       help='The path where the resource file will be output. '
            'Defaults to %s in the build directory.' %
                MINI_INSTALLER_INPUT_FILE),
   parser.add_option('-d', '--distribution',
       help='Name of Chromium Distribution. Optional.')
   parser.add_option('-s', '--skip_rebuild_archive',
       default="False", help='Skip re-building Chrome.7z archive if it exists.')
   parser.add_option('-l', '--last_chrome_installer',
       help='Generate differential installer. The value of this parameter '
            'specifies the directory that contains base versions of '
            'setup.exe, courgette.exe (if --diff_algorithm is COURGETTE) '
            '& chrome.7z.')
   parser.add_option('-f', '--setup_exe_format', default='COMPRESSED',
       help='How setup.exe should be included {COMPRESSED|DIFF|FULL}.')
   parser.add_option('-a', '--diff_algorithm', default='BSDIFF',
       help='Diff algorithm to use when generating differential patches '
            '{BSDIFF|COURGETTE}.')
   parser.add_option('-n', '--output_name', default='chrome',
       help='Name used to prefix names of generated archives.')
 
   options, args = parser.parse_args()
-
   if not options.build_dir:
     parser.error('You must provide a build dir.')
 
   if not options.staging_dir:
     parser.error('You must provide a staging dir.')
 
+  if not options.output_dir:
+    options.output_dir = options.build_dir
+
   if not options.resource_file_path:
     options.options.resource_file_path = os.path.join(options.build_dir,
                                                       MINI_INSTALLER_INPUT_FILE)
 
-  print sys.argv
   return options
 
 
 if '__main__' == __name__:
+  print sys.argv
   sys.exit(main(_ParseOptions()))