Moving away from shell api to support long path names on windows for filesystem.

base/file_path.cc

 // Copyright (c) 2010 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.
 
 #include "base/file_path.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #elif defined(OS_MACOSX)
 #include <CoreFoundation/CoreFoundation.h>
@@ skipping 16 matching lines @@
 
 #if defined(FILE_PATH_USES_WIN_SEPARATORS)
 const FilePath::CharType FilePath::kSeparators[] = FILE_PATH_LITERAL("\\/");
 #else  // FILE_PATH_USES_WIN_SEPARATORS
 const FilePath::CharType FilePath::kSeparators[] = FILE_PATH_LITERAL("/");
 #endif  // FILE_PATH_USES_WIN_SEPARATORS
 
 const FilePath::CharType FilePath::kCurrentDirectory[] = FILE_PATH_LITERAL(".");
 const FilePath::CharType FilePath::kParentDirectory[] = FILE_PATH_LITERAL("..");
 
+#if defined(OS_WIN)
+const FilePath::CharType FilePath::kExtendedPathPrefix[] =
+    FILE_PATH_LITERAL("\\\\?\\");
+
+const FilePath::CharType FilePath::kUNCExtendedPathPrefix[] =
+    FILE_PATH_LITERAL("\\\\?\\UNC\\");
+
+const FilePath::CharType FilePath::kSharePrefix[] =
+    FILE_PATH_LITERAL("\\\\");
+#endif
+
 const FilePath::CharType FilePath::kExtensionSeparator = FILE_PATH_LITERAL('.');
 
 typedef FilePath::StringType StringType;
 
 namespace {
 
 const char* kCommonDoubleExtensions[] = { "gz", "z", "bz2" };
 
 // If this FilePath contains a drive letter specification, returns the
 // position of the last character of the drive letter specification,
@@ skipping 101 matching lines @@
       (last_separator == StringType::npos ||
       penultimate_dot > last_separator) &&
       last_dot - penultimate_dot <= 5U &&
       last_dot - penultimate_dot > 1U) {
     return penultimate_dot;
   }
 
   return last_dot;
 }
 
+#if defined(OS_WIN)
+// TODO(kkanetkar): Taken from gears. When crbug.com/67384 is addressed
+// this logic will be used in a different way such that the callers
+// would not be aware of the extended path or UNC formats.
+StringType ToLongFileNameHack(const FilePath::StringType& path) {
+  StringType long_path;
+  // This cast is for countering the compiler warning.
+  DWORD length_to_try = static_cast<DWORD>(path.length() * 2);

[Erik does not do reviews, 2010/12/23 17:57:27]

I don't understand this *2 logic.  Why not just pass NULL and always retrieve
the length first?

+  long_path.resize(length_to_try);
+  DWORD actual_length = GetLongPathName(path.c_str(),
+                                        &long_path.at(0),
+                                        length_to_try);
+  if (actual_length == 0) {
+    return path;

[Erik does not do reviews, 2010/12/23 17:57:27]

I'm a bit nervous that this won't work in all cases.  Here's the scenario:
(1) get a FilePath object that's a short name near the 260 char limit
(2) call Append to add a path component to it, pushing it past 260 (say you want
to create a subdirectory)
(3) now we call ToLongFileNameHack which returns the path that you passed in
without the parent being converted to a proper long name
(4) we prepend \\? to this filename since
(5) the file operation fails since the path is bogus

I don't have a great suggestion here.  We may need to look at the callsites that
could generate a problem like this and see if there are's anything obvious we
could do.

Maybe we need to figure out how to make sure we're never passing around short
names to begin with.

+  } else if (actual_length <= length_to_try) {
+    long_path.resize(actual_length);
+    return long_path;
+  }
+
+  length_to_try = actual_length;
+  long_path.resize(length_to_try);
+  actual_length = GetLongPathName(path.c_str(),
+                                  &long_path.at(0),
+                                  length_to_try + 1);
+  if (actual_length > 0 && actual_length <= length_to_try) {
+    long_path.resize(actual_length);
+    return long_path;
+  } else {
+    return path;
+  }
+}
+#endif
+
 }  // namespace
 
 FilePath::FilePath() {
 }
 
 FilePath::FilePath(const FilePath& that) : path_(that.path_) {
 }
 
 FilePath::FilePath(const StringType& path) : path_(path) {
 }
@@ skipping 1015 matching lines @@
 
 #if defined(FILE_PATH_USES_WIN_SEPARATORS)
 FilePath FilePath::NormalizeWindowsPathSeparators() const {
   StringType copy = path_;
   for (size_t i = 1; i < arraysize(kSeparators); ++i) {
     std::replace(copy.begin(), copy.end(), kSeparators[i], kSeparators[0]);
   }
   return FilePath(copy);
 }
 #endif
+
+#if defined(OS_WIN)
+FilePath FilePath::GetLongPathHack() const {
+  if (StartsWith(path_, kExtendedPathPrefix, false) ||

[Erik does not do reviews, 2010/12/23 17:57:27]

why not call StartsWithExtendedPathOrUNCPrefix?

+      StartsWith(path_, kUNCExtendedPathPrefix, false)) {
+    return FilePath(path_);
+  }
+
+  // Note that the 8.3 short file name can not be simply prefixed with the long
+  // path prefix. It has to be converted to long file name first.
+  if (StartsWith(path_, kSharePrefix, false)) {
+    return FilePath(kUNCExtendedPathPrefix + ToLongFileNameHack(
+        path_.substr(arraysize(FilePath::kSharePrefix) - 1)));
+  } else {
+    return FilePath(kExtendedPathPrefix + ToLongFileNameHack(path_));
+  }
+}
+#endif
+
+#if defined(OS_WIN)
+bool FilePath::StartsWithExtendedPathOrUNCPrefix() const {
+  return StartsWith(path_, kExtendedPathPrefix, false) ||
+      StartsWith(path_, kUNCExtendedPathPrefix, false);
+}
+#endif