Cleanup 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 "bin/process.h"
+
 #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"
 
-
 namespace dart {
 namespace bin {
 
 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.
@@ skipping 33 matching lines @@
   DWORD process_id_;
   // Process handle.
   HANDLE process_handle_;
   // Wait handle identifying the exit-code wait operation registered
   // with RegisterWaitForSingleObject.
   HANDLE wait_handle_;
   // File descriptor for pipe to report exit code.
   HANDLE exit_pipe_;
   // Link to next ProcessInfo object in the singly-linked list.
   ProcessInfo* next_;
+
+  DISALLOW_COPY_AND_ASSIGN(ProcessInfo);
 };
 
 
 // Singly-linked list of ProcessInfo objects for all active processes
 // started from Dart.
 class ProcessInfoList {
  public:
   static void AddProcess(DWORD pid, HANDLE handle, HANDLE pipe) {
     // Register a callback to extract the exit code, when the process
     // is signaled.  The callback runs in a independent thread from the OS pool.
@@ skipping 51 matching lines @@
       }
       prev = current;
       current = current->next();
     }
   }
 
  private:
   // Callback called when an exit code is available from one of the
   // processes in the list.
   static void CALLBACK ExitCodeCallback(PVOID data, BOOLEAN timed_out) {
-    if (timed_out) return;
+    if (timed_out) {
+      return;
+    }
     DWORD pid = reinterpret_cast<DWORD>(data);
     HANDLE handle;
     HANDLE wait_handle;
     HANDLE exit_pipe;
     bool success = LookupProcess(pid, &handle, &wait_handle, &exit_pipe);
     if (!success) {
       FATAL("Failed to lookup process in list of active processes");
     }
     // Unregister the event in a non-blocking way.
     BOOL ok = UnregisterWait(wait_handle);
-    if (!ok && GetLastError() != ERROR_IO_PENDING) {
+    if (!ok && (GetLastError() != ERROR_IO_PENDING)) {
       FATAL("Failed unregistering wait operation");
     }
     // Get and report the exit code to Dart.
     int exit_code;
-    ok = GetExitCodeProcess(handle,
-                            reinterpret_cast<DWORD*>(&exit_code));
+    ok = GetExitCodeProcess(handle, reinterpret_cast<DWORD*>(&exit_code));
     if (!ok) {
       FATAL1("GetExitCodeProcess failed %d\n", GetLastError());
     }
     int negative = 0;
     if (exit_code < 0) {
       exit_code = abs(exit_code);
       negative = 1;
     }
     int message[2] = { exit_code, negative };
     DWORD written;
     ok = WriteFile(exit_pipe, message, sizeof(message), &written, NULL);
     // If the process has been closed, the read end of the exit
     // pipe has been closed. It is therefore not a problem that
     // WriteFile fails with a closed pipe error
     // (ERROR_NO_DATA). Other errors should not happen.
-    if (ok && written != sizeof(message)) {
+    if (ok && (written != sizeof(message))) {
       FATAL("Failed to write entire process exit message");
-    } else if (!ok && GetLastError() != ERROR_NO_DATA) {
+    } else if (!ok && (GetLastError() != ERROR_NO_DATA)) {
       FATAL1("Failed to write exit code: %d", GetLastError());
     }
     // Remove the process from the list of active processes.
     RemoveProcess(pid);
   }
 
   // Linked list of ProcessInfo objects for all active processes
   // started from Dart code.
   static ProcessInfo* active_processes_;
   // Mutex protecting all accesses to the linked list of active
   // processes.
   static Mutex* mutex_;
+
+  DISALLOW_ALLOCATION();
+  DISALLOW_IMPLICIT_CONSTRUCTORS(ProcessInfoList);
 };
 
 
 ProcessInfo* ProcessInfoList::active_processes_ = NULL;
 Mutex* ProcessInfoList::mutex_ = new Mutex();
 
 
 // Types of pipes to create.
 enum NamedPipeType {
   kInheritRead,
@@ skipping 38 matching lines @@
                     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);
+    ASSERT((type == kInheritWrite) || (type == kInheritNone));
     handles[kReadHandle] =
         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);
 
