Rename Api::NewLocalHandle -> Api::NewHandle.

runtime/vm/dart_api_impl.cc

 // Copyright (c) 2012, 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 "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/dart.h"
@@ skipping 63 matching lines @@
   const Error& err = Error::Handle(isolate->object_store()->sticky_error());
   const char* errmsg = err.ToErrorCString();
   intptr_t errlen = strlen(errmsg) + 1;
   char* msg = reinterpret_cast<char*>(Api::Allocate(isolate, errlen));
   OS::SNPrint(msg, errlen, "%s", errmsg);
   return msg;
 }
 
 
 void SetupErrorResult(Isolate* isolate, Dart_Handle* handle) {
-  const Error& error = Error::Handle(
+  *handle = Api::NewHandle(
       isolate, Isolate::Current()->object_store()->sticky_error());
-  *handle = Api::NewLocalHandle(isolate, error);
 }
 
 
-Dart_Handle Api::NewLocalHandle(Isolate* isolate, const Object& object) {
+Dart_Handle Api::NewHandle(Isolate* isolate, RawObject* raw) {
   ASSERT(isolate != NULL);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   ApiLocalScope* scope = state->top_scope();
   ASSERT(scope != NULL);
   LocalHandles* local_handles = scope->local_handles();
   ASSERT(local_handles != NULL);
   LocalHandle* ref = local_handles->AllocateHandle();
-  ref->set_raw(object);
+  ref->set_raw(raw);
   return reinterpret_cast<Dart_Handle>(ref);
 }
 
 RawObject* Api::UnwrapHandle(Dart_Handle object) {
 #ifdef DEBUG
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   ASSERT(state->IsValidPrologueWeakPersistentHandle(object) ||
@@ skipping 74 matching lines @@
   intptr_t len = OS::VSNPrint(NULL, 0, format, args);
   va_end(args);
 
   char* buffer = reinterpret_cast<char*>(zone.Allocate(len + 1));
   va_list args2;
   va_start(args2, format);
   OS::VSNPrint(buffer, (len + 1), format, args2);
   va_end(args2);
 
   const String& message = String::Handle(isolate, String::New(buffer));
-  const Object& obj = Object::Handle(isolate, ApiError::New(message));
-  return Api::NewLocalHandle(isolate, obj);
+  return Api::NewHandle(isolate, ApiError::New(message));
 }
 
 
 Dart_Handle Api::Null(Isolate* isolate) {
   ASSERT(isolate != NULL);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   PersistentHandle* null_handle = state->Null();
   return reinterpret_cast<Dart_Handle>(null_handle);
 }
@@ skipping 84 matching lines @@
 }
 
 
 DART_EXPORT Dart_Handle Dart_ErrorGetException(Dart_Handle handle) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(handle));
   if (obj.IsUnhandledException()) {
     UnhandledException& error = UnhandledException::Handle(isolate);
     error ^= obj.raw();
-    const Object& exception = Object::Handle(isolate, error.exception());
-    return Api::NewLocalHandle(isolate, exception);
+    return Api::NewHandle(isolate, error.exception());
   } else if (obj.IsError()) {
     return Api::NewError("This error is not an unhandled exception error.");
   } else {
     return Api::NewError("Can only get exceptions from error handles.");
   }
 }
 
 
 DART_EXPORT Dart_Handle Dart_ErrorGetStacktrace(Dart_Handle handle) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(handle));
   if (obj.IsUnhandledException()) {
     UnhandledException& error = UnhandledException::Handle(isolate);
     error ^= obj.raw();
-    const Object& stacktrace = Object::Handle(isolate, error.stacktrace());
-    return Api::NewLocalHandle(isolate, stacktrace);
+    return Api::NewHandle(isolate, error.stacktrace());
   } else if (obj.IsError()) {
     return Api::NewError("This error is not an unhandled exception error.");
   } else {
     return Api::NewError("Can only get stacktraces from error handles.");
   }
 }
 
 
 // TODO(turnidge): This clones Api::NewError.  I need to use va_copy to
 // fix this but not sure if it available on all of our builds.
 DART_EXPORT Dart_Handle Dart_Error(const char* format, ...) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
 
   va_list args;
   va_start(args, format);
   intptr_t len = OS::VSNPrint(NULL, 0, format, args);
   va_end(args);
 
   char* buffer = reinterpret_cast<char*>(zone.Allocate(len + 1));
   va_list args2;
   va_start(args2, format);
   OS::VSNPrint(buffer, (len + 1), format, args2);
   va_end(args2);
 
   const String& message = String::Handle(isolate, String::New(buffer));
-  const Object& obj = Object::Handle(isolate, ApiError::New(message));
-  return Api::NewLocalHandle(isolate, obj);
+  return Api::NewHandle(isolate, ApiError::New(message));
 }
 
 
 DART_EXPORT Dart_Handle Dart_PropagateError(Dart_Handle handle) {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
   const Object& error = Object::Handle(isolate, Api::UnwrapHandle(handle));
   if (!error.IsError()) {
     return Api::NewError(
         "%s expects argument 'handle' to be an error handle.  "
@@ skipping 24 matching lines @@
   fprintf(stderr, "%s:%d: error handle: '%s':\n    '%s'\n",
           file, line, handle, message);
   OS::Abort();
 }
 
 
 DART_EXPORT Dart_Handle Dart_ToString(Dart_Handle object) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(object));
-  Object& result = Object::Handle(isolate);
   if (obj.IsString()) {
-    result = obj.raw();
+    return Api::NewHandle(isolate, obj.raw());
   } else if (obj.IsInstance()) {
     Instance& receiver = Instance::Handle(isolate);
     receiver ^= obj.raw();
-    result = DartLibraryCalls::ToString(receiver);
+    return Api::NewHandle(isolate, DartLibraryCalls::ToString(receiver));
   } else {
     // This is a VM internal object. Call the C++ method of printing.
-    result = String::New(obj.ToCString());
+    return Api::NewHandle(isolate, String::New(obj.ToCString()));
   }
-  return Api::NewLocalHandle(isolate, result);
 }
 
 
 DART_EXPORT Dart_Handle Dart_IsSame(Dart_Handle obj1, Dart_Handle obj2,
                                     bool* value) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& expected = Object::Handle(isolate, Api::UnwrapHandle(obj1));
   const Object& actual = Object::Handle(isolate, Api::UnwrapHandle(obj2));
   *value = (expected.raw() == actual.raw());
