Track external allocated memory for weak persistent handles.

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 605 matching lines @@
   PersistentHandle* obj1_ref = PersistentHandle::Cast(obj1);
   obj1_ref->set_raw(obj2_ref);
 }
 
 
 static Dart_WeakPersistentHandle AllocateFinalizableHandle(
     Isolate* isolate,
     Dart_Handle object,
     bool is_prologue,
     void* peer,
+    intptr_t external_allocation_size,
     Dart_WeakPersistentHandleFinalizer callback) {
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   ReusableObjectHandleScope reused_obj_handle(isolate);
   Object& ref = reused_obj_handle.Handle();
   ref = Api::UnwrapHandle(object);
   FinalizablePersistentHandle* finalizable_ref = is_prologue ?
       state->prologue_weak_persistent_handles().AllocateHandle() :
       state->weak_persistent_handles().AllocateHandle();
 
   finalizable_ref->set_raw(ref);
   finalizable_ref->set_peer(peer);
   finalizable_ref->set_callback(callback);
+  finalizable_ref->SetExternalSize(external_allocation_size, isolate);
   if (is_prologue) {
     return finalizable_ref->apiPrologueHandle();
   } else {
     return finalizable_ref->apiHandle();
   }
 }
 
 
 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);
   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);
   return AllocateFinalizableHandle(isolate,
                                    object,
                                    true,
                                    peer,
+                                   external_allocation_size,
                                    callback);
 }
 
 
 DART_EXPORT void Dart_DeletePersistentHandle(Dart_PersistentHandle object) {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   PersistentHandle* ref = PersistentHandle::Cast(object);
   ASSERT(!state->IsProtectedHandle(ref));
   if (!state->IsProtectedHandle(ref)) {
     state->persistent_handles().FreeHandle(ref);
   }
 }
 
 
 DART_EXPORT void Dart_DeleteWeakPersistentHandle(
     Dart_Isolate current_isolate,
     Dart_WeakPersistentHandle object) {
   Isolate* isolate = reinterpret_cast<Isolate*>(current_isolate);
   CHECK_ISOLATE(isolate);
   ASSERT(isolate == Isolate::Current());
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   if (FinalizablePersistentHandle::IsPrologueWeakPersistentHandle(object)) {
     ASSERT(state->IsValidPrologueWeakPersistentHandle(object));
     FinalizablePersistentHandle* weak_ref =
         FinalizablePersistentHandle::Cast(object);
+    weak_ref->EnsureFreeExternal(isolate);
     state->prologue_weak_persistent_handles().FreeHandle(weak_ref);
   } else {
     ASSERT(!state->IsValidPrologueWeakPersistentHandle(object));
     FinalizablePersistentHandle* weak_ref =
         FinalizablePersistentHandle::Cast(object);
+    weak_ref->EnsureFreeExternal(isolate);
     state->weak_persistent_handles().FreeHandle(weak_ref);
   }
 }
 
 
 DART_EXPORT bool Dart_IsPrologueWeakPersistentHandle(
     Dart_WeakPersistentHandle object) {
 #if defined(DEBUG)
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
@@ skipping 3923 matching lines @@
 
 
 DART_EXPORT void Dart_RegisterRootServiceRequestCallback(
     const char* name,
     Dart_ServiceRequestCallback callback,
     void* user_data) {
   Service::RegisterRootEmbedderCallback(name, callback, user_data);
 }
 
 }  // namespace dart