Added function to get native path case on Windows and OSX.

tools/isolate/trace_inputs.py

 #!/usr/bin/env python
 # coding=utf-8
 # 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.
 
 """Runs strace or dtrace on a test and processes the logs to extract the
 dependencies from the source tree.
 
 Automatically extracts directories where all the files are used to make the
 dependencies list more compact.
 """
 
 import codecs
 import csv
 import logging
 import optparse
 import os
 import posixpath
 import re
 import subprocess
 import sys
 
+## OS-specific imports
+
+if sys.platform == 'win32':
+  from ctypes.wintypes import create_unicode_buffer
+  from ctypes.wintypes import windll, FormatError  # pylint: disable=E0611
+  from ctypes.wintypes import GetLastError  # pylint: disable=E0611
+elif sys.platform == 'darwin':
+  import Carbon.File  #  pylint: disable=F0401
+
 
 BASE_DIR = os.path.dirname(os.path.abspath(__file__))
 ROOT_DIR = os.path.dirname(os.path.dirname(BASE_DIR))
 
 KEY_TRACKED = 'isolate_dependency_tracked'
 KEY_UNTRACKED = 'isolate_dependency_untracked'
 
 
+## OS-specific functions
+
 if sys.platform == 'win32':
-  from ctypes.wintypes import create_unicode_buffer
-  from ctypes.wintypes import windll, FormatError  # pylint: disable=E0611
-  from ctypes.wintypes import GetLastError  # pylint: disable=E0611
-
-
   def QueryDosDevice(drive_letter):
     """Returns the Windows 'native' path for a DOS drive letter."""
     assert re.match(r'^[a-zA-Z]:$', drive_letter), drive_letter
     # Guesswork. QueryDosDeviceW never returns the required number of bytes.
     chars = 1024
     drive_letter = unicode(drive_letter)
     p = create_unicode_buffer(chars)
     if 0 == windll.kernel32.QueryDosDeviceW(drive_letter, p, chars):
       err = GetLastError()
       if err:
         # pylint: disable=E0602
         raise WindowsError(
             err,
             'QueryDosDevice(%s): %s (%d)' % (
               str(drive_letter), FormatError(err), err))
     return p.value
 
 
   def GetShortPathName(long_path):
     """Returns the Windows short path equivalent for a 'long' path."""
     long_path = unicode(long_path)
+    # Adds '\\\\?\\' when given an absolute path so the MAX_PATH (260) limit is
+    # not enforced.
+    if os.path.isabs(long_path) and not long_path.startswith('\\\\?\\'):
+      long_path = '\\\\?\\' + long_path
     chars = windll.kernel32.GetShortPathNameW(long_path, None, 0)
     if chars:
       p = create_unicode_buffer(chars)
       if windll.kernel32.GetShortPathNameW(long_path, p, chars):
         return p.value
 
     err = GetLastError()
     if err:
       # pylint: disable=E0602
       raise WindowsError(
           err,
           'GetShortPathName(%s): %s (%d)' % (
             str(long_path), FormatError(err), err))
 
 
+  def GetLongPathName(short_path):
+    """Returns the Windows long path equivalent for a 'short' path."""
+    short_path = unicode(short_path)
+    # Adds '\\\\?\\' when given an absolute path so the MAX_PATH (260) limit is
+    # not enforced.
+    if os.path.isabs(short_path) and not short_path.startswith('\\\\?\\'):
+      short_path = '\\\\?\\' + short_path
+    chars = windll.kernel32.GetLongPathNameW(short_path, None, 0)
+    if chars:
+      p = create_unicode_buffer(chars)
+      if windll.kernel32.GetLongPathNameW(short_path, p, chars):
+        return p.value
+
+    err = GetLastError()
+    if err:
+      # pylint: disable=E0602
+      raise WindowsError(
+          err,
+          'GetLongPathName(%s): %s (%d)' % (
+            str(short_path), FormatError(err), err))
+
+
   def get_current_encoding():
     """Returns the 'ANSI' code page associated to the process."""
     return 'cp%d' % int(windll.kernel32.GetACP())
 
 
   class DosDriveMap(object):
     """Maps \Device\HarddiskVolumeN to N: on Windows."""
     # Keep one global cache.
     _MAPPING = {}
 
     def __init__(self):
       if not self._MAPPING:
