Add support for create_installer_archive.py to generate a depfile

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 24 matching lines @@
 COMPRESSED_FILE_EXT = ".packed.7z"     # extension of patch archive file
 COURGETTE_EXEC = "courgette.exe"
 MINI_INSTALLER_INPUT_FILE = "packed_files.txt"
 PATCH_FILE_EXT = '.diff'
 SETUP_EXEC = "setup.exe"
 SETUP_PATCH_FILE_PREFIX = "setup_patch"
 TEMP_ARCHIVE_DIR = "temp_installer_archive"
 VERSION_FILE = "VERSION"
 
 
+g_archive_inputs = []
+
+
 def BuildVersion(build_dir):
   """Returns the full build version string constructed from information in
   VERSION_FILE.  Any segment not found in that file will default to '0'.
   """
   major = 0
   minor = 0
   build = 0
   patch = 0
   for line in open(os.path.join(build_dir, '../../chrome', VERSION_FILE), 'r'):
     line = line.rstrip()
@@ skipping 59 matching lines @@
     if option.endswith('dir'):
       continue
 
     dst_dir = os.path.join(staging_dir, config.get(section, option))
     src_paths = glob.glob(os.path.join(src_dir, option))
     if src_paths and not os.path.exists(dst_dir):
       os.makedirs(dst_dir)
     for src_path in src_paths:
       dst_path = os.path.join(dst_dir, os.path.basename(src_path))
       if not os.path.exists(dst_path):
+        g_archive_inputs.append(src_path)
         shutil.copy(src_path, dst_dir)
 
 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 53 matching lines @@
     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.output_dir,
                               options.output_name + ARCHIVE_SUFFIX)
+  if options.depfile:
+    # If a depfile was requested, do the glob of the staging dir and generate
+    # a list of dependencies in .d format. We list the files that were copied
+    # into the staging dir, not the files that are actually in the staging dir
+    # because the ones in the staging dir will never be edited, and we want
+    # to have the build be triggered when the thing-that-was-copied-there
+    # changes.
+
+    def path_fixup(path):
+      """Fixes path for depfile format: backslash to forward slash, and
+      backslash escaping for spaces."""
+      return path.replace('\\', '/').replace(' ', '\\ ')
+
+    # Gather the list of files in the staging dir that will be zipped up. We
+    # only gather this list to make sure that g_archive_inputs is complete (i.e.
+    # that there's not file copies that got missed).
+    staging_contents = []
+    for root, dirs, files in os.walk(os.path.join(staging_dir, CHROME_DIR)):
+      for filename in files:
+        staging_contents.append(path_fixup(os.path.join(root, filename)))
+
+    # Make sure there's an archive_input for each staging dir file.
+    for staging_file in staging_contents:
+      for archive_input in g_archive_inputs:
+        archive_rel = path_fixup(archive_input)
+        if (os.path.basename(staging_file).lower() ==
+            os.path.basename(archive_rel).lower()):
+          break
+      else:
+        raise Exception('Did not find an archive input file for "%s"' %
+                        staging_file)
+
+    # Finally, write the depfile referencing the inputs.
+    with open(options.depfile, 'wb') as f:
+      f.write(path_fixup(os.path.relpath(archive_file, options.build_dir)) +
+              ': \\\n')
+      f.write('  ' + ' \\\n  '.join(path_fixup(x) for x in g_archive_inputs))
+
   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):
     RunSystemCommand(cmd)
@@ skipping 136 matching lines @@
     f.write(''.join(manifest_lines))
 
 
 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))
+  g_archive_inputs.append(src)
   if os.path.exists(dest):
     # We assume the files are OK to buffer fully into memory since we know
     # they're only 1-2M.
     with open(src, 'rb') as fsrc:
       src_data = fsrc.read()
     with open(dest, 'rb') as fdest:
       dest_data = fdest.read()
     if src_data != dest_data:
       # This may still raise if we get here, but this really should almost
       # never happen (it would mean that the contents of e.g. msvcr100d.dll
@@ skipping 81 matching lines @@
   setup_component_dll_globs = [ 'base.dll',
                                 'boringssl.dll',
                                 'crcrypto.dll',
                                 'icui18n.dll',
                                 'icuuc.dll',
                                 'msvc*.dll' ]
   for setup_component_dll_glob in setup_component_dll_globs:
     setup_component_dlls = glob.glob(os.path.join(build_dir,
                                                   setup_component_dll_glob))
     for setup_component_dll in setup_component_dlls:
+      g_archive_inputs.append(setup_component_dll)
       shutil.copy(setup_component_dll, installer_dir)
 
   # Stage all the component DLLs found in |build_dir| 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). The component DLLs are considered to
   # be all the DLLs which have not already been added to the |version_dir| by
   # virtue of chrome.release.
   build_dlls = glob.glob(os.path.join(build_dir, '*.dll'))
   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 \
                         os.path.basename(dll) not in staged_dll_basenames]:
     component_dll_name = os.path.basename(component_dll)
     # remoting_*.dll's don't belong in the archive (it doesn't depend on them
     # in gyp). Trying to copy them causes a build race when creating the
     # installer archive in component mode. See: crbug.com/180996
     if component_dll_name.startswith('remoting_'):
       continue
     component_dll_filenames.append(component_dll_name)
+    g_archive_inputs.append(component_dll)
     shutil.copy(component_dll, version_dir)
 
   # Augment {version}.manifest to include all component DLLs as part of the
   # assembly it constitutes, which will allow dependents of this assembly to
   # find these DLLs.
   version_assembly_dll_additions = []
   for dll_filename in component_dll_filenames:
     version_assembly_dll_additions.append("  <file name='%s'/>" % dll_filename)
   CopyAndAugmentManifest(build_dir, version_dir,
                          '%s.manifest' % current_version,
@@ skipping 83 matching lines @@
       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('--component_build', default='0',
       help='Whether this archive is packaging a component build. This will '
            'also turn off compression of chrome.7z into chrome.packed.7z and '
            'helpfully delete any old chrome.packed.7z in |output_dir|.')
+  parser.add_option('--depfile',
+      help='Generate a depfile with the given name listing the implicit inputs '
+           'to the archive process that can be used with a build system.')
   parser.add_option('--target_arch', default='x86',
       help='Specify the target architecture for installer - this is used '
            'to determine which CRT runtime files to pull and package '
            'with the installer archive {x86|x64}.')
 
   options, _ = parser.parse_args()
   if not options.build_dir:
     parser.error('You must provide a build dir.')
 
   options.build_dir = os.path.normpath(options.build_dir)
@@ skipping 10 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()))