Support VS2013 Express for automatic toolchain too

win_toolchain/toolchain2013.py

 #!/usr/bin/env python
 # Copyright 2013 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.
 
 """Extracts a Windows VS2013 toolchain from various downloadable pieces."""
 
 
 import ctypes
 import optparse
 import os
 import shutil
 import subprocess
 import sys
 import tempfile
 import urllib2
 
 
 BASEDIR = os.path.dirname(os.path.abspath(__file__))
+WDK_ISO_URL = (
+    'http://download.microsoft.com/download/'
+    '4/A/2/4A25C7D5-EFBE-4182-B6A9-AE6850409A78/GRMWDK_EN_7600_1.ISO')
 g_temp_dirs = []
 
 
 sys.path.append(os.path.join(BASEDIR, '..'))
 import download_from_google_storage
 
 
 def GetLongPathName(path):
   """Converts any 8dot3 names in the path to the full name."""
   buf = ctypes.create_unicode_buffer(260)
@@ skipping 20 matching lines @@
   """Removes all temporary directories created by |TempDir()|."""
   global g_temp_dirs
   if g_temp_dirs:
     sys.stdout.write('Cleaning up temporaries...\n')
   for temp in g_temp_dirs:
     # shutil.rmtree errors out on read only attributes.
     RunOrDie('rmdir /s/q "%s"' % temp)
   g_temp_dirs = []
 
 
