[dart:io] Adds a finalizer to _NativeSocket to avoid socket leaks

runtime/bin/socket_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/socket.h"
@@ skipping 28 matching lines @@
 
 
 bool Socket::FormatNumericAddress(const RawAddr& addr, char* address, int len) {
   socklen_t salen = SocketAddress::GetAddrLength(addr);
   DWORD l = len;
   RawAddr& raw = const_cast<RawAddr&>(addr);
   return WSAAddressToStringA(&raw.addr, salen, NULL, address, &l) != 0;
 }
 
 
+Socket::Socket(intptr_t fd) : ReferenceCounted(), fd_(fd), port_(ILLEGAL_PORT) {
+  ASSERT(fd_ != kClosedFd);
+  Handle* handle = reinterpret_cast<Handle*>(fd_);
+  ASSERT(handle != NULL);
+}
+
+
+void Socket::SetClosedFd() {
+  ASSERT(fd_ != kClosedFd);
+  Handle* handle = reinterpret_cast<Handle*>(fd_);
+  ASSERT(handle != NULL);
+  handle->Release();
+  fd_ = kClosedFd;
+}
+
+
 static Mutex* init_mutex = new Mutex();
 static bool socket_initialized = false;
 
 bool Socket::Initialize() {
   MutexLocker lock(init_mutex);
   if (socket_initialized) {
     return true;
   }
   int err;
   WSADATA winsock_data;
@@ skipping 99 matching lines @@
                         const RawAddr& bind_addr) {
   ASSERT(reinterpret_cast<Handle*>(fd)->is_client_socket());
   ClientSocket* handle = reinterpret_cast<ClientSocket*>(fd);
   SOCKET s = handle->socket();
 
   int status =
       bind(s, &bind_addr.addr, SocketAddress::GetAddrLength(bind_addr));
   if (status != NO_ERROR) {
     int rc = WSAGetLastError();
     handle->mark_closed();  // Destructor asserts that socket is marked closed.
-    delete handle;
+    handle->Release();
     closesocket(s);
     SetLastError(rc);
     return -1;
   }
 
   LPFN_CONNECTEX connectEx = NULL;
   GUID guid_connect_ex = WSAID_CONNECTEX;
   DWORD bytes;
   status = WSAIoctl(s, SIO_GET_EXTENSION_FUNCTION_POINTER, &guid_connect_ex,
                     sizeof(guid_connect_ex), &connectEx, sizeof(connectEx),
@@ skipping 10 matching lines @@
 
     if (status == TRUE) {
       handle->ConnectComplete(overlapped);
       return fd;
     } else if (WSAGetLastError() == ERROR_IO_PENDING) {
       return fd;
     }
     rc = WSAGetLastError();
     // Cleanup in case of error.
     OverlappedBuffer::DisposeBuffer(overlapped);
+    handle->Release();
   } else {
     rc = WSAGetLastError();
   }
   handle->Close();
-  delete handle;
+  handle->Release();
   SetLastError(rc);
   return -1;
 }
 
 
 intptr_t Socket::CreateConnect(const RawAddr& addr) {
   intptr_t fd = Create(addr);
   if (fd < 0) {
     return fd;
   }
@@ skipping 276 matching lines @@
   ListenSocket* listen_socket = new ListenSocket(s);
 
   // Test for invalid socket port 65535 (some browsers disallow it).
   if ((SocketAddress::GetAddrPort(addr) == 0) &&
       (Socket::GetPort(reinterpret_cast<intptr_t>(listen_socket)) == 65535)) {
     // Don't close fd until we have created new. By doing that we ensure another
     // port.
     intptr_t new_s = CreateBindListen(addr, backlog, v6_only);
     DWORD rc = WSAGetLastError();
     closesocket(s);
-    delete listen_socket;
+    listen_socket->Release();
     SetLastError(rc);
     return new_s;
   }
 
   status = listen(s, backlog > 0 ? backlog : SOMAXCONN);
   if (status == SOCKET_ERROR) {
     DWORD rc = WSAGetLastError();
     closesocket(s);
-    delete listen_socket;
+    listen_socket->Release();
     SetLastError(rc);
     return -1;
   }
 
   return reinterpret_cast<intptr_t>(listen_socket);
 }
 
 
 bool ServerSocket::StartAccept(intptr_t fd) {
   ListenSocket* listen_socket = reinterpret_cast<ListenSocket*>(fd);
   listen_socket->EnsureInitialized(EventHandler::delegate());
   // Always keep 5 outstanding accepts going, to enhance performance.
   for (int i = 0; i < 5; i++) {
     if (!listen_socket->IssueAccept()) {
       DWORD rc = WSAGetLastError();
       listen_socket->Close();
       if (!listen_socket->HasPendingAccept()) {
         // Delete socket now, if there are no pending accepts. Otherwise,
         // the event-handler will take care of deleting it.
-        delete listen_socket;
+        listen_socket->Release();
       }
       SetLastError(rc);
       return false;
     }
   }
   return true;
 }
 
 
 void Socket::Close(intptr_t fd) {
@@ skipping 124 matching lines @@
   return setsockopt(handle->socket(), proto, MCAST_LEAVE_GROUP,
                     reinterpret_cast<char*>(&mreq), sizeof(mreq)) == 0;
 }
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // defined(HOST_OS_WINDOWS)
 
 #endif  // !defined(DART_IO_DISABLED)