Fixes memory leaks in the eventhandler

runtime/bin/eventhandler.h

 // 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.
 
 #ifndef BIN_EVENTHANDLER_H_
 #define BIN_EVENTHANDLER_H_
 
 #include "bin/builtin.h"
 #include "bin/dartutils.h"
 #include "bin/isolate_data.h"
@@ skipping 114 matching lines @@
 static const int kInfinityTimeout = -1;
 static const int kTimerId = -1;
 static const int kShutdownId = -2;
 
 
 template<typename T>
 class CircularLinkedList {
  public:
   CircularLinkedList() : head_(NULL) {}
 
+  typedef void (*ClearFun) (void* value);
+
   // Returns true if the list was empty.
   bool Add(T t) {
     Entry* e = new Entry(t);
     if (head_ == NULL) {
       // Empty list, make e head, and point to itself.
       e->next_ = e;
       e->prev_ = e;
       head_ = e;
       return true;
     } else {
@@ skipping 43 matching lines @@
           }
 
           delete current;
           return;
         }
         current = current->next_;
       } while (current != head_);
     }
   }
 
-  void RemoveAll() {
+  void RemoveAll(ClearFun clear = NULL) {
     while (HasHead()) {
+      if (clear != NULL) {
+        T h = head();
+        clear(reinterpret_cast<void*>(h));
+      }
       RemoveHead();

[siva, 2016/08/09 21:41:43]

Wouldn't it be more atomic to pass the clear function down to RemoveHead and
invoke it after head is removed from the list.

There seems to be no locks around this not sure if multiple threads can access
the list and see an entry is an inconsistent state because it still is in the
list but the PortEntry has been deleted.

[zra, 2016/08/09 22:19:27]

Done. The DescriptorInfos and therefore the CircularLinkedList of active readers
are only touched by the event handler thread, AFAIU.

     }
   }
 
   T head() const { return head_->t; }
 
   bool HasHead() const {
     return head_ != NULL;
   }
 
   void Rotate() {
@@ skipping 195 matching lines @@
     intptr_t token_count;
 
     bool IsReady() { return token_count > 0 && is_reading; }
   };
 
  public:
   DescriptorInfoMultipleMixin(intptr_t fd, bool disable_tokens)
       : DI(fd), tokens_map_(&SamePortValue, kTokenCount),
         disable_tokens_(disable_tokens) {}
 
-  virtual ~DescriptorInfoMultipleMixin() {}
+  virtual ~DescriptorInfoMultipleMixin() {
+    RemoveAllPorts();
+  }
 
   virtual bool IsListeningSocket() const { return true; }
 
   virtual void SetPortAndMask(Dart_Port port, intptr_t mask) {
     HashMap::Entry* entry = tokens_map_.Lookup(
         GetHashmapKeyFromPort(port), GetHashmapHashFromPort(port), true);
     PortEntry* pentry;
     if (entry->value == NULL) {
       pentry = new PortEntry();
       pentry->dart_port = port;
@@ skipping 63 matching lines @@
       // know about it beforehand. So the first time the event handler knows
       // about it, is when it is supposed to be closed. We therefore do nothing
       // here.
       //
       // But whether to close it, depends on whether other isolates have it open
       // as well or not.
     }
   }
 
   virtual void RemoveAllPorts() {
-    active_readers_.RemoveAll();
     for (HashMap::Entry *entry = tokens_map_.Start();
          entry != NULL;
          entry = tokens_map_.Next(entry)) {
       PortEntry* pentry = reinterpret_cast<PortEntry*>(entry->value);
+      entry->value = NULL;
+      active_readers_.Remove(pentry);
       delete pentry;
     }
     tokens_map_.Clear();
+    active_readers_.RemoveAll(DeletePortEntry);
   }
 
   virtual Dart_Port NextNotifyDartPort(intptr_t events_ready) {
     // We're only sending `kInEvents` if there are multiple listeners (which is
     // listening socktes).
     ASSERT(IS_EVENT(events_ready, kInEvent) ||
            IS_EVENT(events_ready, kDestroyedEvent));
 
     if (active_readers_.HasHead()) {
       PortEntry* pentry = reinterpret_cast<PortEntry*>(active_readers_.head());
@@ skipping 60 matching lines @@
       return 1 << kInEvent;
     }
     return 0;
   }
 
   virtual void Close() {
     DI::Close();
   }
 
  private:
+  static void DeletePortEntry(void* data) {
+    PortEntry* entry = reinterpret_cast<PortEntry*>(data);
+    delete entry;
+  }
+
   // The [Dart_Port]s which are not paused (i.e. are interested in read events,
   // i.e. `mask == (1 << kInEvent)`) and we have enough tokens to communicate
   // with them.
   CircularLinkedList<PortEntry *> active_readers_;
 
   // A convenience mapping:
   //   Dart_Port -> struct PortEntry { dart_port, mask, token_count }
   HashMap tokens_map_;
 
   bool disable_tokens_;
@@ skipping 51 matching lines @@
   friend class EventHandlerImplementation;
   EventHandlerImplementation delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(EventHandler);
 };
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // BIN_EVENTHANDLER_H_