Added API Dart_PostCMessage for posting a Dart_CMessage structure

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"
 
 
 static const int kInfinityTimeout = -1;
 
 
 int64_t GetCurrentTimeMilliseconds() {
   static const int64_t kTimeEpoc = 116444736000000000LL;
 
   // Although win32 uses 64-bit integers for representing timestamps,
@@ skipping 611 matching lines @@
       handle->EnsureInitialized(this);
 
       Handle::ScopedLock lock(handle);
 
       // If the data available callback has been requested and data are
       // available post it immediately. Otherwise make sure that a pending
       // read is issued unless the socket is already closed for read.
       if ((msg->data & (1 << kInEvent)) != 0) {
         if (handle->Available() > 0) {
           int event_mask = (1 << kInEvent);
-          Dart_PostIntArray(handle->port(), 1, &event_mask);
+          DartUtils::PostInteger(port, event_mask);
         } else if (!handle->HasPendingRead() &&
                    !handle->IsClosedRead()) {
           handle->IssueRead();
         }
       }
 
       // If can send callback had been requested and there is no pending
       // send post it immediately.
       if ((msg->data & (1 << kOutEvent)) != 0) {
         if (!handle->HasPendingWrite()) {
           int event_mask = (1 << kOutEvent);
-          Dart_PostIntArray(handle->port(), 1, &event_mask);
+          DartUtils::PostInteger(port, event_mask);
         }
       }
 
       if (handle->is_client_socket()) {
         ClientSocket* client_socket = reinterpret_cast<ClientSocket*>(handle);
         if ((msg->data & (1 << kShutdownReadCommand)) != 0) {
           client_socket->Shutdown(SD_RECEIVE);
         }
 
         if ((msg->data & (1 << kShutdownWriteCommand)) != 0) {
@@ skipping 15 matching lines @@
 }
 
 
 void EventHandlerImplementation::HandleAccept(ListenSocket* listen_socket,
                                               IOBuffer* buffer) {
   listen_socket->AcceptComplete(buffer, completion_port_);
 
   if (!listen_socket->IsClosing()) {
     int event_mask = 1 << kInEvent;
     if ((listen_socket->mask() & event_mask) != 0) {
-      Dart_PostIntArray(listen_socket->port(), 1, &event_mask);
+      DartUtils::PostInteger(port, event_mask);
     }
   }
 
   if (listen_socket->IsClosed()) {
     delete listen_socket;
   }
 }
 
 
 void EventHandlerImplementation::HandleClosed(Handle* handle) {
   if (!handle->IsClosing()) {
     int event_mask = 1 << kCloseEvent;
-    Dart_PostIntArray(handle->port(), 1, &event_mask);
+    DartUtils::PostInteger(port, event_mask);
   }
 }
 
 
 void EventHandlerImplementation::HandleRead(Handle* handle,
                                             int bytes,
                                             IOBuffer* buffer) {
   buffer->set_data_length(bytes);
   handle->ReadComplete(buffer);
   if (bytes > 0) {
     if (!handle->IsClosing()) {
       int event_mask = 1 << kInEvent;
       if ((handle->mask() & event_mask) != 0) {
-        Dart_PostIntArray(handle->port(), 1, &event_mask);
+        DartUtils::PostInteger(port, event_mask);
       }
     }
   } else {
     ASSERT(bytes == 0);
     handle->MarkClosedRead();
     HandleClosed(handle);
   }
 
   if (handle->IsClosed()) {
     delete handle;
   }
 }
 
 
 void EventHandlerImplementation::HandleWrite(Handle* handle,
                                              int bytes,
                                              IOBuffer* buffer) {
   handle->WriteComplete(buffer);
 
   if (bytes > 0) {
     if (!handle->IsClosing()) {
       int event_mask = 1 << kOutEvent;
       if ((handle->mask() & event_mask) != 0) {
-        Dart_PostIntArray(handle->port(), 1, &event_mask);
+        DartUtils::PostInteger(port, event_mask);
       }
     }
   } else {
     ASSERT(bytes == 0);
     HandleClosed(handle);
   }
 
   if (handle->IsClosed()) {
     delete handle;
   }
 }
 
 
 void EventHandlerImplementation::HandleTimeout() {
   // TODO(sgjesse) check if there actually is a timeout.
-  Dart_PostIntArray(timeout_port_, 0, NULL);
+  DartUtils::PostNull(timeout_port_);
   timeout_ = kInfinityTimeout;
   timeout_port_ = 0;
 }
 
 
 void EventHandlerImplementation::HandleIOCompletion(DWORD bytes,
                                                     ULONG_PTR key,
                                                     OVERLAPPED* overlapped) {
   IOBuffer* buffer = IOBuffer::GetFromOverlapped(overlapped);
   switch (buffer->operation()) {
@@ skipping 113 matching lines @@
                                    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");
   }
 }