@@ skipping 87 matching lines @@
 static UpdateProcThreadAttrFn update_proc_thread_attr = NULL;
 static DeleteProcThreadAttrListFn delete_proc_thread_attr_list = NULL;
 
 
 static bool EnsureInitialized() {
   static bool load_attempted = false;
   static Mutex* mutex = new Mutex();
   HMODULE kernel32_module = GetModuleHandleW(L"kernel32.dll");
   if (!load_attempted) {
     MutexLocker locker(mutex);
-    if (load_attempted) return delete_proc_thread_attr_list != NULL;
+    if (load_attempted) {
+      return (delete_proc_thread_attr_list != NULL);
+    }
     init_proc_thread_attr_list = reinterpret_cast<InitProcThreadAttrListFn>(
         GetProcAddress(kernel32_module, "InitializeProcThreadAttributeList"));
-    update_proc_thread_attr =
-        reinterpret_cast<UpdateProcThreadAttrFn>(
-            GetProcAddress(kernel32_module, "UpdateProcThreadAttribute"));
+    update_proc_thread_attr = reinterpret_cast<UpdateProcThreadAttrFn>(
+        GetProcAddress(kernel32_module, "UpdateProcThreadAttribute"));
     delete_proc_thread_attr_list = reinterpret_cast<DeleteProcThreadAttrListFn>(
-        reinterpret_cast<DeleteProcThreadAttrListFn>(
-            GetProcAddress(kernel32_module, "DeleteProcThreadAttributeList")));
+        GetProcAddress(kernel32_module, "DeleteProcThreadAttributeList"));
     load_attempted = true;
-    return delete_proc_thread_attr_list != NULL;
+    return (delete_proc_thread_attr_list != NULL);
   }
