Fixes some memory leaks in //runtime/bin

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 "platform/globals.h"
 #if defined(TARGET_OS_WINDOWS)
 
 #include <process.h>  // NOLINT
 
 #include "bin/builtin.h"
+#include "bin/dartutils.h"
 #include "bin/process.h"
 #include "bin/eventhandler.h"
 #include "bin/lockers.h"
 #include "bin/log.h"
 #include "bin/socket.h"
 #include "bin/thread.h"
 #include "bin/utils.h"
 #include "bin/utils_win.h"
 
 
@@ skipping 406 matching lines @@
     stdin_handles_[kWriteHandle] = INVALID_HANDLE_VALUE;
     stdout_handles_[kReadHandle] = INVALID_HANDLE_VALUE;
     stdout_handles_[kWriteHandle] = INVALID_HANDLE_VALUE;
     stderr_handles_[kReadHandle] = INVALID_HANDLE_VALUE;
     stderr_handles_[kWriteHandle] = INVALID_HANDLE_VALUE;
     exit_handles_[kReadHandle] = INVALID_HANDLE_VALUE;
     exit_handles_[kWriteHandle] = INVALID_HANDLE_VALUE;
 
     // Transform input strings to system format.
     const wchar_t* system_path = StringUtilsWin::Utf8ToWide(path_);
-    wchar_t** system_arguments = new wchar_t*[arguments_length];
+    wchar_t** system_arguments;
+    system_arguments = reinterpret_cast<wchar_t**>(
+        Dart_ScopeAllocate(arguments_length * sizeof(*system_arguments)));
     for (int i = 0; i < arguments_length; i++) {
        system_arguments[i] = StringUtilsWin::Utf8ToWide(arguments[i]);
     }
 
     // Compute command-line length.
     int command_line_length = wcslen(system_path);
     for (int i = 0; i < arguments_length; i++) {
       command_line_length += wcslen(system_arguments[i]);
     }
     // Account for null termination and one space per argument.
     command_line_length += arguments_length + 1;
 
     // Put together command-line string.
     command_line_ = new wchar_t[command_line_length];
     int len = 0;
     int remaining = command_line_length;
     int written =
         _snwprintf(command_line_ + len, remaining, L"%s", system_path);
     len += written;
     remaining -= written;
     ASSERT(remaining >= 0);
     for (int i = 0; i < arguments_length; i++) {
       written =
           _snwprintf(
               command_line_ + len, remaining, L" %s", system_arguments[i]);
       len += written;
       remaining -= written;
       ASSERT(remaining >= 0);
     }
-    free(const_cast<wchar_t*>(system_path));
-    for (int i = 0; i < arguments_length; i++) free(system_arguments[i]);
-    delete[] system_arguments;
 
     // Create environment block if an environment is supplied.
     environment_block_ = NULL;
     if (environment != NULL) {
-      wchar_t** system_environment = new wchar_t*[environment_length];
+      wchar_t** system_environment;
+      system_environment = reinterpret_cast<wchar_t**>(
+          Dart_ScopeAllocate(environment_length * sizeof(*system_environment)));
       // Convert environment strings to system strings.
       for (intptr_t i = 0; i < environment_length; i++) {
         system_environment[i] = StringUtilsWin::Utf8ToWide(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 += wcslen(system_environment[i]) + 1;
       }
       environment_block_ = new wchar_t[block_size];
       intptr_t block_index = 0;
       for (intptr_t i = 0; i < environment_length; i++) {
         intptr_t len = wcslen(system_environment[i]);
         intptr_t result = _snwprintf(environment_block_ + block_index,
                                      len,
                                      L"%s",
                                      system_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(system_environment[i]);
-      }
-      delete[] system_environment;
     }
 
     system_working_directory_ = NULL;
     if (working_directory_ != NULL) {
       system_working_directory_ =
           StringUtilsWin::Utf8ToWide(working_directory_);
     }
 
     attribute_list_ = NULL;
   }
 
 
   ~ProcessStarter() {
     // Deallocate command-line and environment block strings.
     delete[] command_line_;
     delete[] environment_block_;
-    if (system_working_directory_ != NULL) {
-      free(const_cast<wchar_t*>(system_working_directory_));
-    }
     if (attribute_list_ != NULL) {
       delete_proc_thread_attr_list(attribute_list_);
       free(attribute_list_);
     }
   }
 
 
   int Start() {
     // Create pipes required.
     int err = CreatePipes();
@@ skipping 509 matching lines @@
       USE(SetConsoleCtrlHandler(SignalHandler, false));
     }
   }
   delete handler;
 }
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // defined(TARGET_OS_WINDOWS)