Use a tag bit for indicating prologue weak persistent handles, this avoids

runtime/vm/dart_api_impl.cc

Index: runtime/vm/dart_api_impl.cc
===================================================================
--- runtime/vm/dart_api_impl.cc	(revision 33182)
+++ runtime/vm/dart_api_impl.cc	(working copy)
@@ -166,18 +166,10 @@
   ASSERT(Isolate::Current()->api_state()->IsValidWeakPersistentHandle(object) ||
          Isolate::Current()->api_state()->
              IsValidPrologueWeakPersistentHandle(object));
-  return reinterpret_cast<FinalizablePersistentHandle*>(object);
+  return FinalizablePersistentHandle::AsFinalizablePersistentHandle(object);
 }
 
 
-FinalizablePersistentHandle* Api::UnwrapAsPrologueWeakPersistentHandle(
-    Dart_WeakPersistentHandle object) {
-  ASSERT(Isolate::Current()->api_state()->IsValidPrologueWeakPersistentHandle(
-      object));
-  return reinterpret_cast<FinalizablePersistentHandle*>(object);
-}
-
-
 Dart_Handle Api::CheckIsolateState(Isolate* isolate) {
   if (!isolate->AllowClassFinalization()) {
     // Class finalization is blocked for the isolate. Do nothing.
@@ -568,9 +560,8 @@
   CHECK_ISOLATE(isolate);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
-  ASSERT(state->IsValidPersistentHandle(object));
-  return Api::NewHandle(isolate,
-                        reinterpret_cast<PersistentHandle*>(object)->raw());
+  PersistentHandle* ref = Api::UnwrapAsPersistentHandle(object);
+  return Api::NewHandle(isolate, ref->raw());
 }
 
 
@@ -580,10 +571,9 @@
   CHECK_ISOLATE(isolate);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
-  ASSERT(state->IsValidWeakPersistentHandle(object) ||
-         state->IsValidPrologueWeakPersistentHandle(object));
-  return Api::NewHandle(
-      isolate, reinterpret_cast<FinalizablePersistentHandle*>(object)->raw());
+  FinalizablePersistentHandle* weak_ref =
+      Api::UnwrapAsWeakPersistentHandle(object);
+  return Api::NewHandle(isolate, weak_ref->raw());
 }
 
 
@@ -616,6 +606,7 @@
     Isolate* isolate,
     FinalizablePersistentHandles* handles,
     Dart_Handle object,
+    bool is_prologue,
     void* peer,
     Dart_WeakPersistentHandleFinalizer callback) {
   ReusableObjectHandleScope reused_obj_handle(isolate);
@@ -625,7 +616,13 @@
   finalizable_ref->set_raw(ref);
   finalizable_ref->set_peer(peer);
   finalizable_ref->set_callback(callback);
-  return reinterpret_cast<Dart_WeakPersistentHandle>(finalizable_ref);
+  if (is_prologue) {
+    return FinalizablePersistentHandle::
+        AsDartPrologueWeakPersistentHandle(finalizable_ref);
+  } else {
+    return FinalizablePersistentHandle::
+        AsDartWeakPersistentHandle(finalizable_ref);
+  }
 }
 
 
@@ -640,6 +637,7 @@
   return AllocateFinalizableHandle(isolate,
                                    &state->weak_persistent_handles(),
                                    object,
+                                   false,
                                    peer,
                                    callback);
 }
@@ -656,6 +654,7 @@
   return AllocateFinalizableHandle(isolate,
                                    &state->prologue_weak_persistent_handles(),
                                    object,
+                                   true,
                                    peer,
                                    callback);
 }
@@ -680,26 +679,31 @@
   CHECK_ISOLATE(isolate);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
-  if (state->IsValidPrologueWeakPersistentHandle(object)) {
-    FinalizablePersistentHandle* prologue_weak_ref =
-        Api::UnwrapAsPrologueWeakPersistentHandle(object);
-    state->prologue_weak_persistent_handles().FreeHandle(prologue_weak_ref);
-    return;
+  if (FinalizablePersistentHandle::IsPrologueWeakPersistentHandle(object)) {
+    ASSERT(state->IsValidPrologueWeakPersistentHandle(object));
+    FinalizablePersistentHandle* weak_ref =
+        FinalizablePersistentHandle::AsFinalizablePersistentHandle(object);
+    state->prologue_weak_persistent_handles().FreeHandle(weak_ref);
+  } else {
+    ASSERT(!state->IsValidPrologueWeakPersistentHandle(object));
+    FinalizablePersistentHandle* weak_ref =
+        FinalizablePersistentHandle::AsFinalizablePersistentHandle(object);
+    state->weak_persistent_handles().FreeHandle(weak_ref);
   }
-  FinalizablePersistentHandle* weak_ref =
-      Api::UnwrapAsWeakPersistentHandle(object);
-  state->weak_persistent_handles().FreeHandle(weak_ref);
-  return;
 }
 
 
 DART_EXPORT bool Dart_IsPrologueWeakPersistentHandle(
     Dart_WeakPersistentHandle object) {
+#if defined(DEBUG)
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
-  return state->IsValidPrologueWeakPersistentHandle(object);
+  ASSERT(state->IsValidPrologueWeakPersistentHandle(object) ==
+         FinalizablePersistentHandle::IsPrologueWeakPersistentHandle(object));
+#endif
+  return FinalizablePersistentHandle::IsPrologueWeakPersistentHandle(object);
 }