Resolution for issue #5092: Unit test handle checks consider dangling handles to be valid.

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 RUNTIME_VM_DART_API_STATE_H_
 #define RUNTIME_VM_DART_API_STATE_H_
 
 #include "include/dart_api.h"
 
 #include "platform/utils.h"
@@ skipping 494 matching lines @@
   void FreeHandle(PersistentHandle* handle) {
     handle->FreeHandle(free_list());
     set_free_list(handle);
   }
 
   // Validate if passed in handle is a Persistent Handle.
   bool IsValidHandle(Dart_PersistentHandle object) const {
     return IsValidScopedHandle(reinterpret_cast<uword>(object));
   }
 
+  bool IsFreeHandle(Dart_PersistentHandle object) const {
+    PersistentHandle* handle = free_list_;
+    while (handle != NULL) {
+      if (handle == reinterpret_cast<PersistentHandle*>(object)) {
+        return true;
+      }
+      handle = handle->Next();
+    }
+    return false;
+  }
+
   // Returns a count of active handles (used for testing purposes).
   int CountHandles() const { return CountScopedHandles(); }
 
  private:
   PersistentHandle* free_list_;
   DISALLOW_COPY_AND_ASSIGN(PersistentHandles);
 };
 
 
 // Finalizable persistent handles repository structure.
@@ skipping 62 matching lines @@
     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));
   }
 
+  bool IsFreeHandle(Dart_WeakPersistentHandle object) const {
+    MutexLocker ml(mutex_);
+    FinalizablePersistentHandle* handle = free_list_;
+    while (handle != NULL) {
+      if (handle == reinterpret_cast<FinalizablePersistentHandle*>(object)) {
+        return true;
+      }
+      handle = handle->Next();
+    }
+    return false;
+  }
+
   // Returns a count of active handles (used for testing purposes).
   int CountHandles() const { return CountScopedHandles(); }
 
  private:
   FinalizablePersistentHandle* free_list_;
   Mutex* mutex_;
   DISALLOW_COPY_AND_ASSIGN(FinalizablePersistentHandles);
 };
 
 
@@ skipping 128 matching lines @@
   }
 
   void VisitWeakHandles(HandleVisitor* visitor) {
     weak_persistent_handles().VisitHandles(visitor);
   }
 
   bool IsValidPersistentHandle(Dart_PersistentHandle object) const {
     return persistent_handles_.IsValidHandle(object);
   }
 
+  bool IsFreePersistentHandle(Dart_PersistentHandle object) const {
+    return persistent_handles_.IsFreeHandle(object);
+  }
+
+  bool IsActivePersistentHandle(Dart_PersistentHandle object) const {
+    return IsValidPersistentHandle(object) && !IsFreePersistentHandle(object);
+  }
+
   bool IsValidWeakPersistentHandle(Dart_WeakPersistentHandle object) const {
     return weak_persistent_handles_.IsValidHandle(object);
   }
 
+  bool IsFreeWeakPersistentHandle(Dart_WeakPersistentHandle object) const {
+    return weak_persistent_handles_.IsFreeHandle(object);
+  }
+
+  bool IsActiveWeakPersistentHandle(Dart_WeakPersistentHandle object) const {
+    return IsValidWeakPersistentHandle(object) &&
+           !IsFreeWeakPersistentHandle(object);
+  }
+
   bool IsProtectedHandle(PersistentHandle* object) const {
     if (object == NULL) return false;
     return object == null_ || object == true_ || object == false_;
   }
 
   int CountPersistentHandles() const {
     return persistent_handles_.CountHandles();
   }
 
   void SetupAcquiredError() {
@@ skipping 42 matching lines @@
   ref->set_callback(callback);
   ref->set_is_queued_for_finalization(false);
   // This may trigger GC, so it must be called last.
   ref->SetExternalSize(external_size, isolate);
   return ref;
 }
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_DART_API_STATE_H_