[dart:io] Don't close stdin with a socket finalizer

runtime/bin/eventhandler_win.cc

 // Copyright (c) 2013, 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(HOST_OS_WINDOWS)
 
 #include "bin/eventhandler.h"
@@ skipping 138 matching lines @@
   return (completion_port_ != NULL);
 }
 
 
 void Handle::Close() {
   MonitorLocker ml(monitor_);
   if (!SupportsOverlappedIO()) {
     // If the handle uses synchronous I/O (e.g. stdin), cancel any pending
     // operation before closing the handle, so the read thread is not blocked.
     BOOL result = CancelIoEx(handle_, NULL);
-    ASSERT(result || (GetLastError() == ERROR_NOT_FOUND));
+// The Dart code 'stdin.listen(() {}).cancel()' causes this assert to be
+// triggered on Windows 7, but not on Windows 10.
+#if defined(DEBUG)
+    if (IsWindows10OrGreater()) {
+      ASSERT(result || (GetLastError() == ERROR_NOT_FOUND));
+    }
+#else
+    USE(result);
+#endif
   }
   if (!IsClosing()) {
     // Close the socket and set the closing state. This close method can be
     // called again if this socket has pending IO operations in flight.
     MarkClosing();
     // Perform handle type specific closing.
     DoClose();
   }
   ASSERT(IsHandleClosed());
 }
@@ skipping 576 matching lines @@
   }
   pending_write_ = OverlappedBuffer::AllocateSendToBuffer(num_bytes);
   pending_write_->Write(buffer, num_bytes);
   if (!IssueSendTo(sa, sa_len)) {
     return -1;
   }
   return num_bytes;
 }
 
 
+Mutex* StdHandle::stdin_mutex_ = new Mutex();
+StdHandle* StdHandle::stdin_ = NULL;
+
+StdHandle* StdHandle::Stdin(HANDLE handle) {
+  MutexLocker ml(stdin_mutex_);
+  if (stdin_ == NULL) {
+    stdin_ = new StdHandle(handle);
+  }
+  return stdin_;
+}
+
+
 static void WriteFileThread(uword args) {
   StdHandle* handle = reinterpret_cast<StdHandle*>(args);
   handle->RunWriteLoop();
 }
 
 
 void StdHandle::RunWriteLoop() {
   MonitorLocker ml(monitor_);
   write_thread_running_ = true;
   thread_id_ = Thread::GetCurrentThreadId();
@@ skipping 72 matching lines @@
   int truncated_bytes = Utils::Minimum<intptr_t>(num_bytes, INT_MAX);
   // Create buffer and notify thread about the new handle.
   pending_write_ = OverlappedBuffer::AllocateWriteBuffer(truncated_bytes);
   pending_write_->Write(buffer, truncated_bytes);
   ml.Notify();
   return 0;
 }
 
 
 void StdHandle::DoClose() {
-  MonitorLocker ml(monitor_);
-  if (write_thread_exists_) {
-    write_thread_running_ = false;
-    ml.Notify();
-    while (write_thread_exists_) {
-      ml.Wait(Monitor::kNoTimeout);
+  {
+    MonitorLocker ml(monitor_);
+    if (write_thread_exists_) {
+      write_thread_running_ = false;
+      ml.Notify();
+      while (write_thread_exists_) {
+        ml.Wait(Monitor::kNoTimeout);
+      }
+      // Join the thread.
+      DWORD res = WaitForSingleObject(thread_handle_, INFINITE);
+      CloseHandle(thread_handle_);
+      ASSERT(res == WAIT_OBJECT_0);
     }
-    // Join the thread.
-    DWORD res = WaitForSingleObject(thread_handle_, INFINITE);
-    CloseHandle(thread_handle_);
-    ASSERT(res == WAIT_OBJECT_0);
+    Handle::DoClose();
   }
-  Handle::DoClose();
+  MutexLocker ml(stdin_mutex_);
+  stdin_->Release();
+  StdHandle::stdin_ = NULL;
 }
 
 
 #if defined(DEBUG)
 intptr_t ClientSocket::disconnecting_ = 0;
 #endif
 
 
 bool ClientSocket::LoadDisconnectEx() {
   // Load the DisconnectEx function into memory using WSAIoctl.
@@ skipping 634 matching lines @@
 #if defined(DEBUG)
   while (true) {
     ok = GetQueuedCompletionStatus(handler_impl->completion_port(), &bytes,
                                    &key, &overlapped, 0);
     if (!ok && (overlapped == NULL)) {
       // There was an error or nothing is ready. Assume the port is drained.
       break;
     }
     handler_impl->HandleCompletionOrInterrupt(ok, bytes, key, overlapped);
   }
-#endif
 
   // The eventhandler thread is going down so there should be no more live
   // Handles or Sockets.
   // TODO(dart:io): It would be nice to be able to assert here that:
   //     ReferenceCounted<Handle>::instances() == 0;
   // However, we cannot at the moment. See the TODO on:
   //     ClientSocket::IssueDisconnect()
+  // Furthermore, if the Dart program references stdin, but does not
+  // explicitly close it, then the StdHandle for it will be leaked to here.
+  const intptr_t stdin_leaked = (StdHandle::StdinPtr() == NULL) ? 0 : 1;
   DEBUG_ASSERT(ReferenceCounted<Handle>::instances() ==
-               ClientSocket::disconnecting());
+               ClientSocket::disconnecting() + stdin_leaked);
   DEBUG_ASSERT(ReferenceCounted<Socket>::instances() == 0);
+#endif  // defined(DEBUG)
   handler->NotifyShutdownDone();
 }
 
 
 void EventHandlerImplementation::Start(EventHandler* handler) {
   int result =
       Thread::Start(EventHandlerEntry, reinterpret_cast<uword>(handler));
   if (result != 0) {
     FATAL1("Failed to start event handler thread %d", result);
   }
@@ skipping 15 matching lines @@
 void EventHandlerImplementation::Shutdown() {
   SendData(kShutdownId, 0, 0);
 }
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // defined(HOST_OS_WINDOWS)
 
 #endif  // !defined(DART_IO_DISABLED)