- Add different types for persistent and weak persistent handles

runtime/vm/dart_api_impl.cc

 // Copyright (c) 2013, 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 "platform/assert.h"
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
@@ skipping 18 matching lines @@
 #include "vm/timer.h"
 #include "vm/unicode.h"
 #include "vm/verifier.h"
 #include "vm/version.h"
 
 namespace dart {
 
 DECLARE_FLAG(bool, print_class_table);
 
 ThreadLocalKey Api::api_native_key_ = Thread::kUnsetThreadLocalKey;
+Dart_Handle Api::true_handle_ = NULL;
+Dart_Handle Api::false_handle_ = NULL;
+Dart_Handle Api::null_handle_ = NULL;
 
 
 const char* CanonicalFunction(const char* func) {
   if (strncmp(func, "dart::", 6) == 0) {
     return func + 6;
   } else {
     return func;
   }
 }
 
@@ skipping 39 matching lines @@
   return reinterpret_cast<Dart_Handle>(ref);
 }
 
 RawObject* Api::UnwrapHandle(Dart_Handle object) {
 #if defined(DEBUG)
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   ASSERT(state->IsValidLocalHandle(object) ||
-         state->IsValidPersistentHandle(object) ||
-         state->IsValidWeakPersistentHandle(object) ||
-         state->IsValidPrologueWeakPersistentHandle(object));
+         Dart::vm_isolate()->api_state()->IsValidLocalHandle(object));
   ASSERT(FinalizablePersistentHandle::raw_offset() == 0 &&
          PersistentHandle::raw_offset() == 0 &&
          LocalHandle::raw_offset() == 0);
 #endif
   return (reinterpret_cast<LocalHandle*>(object))->raw();
 }
 
 #define DEFINE_UNWRAP(type)                                                    \
   const type& Api::Unwrap##type##Handle(Isolate* iso,                          \
                                         Dart_Handle dart_handle) {             \
     const Object& obj = Object::Handle(iso, Api::UnwrapHandle(dart_handle));   \
     if (obj.Is##type()) {                                                      \
       return type::Cast(obj);                                                  \
     }                                                                          \
     return type::Handle(iso);                                                  \
   }
 CLASS_LIST_FOR_HANDLES(DEFINE_UNWRAP)
 #undef DEFINE_UNWRAP
 
 
