- Add different types for persistent and weak persistent handles

runtime/vm/dart_api_state.h

 // 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.
 
 #ifndef VM_DART_API_STATE_H_
 #define VM_DART_API_STATE_H_
 
 #include "include/dart_api.h"
 
 #include "platform/thread.h"
@@ skipping 169 matching lines @@
   Dart_WeakPersistentHandleFinalizer callback() const { return callback_; }
   void set_callback(Dart_WeakPersistentHandleFinalizer callback) {
     callback_ = callback;
   }
 
   static void Finalize(FinalizablePersistentHandle* handle) {
     Dart_WeakPersistentHandleFinalizer callback = handle->callback();
     if (callback != NULL) {
       void* peer = handle->peer();
       handle->Clear();
-      (*callback)(reinterpret_cast<Dart_Handle>(handle), peer);
+      (*callback)(reinterpret_cast<Dart_WeakPersistentHandle>(handle), peer);
     } else {
       handle->Clear();
     }
   }
 
  private:
   friend class FinalizablePersistentHandles;
 
   FinalizablePersistentHandle() : raw_(NULL), peer_(NULL), callback_(NULL) { }
   ~FinalizablePersistentHandle() { }
@@ skipping 143 matching lines @@
     handle->set_raw(NULL);
     return handle;
   }
 
   void FreeHandle(PersistentHandle* handle) {
     handle->FreeHandle(free_list());
     set_free_list(handle);
   }
 
   // Validate if passed in handle is a Persistent Handle.
-  bool IsValidHandle(Dart_Handle object) const {
+  bool IsValidHandle(Dart_PersistentHandle object) const {
     return IsValidScopedHandle(reinterpret_cast<uword>(object));
   }
 
   // Returns a count of active handles (used for testing purposes).
   int CountHandles() const {
     return CountScopedHandles();
   }
 
  private:
   PersistentHandle* free_list_;
@@ skipping 53 matching lines @@
     handle->set_callback(NULL);
     return handle;
   }
 
   void FreeHandle(FinalizablePersistentHandle* handle) {
     handle->FreeHandle(free_list());
     set_free_list(handle);
   }
 
   // Validate if passed in handle is a Persistent Handle.
-  bool IsValidHandle(Dart_Handle object) const {
+  bool IsValidHandle(Dart_WeakPersistentHandle object) const {
     return IsValidScopedHandle(reinterpret_cast<uword>(object));
   }
 
   // Returns a count of active handles (used for testing purposes).
   int CountHandles() const {
     return CountScopedHandles();
   }
 
  private:
   FinalizablePersistentHandle* free_list_;
@@ skipping 10 matching lines @@
         values_(values), num_values_(values_length) {
   }
   ~WeakReferenceSet() {}
 
   WeakReferenceSet* next() const { return next_; }
 
   intptr_t num_keys() const { return num_keys_; }
   RawObject** get_key(intptr_t i) {
     ASSERT(i >= 0);
     ASSERT(i < num_keys_);
-    return (reinterpret_cast<PersistentHandle*>(keys_[i]))->raw_addr();
+    return (reinterpret_cast<FinalizablePersistentHandle*>(keys_[i]))->raw_addr();
   }
 
   intptr_t num_values() const { return num_values_; }
   RawObject** get_value(intptr_t i) {
     ASSERT(i >= 0);
     ASSERT(i < num_values_);
-    return (reinterpret_cast<PersistentHandle*>(values_[i]))->raw_addr();
+    return (reinterpret_cast<FinalizablePersistentHandle*>(values_[i]))->raw_addr();
   }
 
   static WeakReferenceSet* Pop(WeakReferenceSet** queue) {
     ASSERT(queue != NULL);
     WeakReferenceSet* head = *queue;
     if (head != NULL) {
       *queue = head->next();
       head->next_ = NULL;
     }
     return head;
@@ skipping 133 matching lines @@
     ApiLocalScope* scope = top_scope_;
     while (scope != NULL) {
       if (scope->local_handles()->IsValidHandle(object)) {
         return true;
       }
       scope = scope->previous();
     }
     return false;
   }
 
-  bool IsValidPersistentHandle(Dart_Handle object) const {
+  bool IsValidPersistentHandle(Dart_PersistentHandle object) const {
     return persistent_handles_.IsValidHandle(object);
   }
 
-  bool IsValidWeakPersistentHandle(Dart_Handle object) const {
+  bool IsValidWeakPersistentHandle(Dart_WeakPersistentHandle object) const {
     return weak_persistent_handles_.IsValidHandle(object);
   }
 
-  bool IsValidPrologueWeakPersistentHandle(Dart_Handle object) const {
+  bool IsValidPrologueWeakPersistentHandle(Dart_WeakPersistentHandle object) const {
     return prologue_weak_persistent_handles_.IsValidHandle(object);
   }
 
   bool IsProtectedHandle(PersistentHandle* object) const {
     if (object == NULL) return false;
     return object == null_ || object == true_ || object == false_;
   }
 
   int CountLocalHandles() const {
     int total = 0;
@@ skipping 110 matching lines @@
           ApiNativeScope::Current()->zone()) {}
   ApiGrowableArray()
       : BaseGrowableArray<T, ValueObject>(
           ApiNativeScope::Current()->zone()) {}
 };
 
 
 }  // namespace dart
 
 #endif  // VM_DART_API_STATE_H_