@@ skipping 360 matching lines @@
   CHECK_ISOLATE(isolate);
   isolate->set_message_notify_callback(message_notify_callback);
 }
 
 
 DART_EXPORT Dart_Handle Dart_RunLoop() {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, isolate->StandardRunLoop());
   if (obj.IsError()) {
-    return Api::NewLocalHandle(isolate, obj);
+    return Api::NewHandle(isolate, obj.raw());
   }
   ASSERT(obj.IsNull());
   return Api::Success(isolate);
 }
 
 
 static RawInstance* DeserializeMessage(Isolate* isolate, void* data) {
   // Create a snapshot object using the buffer.
   const Snapshot* snapshot = Snapshot::SetupFromBuffer(data);
   ASSERT(snapshot->IsMessageSnapshot());
@@ skipping 23 matching lines @@
     priority = message->priority();
     if (priority == Message::kOOBPriority) {
       // For now the only OOB messages are Mirrors messages.
       const Object& result = Object::Handle(
           isolate,
           DartLibraryCalls::HandleMirrorsMessage(
               message->dest_port(), message->reply_port(), msg));
       delete message;
       if (result.IsError()) {
         // TODO(turnidge): Propagating the error is probably wrong here.
-        return Api::NewLocalHandle(isolate, result);
+        return Api::NewHandle(isolate, result.raw());
       }
       ASSERT(result.IsNull());
     } else {
       const Object& result = Object::Handle(
           isolate,
           DartLibraryCalls::HandleMessage(
               message->dest_port(), message->reply_port(), msg));
       delete message;
       if (result.IsError()) {
-        return Api::NewLocalHandle(isolate, result);
+        return Api::NewHandle(isolate, result.raw());
       }
       ASSERT(result.IsNull());
     }
   } while (priority >= Message::kOOBPriority);
   return Api::Success(isolate);
 }
 
 
 DART_EXPORT bool Dart_HasLivePorts() {
   Isolate* isolate = Isolate::Current();
@@ skipping 75 matching lines @@
   Isolate::SetCurrent(NULL);
 
   // TODO(turnidge): Check that the port is native before trying to close.
   return PortMap::ClosePort(native_port_id);
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewSendPort(Dart_Port port_id) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
-  const Object& result =
-      Object::Handle(isolate, DartLibraryCalls::NewSendPort(port_id));
-  return Api::NewLocalHandle(isolate, result);
+  return Api::NewHandle(isolate, DartLibraryCalls::NewSendPort(port_id));
 }
 
 
 DART_EXPORT Dart_Handle Dart_GetReceivePort(Dart_Port port_id) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   Library& isolate_lib = Library::Handle(isolate, Library::IsolateLibrary());
   ASSERT(!isolate_lib.IsNull());
   const String& public_class_name =
       String::Handle(isolate, String::New("_ReceivePortImpl"));
   const String& class_name =
       String::Handle(isolate, isolate_lib.PrivateName(public_class_name));
   const String& function_name =
       String::Handle(isolate, String::NewSymbol("_get_or_create"));
   const int kNumArguments = 1;
   const Array& kNoArgumentNames = Array::Handle(isolate);
   const Function& function = Function::Handle(
       isolate,
       Resolver::ResolveStatic(isolate_lib,
                               class_name,
                               function_name,
                               kNumArguments,
                               kNoArgumentNames,
                               Resolver::kIsQualified));
   GrowableArray<const Object*> arguments(kNumArguments);
   arguments.Add(&Integer::Handle(isolate, Integer::New(port_id)));
-  const Object& result = Object::Handle(
+  return Api::NewHandle(
       isolate, DartEntry::InvokeStatic(function, arguments, kNoArgumentNames));
-  return Api::NewLocalHandle(isolate, result);
 }
 
 
 DART_EXPORT Dart_Port Dart_GetMainPortId() {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
   return isolate->main_port();
 }
 
 // --- Scopes ----
@@ skipping 66 matching lines @@
   const Instance& actual =
       Instance::CheckedHandle(isolate, Api::UnwrapHandle(obj2));
   const Object& result =
       Object::Handle(isolate, DartLibraryCalls::Equals(expected, actual));
   if (result.IsBool()) {
     Bool& b = Bool::Handle(isolate);
     b ^= result.raw();
     *value = b.value();
     return Api::Success(isolate);
   } else if (result.IsError()) {
-    return Api::NewLocalHandle(isolate, result);
+    return Api::NewHandle(isolate, result.raw());
   } else {
     return Api::NewError("Expected boolean result from ==");
   }
 }
 
 
 // TODO(iposva): This call actually implements IsInstanceOfClass.
 // Do we also need a real Dart_IsInstanceOf, which should take an instance
 // rather than an object and a type rather than a class?
 DART_EXPORT Dart_Handle Dart_ObjectIsType(Dart_Handle object,
@@ skipping 84 matching lines @@
     bigint ^= int_obj.raw();
     *fits = BigintOperations::FitsIntoUint64(bigint);
   }
   return Api::Success(isolate);
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewInteger(int64_t value) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
-  const Integer& obj = Integer::Handle(isolate, Integer::New(value));
-  return Api::NewLocalHandle(isolate, obj);
+  return Api::NewHandle(isolate, Integer::New(value));
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewIntegerFromHexCString(const char* str) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const String& str_obj = String::Handle(isolate, String::New(str));
-  const Integer& obj = Integer::Handle(isolate, Integer::New(str_obj));
-  return Api::NewLocalHandle(isolate, obj);
+  return Api::NewHandle(isolate, Integer::New(str_obj));
 }
 
 
 DART_EXPORT Dart_Handle Dart_IntegerToInt64(Dart_Handle integer,
                                             int64_t* value) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Integer& int_obj = Api::UnwrapIntegerHandle(isolate, integer);
   if (int_obj.IsNull()) {
     RETURN_TYPE_ERROR(isolate, integer, Integer);
@@ skipping 120 matching lines @@
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(object));
   return obj.IsDouble();
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewDouble(double value) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
-  const Double& obj = Double::Handle(isolate, Double::New(value));
-  return Api::NewLocalHandle(isolate, obj);
+  return Api::NewHandle(isolate, Double::New(value));
 }
 
 
 DART_EXPORT Dart_Handle Dart_DoubleValue(Dart_Handle double_obj,
                                          double* value) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Double& obj = Api::UnwrapDoubleHandle(isolate, double_obj);
   if (obj.IsNull()) {
     RETURN_TYPE_ERROR(isolate, double_obj, Double);
@@ skipping 41 matching lines @@
     *len = string_obj.Length();
     return Api::Success(isolate);
   }
   return Api::NewError("Object is not a String");
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewString(const char* str) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
-  const String& obj = String::Handle(isolate, String::New(str));
-  return Api::NewLocalHandle(isolate, obj);
+  return Api::NewHandle(isolate, String::New(str));
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewString8(const uint8_t* codepoints,
                                         intptr_t length) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
