Instrument setup.exe in the SyzyAsan builds.

chrome/tools/build/win/create_installer_archive.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.
 
 """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 284 matching lines @@
     orig_file = archive_file
 
   compressed_archive_file_path = os.path.join(options.output_dir,
                                               compressed_archive_file)
   CompressUsingLZMA(options.build_dir, compressed_archive_file_path, orig_file,
                     options.verbose)
 
   return compressed_archive_file
 
 
+def CompressUsingMakecab(input_file, output_dir, verbose=False):
+  """ Compress |input_file| with makecab.exe and put the compressed file in
+  |output_dir|, returns the basename of this file.
+  """
+  cmd = ['makecab.exe',
+         '/D', 'CompressionType=LZX',
+         '/V1',
+         '/L', output_dir,
+         input_file,]
+  RunSystemCommand(cmd, verbose)
+  return os.path.basename(input_file)[:-1] + "_"
+
+
 def PrepareSetupExec(options, 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,
                       options.verbose)
   else:
-    cmd = ['makecab.exe',
-           '/D', 'CompressionType=LZX',
-           '/V1',
-           '/L', options.output_dir,
-           os.path.join(options.build_dir, SETUP_EXEC),]
-    RunSystemCommand(cmd, options.verbose)
-    setup_file = SETUP_EXEC[:-1] + "_"
+    setup_file = CompressUsingMakecab(
+        os.path.join(options.build_dir, SETUP_EXEC),

[grt (UTC plus 2), 2017/04/20 09:30:50]

in my checkout, i find that this is compressing the pre-syzyasan setup.exe, not
the one in the syzygy dir. i think you need to plumb through a way for the
script invoker to pass in an optional path to setup.exe, or something, so that
the mini_installer_syzygy target uses syzygy/setup.exe rather than setup.exe. or
am i building it wrong?

C:\src\chromium\src>type out\asan\args.gn
enable_precompiled_headers = false
is_chrome_branded = true
is_debug = false
is_syzyasan = true
target_cpu = "x86"

C:\src\chromium\src>ninja -c out\asan mini_installer_syzygy

+        options.output_dir,
+        options.verbose)
   return setup_file
 
 
 _RESOURCE_FILE_HEADER = """\
 // 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
 // lines:
 // - The first line contains the output filename (without path) and the
 // type of the resource ('BN' - not compressed , 'BL' - LZ compressed,
@@ skipping 18 matching lines @@
     setup_resource_type = "B7"
 
   # An array of (file, type, path) tuples of the files to be included.
   resources = []
   resources.append((setup_file, setup_resource_type,
                     os.path.join(output_dir, setup_file)))
   resources.append((archive_file, 'B7',
                     os.path.join(output_dir, archive_file)))
   # Include all files needed to run setup.exe (these are copied into the
   # 'Installer' dir by DoComponentBuildTasks).
-  if component_build:
-    installer_dir = os.path.join(staging_dir, CHROME_DIR, current_version,
-                                 'Installer')
-    for file in os.listdir(installer_dir):
+  installer_dir = os.path.join(staging_dir, CHROME_DIR, current_version,
+                               'Installer')
+  for file in os.listdir(installer_dir):
+    if component_build:
       resources.append((file, 'BN', os.path.join(installer_dir, file)))
+    else:
+      resources.append((file, 'BL', os.path.join(installer_dir, file)))
 
   with open(resource_file_path, 'w') as f:
     f.write(_RESOURCE_FILE_HEADER)
     for (file, type, path) in resources:
       f.write('\n%s  %s\n    "%s"\n' % (file, type, path.replace("\\","/")))
 
 
 # Reads |manifest_name| from |build_dir| and writes |manifest_name| to
 # |output_dir| with the same content plus |inserted_string| added just before
 # |insert_before|.
