Fixes memory leak of async directory lister

runtime/bin/directory.cc

 // 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.
 
 #if !defined(DART_IO_DISABLED)
 
 #include "bin/directory.h"
 
 #include "bin/dartutils.h"
+#include "bin/log.h"
 #include "include/dart_api.h"
 #include "platform/assert.h"
 
 namespace dart {
 namespace bin {
 
 void FUNCTION_NAME(Directory_Current)(Dart_NativeArguments args) {
   const char* current = Directory::Current();
   if (current != NULL) {
     Dart_SetReturnValue(args, DartUtils::NewString(current));
@@ skipping 112 matching lines @@
   }
   SyncDirectoryListing sync_listing(results,
                                     DartUtils::GetStringValue(path),
                                     DartUtils::GetBooleanValue(recursive),
                                     DartUtils::GetBooleanValue(follow_links));
   Directory::List(&sync_listing);
   Dart_SetReturnValue(args, results);
 }
 
 
+static const int kAsyncDirectoryListerFieldIndex = 0;
+
+
+void FUNCTION_NAME(Directory_GetAsyncDirectoryListerPointer)(
+    Dart_NativeArguments args) {
+  AsyncDirectoryListing* listing;
+  Dart_Handle dart_this = ThrowIfError(Dart_GetNativeArgument(args, 0));
+  ASSERT(Dart_IsInstance(dart_this));
+  ThrowIfError(Dart_GetNativeInstanceField(
+      dart_this,
+      kAsyncDirectoryListerFieldIndex,
+      reinterpret_cast<intptr_t*>(&listing)));
+  if (listing != NULL) {
+    intptr_t listing_pointer = reinterpret_cast<intptr_t>(listing);
+    // Increment the listing's reference count. This native should only be
+    // be called when we are about to send the AsyncDirectoryListing* to the
+    // IO service.
+    listing->Retain();
+    Dart_SetReturnValue(args, Dart_NewInteger(listing_pointer));
+  }
+}
+
+
+static void ReleaseListing(void* isolate_callback_data,
+                           Dart_WeakPersistentHandle handle,
+                           void* peer) {
+  AsyncDirectoryListing* listing =
+      reinterpret_cast<AsyncDirectoryListing*>(peer);
+  listing->Release();
+}
+
+
+void FUNCTION_NAME(Directory_SetAsyncDirectoryListerPointer)(
+    Dart_NativeArguments args) {
+  Dart_Handle dart_this = ThrowIfError(Dart_GetNativeArgument(args, 0));
+  intptr_t listing_pointer =
+      DartUtils::GetIntptrValue(Dart_GetNativeArgument(args, 1));
+  AsyncDirectoryListing* listing =
+      reinterpret_cast<AsyncDirectoryListing*>(listing_pointer);
+  Dart_WeakPersistentHandle handle = Dart_NewWeakPersistentHandle(
+      dart_this,
+      reinterpret_cast<void*>(listing),
+      sizeof(*listing),
+      ReleaseListing);
+  listing->SetWeakHandle(handle);
+  Dart_Handle result = Dart_SetNativeInstanceField(
+      dart_this,
+      kAsyncDirectoryListerFieldIndex,
+      listing_pointer);
+  if (Dart_IsError(result)) {
+    Log::PrintErr("SetAsyncDirectoryListerPointer failed\n");
+    Dart_PropagateError(result);
+  }
+}
+
+
 CObject* Directory::CreateRequest(const CObjectArray& request) {
   if ((request.Length() == 1) && request[0]->IsString()) {
     CObjectString path(request[0]);
     if (Directory::Create(path.CString())) {
       return CObject::True();
     } else {
       return CObject::NewOSError();
     }
   }
   return CObject::IllegalArgumentError();
@@ skipping 67 matching lines @@
     CObjectString path(request[0]);
     CObjectBool recursive(request[1]);
     CObjectBool follow_links(request[2]);
     AsyncDirectoryListing* dir_listing =
         new AsyncDirectoryListing(path.CString(),
                                   recursive.Value(),
                                   follow_links.Value());
     if (dir_listing->error()) {
       // Report error now, so we capture the correct OSError.
       CObject* err = CObject::NewOSError();
-      delete dir_listing;
+      dir_listing->Release();
       CObjectArray* error = new CObjectArray(CObject::NewArray(3));
       error->SetAt(0, new CObjectInt32(
           CObject::NewInt32(AsyncDirectoryListing::kListError)));
       error->SetAt(1, request[0]);
       error->SetAt(2, err);
       return error;
     }
     // TODO(ajohnsen): Consider returning the first few results.
     return new CObjectIntptr(CObject::NewIntptr(
         reinterpret_cast<intptr_t>(dir_listing)));
   }
   return CreateIllegalArgumentError();
 }
 
 
 CObject* Directory::ListNextRequest(const CObjectArray& request) {
   if ((request.Length() == 1) && request[0]->IsIntptr()) {
     CObjectIntptr ptr(request[0]);
     AsyncDirectoryListing* dir_listing =
         reinterpret_cast<AsyncDirectoryListing*>(ptr.Value());
+    RefCntReleaseScope<AsyncDirectoryListing> rs(dir_listing);
     if (dir_listing->IsEmpty()) {
       return new CObjectArray(CObject::NewArray(0));
     }
     const int kArraySize = 128;
     CObjectArray* response = new CObjectArray(CObject::NewArray(kArraySize));
     dir_listing->SetArray(response, kArraySize);
     Directory::List(dir_listing);
     // In case the listing ended before it hit the buffer length, we need to
     // override the array length.
     response->AsApiCObject()->value.as_array.length = dir_listing->index();
     return response;
   }
   return CreateIllegalArgumentError();
 }
 
 
 CObject* Directory::ListStopRequest(const CObjectArray& request) {
   if ((request.Length() == 1) && request[0]->IsIntptr()) {
     CObjectIntptr ptr(request[0]);
     AsyncDirectoryListing* dir_listing =
         reinterpret_cast<AsyncDirectoryListing*>(ptr.Value());
-    delete dir_listing;
+    RefCntReleaseScope<AsyncDirectoryListing> rs(dir_listing);
+
+    // We have retained a reference to the listing here. Therefore the listing's
+    // destructor can't be running. Since no further requests are dispatched by
+    // the Dart code after an async stop call, this PopAll() can't be racing
+    // with any other call on the listing. We don't do an extra Release(), and
+    // we don't delete the weak persistent handle. The file is closed here, but
+    // the memory for the listing will be cleaned up when the finalizer runs.
+    dir_listing->PopAll();
     return new CObjectBool(CObject::Bool(true));
   }
   return CreateIllegalArgumentError();
 }
 
 
 CObject* Directory::RenameRequest(const CObjectArray& request) {
   if ((request.Length() == 2) &&
       request[0]->IsString() &&
       request[1]->IsString()) {
@@ skipping 137 matching lines @@
     listing->HandleDone();
   } else {
     while (ListNext(listing)) {}
   }
 }
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // !defined(DART_IO_DISABLED)