[windows] Make most file_win.cc functions use malloc for string conversions.

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
@@ skipping 215 matching lines @@
       (((mode & kWriteOnly) != 0) && ((mode & kTruncate) == 0))) {
     int64_t position = _lseeki64(fd, 0, SEEK_END);
     if (position < 0) {
       return NULL;
     }
   }
   return new File(new FileHandle(fd));
 }
 
 
-File* File::ScopedOpen(const char* name, FileOpenMode mode) {
-  const wchar_t* system_name = StringUtilsWin::Utf8ToWide(name);
-  return FileOpenW(system_name, mode);
-}
-
-
 File* File::Open(const char* path, FileOpenMode mode) {
-  int path_len = MultiByteToWideChar(CP_UTF8, 0, path, -1, NULL, 0);
-  wchar_t* system_name = new wchar_t[path_len];
-  if (system_name == NULL) {
-    return NULL;
-  }
-  MultiByteToWideChar(CP_UTF8, 0, path, -1, system_name, path_len);
-  File* file = FileOpenW(system_name, mode);
-  delete[] system_name;
+  Utf8ToWideScope system_name(path);
+  File* file = FileOpenW(system_name.wide(), mode);
   return file;
 }
 
 
 File* File::OpenStdio(int fd) {
   switch (fd) {
     case 1:
       fd = _fileno(stdout);
       break;
     case 2:
       fd = _fileno(stderr);
       break;
     default:
       UNREACHABLE();
   }
   _setmode(fd, _O_BINARY);
   return new File(new FileHandle(fd));
 }
 
 
 bool File::Exists(const char* name) {
   struct __stat64 st;
-  const wchar_t* system_name = StringUtilsWin::Utf8ToWide(name);
-  bool stat_status = _wstat64(system_name, &st);
+  Utf8ToWideScope system_name(name);
+  bool stat_status = _wstat64(system_name.wide(), &st);
   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 = StringUtilsWin::Utf8ToWide(name);
-  int fd = _wopen(system_name, O_RDONLY | O_CREAT, 0666);
+  Utf8ToWideScope system_name(name);
+  int fd = _wopen(system_name.wide(), O_RDONLY | O_CREAT, 0666);
   if (fd < 0) {
     return false;
   }
   return (close(fd) == 0);
 }
 
 
 // This structure is needed for creating and reading Junctions.
 typedef struct _REPARSE_DATA_BUFFER {
     ULONG  ReparseTag;
@@ skipping 23 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 = StringUtilsWin::Utf8ToWide(utf8_name);
-  int create_status = CreateDirectoryW(name, NULL);
+  Utf8ToWideScope name(utf8_name);
+  int create_status = CreateDirectoryW(name.wide(), 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))) {
+       ((GetFileAttributesW(name.wide()) & FILE_ATTRIBUTE_DIRECTORY) != 0))) {
     return false;
   }
 
   HANDLE dir_handle = CreateFileW(
-      name,
+      name.wide(),
       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);
   if (dir_handle == INVALID_HANDLE_VALUE) {
     return false;
   }
 
