Auto delete persistent weak handles during finalization after invoking the callback associated with…

runtime/vm/dart_api_impl.cc

 // Copyright (c) 2013, 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 "include/dart_api.h"
 #include "include/dart_mirrors_api.h"
 #include "include/dart_native_api.h"
 
 #include "platform/assert.h"
 #include "vm/bigint_operations.h"
@@ skipping 353 matching lines @@
   ApiState* state = Isolate::Current()->api_state();
   ASSERT(state->IsValidWeakPersistentHandle(handle) ||
          state->IsValidPrologueWeakPersistentHandle(handle));
 #endif
   uword addr = reinterpret_cast<uword>(handle);
   return reinterpret_cast<FinalizablePersistentHandle*>(
       addr & ~kWeakPersistentTagMask);
 }
 
 
+void FinalizablePersistentHandle::Finalize(Isolate* isolate,
+                                           FinalizablePersistentHandle* handle,
+                                           bool is_prologue_weak) {
+  if (!handle->raw()->IsHeapObject()) {
+    return;
+  }
+  Dart_WeakPersistentHandleFinalizer callback = handle->callback();
+  ASSERT(callback != NULL);
+  void* peer = handle->peer();
+  Dart_WeakPersistentHandle object = is_prologue_weak ?
+      handle->apiPrologueHandle() :
+      handle->apiHandle();
+  (*callback)(isolate->init_callback_data(), object, peer);
+  ApiState* state = isolate->api_state();
+  ASSERT(state != NULL);
+  if (is_prologue_weak) {
+    state->prologue_weak_persistent_handles().FreeHandle(handle);
+  } else {
+    state->weak_persistent_handles().FreeHandle(handle);
+  }
+}
+
+
 // --- Handles ---
 
 DART_EXPORT bool Dart_IsError(Dart_Handle handle) {
   TRACE_API_CALL(CURRENT_FUNC);
   return RawObject::IsErrorClassId(Api::ClassId(handle));
 }
 
 
 DART_EXPORT bool Dart_IsApiError(Dart_Handle object) {
   TRACE_API_CALL(CURRENT_FUNC);
@@ skipping 263 matching lines @@
 }
 
 
 DART_EXPORT Dart_WeakPersistentHandle Dart_NewWeakPersistentHandle(
     Dart_Handle object,
     void* peer,
     intptr_t external_allocation_size,
     Dart_WeakPersistentHandleFinalizer callback) {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
+  if (callback == NULL) {
+    return NULL;
+  }
   return AllocateFinalizableHandle(isolate,
                                    object,
                                    false,
                                    peer,
                                    external_allocation_size,
                                    callback);
 }
 
 
 DART_EXPORT Dart_WeakPersistentHandle Dart_NewPrologueWeakPersistentHandle(
     Dart_Handle object,
     void* peer,
     intptr_t external_allocation_size,
     Dart_WeakPersistentHandleFinalizer callback) {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
+  if (callback == NULL) {
+    return NULL;
+  }
   return AllocateFinalizableHandle(isolate,
                                    object,
                                    true,
                                    peer,
                                    external_allocation_size,
                                    callback);
 }
 
 
 DART_EXPORT void Dart_DeletePersistentHandle(Dart_PersistentHandle object) {
@@ skipping 3945 matching lines @@
 
 
 DART_EXPORT void Dart_RegisterRootServiceRequestCallback(
     const char* name,
     Dart_ServiceRequestCallback callback,
     void* user_data) {
   Service::RegisterRootEmbedderCallback(name, callback, user_data);
 }
 
 }  // namespace dart