@@ skipping 77 matching lines @@
 def ParseDLLsFromDeps(build_dir, runtime_deps_file):
   """Parses the runtime_deps file and returns the set of DLLs in it, relative
   to build_dir."""
   build_dlls = set()
   args = open(runtime_deps_file).read()
   for l in args.splitlines():
     if os.path.splitext(l)[1] == ".dll":
       build_dlls.add(os.path.join(build_dir, l))
   return build_dlls
 
+
+def CopySetupRuntimeDeps(build_dir, setup_runtime_deps, version_dir,
+                         component_build):
+  """Copy the setup.exe runtime dependencies to the installer's directory."""
+  installer_dir = os.path.join(version_dir, 'Installer')
+  # |installer_dir| is technically only created post-install, but we need it
+  # now to add setup.exe's config and manifest to the archive.
+  if not os.path.exists(installer_dir):
+    os.mkdir(installer_dir)
+
+  setup_component_dlls = ParseDLLsFromDeps(build_dir, setup_runtime_deps)
+  for setup_component_dll in setup_component_dlls:
+    if component_build:
+      input_name = setup_component_dll
+      shutil.copy(input_name, installer_dir)
+    else:
+      input_name = CompressUsingMakecab(setup_component_dll, installer_dir)
+    g_archive_inputs.append(input_name)
+
+
 # Copies component build DLLs and generates required config files and manifests
 # in order for chrome.exe and setup.exe to be able to find those DLLs at
 # run-time.
 # This is meant for developer builds only and should never be used to package
 # an official build.
 def DoComponentBuildTasks(staging_dir, build_dir, target_arch,
                           setup_runtime_deps, chrome_runtime_deps,
                           current_version):
   # Get the required directories for the upcoming operations.
   chrome_dir = os.path.join(staging_dir, CHROME_DIR)
   version_dir = os.path.join(chrome_dir, current_version)
-  installer_dir = os.path.join(version_dir, 'Installer')
-  # |installer_dir| is technically only created post-install, but we need it
-  # now to add setup.exe's config and manifest to the archive.
-  if not os.path.exists(installer_dir):
-    os.mkdir(installer_dir)
 
-  setup_component_dlls = ParseDLLsFromDeps(build_dir, setup_runtime_deps)
-
-  for setup_component_dll in setup_component_dlls:
-    g_archive_inputs.append(setup_component_dll)
-    shutil.copy(setup_component_dll, installer_dir)
+  CopySetupRuntimeDeps(build_dir, setup_runtime_deps, version_dir, True)
 
   # Stage all the component DLLs to the |version_dir| (for
   # the version assembly to be able to refer to them below and make sure
   # chrome.exe can find them at runtime), except the ones that are already
   # staged (i.e. non-component DLLs).
   build_dlls = ParseDLLsFromDeps(build_dir, chrome_runtime_deps)
   staged_dll_basenames = [os.path.basename(staged_dll) for staged_dll in \
                           glob.glob(os.path.join(version_dir, '*.dll'))]
   component_dll_filenames = []
   for component_dll in [dll for dll in build_dlls if \
@@ skipping 39 matching lines @@
 
   # Now copy the remainder of the files from the build dir.
   CopyAllFilesToStagingDir(config, options.distribution,
                            staging_dir, options.build_dir,
                            options.enable_hidpi)
 
   if options.component_build == '1':
     DoComponentBuildTasks(staging_dir, options.build_dir,
                           options.target_arch, options.setup_runtime_deps,
                           options.chrome_runtime_deps, current_version)
+  elif options.setup_runtime_deps:
+    CopySetupRuntimeDeps(options.build_dir, options.setup_runtime_deps,
+                         os.path.join(staging_dir, CHROME_DIR, current_version),
+                         options.component_build=='1')
 
   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
@@ skipping 88 matching lines @@
                                               MINI_INSTALLER_INPUT_FILE)
 
   return options
 
 
 if '__main__' == __name__:
   options = _ParseOptions()
   if options.verbose:
     print sys.argv
   sys.exit(main(options))