Update dart:io to convert strings between UTF8 and current code page

runtime/bin/process_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 <process.h>
 
 #include "bin/builtin.h"
 #include "bin/process.h"
 #include "bin/eventhandler.h"
 #include "bin/thread.h"
+#include "bin/utils.h"
 #include "platform/globals.h"
 
 static const int kReadHandle = 0;
 static const int kWriteHandle = 1;
 
 
 // ProcessInfo is used to map a process id to the process handle,
 // wait handle for registered exit code event and the pipe used to
 // communicate the exit code of the process to Dart.
 // ProcessInfo objects are kept in the static singly-linked
@@ skipping 370 matching lines @@
   ZeroMemory(&startup_info, sizeof(startup_info));
   startup_info.cb = sizeof(startup_info);
   startup_info.hStdInput = stdin_handles[kReadHandle];
   startup_info.hStdOutput = stdout_handles[kWriteHandle];
   startup_info.hStdError = stderr_handles[kWriteHandle];
   startup_info.dwFlags = STARTF_USESTDHANDLES;
 
   PROCESS_INFORMATION process_info;
   ZeroMemory(&process_info, sizeof(process_info));
 
+  // Transform input strings to system format.
+  path = StringUtils::Utf8ToSystemString(path);
+  for (int i = 0; i < arguments_length; i++) {
+     arguments[i] = StringUtils::Utf8ToSystemString(arguments[i]);
+  }
+
   // Compute command-line length.
   int command_line_length = strlen(path);
   for (int i = 0; i < arguments_length; i++) {
     command_line_length += strlen(arguments[i]);
   }
   // Account for null termination and one space per argument.
   command_line_length += arguments_length + 1;
   static const int kMaxCommandLineLength = 32768;
   if (command_line_length > kMaxCommandLineLength) {
     int error_code = SetOsErrorMessage(os_error_message, os_error_message_len);
     CloseProcessPipes(
         stdin_handles, stdout_handles, stderr_handles, exit_handles);
+    free(const_cast<char*>(path));
+    for (int i = 0; i < arguments_length; i++) free(arguments[i]);
     return error_code;
   }
 
   // Put together command-line string.
   char* command_line = new char[command_line_length];
   int len = 0;
   int remaining = command_line_length;
   int written = snprintf(command_line + len, remaining, "%s", path);
   len += written;
   remaining -= written;
   ASSERT(remaining >= 0);
   for (int i = 0; i < arguments_length; i++) {
     written = snprintf(command_line + len, remaining, " %s", arguments[i]);
     len += written;
     remaining -= written;
     ASSERT(remaining >= 0);
   }
+  free(const_cast<char*>(path));
+  for (int i = 0; i < arguments_length; i++) free(arguments[i]);
 
   // Create environment block if an environment is supplied.
   char* environment_block = NULL;
   if (environment != NULL) {
+    // Convert environment strings to system strings.
+    for (intptr_t i = 0; i < environment_length; i++) {
+      environment[i] = StringUtils::Utf8ToSystemString(environment[i]);
+    }
+
     // An environment block is a sequence of zero-terminated strings
     // followed by a block-terminating zero char.
     intptr_t block_size = 1;
     for (intptr_t i = 0; i < environment_length; i++) {
       block_size += strlen(environment[i]) + 1;
     }
     environment_block = new char[block_size];
     intptr_t block_index = 0;
     for (intptr_t i = 0; i < environment_length; i++) {
       intptr_t len = strlen(environment[i]);
       intptr_t result = snprintf(environment_block + block_index,
                                  len,
                                  "%s",
                                  environment[i]);
       ASSERT(result == len);
       block_index += len;
       environment_block[block_index++] = '\0';
     }
     // Block-terminating zero char.
     environment_block[block_index++] = '\0';
     ASSERT(block_index == block_size);
+    for (intptr_t i = 0; i < environment_length; i++) free(environment[i]);
+  }
+
+  if (working_directory != NULL) {
+    working_directory = StringUtils::Utf8ToSystemString(working_directory);
   }
 
   // Create process.
   BOOL result = CreateProcess(NULL,   // ApplicationName
                               command_line,
                               NULL,   // ProcessAttributes
                               NULL,   // ThreadAttributes
                               TRUE,   // InheritHandles
                               0,      // CreationFlags
                               environment_block,
                               working_directory,
                               &startup_info,
                               &process_info);
 
   // Deallocate command-line and environment block strings.
   delete[] command_line;
   delete[] environment_block;
+  if (working_directory != NULL) {
+    free(const_cast<char*>(working_directory));
+  }
 
   if (result == 0) {
     int error_code = SetOsErrorMessage(os_error_message, os_error_message_len);
     CloseProcessPipes(
         stdin_handles, stdout_handles, stderr_handles, exit_handles);
     return error_code;
   }
 
   ProcessInfoList::AddProcess(process_info.dwProcessId,
                               process_info.hProcess,
@@ skipping 37 matching lines @@
 
 
 void Process::TerminateExitCodeHandler() {
   // Nothing needs to be done on Windows.
 }
 
 
 intptr_t Process::CurrentProcessId() {
   return static_cast<intptr_t>(GetCurrentProcessId());
 }