-  const String& obj = String::Handle(isolate, String::New(codepoints, length));
-  return Api::NewLocalHandle(isolate, obj);
+  return Api::NewHandle(isolate, String::New(codepoints, length));
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewString16(const uint16_t* codepoints,
                                          intptr_t length) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
-  const String& obj = String::Handle(isolate, String::New(codepoints, length));
-  return Api::NewLocalHandle(isolate, obj);
+  return Api::NewHandle(isolate, String::New(codepoints, length));
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewString32(const uint32_t* codepoints,
                                          intptr_t length) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
-  const String& obj = String::Handle(isolate, String::New(codepoints, length));
-  return Api::NewLocalHandle(isolate, obj);
+  return Api::NewHandle(isolate, String::New(codepoints, length));
 }
 
 
 DART_EXPORT bool Dart_IsExternalString(Dart_Handle object) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const String& str = Api::UnwrapStringHandle(isolate, object);
   if (str.IsNull()) {
     return false;
   }
@@ skipping 30 matching lines @@
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   if (codepoints == NULL && length != 0) {
     return Api::NewError("%s expects argument 'codepoints' to be non-null.",
                          CURRENT_FUNC);
   }
   if (length < 0) {
     return Api::NewError("%s expects argument 'length' to be greater than 0.",
                          CURRENT_FUNC);
   }
-  const String& obj =
-      String::Handle(isolate,
-                     String::NewExternal(codepoints, length, peer, callback));
-  return Api::NewLocalHandle(isolate, obj);
+  return Api::NewHandle(
+      isolate, String::NewExternal(codepoints, length, peer, callback));
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewExternalString16(const uint16_t* codepoints,
                                                  intptr_t length,
                                                  void* peer,
                                                  Dart_PeerFinalizer callback) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   if (codepoints == NULL && length != 0) {
     return Api::NewError("%s expects argument 'codepoints' to be non-null.",
                          CURRENT_FUNC);
   }
   if (length < 0) {
     return Api::NewError("%s expects argument 'length' to be greater than 0.",
                          CURRENT_FUNC);
   }
-  const String& obj =
-      String::Handle(isolate,
-                     String::NewExternal(codepoints, length, peer, callback));
-  return Api::NewLocalHandle(isolate, obj);
+  return Api::NewHandle(
+      isolate, String::NewExternal(codepoints, length, peer, callback));
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewExternalString32(const uint32_t* codepoints,
                                                  intptr_t length,
                                                  void* peer,
                                                  Dart_PeerFinalizer callback) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   if (codepoints == NULL && length != 0) {
     return Api::NewError("%s expects argument 'codepoints' to be non-null.",
                          CURRENT_FUNC);
   }
   if (length < 0) {
     return Api::NewError("%s expects argument 'length' to be greater than 0.",
                          CURRENT_FUNC);
   }
