Make setup.exe compatible with the component build.

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 294 matching lines @@
       'archive_file': archive_file,
       'archive_file_path':
           os.path.join(output_dir, archive_file).replace("\\","/"),
       }
   resource_file = _RESOURCE_FILE_TEMPLATE % args
 
   with open(resource_file_path, 'w') as f:
     f.write(resource_file)
 
 
+# Adds component build DLLs and required config files and manifests in order

[grt (UTC plus 2), 2012/05/11 15:10:50]

?? Adds -> Generates ??

[gab, 2012/05/11 15:56:51]

Yes, but "copies" for the DLLs, let me know if the new comment works for you.

[grt (UTC plus 2), 2012/05/11 17:01:22]

Right on.

+# 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, 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)
+
+  # Copy all the DLLs in |build_dir| to the version directory.
+  dlls = glob.glob(os.path.join(build_dir, '*.dll'))
+  for dll in dlls:
+    shutil.copy(dll, version_dir)
+
+  exe_config = (
+      "<configuration>\n"
+      "  <windows>\n"
+      "    <assemblyBinding xmlns='urn:schemas-microsoft-com:asm.v1'>\n"
+      "        <probing privatePath='{rel_path}'/>\n"
+      "    </assemblyBinding>\n"
+      "  </windows>\n"
+      "</configuration>")
+
+  # Write chrome.exe.config to point to the version directory.
+  chrome_exe_config_file = open(
+      os.path.join(chrome_dir, 'chrome.exe.config'), 'w')
+  chrome_exe_config_file.write(exe_config.format(rel_path=current_version))
+  chrome_exe_config_file.close()
+
+  # Write setup.exe.config to point to the version directory (which is under it
+  # post-install).
+  setup_exe_config_file = open(
+      os.path.join(installer_dir, 'setup.exe.config'), 'w')
+  setup_exe_config_file.write(exe_config.format(rel_path='..'))
+  setup_exe_config_file.close()
+
+  # Build a list containing the name of each DLL found in |build_dir|.
+  dll_names = []
+  for dll in dlls:
+    dll_names.append(os.path.splitext(os.path.basename(dll))[0])
+
+  # Build the manifests for chrome.exe and setup.exe in which we list all the
+  # DLLs as side by side assembly dependencies.
+  # TODO (gab): These extra properties should be merged with the existing
+  # chrome/app/chrome.exe.manifest and
+  # chrome/installer/setup/setup.exe.manifest.
+  exe_manifest_parts = [
+      "<assembly\n"
+      "    xmlns='urn:schemas-microsoft-com:asm.v1' manifestVersion='1.0'>\n"
+      "  <trustInfo xmlns='urn:schemas-microsoft-com:asm.v3'>\n"
+      "    <security>\n"
+      "      <requestedPrivileges>\n"
+      "        <requestedExecutionLevel level='asInvoker' uiAccess='false'/>\n"
+      "      </requestedPrivileges>\n"
+      "    </security>\n"
+      "  </trustInfo>\n"]
+
+  for name in dll_names:
+    exe_manifest_parts.append(
+        "  <dependency>\n"
+        "    <dependentAssembly>\n"
+        "      <assemblyIdentity type='win32' name='chrome.{dll_basename}'\n"
+        "          version='0.0.0.0' processorArchitecture='x86'\n"
+        "          language='*'/>\n"
+        "    </dependentAssembly>\n"
+        "  </dependency>\n".format(dll_basename=name))
+
+  exe_manifest_parts.append("</assembly>")
+  exe_manifest = ''.join(exe_manifest_parts)
+
+  # Write chrome.exe.manifest beside chrome.exe.
+  chrome_exe_manifest_file = open(
+      os.path.join(chrome_dir, 'chrome.exe.manifest'), 'w')
+  chrome_exe_manifest_file.write(exe_manifest)
+  chrome_exe_manifest_file.close()
+
+  # Write setup.exe.manifest beside setup.exe in |version_dir|/Installer.
+  setup_exe_manifest_file = open(
+      os.path.join(installer_dir, 'setup.exe.manifest'), 'w')
+  setup_exe_manifest_file.write(exe_manifest)
+  setup_exe_manifest_file.close()
+
+  # Write chrome.{dllname}.manifest in the version directory for each DLL list
+  # as a dependency in the previous step.
+  # TODO (gab): The properties should probably be merged with the existing
+  # chrome/app/chrome.dll.manifest which could be duplicated for every extra
+  # DLL in the component build.
+  for name in dll_names:
+    dll_manifest = (
+        "<assembly\n"
+        "    xmlns='urn:schemas-microsoft-com:asm.v1' manifestVersion='1.0'>\n"
+        "  <assemblyIdentity name='chrome.{dll_basename}' version='0.0.0.0'\n"
+        "      type='win32' processorArchitecture='x86'/>\n"
+        "  <file name='{dll_basename}.dll'/>\n"
+        "</assembly>".format(dll_basename=name))
+
+    dll_manifest_file = open(os.path.join(
+        version_dir,
+        "chrome.{dll_basename}.manifest".format(dll_basename=name)), 'w')
+    dll_manifest_file.write(dll_manifest)
+    dll_manifest_file.close()
+
+
 def main(options):
   """Main method that reads input file, creates archive file and write
   resource input file.
   """
   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,
                              options.enable_hidpi, options.enable_metro)
 
   # Now copy the remainder of the files from the build dir.
   CopyAllFilesToStagingDir(config, options.distribution,
                            staging_dir, options.build_dir,
                            options.enable_hidpi, options.enable_metro)
 
+  if options.component_build == '1':
+    DoComponentBuildTasks(staging_dir, options.build_dir, current_version)
+
   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,
@@ skipping 35 matching lines @@
   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.')
   parser.add_option('--enable_hidpi', default='0',
       help='Whether to include HiDPI resource files.')
   parser.add_option('--enable_metro', default='0',
       help='Whether to include resource files from the "METRO" section of the '
            'input file.')
+  parser.add_option('--component_build', default='0',
+      help='Whether this archive is packaging a component build.')
 
   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.input_file:
+    parser.error('You must provide an input file')
+
   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)
+    options.resource_file_path = os.path.join(options.build_dir,
+                                              MINI_INSTALLER_INPUT_FILE)
 
   return options
 
 
 if '__main__' == __name__:
   print sys.argv
   sys.exit(main(_ParseOptions()))