Make "vs_toolchain.py update" work on case-sensitive file systems

win_toolchain/get_toolchain_if_necessary.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.
 
 """Downloads and unpacks a toolchain for building on Windows. The contents are
 matched by sha1 which will be updated when the toolchain is updated.
 
 Having a toolchain script in depot_tools means that it's not versioned
 directly with the source code. That is, if the toolchain is upgraded, but
@@ skipping 58 matching lines @@
 
 def GetFileList(root):
   """Gets a normalized list of files under |root|."""
   assert not os.path.isabs(root)
   assert os.path.normpath(root) == root
   file_list = []
   # Ignore WER ReportQueue entries that vctip/cl leave in the bin dir if/when
   # they crash. Also ignores the content of the win_sdk/debuggers/x(86|64)/sym/
   # directories as this is just the temporarily location that Windbg might use
   # to store the symbol files.
+  #
+  # Note: These files are only created on a Windows host, so the
+  # ignored_directories list isn't relevant on non-Windows hosts.
+
   ignored_directories = ['wer\\reportqueue',
                          'win_sdk\\debuggers\\x86\\sym\\',
                          'win_sdk\\debuggers\\x64\\sym\\']
   for base, _, files in os.walk(root):
-    paths = [os.path.join(base, f).lower() for f in files]
+    paths = [os.path.join(base, f) for f in files]
     for p in paths:
-      if any(ignored_dir in p for ignored_dir in ignored_directories):
+      if any(ignored_dir in p.lower() for ignored_dir in ignored_directories):
         continue
       file_list.append(p)
-  return sorted(file_list, key=lambda s: s.replace('/', '\\'))
+  return sorted(file_list, key=lambda s: s.replace('/', '\\').lower())
 
 
 def MakeTimestampsFileName(root, sha1):
   return os.path.join(root, os.pardir, '%s.timestamps' % sha1)
 
 
 def CalculateHash(root, expected_hash):
   """Calculates the sha1 of the paths to all files in the given |root| and the
   contents of those files, and returns as a hex string.
 
@@ skipping 52 matching lines @@
 
   # Make long hangs when updating the toolchain less mysterious.
   print 'Calculating hash of toolchain in %s. Please wait...' % full_root_path
   sys.stdout.flush()
   digest = hashlib.sha1()
   for path in file_list:
     path_without_hash = str(path).replace('/', '\\')
     if expected_hash:
       path_without_hash = path_without_hash.replace(
           os.path.join(root, expected_hash).replace('/', '\\'), root)
-    digest.update(path_without_hash)
+    digest.update(path_without_hash.lower())

[scottmg, 2016/06/06 16:39:22]

I don't really remember what the data looks like now, but you're saying this
lower() is unnecessary then? This looks like it's only used to calculate the
digest, so best case it does nothing, worst case it changes the hashes, right?

[scottmg, 2016/06/06 16:40:56]

Oh, I missed the old lower(). I'm probably not the right reviewer for this any
more :(

     with open(path, 'rb') as f:
       digest.update(f.read())
   return digest.hexdigest()
 
 
 def CalculateToolchainHashes(root, remove_corrupt_toolchains):
   """Calculate the hash of the different toolchains installed in the |root|
   directory."""
   hashes = []
   dir_list = [
@@ skipping 360 matching lines @@
   if os.environ.get('GYP_MSVS_VERSION') == '2015':
     InstallUniversalCRTIfNeeded(abs_toolchain_target_dir)
 
   RemoveUnusedToolchains(target_dir)
 
   return 0
 
 
 if __name__ == '__main__':
   sys.exit(main())