-  const String& obj =
-      String::Handle(isolate,
-                     String::NewExternal(codepoints, length, peer, callback));
-  return Api::NewLocalHandle(isolate, obj);
+  return Api::NewHandle(
+      isolate, String::NewExternal(codepoints, length, peer, callback));
 }
 
 
 DART_EXPORT Dart_Handle Dart_StringGet8(Dart_Handle str,
                                         uint8_t* codepoints,
                                         intptr_t* length) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(str));
   if (obj.IsString()) {
@@ skipping 110 matching lines @@
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(object));
   // TODO(5526318): Make access to GrowableObjectArray more efficient.
   return (obj.IsArray() ||
           (GetListInstance(isolate, obj) != Instance::null()));
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewList(intptr_t length) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
-  const Array& obj = Array::Handle(isolate, Array::New(length));
-  return Api::NewLocalHandle(isolate, obj);
+  return Api::NewHandle(isolate, Array::New(length));
 }
 
 
 DART_EXPORT Dart_Handle Dart_ListLength(Dart_Handle list, intptr_t* len) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(list));
   if (obj.IsByteArray()) {
     ByteArray& byte_array = ByteArray::Handle(isolate);
     byte_array ^= obj.raw();
@@ skipping 35 matching lines @@
     Bigint& bigint = Bigint::Handle(isolate);
     bigint ^= retval.raw();
     if (BigintOperations::FitsIntoMint(bigint)) {
       *len = BigintOperations::ToMint(bigint);
       return Api::Success(isolate);
     } else {
       return Api::NewError("Length of List object is greater than the "
                            "maximum value that 'len' parameter can hold");
     }
   } else if (retval.IsError()) {
-    return Api::NewLocalHandle(isolate, retval);
+    return Api::NewHandle(isolate, retval.raw());
   } else {
     return Api::NewError("Length of List object is not an integer");
   }
 }
 
 
 DART_EXPORT Dart_Handle Dart_ListGetAt(Dart_Handle list, intptr_t index) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(list));
   if (obj.IsArray()) {
     Array& array_obj = Array::Handle(isolate);
     array_obj ^= obj.raw();
     if ((index >= 0) && (index < array_obj.Length())) {
-      const Object& element = Object::Handle(isolate, array_obj.At(index));
-      return Api::NewLocalHandle(isolate, element);
+      return Api::NewHandle(isolate, array_obj.At(index));
     }
     return Api::NewError("Invalid index passed in to access array element");
   }
   // TODO(5526318): Make access to GrowableObjectArray more efficient.
   // Now check and handle a dart object that implements the List interface.
   const Instance& instance =
       Instance::Handle(isolate, GetListInstance(isolate, obj));
   if (!instance.IsNull()) {
     String& name = String::Handle(isolate, String::New("[]"));
     const Function& function =
         Function::Handle(isolate,
                          Resolver::ResolveDynamic(instance, name, 2, 0));
     if (!function.IsNull()) {
       GrowableArray<const Object*> args(1);
       Integer& indexobj = Integer::Handle(isolate);
       indexobj = Integer::New(index);
       args.Add(&indexobj);
       const Array& kNoArgumentNames = Array::Handle(isolate);
-      const Object& result = Object::Handle(
+      return Api::NewHandle(
           isolate,
           DartEntry::InvokeDynamic(instance, function, args, kNoArgumentNames));
-      return Api::NewLocalHandle(isolate, result);
     }
   }
   return Api::NewError("Object does not implement the 'List' interface");
 }
 
 
 DART_EXPORT Dart_Handle Dart_ListSetAt(Dart_Handle list,
                                        intptr_t index,
                                        Dart_Handle value) {
   Isolate* isolate = Isolate::Current();
@@ skipping 22 matching lines @@
         Function::Handle(isolate,
                          Resolver::ResolveDynamic(instance, name, 3, 0));
     if (!function.IsNull()) {
       const Integer& index_obj = Integer::Handle(isolate, Integer::New(index));
       const Object& value_obj =
           Object::Handle(isolate, Api::UnwrapHandle(value));
       GrowableArray<const Object*> args(2);
       args.Add(&index_obj);
       args.Add(&value_obj);
       const Array& kNoArgumentNames = Array::Handle(isolate);
-      const Object& result = Object::Handle(
+      return Api::NewHandle(
           isolate,
           DartEntry::InvokeDynamic(instance, function, args, kNoArgumentNames));
-      return Api::NewLocalHandle(isolate, result);
     }
   }
   return Api::NewError("Object does not implement the 'List' interface");
 }
 
 
 DART_EXPORT Dart_Handle Dart_ListGetAsBytes(Dart_Handle list,
                                             intptr_t offset,
                                             uint8_t* native_array,
                                             intptr_t length) {
@@ skipping 44 matching lines @@
       Object& result = Object::Handle(isolate);
       Integer& intobj = Integer::Handle(isolate);
       for (int i = 0; i < length; i++) {
         intobj = Integer::New(offset + i);
         GrowableArray<const Object*> args(1);
         args.Add(&intobj);
         const Array& kNoArgumentNames = Array::Handle(isolate);
         result = DartEntry::InvokeDynamic(
             instance, function, args, kNoArgumentNames);
         if (result.IsError()) {
-          return Api::NewLocalHandle(isolate, result);
+          return Api::NewHandle(isolate, result.raw());
         }
         if (!result.IsInteger()) {
           return Api::NewError("%s expects the argument 'list' to be "
                                "a List of int", CURRENT_FUNC);
         }
         intobj ^= result.raw();
         ASSERT(intobj.AsInt64Value() <= 0xff);
         // TODO(hpayer): value should always be smaller then 0xff. Add error
         // handling.
         native_array[i] = static_cast<uint8_t>(intobj.AsInt64Value() & 0xff);
@@ skipping 54 matching lines @@
         valueobj = Integer::New(native_array[i]);
         GrowableArray<const Object*> args(2);
         args.Add(&indexobj);
         args.Add(&valueobj);
         const Array& kNoArgumentNames = Array::Handle(isolate);
         const Object& result = Object::Handle(
             isolate,
             DartEntry::InvokeDynamic(
                 instance, function, args, kNoArgumentNames));
         if (result.IsError()) {
-          return Api::NewLocalHandle(isolate, result);
+          return Api::NewHandle(isolate, result.raw());
         }
       }
       return Api::Success(isolate);
     }
   }
   return Api::NewError("Object does not implement the 'List' interface");
 }
 
 
 // --- Byte Arrays ---
 
 
 DART_EXPORT bool Dart_IsByteArray(Dart_Handle object) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(object));
   return obj.IsByteArray();
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewByteArray(intptr_t length) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
-  const InternalByteArray& obj =
-      InternalByteArray::Handle(isolate, InternalByteArray::New(length));
-  return Api::NewLocalHandle(isolate, obj);
+  return Api::NewHandle(isolate, InternalByteArray::New(length));
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewExternalByteArray(uint8_t* data,
                                                   intptr_t length,
                                                   void* peer,
                                                   Dart_PeerFinalizer callback) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   if (data == NULL && length != 0) {
     return Api::NewError("%s expects argument 'data' to be non-null.",
                          CURRENT_FUNC);
   }
   if (length < 0) {
     return Api::NewError("%s expects argument 'length' to be greater than 0.",
                          CURRENT_FUNC);
   }
-  const ExternalByteArray& obj =
-      ExternalByteArray::Handle(isolate,
-                                ExternalByteArray::New(data,
-                                                       length,
-                                                       peer,
-                                                       callback));
-  return Api::NewLocalHandle(isolate, obj);
+  return Api::NewHandle(
+      isolate, ExternalByteArray::New(data, length, peer, callback));
 }
 
 
 DART_EXPORT Dart_Handle Dart_ExternalByteArrayGetPeer(Dart_Handle object,
                                                       void** peer) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const ExternalByteArray& array =
       Api::UnwrapExternalByteArrayHandle(isolate, object);
   if (array.IsNull()) {
@@ skipping 212 matching lines @@
   // Now try to invoke the closure.
   Closure& closure_obj = Closure::Handle(isolate);
   closure_obj ^= obj.raw();
   GrowableArray<const Object*> dart_arguments(number_of_arguments);
   for (int i = 0; i < number_of_arguments; i++) {
     const Object& arg =
         Object::Handle(isolate, Api::UnwrapHandle(arguments[i]));
     dart_arguments.Add(&arg);
   }
   const Array& kNoArgumentNames = Array::Handle(isolate);
-  const Object& result = Object::Handle(
+  return Api::NewHandle(
       isolate,
       DartEntry::InvokeClosure(closure_obj, dart_arguments, kNoArgumentNames));
-  return Api::NewLocalHandle(isolate, result);
 }
 
 
 DART_EXPORT int64_t Dart_ClosureSmrck(Dart_Handle object) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Closure& obj =
       Closure::CheckedHandle(isolate, Api::UnwrapHandle(object));
   const Integer& smrck = Integer::Handle(isolate, obj.smrck());
   return smrck.IsNull() ? 0 : smrck.AsInt64Value();
@@ skipping 30 matching lines @@
         CURRENT_FUNC);
   }
 
   // Check for malformed arguments in the arguments list.
   GrowableArray<const Object*> dart_args(number_of_arguments);
   for (int i = 0; i < number_of_arguments; i++) {
     const Object& arg =
         Object::Handle(isolate, Api::UnwrapHandle(arguments[i]));
     if (!arg.IsNull() && !arg.IsInstance()) {
       if (arg.IsError()) {
-        return Api::NewLocalHandle(isolate, arg);
+        return Api::NewHandle(isolate, arg.raw());
       } else {
         return Api::NewError(
             "%s expects argument %d to be an instance of Object.",
             CURRENT_FUNC, i);
       }
     }
     dart_args.Add(&arg);
   }
 
   const Array& kNoArgNames = Array::Handle(isolate);
