Add Process.runSync for running processe synchronously.

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"
@@ skipping 624 matching lines @@
   *exit_handler = reinterpret_cast<intptr_t>(exit_handle);
 
   CloseHandle(process_info.hThread);
 
   // Return process id.
   *id = process_info.dwProcessId;
   return 0;
 }
 
 
+class OverlappedHandle {
+ public:
+  static const int kBufferSize = 16 * 1024;
+
+  void Init(HANDLE handle, HANDLE event) {
+    handle_ = handle;
+    event_ = event;
+    ClearOverlapped();
+    data_ = NULL;
+    data_length_ = 0;
+  }
+
+  bool HasEvent(HANDLE event) {
+    return event_ == event;
+  }
+
+  bool Read() {
+    // Get the data read as a rasult of a completed overlapped operation.
+    if (overlapped_.InternalHigh > 0) {
+      AddData(overlapped_.InternalHigh);
+    }
+
+    // Keep reading until error or pending operation.
+    while (true) {
+      ClearOverlapped();
+      BOOL ok = ReadFile(handle_, buffer_, kBufferSize, NULL, &overlapped_);
+      if (!ok) return GetLastError() == ERROR_IO_PENDING;
+      AddData(overlapped_.InternalHigh);
+    }
+  }
+
+  uint8_t* data() { return data_; }
+  intptr_t data_length() { return data_length_; }
+
+  void Close() {
+    CloseHandle(handle_);
+    CloseHandle(event_);
+    handle_ = INVALID_HANDLE_VALUE;
+    overlapped_.hEvent = INVALID_HANDLE_VALUE;
+  }
+
+  void FreeData() {
+    free(data_);
+    data_ = NULL;
+    data_length_ = 0;
+  }
+
+  void Destroy() {
+    Close();
+    FreeData();
+  }
+
+ private:
+  void ClearOverlapped() {
+    memset(&overlapped_, 0, sizeof(overlapped_));
+    overlapped_.hEvent = event_;
+  }
+
+  void AddData(DWORD length) {
+    uint8_t* tmp = new uint8_t[data_length_ + length];
+    if (tmp == NULL) FATAL("Allocation failed");
+    memmove(tmp, data_, data_length_);
+    memmove(tmp + data_length_, buffer_, length);
+    delete[] data_;
+    data_ = tmp;
+    data_length_ += length;
+  }
+
+  OVERLAPPED overlapped_;
+  HANDLE handle_;
+  HANDLE event_;
+  char buffer_[kBufferSize];
+  uint8_t* data_;
+  intptr_t data_length_;
+
+  DISALLOW_ALLOCATION();
+};
+
+
+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.
+  reinterpret_cast<FileHandle*>(in)->Close();
+
+  // All pipes created to the sub-process supports overlapped IO.
+  FileHandle* stdout_handle = reinterpret_cast<FileHandle*>(out);
+  ASSERT(stdout_handle->SupportsOverlappedIO());
+  FileHandle* stderr_handle = reinterpret_cast<FileHandle*>(err);
+  ASSERT(stderr_handle->SupportsOverlappedIO());
+  FileHandle* exit_handle = reinterpret_cast<FileHandle*>(exit_event);
+  ASSERT(exit_handle->SupportsOverlappedIO());
+
+  // Create three events for overlapped IO. These are created as already
+  // signalled to ensure they have read called at least once.
+  static const int kHandles = 3;
+  HANDLE events[kHandles];
+  for (int i = 0; i < kHandles; i++) {
+    events[i] = CreateEvent(NULL, FALSE, TRUE, NULL);
+  }
+
+  // Setup the structure for handling overlapped IO.
+  OverlappedHandle oh[kHandles];
+  memset(&oh, 0, sizeof(oh));
+  oh[0].Init(stdout_handle->handle(), events[0]);
+  oh[1].Init(stderr_handle->handle(), events[1]);
+  oh[2].Init(exit_handle->handle(), events[2]);
+
+  // Continue until all handles are closed.
+  int alive = kHandles;
+  while (alive > 0) {
+    // Wait for event to become signalled.
+    DWORD wait_result = WaitForMultipleObjects(alive, events, FALSE, INFINITE);
+
+    // Find the handle signalled.
+    int index = wait_result - WAIT_OBJECT_0;
+    for (int i = 0; i < kHandles; i++) {
+      if (oh[i].HasEvent(events[index])) {
+        bool ok = oh[i].Read();
+        if (!ok) {
+          if (GetLastError() == ERROR_BROKEN_PIPE) {
+            oh[i].Close();
+            alive--;
+            if (index < alive) {
+              events[index] = events[alive];
+            }
+          } else if (err != ERROR_IO_PENDING) {
+            DWORD e = GetLastError();
+            oh[0].Destroy();
+            oh[1].Destroy();
+            oh[2].Destroy();
+            SetLastError(e);
+            return false;
+          }
+        }
+        break;
+      }
+    }
+  }
+
+  // All handles closed and all data read.
+  result->SetStdoutData(oh[0].data(), oh[0].data_length());
+  result->SetStderrData(oh[1].data(), oh[1].data_length());
+
+  // Calculate the exit code.
+  ASSERT(oh[2].data_length() == 8);
+  uint32_t exit[2];
+  memcpy(&exit, oh[2].data(), sizeof(exit));
+  oh[2].FreeData();
+  intptr_t exit_code = exit[0];
+  intptr_t negative = exit[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;
   bool success = ProcessInfoList::LookupProcess(id,
                                                 &process_handle,
                                                 &wait_handle,
                                                 &exit_pipe);
   // The process is already dead.
   if (!success) return false;
   BOOL result = TerminateProcess(process_handle, -1);
   return result ? true : false;
 }
 
 
 void Process::TerminateExitCodeHandler() {
   // Nothing needs to be done on Windows.
 }
 
 
 intptr_t Process::CurrentProcessId() {
   return static_cast<intptr_t>(GetCurrentProcessId());
 }
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // defined(TARGET_OS_WINDOWS)