+        # This is related to UNC resolver on windows. Ignore that.
+        self._MAPPING['\\Device\\Mup'] = None
+
         for letter in (chr(l) for l in xrange(ord('C'), ord('Z')+1)):
           try:
             letter = '%s:' % letter
             mapped = QueryDosDevice(letter)
             # It can happen. Assert until we see it happens in the wild. In
             # practice, prefer the lower drive letter.
             assert mapped not in self._MAPPING
             if mapped not in self._MAPPING:
               self._MAPPING[mapped] = letter
           except WindowsError:  # pylint: disable=E0602
             pass
 
     def to_dos(self, path):
       """Converts a native NT path to DOS path."""
       m = re.match(r'(^\\Device\\[a-zA-Z0-9]+)(\\.*)?$', path)
-      if not m or m.group(1) not in self._MAPPING:
-        assert False, path
+      assert m, path
+      assert m.group(1) in self._MAPPING, (path, self._MAPPING)
       drive = self._MAPPING[m.group(1)]
-      if not m.group(2):
+      if not drive or not m.group(2):
         return drive
       return drive + m.group(2)
 
 
+def get_native_path_case(root, relative_path):
+  """Returns the native path case."""
+  if sys.platform == 'win32':
+    # Windows used to have an option to turn on case sensitivity on non Win32
+    # subsystem but that's out of scope here and isn't supported anymore.
+    # First process root.
+    if root:
+      root = GetLongPathName(GetShortPathName(root)) + os.path.sep
+    path = os.path.join(root, relative_path) if root else relative_path
+    # Go figure why GetShortPathName() is needed.
+    return GetLongPathName(GetShortPathName(path))[len(root):]
+  elif sys.platform == 'darwin':
+    # Technically, it's only HFS+ on OSX that is case insensitive. It's
+    # the default setting on HFS+ but can be changed.
+    root_ref, _ = Carbon.File.FSPathMakeRef(root)
+    rel_ref, _ = Carbon.File.FSPathMakeRef(os.path.join(root, relative_path))
+    return rel_ref.FSRefMakePath()[len(root_ref.FSRefMakePath())+1:]
+  else:
+    # Give up on cygwin, as GetLongPathName() can't be called.
+    return relative_path
+
+
 def get_flavor():
   """Returns the system default flavor. Copied from gyp/pylib/gyp/common.py."""
   flavors = {
     'cygwin': 'win',
     'win32': 'win',
     'darwin': 'mac',
     'sunos5': 'solaris',
     'freebsd7': 'freebsd',
     'freebsd8': 'freebsd',
   }
@@ skipping 711 matching lines @@
       if handler:
         handler(line)
       else:
         assert False, '%s_%s' % (line[self.EVENT_NAME], line[self.TYPE])
 
     def handle_EventTrace_Any(self, line):
       pass
 
     def handle_FileIo_Create(self, line):
       m = re.match(r'^\"(.+)\"$', line[self.FILE_PATH])
-      self._handle_file(self._drive_map.to_dos(m.group(1)).lower())
+      self._handle_file(self._drive_map.to_dos(m.group(1)))
 
     def handle_FileIo_Rename(self, line):
       # TODO(maruel): Handle?
       pass
 
     def handle_FileIo_Any(self, line):
       pass
 
     def handle_Image_DCStart(self, line):
       # TODO(maruel): Handle?
@@ skipping 55 matching lines @@
           filename in self.non_existent):
         return
       logging.debug('_handle_file(%s)' % filename)
       if os.path.isfile(filename):
         self.files.add(filename)
       else:
         self.non_existent.add(filename)
 
   def __init__(self):
     # Most ignores need to be determined at runtime.
