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

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 VM_DART_API_IMPL_H_
 #define VM_DART_API_IMPL_H_
 
 #include "vm/allocation.h"
 #include "vm/native_arguments.h"
 #include "vm/object.h"
 
 namespace dart {
 
 DECLARE_FLAG(bool, trace_api);
 
 class ApiLocalScope;
 class ApiState;
 class FinalizablePersistentHandle;
 class LocalHandle;
 class PersistentHandle;
+class ReusableObjectHandleScope;
 
 const char* CanonicalFunction(const char* func);
 
 #define CURRENT_FUNC CanonicalFunction(__FUNCTION__)
 
 #if defined(DEBUG)
 #define TRACE_API_CALL(name)                                                   \
   if (FLAG_trace_api) {                                                        \
     OS::Print("Calling API func: %s\n", name);                                 \
   }
@@ skipping 84 matching lines @@
   static RawObject* UnwrapHandle(Dart_Handle object);
 
   // Unwraps a raw Type from the handle.  The handle will be null if
   // the object was not of the requested Type.
 #define DECLARE_UNWRAP(Type)                                                   \
   static const Type& Unwrap##Type##Handle(Isolate* isolate,                    \
                                           Dart_Handle object);
   CLASS_LIST_FOR_HANDLES(DECLARE_UNWRAP)
 #undef DECLARE_UNWRAP
 
+  // Unwraps the raw object from the handle using a reused handle.
+  static const String& UnwrapStringHandle(
+      const ReusableObjectHandleScope& reused, Dart_Handle object);
+  static const Instance& UnwrapInstanceHandle(
+      const ReusableObjectHandleScope& reused, Dart_Handle object);
+
   // Validates and converts the passed in handle as a persistent handle.
   static PersistentHandle* UnwrapAsPersistentHandle(
       Dart_PersistentHandle object);
 
   // Validates and converts the passed in handle as a weak persistent handle.
   static FinalizablePersistentHandle* UnwrapAsWeakPersistentHandle(
       Dart_WeakPersistentHandle object);
 
   // Validates and converts the passed in handle as a prologue weak
   // persistent handle.
@@ skipping 63 matching lines @@
   // Retrieves the top ApiLocalScope.
   static ApiLocalScope* TopScope(Isolate* isolate);
 
   // Performs one-time initialization needed by the API.
   static void InitOnce();
 
   // Allocates handles for objects in the VM isolate.
   static void InitHandles();
 
   // Helper function to get the peer value of an external string object.
-  static bool StringGetPeerHelper(Dart_NativeArguments args,
+  static bool StringGetPeerHelper(NativeArguments* args,
                                   int arg_index,
                                   void** peer);
 
   // Helper function to get the native field from a native receiver argument.
-  static bool GetNativeReceiver(Dart_NativeArguments args, intptr_t* value);
+  static bool GetNativeReceiver(NativeArguments* args, intptr_t* value);
 
   // Helper function to get the boolean value of a Bool native argument.
-  static bool GetNativeBooleanArgument(Dart_NativeArguments args,
+  static bool GetNativeBooleanArgument(NativeArguments* args,
                                        int arg_index,
                                        bool* value);
 
   // Helper function to set the return value of native functions.
   static void SetReturnValue(NativeArguments* args, Dart_Handle retval) {
     args->SetReturnUnsafe(UnwrapHandle(retval));
   }
   static void SetSmiReturnValue(NativeArguments* args, intptr_t retval) {
     args->SetReturnUnsafe(Smi::New(retval));
   }
@@ skipping 45 matching lines @@
   if (isolate->no_callback_scope_depth() != 0) {                               \
     return reinterpret_cast<Dart_Handle>(Api::AcquiredError(isolate));         \
   }                                                                            \
 
 #define ASSERT_CALLBACK_STATE(isolate)                                         \
   ASSERT(isolate->no_callback_scope_depth() == 0)
 
 }  // namespace dart.
 
 #endif  // VM_DART_API_IMPL_H_