includes_normalizes: Full fix for long path support.

Use GetFullPathNameW() instead of GetFullPathNameA() to ensure that
normalization works for all long paths on Windows. Adjust unit
tests accordingly.

Fixes #2442

Author: digit-google

src/includes_normalize-win32.cc

@@ -34,24 +34,35 @@ bool InternalGetFullPathName(const StringPiece& file_name, std::string* path,
   // "The filename or extension is too long" even if long path supported is
   // enabled. GetFullPathNameW() must be used for this function to work!
   path->clear();
+  // Convert to wide filename first.
   std::string filename_str = file_name.AsString();
-  DWORD full_size = GetFullPathNameA(filename_str.c_str(), 0, NULL, NULL);
-  if (full_size == 0) {
-    *err = "GetFullPathNameA(" + filename_str + "): " + GetLastErrorString();
+  std::wstring wide_filename;
+  if (!ConvertUTF8ToWin32Unicode(filename_str, &wide_filename, err))
+    return false;
+
+  // Call GetFullPathNameW()
+  DWORD wide_full_size = GetFullPathNameW(wide_filename.c_str(), 0, NULL, NULL);
+  if (wide_full_size == 0) {
+    *err = "GetFullPathNameW(" +
+           std::string(wide_filename.begin(), wide_filename.end()) +
+           "): " + GetLastErrorString();
     return false;
   }
 
-  // NOTE: full_size includes the null-terminating character.
-  path->resize(static_cast<size_t>(full_size - 1));
-  DWORD result2 = GetFullPathNameA(filename_str.c_str(), full_size,
-                                   const_cast<char*>(path->data()), NULL);
-  if (result2 == 0) {
-    *err = "GetFullPathNameA(" + filename_str + "): " + GetLastErrorString();
+  // NOTE: wide_full_size includes the null-terminating character.
+  std::wstring wide_path;
+  wide_path.resize(static_cast<size_t>(wide_full_size - 1));
+  DWORD wide_full_size2 =
+      GetFullPathNameW(wide_filename.c_str(), wide_full_size,
+                       const_cast<wchar_t*>(wide_path.data()), NULL);
+  if (wide_full_size2 == 0) {
+    *err = "GetFullPathNameW(" + filename_str + "): " + GetLastErrorString();
+    path->clear();
     return false;
   }
 
-  path->resize(static_cast<size_t>(result2));
-  return true;
+  // Convert wide_path to Unicode.
+  return ConvertWin32UnicodeToUTF8(wide_path, path, err);
 }
 
 // Get the drive prefix of a given filename. On success set |*drive| then return

src/includes_normalize_test.cc

@@ -144,26 +144,27 @@ TEST(IncludesNormalize, LongInvalidPath) {
             NormalizeAndCheckNoError(kExactlyMaxPath));
 }
 
-TEST(IncludesNormalize, ShortRelativeButTooLongAbsolutePath) {
+TEST(IncludesNormalize, ShortRelativeButLongAbsolutePath) {
   std::string result, err;
   IncludesNormalize normalizer(".");
   // A short path should work
   EXPECT_TRUE(normalizer.Normalize("a", &result, &err));
   EXPECT_EQ("", err);
 
+  // Make sure a path that's exactly _MAX_PATH long fails does not fail.
   // Construct max size path having cwd prefix.
   // kExactlyMaxPath = "aaaa\\aaaa...aaaa\0";
-  char kExactlyMaxPath[_MAX_PATH + 1];
+  std::string exactly_max_path;
   for (int i = 0; i < _MAX_PATH; ++i) {
     if (i < _MAX_PATH - 1 && i % 10 == 4)
-      kExactlyMaxPath[i] = '\\';
+      exactly_max_path.push_back('\\');
     else
-      kExactlyMaxPath[i] = 'a';
+      exactly_max_path.push_back('a');
   }
-  kExactlyMaxPath[_MAX_PATH] = '\0';
-  EXPECT_EQ(strlen(kExactlyMaxPath), static_cast<size_t>(_MAX_PATH));
+  EXPECT_EQ(exactly_max_path.size(), static_cast<size_t>(_MAX_PATH));
+  EXPECT_TRUE(normalizer.Normalize(exactly_max_path, &result, &err)) << err;
 
-  // Make sure a path that's exactly _MAX_PATH long fails with a proper error.
-  EXPECT_FALSE(normalizer.Normalize(kExactlyMaxPath, &result, &err)) << err;
-  EXPECT_NE(err.find("GetFullPathNameA"), std::string::npos);
+  // Make sue a path of _MAX_PATH + 1 characters also works.
+  std::string more_than_max_path = exactly_max_path + "\\a";
+  EXPECT_TRUE(normalizer.Normalize(more_than_max_path, &result, &err)) << err;
 }