Fixes memory leak of async directory lister

sdk/lib/io/directory_impl.dart

 // 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.
 
 part of dart.io;
 
 class _Directory extends FileSystemEntity implements Directory {
   final String path;
 
   _Directory(this.path) {
@@ skipping 234 matching lines @@
       case _OSERROR_RESPONSE:
         var err = new OSError(response[_OSERROR_RESPONSE_MESSAGE],
                               response[_OSERROR_RESPONSE_ERROR_CODE]);
         return new FileSystemException(message, path, err);
       default:
         return new Exception("Unknown error");
     }
   }
 }
 
+abstract class _AsyncDirectoryListerOps {
+  external factory _AsyncDirectoryListerOps(int pointer);

[Ivan Posva, 2016/04/20 05:38:16]

ditto. (Needs dart2js patch file.)

[zra, 2016/04/20 22:13:58]

Done.

+
+  int getPointer();
+}
+
 class _AsyncDirectoryLister {
   static const int LIST_FILE = 0;
   static const int LIST_DIRECTORY = 1;
   static const int LIST_LINK = 2;
   static const int LIST_ERROR = 3;
   static const int LIST_DONE = 4;
 
   static const int RESPONSE_TYPE = 0;
   static const int RESPONSE_PATH = 1;
   static const int RESPONSE_COMPLETE = 1;
   static const int RESPONSE_ERROR = 2;
 
   final String path;
   final bool recursive;
   final bool followLinks;
 
   StreamController controller;
-  int id;
   bool canceled = false;
   bool nextRunning = false;
   bool closed = false;
+  _AsyncDirectoryListerOps _ops;
   Completer closeCompleter = new Completer();
 
   _AsyncDirectoryLister(this.path, this.recursive, this.followLinks) {
     controller = new StreamController(onListen: onListen,
                                       onResume: onResume,
                                       onCancel: onCancel,
                                       sync: true);
   }
 
+  int get _pointer => (_ops == null) ? null : _ops.getPointer();
+
   Stream get stream => controller.stream;
 
   void onListen() {
     _IOService._dispatch(_DIRECTORY_LIST_START, [path, recursive, followLinks])
         .then((response) {
           if (response is int) {
-            id = response;
+            _ops = new _AsyncDirectoryListerOps(response);
             next();
           } else if (response is Error) {
             controller.addError(response, response.stackTrace);
             close();
           } else {
             error(response);
             close();
           }
         });
   }
 
   void onResume() {
-    if (!nextRunning) next();
+    if (!nextRunning) {
+      next();
+    }
   }
 
   Future onCancel() {
     canceled = true;
     // If we are active, but not requesting, close.
     if (!nextRunning) {
       close();
     }
 
     return closeCompleter.future;
   }
 
   void next() {
     if (canceled) {
       close();
       return;
     }
-    if (id == null) return;
-    if (controller.isPaused) return;
-    if (nextRunning) return;
+    if ((_pointer == null) || controller.isPaused || nextRunning) {
+      return;
+    }
     nextRunning = true;
-    _IOService._dispatch(_DIRECTORY_LIST_NEXT, [id]).then((result) {
+    _IOService._dispatch(_DIRECTORY_LIST_NEXT, [_pointer]).then((result) {
       nextRunning = false;
       if (result is List) {
         next();
         assert(result.length % 2 == 0);
         for (int i = 0; i < result.length; i++) {
           assert(i % 2 == 0);
           switch (result[i++]) {
             case LIST_FILE:
               controller.add(new File(result[i]));
               break;
@@ skipping 10 matching lines @@
               canceled = true;
               return;
           }
         }
       } else {
         controller.addError(new FileSystemException("Internal error"));
       }
     });
   }
 
+  void _cleanup() {
+    controller.close();
+    closeCompleter.complete();
+    _ops = null;
+  }
+
   void close() {
-    if (closed) return;
-    if (nextRunning) return;
-    void cleanup() {
-      controller.close();
-      closeCompleter.complete();
+    if (closed) {
+      return;
+    }
+    if (nextRunning) {
+      return;
     }
     closed = true;
-    if (id != null) {
-      _IOService._dispatch(_DIRECTORY_LIST_STOP, [id]).whenComplete(cleanup);
+    if (_pointer != null) {
+      _IOService._dispatch(_DIRECTORY_LIST_STOP, [_pointer])
+                .whenComplete(_cleanup);
     } else {
-      cleanup();
+      _cleanup();
     }
   }
 
   void error(message) {
     var errorType =
         message[RESPONSE_ERROR][_ERROR_RESPONSE_ERROR_TYPE];
     if (errorType == _ILLEGAL_ARGUMENT_RESPONSE) {
       controller.addError(new ArgumentError());
     } else if (errorType == _OSERROR_RESPONSE) {
       var responseError = message[RESPONSE_ERROR];
       var err = new OSError(
           responseError[_OSERROR_RESPONSE_MESSAGE],
           responseError[_OSERROR_RESPONSE_ERROR_CODE]);
       var errorPath = message[RESPONSE_PATH];
       if (errorPath == null) errorPath = path;
       controller.addError(
           new FileSystemException("Directory listing failed",
                                   errorPath,
                                   err));
     } else {
       controller.addError(
           new FileSystemException("Internal error"));
     }
   }
 }