-  const wchar_t* target = StringUtilsWin::Utf8ToWide(utf8_target);
-  int target_len = wcslen(target);
+  Utf8ToWideScope target(utf8_target);
+  int target_len = wcslen(target.wide());
   if (target_len > MAX_PATH - 1) {
     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 =
-      reinterpret_cast<REPARSE_DATA_BUFFER*>(Dart_ScopeAllocate(
-          reparse_data_buffer_size));
+      reinterpret_cast<REPARSE_DATA_BUFFER*>(malloc(reparse_data_buffer_size));
   reparse_data_buffer->ReparseTag = IO_REPARSE_TAG_MOUNT_POINT;
-  wcscpy(reparse_data_buffer->MountPointReparseBuffer.PathBuffer, target);
+  wcscpy(reparse_data_buffer->MountPointReparseBuffer.PathBuffer,
+         target.wide());
   wcscpy(
       reparse_data_buffer->MountPointReparseBuffer.PathBuffer + target_len + 1,
-      target);
+      target.wide());
   reparse_data_buffer->MountPointReparseBuffer.SubstituteNameOffset = 0;
   reparse_data_buffer->MountPointReparseBuffer.SubstituteNameLength =
       target_len * sizeof WCHAR;
   reparse_data_buffer->MountPointReparseBuffer.PrintNameOffset =
       (target_len + 1) * sizeof WCHAR;
   reparse_data_buffer->MountPointReparseBuffer.PrintNameLength =
       target_len * sizeof WCHAR;
   reparse_data_buffer->ReparseDataLength =
       (target_len + 1) * 2 * sizeof WCHAR + kMountPointHeaderSize;
   DWORD dummy_received_bytes;
   int result = DeviceIoControl(
       dir_handle,
       FSCTL_SET_REPARSE_POINT,
       reparse_data_buffer,
       reparse_data_buffer->ReparseDataLength + kReparseDataHeaderSize,
       NULL,
       0,
       &dummy_received_bytes,
       NULL);
