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

utils/archive/dart_archive.c

 // 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.
 
 #include <assert.h>
 #include <errno.h>
 #include <stdlib.h>
 
 #include "dart_archive.h"
 #include "messaging.h"
@@ skipping 183 matching lines @@
   Dart_Port service_port =
       Dart_NewNativePort("ArchiveService", archiveDispatch, false);
   if (service_port != ILLEGAL_PORT) {
     Dart_Handle send_port = handleError(Dart_NewSendPort(service_port));
     Dart_SetReturnValue(arguments, send_port);
   }
   Dart_ExitScope();
 }
 
 /**
+ * The C callback that runs the Dart finalizer for an object. Set up by
+ * [attachDartFinalizer]. [handle] is the object that's been collected, and
+ * [peerPtr] is a Dart list containing the callback and its argument.
+ */
+static void runDartFinalizer(Dart_Handle handle, void* peerPtr) {
+  Dart_EnterScope();
+  Dart_Handle wrappedPeer = (Dart_Handle) peerPtr;
+  Dart_Handle callback = handleError(Dart_ListGetAt(wrappedPeer, 0));
+  Dart_Handle peer = handleError(Dart_ListGetAt(wrappedPeer, 1));
+
+  handleError(Dart_InvokeClosure(callback, 1, &peer));
+  Dart_DeletePersistentHandle(wrappedPeer);
+  Dart_ExitScope();
+}
+
+/**
+ * Attaches a finalizer callback to a Dart object.
+ *
+ * This takes a Dart object, a callback function, and an argument to pass to the
+ * callback function. The callback will be called with the given argument some
+ * time after the object has been garbage collected.
+ */
+static void attachDartFinalizer(Dart_NativeArguments arguments) {
+  Dart_EnterScope();
+  Dart_SetReturnValue(arguments, Dart_Null());
+  Dart_Handle object = handleError(Dart_GetNativeArgument(arguments, 0));
+  Dart_Handle callback = handleError(Dart_GetNativeArgument(arguments, 1));
+  Dart_Handle peer = handleError(Dart_GetNativeArgument(arguments, 2));
+
+  Dart_Handle wrappedPeer = handleError(Dart_NewList(2));
+  handleError(Dart_ListSetAt(wrappedPeer, 0, callback));
+  handleError(Dart_ListSetAt(wrappedPeer, 1, peer));
+  wrappedPeer = handleError(Dart_NewPersistentHandle(wrappedPeer));
+
+  handleError(Dart_NewWeakPersistentHandle(
+      object, wrappedPeer, runDartFinalizer));
+  Dart_ExitScope();
+}
+
+/**
  * A struct representing a function exposed to Dart and the name under which it
  * can be looked up.
  */
 struct FunctionLookup {
   const char* name;
   Dart_NativeFunction function;
 };
 
 /** The list of functions exposed to Dart. */
 struct FunctionLookup function_list[] = {
   {"Archive_ServicePort", archiveServicePort},
+  {"Archive_AttachFinalizer", attachDartFinalizer},
   {NULL, NULL}
 };
 
 /**
  * Resolves a Dart name as provided in a `native` declaration and returns the
  * C function that should be invoked for that name.
  */
 static Dart_NativeFunction resolveName(Dart_Handle name, int argc) {
   if (!Dart_IsString8(name)) return NULL;
   Dart_EnterScope();
@@ skipping 14 matching lines @@
 
 /** Initializes the C extension. */
 DART_EXPORT Dart_Handle dart_archive_Init(Dart_Handle parent_library) {
   if (Dart_IsError(parent_library)) return parent_library;
 
   Dart_Handle result_code = Dart_SetNativeResolver(parent_library, resolveName);
   if (Dart_IsError(result_code)) return result_code;
 
   return Dart_Null();
 }