Fixes memory leak of async directory lister

runtime/bin/directory.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_DIRECTORY_H_
 #define BIN_DIRECTORY_H_
 
 #include "bin/builtin.h"
 #include "bin/dartutils.h"
+#include "bin/reference_counting.h"
 #include "bin/thread.h"
 #include "platform/globals.h"
 
 namespace dart {
 namespace bin {
 
 enum ListType {
   kListFile = 0,
   kListDirectory = 1,
   kListLink = 2,
@@ skipping 80 matching lines @@
       error_(false),
       recursive_(recursive),
       follow_links_(follow_links) {
     if (!path_buffer_.Add(dir_name)) {
       error_ = true;
     }
     Push(new DirectoryListingEntry(NULL));
   }
 
   virtual ~DirectoryListing() {
-    while (!IsEmpty()) {
-      Pop();
-    }
+    PopAll();
   }
 
   virtual bool HandleDirectory(const char* dir_name) = 0;
   virtual bool HandleFile(const char* file_name) = 0;
   virtual bool HandleLink(const char* link_name) = 0;
   virtual bool HandleError() = 0;
   virtual void HandleDone() {}
 
   void Push(DirectoryListingEntry* directory) {
     top_ = directory;
   }
 
   void Pop() {
     ASSERT(!IsEmpty());
     DirectoryListingEntry* current = top_;
     top_ = top_->parent();
     delete current;
   }
 
   bool IsEmpty() const {
     return top_ == NULL;
   }
 
+  void PopAll() {
+    while (!IsEmpty()) {
+      Pop();
+    }
+  }
+
   DirectoryListingEntry* top() const {
     return top_;
   }
 
   bool recursive() const {
     return recursive_;
   }
 
   bool follow_links() const {
     return follow_links_;
@@ skipping 13 matching lines @@
 
  private:
   PathBuffer path_buffer_;
   DirectoryListingEntry* top_;
   bool error_;
   bool recursive_;
   bool follow_links_;
 };
 
 
-class AsyncDirectoryListing : public DirectoryListing {
+class AsyncDirectoryListing : public ReferenceCounted<AsyncDirectoryListing>,
+                              public DirectoryListing {
  public:
   enum Response {
     kListFile = 0,
     kListDirectory = 1,
     kListLink = 2,
     kListError = 3,
     kListDone = 4
   };
 
   AsyncDirectoryListing(const char* dir_name,
                         bool recursive,
                         bool follow_links)
-      : DirectoryListing(dir_name, recursive, follow_links) {}
+      : ReferenceCounted(),
+        DirectoryListing(dir_name, recursive, follow_links),
+        array_(NULL),
+        index_(0),
+        length_(0),
+        weak_handle_(NULL) {}
 
-  virtual ~AsyncDirectoryListing() {}
   virtual bool HandleDirectory(const char* dir_name);
   virtual bool HandleFile(const char* file_name);
   virtual bool HandleLink(const char* file_name);
   virtual bool HandleError();
   virtual void HandleDone();
 
   void SetArray(CObjectArray* array, intptr_t length) {
     ASSERT(length % 2 == 0);
     array_ = array;
     index_ = 0;
     length_ = length;
   }
 
   intptr_t index() const {
     return index_;
   }
 
+  // Returns the weak persistent handle for the Dart wrapper.
+  Dart_WeakPersistentHandle WeakHandle() const { return weak_handle_; }
+
+  // Set the weak persistent handle for the Dart wrapper.
+  void SetWeakHandle(Dart_WeakPersistentHandle handle) {
+    ASSERT(weak_handle_ == NULL);
+    weak_handle_ = handle;
+  }
+
+  // Deletes the weak persistent handle for the Dart wrapper. Call
+  // when the listing is explicitly closed and the finalizer is no longer
+  // needed.
+  void DeleteWeakHandle(Dart_Isolate isolate) {
+    Dart_DeleteWeakPersistentHandle(isolate, weak_handle_);
+    weak_handle_ = NULL;
+  }
+
  private:
+  virtual ~AsyncDirectoryListing() {}
   bool AddFileSystemEntityToResponse(Response response, const char* arg);
   CObjectArray* array_;
   intptr_t index_;
   intptr_t length_;
+  Dart_WeakPersistentHandle weak_handle_;
 
+  friend class ReferenceCounted<AsyncDirectoryListing>;
   DISALLOW_IMPLICIT_CONSTRUCTORS(AsyncDirectoryListing);
 };
 
 
 class SyncDirectoryListing: public DirectoryListing {
  public:
   SyncDirectoryListing(Dart_Handle results,
                        const char* dir_name,
                        bool recursive,
                        bool follow_links)
@@ skipping 13 matching lines @@
   virtual bool HandleLink(const char* file_name);
   virtual bool HandleError();
 
  private:
   Dart_Handle results_;
   Dart_Handle add_string_;
   Dart_Handle directory_type_;
   Dart_Handle file_type_;
   Dart_Handle link_type_;
 
+  DISALLOW_ALLOCATION()
   DISALLOW_IMPLICIT_CONSTRUCTORS(SyncDirectoryListing);
 };
 
 
 class Directory {
  public:
   enum ExistsResult {
     UNKNOWN,
     EXISTS,
     DOES_NOT_EXIST
@@ skipping 28 matching lines @@
 
  private:
   DISALLOW_ALLOCATION();
   DISALLOW_IMPLICIT_CONSTRUCTORS(Directory);
 };
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // BIN_DIRECTORY_H_