Initial implementation of Chrome Early Loading Framework

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 330 matching lines @@
         insert_before, ''.join(manifest_lines)))
   old = manifest_lines[insert_line]
   manifest_lines[insert_line] = (old[:insert_pos] + inserted_string +
                                  old[insert_pos:])
 
   modified_manifest_file = open(
       os.path.join(output_dir, manifest_name), 'w')
   modified_manifest_file.write(''.join(manifest_lines))
   modified_manifest_file.close()
 
+def AddVersionAssemblyManifest(staging_dir, current_version):
+  """Creates a manifest file, {current_version}.manifest, and places it in the
+  VersionDir, so that chrome.exe can find the chrome_elf dll.
+  """
+  # 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)
+
+  version_manifest = (
+      "<assembly\n"
+      "    xmlns='urn:schemas-microsoft-com:asm.v1' manifestVersion='1.0'>\n"
+      "  <assemblyIdentity name='{version}' version='{version}'\n"
+      "      type='win32'/>\n"
+      "  <file name='chrome_elf.dll'/>\n"
+      "</assembly>".format(version=current_version))
+
+  manifest_name = "%s.manifest" % current_version
+
+  with open(os.path.join(version_dir, manifest_name), 'w') as f:

[gab, 2013/11/05 16:43:20]

I'm guessing this automatically closes |f| when it goes out of scope?

[grt (UTC plus 2), 2013/11/05 20:56:06]

at the end of the scope opened by the "with", yes.

+    f.write(version_manifest)
+
 
 def CopyIfChanged(src, target_dir):
   """Copy specified |src| file to |target_dir|, but only write to target if
   the file has changed. This avoids a problem during packaging where parts of
   the build have not completed and have the runtime DLL locked when we try to
   copy over it. See http://crbug.com/305877 for details."""
   assert os.path.isdir(target_dir)
   dest = os.path.join(target_dir, os.path.basename(src))
   if os.path.exists(dest):
     # We assume the files are OK to buffer fully into memory since we know
@@ skipping 189 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, options.enable_touch_ui)
 
   if options.component_build == '1':
     DoComponentBuildTasks(staging_dir, options.build_dir,
                           options.target_arch, current_version)
 
+  AddVersionAssemblyManifest(staging_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 69 matching lines @@
   if not options.resource_file_path:
     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()))