Terminate event handler thread on isolate shutdown.

runtime/bin/eventhandler_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 "bin/eventhandler.h"
 
 #include <process.h>
 #include <winsock2.h>
 #include <ws2tcpip.h>
 #include <mswsock.h>
 
 #include "bin/builtin.h"
 #include "bin/dartutils.h"
 #include "bin/socket.h"
 #include "platform/thread.h"
 
 
 static const int kInfinityTimeout = -1;
+static const int kTimeoutId = -1;
+static const int kShutdownId = -2;
 
 
 int64_t GetCurrentTimeMilliseconds() {
   static const int64_t kTimeEpoc = 116444736000000000LL;
 
   // Although win32 uses 64-bit integers for representing timestamps,
   // these are packed into a FILETIME structure. The FILETIME structure
   // is just a struct representing a 64-bit integer. The TimeStamp union
   // allows access to both a FILETIME and an integer representation of
   // the timestamp.
@@ skipping 579 matching lines @@
   }
 }
 
 
 bool ClientSocket::IsClosed() {
   return IsClosing() && !HasPendingRead() && !HasPendingWrite();
 }
 
 
 void EventHandlerImplementation::HandleInterrupt(InterruptMessage* msg) {
-  if (msg->id == -1) {
+  if (msg->id == kTimeoutId) {
     // Change of timeout request. Just set the new timeout and port as the
     // completion thread will use the new timeout value for its next wait.
     timeout_ = msg->data;
     timeout_port_ = msg->dart_port;
+  } else if (msg->id == kShutdownId) {
+    shutdown_ = true;
   } else {
     bool delete_handle = false;
     Handle* handle = reinterpret_cast<Handle*>(msg->id);
     ASSERT(handle != NULL);
     if (handle->is_listen_socket()) {
       ListenSocket* listen_socket =
           reinterpret_cast<ListenSocket*>(handle);
       listen_socket->EnsureInitialized(this);
       listen_socket->SetPortAndMask(msg->dart_port, msg->data);
 
@@ skipping 187 matching lines @@
 
 EventHandlerImplementation::EventHandlerImplementation() {
   intptr_t result;
   completion_port_ =
       CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, NULL, 1);
   if (completion_port_ == NULL) {
     FATAL("Completion port creation failed");
   }
   timeout_ = kInfinityTimeout;
   timeout_port_ = 0;
+  shutdown_ = false;
 }
 
 
 DWORD EventHandlerImplementation::GetTimeout() {
   if (timeout_ == kInfinityTimeout) {
     return kInfinityTimeout;
   }
   intptr_t millis = timeout_ - GetCurrentTimeMilliseconds();
   return (millis < 0) ? 0 : millis;
 }
 
 
 void EventHandlerImplementation::SendData(intptr_t id,
                                           Dart_Port dart_port,
                                           intptr_t data) {
   InterruptMessage* msg = new InterruptMessage;
   msg->id = id;
   msg->dart_port = dart_port;
   msg->data = data;
   BOOL ok = PostQueuedCompletionStatus(
       completion_port_, 0, NULL, reinterpret_cast<OVERLAPPED*>(msg));
   if (!ok) {
     FATAL("PostQueuedCompletionStatus failed");
   }
 }
 
 
-static void EventHandlerThread(uword args) {
+void EventHandlerImplementation::EventHandlerEntry(uword args) {
   EventHandlerImplementation* handler =
       reinterpret_cast<EventHandlerImplementation*>(args);
   ASSERT(handler != NULL);
-  while (true) {
+  while (!handler->shutdown_) {
     DWORD bytes;
     ULONG_PTR key;
     OVERLAPPED* overlapped;
     intptr_t millis = handler->GetTimeout();
     BOOL ok = GetQueuedCompletionStatus(handler->completion_port(),
                                         &bytes,
                                         &key,
                                         &overlapped,
                                         millis);
     if (!ok && overlapped == NULL) {
@@ skipping 27 matching lines @@
       InterruptMessage* msg = reinterpret_cast<InterruptMessage*>(overlapped);
       handler->HandleInterrupt(msg);
       delete msg;
     } else {
       handler->HandleIOCompletion(bytes, key, overlapped);
     }
   }
 }
 
 
-void EventHandlerImplementation::StartEventHandler() {
-  int result = dart::Thread::Start(EventHandlerThread,
+void EventHandlerImplementation::Start() {
+  int result = dart::Thread::Start(EventHandlerEntry,
                                    reinterpret_cast<uword>(this));
   if (result != 0) {
     FATAL1("Failed to start event handler thread %d", result);
   }
 
   // Initialize Winsock32
   if (!Socket::Initialize()) {
     FATAL("Failed to initialized Windows sockets");
   }
 }
+
+
+void EventHandlerImplementation::Shutdown() {
+  SendData(kShutdownId, 0, 0);
+}