@@ skipping 11 matching lines @@
                                  (number_of_arguments + 1),
                                  Resolver::kIsQualified));
     if (function.IsNull()) {
       const Type& type = Type::Handle(isolate, instance.GetType());
       const String& cls_name = String::Handle(isolate, type.ClassName());
       return Api::NewError("%s: did not find instance method '%s.%s'.",
                            CURRENT_FUNC,
                            cls_name.ToCString(),
                            function_name.ToCString());
     }
-    const Object& result = Object::Handle(
+    return Api::NewHandle(
         isolate,
         DartEntry::InvokeDynamic(instance, function, dart_args, kNoArgNames));
-    return Api::NewLocalHandle(isolate, result);
 
   } else if (obj.IsClass()) {
     // Finalize all classes.
     const char* msg = CheckIsolateState(isolate);
     if (msg != NULL) {
       return Api::NewError(msg);
     }
 
     Class& cls = Class::Handle(isolate);
     cls ^= obj.raw();
     const Function& function = Function::Handle(
         isolate,
         Resolver::ResolveStatic(cls,
                                 function_name,
                                 number_of_arguments,
                                 Array::Handle(isolate),
                                 Resolver::kIsQualified));
     if (function.IsNull()) {
       const String& cls_name = String::Handle(isolate, cls.Name());
       return Api::NewError("%s: did not find static method '%s.%s'.",
                            CURRENT_FUNC,
                            cls_name.ToCString(),
                            function_name.ToCString());
     }
-    const Object& result = Object::Handle(
+    return Api::NewHandle(
         isolate,
         DartEntry::InvokeStatic(function, dart_args, kNoArgNames));
-    return Api::NewLocalHandle(isolate, result);
 
   } else if (obj.IsLibrary()) {
     // Check whether class finalization is needed.
     bool finalize_classes = true;
     Library& lib = Library::Handle(isolate);
     lib ^= obj.raw();
 
     // When calling functions in the dart:builtin library do not finalize as it
     // should have been prefinalized.
     Library& builtin =
@@ skipping 10 matching lines @@
       }
     }
 
     const Function& function =
         Function::Handle(isolate, lib.LookupLocalFunction(function_name));
     if (function.IsNull()) {
       return Api::NewError("%s: did not find top-level function '%s'.",
                            CURRENT_FUNC,
                            function_name.ToCString());
     }
-    const Object& result = Object::Handle(
+    return Api::NewHandle(
         isolate, DartEntry::InvokeStatic(function, dart_args, kNoArgNames));
-    return Api::NewLocalHandle(isolate, result);
 
   } else {
     return Api::NewError(
         "%s expects argument 'target' to be an object, class, or library.",
         CURRENT_FUNC);
   }
 }
 
 
 DART_EXPORT Dart_Handle Dart_InvokeStatic(Dart_Handle library_in,
@@ skipping 59 matching lines @@
     }
     return Api::NewError(msg);
   }
   GrowableArray<const Object*> dart_arguments(number_of_arguments);
   for (int i = 0; i < number_of_arguments; i++) {
     const Object& arg =
         Object::Handle(isolate, Api::UnwrapHandle(arguments[i]));
     dart_arguments.Add(&arg);
   }
   const Array& kNoArgumentNames = Array::Handle(isolate);
-  const Object& result = Object::Handle(
+  return Api::NewHandle(
       isolate,
       DartEntry::InvokeStatic(function, dart_arguments, kNoArgumentNames));
-  return Api::NewLocalHandle(isolate, result);
 }
 
 
 DART_EXPORT Dart_Handle Dart_InvokeDynamic(Dart_Handle object,
                                            Dart_Handle function_name,
                                            int number_of_arguments,
                                            Dart_Handle* arguments) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(object));
@@ skipping 24 matching lines @@
     OS::PrintErr("Unable to find instance function: %s\n", name.ToCString());
     return Api::NewError("Unable to find instance function");
   }
   GrowableArray<const Object*> dart_arguments(number_of_arguments);
   for (int i = 0; i < number_of_arguments; i++) {
     const Object& arg =
         Object::Handle(isolate, Api::UnwrapHandle(arguments[i]));
     dart_arguments.Add(&arg);
   }
   const Array& kNoArgumentNames = Array::Handle(isolate);
