get_native_path_case() now preserves the trailing os.sep.path and work with non-existing path.

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.
 
 """Traces an executable and its child processes and extract the files accessed
 by them.
 
 The implementation uses OS-specific API. The native Kernel logger and the ETL
@@ skipping 176 matching lines @@
       if not drive or not match.group(2):
         return drive
       return drive + match.group(2)
 
 
   def isabs(path):
     """Accepts X: as an absolute path, unlike python's os.path.isabs()."""
     return os.path.isabs(path) or len(path) == 2 and path[1] == ':'
 
 
-  def get_native_path_case(path):
+  def get_native_path_case(p):
     """Returns the native path case for an existing file.
 
     On Windows, removes any leading '\\?\'.
     """
-    if not isabs(path):
+    if not isabs(p):
       raise ValueError(
-          'Can\'t get native path case for a non-absolute path: %s' % path,
-          path)
+          'Can\'t get native path case for a non-absolute path: %s' % p,
+          p)
     # 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.
     # Go figure why GetShortPathName() is needed.
     try:
-      path = GetLongPathName(GetShortPathName(path))
-    except OSError:
-      # This is wrong to silently eat the exception but there's nothing that can
-      # be done about it.
-      logging.info('No access to %s' % path)
-    if path.startswith('\\\\?\\'):
-      path = path[4:]
+      out = GetLongPathName(GetShortPathName(p))
+    except OSError, e:
+      if e.args[0] in (2, 3):
+        # The path does not exist. Try to recurse and reconstruct the path.
+        base = os.path.dirname(p)
+        rest = os.path.basename(p)
+        return os.path.join(get_native_path_case(base), rest)
+      raise
+    if out.startswith('\\\\?\\'):
+      out = out[4:]
     # Always upper case the first letter since GetLongPathName() will return the
     # drive letter in the case it was given.
-    return path[0].upper() + path[1:]
+    return out[0].upper() + out[1:]
 
 
   def CommandLineToArgvW(command_line):
     """Splits a commandline into argv using CommandLineToArgvW()."""
     # http://msdn.microsoft.com/library/windows/desktop/bb776391.aspx
     size = c_int()
     ptr = windll.shell32.CommandLineToArgvW(unicode(command_line), byref(size))
     try:
       return [arg for arg in (c_wchar_p * size.value).from_address(ptr)]
     finally:
@@ skipping 17 matching lines @@
     for element in os.listdir(root_path):
       if element.lower() == item:
         return element
 
 
   def _native_case(p):
     """Gets the native path case. Warning: this function resolves symlinks."""
     logging.debug('native_case(%s)' % p)
     try:
       rel_ref, _ = Carbon.File.FSPathMakeRef(p)
-      return rel_ref.FSRefMakePath()
+      out = rel_ref.FSRefMakePath()
+      if p.endswith(os.path.sep) and not out.endswith(os.path.sep):
+        return out + os.path.sep
+      return out
     except MacOS.Error, e:
+      if e.args[0] == -43:
+        # The path does not exist. Try to recurse and reconstruct the path.
+        base = os.path.dirname(p)
+        rest = os.path.basename(p)
+        return os.path.join(_native_case(base), rest)
       raise OSError(
           e.args[0], 'Failed to get native path for %s' % p, p, e.args[1])
 
 
   def _split_at_symlink_native(base_path, rest):
     """Returns the native path for a symlink."""
     base, symlink, rest = split_at_symlink(base_path, rest)
     if symlink:
       if not base_path:
         base_path = base
@@ skipping 18 matching lines @@
       return path
 
     # Starts assuming there is no symlink along the path.
     resolved = _native_case(path)
     if resolved.lower() == path.lower():
       # This code path is incredibly faster.
       return resolved
 
     # There was a symlink, process it.
     base, symlink, rest = _split_at_symlink_native(None, path)
-    assert symlink, (path, base, symlink, rest)
+    assert symlink, (path, base, symlink, rest, resolved)
     prev = base
     base = safe_join(_native_case(base), symlink)
     assert len(base) > len(prev)
     while rest:
       prev = base
       relbase, symlink, rest = _split_at_symlink_native(base, rest)
       base = safe_join(base, relbase)
       assert len(base) > len(prev), (prev, base, symlink)
       if symlink:
         base = safe_join(base, symlink)
@@ skipping 19 matching lines @@
     TODO(maruel): This is not strictly true. Implement if necessary.
     """
     if not isabs(path):
       raise ValueError(
           'Can\'t get native path case for a non-absolute path: %s' % path,
           path)
     # Give up on cygwin, as GetLongPathName() can't be called.
     # Linux traces tends to not be normalized so use this occasion to normalize
     # it. This function implementation already normalizes the path on the other
     # OS so this needs to be done here to be coherent between OSes.
-    return os.path.normpath(path)
+    out = os.path.normpath(path)
+    if path.endswith(os.path.sep) and not out.endswith(os.path.sep):
+      return out + os.path.sep
+    return out
 
 
 if sys.platform != 'win32':  # All non-Windows OSes.
 
 
   def safe_join(*args):
     """Joins path elements like os.path.join() but doesn't abort on absolute
     path.
 
     os.path.join('foo', '/bar') == '/bar'
@@ skipping 214 matching lines @@
       self.tainted = tainted
       # These are cache only.
       self._real_path = None
       self._size = None
 
       # Check internal consistency.
       assert path, path
       assert tainted or bool(root) != bool(isabs(path)), (root, path)
       assert tainted or (
           not os.path.exists(self.full_path) or
-          (self.full_path.rstrip(os.path.sep) ==
-            get_native_path_case(self.full_path))), (
+          (self.full_path == get_native_path_case(self.full_path))), (
               tainted, self.full_path, get_native_path_case(self.full_path))
 
     @property
     def existent(self):
       return self.size != -1
 
     @property
     def full_path(self):
       if self.root:
         return os.path.join(self.root, self.path)
@@ skipping 2492 matching lines @@
     return command(argv[1:])
   except TracingFailure, e:
     sys.stderr.write('\nError: ')
     sys.stderr.write(str(e))
     sys.stderr.write('\n')
     return 1
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv[1:]))