Free the C memory for ArchiveInputStream when the stream is garbage collected.

utils/archive/input_stream.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.
 
 #library("input_stream");
 
 #import("entry.dart");
 #import("read_request.dart");
 #import("utils.dart");
 
-// TODO(nweiz): ensure that the C struct associated with an input stream gets
-// freed if the stream gets garbage collected before it's closed.
 /**
  * A stream of [ArchiveEntry]s being read from an archive.
  *
  * This is accessible via [ArchiveReader].
  */
 class ArchiveInputStream {
   /**
    * The id of the underlying archive.
    *
    * This will be set to null once the input stream has finished reading from
    * the archive.
    */
-  int _id;
+  final Reference<int> _id;
 
   /** A [Completer] that will fire once the [_onEntry] callback is set. */
   final Completer<Function> _onEntryCompleter;
 
   /** The callback to call when the input stream is closed. */
   Function _onClosed;
 
   /** The callback to call when an error occurs. */
   Function _onError;
 
   /** The entry that is currently eligible to read data from the archive. */
   ArchiveEntry _currentEntry;
 
-  ArchiveInputStream(this._id) : _onEntryCompleter = new Completer<Function>() {
+  ArchiveInputStream(int id) : _id = new Reference<int>(id),

[Bob Nystrom, 2012/08/01 23:52:36]

How about moving : to the next line and not indenting these so far?

+                               _onEntryCompleter = new Completer<Function>() {
     var future = _consumeHeaders();
     future.handleException((e) {
       if (_onError != null) {
         _onError(e, future.stackTrace);
         return true;
       } else {
         throw e;
       }
     });
 
     future.then((_) {
       close();
       if (_onClosed != null) _onClosed();
     });
+
+    attachFinalizer(this, (id) {
+      if (id.value != null) call(FREE, id.value).then(() {});
+    }, _id);
   }
 
   /** Whether this stream has finished reading entries. */
-  bool get closed() => _id == null;
+  bool get closed() => _id.value == null;
 
   /**
    * Sets a callback to call when a new entry is read from the archive.
    *
    * The [ArchiveEntry] that's read from an archive initially only contains
    * header information such as the filename and permissions. To get the actual
    * data contained in the entry, use [ArchiveEntry.openInputStream].
    *
    * Since the entries are read in sequence from the archive, the data stream
    * for one entry must be opened before the next entry is read from the
@@ skipping 21 matching lines @@
    */
   void set onError(void callback(e, stack)) {
     _onError = callback;
   }
 
   /**
    * Closes the input stream. No more entries will be emitted.
    */
   void close() {
     if (closed) return;
-    call(FREE, _id).then((_) {});
-    _id = null;
+    call(FREE, _id.value).then((_) {});
+    _id.value = null;
     if (_currentEntry != null) _currentEntry.close();
     if (!_onEntryCompleter.future.isComplete) _onEntryCompleter.complete(null);
   }
 
   /**
    * Consumes and emits all [ArchiveEntries] in this archive.
    */
   Future _consumeHeaders() {
     if (closed) return new Future.immediate(null);
     var data;
-    return call(NEXT_HEADER, _id).chain((_data) {
+    return call(NEXT_HEADER, _id.value).chain((_data) {
       data = _data;
       if (data == null) return new Future.immediate(null);
-      return _emit(new ArchiveEntry(_id, data)).
+      return _emit(new ArchiveEntry(_id.value, data)).
         chain((_) => _consumeHeaders());
     });
   }
 
   /**
    * Emits [entry] to the [onEntry] callback. Returns a [Future] that will
    * complete once the callback's return value completes and the entry's data
    * has been fully consumed.
    */
   Future _emit(ArchiveEntry entry) {
     _currentEntry = entry;
     var future = _onEntryCompleter.future.chain((onEntry) {
       if (closed) return new Future.immediate(null);
       var result = onEntry(entry);
       if (result is Future) return result;
       return new Future.immediate(null);
     }).chain((_) {
       if (entry.isInputOpen) return entry.inputComplete;
       return new Future.immediate(null);
     });
     future.onComplete((_) {
       _currentEntry = null;
       entry.close();
     });
     return future;
   }
 }