Retry: 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 {
       // Insert e as the last element in the list.
       e->prev_ = head_->prev_;
       e->next_ = head_;
       e->prev_->next_ = e;
       head_->prev_ = e;
       return false;
     }
   }
 
-  void RemoveHead() {
+  void RemoveHead(ClearFun clear = NULL) {
     ASSERT(head_ != NULL);
 
     Entry* e = head_;
     if (e->next_ == e) {
       head_ = NULL;
     } else {
       e->prev_->next_ = e->next_;
       e->next_->prev_ = e->prev_;
       head_ = e->next_;
     }
+    if (clear != NULL) {
+      clear(reinterpret_cast<void*>(e->t));
+    }
     delete e;
   }
 
   void Remove(T item) {
     if (head_ == NULL) {
       return;
     } else if (head_ == head_->next_) {
       if (head_->t == item) {
         delete head_;
         head_ = NULL;
@@ skipping 13 matching lines @@
           }
 
           delete current;
           return;
         }
         current = current->next_;
       } while (current != head_);
     }
   }
 
-  void RemoveAll() {
+  void RemoveAll(ClearFun clear = NULL) {
     while (HasHead()) {
-      RemoveHead();
+      RemoveHead(clear);
     }
   }
 
   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_