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 599 matching lines @@
   PersistentHandle* obj1_ref = Api::UnwrapAsPersistentHandle(obj1);
   obj1_ref->set_raw(obj2_ref);
 }
 
 
 static Dart_WeakPersistentHandle AllocateFinalizableHandle(
     Isolate* isolate,
     FinalizablePersistentHandles* handles,
     Dart_Handle object,
     void* peer,
+    intptr_t external_allocation_size,
     Dart_WeakPersistentHandleFinalizer callback) {
   ReusableObjectHandleScope reused_obj_handle(isolate);
   Object& ref = reused_obj_handle.Handle();
   ref = Api::UnwrapHandle(object);
   FinalizablePersistentHandle* finalizable_ref = handles->AllocateHandle();
   finalizable_ref->set_raw(ref);
   finalizable_ref->set_peer(peer);
   finalizable_ref->set_callback(callback);
+  finalizable_ref->SetExternalAllocationSize(external_allocation_size,
+                                             isolate->heap());
   return reinterpret_cast<Dart_WeakPersistentHandle>(finalizable_ref);
 }
 
 
 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);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   return AllocateFinalizableHandle(isolate,
                                    &state->weak_persistent_handles(),
                                    object,
                                    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);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   return AllocateFinalizableHandle(isolate,
                                    &state->prologue_weak_persistent_handles(),
                                    object,
                                    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 = Api::UnwrapAsPersistentHandle(object);
@@ skipping 1108 matching lines @@
   CHECK_CALLBACK_STATE(isolate);
   return Api::NewHandle(isolate, String::FromUTF32(utf32_array, length));
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewExternalLatin1String(
     const uint8_t* latin1_array,
     intptr_t length,
     void* peer,
     Dart_PeerFinalizer cback) {
+  // TODO(17284): Allocate large external data in old space.
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   if (latin1_array == NULL && length != 0) {
     RETURN_NULL_ERROR(latin1_array);
   }
   CHECK_LENGTH(length, String::kMaxElements);
   CHECK_CALLBACK_STATE(isolate);
   return Api::NewHandle(isolate,
                         String::NewExternal(latin1_array, length, peer, cback));
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewExternalUTF16String(const uint16_t* utf16_array,
                                                     intptr_t length,
                                                     void* peer,
                                                     Dart_PeerFinalizer cback) {
+  // TODO(17284): Allocate large external data in old space.
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   if (utf16_array == NULL && length != 0) {
     RETURN_NULL_ERROR(utf16_array);
   }
   CHECK_LENGTH(length, String::kMaxElements);
   CHECK_CALLBACK_STATE(isolate);
   return Api::NewHandle(isolate,
                         String::NewExternal(utf16_array, length, peer, cback));
 }
@@ skipping 921 matching lines @@
   }
   UNREACHABLE();
   return Api::Null();
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewExternalTypedData(
     Dart_TypedData_Type type,
     void* data,
     intptr_t length) {
+  // TODO(17284): Allocate large external data in old space.
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   if (data == NULL && length != 0) {
     RETURN_NULL_ERROR(data);
   }
   CHECK_CALLBACK_STATE(isolate);
   switch (type) {
     case Dart_TypedData_kByteData:
       return NewExternalByteData(isolate, data, length);
     case Dart_TypedData_kInt8:
@@ skipping 1852 matching lines @@
 
 
 DART_EXPORT void Dart_RegisterRootServiceRequestCallback(
     const char* name,
     Dart_ServiceRequestCallback callback,
     void* user_data) {
   Service::RegisterRootEmbedderCallback(name, callback, user_data);
 }
 
 }  // namespace dart