Fix Process.runSync error handling.

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.
 
 #if !defined(DART_IO_DISABLED)
 
 #include "platform/globals.h"
 #if defined(TARGET_OS_WINDOWS)
 
 #include "bin/process.h"
@@ skipping 696 matching lines @@
 
 
 class BufferList : public BufferListBase {
  public:
   BufferList() : read_pending_(true) {}
 
   // Indicate that data has been read into the buffer provided to
   // overlapped read.
   void DataIsRead(intptr_t size) {
     ASSERT(read_pending_ == true);
-    data_size_ += size;
-    free_size_ -= size;
-    ASSERT(free_size_ >= 0);
+    set_data_size(data_size() + size);
+    set_free_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) {
+  bool GetReadBuffer(uint8_t** buffer, intptr_t* size) {
     ASSERT(!read_pending_);
-    if (free_size_ == 0) {
-      Allocate();
+    if (free_size() == 0) {
+      if (!Allocate()) {
+        return false;
+      }
     }
-    ASSERT(free_size_ > 0);
-    ASSERT(free_size_ <= kBufferSize);
+    ASSERT(free_size() > 0);
+    ASSERT(free_size() <= kBufferSize);
     *buffer = FreeSpaceAddress();
-    *size = free_size_;
+    *size = free_size();
     read_pending_ = true;
+    return true;
   }
 
-  intptr_t GetDataSize() { return data_size_; }
+  intptr_t GetDataSize() { return data_size(); }
 
   uint8_t* GetFirstDataBuffer() {
-    ASSERT(head_ != NULL);
-    ASSERT(head_ == tail_);
-    ASSERT(data_size_ <= kBufferSize);
-    return head_->data_;
+    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);
 };
 
@@ skipping 16 matching lines @@
       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);
+      if (!buffer_.GetReadBuffer(&buffer, &buffer_size)) {
+        return false;
+      }
       BOOL ok = ReadFile(handle_, buffer, buffer_size, NULL, &overlapped_);
       if (!ok) {
         return (GetLastError() == ERROR_IO_PENDING);
       }
       buffer_.DataIsRead(overlapped_.InternalHigh);
     }
   }
 
   Dart_Handle GetData() { return buffer_.GetData(); }
 
   intptr_t GetDataSize() { return buffer_.GetDataSize(); }
 
   uint8_t* GetFirstDataBuffer() { return buffer_.GetFirstDataBuffer(); }
 
   void FreeDataBuffer() { return buffer_.FreeDataBuffer(); }
 
+#if defined(DEBUG)
+  bool IsEmpty() const { return buffer_.IsEmpty(); }
+#endif
+
   void Close() {
     CloseHandle(handle_);
     CloseHandle(event_);
     handle_ = INVALID_HANDLE_VALUE;
     overlapped_.hEvent = INVALID_HANDLE_VALUE;
   }
 
  private:
   void ClearOverlapped() {
     memset(&overlapped_, 0, sizeof(overlapped_));
@@ skipping 69 matching lines @@
           }
         }
         break;
       }
     }
   }
 
   // All handles closed and all data read.
   result->set_stdout_data(oh[0].GetData());
   result->set_stderr_data(oh[1].GetData());
+  DEBUG_ASSERT(oh[0].IsEmpty());
+  DEBUG_ASSERT(oh[1].IsEmpty());
 
   // Calculate the exit code.
   ASSERT(oh[2].GetDataSize() == 8);
   uint32_t exit_codes[2];
   memmove(&exit_codes, oh[2].GetFirstDataBuffer(), sizeof(exit_codes));
   oh[2].FreeDataBuffer();
   intptr_t exit_code = exit_codes[0];
   intptr_t negative = exit_codes[1];
   if (negative != 0) {
     exit_code = -exit_code;
@@ skipping 135 matching lines @@
   }
   delete handler;
 }
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // defined(TARGET_OS_WINDOWS)
 
 #endif  // !defined(DART_IO_DISABLED)