-  const Object& result = Object::Handle(
+  return Api::NewHandle(
       isolate,
       DartEntry::InvokeDynamic(
           receiver, function, dart_arguments, kNoArgumentNames));
-  return Api::NewLocalHandle(isolate, result);
 }
 
 
 static const bool kGetter = true;
 static const bool kSetter = false;
 
 
 static bool FieldIsUninitialized(Isolate* isolate, const Field& fld) {
   ASSERT(!fld.IsNull());
 
@@ skipping 22 matching lines @@
   cls ^= param1.raw();
   String& fld_name = String::Handle(isolate);
   fld_name ^= param2.raw();
   const Field& fld = Field::Handle(isolate, cls.LookupStaticField(fld_name));
   if (is_getter && (fld.IsNull() || FieldIsUninitialized(isolate, fld))) {
     const String& func_name =
         String::Handle(isolate, Field::GetterName(fld_name));
     const Function& function =
         Function::Handle(isolate, cls.LookupStaticFunction(func_name));
     if (!function.IsNull()) {
-      return Api::NewLocalHandle(isolate, function);
+      return Api::NewHandle(isolate, function.raw());
     }
     return Api::NewError("Specified field is not found in the class");
   }
   if (fld.IsNull()) {
     return Api::NewError("Specified field is not found in the class");
   }
-  return Api::NewLocalHandle(isolate, fld);
+  return Api::NewHandle(isolate, fld.raw());
 }
 
 
 static Dart_Handle LookupInstanceField(Isolate* isolate,
                                        const Object& object,
                                        Dart_Handle name,
                                        bool is_getter) {
   const Object& param = Object::Handle(isolate, Api::UnwrapHandle(name));
   if (param.IsNull() || !param.IsString()) {
     return Api::NewError("Invalid field name specified");
@@ skipping 10 matching lines @@
         return Api::NewError("Cannot set value of final fields");
       }
       func_name = (is_getter
                    ? Field::GetterName(field_name)
                    : Field::SetterName(field_name));
       const Function& function =
           Function::Handle(isolate, cls.LookupDynamicFunction(func_name));
       if (function.IsNull()) {
         return Api::NewError("Unable to find accessor function in the class");
       }
-      return Api::NewLocalHandle(isolate, function);
+      return Api::NewHandle(isolate, function.raw());
     }
     cls = cls.SuperClass();
   }
   return Api::NewError("Unable to find field '%s'.", field_name.ToCString());
 }
 
 
 DART_EXPORT Dart_Handle Dart_GetField(Dart_Handle container, Dart_Handle name) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
@@ skipping 28 matching lines @@
     }
 
     if (getter.IsNull()) {
       return Api::NewError("%s: did not find instance field '%s'.",
                            CURRENT_FUNC, field_name.ToCString());
     }
 
     // Invoke the getter and return the result.
     GrowableArray<const Object*> args;
     const Array& kNoArgNames = Array::Handle(isolate);