-LocalHandle* Api::UnwrapAsLocalHandle(const ApiState& state,
-                                      Dart_Handle object) {
-  ASSERT(state.IsValidLocalHandle(object));
-  return reinterpret_cast<LocalHandle*>(object);
-}
-
-
-PersistentHandle* Api::UnwrapAsPersistentHandle(const ApiState& state,
-                                                Dart_Handle object) {
-  ASSERT(state.IsValidPersistentHandle(object));
+PersistentHandle* Api::UnwrapAsPersistentHandle(Dart_PersistentHandle object) {
+  ASSERT(Isolate::Current()->api_state()->IsValidPersistentHandle(object));
   return reinterpret_cast<PersistentHandle*>(object);
 }
 
 
 FinalizablePersistentHandle* Api::UnwrapAsWeakPersistentHandle(
-    const ApiState& state,
-    Dart_Handle object) {
-  ASSERT(state.IsValidWeakPersistentHandle(object));
+    Dart_WeakPersistentHandle object) {
+  ASSERT(Isolate::Current()->api_state()->IsValidWeakPersistentHandle(object));
   return reinterpret_cast<FinalizablePersistentHandle*>(object);
 }
 
 
 FinalizablePersistentHandle* Api::UnwrapAsPrologueWeakPersistentHandle(
-    const ApiState& state,
-    Dart_Handle object) {
-  ASSERT(state.IsValidPrologueWeakPersistentHandle(object));
+    Dart_WeakPersistentHandle object) {
+  ASSERT(Isolate::Current()->api_state()->IsValidPrologueWeakPersistentHandle(object));
   return reinterpret_cast<FinalizablePersistentHandle*>(object);
 }
 
 
 Dart_Handle Api::CheckIsolateState(Isolate* isolate) {
   if (ClassFinalizer::FinalizePendingClasses() &&
       isolate->object_store()->PreallocateObjects()) {
     return Api::Success(isolate);
   }
   ASSERT(isolate->object_store()->sticky_error() != Object::null());
   return Api::NewHandle(isolate, isolate->object_store()->sticky_error());
 }
 
 
 Dart_Isolate Api::CastIsolate(Isolate* isolate) {
   return reinterpret_cast<Dart_Isolate>(isolate);
 }
 
 
 Dart_Handle Api::Success(Isolate* isolate) {
   ASSERT(isolate != NULL);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
-  PersistentHandle* true_handle = state->True();
-  return reinterpret_cast<Dart_Handle>(true_handle);
+  return Api::True(isolate);
 }
 
 
 Dart_Handle Api::NewError(const char* format, ...) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   CHECK_CALLBACK_STATE(isolate);
 
   va_list args;
   va_start(args, format);
@@ skipping 21 matching lines @@
 
 Dart_Handle Api::AcquiredError(Isolate* isolate) {
   ASSERT(isolate != NULL);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   PersistentHandle* acquired_error_handle = state->AcquiredError();
   return reinterpret_cast<Dart_Handle>(acquired_error_handle);
 }
 
 
 Dart_Handle Api::Null(Isolate* isolate) {

[siva, 2013/05/28 17:37:18]

Is the isolate parameter still needed for these handle accessors?
These handles are coming from the vm isolate.

[Ivan Posva, 2013/05/28 21:12:20]

Removed the isolate parameter as well as the unused pieces in ApiState.

-  ASSERT(isolate != NULL);
-  ApiState* state = isolate->api_state();
-  ASSERT(state != NULL);
-  PersistentHandle* null_handle = state->Null();
-  return reinterpret_cast<Dart_Handle>(null_handle);
+  return null_handle_;
 }
 
 
 Dart_Handle Api::True(Isolate* isolate) {
-  ASSERT(isolate != NULL);
-  ApiState* state = isolate->api_state();
-  ASSERT(state != NULL);
-  PersistentHandle* true_handle = state->True();
-  return reinterpret_cast<Dart_Handle>(true_handle);
+  return true_handle_;
 }
 
 
 Dart_Handle Api::False(Isolate* isolate) {
-  ASSERT(isolate != NULL);
-  ApiState* state = isolate->api_state();
-  ASSERT(state != NULL);
-  PersistentHandle* false_handle = state->False();
-  return reinterpret_cast<Dart_Handle>(false_handle);
+  return false_handle_;
 }
 
 
 ApiLocalScope* Api::TopScope(Isolate* isolate) {
   ASSERT(isolate != NULL);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   ApiLocalScope* scope = state->top_scope();
   ASSERT(scope != NULL);
   return scope;
 }
 
 
 void Api::InitOnce() {
   ASSERT(api_native_key_ == Thread::kUnsetThreadLocalKey);
   api_native_key_ = Thread::CreateThreadLocal();
   ASSERT(api_native_key_ != Thread::kUnsetThreadLocalKey);
 }
 
 
+void Api::InitHandles() {
+  Isolate* isolate = Isolate::Current();
+  ASSERT(isolate != NULL);
+  ASSERT(isolate == Dart::vm_isolate());
+  ApiState* state = isolate->api_state();
+  ASSERT(state != NULL);
+  ASSERT(true_handle_ == NULL);
+  true_handle_ = Api::NewHandle(isolate, Bool::True().raw());
+
+  ASSERT(false_handle_ == NULL);
+  false_handle_ = Api::NewHandle(isolate, Bool::False().raw());
+
+  ASSERT(null_handle_ == NULL);
+  null_handle_ = Api::NewHandle(isolate, Object::null());
+}
+
+
 bool Api::ExternalStringGetPeerHelper(Dart_Handle object, void** peer) {
   NoGCScope no_gc_scope;
   RawObject* raw_obj = Api::UnwrapHandle(object);
   switch (Api::ClassId(object)) {
     case kExternalOneByteStringCid: {
       RawExternalOneByteString* raw_string =
           reinterpret_cast<RawExternalOneByteString*>(raw_obj)->ptr();
       ExternalStringData<uint8_t>* data = raw_string->external_data_;
       *peer = data->peer();
       return true;
@@ skipping 250 matching lines @@
 
 
 DART_EXPORT bool Dart_IdentityEquals(Dart_Handle obj1, Dart_Handle obj2) {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
   NoGCScope ngc;
   return Api::UnwrapHandle(obj1) == Api::UnwrapHandle(obj2);
 }
 
 
-DART_EXPORT Dart_Handle Dart_NewPersistentHandle(Dart_Handle object) {
+DART_EXPORT Dart_Handle Dart_HandleFromPersistent(Dart_PersistentHandle object) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  ApiState* state = isolate->api_state();
+  ASSERT(state != NULL);
+  ASSERT(state->IsValidPersistentHandle(object));
+  return Api::NewHandle(isolate, reinterpret_cast<PersistentHandle*>(object)->raw());
+}
+
+
+DART_EXPORT Dart_Handle Dart_HandleFromWeakPersistent(Dart_WeakPersistentHandle object) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(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());
+}
+
+
+DART_EXPORT Dart_PersistentHandle Dart_NewPersistentHandle(Dart_Handle object) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   const Object& old_ref = Object::Handle(isolate, Api::UnwrapHandle(object));
   PersistentHandle* new_ref = state->persistent_handles().AllocateHandle();
   new_ref->set_raw(old_ref);
-  return reinterpret_cast<Dart_Handle>(new_ref);
+  return reinterpret_cast<Dart_PersistentHandle>(new_ref);
 }
 
-static Dart_Handle AllocateFinalizableHandle(
+static Dart_WeakPersistentHandle AllocateFinalizableHandle(
     Isolate* isolate,
     FinalizablePersistentHandles* handles,
     Dart_Handle object,
     void* peer,
     Dart_WeakPersistentHandleFinalizer callback) {
   const Object& ref = Object::Handle(isolate, Api::UnwrapHandle(object));
   FinalizablePersistentHandle* finalizable_ref = handles->AllocateHandle();
   finalizable_ref->set_raw(ref);
   finalizable_ref->set_peer(peer);
   finalizable_ref->set_callback(callback);
-  return reinterpret_cast<Dart_Handle>(finalizable_ref);
+  return reinterpret_cast<Dart_WeakPersistentHandle>(finalizable_ref);
 }
 
 
-DART_EXPORT Dart_Handle Dart_NewWeakPersistentHandle(
+DART_EXPORT Dart_WeakPersistentHandle Dart_NewWeakPersistentHandle(
     Dart_Handle object,
     void* peer,
     Dart_WeakPersistentHandleFinalizer callback) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   return AllocateFinalizableHandle(isolate,
                                    &state->weak_persistent_handles(),
                                    object,
                                    peer,
                                    callback);
 }
 
 
-DART_EXPORT Dart_Handle Dart_NewPrologueWeakPersistentHandle(
+DART_EXPORT Dart_WeakPersistentHandle Dart_NewPrologueWeakPersistentHandle(
     Dart_Handle object,
     void* peer,
     Dart_WeakPersistentHandleFinalizer callback) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   return AllocateFinalizableHandle(isolate,
                                    &state->prologue_weak_persistent_handles(),
                                    object,
                                    peer,
                                    callback);
 }
 
 
-DART_EXPORT void Dart_DeletePersistentHandle(Dart_Handle object) {
+DART_EXPORT void Dart_DeletePersistentHandle(Dart_PersistentHandle object) {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
-  if (state->IsValidPrologueWeakPersistentHandle(object)) {
-    FinalizablePersistentHandle* prologue_weak_ref =
-        Api::UnwrapAsPrologueWeakPersistentHandle(*state, object);
-    state->prologue_weak_persistent_handles().FreeHandle(prologue_weak_ref);
-    return;
-  }
-  if (state->IsValidWeakPersistentHandle(object)) {
-    FinalizablePersistentHandle* weak_ref =
-        Api::UnwrapAsWeakPersistentHandle(*state, object);
-    state->weak_persistent_handles().FreeHandle(weak_ref);
-    return;
-  }
-  PersistentHandle* ref = Api::UnwrapAsPersistentHandle(*state, object);
+  PersistentHandle* ref = Api::UnwrapAsPersistentHandle(object);
   ASSERT(!state->IsProtectedHandle(ref));
   if (!state->IsProtectedHandle(ref)) {
     state->persistent_handles().FreeHandle(ref);
   }
 }
 
 
-DART_EXPORT bool Dart_IsWeakPersistentHandle(Dart_Handle object) {
+DART_EXPORT void Dart_DeleteWeakPersistentHandle(Dart_WeakPersistentHandle object) {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
-  return state->IsValidWeakPersistentHandle(object);
+  if (state->IsValidPrologueWeakPersistentHandle(object)) {
+    FinalizablePersistentHandle* prologue_weak_ref =
+        Api::UnwrapAsPrologueWeakPersistentHandle(object);
+    state->prologue_weak_persistent_handles().FreeHandle(prologue_weak_ref);
+    return;
+  }
+  FinalizablePersistentHandle* weak_ref =
+      Api::UnwrapAsWeakPersistentHandle(object);
+  state->weak_persistent_handles().FreeHandle(weak_ref);
+  return;
 }
 
 
-DART_EXPORT bool Dart_IsPrologueWeakPersistentHandle(Dart_Handle object) {
+DART_EXPORT bool Dart_IsPrologueWeakPersistentHandle(Dart_WeakPersistentHandle object) {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   return state->IsValidPrologueWeakPersistentHandle(object);
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewWeakReferenceSet(Dart_Handle* keys,
                                                  intptr_t num_keys,
@@ skipping 1851 matching lines @@
 
 static Dart_Handle NewTypedData(Isolate* isolate,
                                 intptr_t cid,
                                 intptr_t length) {
   CHECK_LENGTH(length, TypedData::MaxElements(cid));
   return Api::NewHandle(isolate, TypedData::New(cid, length));
 }
 
 
 static Dart_Handle NewExternalTypedData(
-    Isolate* isolate,
-    intptr_t cid,
-    void* data,
-    intptr_t length,
-    void* peer,
-    Dart_WeakPersistentHandleFinalizer callback) {
+    Isolate* isolate, intptr_t cid, void* data, intptr_t length) {
   CHECK_LENGTH(length, ExternalTypedData::MaxElements(cid));
   const ExternalTypedData& result = ExternalTypedData::Handle(
       isolate,
       ExternalTypedData::New(cid, reinterpret_cast<uint8_t*>(data), length));
-  result.AddFinalizer(peer, callback);
   return Api::NewHandle(isolate, result.raw());
 }
 
 
-static Dart_Handle NewExternalByteData(Isolate* isolate,
-                                       void* data,
-                                       intptr_t length,
-                                       void* peer,
-                                       Dart_WeakPersistentHandleFinalizer cb) {
-  Dart_Handle ext_data = NewExternalTypedData(isolate,
-                                              kExternalTypedDataUint8ArrayCid,
-                                              data,
-                                              length,
-                                              peer,
-                                              cb);
+static Dart_Handle NewExternalByteData(
+    Isolate* isolate, void* data, intptr_t length) {
+  Dart_Handle ext_data = NewExternalTypedData(
+      isolate, kExternalTypedDataUint8ArrayCid, data, length);
   if (::Dart_IsError(ext_data)) {
     return ext_data;
   }
   Object& result = Object::Handle(isolate);
   result = GetByteDataConstructor(isolate, Symbols::ByteDataDotview(), 3);
   ASSERT(!result.IsNull());
   ASSERT(result.IsFunction());
   const Function& factory = Function::Cast(result);
   ASSERT(!factory.IsConstructor());
 
@@ skipping 55 matching lines @@
                            CURRENT_FUNC);
   }
   UNREACHABLE();
   return Api::Null(isolate);
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewExternalTypedData(
     Dart_TypedData_Type type,
     void* data,
-    intptr_t length,
-    void* peer,
-    Dart_WeakPersistentHandleFinalizer callback) {
+    intptr_t length) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   if (data == NULL && length != 0) {
     RETURN_NULL_ERROR(data);
   }
   CHECK_CALLBACK_STATE(isolate);
   switch (type) {
     case kByteData:
-      return NewExternalByteData(isolate, data, length, peer, callback);
+      return NewExternalByteData(isolate, data, length);
     case kInt8:
       return NewExternalTypedData(isolate,
                                   kExternalTypedDataInt8ArrayCid,
                                   data,
-                                  length,
-                                  peer,
-                                  callback);
+                                  length);
     case kUint8:
       return NewExternalTypedData(isolate,
                                   kExternalTypedDataUint8ArrayCid,
                                   data,
-                                  length,
-                                  peer,
-                                  callback);
+                                  length);
     case kUint8Clamped:
       return NewExternalTypedData(isolate,
                                   kExternalTypedDataUint8ClampedArrayCid,
                                   data,
-                                  length,
-                                  peer,
-                                  callback);
+                                  length);
     case kInt16:
       return NewExternalTypedData(isolate,
                                   kExternalTypedDataInt16ArrayCid,
                                   data,
-                                  length,
-                                  peer,
-                                  callback);
+                                  length);
     case kUint16:
       return NewExternalTypedData(isolate,
                                   kExternalTypedDataUint16ArrayCid,
                                   data,
-                                  length,
-                                  peer,
-                                  callback);
+                                  length);
     case kInt32:
       return NewExternalTypedData(isolate,
                                   kExternalTypedDataInt32ArrayCid,
                                   data,
-                                  length,
-                                  peer,
-                                  callback);
+                                  length);
     case kUint32:
       return NewExternalTypedData(isolate,
                                   kExternalTypedDataUint32ArrayCid,
                                   data,
-                                  length,
-                                  peer,
-                                  callback);
+                                  length);
     case kInt64:
       return NewExternalTypedData(isolate,
                                   kExternalTypedDataInt64ArrayCid,
                                   data,
-                                  length,
-                                  peer,
-                                  callback);
+                                  length);
     case kUint64:
       return NewExternalTypedData(isolate,
                                   kExternalTypedDataUint64ArrayCid,
                                   data,
-                                  length,
-                                  peer,
-                                  callback);
+                                  length);
     case kFloat32:
       return NewExternalTypedData(isolate,
                                   kExternalTypedDataFloat32ArrayCid,
                                   data,
-                                  length,
-                                  peer,
-                                  callback);
+                                  length);
     case kFloat64:
       return NewExternalTypedData(isolate,
                                   kExternalTypedDataFloat64ArrayCid,
                                   data,
-                                  length,
-                                  peer,
-                                  callback);
+                                  length);
     case kFloat32x4:
       return NewExternalTypedData(isolate,
                                   kExternalTypedDataFloat32x4ArrayCid,
                                   data,
-                                  length,
-                                  peer,
-                                  callback);
+                                  length);
     default:
       return Api::NewError("%s expects argument 'type' to be of"
                            " 'external TypedData'", CURRENT_FUNC);
   }
   UNREACHABLE();
   return Api::Null(isolate);
 }
 
 