-  return delete_proc_thread_attr_list != NULL;
+  return (delete_proc_thread_attr_list != NULL);
 }
 
 
 const int kMaxPipeNameSize = 80;
 template<int Count>
 static int GenerateNames(wchar_t pipe_names[Count][kMaxPipeNameSize]) {
   UUID uuid;
   RPC_STATUS status = UuidCreateSequential(&uuid);
-  if (status != RPC_S_OK && status != RPC_S_UUID_LOCAL_ONLY) {
+  if ((status != RPC_S_OK) && (status != RPC_S_UUID_LOCAL_ONLY)) {
     return status;
   }
   RPC_WSTR uuid_string;
   status = UuidToStringW(&uuid, &uuid_string);
   if (status != RPC_S_OK) {
     return status;
   }
   for (int i = 0; i < Count; i++) {
     static const wchar_t* prefix = L"\\\\.\\Pipe\\dart";
     _snwprintf(pipe_names[i],
@@ skipping 52 matching lines @@
 
     // 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];
+    command_line_ = reinterpret_cast<wchar_t*>(Dart_ScopeAllocate(

[zra, 2016/03/15 18:12:29]

Changed to scope allocated.

+        command_line_length * sizeof(*command_line_)));
     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]);
+      written = _snwprintf(
+          command_line_ + len, remaining, L" %s", system_arguments[i]);
       len += written;
       remaining -= written;
       ASSERT(remaining >= 0);
     }
 
     // Create environment block if an environment is supplied.
     environment_block_ = NULL;
     if (environment != NULL) {
       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];
+      environment_block_ = reinterpret_cast<wchar_t*>(Dart_ScopeAllocate(

[zra, 2016/03/15 18:12:29]

ditto.

+          block_size * sizeof(*environment_block_)));
       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);
     }
 
     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 (attribute_list_ != NULL) {
       delete_proc_thread_attr_list(attribute_list_);
-      free(attribute_list_);
     }
   }
 
 
   int Start() {
     // Create pipes required.
     int err = CreatePipes();
-    if (err != 0) return err;
+    if (err != 0) {
+      return err;
+    }
 
     // Setup info structures.
     STARTUPINFOEXW startup_info;
     ZeroMemory(&startup_info, sizeof(startup_info));
     startup_info.StartupInfo.cb = sizeof(startup_info);
     startup_info.StartupInfo.hStdInput = stdin_handles_[kReadHandle];
     startup_info.StartupInfo.hStdOutput = stdout_handles_[kWriteHandle];
     startup_info.StartupInfo.hStdError = stderr_handles_[kWriteHandle];
     startup_info.StartupInfo.dwFlags = STARTF_USESTDHANDLES;
 
     bool supports_proc_thread_attr_lists = EnsureInitialized();
     if (supports_proc_thread_attr_lists) {
       // Setup the handles to inherit. We only want to inherit the three handles
       // for stdin, stdout and stderr.
       SIZE_T size = 0;
       // The call to determine the size of an attribute list always fails with
       // ERROR_INSUFFICIENT_BUFFER and that error should be ignored.
       if (!init_proc_thread_attr_list(NULL, 1, 0, &size) &&
-          GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
+          (GetLastError() != ERROR_INSUFFICIENT_BUFFER)) {
         return CleanupAndReturnError();
       }
-      attribute_list_ =
-          reinterpret_cast<LPPROC_THREAD_ATTRIBUTE_LIST>(malloc(size));
+      attribute_list_ = reinterpret_cast<LPPROC_THREAD_ATTRIBUTE_LIST>(

[zra, 2016/03/15 18:12:29]

ditto.

+          Dart_ScopeAllocate(size));
       ZeroMemory(attribute_list_, size);
       if (!init_proc_thread_attr_list(attribute_list_, 1, 0, &size)) {
         return CleanupAndReturnError();
       }
       static const int kNumInheritedHandles = 3;
       HANDLE inherited_handles[kNumInheritedHandles] =
           { stdin_handles_[kReadHandle],
             stdout_handles_[kWriteHandle],
             stderr_handles_[kWriteHandle] };
       if (!update_proc_thread_attr(attribute_list_,
@@ skipping 80 matching lines @@
           !CreateProcessPipe(stderr_handles_, pipe_names[2], kInheritWrite)) {
         return CleanupAndReturnError();
       }
       // Only open exit code pipe for non detached processes.
       if (mode_ == kNormal) {
         if (!CreateProcessPipe(exit_handles_, pipe_names[3], kInheritNone)) {
           return CleanupAndReturnError();
         }
       }
     } else {
-      // Open NUL for stdin, stdout and stderr.
-      if ((stdin_handles_[kReadHandle] = OpenNul()) == INVALID_HANDLE_VALUE ||
-          (stdout_handles_[kWriteHandle] = OpenNul()) == INVALID_HANDLE_VALUE ||
-          (stderr_handles_[kWriteHandle] = OpenNul()) == INVALID_HANDLE_VALUE) {
+      // Open NUL for stdin, stdout, and stderr.
+      stdin_handles_[kReadHandle] = OpenNul();
+      if (stdin_handles_[kReadHandle] == INVALID_HANDLE_VALUE) {
+        return CleanupAndReturnError();
+      }
+
+      stdout_handles_[kWriteHandle] = OpenNul();
+      if (stdout_handles_[kWriteHandle] == INVALID_HANDLE_VALUE) {
+        return CleanupAndReturnError();
+      }
+
+      stderr_handles_[kWriteHandle] = OpenNul();
+      if (stderr_handles_[kWriteHandle] == INVALID_HANDLE_VALUE) {
         return CleanupAndReturnError();
       }
     }
     return 0;
   }
 
 
   int CleanupAndReturnError() {
     int error_code = SetOsErrorMessage(os_error_message_);
     CloseProcessPipes(
@@ skipping 14 matching lines @@
 
   const char* path_;
   const char* working_directory_;
   ProcessStartMode mode_;
   intptr_t* in_;
   intptr_t* out_;
   intptr_t* err_;
   intptr_t* id_;
   intptr_t* exit_handler_;
   char** os_error_message_;
+
+ private:
+  DISALLOW_ALLOCATION();
+  DISALLOW_IMPLICIT_CONSTRUCTORS(ProcessStarter);
 };
 
 
 int Process::Start(const char* path,
                    char* arguments[],
                    intptr_t arguments_length,
                    const char* working_directory,
                    char* environment[],
                    intptr_t environment_length,
                    ProcessStartMode mode,
@@ skipping 30 matching lines @@
     ASSERT(read_pending_ == true);
     data_size_ += size;
     free_size_ -= size;
     ASSERT(free_size_ >= 0);
     read_pending_ = false;
   }
 
   // The access to the read buffer for overlapped read.
   void GetReadBuffer(uint8_t** buffer, intptr_t* size) {
     ASSERT(!read_pending_);
-    if (free_size_ == 0) Allocate();
+    if (free_size_ == 0) {
+      Allocate();
+    }
     ASSERT(free_size_ > 0);
     ASSERT(free_size_ <= kBufferSize);
     *buffer = FreeSpaceAddress();
     *size = free_size_;
     read_pending_ = true;
   }
 
   intptr_t GetDataSize() {
     return data_size_;
   }
 
   uint8_t* GetFirstDataBuffer() {
     ASSERT(head_ != NULL);
     ASSERT(head_ == tail_);
     ASSERT(data_size_ <= kBufferSize);
     return head_->data_;
   }
 
   void FreeDataBuffer() {
     Free();
   }
 
  private:
   bool read_pending_;
+
+  DISALLOW_COPY_AND_ASSIGN(BufferList);
 };
 
 
 class OverlappedHandle {
  public:
+  OverlappedHandle() {}
+
   void Init(HANDLE handle, HANDLE event) {
     handle_ = handle;
     event_ = event;
     ClearOverlapped();
   }
 
   bool HasEvent(HANDLE event) {
-    return event_ == event;
+    return (event_ == event);
   }
 
   bool Read() {
     // Get the data read as a result of a completed overlapped operation.
     if (overlapped_.InternalHigh > 0) {
       buffer_.DataIsRead(overlapped_.InternalHigh);
     } else {
       buffer_.DataIsRead(0);
     }
 
     // Keep reading until error or pending operation.
     while (true) {
       ClearOverlapped();
       uint8_t* buffer;
       intptr_t buffer_size;
       buffer_.GetReadBuffer(&buffer, &buffer_size);
       BOOL ok = ReadFile(handle_, buffer, buffer_size, NULL, &overlapped_);
-      if (!ok) return GetLastError() == ERROR_IO_PENDING;
+      if (!ok) {
+        return (GetLastError() == ERROR_IO_PENDING);
+      }
       buffer_.DataIsRead(overlapped_.InternalHigh);
     }
   }
 
   Dart_Handle GetData() {
     return buffer_.GetData();
   }
 
   intptr_t GetDataSize() {
     return buffer_.GetDataSize();
@@ skipping 19 matching lines @@
     memset(&overlapped_, 0, sizeof(overlapped_));
     overlapped_.hEvent = event_;
   }
 
   OVERLAPPED overlapped_;
   HANDLE handle_;
   HANDLE event_;
   BufferList buffer_;
 
   DISALLOW_ALLOCATION();
+  DISALLOW_COPY_AND_ASSIGN(OverlappedHandle);
 };
 
 
 bool Process::Wait(intptr_t pid,
                    intptr_t in,
                    intptr_t out,
                    intptr_t err,
                    intptr_t exit_event,
                    ProcessResult* result) {
   // Close input to the process right away.
@@ skipping 52 matching lines @@
       }
     }
   }
 
   // All handles closed and all data read.
   result->set_stdout_data(oh[0].GetData());
   result->set_stderr_data(oh[1].GetData());
 
   // Calculate the exit code.
   ASSERT(oh[2].GetDataSize() == 8);
