- Add different types for persistent and weak persistent handles

runtime/lib/mirrors.cc

 // Copyright (c) 2012, 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_debugger_api.h"
 #include "vm/dart_api_impl.h"
 #include "vm/bootstrap_natives.h"
 #include "vm/dart_entry.h"
 #include "vm/exceptions.h"
@@ skipping 70 matching lines @@
 
 
 static bool IsSimpleValue(Dart_Handle object) {
   return (Dart_IsNull(object) ||
           Dart_IsNumber(object) ||
           Dart_IsString(object) ||
           Dart_IsBoolean(object));
 }
 
 
-static void FreeVMReference(Dart_Handle weak_ref, void* data) {
-  Dart_Handle perm_handle = reinterpret_cast<Dart_Handle>(data);
+static void FreeVMReference(Dart_WeakPersistentHandle weak_ref, void* data) {
+  Dart_PersistentHandle perm_handle =
+      reinterpret_cast<Dart_PersistentHandle>(data);
   Dart_DeletePersistentHandle(perm_handle);
-  Dart_DeletePersistentHandle(weak_ref);
+  Dart_DeleteWeakPersistentHandle(weak_ref);
 }
 
 
 static Dart_Handle CreateVMReference(Dart_Handle handle) {
   // Create the VMReference object.
   Dart_Handle cls_name = NewString("VMReference");
   Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
   if (Dart_IsError(cls)) {
     return cls;
   }
   Dart_Handle vm_ref =  Dart_New(cls, Dart_Null(), 0, NULL);
   if (Dart_IsError(vm_ref)) {
     return vm_ref;
   }
 
   // Allocate a persistent handle.
-  Dart_Handle perm_handle = Dart_NewPersistentHandle(handle);
-  if (Dart_IsError(perm_handle)) {
-    return perm_handle;
-  }
+  Dart_PersistentHandle perm_handle = Dart_NewPersistentHandle(handle);
+  ASSERT(perm_handle != NULL);
 
   // Store the persistent handle in the VMReference.
   intptr_t perm_handle_value = reinterpret_cast<intptr_t>(perm_handle);
   Dart_Handle result =
       Dart_SetNativeInstanceField(vm_ref, 0, perm_handle_value);
   if (Dart_IsError(result)) {
     Dart_DeletePersistentHandle(perm_handle);
     return result;
   }
 
   // Create a weak reference.  We use the callback to be informed when
   // the VMReference is collected, so we can release the persistent
   // handle.
   void* perm_handle_data = reinterpret_cast<void*>(perm_handle);
-  Dart_Handle weak_ref =
+  Dart_WeakPersistentHandle weak_ref =
       Dart_NewWeakPersistentHandle(vm_ref, perm_handle_data, FreeVMReference);
-  if (Dart_IsError(weak_ref)) {
-    Dart_DeletePersistentHandle(perm_handle);
-    return weak_ref;
-  }
+  ASSERT(weak_ref != NULL);
 
   // Success.
   return vm_ref;
 }
 
 
 static Dart_Handle UnwrapVMReference(Dart_Handle vm_ref) {
   // Retrieve the persistent handle from the VMReference
   intptr_t perm_handle_value = 0;
   Dart_Handle result =
       Dart_GetNativeInstanceField(vm_ref, 0, &perm_handle_value);
   if (Dart_IsError(result)) {
     return result;
   }
-  Dart_Handle perm_handle = reinterpret_cast<Dart_Handle>(perm_handle_value);
-  ASSERT(!Dart_IsError(perm_handle));
-  return perm_handle;
+  Dart_PersistentHandle perm_handle =
+      reinterpret_cast<Dart_PersistentHandle>(perm_handle_value);
+  ASSERT(perm_handle != NULL);
+  Dart_Handle handle = Dart_HandleFromPersistent(perm_handle);
+  ASSERT(handle != NULL);
+  ASSERT(!Dart_IsError(handle));
+  return handle;
 }
 
 
 static Dart_Handle UnwrapMirror(Dart_Handle mirror) {
   Dart_Handle field_name = NewString("_reference");
   Dart_Handle vm_ref = Dart_GetField(mirror, field_name);
   if (Dart_IsError(vm_ref)) {
     return vm_ref;
   }
   return UnwrapVMReference(vm_ref);
@@ skipping 1117 matching lines @@
 }
 
 
 void HandleMirrorsMessage(Isolate* isolate,
                           Dart_Port reply_port,
                           const Instance& message) {
   UNIMPLEMENTED();
 }
 
 }  // namespace dart