Reland "Introduce optional 'bool shared' parameter to ServerSocket.bind() ..."

dart/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.
 
 #include "platform/globals.h"
 #if defined(TARGET_OS_WINDOWS)
 
 #include "bin/eventhandler.h"
 #include "bin/eventhandler_win.h"
 
@@ skipping 1000 matching lines @@
 
       if (IS_COMMAND(msg->data, kReturnTokenCommand)) {
         listen_socket->ReturnTokens(msg->dart_port, TOKEN_COUNT(msg->data));
       } else if (IS_COMMAND(msg->data, kSetEventMaskCommand)) {
         // `events` can only have kInEvent/kOutEvent flags set.
         intptr_t events = msg->data & EVENT_MASK;
         ASSERT(0 == (events & ~(1 << kInEvent | 1 << kOutEvent)));
         listen_socket->SetPortAndMask(msg->dart_port, events);
         TryDispatchingPendingAccepts(listen_socket);
       } else if (IS_COMMAND(msg->data, kCloseCommand)) {
-        handle->SetPortAndMask(msg->dart_port, 0);
-        if (handle->Mask() == 0) {
-          // TODO(dart:io): This assumes that all sockets listen before we
-          // close.
-          // This needs to be synchronized with a global datastructure.
-          handle->Close();
+        listen_socket->SetPortAndMask(msg->dart_port, 0);
+        // We only close the socket file descriptor from the operating
+        // system if there are no other dart socket objects which
+        // are listening on the same (address, port) combination.
+        ListeningSocketRegistry *registry =
+            ListeningSocketRegistry::Instance();
+        MutexLocker locker(registry->mutex());
+        if (registry->CloseSafe(reinterpret_cast<intptr_t>(listen_socket))) {
+          ASSERT(listen_socket->Mask() == 0);
+          listen_socket->Close();

[kustermann, 2015/02/10 16:35:51]

Note that the `Handle::ScopedLock lock()` from above doesn't conflict with the
lock aquired in Close() because the implementation of ScopedLock on windows
seems to allow a thread to take the same lock multiple times on the same thread
:-/

[Søren Gjesse, 2015/02/11 08:51:05]

It uses a Windows critical section object which is always "recursive".

+          DeleteIfClosed(handle);
         }
       } else {
         UNREACHABLE();
       }
     } else {
       handle->EnsureInitialized(this);
 
       Handle::ScopedLock lock(handle);
 
       if (IS_COMMAND(msg->data, kReturnTokenCommand)) {
@@ skipping 49 matching lines @@
         ASSERT(handle->is_client_socket());
 
         ClientSocket* client_socket = reinterpret_cast<ClientSocket*>(handle);
         client_socket->Shutdown(SD_SEND);
       } else if (IS_COMMAND(msg->data, kCloseCommand)) {
         handle->SetPortAndMask(msg->dart_port, 0);
         handle->Close();
       } else {
         UNREACHABLE();
       }
+      DeleteIfClosed(handle);
     }
-    DeleteIfClosed(handle);
   }
 }
 
 
 void EventHandlerImplementation::HandleAccept(ListenSocket* listen_socket,
                                               OverlappedBuffer* buffer) {
   listen_socket->AcceptComplete(buffer, completion_port_);
 
   {
     Handle::ScopedLock lock(listen_socket);
@@ skipping 272 matching lines @@
 
 
 void EventHandlerImplementation::Shutdown() {
   SendData(kShutdownId, 0, 0);
 }
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // defined(TARGET_OS_WINDOWS)