-DART_EXPORT Dart_Handle Dart_ExternalTypedDataGetPeer(Dart_Handle object,
-                                                      void** peer) {
-  Isolate* isolate = Isolate::Current();
-  DARTSCOPE(isolate);
-  const ExternalTypedData& array =
-      Api::UnwrapExternalTypedDataHandle(isolate, object);
-  if (array.IsNull()) {
-    RETURN_TYPE_ERROR(isolate, object, ExternalTypedData);
-  }
-  if (peer == NULL) {
-    RETURN_NULL_ERROR(peer);
-  }
-  *peer = array.GetPeer();
-  return Api::Success(isolate);
-}
-

[siva, 2013/05/28 17:37:18]

Why is this not needed anymore?

-
 DART_EXPORT Dart_Handle Dart_TypedDataAcquireData(Dart_Handle object,
                                                   Dart_TypedData_Type* type,
                                                   void** data,
                                                   intptr_t* len) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   intptr_t class_id = Api::ClassId(object);
   if (!RawObject::IsExternalTypedDataClassId(class_id) &&
       !RawObject::IsTypedDataViewClassId(class_id) &&
       !RawObject::IsTypedDataClassId(class_id)) {
@@ skipping 2156 matching lines @@
   }
   {
     NoGCScope no_gc;
     RawObject* raw_obj = obj.raw();
     isolate->heap()->SetPeer(raw_obj, peer);
   }
   return Api::Success(isolate);
 }
 
 }  // namespace dart