-    self.IGNORED = set([os.path.dirname(sys.executable).lower()])
+    self.IGNORED = set([os.path.dirname(sys.executable)])
     # Add many directories from environment variables.
     vars_to_ignore = (
       'APPDATA',
       'LOCALAPPDATA',
       'ProgramData',
       'ProgramFiles',
       'ProgramFiles(x86)',
       'ProgramW6432',
       'SystemRoot',
       'TEMP',
       'TMP',
     )
     for i in vars_to_ignore:
       if os.environ.get(i):
-        self.IGNORED.add(os.environ[i].lower())
+        self.IGNORED.add(os.environ[i])
 
     # Also add their short path name equivalents.
     for i in list(self.IGNORED):
-      self.IGNORED.add(GetShortPathName(i).lower())
+      self.IGNORED.add(GetShortPathName(i))
 
     # Add this one last since it has no short path name equivalent.
     self.IGNORED.add('\\systemroot')
     self.IGNORED = tuple(sorted(self.IGNORED))
 
   @classmethod
   def gen_trace(cls, cmd, cwd, logname):
     logging.info('gen_trace(%s, %s, %s)' % (cmd, cwd, logname))
     # Use "logman -?" for help.
 
@@ skipping 272 matching lines @@
   assert not product_dir or not os.path.isabs(product_dir), product_dir
 
   cmd = fix_python_path(cmd)
   assert (
       (os.path.isfile(logfile) and not force_trace) or os.path.isabs(cmd[0])
       ), cmd[0]
 
   # Resolve any symlink
   root_dir = os.path.realpath(root_dir)
 
-  if sys.platform == 'win32':
-    # Help ourself and lowercase all the paths.
-    # TODO(maruel): handle short path names by converting them to long path name
-    # as needed.
-    root_dir = root_dir.lower()
-    if cwd_dir:
-      cwd_dir = cwd_dir.lower()
-    if product_dir:
-      product_dir = product_dir.lower()
-
   def print_if(txt):
     if cwd_dir is None:
       print(txt)
 
   flavor = get_flavor()
   if flavor == 'linux':
     api = Strace()
   elif flavor == 'mac':
     api = Dtrace()
   elif sys.platform == 'win32':
@@ skipping 32 matching lines @@
   for f in non_existent:
     print_if('  %s' % f)
 
   expected, unexpected = relevant_files(
       files, root_dir.rstrip(os.path.sep) + os.path.sep)
   if unexpected:
     print_if('Unexpected: %d' % len(unexpected))
     for f in unexpected:
       print_if('  %s' % f)
 
+  # In case the file system is case insensitive.
+  expected = sorted(set(get_native_path_case(root_dir, f) for f in expected))
+
   simplified = extract_directories(expected, root_dir)
   print_if('Interesting: %d reduced to %d' % (len(expected), len(simplified)))
   for f in simplified:
     print_if('  %s' % f)
 
   if cwd_dir is not None:
     def cleanuppath(x):
       """Cleans up a relative path. Converts any os.path.sep to '/' on Windows.
       """
       if x:
         x = x.rstrip(os.path.sep).replace(os.path.sep, '/')
       if x == '.':
         x = ''
       if x:
         x += '/'
       return x
 
     # Both are relative directories to root_dir.
     cwd_dir = cleanuppath(cwd_dir)
     product_dir = cleanuppath(product_dir)
 
     def fix(f):
       """Bases the file on the most restrictive variable."""
       logging.debug('fix(%s)' % f)
       # Important, GYP stores the files with / and not \.
-      if sys.platform == 'win32':
-        f = f.replace('\\', '/')
+      f = f.replace(os.path.sep, '/')
 
       if product_dir and f.startswith(product_dir):
         return '<(PRODUCT_DIR)/%s' % f[len(product_dir):]
       else:
         # cwd_dir is usually the directory containing the gyp file. It may be
         # empty if the whole directory containing the gyp file is needed.
         return posix_relpath(f, cwd_dir) or './'
 
     corrected = [fix(f) for f in simplified]
     tracked = [f for f in corrected if not f.endswith('/') and ' ' not in f]
@@ skipping 60 matching lines @@
       os.path.abspath(options.log),
       args,
       options.root_dir,
       options.cwd,
       options.product_dir,
       options.force)
 
 
 if __name__ == '__main__':
   sys.exit(main())