-  uint32_t exit[2];
-  memmove(&exit, oh[2].GetFirstDataBuffer(), sizeof(exit));
+  uint32_t exit_codes[2];
+  memmove(&exit_codes, oh[2].GetFirstDataBuffer(), sizeof(exit_codes));
   oh[2].FreeDataBuffer();
-  intptr_t exit_code = exit[0];
-  intptr_t negative = exit[1];
-  if (negative) exit_code = -exit_code;
+  intptr_t exit_code = exit_codes[0];
+  intptr_t negative = exit_codes[1];
+  if (negative) {
+    exit_code = -exit_code;
+  }
   result->set_exit_code(exit_code);
   return true;
 }
 
 
 bool Process::Kill(intptr_t id, int signal) {
   USE(signal);  // signal is not used on Windows.
   HANDLE process_handle;
   HANDLE wait_handle;
   HANDLE exit_pipe;
   // First check the process info list for the process to get a handle to it.
   bool success = ProcessInfoList::LookupProcess(id,
                                                 &process_handle,
                                                 &wait_handle,
                                                 &exit_pipe);
   // For detached processes we don't have the process registered in the
   // process info list. Try to look it up through the OS.
   if (!success) {
     process_handle = OpenProcess(PROCESS_TERMINATE, FALSE, id);
     // The process is already dead.
-    if (process_handle == INVALID_HANDLE_VALUE) return false;
+    if (process_handle == INVALID_HANDLE_VALUE) {
+      return false;
+    }
   }
   BOOL result = TerminateProcess(process_handle, -1);
   return result ? true : false;
 }
 
 
 void Process::TerminateExitCodeHandler() {
   // Nothing needs to be done on Windows.
 }
 
