Fix create_installer_archive.py to be more flexible with output directory names

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 334 matching lines @@
 
   modified_manifest_file = open(
       os.path.join(output_dir, manifest_name), 'w')
   modified_manifest_file.write(''.join(manifest_lines))
   modified_manifest_file.close()
 
 
 # Copy the relevant CRT DLLs to |build_dir|. We copy DLLs from all versions
 # of VS installed to make sure we have the correct CRT version, unused DLLs
 # should not conflict with the others anyways.
-def CopyVisualStudioRuntimeDLLs(build_dir):
-  is_debug = os.path.basename(build_dir) == 'Debug'
-  if not is_debug and os.path.basename(build_dir) != 'Release':
+def CopyVisualStudioRuntimeDLLs(build_dir, target_arch):
+  is_debug = os.path.basename(build_dir).startswith('Debug')
+  if not is_debug and not os.path.basename(build_dir).startswith('Release'):
     print ("Warning: could not determine build configuration from "
            "output directory, assuming Release build.")
 
   crt_dlls = []
+  sys_dll_dir = None
   if is_debug:
     crt_dlls = glob.glob(
         "C:/Program Files (x86)/Microsoft Visual Studio */VC/redist/"
-        "Debug_NonRedist/x86/Microsoft.*.DebugCRT/*.dll")
+        "Debug_NonRedist/" + target_arch + "/Microsoft.*.DebugCRT/*.dll")
   else:
     crt_dlls = glob.glob(
-        "C:/Program Files (x86)/Microsoft Visual Studio */VC/redist/x86/"
-        "Microsoft.*.CRT/*.dll")
+        "C:/Program Files (x86)/Microsoft Visual Studio */VC/redist/" +
+        target_arch + "/Microsoft.*.CRT/*.dll")
 
   # Also handle the case where someone is building using only winsdk and
   # doesn't have Visual Studio installed.
   if not crt_dlls:
-    # On a 64-bit system, 32-bit dlls are in SysWOW64 (don't ask).
-    if os.access("C:/Windows/SysWOW64", os.F_OK):
-      sys_dll_dir = "C:/Windows/SysWOW64"
+    if target_arch == 'x64':
+      # check we are are on a 64bit system by existence of WOW64 dir
+      if os.access("C:/Windows/SysWOW64", os.F_OK):
+        sys_dll_dir = "C:/Windows/System32"
+      else:
+        # only support packaging of 64bit installer on 64bit system
+        # but this just as bad as not finding DLLs at all so we
+        # don't abort here to mirror behavior below
+        print ("Warning: could not find x64 CRT DLLs on x86 system.")
     else:
-      sys_dll_dir = "C:/Windows/System32"
+      # On a 64-bit system, 32-bit dlls are in SysWOW64 (don't ask).
+      if os.access("C:/Windows/SysWOW64", os.F_OK):
+        sys_dll_dir = "C:/Windows/SysWOW64"
+      else:
+        sys_dll_dir = "C:/Windows/System32"
 
-    if is_debug:
-      crt_dlls = glob.glob(os.path.join(sys_dll_dir, "msvc*0d.dll"))
-    else:
-      crt_dlls = glob.glob(os.path.join(sys_dll_dir, "msvc*0.dll"))
+    if sys_dll_dir is not None:
+      if is_debug:
+        crt_dlls = glob.glob(os.path.join(sys_dll_dir, "msvc*0d.dll"))
+      else:
+        crt_dlls = glob.glob(os.path.join(sys_dll_dir, "msvc*0.dll"))
 
   if not crt_dlls:
     print ("Warning: could not find CRT DLLs to copy to build dir - target "
            "may not run on a system that doesn't have those DLLs.")
 
   for dll in crt_dlls:
     shutil.copy(dll, build_dir)
 
 
 # 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, current_version):
+def DoComponentBuildTasks(staging_dir, build_dir, target_arch, 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 the VS CRT DLLs to |build_dir|. This must be done before the general
   # copy step below to ensure the CRT DLLs are added to the archive and marked
   # as a dependency in the exe manifests generated below.
-  CopyVisualStudioRuntimeDLLs(build_dir)
+  CopyVisualStudioRuntimeDLLs(build_dir, target_arch)
 
   # Copy all the DLLs in |build_dir| to the version directory. Simultaneously
   # build a list of their names to mark them as dependencies of chrome.exe and
   # setup.exe later.
   dlls = glob.glob(os.path.join(build_dir, '*.dll'))
   dll_names = []
   for dll in dlls:
     shutil.copy(dll, version_dir)
     dll_names.append(os.path.splitext(os.path.basename(dll))[0])
 
@@ skipping 85 matching lines @@
     CopyAllFilesToStagingDir(config, options.distribution,
                              staging_dir, options.output_dir,
                              options.enable_hidpi, options.enable_touch_ui)
 
   # 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, current_version)
+    DoComponentBuildTasks(staging_dir, options.build_dir,
+                          options.target_arch, 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
@@ skipping 40 matching lines @@
       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_touch_ui', default='0',
       help='Whether to include resource files from the "TOUCH" section of the '
            'input file.')
   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('--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)
 
   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.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()))