Retry: Fixes memory leaks in the eventhandler

runtime/bin/socket.h

 // 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.
 
 #ifndef BIN_SOCKET_H_
 #define BIN_SOCKET_H_
 
 #if defined(DART_IO_DISABLED)
 #error "socket.h can only be included on builds with IO enabled"
 #endif
 
 #include "platform/globals.h"
 // Declare the OS-specific types ahead of defining the generic class.
 #if defined(TARGET_OS_ANDROID)
 #include "bin/socket_android.h"
 #elif defined(TARGET_OS_FUCHSIA)
 #include "bin/socket_fuchsia.h"
 #elif defined(TARGET_OS_LINUX)
 #include "bin/socket_linux.h"
 #elif defined(TARGET_OS_MACOS)
 #include "bin/socket_macos.h"
 #elif defined(TARGET_OS_WINDOWS)
 #include "bin/socket_win.h"
 #else
 #error Unknown target os.
 #endif
 
-#include <map>
-
 #include "bin/builtin.h"
 #include "bin/dartutils.h"
 #include "bin/thread.h"
 #include "bin/utils.h"
+#include "platform/hashmap.h"
 
 namespace dart {
 namespace bin {
 
 union RawAddr {
   struct sockaddr_in in;
   struct sockaddr_in6 in6;
   struct sockaddr_storage ss;
   struct sockaddr addr;
 };
@@ skipping 321 matching lines @@
   // start accepting incoming sockets, the fd is invalidated.
   static bool StartAccept(intptr_t fd);
 
  private:
   DISALLOW_ALLOCATION();
   DISALLOW_IMPLICIT_CONSTRUCTORS(ServerSocket);
 };
 
 
 class ListeningSocketRegistry {
- private:
-  struct OSSocket {
-    RawAddr address;
-    int port;
-    bool v6_only;
-    bool shared;
-    int ref_count;
-    intptr_t socketfd;
+ public:
+  ListeningSocketRegistry() :
+      sockets_by_port_(SameIntptrValue, kInitialSocketsCount),
+      sockets_by_fd_(SameIntptrValue, kInitialSocketsCount),
+      mutex_(new Mutex()) {}
 
-    // Singly linked lists of OSSocket instances which listen on the same port
-    // but on different addresses.
-    OSSocket *next;
+  ~ListeningSocketRegistry() {
+    CloseAllSafe();
+    delete mutex_;
+    mutex_ = NULL;
+  }
 
-    OSSocket(RawAddr address, int port, bool v6_only, bool shared,
-             intptr_t socketfd)
-        : address(address), port(port), v6_only(v6_only), shared(shared),
-          ref_count(0), socketfd(socketfd), next(NULL) {}
-  };
-
- public:
   static void Initialize();
 
   static ListeningSocketRegistry *Instance();
 
   static void Cleanup();
 
-
-  ListeningSocketRegistry() : mutex_(new Mutex()) {}
-
-  ~ListeningSocketRegistry() {
-    delete mutex_;
-    mutex_ = NULL;
-  }
-
   // This function should be called from a dart runtime call in order to create
   // a new (potentially shared) socket.
   Dart_Handle CreateBindListen(Dart_Handle socket_object,
                                RawAddr addr,
                                intptr_t backlog,
                                bool v6_only,
                                bool shared);
 
   // This should be called from the event handler for every kCloseEvent it gets
   // on listening sockets.
   //
   // Returns `true` if the last reference has been dropped and the underlying
   // socket can be closed.
   //
   // The caller is responsible for obtaining the mutex first, before calling
   // this function.
   bool CloseSafe(intptr_t socketfd);
 
   Mutex *mutex() { return mutex_; }
 
  private:
+  struct OSSocket {
+    RawAddr address;
+    int port;
+    bool v6_only;
+    bool shared;
+    int ref_count;
+    intptr_t socketfd;
+
+    // Singly linked lists of OSSocket instances which listen on the same port
+    // but on different addresses.
+    OSSocket *next;
+
+    OSSocket(RawAddr address, int port, bool v6_only, bool shared,
+             intptr_t socketfd)
+        : address(address), port(port), v6_only(v6_only), shared(shared),
+          ref_count(0), socketfd(socketfd), next(NULL) {}
+  };
+
+  static const intptr_t kInitialSocketsCount = 8;
+
   OSSocket *findOSSocketWithAddress(OSSocket *current, const RawAddr& addr) {
     while (current != NULL) {
       if (SocketAddress::AreAddressesEqual(current->address, addr)) {
         return current;
       }
       current = current->next;
     }
     return NULL;
   }
 
-  std::map<intptr_t, OSSocket*> sockets_by_port_;
-  std::map<intptr_t, OSSocket*> sockets_by_fd_;
+  static bool SameIntptrValue(void* key1, void* key2) {
+    return reinterpret_cast<intptr_t>(key1) == reinterpret_cast<intptr_t>(key2);
+  }
+
+  static uint32_t GetHashmapHashFromIntptr(intptr_t i) {
+    return static_cast<uint32_t>((i + 1) & 0xFFFFFFFF);
+  }
+
+
+  static void* GetHashmapKeyFromIntptr(intptr_t i) {
+    return reinterpret_cast<void*>(i + 1);
+  }
+
+  OSSocket* LookupByPort(intptr_t port);
+  void InsertByPort(intptr_t port, OSSocket* socket);
+  void RemoveByPort(intptr_t port);
+
+  OSSocket* LookupByFd(intptr_t fd);
+  void InsertByFd(intptr_t fd, OSSocket* socket);
+  void RemoveByFd(intptr_t fd);
+
+  bool CloseOneSafe(OSSocket* os_socket);
+  void CloseAllSafe();
+
+  HashMap sockets_by_port_;
+  HashMap sockets_by_fd_;
+
   Mutex *mutex_;
 
-  typedef std::map<intptr_t, OSSocket*>::iterator SocketsIterator;
-
- private:
   DISALLOW_COPY_AND_ASSIGN(ListeningSocketRegistry);
 };
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // BIN_SOCKET_H_