Complete the transition to unicode APIs on Windows.

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/log.h"
@@ skipping 184 matching lines @@
   kInheritNone
 };
 
 
 // Create a pipe for communicating with a new process. The handles array
 // will contain the read and write ends of the pipe. Based on the type
 // one of the handles will be inheritable.
 // NOTE: If this function returns false the handles might have been allocated
 // and the caller should make sure to close them in case of an error.
 static bool CreateProcessPipe(HANDLE handles[2],
-                              char* pipe_name,
+                              wchar_t* pipe_name,
                               NamedPipeType type) {
   // Security attributes describing an inheritable handle.
   SECURITY_ATTRIBUTES inherit_handle;
   inherit_handle.nLength = sizeof(SECURITY_ATTRIBUTES);
   inherit_handle.bInheritHandle = TRUE;
   inherit_handle.lpSecurityDescriptor = NULL;
 
   if (type == kInheritRead) {
     handles[kWriteHandle] =
-        CreateNamedPipe(pipe_name,
-                        PIPE_ACCESS_OUTBOUND | FILE_FLAG_OVERLAPPED,
-                        PIPE_TYPE_BYTE | PIPE_WAIT,
-                        1,             // Number of pipes
-                        1024,          // Out buffer size
-                        1024,          // In buffer size
-                        0,             // Timeout in ms
-                        NULL);
+        CreateNamedPipeW(pipe_name,
+                         PIPE_ACCESS_OUTBOUND | FILE_FLAG_OVERLAPPED,
+                         PIPE_TYPE_BYTE | PIPE_WAIT,
+                         1,             // Number of pipes
+                         1024,          // Out buffer size
+                         1024,          // In buffer size
+                         0,             // Timeout in ms
+                         NULL);
 
     if (handles[kWriteHandle] == INVALID_HANDLE_VALUE) {
       Log::PrintErr("CreateNamedPipe failed %d\n", GetLastError());
       return false;
     }
 
     handles[kReadHandle] =
-        CreateFile(pipe_name,
-                   GENERIC_READ,
-                   0,
-                   &inherit_handle,
-                   OPEN_EXISTING,
-                   FILE_READ_ATTRIBUTES | FILE_FLAG_OVERLAPPED,
-                   NULL);
+        CreateFileW(pipe_name,
+                    GENERIC_READ,
+                    0,
+                    &inherit_handle,
+                    OPEN_EXISTING,
+                    FILE_READ_ATTRIBUTES | FILE_FLAG_OVERLAPPED,
+                    NULL);
     if (handles[kReadHandle] == INVALID_HANDLE_VALUE) {
       Log::PrintErr("CreateFile failed %d\n", GetLastError());
       return false;
     }
   } else {
     ASSERT(type == kInheritWrite || type == kInheritNone);
     handles[kReadHandle] =
-        CreateNamedPipe(pipe_name,
-                        PIPE_ACCESS_INBOUND | FILE_FLAG_OVERLAPPED,
-                        PIPE_TYPE_BYTE | PIPE_WAIT,
-                        1,             // Number of pipes
-                        1024,          // Out buffer size
-                        1024,          // In buffer size
-                        0,             // Timeout in ms
-                        NULL);
+        CreateNamedPipeW(pipe_name,
+                         PIPE_ACCESS_INBOUND | FILE_FLAG_OVERLAPPED,
+                         PIPE_TYPE_BYTE | PIPE_WAIT,
+                         1,             // Number of pipes
+                         1024,          // Out buffer size
+                         1024,          // In buffer size
+                         0,             // Timeout in ms
+                         NULL);
 
     if (handles[kReadHandle] == INVALID_HANDLE_VALUE) {
       Log::PrintErr("CreateNamedPipe failed %d\n", GetLastError());
       return false;
     }
 
     handles[kWriteHandle] =
-        CreateFile(pipe_name,
-                   GENERIC_WRITE,
-                   0,
-                   (type == kInheritWrite) ? &inherit_handle : NULL,
-                   OPEN_EXISTING,
-                   FILE_WRITE_ATTRIBUTES | FILE_FLAG_OVERLAPPED,
-                   NULL);
+        CreateFileW(pipe_name,
+                    GENERIC_WRITE,
+                    0,
+                    (type == kInheritWrite) ? &inherit_handle : NULL,
+                    OPEN_EXISTING,
+                    FILE_WRITE_ATTRIBUTES | FILE_FLAG_OVERLAPPED,
+                    NULL);
     if (handles[kWriteHandle] == INVALID_HANDLE_VALUE) {
       Log::PrintErr("CreateFile failed %d\n", GetLastError());
       return false;
     }
   }
   return true;
 }
 
 
 static void CloseProcessPipe(HANDLE handles[2]) {
@@ skipping 54 matching lines @@
                    intptr_t* err,
                    intptr_t* id,
                    intptr_t* exit_handler,
                    char** os_error_message) {
   HANDLE stdin_handles[2] = { INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE };
   HANDLE stdout_handles[2] = { INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE };
   HANDLE stderr_handles[2] = { INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE };
   HANDLE exit_handles[2] = { INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE };
 
   // Generate unique pipe names for the four named pipes needed.
-  char pipe_names[4][80];
+  static const int kMaxPipeNameSize = 80;
+  wchar_t pipe_names[4][kMaxPipeNameSize];
   UUID uuid;
   RPC_STATUS status = UuidCreateSequential(&uuid);
   if (status != RPC_S_OK && status != RPC_S_UUID_LOCAL_ONLY) {
     SetOsErrorMessage(os_error_message);
     Log::PrintErr("UuidCreateSequential failed %d\n", status);
     return status;
   }
-  RPC_CSTR uuid_string;
-  status = UuidToString(&uuid, &uuid_string);
+  RPC_WSTR uuid_string;
+  status = UuidToStringW(&uuid, &uuid_string);
   if (status != RPC_S_OK) {
     SetOsErrorMessage(os_error_message);
     Log::PrintErr("UuidToString failed %d\n", status);
     return status;
   }
   for (int i = 0; i < 4; i++) {
-    static const char* prefix = "\\\\.\\Pipe\\dart";
-    snprintf(pipe_names[i],
-             sizeof(pipe_names[i]),
-             "%s_%s_%d", prefix, uuid_string, i + 1);
+    static const wchar_t* prefix = L"\\\\.\\Pipe\\dart";
+    _snwprintf(pipe_names[i],
+               kMaxPipeNameSize,
+               L"%s_%s_%d", prefix, uuid_string, i + 1);
   }
-  status = RpcStringFree(&uuid_string);
+  status = RpcStringFreeW(&uuid_string);
   if (status != RPC_S_OK) {
     SetOsErrorMessage(os_error_message);
     Log::PrintErr("RpcStringFree failed %d\n", status);
     return status;
   }
 
   if (!CreateProcessPipe(stdin_handles, pipe_names[0], kInheritRead)) {
     int error_code = SetOsErrorMessage(os_error_message);
     CloseProcessPipes(
         stdin_handles, stdout_handles, stderr_handles, exit_handles);
@@ skipping 233 matching lines @@
 
 
 void Process::TerminateExitCodeHandler() {
   // Nothing needs to be done on Windows.
 }
 
 
 intptr_t Process::CurrentProcessId() {
   return static_cast<intptr_t>(GetCurrentProcessId());
 }