-    const Object& result = Object::Handle(
+    return Api::NewHandle(
         isolate,
         DartEntry::InvokeDynamic(instance, getter, args, kNoArgNames));
-    return Api::NewLocalHandle(isolate, result);
 
   } else if (obj.IsClass()) {
     // To access a static field we may need to use the Field or the
     // getter Function.
     Class& cls = Class::Handle(isolate);
     cls ^= obj.raw();
     field = cls.LookupStaticField(field_name);
     if (field.IsNull() || FieldIsUninitialized(isolate, field)) {
       const String& getter_name =
           String::Handle(isolate, Field::GetterName(field_name));
       getter = cls.LookupStaticFunction(getter_name);
     }
 
     if (!getter.IsNull()) {
       // Invoke the getter and return the result.
       GrowableArray<const Object*> args;
       const Array& kNoArgNames = Array::Handle(isolate);
-      const Object& result = Object::Handle(
+      return Api::NewHandle(
           isolate, DartEntry::InvokeStatic(getter, args, kNoArgNames));
-      return Api::NewLocalHandle(isolate, result);
     } else if (!field.IsNull()) {
-      const Object& result = Object::Handle(isolate, field.value());
-      return Api::NewLocalHandle(isolate, result);
+      return Api::NewHandle(isolate, field.value());
     } else {
       return Api::NewError("%s: did not find static field '%s'.",
                            CURRENT_FUNC, field_name.ToCString());
     }
 
   } else if (obj.IsLibrary()) {
     // To access a top-level we may need to use the Field or the
     // getter Function.  The getter function may either be in the
     // library or in the field's owner class, depending.
     Library& lib = Library::Handle(isolate);
     lib ^= obj.raw();
     field = lib.LookupLocalField(field_name);
     if (field.IsNull()) {
       // No field found.  Check for a getter in the lib.
       const String& getter_name =
           String::Handle(isolate, Field::GetterName(field_name));
       getter = lib.LookupLocalFunction(getter_name);
     } else if (FieldIsUninitialized(isolate, field)) {
       // A field was found.  Check for a getter in the field's owner classs.
       const Class& cls = Class::Handle(isolate, field.owner());
       const String& getter_name =
           String::Handle(isolate, Field::GetterName(field_name));
       getter = cls.LookupStaticFunction(getter_name);
     }
 
     if (!getter.IsNull()) {
       // Invoke the getter and return the result.
       GrowableArray<const Object*> args;
       const Array& kNoArgNames = Array::Handle(isolate);
-      const Object& result = Object::Handle(
+      return Api::NewHandle(
           isolate, DartEntry::InvokeStatic(getter, args, kNoArgNames));
-      return Api::NewLocalHandle(isolate, result);
     } else if (!field.IsNull()) {
-      const Object& result = Object::Handle(isolate, field.value());
-      return Api::NewLocalHandle(isolate, result);
+      return Api::NewHandle(isolate, field.value());
     } else {
       return Api::NewError("%s: did not find top-level variable '%s'.",
                            CURRENT_FUNC, field_name.ToCString());
     }
 
   } else {
     return Api::NewError(
         "%s expects argument 'container' to be an object, class, or library.",
         CURRENT_FUNC);
   }
@@ skipping 49 matching lines @@
 
     if (setter.IsNull()) {
       return Api::NewError("%s: did not find instance field '%s'.",
                            CURRENT_FUNC, field_name.ToCString());
     }
 
     // Invoke the setter and return the result.
     GrowableArray<const Object*> args(1);
     args.Add(&value_instance);
     const Array& kNoArgNames = Array::Handle(isolate);
-    const Object& result = Object::Handle(
+    return Api::NewHandle(
         isolate,
         DartEntry::InvokeDynamic(instance, setter, args, kNoArgNames));
-    return Api::NewLocalHandle(isolate, result);
 
   } else if (obj.IsClass()) {
     // To access a static field we may need to use the Field or the
     // setter Function.
     Class& cls = Class::Handle(isolate);
     cls ^= obj.raw();
     field = cls.LookupStaticField(field_name);
     if (field.IsNull()) {
       String& setter_name =
           String::Handle(isolate, Field::SetterName(field_name));
       setter = cls.LookupStaticFunction(setter_name);
     }
 
     if (!setter.IsNull()) {
       // Invoke the setter and return the result.
       GrowableArray<const Object*> args(1);
       args.Add(&value_instance);
       const Array& kNoArgNames = Array::Handle(isolate);
       const Object& result = Object::Handle(
           isolate,
           DartEntry::InvokeStatic(setter, args, kNoArgNames));
       if (result.IsError()) {
-        return Api::NewLocalHandle(isolate, result);
+        return Api::NewHandle(isolate, result.raw());
       } else {
         return Api::Success(isolate);
       }
     } else if (!field.IsNull()) {
       if (field.is_final()) {
         return Api::NewError("%s: cannot set final field '%s'.",
                              CURRENT_FUNC, field_name.ToCString());
       } else {
         field.set_value(value_instance);
         return Api::Success(isolate);
@@ skipping 17 matching lines @@
     }
 
     if (!setter.IsNull()) {
       // Invoke the setter and return the result.
       GrowableArray<const Object*> args(1);
       args.Add(&value_instance);
       const Array& kNoArgNames = Array::Handle(isolate);
       const Object& result = Object::Handle(
           isolate, DartEntry::InvokeStatic(setter, args, kNoArgNames));
       if (result.IsError()) {
-        return Api::NewLocalHandle(isolate, result);
+        return Api::NewHandle(isolate, result.raw());
       } else {
         return Api::Success(isolate);
       }
     } else if (!field.IsNull()) {
       if (field.is_final()) {
         return Api::NewError("%s: cannot set final top-level variable '%s'.",
                              CURRENT_FUNC, field_name.ToCString());
       } else {
         field.set_value(value_instance);
         return Api::Success(isolate);
@@ skipping 12 matching lines @@
 
 
 DART_EXPORT Dart_Handle Dart_GetStaticField(Dart_Handle cls,
                                             Dart_Handle name) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   Dart_Handle result = LookupStaticField(isolate, cls, name, kGetter);
   if (::Dart_IsError(result)) {
     return result;
   }
-  Object& retval = Object::Handle(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(result));
   if (obj.IsField()) {
     Field& fld = Field::Handle(isolate);
     fld ^= obj.raw();
-    retval = fld.value();
-    return Api::NewLocalHandle(isolate, retval);
+    return Api::NewHandle(isolate, fld.value());
   } else {
     Function& func = Function::Handle(isolate);
     func ^= obj.raw();
     GrowableArray<const Object*> args;
     const Array& kNoArgumentNames = Array::Handle(isolate);
-    const Object& result = Object::Handle(
+    return Api::NewHandle(
         isolate, DartEntry::InvokeStatic(func, args, kNoArgumentNames));
-    return Api::NewLocalHandle(isolate, result);
   }
 }
 
 
 // TODO(iposva): The value parameter should be documented as being an instance.
 // TODO(turnidge): Is this skipping the setter?
 DART_EXPORT Dart_Handle Dart_SetStaticField(Dart_Handle cls,
                                             Dart_Handle name,
                                             Dart_Handle value) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   Dart_Handle result = LookupStaticField(isolate, cls, name, kSetter);
   if (::Dart_IsError(result)) {
     return result;
   }
   Field& fld = Field::Handle(isolate);
   fld ^= Api::UnwrapHandle(result);
   if (fld.is_final()) {
     return Api::NewError(
         "Specified field is a static final field in the class");
   }
   const Object& val = Object::Handle(isolate, Api::UnwrapHandle(value));
   Instance& instance = Instance::Handle(isolate);
   instance ^= val.raw();
   fld.set_value(instance);
-  return Api::NewLocalHandle(isolate, val);
+  return Api::NewHandle(isolate, val.raw());
 }
 
 
 DART_EXPORT Dart_Handle Dart_GetInstanceField(Dart_Handle obj,
                                               Dart_Handle name) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& param = Object::Handle(isolate, Api::UnwrapHandle(obj));
   if (param.IsNull() || !param.IsInstance()) {
     return Api::NewError("Invalid object passed in to access instance field");
   }
   Instance& object = Instance::Handle(isolate);
   object ^= param.raw();
   Dart_Handle result = LookupInstanceField(isolate, object, name, kGetter);
   if (::Dart_IsError(result)) {
     return result;
   }
   Function& func = Function::Handle(isolate);
   func ^= Api::UnwrapHandle(result);
   GrowableArray<const Object*> arguments;
   const Array& kNoArgumentNames = Array::Handle(isolate);
-  const Object& retval = Object::Handle(
+  return Api::NewHandle(
       isolate,
       DartEntry::InvokeDynamic(object, func, arguments, kNoArgumentNames));
-  return Api::NewLocalHandle(isolate, retval);
 }
 
 
 DART_EXPORT Dart_Handle Dart_SetInstanceField(Dart_Handle obj,
                                               Dart_Handle name,
                                               Dart_Handle value) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& param = Object::Handle(isolate, Api::UnwrapHandle(obj));
   if (param.IsNull() || !param.IsInstance()) {
     return Api::NewError("Invalid object passed in to access instance field");
   }
   Instance& object = Instance::Handle(isolate);
   object ^= param.raw();
   Dart_Handle result = LookupInstanceField(isolate, object, name, kSetter);
   if (::Dart_IsError(result)) {
     return result;
   }
   Function& func = Function::Handle(isolate);
   func ^= Api::UnwrapHandle(result);
   GrowableArray<const Object*> arguments(1);
   const Object& arg = Object::Handle(isolate, Api::UnwrapHandle(value));
   arguments.Add(&arg);
   const Array& kNoArgumentNames = Array::Handle(isolate);
-  const Object& retval = Object::Handle(
+  return Api::NewHandle(
       isolate,
       DartEntry::InvokeDynamic(object, func, arguments, kNoArgumentNames));
-  return Api::NewLocalHandle(isolate, retval);
 }
 
 
 DART_EXPORT Dart_Handle Dart_CreateNativeWrapperClass(Dart_Handle library,
                                                       Dart_Handle name,
                                                       int field_count) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& param = Object::Handle(isolate, Api::UnwrapHandle(name));
   if (param.IsNull() || !param.IsString() || field_count <= 0) {
     return Api::NewError(
         "Invalid arguments passed to Dart_CreateNativeWrapperClass");
   }
   String& cls_name = String::Handle(isolate);
   cls_name ^= param.raw();
   cls_name = String::NewSymbol(cls_name);
   Library& lib = Library::Handle(isolate);
   lib ^= Api::UnwrapHandle(library);
   if (lib.IsNull()) {
     return Api::NewError(
         "Invalid arguments passed to Dart_CreateNativeWrapperClass");
   }
   const Class& cls = Class::Handle(
       isolate, Class::NewNativeWrapper(&lib, cls_name, field_count));
   if (cls.IsNull()) {
     return Api::NewError(
         "Unable to create native wrapper class : already exists");
   }
-  return Api::NewLocalHandle(isolate, cls);
+  return Api::NewHandle(isolate, cls.raw());
 }
 
 
 DART_EXPORT Dart_Handle Dart_GetNativeInstanceField(Dart_Handle obj,
                                                     int index,
                                                     intptr_t* value) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& param = Object::Handle(isolate, Api::UnwrapHandle(obj));
   if (param.IsNull() || !param.IsInstance()) {
@@ skipping 84 matching lines @@
 
 DART_EXPORT Dart_Handle Dart_GetNativeArgument(Dart_NativeArguments args,
                                                int index) {
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
   if (index < 0 || index >= arguments->Count()) {
     return Api::NewError(
         "%s: argument 'index' out of range. Expected 0..%d but saw %d.",
         CURRENT_FUNC, arguments->Count() - 1, index);
   }
   Isolate* isolate = arguments->isolate();
-  DARTSCOPE(isolate);
-  const Object& obj = Object::Handle(isolate, arguments->At(index));
-  return Api::NewLocalHandle(isolate, obj);
+  CHECK_ISOLATE(isolate);
+  return Api::NewHandle(isolate, arguments->At(index));
 }
 
 
 DART_EXPORT int Dart_GetNativeArgumentCount(Dart_NativeArguments args) {
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
-  CHECK_ISOLATE(arguments->isolate());
   return arguments->Count();
 }
 
 
 DART_EXPORT void Dart_SetReturnValue(Dart_NativeArguments args,
                                      Dart_Handle retval) {
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
   Isolate* isolate = arguments->isolate();
   DARTSCOPE(isolate);
   arguments->SetReturn(Object::Handle(isolate, Api::UnwrapHandle(retval)));
@@ skipping 15 matching lines @@
   bool update_lib_status = (kind == RawScript::kScript ||
                             kind == RawScript::kLibrary);
   if (update_lib_status) {
     lib.SetLoadInProgress();
   }
   const Script& script =
       Script::Handle(isolate, Script::New(url, source, kind));
   ASSERT(isolate != NULL);
   const Error& error = Error::Handle(isolate, Compiler::Compile(lib, script));
   if (error.IsNull()) {
-    *result = Api::NewLocalHandle(isolate, lib);
+    *result = Api::NewHandle(isolate, lib.raw());
     if (update_lib_status) {
       lib.SetLoaded();
     }
   } else {
-    *result = Api::NewLocalHandle(isolate, error);
+    *result = Api::NewHandle(isolate, error.raw());
     if (update_lib_status) {
       lib.SetLoadError();
     }
   }
 }
 
 
 DART_EXPORT Dart_Handle Dart_LoadScript(Dart_Handle url,
                                         Dart_Handle source,
                                         Dart_LibraryTagHandler handler,
@@ skipping 58 matching lines @@
                          CURRENT_FUNC, library_url.ToCString());
   }
   SnapshotReader reader(snapshot, isolate);
   const Object& tmp = Object::Handle(isolate, reader.ReadObject());
   if (!tmp.IsLibrary()) {
     return Api::NewError("%s: Unable to deserialize snapshot correctly.",
                          CURRENT_FUNC);
   }
   library ^= tmp.raw();
   isolate->object_store()->set_root_library(library);
-  return Api::NewLocalHandle(isolate, library);
+  return Api::NewHandle(isolate, library.raw());
 }
 
 
 static void CompileAll(Isolate* isolate, Dart_Handle* result) {
   ASSERT(isolate != NULL);
   const Error& error = Error::Handle(isolate, Library::CompileAll());
   if (error.IsNull()) {
     *result = Api::Success(isolate);
   } else {
-    *result = Api::NewLocalHandle(isolate, error);
+    *result = Api::NewHandle(isolate, error.raw());
   }
 }
 
 
 DART_EXPORT Dart_Handle Dart_CompileAll() {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   Dart_Handle result;
   const char* msg = CheckIsolateState(isolate);
   if (msg != NULL) {
@@ skipping 25 matching lines @@
     return Api::NewError("Invalid parameter, Unknown library specified");
   }
   String& cls_name = String::Handle(isolate);
   cls_name ^= param.raw();
   const Class& cls = Class::Handle(isolate, lib.LookupClass(cls_name));
   if (cls.IsNull()) {
     const String& lib_name = String::Handle(isolate, lib.name());
     return Api::NewError("Class '%s' not found in library '%s'.",
                          cls_name.ToCString(), lib_name.ToCString());
   }
-  return Api::NewLocalHandle(isolate, cls);
+  return Api::NewHandle(isolate, cls.raw());
 }
 
 
 DART_EXPORT Dart_Handle Dart_LibraryUrl(Dart_Handle library) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Library& lib = Api::UnwrapLibraryHandle(isolate, library);
   if (lib.IsNull()) {
     RETURN_TYPE_ERROR(isolate, library, Library);
   }
   const String& url = String::Handle(isolate, lib.url());
   ASSERT(!url.IsNull());
-  return Api::NewLocalHandle(isolate, url);
+  return Api::NewHandle(isolate, url.raw());
 }
 
 
 DART_EXPORT Dart_Handle Dart_LookupLibrary(Dart_Handle url) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const String& url_str = Api::UnwrapStringHandle(isolate, url);
   if (url_str.IsNull()) {
     RETURN_TYPE_ERROR(isolate, url, String);
   }
   const Library& library =
       Library::Handle(isolate, Library::LookupLibrary(url_str));
   if (library.IsNull()) {
     return Api::NewError("%s: library '%s' not found.",
                          CURRENT_FUNC, url_str.ToCString());
   } else {
-    return Api::NewLocalHandle(isolate, library);
+    return Api::NewHandle(isolate, library.raw());
   }
 }
 
 
 DART_EXPORT Dart_Handle Dart_LoadLibrary(Dart_Handle url,
                                          Dart_Handle source,
                                          Dart_Handle import_map) {
   TIMERSCOPE(time_script_loading);
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
@@ skipping 125 matching lines @@
       *buffer = NULL;
     }
     delete debug_region;
   } else {
     *buffer = NULL;
     *buffer_size = 0;
   }
 }
 
 }  // namespace dart