@@ skipping 33 matching lines @@
     case kSighup: return CTRL_CLOSE_EVENT;
     case kSigint: return CTRL_C_EVENT;
     default:
       return -1;
   }
 }
 
 
 intptr_t Process::SetSignalHandler(intptr_t signal) {
   signal = GetWinSignal(signal);
-  if (signal == -1) return -1;
+  if (signal == -1) {
+    return -1;
+  }
 
   // Generate a unique pipe name for the named pipe.
   wchar_t pipe_name[kMaxPipeNameSize];
   int status = GenerateNames<1>(&pipe_name);
-  if (status != 0) return status;
+  if (status != 0) {
+    return status;
+  }
 
   HANDLE fds[2];
   if (!CreateProcessPipe(fds, pipe_name, kInheritNone)) {
     int error_code = GetLastError();
     CloseProcessPipe(fds);
     SetLastError(error_code);
     return -1;
   }
   MutexLocker lock(signal_mutex);
   FileHandle* write_handle = new FileHandle(fds[kWriteHandle]);
   write_handle->EnsureInitialized(EventHandler::delegate());
   intptr_t write_fd = reinterpret_cast<intptr_t>(write_handle);
   if (signal_handlers == NULL) {
     if (SetConsoleCtrlHandler(SignalHandler, true) == 0) {
       int error_code = GetLastError();
       delete write_handle;
       CloseProcessPipe(fds);
       SetLastError(error_code);
       return -1;
     }
   }
   signal_handlers = new SignalInfo(write_fd, signal, signal_handlers);
   return reinterpret_cast<intptr_t>(new FileHandle(fds[kReadHandle]));
 }
 
 
 void Process::ClearSignalHandler(intptr_t signal) {
   signal = GetWinSignal(signal);
-  if (signal == -1) return;
+  if (signal == -1) {
+    return;
+  }
   MutexLocker lock(signal_mutex);
   SignalInfo* handler = signal_handlers;
   while (handler != NULL) {
-    if (handler->port() == Dart_GetMainPortId() &&
-        handler->signal() == signal) {
+    if ((handler->port() == Dart_GetMainPortId()) &&
+        (handler->signal() == signal)) {
       handler->Unlink();
       break;
     }
     handler = handler->next();
   }
   if (handler != NULL) {
     if (signal_handlers == handler) {
       signal_handlers = handler->next();
     }
     if (signal_handlers == NULL) {
       USE(SetConsoleCtrlHandler(SignalHandler, false));
     }
   }
   delete handler;
 }
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // defined(TARGET_OS_WINDOWS)