Added following dart API changes to enable more efficient access based

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"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/dart.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_api_message.h"
 #include "vm/dart_api_state.h"
 #include "vm/dart_entry.h"
 #include "vm/debuginfo.h"
 #include "vm/exceptions.h"
 #include "vm/flags.h"
 #include "vm/growable_array.h"
 #include "vm/message.h"
 #include "vm/message_handler.h"
 #include "vm/native_entry.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/port.h"
 #include "vm/resolver.h"
+#include "vm/reusable_handles.h"
 #include "vm/stack_frame.h"
 #include "vm/symbols.h"
 #include "vm/timer.h"
 #include "vm/unicode.h"
 #include "vm/verifier.h"
 #include "vm/version.h"
 
 namespace dart {
 
 DECLARE_FLAG(bool, print_class_table);
@@ skipping 216 matching lines @@
           reinterpret_cast<RawExternalTwoByteString*>(raw_obj)->ptr();
       ExternalStringData<uint16_t>* data = raw_string->external_data_;
       *peer = data->peer();
       return true;
     }
   }
   return false;
 }
 
 
+void Api::SetWeakHandleReturnValue(NativeArguments* args,
+                                   Dart_WeakPersistentHandle retval) {
+  args->SetReturnUnsafe(
+      reinterpret_cast<FinalizablePersistentHandle*>(retval)->raw());
+}
+
+
 // --- Handles ---
 
 DART_EXPORT bool Dart_IsError(Dart_Handle handle) {
   return RawObject::IsErrorClassId(Api::ClassId(handle));
 }
 
 
 DART_EXPORT bool Dart_IsApiError(Dart_Handle object) {
   return Api::ClassId(object) == kApiErrorCid;
 }
@@ skipping 850 matching lines @@
 // --- Objects ----
 
 DART_EXPORT Dart_Handle Dart_Null() {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE_SCOPE(isolate);
   return Api::Null();
 }
 
 
 DART_EXPORT bool Dart_IsNull(Dart_Handle object) {
-  return Api::ClassId(object) == kNullCid;
+  return Api::UnwrapHandle(object) == Object::null();
 }
 
 
 DART_EXPORT Dart_Handle Dart_ObjectEquals(Dart_Handle obj1, Dart_Handle obj2,
                                           bool* value) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   CHECK_CALLBACK_STATE(isolate);
   const Instance& expected =
       Instance::CheckedHandle(isolate, Api::UnwrapHandle(obj1));
@@ skipping 689 matching lines @@
         utf16_array[i] = static_cast<uint16_t>(str_obj.CharAt(i));
       }
     }
     return Api::Null();
   }
   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);
+  if (str.IsNull()) {
+    RETURN_TYPE_ERROR(isolate, object, String);
+  }
+  if (str.IsExternal()) {
+    *peer = str.GetPeer();
+    ASSERT(*peer != NULL);
+  } else {
+    *peer = NULL;
+  }
+  *char_size = str.CharSize();
+  *str_len = str.Length();
+  return Api::Success();
+}
+
+
 // --- Lists ---
 
 DART_EXPORT Dart_Handle Dart_NewList(intptr_t length) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   CHECK_LENGTH(length, Array::kMaxElements);
   CHECK_CALLBACK_STATE(isolate);
   return Api::NewHandle(isolate, Array::New(length));
 }
 
@@ skipping 1761 matching lines @@
         "%s: invalid index %d passed in to access native instance field",
         CURRENT_FUNC, fld_index);
   }
   if (value == NULL) {
     RETURN_NULL_ERROR(value);
   }
   *value = instance.GetNativeField(isolate, fld_index);
   return Api::Success();
 }
 
+
 DART_EXPORT Dart_Handle Dart_GetNativeReceiver(Dart_NativeArguments args,
                                                intptr_t* value) {
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
   Isolate* isolate = arguments->isolate();
-  DARTSCOPE(isolate);
-  const Object& obj = Object::Handle(isolate, arguments->NativeArgAt(0));
+  CHECK_ISOLATE(isolate);
+  ReusableObjectHandleScope reused_obj_handle(isolate);
+  Object& obj = reused_obj_handle.Handle();
+  obj = arguments->NativeArgAt(0);
   intptr_t cid = obj.GetClassId();
   if (cid <= kNumPredefinedCids) {
     if (cid == kNullCid) {
       return Api::NewError("%s expects receiver argument to be non-null.",
                            CURRENT_FUNC);
     }
     return Api::NewError("%s expects receiver argument to be of"
                          " type Instance.", CURRENT_FUNC);
   }
   const Instance& instance = Instance::Cast(obj);
   ASSERT(instance.IsValidNativeIndex(0));
   if (value == NULL) {
     RETURN_NULL_ERROR(value);
   }
   *value = instance.GetNativeField(isolate, 0);
   return Api::Success();
 }
 
 
+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);
+  ReusableObjectHandleScope reused_obj_handle(isolate);
+  Object& obj = reused_obj_handle.Handle();
+  obj = arguments->NativeArgAt(arg_index);
+  intptr_t cid = obj.GetClassId();
+  if (RawObject::IsExternalStringClassId(cid)) {
+    const String& str = String::Cast(obj);
+    *peer = str.GetPeer();
+    ASSERT(*peer != NULL);
+    return Api::Success();
+  }
+  *peer = NULL;
+  if (RawObject::IsStringClassId(cid)) {
+    return Api::NewHandle(isolate, obj.raw());
+  }
+  return Api::NewError("%s expects argument to be of"
+                       " type String.", CURRENT_FUNC);
+}
+
+
 DART_EXPORT void Dart_SetReturnValue(Dart_NativeArguments args,
                                      Dart_Handle retval) {
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
   Isolate* isolate = arguments->isolate();
   CHECK_ISOLATE(isolate);
   if ((retval != Api::Null()) && (!Api::IsInstance(retval))) {
     const Object& ret_obj = Object::Handle(Api::UnwrapHandle(retval));
     FATAL1("Return value check failed: saw '%s' expected a dart Instance.",
            ret_obj.ToCString());
   }
   ASSERT(retval != 0);
   Api::SetReturnValue(arguments, retval);
 }
 
 
+DART_EXPORT void Dart_SetWeakHandleReturnValue(Dart_NativeArguments args,
+                                               Dart_WeakPersistentHandle rval) {
+  NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
+  Isolate* isolate = arguments->isolate();
+  CHECK_ISOLATE(isolate);
+  ASSERT(isolate->api_state() != NULL &&
+         (isolate->api_state()->IsValidWeakPersistentHandle(rval) ||
+          isolate->api_state()->IsValidPrologueWeakPersistentHandle(rval)));
+  Api::SetWeakHandleReturnValue(arguments, rval);
+}
+
+
 DART_EXPORT void Dart_SetBooleanReturnValue(Dart_NativeArguments args,
                                             bool retval) {
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
   arguments->SetReturn(retval ? Bool::True() : Bool::False());
 }
 
 
 DART_EXPORT void Dart_SetIntegerReturnValue(Dart_NativeArguments args,
                                             intptr_t retval) {
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
@@ skipping 490 matching lines @@
   }
   {
     NoGCScope no_gc;
     RawObject* raw_obj = obj.raw();
     isolate->heap()->SetPeer(raw_obj, peer);
   }
   return Api::Success();
 }
 
 }  // namespace dart