Change the thread interface in runtime/platform and use it starting all threads

runtime/bin/eventhandler_linux.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 <errno.h>
 #include <poll.h>
 #include <pthread.h>
 #include <stdio.h>
 #include <string.h>
 #include <sys/time.h>
 #include <unistd.h>
 
-#include "bin/eventhandler.h"
 #include "bin/fdutils.h"
 #include "bin/hashmap.h"
 #include "platform/utils.h"
 
 
 int64_t GetCurrentTimeMilliseconds() {
   struct timeval tv;
   if (gettimeofday(&tv, NULL) < 0) {
     UNREACHABLE();
     return 0;
@@ skipping 305 matching lines @@
     intptr_t millis = timeout_ - GetCurrentTimeMilliseconds();
     if (millis <= 0) {
       Dart_PostIntArray(timeout_port_, 0, NULL);
       timeout_ = kInfinityTimeout;
       timeout_port_ = 0;
     }
   }
 }
 
 
-void* EventHandlerImplementation::Poll(void* args) {
+void EventHandlerImplementation::Poll(uword args) {
   intptr_t pollfds_size;
   struct pollfd* pollfds;
   EventHandlerImplementation* handler =
       reinterpret_cast<EventHandlerImplementation*>(args);
+  ASSERT(handler != NULL);
   while (1) {
     pollfds = handler->GetPollFds(&pollfds_size);
     intptr_t millis = handler->GetTimeout();
     intptr_t result = TEMP_FAILURE_RETRY(poll(pollfds, pollfds_size, millis));
     ASSERT(EAGAIN == EWOULDBLOCK);
     if (result == -1) {
       if (errno != EWOULDBLOCK) {
         perror("Poll failed");
       }
     } else {
       handler->HandleTimeout();
       handler->HandleEvents(pollfds, pollfds_size, result);
     }
     free(pollfds);
   }
-  return NULL;
 }
 
 
 void EventHandlerImplementation::StartEventHandler() {
-  pthread_t handler_thread;
-  int result = pthread_create(&handler_thread,
-                              NULL,
-                              &EventHandlerImplementation::Poll,
-                              this);
+  int result = dart::Thread::Start(&EventHandlerImplementation::Poll,
+                                   reinterpret_cast<uword>(this));
   if (result != 0) {
-    FATAL("Create start event handler thread");
+    FATAL1("Failed to start event handler thread %d", result);
   }
 }
 
 
 void EventHandlerImplementation::SendData(intptr_t id,
                                           Dart_Port dart_port,
                                           intptr_t data) {
   WakeupHandler(id, dart_port, data);
 }
 
 
 void* EventHandlerImplementation::GetHashmapKeyFromFd(intptr_t fd) {
   // The hashmap does not support keys with value 0.
   return reinterpret_cast<void*>(fd + 1);
 }
 
 
 uint32_t EventHandlerImplementation::GetHashmapHashFromFd(intptr_t fd) {
   // The hashmap does not support keys with value 0.
   return dart::Utils::WordHash(fd + 1);
 }