Improve the encoding/decoding to/from system encoding on Windows

runtime/bin/file_win.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "platform/globals.h"
 #if defined(TARGET_OS_WINDOWS)
 
 #include "bin/file.h"
 
 #include <fcntl.h>  // NOLINT
 #include <io.h>  // NOLINT
 #include <stdio.h>  // NOLINT
 #include <string.h>  // NOLINT
 #include <sys/stat.h>  // NOLINT
 #include <WinIoCtl.h>  // NOLINT
 
 #include "bin/builtin.h"
 #include "bin/log.h"
 #include "bin/utils.h"
+#include "bin/utils_win.h"
 #include "platform/utils.h"
 
 
 namespace dart {
 namespace bin {
 
 class FileHandle {
  public:
   explicit FileHandle(int fd) : fd_(fd) { }
   ~FileHandle() { }
@@ skipping 130 matching lines @@
     ASSERT((mode & kWriteOnly) == 0);
     flags = (O_RDWR | O_CREAT | O_BINARY | O_NOINHERIT);
   }
   if ((mode & kWriteOnly) != 0) {
     ASSERT((mode & kWrite) == 0);
     flags = (O_WRONLY | O_CREAT | O_BINARY | O_NOINHERIT);
   }
   if ((mode & kTruncate) != 0) {
     flags = flags | O_TRUNC;
   }
-  const wchar_t* system_name = StringUtils::Utf8ToWide(name);
+  const wchar_t* system_name = StringUtilsWin::Utf8ToWide(name);
   int fd = _wopen(system_name, flags, 0666);
   free(const_cast<wchar_t*>(system_name));
   if (fd < 0) {
     return NULL;
   }
   if ((((mode & kWrite) != 0) && ((mode & kTruncate) == 0)) ||
       (((mode & kWriteOnly) != 0) && ((mode & kTruncate) == 0))) {
     int64_t position = _lseeki64(fd, 0, SEEK_END);
     if (position < 0) {
       return NULL;
@@ skipping 13 matching lines @@
       break;
     default:
       UNREACHABLE();
   }
   return new File(new FileHandle(fd));
 }
 
 
 bool File::Exists(const char* name) {
   struct __stat64 st;
-  const wchar_t* system_name = StringUtils::Utf8ToWide(name);
+  const wchar_t* system_name = StringUtilsWin::Utf8ToWide(name);
   bool stat_status = _wstat64(system_name, &st);
   free(const_cast<wchar_t*>(system_name));
   if (stat_status == 0) {
     return ((st.st_mode & S_IFMT) == S_IFREG);
   } else {
     return false;
   }
 }
 
 
 bool File::Create(const char* name) {
-  const wchar_t* system_name = StringUtils::Utf8ToWide(name);
+  const wchar_t* system_name = StringUtilsWin::Utf8ToWide(name);
   int fd = _wopen(system_name, O_RDONLY | O_CREAT, 0666);
   free(const_cast<wchar_t*>(system_name));
   if (fd < 0) {
     return false;
   }
   return (close(fd) == 0);
 }
 
 
 // This structure is needed for creating and reading Junctions.
@@ skipping 25 matching lines @@
         } GenericReparseBuffer;
     };
 } REPARSE_DATA_BUFFER, *PREPARSE_DATA_BUFFER;
 
 
 static const int kReparseDataHeaderSize = sizeof ULONG + 2 * sizeof USHORT;
 static const int kMountPointHeaderSize = 4 * sizeof USHORT;
 
 
 bool File::CreateLink(const char* utf8_name, const char* utf8_target) {
-  const wchar_t* name = StringUtils::Utf8ToWide(utf8_name);
+  const wchar_t* name = StringUtilsWin::Utf8ToWide(utf8_name);
   int create_status = CreateDirectoryW(name, NULL);
   // If the directory already existed, treat it as a success.
   if (create_status == 0 &&
       (GetLastError() != ERROR_ALREADY_EXISTS ||
        (GetFileAttributesW(name) & FILE_ATTRIBUTE_DIRECTORY) != 0)) {
     free(const_cast<wchar_t*>(name));
     return false;
   }
 
   HANDLE dir_handle = CreateFileW(
       name,
       GENERIC_READ | GENERIC_WRITE,
       FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
       NULL,
       OPEN_EXISTING,
       FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT,
       NULL);
   free(const_cast<wchar_t*>(name));
   if (dir_handle == INVALID_HANDLE_VALUE) {
     return false;
   }
 
-  const wchar_t* target = StringUtils::Utf8ToWide(utf8_target);
+  const wchar_t* target = StringUtilsWin::Utf8ToWide(utf8_target);
   int target_len = wcslen(target);
   if (target_len > MAX_PATH - 1) {
     free(const_cast<wchar_t*>(target));
     CloseHandle(dir_handle);
     return false;
   }
 
   int reparse_data_buffer_size =
       sizeof REPARSE_DATA_BUFFER + 2 * MAX_PATH * sizeof WCHAR;
   REPARSE_DATA_BUFFER* reparse_data_buffer =
@@ skipping 23 matching lines @@
       &dummy_received_bytes,
       NULL);
   if (CloseHandle(dir_handle) == 0) return false;
   free(const_cast<wchar_t*>(target));
   free(reparse_data_buffer);
   return (result != 0);
 }
 
 
 bool File::Delete(const char* name) {
-  const wchar_t* system_name = StringUtils::Utf8ToWide(name);
+  const wchar_t* system_name = StringUtilsWin::Utf8ToWide(name);
   int status = _wremove(system_name);
   free(const_cast<wchar_t*>(system_name));
   return status != -1;
 }
 
 
 bool File::DeleteLink(const char* name) {
-  const wchar_t* system_name = StringUtils::Utf8ToWide(name);
+  const wchar_t* system_name = StringUtilsWin::Utf8ToWide(name);
   bool result = false;
   DWORD attributes = GetFileAttributesW(system_name);
   if ((attributes != INVALID_FILE_ATTRIBUTES) &&
       (attributes & FILE_ATTRIBUTE_REPARSE_POINT) != 0) {
     // It's a junction(link), delete it.
     result = (RemoveDirectoryW(system_name) != 0);
   } else {
     SetLastError(ERROR_NOT_A_REPARSE_POINT);
   }
   free(const_cast<wchar_t*>(system_name));
   return result;
 }
 
 
 bool File::Rename(const char* old_path, const char* new_path) {
   File::Type type = GetType(old_path, false);
   if (type == kIsFile) {
-    const wchar_t* system_old_path = StringUtils::Utf8ToWide(old_path);
-    const wchar_t* system_new_path = StringUtils::Utf8ToWide(new_path);
+    const wchar_t* system_old_path = StringUtilsWin::Utf8ToWide(old_path);
+    const wchar_t* system_new_path = StringUtilsWin::Utf8ToWide(new_path);
     DWORD flags = MOVEFILE_WRITE_THROUGH | MOVEFILE_REPLACE_EXISTING;
     int move_status =
         MoveFileExW(system_old_path, system_new_path, flags);
     free(const_cast<wchar_t*>(system_old_path));
     free(const_cast<wchar_t*>(system_new_path));
     return (move_status != 0);
   } else {
     SetLastError(ERROR_FILE_NOT_FOUND);
   }
   return false;
 }
 
 
 bool File::RenameLink(const char* old_path, const char* new_path) {
   File::Type type = GetType(old_path, false);
   if (type == kIsLink) {
-    const wchar_t* system_old_path = StringUtils::Utf8ToWide(old_path);
-    const wchar_t* system_new_path = StringUtils::Utf8ToWide(new_path);
+    const wchar_t* system_old_path = StringUtilsWin::Utf8ToWide(old_path);
+    const wchar_t* system_new_path = StringUtilsWin::Utf8ToWide(new_path);
     DWORD flags = MOVEFILE_WRITE_THROUGH | MOVEFILE_REPLACE_EXISTING;
     int move_status =
         MoveFileExW(system_old_path, system_new_path, flags);
     free(const_cast<wchar_t*>(system_old_path));
     free(const_cast<wchar_t*>(system_new_path));
     return (move_status != 0);
   } else {
     SetLastError(ERROR_FILE_NOT_FOUND);
   }
   return false;
 }
 
 
 bool File::Copy(const char* old_path, const char* new_path) {
   File::Type type = GetType(old_path, false);
   if (type == kIsFile) {
-    const wchar_t* system_old_path = StringUtils::Utf8ToWide(old_path);
-    const wchar_t* system_new_path = StringUtils::Utf8ToWide(new_path);
+    const wchar_t* system_old_path = StringUtilsWin::Utf8ToWide(old_path);
+    const wchar_t* system_new_path = StringUtilsWin::Utf8ToWide(new_path);
     bool success = CopyFileExW(system_old_path,
                                system_new_path,
                                NULL,
                                NULL,
                                NULL,
                                0) != 0;
     free(const_cast<wchar_t*>(system_old_path));
     free(const_cast<wchar_t*>(system_new_path));
     return success;
   } else {
     SetLastError(ERROR_FILE_NOT_FOUND);
   }
   return false;
 }
 
 
 int64_t File::LengthFromPath(const char* name) {
   struct __stat64 st;
-  const wchar_t* system_name = StringUtils::Utf8ToWide(name);
+  const wchar_t* system_name = StringUtilsWin::Utf8ToWide(name);
   int stat_status = _wstat64(system_name, &st);
   free(const_cast<wchar_t*>(system_name));
   if (stat_status == 0) {
     return st.st_size;
   }
   return -1;
 }
 
 
 char* File::LinkTarget(const char* pathname) {
-  const wchar_t* name = StringUtils::Utf8ToWide(pathname);
+  const wchar_t* name = StringUtilsWin::Utf8ToWide(pathname);
   HANDLE dir_handle = CreateFileW(
       name,
       GENERIC_READ,
       FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
       NULL,
       OPEN_EXISTING,
       FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT,
       NULL);
   free(const_cast<wchar_t*>(name));
   if (dir_handle == INVALID_HANDLE_VALUE) {
@@ skipping 76 matching lines @@
   free(buffer);
   return utf8_target;
 }
 
 
 void File::Stat(const char* name, int64_t* data) {
   File::Type type = GetType(name, false);
   data[kType] = type;
   if (type != kDoesNotExist) {
     struct _stat64 st;
-    const wchar_t* system_name = StringUtils::Utf8ToWide(name);
+    const wchar_t* system_name = StringUtilsWin::Utf8ToWide(name);
     int stat_status = _wstat64(system_name, &st);
     free(const_cast<wchar_t*>(system_name));
     if (stat_status == 0) {
       data[kCreatedTime] = st.st_ctime * 1000;
       data[kModifiedTime] = st.st_mtime * 1000;
       data[kAccessedTime] = st.st_atime * 1000;
       data[kMode] = st.st_mode;
       data[kSize] = st.st_size;
     } else {
       data[kType] = File::kDoesNotExist;
     }
   }
 }
 
 
 time_t File::LastModified(const char* name) {
   struct __stat64 st;
-  const wchar_t* system_name = StringUtils::Utf8ToWide(name);
+  const wchar_t* system_name = StringUtilsWin::Utf8ToWide(name);
   int stat_status = _wstat64(system_name, &st);
   free(const_cast<wchar_t*>(system_name));
   if (stat_status == 0) {
     return st.st_mtime;
   }
   return -1;
 }
 
 
 bool File::IsAbsolutePath(const char* pathname) {
   // Should we consider network paths?
   if (pathname == NULL) return false;
   return (strlen(pathname) > 2) &&
       (pathname[1] == ':') &&
       (pathname[2] == '\\' || pathname[2] == '/');
 }
 
 
 char* File::GetCanonicalPath(const char* pathname) {
-  const wchar_t* system_name = StringUtils::Utf8ToWide(pathname);
+  const wchar_t* system_name = StringUtilsWin::Utf8ToWide(pathname);
   HANDLE file_handle = CreateFileW(
         system_name,
         0,
         FILE_SHARE_READ,
         NULL,
         OPEN_EXISTING,
         FILE_FLAG_BACKUP_SEMANTICS,
         NULL);
   if (file_handle == INVALID_HANDLE_VALUE) {
     free(const_cast<wchar_t*>(system_name));
@@ skipping 17 matching lines @@
                                              path,
                                              required_size,
                                              VOLUME_NAME_DOS);
   ASSERT(result_size <= required_size - 1);
   // Remove leading \\?\ if possible, unless input used it.
   char* result;
   if (result_size < MAX_PATH - 1 + 4 &&
       result_size > 4 &&
       wcsncmp(path, L"\\\\?\\", 4) == 0 &&
       wcsncmp(system_name, L"\\\\?\\", 4) != 0) {
-    result = StringUtils::WideToUtf8(path + 4);
+    result = StringUtilsWin::WideToUtf8(path + 4);
   } else {
-    result = StringUtils::WideToUtf8(path);
+    result = StringUtilsWin::WideToUtf8(path);
   }
   free(const_cast<wchar_t*>(system_name));
   free(path);
   CloseHandle(file_handle);
   return result;
 }
 
 
 const char* File::PathSeparator() {
   // This is already UTF-8 encoded.
   return "\\";
 }
 
 
 const char* File::StringEscapedPathSeparator() {
   // This is already UTF-8 encoded.
   return "\\\\";
 }
 
 
 File::StdioHandleType File::GetStdioHandleType(int fd) {
   // Treat all stdio handles as pipes. The Windows event handler and
   // socket code will handle the different handle types.
   return kPipe;
 }
 
 
 File::Type File::GetType(const char* pathname, bool follow_links) {
-  const wchar_t* name = StringUtils::Utf8ToWide(pathname);
+  const wchar_t* name = StringUtilsWin::Utf8ToWide(pathname);
   DWORD attributes = GetFileAttributesW(name);
   File::Type result = kIsFile;
   if (attributes == INVALID_FILE_ATTRIBUTES) {
     result = kDoesNotExist;
   } else if ((attributes & FILE_ATTRIBUTE_REPARSE_POINT) != 0) {
     if (follow_links) {
       HANDLE dir_handle = CreateFileW(
           name,
           0,
           FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
@@ skipping 15 matching lines @@
   }
   free(const_cast<wchar_t*>(name));
   return result;
 }
 
 
 File::Identical File::AreIdentical(const char* file_1, const char* file_2) {
   BY_HANDLE_FILE_INFORMATION file_info[2];
   const char* file_names[2] = { file_1, file_2 };
   for (int i = 0; i < 2; ++i) {
-    const wchar_t* wide_name = StringUtils::Utf8ToWide(file_names[i]);
+    const wchar_t* wide_name = StringUtilsWin::Utf8ToWide(file_names[i]);
     HANDLE file_handle = CreateFileW(
         wide_name,
         0,
         FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
         NULL,
         OPEN_EXISTING,
         FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT,
         NULL);
     if (file_handle == INVALID_HANDLE_VALUE) {
       free(const_cast<wchar_t*>(wide_name));
@@ skipping 17 matching lines @@
     return kIdentical;
   } else {
     return kDifferent;
   }
 }
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // defined(TARGET_OS_WINDOWS)