Background finalization.

runtime/vm/dart_api_state.h

Index: runtime/vm/dart_api_state.h
diff --git a/runtime/vm/dart_api_state.h b/runtime/vm/dart_api_state.h
index b510377352cdc294d017c4922a86bd2e052e0c5f..1fb92a9893f7156e2cd98d27ca0ef4c95bed3cd1 100644
--- a/runtime/vm/dart_api_state.h
+++ b/runtime/vm/dart_api_state.h
@@ -227,11 +227,16 @@ class FinalizablePersistentHandle {
   }
 
   // Called when the referent becomes unreachable.
-  void UpdateUnreachable(Isolate* isolate) {
+  void UpdateUnreachableFinalizeNow(Isolate* isolate) {
     EnsureFreeExternal(isolate);
     Finalize(isolate, this);
   }
 
+  void UpdateUnreachableFinalizeLater(Isolate* isolate) {
+    EnsureFreeExternal(isolate);
+    MarkForFinalization();
+  }

[siva, 2016/06/02 20:18:05]

Maybe more readable as

void UpdateUnreachable(Isolate* isolate, FinalizationQueue* queue) {
  EnsureFreeExternal(isolate);
  if (queue != NULL) {
    MarkForFinalization();
    queue->Add(this);
  } else {
    Finalize(isolate, this);
  }
}

[rmacnak, 2016/06/03 01:08:30]

Yes, I like that better.

+
   // Called when the referent has moved, potentially between generations.
   void UpdateRelocated(Isolate* isolate) {
     if (IsSetNewSpaceBit() && (SpaceForExternal() == Heap::kOld)) {
@@ -299,6 +304,11 @@ class FinalizablePersistentHandle {
     callback_ = NULL;
   }
 
+  void MarkForFinalization() {
+    raw_ = Object::null();
+    ASSERT(callback_ != NULL);
+  }
+
   void set_raw(RawObject* raw) { raw_ = raw; }
   void set_raw(const LocalHandle& ref) { raw_ = ref.raw(); }
   void set_raw(const Object& object) { raw_ = object.raw(); }
@@ -333,10 +343,13 @@ class FinalizablePersistentHandle {
            Heap::kNew : Heap::kOld;
   }
 
+  friend class BackgroundFinalizer;
+
   RawObject* raw_;
   void* peer_;
   uword external_data_;
   Dart_WeakPersistentHandleFinalizer callback_;
+
   DISALLOW_ALLOCATION();  // Allocated through AllocateHandle methods.
   DISALLOW_COPY_AND_ASSIGN(FinalizablePersistentHandle);
 };
@@ -501,9 +514,11 @@ class FinalizablePersistentHandles
       : Handles<kFinalizablePersistentHandleSizeInWords,
                 kFinalizablePersistentHandlesPerChunk,
                 kOffsetOfRawPtrInFinalizablePersistentHandle>(),
-        free_list_(NULL) { }
+      free_list_(NULL), mutex_(new Mutex()) { }
   ~FinalizablePersistentHandles() {
     free_list_ = NULL;
+    delete mutex_;
+    mutex_ = NULL;
   }
 
   // Accessors.
@@ -529,6 +544,7 @@ class FinalizablePersistentHandles
   // Allocates a persistent handle, these have to be destroyed explicitly
   // by calling FreeHandle.
   FinalizablePersistentHandle* AllocateHandle() {
+    MutexLocker ml(mutex_);
     FinalizablePersistentHandle* handle;
     if (free_list_ != NULL) {
       handle = free_list_;
@@ -543,12 +559,14 @@ class FinalizablePersistentHandles
   }
 
   void FreeHandle(FinalizablePersistentHandle* handle) {
+    MutexLocker ml(mutex_);
     handle->FreeHandle(free_list());
     set_free_list(handle);
   }
 
   // Validate if passed in handle is a Persistent Handle.
   bool IsValidHandle(Dart_WeakPersistentHandle object) const {
+    MutexLocker ml(mutex_);
     return IsValidScopedHandle(reinterpret_cast<uword>(object));
   }
 
@@ -559,6 +577,7 @@ class FinalizablePersistentHandles
 
  private:
   FinalizablePersistentHandle* free_list_;
+  Mutex* mutex_;
   DISALLOW_COPY_AND_ASSIGN(FinalizablePersistentHandles);
 };