1. Added new versions of Api::UnWrapStringHandle Api::UnWrapInstanceHandle to

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 "include/dart_mirrors_api.h"
 #include "include/dart_native_api.h"
 
 #include "platform/assert.h"
 #include "vm/bigint_operations.h"
@@ skipping 115 matching lines @@
     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
 
 
+const String& Api::UnwrapStringHandle(const ReusableObjectHandleScope& reuse,
+                                      Dart_Handle dart_handle) {
+  Object& ref = reuse.Handle();
+  ref = Api::UnwrapHandle(dart_handle);
+  if (ref.IsString()) {
+    return String::Cast(ref);
+  }
+  return Object::null_string();
+}
+
+
+const Instance& Api::UnwrapInstanceHandle(
+    const ReusableObjectHandleScope& reuse, Dart_Handle dart_handle) {
+  Object& ref = reuse.Handle();
+  ref = Api::UnwrapHandle(dart_handle);
+  if (ref.IsInstance()) {
+    return Instance::Cast(ref);
+  }
+  return Object::null_instance();
+}
+
+
 PersistentHandle* Api::UnwrapAsPersistentHandle(Dart_PersistentHandle object) {
   ASSERT(Isolate::Current()->api_state()->IsValidPersistentHandle(object));
   return reinterpret_cast<PersistentHandle*>(object);
 }
 
 
 FinalizablePersistentHandle* Api::UnwrapAsWeakPersistentHandle(
     Dart_WeakPersistentHandle object) {
   ASSERT(Isolate::Current()->api_state()->IsValidWeakPersistentHandle(object) ||
          Isolate::Current()->api_state()->
@@ skipping 108 matching lines @@
   true_handle_ = Api::InitNewHandle(isolate, Bool::True().raw());
 
   ASSERT(false_handle_ == NULL);
   false_handle_ = Api::InitNewHandle(isolate, Bool::False().raw());
 
   ASSERT(null_handle_ == NULL);
   null_handle_ = Api::InitNewHandle(isolate, Object::null());
 }
 
 
-bool Api::StringGetPeerHelper(Dart_NativeArguments args,
+bool Api::StringGetPeerHelper(NativeArguments* arguments,
                               int arg_index,
                               void** peer) {
   NoGCScope no_gc_scope;
-  NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
   RawObject* raw_obj = arguments->NativeArgAt(arg_index);
   if (!raw_obj->IsHeapObject()) {
     return false;
   }
   intptr_t cid = raw_obj->GetClassId();
   if (cid == kExternalOneByteStringCid) {
     RawExternalOneByteString* raw_string =
         reinterpret_cast<RawExternalOneByteString*>(raw_obj)->ptr();
     ExternalStringData<uint8_t>* data = raw_string->external_data_;
     *peer = data->peer();
     return true;
   }
   if (cid == kOneByteStringCid || cid == kTwoByteStringCid) {
     Isolate* isolate = arguments->isolate();
     *peer = isolate->heap()->GetPeer(raw_obj);
     return (*peer != 0);
   }
   if (cid == kExternalTwoByteStringCid) {
     RawExternalTwoByteString* raw_string =
         reinterpret_cast<RawExternalTwoByteString*>(raw_obj)->ptr();
     ExternalStringData<uint16_t>* data = raw_string->external_data_;
     *peer = data->peer();
     return true;
   }
   return false;
 }
 
 
-bool Api::GetNativeReceiver(Dart_NativeArguments args, intptr_t* value) {
+bool Api::GetNativeReceiver(NativeArguments* arguments, intptr_t* value) {
   NoGCScope no_gc_scope;
-  NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
   RawObject* raw_obj = arguments->NativeArg0();
   if (raw_obj->IsHeapObject()) {
     intptr_t cid = raw_obj->GetClassId();
     if (cid > kNumPredefinedCids) {
       ASSERT(Instance::Cast(Object::Handle(raw_obj)).IsValidNativeIndex(0));
       RawTypedData* native_fields = *reinterpret_cast<RawTypedData**>(
           RawObject::ToAddr(raw_obj) + sizeof(RawObject));
       if (native_fields == TypedData::null()) {
         *value = 0;
       } else {
         *value = *bit_cast<intptr_t*, uint8_t*>(native_fields->ptr()->data_);
       }
       return true;
     }
   }
   return false;
 }
 
 
-bool Api::GetNativeBooleanArgument(Dart_NativeArguments args,
+bool Api::GetNativeBooleanArgument(NativeArguments* arguments,
                                    int arg_index,
                                    bool* value) {
   NoGCScope no_gc_scope;
-  NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
   RawObject* raw_obj = arguments->NativeArgAt(arg_index);
   if (raw_obj->IsHeapObject()) {
       intptr_t cid = raw_obj->GetClassId();
       if (cid == kBoolCid) {
         *value = (raw_obj == Object::bool_true().raw());
         return true;
       }
       if (cid == kNullCid) {
         *value = false;
         return true;
@@ skipping 258 matching lines @@
   obj1_ref->set_raw(obj2_ref);
 }
 
 
 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));
+  ReusableObjectHandleScope reused_obj_handle(isolate);
+  Object& ref = reused_obj_handle.Handle();
+  ref = 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_WeakPersistentHandle>(finalizable_ref);
 }
 
 
 DART_EXPORT Dart_WeakPersistentHandle Dart_NewWeakPersistentHandle(
     Dart_Handle object,
     void* peer,
     Dart_WeakPersistentHandleFinalizer callback) {
   Isolate* isolate = Isolate::Current();
-  DARTSCOPE(isolate);
+  CHECK_ISOLATE(isolate);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   return AllocateFinalizableHandle(isolate,
                                    &state->weak_persistent_handles(),
                                    object,
                                    peer,
                                    callback);
 }
 
 
 DART_EXPORT Dart_WeakPersistentHandle Dart_NewPrologueWeakPersistentHandle(
     Dart_Handle object,
     void* peer,
     Dart_WeakPersistentHandleFinalizer callback) {
   Isolate* isolate = Isolate::Current();
-  DARTSCOPE(isolate);
+  CHECK_ISOLATE(isolate);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   return AllocateFinalizableHandle(isolate,
                                    &state->prologue_weak_persistent_handles(),
                                    object,
                                    peer,
                                    callback);
 }
 
 
@@ skipping 696 matching lines @@
   Error& malformed_type_error = Error::Handle(isolate);
   *value = instance.IsInstanceOf(type_obj,
                                  Object::null_type_arguments(),
                                  &malformed_type_error);
   ASSERT(malformed_type_error.IsNull());  // Type was created from a class.
   return Api::Success();
 }
 
 
 DART_EXPORT bool Dart_IsInstance(Dart_Handle object) {
   Isolate* isolate = Isolate::Current();

[Ivan Posva, 2014/02/28 04:41:36]

Could we before doing any of the work below just do a quick class ID check?

-  DARTSCOPE(isolate);
-  const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(object));
-  return obj.IsInstance();
+  CHECK_ISOLATE(isolate);
+  ReusableObjectHandleScope reused_obj_handle(isolate);
+  Object& ref = reused_obj_handle.Handle();
+  ref = Api::UnwrapHandle(object);
+  return ref.IsInstance();
 }
 
 
 DART_EXPORT bool Dart_IsNumber(Dart_Handle object) {
   TRACE_API_CALL(CURRENT_FUNC);
   return RawObject::IsNumberClassId(Api::ClassId(object));
 }
 
 
 DART_EXPORT bool Dart_IsInteger(Dart_Handle object) {
@@ skipping 72 matching lines @@
 DART_EXPORT bool Dart_IsTypeVariable(Dart_Handle handle) {
   TRACE_API_CALL(CURRENT_FUNC);
   return Api::ClassId(handle) == kTypeParameterCid;
 }
 
 
 DART_EXPORT bool Dart_IsClosure(Dart_Handle object) {
   // We can't use a fast class index check here because there are many
   // different signature classes for closures.
   Isolate* isolate = Isolate::Current();
-  DARTSCOPE(isolate);
-  const Instance& closure_obj = Api::UnwrapInstanceHandle(isolate, object);
+  CHECK_ISOLATE(isolate);
+  ReusableObjectHandleScope reused_obj_handle(isolate);
+  const Instance& closure_obj =
+      Api::UnwrapInstanceHandle(reused_obj_handle, object);
   return (!closure_obj.IsNull() && closure_obj.IsClosure());
 }
 
 
 // --- Instances ----
 
 DART_EXPORT Dart_Handle Dart_InstanceGetType(Dart_Handle instance) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(instance));
@@ skipping 226 matching lines @@
   *value = obj.value();
   return Api::Success();
 }
 
 
 // --- Strings ---
 
 
 DART_EXPORT Dart_Handle Dart_StringLength(Dart_Handle str, intptr_t* len) {
   Isolate* isolate = Isolate::Current();
-  DARTSCOPE(isolate);
-  const String& str_obj = Api::UnwrapStringHandle(isolate, str);
+  CHECK_ISOLATE(isolate);
+  ReusableObjectHandleScope reused_obj_handle(isolate);
+  const String& str_obj = Api::UnwrapStringHandle(reused_obj_handle, str);
   if (str_obj.IsNull()) {
     RETURN_TYPE_ERROR(isolate, str, String);
   }
   *len = str_obj.Length();
   return Api::Success();
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewStringFromCString(const char* str) {
   Isolate* isolate = Isolate::Current();
@@ skipping 175 matching lines @@
     utf16_array[i] = static_cast<uint16_t>(str_obj.CharAt(i));
   }
   *length = copy_len;
   return Api::Success();
 }
 
 
 DART_EXPORT Dart_Handle Dart_StringStorageSize(Dart_Handle str,
                                                intptr_t* size) {
   Isolate* isolate = Isolate::Current();
-  DARTSCOPE(isolate);
-  const String& str_obj = Api::UnwrapStringHandle(isolate, str);
+  CHECK_ISOLATE(isolate);
+  ReusableObjectHandleScope reused_obj_handle(isolate);
+  const String& str_obj = Api::UnwrapStringHandle(reused_obj_handle, str);
   if (str_obj.IsNull()) {
     RETURN_TYPE_ERROR(isolate, str, String);
   }
   if (size == NULL) {
     RETURN_NULL_ERROR(size);
   }
   *size = (str_obj.Length() * str_obj.CharSize());
   return Api::Success();
 }
 
