Implement weak persistent handles in the Dart API.

runtime/vm/dart_api_impl.cc

 // Copyright (c) 2011, 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 "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/dart.h"
@@ skipping 469 matching lines @@
 DART_EXPORT Dart_Handle Dart_IsSame(Dart_Handle obj1, Dart_Handle obj2,
                                     bool* value) {
   DARTSCOPE(Isolate::Current());
   const Object& expected = Object::Handle(Api::UnwrapHandle(obj1));
   const Object& actual = Object::Handle(Api::UnwrapHandle(obj2));
   *value = (expected.raw() == actual.raw());
   return Api::Success();
 }
 
 
-DART_EXPORT Dart_Handle Dart_NewPersistentHandle(Dart_Handle object) {
+static PersistentHandle* AllocatePersistentHandle(Dart_Handle object) {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
   DARTSCOPE_NOCHECKS(isolate);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   const Object& old_ref = Object::Handle(Api::UnwrapHandle(object));
   PersistentHandle* new_ref = state->persistent_handles().AllocateHandle();
   new_ref->set_raw(old_ref);
+  return new_ref;
+}
+
+
+DART_EXPORT Dart_Handle Dart_NewPersistentHandle(Dart_Handle object) {
+  PersistentHandle* new_ref = AllocatePersistentHandle(object);
+  new_ref->set_kind(PersistentHandle::StrongReference);
   return reinterpret_cast<Dart_Handle>(new_ref);
 }
 
+
+DART_EXPORT Dart_Handle Dart_NewWeakPersistentHandle(
+    Dart_Handle object,
+    Dart_PeerFinalizer callback) {

[Ivan Posva, 2011/12/19 22:41:36]

We will need to add the peer pointer here.

[cshapiro, 2011/12/20 00:58:57]

Sure.  I was going to leave this for the next change but I have gone ahead and
updated the signature of this function and its internals to receive the peer
pointer in addition to the callback.

+  PersistentHandle* new_ref = AllocatePersistentHandle(object);
+  new_ref->set_kind(PersistentHandle::WeakReference);
+  new_ref->set_callback(reinterpret_cast<void*>(callback));
+  return reinterpret_cast<Dart_Handle>(new_ref);
+}
+
 
 DART_EXPORT void Dart_DeletePersistentHandle(Dart_Handle object) {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   PersistentHandle* ref = Api::UnwrapAsPersistentHandle(*state, object);
   ASSERT(!ref->IsProtected());
   if (!ref->IsProtected()) {
     state->persistent_handles().FreeHandle(ref);
   }
 }
 
 
-DART_EXPORT Dart_Handle Dart_MakeWeakPersistentHandle(Dart_Handle object) {
-  UNIMPLEMENTED();
-  return NULL;
+DART_EXPORT bool Dart_IsWeakPersistentHandle(Dart_Handle object) {
+  Isolate* isolate = Isolate::Current();
+  CHECK_ISOLATE(isolate);
+  ApiState* state = isolate->api_state();
+  ASSERT(state != NULL);
+  if (state->IsValidPersistentHandle(object)) {
+    PersistentHandle* ref = Api::UnwrapAsPersistentHandle(*state, object);
+    return ref->kind() == PersistentHandle::WeakReference;
+  }
+  return false;
 }
 
 
-DART_EXPORT Dart_Handle Dart_MakePersistentHandle(Dart_Handle object) {
-  UNIMPLEMENTED();
-  return NULL;
-}
-
-
 // --- Initialization and Globals ---
 
 
 DART_EXPORT bool Dart_Initialize(Dart_IsolateCreateCallback create,
                                  Dart_IsolateInterruptCallback interrupt) {
   return Dart::InitOnce(create, interrupt);
 }
 
 DART_EXPORT bool Dart_SetVMFlags(int argc, const char** argv) {
   return Flags::ProcessCommandLineFlags(argc, argv);
@@ skipping 1974 matching lines @@
     }
     delete debug_region;
   } else {
     *buffer = NULL;
     *buffer_size = 0;
   }
 }
 
 
 }  // namespace dart