+  free(reparse_data_buffer);
   if (CloseHandle(dir_handle) == 0) {
     return false;
   }
   return (result != 0);
 }
 
 
 bool File::Delete(const char* name) {
-  const wchar_t* system_name = StringUtilsWin::Utf8ToWide(name);
-  int status = _wremove(system_name);
+  Utf8ToWideScope system_name(name);
+  int status = _wremove(system_name.wide());
   return status != -1;
 }
 
 
 bool File::DeleteLink(const char* name) {
-  const wchar_t* system_name = StringUtilsWin::Utf8ToWide(name);
+  Utf8ToWideScope system_name(name);
   bool result = false;
-  DWORD attributes = GetFileAttributesW(system_name);
+  DWORD attributes = GetFileAttributesW(system_name.wide());
   if ((attributes != INVALID_FILE_ATTRIBUTES) &&
       (attributes & FILE_ATTRIBUTE_REPARSE_POINT) != 0) {
     // It's a junction(link), delete it.
-    result = (RemoveDirectoryW(system_name) != 0);
+    result = (RemoveDirectoryW(system_name.wide()) != 0);
   } else {
     SetLastError(ERROR_NOT_A_REPARSE_POINT);
   }
   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 = StringUtilsWin::Utf8ToWide(old_path);
-    const wchar_t* system_new_path = StringUtilsWin::Utf8ToWide(new_path);
+    Utf8ToWideScope system_old_path(old_path);
+    Utf8ToWideScope system_new_path(new_path);
     DWORD flags = MOVEFILE_WRITE_THROUGH | MOVEFILE_REPLACE_EXISTING;
     int move_status =
-        MoveFileExW(system_old_path, system_new_path, flags);
+        MoveFileExW(system_old_path.wide(), system_new_path.wide(), flags);
     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 = StringUtilsWin::Utf8ToWide(old_path);
-    const wchar_t* system_new_path = StringUtilsWin::Utf8ToWide(new_path);
+    Utf8ToWideScope system_old_path(old_path);
+    Utf8ToWideScope system_new_path(new_path);
     DWORD flags = MOVEFILE_WRITE_THROUGH | MOVEFILE_REPLACE_EXISTING;
     int move_status =
-        MoveFileExW(system_old_path, system_new_path, flags);
+        MoveFileExW(system_old_path.wide(), system_new_path.wide(), flags);
     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 = StringUtilsWin::Utf8ToWide(old_path);
-    const wchar_t* system_new_path = StringUtilsWin::Utf8ToWide(new_path);
-    bool success = CopyFileExW(system_old_path,
-                               system_new_path,
+    Utf8ToWideScope system_old_path(old_path);
+    Utf8ToWideScope system_new_path(new_path);
+    bool success = CopyFileExW(system_old_path.wide(),
+                               system_new_path.wide(),
                                NULL,
                                NULL,
                                NULL,
                                0) != 0;
     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 = StringUtilsWin::Utf8ToWide(name);
-  int stat_status = _wstat64(system_name, &st);
+  Utf8ToWideScope system_name(name);
+  int stat_status = _wstat64(system_name.wide(), &st);
   if (stat_status == 0) {
     return st.st_size;
   }
   return -1;
 }
 
 
 const char* File::LinkTarget(const char* pathname) {
   const wchar_t* name = StringUtilsWin::Utf8ToWide(pathname);
   HANDLE dir_handle = CreateFileW(
@@ skipping 78 matching lines @@
   utf8_target[utf8_length] = '\0';
   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 = StringUtilsWin::Utf8ToWide(name);
-    int stat_status = _wstat64(system_name, &st);
+    Utf8ToWideScope system_name(name);
+    int stat_status = _wstat64(system_name.wide(), &st);
     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 = StringUtilsWin::Utf8ToWide(name);
-  int stat_status = _wstat64(system_name, &st);
+  Utf8ToWideScope system_name(name);
+  int stat_status = _wstat64(system_name.wide(), &st);
   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] == '/')));
 }
 
 
 const char* File::GetCanonicalPath(const char* pathname) {
-  const wchar_t* system_name = StringUtilsWin::Utf8ToWide(pathname);
+  Utf8ToWideScope system_name(pathname);
   HANDLE file_handle = CreateFileW(
-        system_name,
+        system_name.wide(),
         0,
         FILE_SHARE_READ,
         NULL,
         OPEN_EXISTING,
         FILE_FLAG_BACKUP_SEMANTICS,
         NULL);
   if (file_handle == INVALID_HANDLE_VALUE) {
     return NULL;
   }
   wchar_t dummy_buffer[1];
@@ skipping 13 matching lines @@
   int result_size = GetFinalPathNameByHandle(file_handle,
                                              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)) {
+      (wcsncmp(system_name.wide(), L"\\\\?\\", 4) != 0)) {
     result = StringUtilsWin::WideToUtf8(path + 4);
   } else {
     result = StringUtilsWin::WideToUtf8(path);
   }
   CloseHandle(file_handle);
   return result;
 }
 
 
 const char* File::PathSeparator() {
@@ skipping 10 matching lines @@
 
 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) {
   // Convert to wchar_t string.
-  int name_len = MultiByteToWideChar(CP_UTF8, 0, pathname, -1, NULL, 0);
-  wchar_t* name;
-  name = new wchar_t[name_len];
-  MultiByteToWideChar(CP_UTF8, 0, pathname, -1, name, name_len);
-
-  DWORD attributes = GetFileAttributesW(name);
+  Utf8ToWideScope name(pathname);
+  DWORD attributes = GetFileAttributesW(name.wide());
   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,
+          name.wide(),
           0,
           FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
           NULL,
           OPEN_EXISTING,
           FILE_FLAG_BACKUP_SEMANTICS,
           NULL);
       if (dir_handle == INVALID_HANDLE_VALUE) {
         result = File::kIsLink;
       } else {
         CloseHandle(dir_handle);
         result = File::kIsDirectory;
       }
     } else {
       result = kIsLink;
     }
   } else if ((attributes & FILE_ATTRIBUTE_DIRECTORY) != 0) {
     result = kIsDirectory;
   }
-  delete[] 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 = StringUtilsWin::Utf8ToWide(file_names[i]);
+    Utf8ToWideScope wide_name(file_names[i]);
     HANDLE file_handle = CreateFileW(
-        wide_name,
+        wide_name.wide(),
         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) {
       return File::kError;
     }
     int result = GetFileInformationByHandle(file_handle, &file_info[i]);
@@ skipping 14 matching lines @@
     return kIdentical;
   } else {
     return kDifferent;
   }
 }
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // defined(TARGET_OS_WINDOWS)