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

runtime/vm/dart_api_impl.h

 // 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.
 
 #ifndef RUNTIME_VM_DART_API_IMPL_H_
 #define RUNTIME_VM_DART_API_IMPL_H_
 
 #include "vm/allocation.h"
 #include "vm/native_arguments.h"
 #include "vm/object.h"
 #include "vm/safepoint.h"
+#include "vm/thread_registry.h"
 
 namespace dart {
 
 class ApiLocalScope;
 class ApiState;
 class FinalizablePersistentHandle;
 class LocalHandle;
 class PersistentHandle;
 class ReusableObjectHandleScope;
+class ThreadRegistry;
 
 const char* CanonicalFunction(const char* func);
 
 #define CURRENT_FUNC CanonicalFunction(__FUNCTION__)
 
 // Checks that the current isolate is not NULL.
 #define CHECK_ISOLATE(isolate)                                                 \
   do {                                                                         \
     if ((isolate) == NULL) {                                                   \
       FATAL1(                                                                  \
@@ skipping 128 matching lines @@
     // TODO(turnidge): Assumes RawObject* is at offset zero.  Fix.
     RawObject* raw = *(reinterpret_cast<RawObject**>(handle));
     return !raw->IsHeapObject();
   }
 
   // Returns true if the handle holds a Dart Instance.
   static bool IsInstance(Dart_Handle handle) {
     return (ClassId(handle) >= kInstanceCid);
   }
 
+  // Returns true if the handle is non-dangling.
+  static bool IsValid(Dart_Handle handle) {
+    Isolate* isolate = Isolate::Current();
+    CHECK_ISOLATE(isolate);
+
+    // Check against all of the handles in the current isolate as well as the
+    // read-only handles.
+    return isolate->thread_registry()->IsValidHandle(handle) ||

[bkonyi, 2017/01/18 00:44:47]

I'm not sure if I should be checking to see if any isolate contains this handle
or if I should only be looking at the current isolate. All tests currently pass
in the current state.

[Cutch, 2017/01/18 14:49:51]

In general our API always interacts with the current isolate. 

+           Dart::IsReadOnlyApiHandle(handle) ||
+           Dart::IsReadOnlyHandle(reinterpret_cast<uword>(handle));
+  }
+
   // Returns true if the handle holds an Error.
   static bool IsError(Dart_Handle handle) {
     return RawObject::IsErrorClassId(ClassId(handle));
   }
 
   // Returns the value of a Smi.
   static intptr_t SmiValue(Dart_Handle handle) {
     // TODO(turnidge): Assumes RawObject* is at offset zero.  Fix.
     uword value = *(reinterpret_cast<uword*>(handle));
     return Smi::ValueFromRaw(value);
@@ skipping 112 matching lines @@
     return Api::NewError("%s: Cannot load after Dart_Precompile",              \
                          CURRENT_FUNC);                                        \
   }
 
 #define ASSERT_CALLBACK_STATE(thread)                                          \
   ASSERT(thread->no_callback_scope_depth() == 0)
 
 }  // namespace dart.
 
 #endif  // RUNTIME_VM_DART_API_IMPL_H_