-def GetIsoUrl(pro):
-  """Gets the .iso URL.
+def GetMainIsoUrl(pro):
+  """Gets the main .iso URL.
 
   If |pro| is False, downloads the Express edition. If |CHROME_HEADLESS| is
   set in the environment, then we assume we're on an internal bot, and download
   from internal google storage instead.
   """
   prefix = 'http://download.microsoft.com/download/'
   if pro:
     return (prefix +
         'A/F/1/AF128362-A6A8-4DB3-A39A-C348086472CC/VS2013_RTM_PRO_ENU.iso')
   else:
@@ skipping 72 matching lines @@
   Download(
       ('http://download.microsoft.com/download/'
        'F/1/3/F1300C9C-A120-4341-90DF-8A52509B23AC/standalonesdk/sdksetup.exe'),
       target_path)
   sys.stdout.write(
       'Running sdksetup.exe to download Win8 SDK (may request elevation)...\n')
   count = 0
   while count < 5:
     rc = os.system(target_path + ' /quiet '
                    '/features OptionId.WindowsDesktopDebuggers '
+                             'OptionId.WindowsDesktopSoftwareDevelopmentKit '
                    '/layout ' + standalone_path)
     if rc == 0:
       return standalone_path
     count += 1
     sys.stdout.write('Windows 8 SDK failed to download, retrying.\n')
   sys.exit('After multiple retries, couldn\'t download Win8 SDK')
 
 
+def DownloadWDKIso():
+  wdk_temp_dir = TempDir()
+  target_path = os.path.join(wdk_temp_dir, 'GRMWDK_EN_7600_1.ISO')
+  Download(WDK_ISO_URL, target_path)
+  return target_path
+
+
 def DownloadUsingGsutil(filename):
   """Downloads the given file from Google Storage chrome-wintoolchain bucket."""
   temp_dir = TempDir()
   assert os.path.basename(filename) == filename
   target_path = os.path.join(temp_dir, filename)
   gsutil = download_from_google_storage.Gsutil(
       download_from_google_storage.GSUTIL_DEFAULT_PATH, boto_path=None)
   code = gsutil.call('cp', 'gs://chrome-wintoolchain/' + filename, target_path)
   if code != 0:
     sys.exit('gsutil failed')
   return target_path
 
 
 def GetVSInternal():
   """Uses gsutil to pull the toolchain from internal Google Storage bucket."""
   return DownloadUsingGsutil('VS2013_RTM_PRO_ENU.iso')
 
 
 def GetSDKInternal():
   """Downloads a zipped copy of the SDK from internal Google Storage bucket,
   and extracts it."""
   zip_file = DownloadUsingGsutil('Standalone.zip')
   return ExtractIso(zip_file)
 
 
 class SourceImages(object):
-  def __init__(self, vs_path, sdk8_path):
+  """Local paths for components. |wdk_path| may be None if it's unnecessary for
+  the given configuration."""
+  def __init__(self, vs_path, sdk8_path, wdk_path):
     self.vs_path = vs_path
     self.sdk8_path = sdk8_path
+    self.wdk_path = wdk_path
 
 
 def GetSourceImages(local_dir, pro):
-  url = GetIsoUrl(pro)
+  """Downloads the various sources that we need.
+
+  Of note: Because Express does not include ATL, there's an additional download
+  of the 7.1 WDK which is the latest publically accessible source for ATL. When
+  |pro| this is not necessary (and CHROME_HEADLESS always implies Pro).
+  """
+  url = GetMainIsoUrl(pro)
   if os.environ.get('CHROME_HEADLESS'):

[M-A Ruel, 2014/02/03 23:10:52]

I'd prefer an option --bot-mode with
default=bool(int(os.environ.get('CHROME_HEADLESS', 0))) and pass this value down
here.

[scottmg, 2014/02/03 23:22:12]

Done.

-    return SourceImages(GetVSInternal(), GetSDKInternal())
+    return SourceImages(GetVSInternal(), GetSDKInternal(), wdk_path=None)
   elif local_dir:
+    wdk_path = (os.path.join(local_dir, os.path.basename(WDK_ISO_URL))
+                if not pro else None)
     return SourceImages(os.path.join(local_dir, os.path.basename(url)),
-                        os.path.join(local_dir, 'Standalone'))
+                        os.path.join(local_dir, 'Standalone'),
+                        wdk_path=wdk_path)
   else:
     # Note that we do the SDK first, as it might cause an elevation prompt.
     sdk8_path = DownloadSDK8()
     vs_path = DownloadMainIso(url)
-    return SourceImages(vs_path, sdk8_path)
+    wdk_path = DownloadWDKIso() if not pro else None
+    return SourceImages(vs_path, sdk8_path, wdk_path=wdk_path)
 
 
 def ExtractMsiList(root_dir, packages):
   """Extracts the contents of a list of .msi files from an already extracted
   .iso file.
 
   |packages| is a list of pairs (msi, required). If required is not True, the
   msi is optional (this is set for packages that are in Pro but not Express).
   """
   results = []
@@ skipping 16 matching lines @@
       (r'vc_compilerCore86\vc_compilerCore86.msi', True),
       (r'vc_compilerCore86res\vc_compilerCore86res.msi', True),
       (r'vc_compilerx64nat\vc_compilerx64nat.msi', False),
       (r'vc_compilerx64natres\vc_compilerx64natres.msi', False),
       (r'vc_compilerx64x86\vc_compilerx64x86.msi', False),
       (r'vc_compilerx64x86res\vc_compilerx64x86res.msi', False),
       (r'vc_librarycore86\vc_librarycore86.msi', True),
       (r'vc_libraryDesktop\x64\vc_LibraryDesktopX64.msi', True),
       (r'vc_libraryDesktop\x86\vc_LibraryDesktopX86.msi', True),
       (r'vc_libraryextended\vc_libraryextended.msi', False),
-      (r'Windows_SDK\Windows Software Development Kit-x86_en-us.msi', True),
-      ('Windows_SDK\\'
-       r'Windows Software Development Kit for Metro style Apps-x86_en-us.msi',
-          True),
     ]
   extracted_iso = ExtractIso(image.vs_path)
   result = ExtractMsiList(os.path.join(extracted_iso, 'packages'), vs_packages)
 
   sdk_packages = [
       (r'X86 Debuggers And Tools-x86_en-us.msi', True),
       (r'X64 Debuggers And Tools-x64_en-us.msi', True),
       (r'SDK Debuggers-x86_en-us.msi', True),
+      (r'Windows Software Development Kit-x86_en-us.msi', True),
+      (r'Windows Software Development Kit for Metro style Apps-x86_en-us.msi',
+          True),
     ]
   result.extend(ExtractMsiList(os.path.join(image.sdk8_path, 'Installers'),
                                sdk_packages))
 
+  if image.wdk_path:
+    # This image will only be set when using Express, when we need the WDK
+    # headers and libs to supplement Express with ATL.
+    wdk_packages = [
+      (r'headers.msi', True),
+      (r'libs_x86fre.msi', True),
+      (r'libs_x64fre.msi', True),
+    ]
+    extracted_iso = ExtractIso(image.wdk_path)
+    result.extend(ExtractMsiList(os.path.join(extracted_iso, 'WDK'),
+                                 wdk_packages))
+
   return result
 
 
 def CopyToFinalLocation(extracted_dirs, target_dir):
   sys.stdout.write('Copying to final location...\n')
   mappings = {
       'Program Files\\Microsoft Visual Studio 12.0\\': '.\\',
       'System64\\': 'sys64\\',
       'System\\': 'sys32\\',
       'Windows Kits\\8.0\\': 'win8sdk\\',
+      'WinDDK\\7600.16385.win7_wdk.100208-1538\\': 'wdk\\',
   }
   matches = []
   for extracted_dir in extracted_dirs:
     for root, _, filenames in os.walk(extracted_dir):
       for filename in filenames:
         matches.append((extracted_dir, os.path.join(root, filename)))
 
   copies = []
   for prefix, full_path in matches:
     # +1 for trailing \.
@@ skipping 43 matching lines @@
                '%~dp0..\\..\\VC\\atlmfc\\lib\n'
             'goto :EOF\n')
 
     # Express does not include a native 64 bit compiler, so we have to use
     # the x86->x64 cross.
     if not pro:
       # x86->x64 cross.
       f.write(':x64\n'
               'set PATH=%~dp0..\\..\\win8sdk\\bin\\x64;'
                  '%~dp0..\\..\\VC\\bin\\x86_amd64;'
+                 # Needed for mspdb120.dll. Must be after above though, so
+                 # that cl.exe is the x86_amd64 one.
+                 '%~dp0..\\..\\VC\\bin;'
                  '%PATH%\n')
     else:
       # x64 native.
       f.write(':x64\n'
               'set PATH=%~dp0..\\..\\win8sdk\\bin\\x64;'
                  '%~dp0..\\..\\VC\\bin\\amd64;'
                  '%PATH%\n')
     f.write('set LIB=%~dp0..\\..\\VC\\lib\\amd64;'
                '%~dp0..\\..\\win8sdk\\Lib\\win8\\um\\x64;'
                '%~dp0..\\..\\VC\\atlmfc\\lib\\amd64\n')
@@ skipping 20 matching lines @@
                    target_dir)
     # Set the working directory to 7z subdirectory. 7-zip doesn't find its
     # codec dll very well, so this is the simplest way to make sure it runs
     # correctly, as we don't otherwise care about working directory.
     os.chdir(os.path.join(BASEDIR, '7z'))
     images = GetSourceImages(options.local, not options.express)
     extracted = ExtractComponents(images)
     CopyToFinalLocation(extracted, target_dir)
 
     GenerateSetEnvCmd(target_dir, not options.express)
+    with open(os.path.join(target_dir, '.version'), 'w') as f:
+      f.write('express' if options.express else 'pro')
   finally:
     if options.clean:
       DeleteAllTempDirs()
 
 
 if __name__ == '__main__':
   sys.exit(main())