@@ skipping 50 matching lines @@
   return Api::NewHandle(isolate,
                         str_obj.MakeExternal(array, length, peer, cback));
 }
 
 
 DART_EXPORT Dart_Handle Dart_StringGetProperties(Dart_Handle object,
                                                  intptr_t* char_size,
                                                  intptr_t* str_len,
                                                  void** peer) {
   Isolate* isolate = Isolate::Current();
-  DARTSCOPE(isolate);
-  const String& str = Api::UnwrapStringHandle(isolate, object);
+  CHECK_ISOLATE(isolate);
+  ReusableObjectHandleScope reused_obj_handle(isolate);
+  const String& str = Api::UnwrapStringHandle(reused_obj_handle, object);
   if (str.IsNull()) {
     RETURN_TYPE_ERROR(isolate, object, String);
   }
   if (str.IsExternal()) {
     *peer = str.GetPeer();
     ASSERT(*peer != NULL);
   } else {
     NoGCScope no_gc_scope;
     *peer = isolate->heap()->GetPeer(str.raw());
   }
@@ skipping 1773 matching lines @@
     return Api::NewError(
         "Unable to create native wrapper class : already exists");
   }
   return Api::NewHandle(isolate, cls.RareType());
 }
 
 
 DART_EXPORT Dart_Handle Dart_GetNativeInstanceFieldCount(Dart_Handle obj,
                                                          int* count) {
   Isolate* isolate = Isolate::Current();
-  DARTSCOPE(isolate);
-  const Instance& instance = Api::UnwrapInstanceHandle(isolate, obj);
+  CHECK_ISOLATE(isolate);
+  ReusableObjectHandleScope reused_obj_handle(isolate);
+  const Instance& instance = Api::UnwrapInstanceHandle(reused_obj_handle, obj);
   if (instance.IsNull()) {
     RETURN_TYPE_ERROR(isolate, obj, Instance);
   }
   const Class& cls = Class::Handle(isolate, instance.clazz());
   *count = cls.num_native_fields();
   return Api::Success();
 }
 
 
 DART_EXPORT Dart_Handle Dart_GetNativeInstanceField(Dart_Handle obj,
                                                     int index,
                                                     intptr_t* value) {
   Isolate* isolate = Isolate::Current();
-  DARTSCOPE(isolate);
-  const Instance& instance = Api::UnwrapInstanceHandle(isolate, obj);
+  CHECK_ISOLATE(isolate);
+  ReusableObjectHandleScope reused_obj_handle(isolate);
+  const Instance& instance = Api::UnwrapInstanceHandle(reused_obj_handle, obj);
   if (instance.IsNull()) {
     RETURN_TYPE_ERROR(isolate, obj, Instance);
   }
   if (!instance.IsValidNativeIndex(index)) {
     return Api::NewError(
         "%s: invalid index %d passed in to access native instance field",
         CURRENT_FUNC, index);
   }
   *value = instance.GetNativeField(index);
   return Api::Success();
 }
 
 
 DART_EXPORT Dart_Handle Dart_SetNativeInstanceField(Dart_Handle obj,
                                                     int index,
                                                     intptr_t value) {
   Isolate* isolate = Isolate::Current();
-  DARTSCOPE(isolate);
-  const Instance& instance = Api::UnwrapInstanceHandle(isolate, obj);
+  CHECK_ISOLATE(isolate);
+  ReusableObjectHandleScope reused_obj_handle(isolate);
+  const Instance& instance = Api::UnwrapInstanceHandle(reused_obj_handle, obj);
   if (instance.IsNull()) {
     RETURN_TYPE_ERROR(isolate, obj, Instance);
   }
   if (!instance.IsValidNativeIndex(index)) {
     return Api::NewError(
         "%s: invalid index %d passed in to set native instance field",
         CURRENT_FUNC, index);
   }
   instance.SetNativeField(index, value);
   return Api::Success();
@@ skipping 36 matching lines @@
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
   if ((arg_index < 0) || (arg_index >= arguments->NativeArgCount())) {
     return Api::NewError(
         "%s: argument 'arg_index' out of range. Expected 0..%d but saw %d.",
         CURRENT_FUNC, arguments->NativeArgCount() - 1, arg_index);
   }
   if (field_values == NULL) {
     RETURN_NULL_ERROR(field_values);
   }
   Isolate* isolate = arguments->isolate();
-  DARTSCOPE(isolate);
+  CHECK_ISOLATE(isolate);
   ReusableObjectHandleScope reused_obj_handle(isolate);
   Object& obj = reused_obj_handle.Handle();
   obj = arguments->NativeArgAt(arg_index);
   if (obj.IsNull()) {
     for (intptr_t i = 0; i < num_fields; i++) {
       field_values[i] = 0;
     }
     return Api::Success();
   }
   if (!obj.IsInstance()) {
@@ skipping 13 matching lines @@
 
 
 DART_EXPORT Dart_Handle Dart_GetNativeReceiver(Dart_NativeArguments args,
                                                intptr_t* value) {
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
   Isolate* isolate = arguments->isolate();
   CHECK_ISOLATE(isolate);
   if (value == NULL) {
     RETURN_NULL_ERROR(value);
   }
-  if (Api::GetNativeReceiver(args, value)) {
+  if (Api::GetNativeReceiver(arguments, value)) {
     return Api::Success();
   }
   return Api::NewError("%s expects receiver argument to be non-null and of"
                        " type Instance.", CURRENT_FUNC);
 }
 
 
 DART_EXPORT Dart_Handle Dart_GetNativeStringArgument(Dart_NativeArguments args,
                                                      int arg_index,
                                                      void** peer) {
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
   Isolate* isolate = arguments->isolate();
   CHECK_ISOLATE(isolate);
-  if (Api::StringGetPeerHelper(args, arg_index, peer)) {
+  if (Api::StringGetPeerHelper(arguments, arg_index, peer)) {
     return Api::Success();
   }
   *peer = NULL;
   ReusableObjectHandleScope reused_obj_handle(isolate);
   Object& obj = reused_obj_handle.Handle();
   obj = arguments->NativeArgAt(arg_index);
   if (RawObject::IsStringClassId(obj.GetClassId())) {
     return Api::NewHandle(isolate, obj.raw());
   }
   if (obj.IsNull()) {
@@ skipping 46 matching lines @@
 DART_EXPORT Dart_Handle Dart_GetNativeBooleanArgument(Dart_NativeArguments args,
                                                       int index,
                                                       bool* value) {
   TRACE_API_CALL(CURRENT_FUNC);
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
   if ((index < 0) || (index >= arguments->NativeArgCount())) {
     return Api::NewError(
         "%s: argument 'index' out of range. Expected 0..%d but saw %d.",
         CURRENT_FUNC, arguments->NativeArgCount() - 1, index);
   }
-  if (Api::GetNativeBooleanArgument(args, index, value)) {
+  if (Api::GetNativeBooleanArgument(arguments, index, value)) {
     return Api::Success();
   }
   return Api::NewError("%s: argument %d is not a Boolean argument.",
       CURRENT_FUNC, index);
 }
 
 
 DART_EXPORT Dart_Handle Dart_GetNativeDoubleArgument(Dart_NativeArguments args,
                                                      int index,
                                                      double* value) {
@@ skipping 229 matching lines @@
   }
   library ^= tmp.raw();
   library.set_debuggable(true);
   isolate->object_store()->set_root_library(library);
   return Api::NewHandle(isolate, library.raw());
 }
 
 
 DART_EXPORT Dart_Handle Dart_RootLibrary() {
   Isolate* isolate = Isolate::Current();
-  DARTSCOPE(isolate);
-  Library& library =
-      Library::Handle(isolate, isolate->object_store()->root_library());
-  return Api::NewHandle(isolate, library.raw());
+  CHECK_ISOLATE(isolate);
+  return Api::NewHandle(isolate, isolate->object_store()->root_library());
 }
 
 
 DART_EXPORT Dart_Handle Dart_GetClass(Dart_Handle library,
                                       Dart_Handle class_name) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Library& lib = Api::UnwrapLibraryHandle(isolate, library);
   if (lib.IsNull()) {
     RETURN_TYPE_ERROR(isolate, library, Library);
@@ skipping 285 matching lines @@
 }
 
 
 // --- Peer support ---
 
 DART_EXPORT Dart_Handle Dart_GetPeer(Dart_Handle object, void** peer) {
   if (peer == NULL) {
     RETURN_NULL_ERROR(peer);
   }
   Isolate* isolate = Isolate::Current();
-  DARTSCOPE(isolate);
-  const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(object));
+  CHECK_ISOLATE(isolate);
+  ReusableObjectHandleScope reused_obj_handle(isolate);
+  Object& obj = reused_obj_handle.Handle();
+  obj = Api::UnwrapHandle(object);
   if (obj.IsNull() || obj.IsNumber() || obj.IsBool()) {
     const char* msg =
         "%s: argument 'object' cannot be a subtype of Null, num, or bool";
     return Api::NewError(msg, CURRENT_FUNC);
   }
   {
     NoGCScope no_gc;
     RawObject* raw_obj = obj.raw();
     *peer = isolate->heap()->GetPeer(raw_obj);
   }
   return Api::Success();
 }
 
 
 DART_EXPORT Dart_Handle Dart_SetPeer(Dart_Handle object, void* peer) {
   Isolate* isolate = Isolate::Current();
-  DARTSCOPE(isolate);
-  const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(object));
+  CHECK_ISOLATE(isolate);
+  ReusableObjectHandleScope reused_obj_handle(isolate);
+  Object& obj = reused_obj_handle.Handle();
+  obj = Api::UnwrapHandle(object);
   if (obj.IsNull() || obj.IsNumber() || obj.IsBool()) {
     const char* msg =
         "%s: argument 'object' cannot be a subtype of Null, num, or bool";
     return Api::NewError(msg, CURRENT_FUNC);
   }
   {
     NoGCScope no_gc;
     RawObject* raw_obj = obj.raw();
     isolate->heap()->SetPeer(raw_obj, peer);
   }
@@ skipping 22 matching lines @@
 
 
 DART_EXPORT void Dart_RegisterRootServiceRequestCallback(
     const char* name,
     Dart_ServiceRequestCallback callback,
     void* user_data) {
   Service::RegisterRootEmbedderCallback(name, callback, user_data);
 }
 
 }  // namespace dart